def test_linux(args):
adapter = LinuxAdapter()
test_result = Result(message='')
coverage_result = Result(message='')
try:
if args.rebuild or exist_gcov_data_in_linux() or args.coverage:
adapter.distclean()
if not args.skip_build:
adapter.testbinary(with_coverage=args.coverage)
if '/' in args.group or '\\' in args.group:
args.group = os.path.basename(args.group)
test_result = LinuxAdapter().test(verbose=args.verbose,
group=args.group,
name=args.name,
repeat=args.repeat)
if args.coverage:
coverage_result = LinuxAdapter().coverage_lcov()
except RT_OCFError as e:
test_result = Result(exitcode=e.exitcode, message=e.message)
coverage_result = Result(exitcode=e.exitcode, message=e.message)
finally:
if args.is_ci:
write_result(CI_LINUX_TEST_FILE_NAME, test_result.message)
if args.coverage:
write_result(CI_LINUX_COVERAGE_FILE_NAME,
coverage_result.message)
return test_result
def run(args):
adapter = LinuxAdapter()
if not args.skip_build:
adapter.distclean()
adapter.build()
result = Result()
leak_message = LEAK_FAIL_MESSAGE
peak_message = PEAK_FAIL_MESSAGE
try:
leak_dic = {}
peak_dic = {}
for binary in FUNCTIONAL_TESTS:
filename = os.path.basename(binary)
execute('rm -rf massif.out.*')
execute_output = execute_return_output('python {}'.format(binary))
leak_dic[filename] = LeakCalculator().calculate(
execute_output.data)
massif_output = execute_return_output('ms_print massif.out.*')
peak_dic[filename] = PeakCalculator().calculate(massif_output.data)
leak_total = 0
peak_max = Peak()
for filename in leak_dic:
print(
'#############################################################'
)
print('-- {} --'.format(filename))
print(' Memory leak')
print(' {} bytes'.format(leak_dic[filename]))
print(' Memory peak')
print(' {}'.format(str(peak_dic[filename])))
print(
'#############################################################'
)
leak_total += leak_dic[filename]
if peak_dic[filename] > peak_max:
peak_max = peak_dic[filename]
leak_message = 'Memory Leak: {} bytes'.format(str(leak_total))
peak_message = 'Memory Peak: {}'.format(str(peak_max))
except RT_OCFError as e:
peak_message = PEAK_FAIL_MESSAGE
leak_message = LEAK_FAIL_MESSAGE
result = Result(exitcode=e.exitcode, message=e.message)
finally:
if args.is_ci:
write_result(CI_LINUX_LEAK_FILE_NAME, leak_message)
write_result(CI_LINUX_PEAK_FILE_NAME, peak_message)
print("Result::")
print(leak_message)
print(peak_message)
exit(result.exitcode)
def build_linux(args):
result = Result(message='Successfully finished..')
try:
adapter = LinuxAdapter()
if args.rebuild:
adapter.distclean()
adapter.build()
except RT_OCFError as e:
result = Result(exitcode=e.exitcode, message=e.message)
finally:
if args.is_ci:
write_result(CI_LINUX_BUILD_FILE_NAME, result.message)
return result
def read_serial_output(self):
while True:
line = self.serial.readline()
if line == '':
print('Timeout')
return Result(exitcode=1,
message='timeout: Core Dump may occur')
sys.stdout.write(line)
if self.is_test_result(line):
return Result(
exitcode=self.get_test_exitcode(line),
message=line)
if self.is_core_dump(line):
return Result(exitcode=1, message=line)
def build_tizenrt(args):
result = Result(message='Successfully finished..')
try:
adapter = TizenRTAdapter(config=args.config)
if args.rebuild:
adapter.distclean()
adapter.reconfig()
adapter.build()
if args.with_flash:
adapter.flash_binary()
except RT_OCFError as e:
result = Result(exitcode=e.exitcode, message=e.message)
finally:
if args.is_ci:
write_result(CI_TIZENRT_BUILD_FILE_NAME, result.message)
return result
def run_peak(is_ci):
try:
result = PeakCalculator().calculate(FUNCTIONAL_TESTS)
except RT_OCFError as e:
result = Result(exitcode=e.exitcode, message=e.message)
finally:
if args.is_ci:
write_result(CI_LINUX_PEAK_FILE_NAME, result.message)
return result
def test_tizenrt(args):
result = Result(message='')
try:
adapter = TizenRTAdapter(config='artik053/zeroroot_unittest')
if args.rebuild:
adapter.reconfig()
adapter.distclean()
adapter.reconfig()
print('!!!' + args.group)
if not args.skip_build:
adapter.build()
if '/' in args.group or '\\' in args.group:
args.group = os.path.basename(args.group)
result = adapter.test(verbose=args.verbose,
group=args.group,
name=args.name,
repeat=args.repeat)
except RT_OCFError as e:
result = Result(exitcode=e.exitcode, message=e.message)
finally:
if args.is_ci:
write_result(CI_TIZENRT_TEST_FILE_NAME, result.message)
return result
def execute(self, file_list, show_warning):
warning_count = {'error': 0, 'warning': 0}
for filepath in file_list:
if not filepath.endswith('.c') and not filepath.endswith('.h'):
continue
each_result = self.execute_lint(filepath, show_warning)
warning_count['error'] += each_result['error']
warning_count['warning'] += each_result['warning']
report = 'error: {}, warning: {}'.format(warning_count['error'],
warning_count['warning'])
exitcode = 0
if warning_count['error'] > 0:
exitcode = 1
print_fail('Catch you!!! You did not take code style seriously.')
return Result(message=report, exitcode=exitcode)