"""
Copyright (c) 2021 Huawei Device Co., Ltd.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Description: Use ark to execute ts/js files
"""
import os
import sys
import re
import glob
import argparse
import subprocess
import signal
import time
import json
DEFAULT_TIMEOUT = 300
DEFAULT_PGO_THRESHOLD = 10
TARGET_PLATFORM = ['x64', 'arm64']
PRODUCT_LIST = ['hispark_taurus', 'rk3568', 'baltimore']
TARGET_PRODUCT_MAP = {'x64': 0, 'arm64': 1}
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('name', metavar='file|path', type=str, help='test case name: file or path')
parser.add_argument('-a', '--all', action='store_true', help='run all test cases on path')
parser.add_argument('-p', '--product', metavar='name',
help='product name, default is hispark_taurus on x64, rk3568 on arm64, baltimore on arm64')
parser.add_argument('-t', '--tool', metavar='opt',
help='run tool supported opt: aot, int(c interpreter tool), asmint(asm interpreter tool), node(v8), qjs, hermes')
parser.add_argument('-f', '--frontend', metavar='opt',
help='run frontend supported opt: ts2abc (slow), es2abc (quick not released)')
parser.add_argument('-s', '--step', metavar='opt',
help='run step supported opt: abc, pack, aot, aotd, run, rund, asmint, asmintd, int, intd')
parser.add_argument('-d', '--debug', action='store_true', help='run on debug mode')
parser.add_argument('--arm64', action='store_true', help='run on arm64 platform')
parser.add_argument('--device', action='store_true', help='run on device')
parser.add_argument('--copy-path', metavar='path', help='copy bins to device')
parser.add_argument('-m', '--module', action='store_true', help='frontend compile with module')
parser.add_argument('--frontend-args', metavar='args', help='pass to frontend args')
parser.add_argument('--aot-args', metavar='args', help='pass to aot compiler args')
parser.add_argument('--jsvm-args', metavar='args', help='pass to jsvm args')
parser.add_argument('-i', '--info', action='store_true', help='add log level of info to args')
parser.add_argument('-c', '--clean', action='store_true', help='clean output files')
parser.add_argument('--npm', action='store_true', help='npm install')
parser.add_argument('--bt', dest='builtin', action='store_true', help='aot compile with lib_ark_builtins.d.ts')
parser.add_argument('--pgo', action='store_true',
help=f'aot compile with pgo, default threshold is {DEFAULT_PGO_THRESHOLD}')
parser.add_argument('--pgo-th', metavar='n', default=DEFAULT_PGO_THRESHOLD, type=int,
help=f'pgo hotness threshold, default is {DEFAULT_PGO_THRESHOLD}')
parser.add_argument('--sign', metavar='name',
help='sign level, default is system_core, other is normal, system_basic')
parser.add_argument('--timeout', metavar='n', default=DEFAULT_TIMEOUT, type=int,
help=f'specify seconds of test timeout, default is {DEFAULT_TIMEOUT}')
parser.add_argument('-e', '--env', action='store_true', help='print LD_LIBRARY_PATH')
arguments = parser.parse_args()
return arguments
def run_and_print(cmd):
print(cmd)
os.system(cmd)
def run_command(cmd, timeout=DEFAULT_TIMEOUT):
proc = subprocess.Popen(cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE, shell=True)
code_format = 'UTF-8'
try:
(msg, errs) = proc.communicate(timeout=timeout)
ret_code = proc.poll()
if errs:
ret_code = 2
except subprocess.TimeoutExpired:
proc.kill()
proc.terminate()
os.kill(proc.pid, signal.SIGTERM)
return (1, '', f'exec command timeout {timeout}s')
return (ret_code, msg.decode(code_format), errs.decode(code_format))
def match_list_name(list, name):
for str in list:
found = str.find(name)
if (found == 0):
return str
return ''
def get_module_name(hap_dir):
with open(f'{hap_dir}/module.json') as f:
data = json.load(f)
if len(data):
return data['module']['name']
else:
return 'entry'
def get_bundle_name(hap_dir):
with open(f'{hap_dir}/module.json') as f:
data = json.load(f)
if len(data):
return data['app']['bundleName']
else:
return 'entry'
class ArkTest():
def __init__(self, args):
self.args = args
self.self_dir = os.path.abspath(sys.argv[0])
self.hap_abc = 'ets/modules.abc'
self.place_dir = 'arkcompiler/ets_runtime/test'
if not args.device and self.self_dir.find(self.place_dir) < 0:
print(f'pls place this script at: {self.place_dir}')
sys.exit(1)
self.ohdir = os.path.abspath(f'{self.self_dir}/../../../..')
self.product = PRODUCT_LIST[TARGET_PRODUCT_MAP['x64']]
self.builtin = ''
self.arm64 = False
if args.step == 'hap':
self.arm64 = True
if args.arm64:
self.product = PRODUCT_LIST[TARGET_PRODUCT_MAP['arm64']]
self.arm64 = True
if args.product:
self.product = match_list_name(PRODUCT_LIST, args.product)
self.step = 'all'
if args.step:
self.step = args.step
if args.clean:
self.step = 'clean'
self.expect = 'expect_output.txt'
search_type_list = ['.ts', '.js', '.abc']
self.types = {'all': ['.ts', '.js'],
'abc': ['.ts', '.js'],
'pack': ['.an'],
'aot': search_type_list,
'aotd': search_type_list,
'run': search_type_list,
'rund': search_type_list,
'asmint': search_type_list,
'asmintd': search_type_list,
'int': search_type_list,
'intd': search_type_list,
'clean': search_type_list}
product_dir = f'{self.ohdir}/out/{self.product}'
libs_dir_x64_release = (f'{self.ohdir}/prebuilts/clang/ohos/linux-x86_64/llvm/lib:'
f'{product_dir}/clang_x64/arkcompiler/ets_runtime:'
f'{product_dir}/clang_x64/thirdparty/icu:'
f'{product_dir}/clang_x64/thirdparty/zlib')
libs_dir_x64_debug = (f'{self.ohdir}/prebuilts/clang/ohos/linux-x86_64/llvm/lib:'
f'{product_dir}/clang_x64/exe.unstripped/clang_x64/arkcompiler/ets_runtime:'
f'{product_dir}/clang_x64/lib.unstripped/clang_x64/arkcompiler/ets_runtime:'
f'{product_dir}/clang_x64/lib.unstripped/clang_x64/test/test:'
f'{product_dir}/clang_x64/lib.unstripped/clang_x64/thirdparty/icu:'
f'{product_dir}/clang_x64/lib.unstripped/clang_x64/thirdparty/zlib')
libs_dir_arm64_release = (f'{self.ohdir}/prebuilts/clang/ohos/linux-x86_64/llvm/lib/aarch64-linux-ohos/c++/:'
f'{product_dir}/arkcompiler/ets_runtime/:'
f'{product_dir}/utils/utils_base/:'
f'{product_dir}/thirdparty/icu:'
f'{product_dir}/thirdparty/zlib:'
f'{product_dir}/common/dsoftbus/:'
f'{product_dir}/commonlibrary/c_utils:'
f'{product_dir}/systemabilitymgr/samgr:'
f'{product_dir}/hiviewdfx/hisysevent_native:'
f'{product_dir}/common/common:'
f'{product_dir}/securec/thirdparty_bounds_checking_function:'
f'{product_dir}/hiviewdfx/faultloggerd:'
f'{product_dir}/thirdparty/bounds_checking_function:'
f'{product_dir}/hiviewdfx/hilog_native:'
f'{product_dir}/startup/init:'
f'{product_dir}/thirdparty/cjson:'
f'{product_dir}/lib.unstripped/common/dsoftbus:'
f'{product_dir}/security/selinux:'
f'{product_dir}/hiviewdfx/hitrace_native/:'
f'{product_dir}/communication/ipc/:'
f'{product_dir}/distributedschedule/samgr_standard:'
f'{product_dir}/security/access_token:'
f'{product_dir}/communication/dsoftbus:'
f'{product_dir}/startup/startup_l2/:'
f'{product_dir}/security/huks/:'
f'{product_dir}/clang_x64/thirdparty/icu:'
f'{product_dir}/clang_x64/thirdparty/zlib:'
f'{product_dir}/clang_x64/arkcompiler/ets_runtime')
libs_dir_arm64_debug = (f'{self.ohdir}/prebuilts/clang/ohos/linux-x86_64/llvm/lib/aarch64-linux-ohos/c++/:'
f'{product_dir}/lib.unstripped/arkcompiler/ets_runtime/:'
f'{product_dir}/utils/utils_base/:'
f'{product_dir}/thirdparty/icu:'
f'{product_dir}/thirdparty/zlib:'
f'{product_dir}/common/dsoftbus/:'
f'{product_dir}/commonlibrary/c_utils:'
f'{product_dir}/systemabilitymgr/samgr:'
f'{product_dir}/hiviewdfx/hisysevent_native:'
f'{product_dir}/common/common:'
f'{product_dir}/securec/thirdparty_bounds_checking_function:'
f'{product_dir}/hiviewdfx/faultloggerd:'
f'{product_dir}/thirdparty/bounds_checking_function:'
f'{product_dir}/hiviewdfx/hilog_native:'
f'{product_dir}/startup/init:'
f'{product_dir}/thirdparty/cjson:'
f'{product_dir}/security/selinux:'
f'{product_dir}/hiviewdfx/hitrace_native/:'
f'{product_dir}/communication/ipc/:'
f'{product_dir}/distributedschedule/samgr_standard:'
f'{product_dir}/security/access_token:'
f'{product_dir}/communication/dsoftbus:'
f'{product_dir}/startup/startup_l2/:'
f'{product_dir}/security/huks/:'
f'{product_dir}/clang_x64/thirdparty/icu/:'
f'{product_dir}/clang_x64/thirdparty/zlib/:'
f'{product_dir}/clang_x64/arkcompiler/ets_runtime')
libs_dir = [[libs_dir_x64_release, libs_dir_x64_debug], [libs_dir_arm64_release, libs_dir_arm64_debug]]
bins_dir = [['clang_x64/arkcompiler', 'clang_x64/exe.unstripped/clang_x64/arkcompiler'],
['arkcompiler', 'exe.unstripped/arkcompiler']]
icu_arg = f'--icu-data-path={self.ohdir}/third_party/icu/ohos_icu4j/data'
self.libs_dir = libs_dir[self.arm64][args.debug]
self.compiler = f'{product_dir}/{bins_dir[0][args.debug]}/ets_runtime/ark_aot_compiler'
self.jsvm = f'{product_dir}/{bins_dir[self.arm64][args.debug]}/ets_runtime/ark_js_vm'
self.ts2abc = f'node --expose-gc {product_dir}/clang_x64/arkcompiler/ets_frontend/build/src/index.js'
self.es2abc = f'{product_dir}/clang_x64/arkcompiler/ets_frontend/es2abc'
self.frontend = self.ts2abc
if not args.frontend:
args.frontend = 'ts2abc'
if args.frontend not in ['ts2abc', 'es2abc']:
print(f'not supported frontend: {args.frontend}')
sys.exit(1)
if args.frontend == 'es2abc':
self.frontend = self.es2abc
abcmode = {'ts2abc': ['--merge-abc', '--merge-abc -m'],
'es2abc': ['--merge-abc', '--merge-abc --module']}
self.abcmode = abcmode[args.frontend][args.module]
self.frontend_args = ''
self.aot_args = ''
self.jsvm_args = icu_arg
if args.device:
self.jsvm_args = ''
if self.builtin:
self.aot_args = f'{self.aot_args} --builtins-dts={self.builtin}.abc'
self.pgo = False
if args.pgo:
self.pgo = True
self.aot_args = (f'{self.aot_args} --enable-pgo-profiler=true --compiler-pgo-hotness-threshold={args.pgo_th}'
f' --compiler-pgo-profiler-path=pgo_file_name.ap')
if args.frontend_args:
self.frontend_args = f'{self.frontend_args} {args.frontend_args}'
if args.aot_args:
self.aot_args = f'{self.aot_args} {args.aot_args}'
if args.jsvm_args:
self.jsvm_args = f'{self.jsvm_args} {args.jsvm_args}'
if args.info:
self.aot_args = f'{self.aot_args} --log-level=info'
self.jsvm_args = f'{self.jsvm_args} --log-level=info'
self.runner = ''
self.runnerd = 'gdb --args'
if self.arm64 or args.device:
if self.step[:3] != 'aot':
self.runner = 'qemu-aarch64'
self.runnerd = 'qemu-aarch64 -cpu max,sve=off -g 123456'
self.aot_args = f'{self.aot_args} --compiler-target-triple=aarch64-unknown-linux-gnu'
self.test_count = 0
self.fail_cases = []
os.environ['LD_LIBRARY_PATH'] = self.libs_dir
if args.env:
print(f'export LD_LIBRARY_PATH={self.libs_dir}')
sys.exit(0)
if args.copy_path:
run_and_print(f'hdc shell mount -o remount,rw /')
run_and_print(f'hdc file send {args.copy_path}\\ark_aot_compiler /system/bin/')
run_and_print(f'hdc shell chmod a+x /system/bin/ark_aot_compiler')
run_and_print(f'hdc file send {args.copy_path}\\ark_js_vm /system/bin/')
run_and_print(f'hdc shell chmod a+x /system/bin/ark_js_vm')
sys.exit(0)
if args.npm:
index_dir = f'{product_dir}/clang_x64/arkcompiler/ets_frontend/build/src'
os.system(f'cd {index_dir}/.. && npm install')
sys.exit(0)
if args.sign:
self.sign_hap(self.args.name)
sys.exit(0)
def run_cmd(self, cmd):
print(cmd)
ret = run_command(cmd, self.args.timeout)
if ret[0]:
print(ret[2])
return ret
def run_test(self, file):
self.test_count += 1
basename = os.path.basename(f'{file}')
type = os.path.splitext(basename)[-1]
name = os.path.splitext(basename)[0]
dir = os.path.dirname(file)
out_case_dir = f'{dir}'
hap_dir = 'null'
hap_name = 'null'
module_name = 'null'
if self.step == 'hap' or self.step == 'pack':
hap_dir = os.path.abspath(f'{out_case_dir}/..')
hap_name = os.path.basename(hap_dir)
module_name = get_module_name(hap_dir)
abc_file = f'{os.path.splitext(file)[0]}.abc'
if self.pgo:
pgo_file = f'{hap_dir}/ap/{module_name}'
self.aot_args = self.aot_args.replace('pgo_file_name', pgo_file)
cmd_map = {
'node': f'node {self.frontend_args} {file}',
'qjs': f'qjs {self.frontend_args} {file}',
'hermes': f'hermes {self.frontend_args} {file}',
'abc': f'{self.frontend} {self.frontend_args} {self.abcmode} --output {abc_file} {file}',
'pack': [f'mkdir -p {out_case_dir}/../an/arm64-v8a',
f'mv {out_case_dir}/{name}.an {hap_dir}/an/arm64-v8a/{module_name}.an',
f'mv {out_case_dir}/{name}.ai {hap_dir}/an/arm64-v8a/{module_name}.ai',
f'cd {out_case_dir}/.. && rm -f ../{hap_name}.hap && zip -r -q ../{hap_name}.hap *',
f'mv {hap_dir}/an/arm64-v8a/{module_name}.an {out_case_dir}/{name}.an',
f'mv {hap_dir}/an/arm64-v8a/{module_name}.ai {out_case_dir}/{name}.ai',
f'rm -rf {hap_dir}/an'],
'aot': f'{self.compiler} {self.aot_args} --aot-file={out_case_dir}/{name} {abc_file}',
'aotd': f'{self.runnerd} {self.compiler} {self.aot_args} --aot-file={out_case_dir}/{name} {abc_file}',
'run': f'{self.runner} {self.jsvm} {self.jsvm_args} --aot-file={out_case_dir}/{name} --entry-point={name} {abc_file}',
'rund': f'{self.runnerd} {self.jsvm} {self.jsvm_args} --aot-file={out_case_dir}/{name} --entry-point={name} {abc_file}',
'asmint': f'{self.runner} {self.jsvm} {self.jsvm_args} --entry-point={name} {abc_file}',
'asmintd': f'{self.runnerd} {self.jsvm} {self.jsvm_args} --entry-point={name} {abc_file}',
'int': f'{self.runner} {self.jsvm} {self.jsvm_args} --asm-interpreter=0 --entry-point={name} {abc_file}',
'intd': f'{self.runnerd} {self.jsvm} {self.jsvm_args} --asm-interpreter=0 --entry-point={name} {abc_file}',
'clean': f'rm -f {out_case_dir}/{name}.abc {out_case_dir}/{name}.an {out_case_dir}/{name}.ai',
'cleanhap': f'rm -rf {hap_dir}/an {out_case_dir}/{name}.an {out_case_dir}/{name}.ai'}
if self.builtin:
if self.frontend == self.ts2abc:
cmd = f'{self.ts2abc} {self.builtin}.ts -m --merge-abc -q -b'
elif self.frontend == self.es2abc:
cmd = (f'{self.es2abc} --module --merge-abc --extension=ts '
f'--output={self.builtin}.abc {self.builtin}.ts')
print(cmd)
os.system(cmd)
if self.step == 'hap':
self.step = 'aot'
perf_start = time.perf_counter()
cmd = cmd_map[self.step]
print(cmd)
os.system(cmd)
perf_end = time.perf_counter()
abc_size = os.path.getsize(file) / 1024 / 1024
an_size = os.path.getsize(f'{out_case_dir}/{name}.an') / 1024 / 1024
print(f'test: {file} abc_size: {abc_size: .1f}MB an_size: {an_size:.1f}MB '
f'expand: {an_size / abc_size: .1f} time: {perf_end - perf_start: .1f}s')
self.step = 'pack'
if self.step == 'pack':
for cmd in cmd_map[self.step]:
print(cmd)
os.system(cmd)
print(f'packed hap: {hap_name}.hap')
print(f'sign --------------------------------------------')
self.sign_hap(f'{hap_name}.hap')
return
if self.step == 'clean':
if os.path.isfile(f'{hap_dir}/{self.hap_abc}'):
self.step = 'cleanhap'
if self.args.tool == 'node':
ret = self.run_cmd(cmd_map['node'])
self.judge_test(file, ret)
return
if self.args.tool == 'qjs':
ret = self.run_cmd(cmd_map['qjs'])
self.judge_test(file, ret)
return
if self.args.tool == 'hermes':
ret = self.run_cmd(cmd_map['hermes'])
self.judge_test(file, ret)
return
if not self.args.tool:
self.args.tool = 'aot'
if self.args.tool not in ['aot', 'asmint', 'int']:
print(f'not supported tool: {self.args.tool}')
sys.exit(1)
if self.args.device:
ret = self.run_test_on_device(file)
return
if self.step != 'all':
cmd = cmd_map[self.step]
print(cmd)
if self.arm64 and self.step[-1:] == 'd' and self.step[:3] != 'aot':
print(f'gdb-client start: gdb-multiarch {self.jsvm}')
print(f'gdb-server connect: target remote:123456')
os.system(cmd)
return
ret = self.run_cmd(cmd_map['abc'])
if ret[0]:
self.judge_test(file, ret)
return
if self.args.tool == 'aot':
ret = self.run_cmd(cmd_map['aot'])
if ret[0] and ret[2].find('aot compile success') < 0:
self.judge_test(file, ret)
return
ret = self.run_cmd(cmd_map['run'])
else:
ret = self.run_cmd(cmd_map[self.args.tool])
self.judge_test(file, ret)
def run_test_on_device(self, file):
basename = os.path.basename(f'{file}')
name = os.path.splitext(basename)[0]
out_case_dir = '/data/test'
send_abc_file = f'{os.path.splitext(file)[0]}.abc'.replace('/', '\\')
abc_file = f'{out_case_dir}/{name}.abc'
cmd_map = {'abc': f'hdc file send {send_abc_file} {out_case_dir}/',
'aot': f'hdc shell ark_aot_compiler {self.aot_args} --aot-file={out_case_dir}/{name} {abc_file}',
'run': f'hdc shell ark_js_vm {self.jsvm_args} --aot-file={out_case_dir}/{name} --entry-point={name} {abc_file}',
'asmint': f'hdc shell ark_js_vm {self.jsvm_args} --entry-point={name} {abc_file}',
'int': f'hdc shell ark_js_vm {self.jsvm_args} --asm-interpreter=0 --entry-point={name} {abc_file}'}
if self.step != 'all':
run_and_print(cmd_map[self.step])
return
run_and_print(cmd_map['abc'])
if self.args.tool == 'aot':
ret = self.run_cmd(cmd_map['aot'])
if ret[0] and ret[2].find('aot compile success') < 0:
self.judge_test(file, ret)
return
ret = self.run_cmd(cmd_map['run'])
else:
ret = self.run_cmd(cmd_map[self.args.tool])
self.judge_test(file, ret)
def judge_test(self, file, out):
if out[0]:
self.fail_cases.append(file)
print_fail(f'FAIL: {file}')
return
expect_file = f'{os.path.dirname(file)}/{self.expect}'
if os.path.exists(expect_file):
with open(expect_file, mode='r') as infile:
expect = ''.join(infile.readlines()[13:])
if out[1].replace('\r', '') != expect.replace('\r', ''):
self.fail_cases.append(file)
print(f'expect: [{expect}]\nbut got: [{out[1]}]')
print_fail(f'FAIL: {file}')
else:
print_pass(f'PASS: {file}')
else:
print_pass(f'PASS: {file}')
print(out[1])
def report_test(self):
fail_count = len(self.fail_cases)
print(f'Ran tests: {self.test_count}')
print(f'Ran failed: {fail_count}')
if fail_count == 0:
print_pass('================================== All tests Run PASSED!')
return
print_fail('==================================')
for case in self.fail_cases:
print(case)
print_fail('==================================')
def find_file(self, dir, postfix_list):
result = []
for root, lists, files in os.walk(dir):
for file in files:
for postfix in postfix_list:
path = os.path.join(root, file)
found = path.find(postfix)
if found == len(path) - len(postfix):
result.append(path)
if os.path.isfile(dir):
for postfix in postfix_list:
found = dir.find(postfix)
if found == len(dir) - len(postfix):
result.append(dir)
break
return result
def test_hap(self):
if self.step != 'all':
return 1
files = self.find_file(self.args.name, [self.hap_abc, '.hap'])
if len(files):
self.step = 'hap'
file = files[0]
type = os.path.splitext(file)[-1]
if type == '.hap':
hap_dir = f'{os.path.splitext(file)[0]}.aot'
os.system(f'mkdir -p {hap_dir} && unzip -o -q {file} -d {hap_dir}')
file = f'{hap_dir}/{self.hap_abc}'
self.run_test(file)
return 0
return 1
def sign_hap(self, hap_name):
name = os.path.splitext(hap_name)[0]
sign_dir = f'{name}.sign'
sign_tool_dir = f'{self.ohdir}/developtools/hapsigner/dist'
name = os.path.splitext(sign_dir)[0]
self_dir = os.path.abspath(sys.argv[0])
os.system(f'mkdir -p {sign_dir} && unzip -o -q {hap_name} module.json -d {sign_dir}')
bundle_name = get_bundle_name(sign_dir)
if not self.args.sign or self.args.sign == 'system_core':
bundle_apl = 'system_core'
bundle_feature = 'hos_system_app'
elif self.args.sign == 'system_basic':
bundle_apl = self.args.sign
bundle_feature = 'hos_system_app'
elif self.args.sign == 'normal':
bundle_apl = self.args.sign
bundle_feature = 'hos_normal_app'
else:
print(f'sign not supported input: {self.args.sign}')
return 1
data_load = []
data_save = []
sign_config = 'UnsgnedReleasedProfileTemplate.json'
with open(f'{sign_tool_dir}/{sign_config}') as f:
data_load = json.load(f)
data_load['bundle-info']['bundle-name'] = bundle_name
data_load['bundle-info']['apl'] = bundle_apl
data_load['bundle-info']['app-feature'] = bundle_feature
data_save = json.dumps(data_load)
with open(f'{sign_dir}/{sign_config}', 'w+') as f:
f.write(data_save)
gen_cert = f'java -jar {sign_tool_dir}/hap-sign-tool.jar sign-profile -keyAlias "openharmony application profile release" -signAlg "SHA256withECDSA" -mode "localSign" -profileCertFile "{sign_tool_dir}/OpenHarmonyProfileRelease.pem" -inFile "{sign_dir}/{sign_config}" -keystoreFile "{sign_tool_dir}/OpenHarmony.p12" -outFile "{sign_dir}/openharmony.p7b" -keyPwd "123456" -keystorePwd "123456"'
sign_hap = f'java -jar {sign_tool_dir}/hap-sign-tool.jar sign-app -keyAlias "openharmony application release" -signAlg "SHA256withECDSA" -mode "localSign" -appCertFile "{sign_tool_dir}/OpenHarmonyApplication.pem" -profileFile "{sign_dir}/openharmony.p7b" -inFile "{hap_name}" -keystoreFile "{sign_tool_dir}/OpenHarmony.p12" -outFile "{name}.sign.hap" -keyPwd "123456" -keystorePwd "123456"'
print(gen_cert)
print(sign_hap)
os.system(gen_cert)
os.system(sign_hap)
print(f'signed of {bundle_apl} for hap: {name}.sign.hap')
def test(self):
files = []
if self.step not in self.types:
print(f'not supported step: {self.step}')
return 1
if not self.args.all:
files = self.find_file(self.args.name, self.types[self.step])
if len(files):
self.run_test(files[0])
elif self.test_hap():
print(f'only support file type: {self.types[self.step]}')
print(f'input path no test case: {self.args.name}')
return 1
return 0
if not os.path.isdir(self.args.name):
print(f'input path not exists or is file: {self.args.name}')
return 1
files = self.find_file(self.args.name, self.types[self.step])
for test in files:
self.run_test(test)
if len(files) == 0:
self.test_hap()
if self.step == 'clean':
print('clean output files finished')
return 0
if self.test_count == 0:
print(f'input path no test case: {self.args.name}')
return 1
self.report_test()
return 0
def print_pass(str):
print(f'\033[32;2m{str}\033[0m')
sys.stdout.flush()
def print_fail(str):
print(f'\033[31;2m{str}\033[0m')
sys.stdout.flush()
def main():
args = parse_args()
arktest = ArkTest(args)
return arktest.test()
if __name__ == '__main__':
sys.exit(main())
