[mirror_ubuntu-hirsute-kernel.git] / tools / testing / kunit / kunit_tool_test.py

#!/usr/bin/python3
# SPDX-License-Identifier: GPL-2.0
#
# A collection of tests for tools/testing/kunit/kunit.py
#
# Copyright (C) 2019, Google LLC.
# Author: Brendan Higgins <brendanhiggins@google.com>

import unittest
from unittest import mock

import tempfile, shutil # Handling test_tmpdir

import os

import kunit_config
import kunit_parser
import kunit_kernel
import kunit

test_tmpdir = ''

def setUpModule():
	global test_tmpdir
	test_tmpdir = tempfile.mkdtemp()

def tearDownModule():
	shutil.rmtree(test_tmpdir)

def get_absolute_path(path):
	return os.path.join(os.path.dirname(__file__), path)

class KconfigTest(unittest.TestCase):

	def test_is_subset_of(self):
		kconfig0 = kunit_config.Kconfig()
		self.assertTrue(kconfig0.is_subset_of(kconfig0))

		kconfig1 = kunit_config.Kconfig()
		kconfig1.add_entry(kunit_config.KconfigEntry('TEST', 'y'))
		self.assertTrue(kconfig1.is_subset_of(kconfig1))
		self.assertTrue(kconfig0.is_subset_of(kconfig1))
		self.assertFalse(kconfig1.is_subset_of(kconfig0))

	def test_read_from_file(self):
		kconfig = kunit_config.Kconfig()
		kconfig_path = get_absolute_path(
			'test_data/test_read_from_file.kconfig')

		kconfig.read_from_file(kconfig_path)

		expected_kconfig = kunit_config.Kconfig()
		expected_kconfig.add_entry(
			kunit_config.KconfigEntry('UML', 'y'))
		expected_kconfig.add_entry(
			kunit_config.KconfigEntry('MMU', 'y'))
		expected_kconfig.add_entry(
			kunit_config.KconfigEntry('TEST', 'y'))
		expected_kconfig.add_entry(
			kunit_config.KconfigEntry('EXAMPLE_TEST', 'y'))
		expected_kconfig.add_entry(
			kunit_config.KconfigEntry('MK8', 'n'))

		self.assertEqual(kconfig.entries(), expected_kconfig.entries())

	def test_write_to_file(self):
		kconfig_path = os.path.join(test_tmpdir, '.config')

		expected_kconfig = kunit_config.Kconfig()
		expected_kconfig.add_entry(
			kunit_config.KconfigEntry('UML', 'y'))
		expected_kconfig.add_entry(
			kunit_config.KconfigEntry('MMU', 'y'))
		expected_kconfig.add_entry(
			kunit_config.KconfigEntry('TEST', 'y'))
		expected_kconfig.add_entry(
			kunit_config.KconfigEntry('EXAMPLE_TEST', 'y'))
		expected_kconfig.add_entry(
			kunit_config.KconfigEntry('MK8', 'n'))

		expected_kconfig.write_to_file(kconfig_path)

		actual_kconfig = kunit_config.Kconfig()
		actual_kconfig.read_from_file(kconfig_path)

		self.assertEqual(actual_kconfig.entries(),
				 expected_kconfig.entries())

class KUnitParserTest(unittest.TestCase):

	def assertContains(self, needle, haystack):
		for line in haystack:
			if needle in line:
				return
		raise AssertionError('"' +
			str(needle) + '" not found in "' + str(haystack) + '"!')

	def test_output_isolated_correctly(self):
		log_path = get_absolute_path(
			'test_data/test_output_isolated_correctly.log')
		file = open(log_path)
		result = kunit_parser.isolate_kunit_output(file.readlines())
		self.assertContains('TAP version 14\n', result)
		self.assertContains('	# Subtest: example', result)
		self.assertContains('	1..2', result)
		self.assertContains('	ok 1 - example_simple_test', result)
		self.assertContains('	ok 2 - example_mock_test', result)
		self.assertContains('ok 1 - example', result)
		file.close()

	def test_output_with_prefix_isolated_correctly(self):
		log_path = get_absolute_path(
			'test_data/test_pound_sign.log')
		with open(log_path) as file:
			result = kunit_parser.isolate_kunit_output(file.readlines())
		self.assertContains('TAP version 14\n', result)
		self.assertContains('	# Subtest: kunit-resource-test', result)
		self.assertContains('	1..5', result)
		self.assertContains('	ok 1 - kunit_resource_test_init_resources', result)
		self.assertContains('	ok 2 - kunit_resource_test_alloc_resource', result)
		self.assertContains('	ok 3 - kunit_resource_test_destroy_resource', result)
		self.assertContains(' foo bar 	#', result)
		self.assertContains('	ok 4 - kunit_resource_test_cleanup_resources', result)
		self.assertContains('	ok 5 - kunit_resource_test_proper_free_ordering', result)
		self.assertContains('ok 1 - kunit-resource-test', result)
		self.assertContains(' foo bar 	# non-kunit output', result)
		self.assertContains('	# Subtest: kunit-try-catch-test', result)
		self.assertContains('	1..2', result)
		self.assertContains('	ok 1 - kunit_test_try_catch_successful_try_no_catch',
				    result)
		self.assertContains('	ok 2 - kunit_test_try_catch_unsuccessful_try_does_catch',
				    result)
		self.assertContains('ok 2 - kunit-try-catch-test', result)
		self.assertContains('	# Subtest: string-stream-test', result)
		self.assertContains('	1..3', result)
		self.assertContains('	ok 1 - string_stream_test_empty_on_creation', result)
		self.assertContains('	ok 2 - string_stream_test_not_empty_after_add', result)
		self.assertContains('	ok 3 - string_stream_test_get_string', result)
		self.assertContains('ok 3 - string-stream-test', result)

	def test_parse_successful_test_log(self):
		all_passed_log = get_absolute_path(
			'test_data/test_is_test_passed-all_passed.log')
		file = open(all_passed_log)
		result = kunit_parser.parse_run_tests(file.readlines())
		self.assertEqual(
			kunit_parser.TestStatus.SUCCESS,
			result.status)
		file.close()

	def test_parse_failed_test_log(self):
		failed_log = get_absolute_path(
			'test_data/test_is_test_passed-failure.log')
		file = open(failed_log)
		result = kunit_parser.parse_run_tests(file.readlines())
		self.assertEqual(
			kunit_parser.TestStatus.FAILURE,
			result.status)
		file.close()

	def test_no_tests(self):
		empty_log = get_absolute_path(
			'test_data/test_is_test_passed-no_tests_run.log')
		file = open(empty_log)
		result = kunit_parser.parse_run_tests(
			kunit_parser.isolate_kunit_output(file.readlines()))
		self.assertEqual(0, len(result.suites))
		self.assertEqual(
			kunit_parser.TestStatus.NO_TESTS,
			result.status)
		file.close()

	def test_no_kunit_output(self):
		crash_log = get_absolute_path(
			'test_data/test_insufficient_memory.log')
		file = open(crash_log)
		print_mock = mock.patch('builtins.print').start()
		result = kunit_parser.parse_run_tests(
			kunit_parser.isolate_kunit_output(file.readlines()))
		print_mock.assert_any_call(StrContains("no kunit output detected"))
		print_mock.stop()
		file.close()

	def test_crashed_test(self):
		crashed_log = get_absolute_path(
			'test_data/test_is_test_passed-crash.log')
		file = open(crashed_log)
		result = kunit_parser.parse_run_tests(file.readlines())
		self.assertEqual(
			kunit_parser.TestStatus.TEST_CRASHED,
			result.status)
		file.close()

	def test_ignores_prefix_printk_time(self):
		prefix_log = get_absolute_path(
			'test_data/test_config_printk_time.log')
		with open(prefix_log) as file:
			result = kunit_parser.parse_run_tests(file.readlines())
		self.assertEqual('kunit-resource-test', result.suites[0].name)

	def test_ignores_multiple_prefixes(self):
		prefix_log = get_absolute_path(
			'test_data/test_multiple_prefixes.log')
		with open(prefix_log) as file:
			result = kunit_parser.parse_run_tests(file.readlines())
		self.assertEqual('kunit-resource-test', result.suites[0].name)

	def test_prefix_mixed_kernel_output(self):
		mixed_prefix_log = get_absolute_path(
			'test_data/test_interrupted_tap_output.log')
		with open(mixed_prefix_log) as file:
			result = kunit_parser.parse_run_tests(file.readlines())
		self.assertEqual('kunit-resource-test', result.suites[0].name)

	def test_prefix_poundsign(self):
		pound_log = get_absolute_path('test_data/test_pound_sign.log')
		with open(pound_log) as file:
			result = kunit_parser.parse_run_tests(file.readlines())
		self.assertEqual('kunit-resource-test', result.suites[0].name)

	def test_kernel_panic_end(self):
		panic_log = get_absolute_path('test_data/test_kernel_panic_interrupt.log')
		with open(panic_log) as file:
			result = kunit_parser.parse_run_tests(file.readlines())
		self.assertEqual('kunit-resource-test', result.suites[0].name)

	def test_pound_no_prefix(self):
		pound_log = get_absolute_path('test_data/test_pound_no_prefix.log')
		with open(pound_log) as file:
			result = kunit_parser.parse_run_tests(file.readlines())
		self.assertEqual('kunit-resource-test', result.suites[0].name)

class StrContains(str):
	def __eq__(self, other):
		return self in other

class KUnitMainTest(unittest.TestCase):
	def setUp(self):
		path = get_absolute_path('test_data/test_is_test_passed-all_passed.log')
		file = open(path)
		all_passed_log = file.readlines()
		self.print_patch = mock.patch('builtins.print')
		self.print_mock = self.print_patch.start()
		self.linux_source_mock = mock.Mock()
		self.linux_source_mock.build_reconfig = mock.Mock(return_value=True)
		self.linux_source_mock.build_um_kernel = mock.Mock(return_value=True)
		self.linux_source_mock.run_kernel = mock.Mock(return_value=all_passed_log)

	def tearDown(self):
		self.print_patch.stop()
		pass

	def test_config_passes_args_pass(self):
		kunit.main(['config'], self.linux_source_mock)
		assert self.linux_source_mock.build_reconfig.call_count == 1
		assert self.linux_source_mock.run_kernel.call_count == 0

	def test_build_passes_args_pass(self):
		kunit.main(['build'], self.linux_source_mock)
		assert self.linux_source_mock.build_reconfig.call_count == 0
		self.linux_source_mock.build_um_kernel.assert_called_once_with(False, 8, '', None)
		assert self.linux_source_mock.run_kernel.call_count == 0

	def test_exec_passes_args_pass(self):
		kunit.main(['exec'], self.linux_source_mock)
		assert self.linux_source_mock.build_reconfig.call_count == 0
		assert self.linux_source_mock.run_kernel.call_count == 1
		self.linux_source_mock.run_kernel.assert_called_once_with(build_dir='', timeout=300)
		self.print_mock.assert_any_call(StrContains('Testing complete.'))

	def test_run_passes_args_pass(self):
		kunit.main(['run'], self.linux_source_mock)
		assert self.linux_source_mock.build_reconfig.call_count == 1
		assert self.linux_source_mock.run_kernel.call_count == 1
		self.linux_source_mock.run_kernel.assert_called_once_with(
			build_dir='', timeout=300)
		self.print_mock.assert_any_call(StrContains('Testing complete.'))

	def test_exec_passes_args_fail(self):
		self.linux_source_mock.run_kernel = mock.Mock(return_value=[])
		with self.assertRaises(SystemExit) as e:
			kunit.main(['exec'], self.linux_source_mock)
		assert type(e.exception) == SystemExit
		assert e.exception.code == 1

	def test_run_passes_args_fail(self):
		self.linux_source_mock.run_kernel = mock.Mock(return_value=[])
		with self.assertRaises(SystemExit) as e:
			kunit.main(['run'], self.linux_source_mock)
		assert type(e.exception) == SystemExit
		assert e.exception.code == 1
		assert self.linux_source_mock.build_reconfig.call_count == 1
		assert self.linux_source_mock.run_kernel.call_count == 1
		self.print_mock.assert_any_call(StrContains(' 0 tests run'))

	def test_exec_raw_output(self):
		self.linux_source_mock.run_kernel = mock.Mock(return_value=[])
		kunit.main(['exec', '--raw_output'], self.linux_source_mock)
		assert self.linux_source_mock.run_kernel.call_count == 1
		for kall in self.print_mock.call_args_list:
			assert kall != mock.call(StrContains('Testing complete.'))
			assert kall != mock.call(StrContains(' 0 tests run'))

	def test_run_raw_output(self):
		self.linux_source_mock.run_kernel = mock.Mock(return_value=[])
		kunit.main(['run', '--raw_output'], self.linux_source_mock)
		assert self.linux_source_mock.build_reconfig.call_count == 1
		assert self.linux_source_mock.run_kernel.call_count == 1
		for kall in self.print_mock.call_args_list:
			assert kall != mock.call(StrContains('Testing complete.'))
			assert kall != mock.call(StrContains(' 0 tests run'))

	def test_exec_timeout(self):
		timeout = 3453
		kunit.main(['exec', '--timeout', str(timeout)], self.linux_source_mock)
		self.linux_source_mock.run_kernel.assert_called_once_with(build_dir='', timeout=timeout)
		self.print_mock.assert_any_call(StrContains('Testing complete.'))

	def test_run_timeout(self):
		timeout = 3453
		kunit.main(['run', '--timeout', str(timeout)], self.linux_source_mock)
		assert self.linux_source_mock.build_reconfig.call_count == 1
		self.linux_source_mock.run_kernel.assert_called_once_with(
			build_dir='', timeout=timeout)
		self.print_mock.assert_any_call(StrContains('Testing complete.'))

	def test_run_builddir(self):
		build_dir = '.kunit'
		kunit.main(['run', '--build_dir', build_dir], self.linux_source_mock)
		assert self.linux_source_mock.build_reconfig.call_count == 1
		self.linux_source_mock.run_kernel.assert_called_once_with(
			build_dir=build_dir, timeout=300)
		self.print_mock.assert_any_call(StrContains('Testing complete.'))

	def test_config_builddir(self):
		build_dir = '.kunit'
		kunit.main(['config', '--build_dir', build_dir], self.linux_source_mock)
		assert self.linux_source_mock.build_reconfig.call_count == 1

	def test_build_builddir(self):
		build_dir = '.kunit'
		kunit.main(['build', '--build_dir', build_dir], self.linux_source_mock)
		self.linux_source_mock.build_um_kernel.assert_called_once_with(False, 8, build_dir, None)

	def test_exec_builddir(self):
		build_dir = '.kunit'
		kunit.main(['exec', '--build_dir', build_dir], self.linux_source_mock)
		self.linux_source_mock.run_kernel.assert_called_once_with(build_dir=build_dir, timeout=300)
		self.print_mock.assert_any_call(StrContains('Testing complete.'))

if __name__ == '__main__':
	unittest.main()
Commit	Line	Data
6ebf5866 FG	1	#!/usr/bin/python3
	2	# SPDX-License-Identifier: GPL-2.0
	3	#
	4	# A collection of tests for tools/testing/kunit/kunit.py
	5	#
	6	# Copyright (C) 2019, Google LLC.
	7	# Author: Brendan Higgins <brendanhiggins@google.com>
	8
	9	import unittest
	10	from unittest import mock
	11
	12	import tempfile, shutil # Handling test_tmpdir
	13
	14	import os
	15
	16	import kunit_config
	17	import kunit_parser
	18	import kunit_kernel
	19	import kunit
	20
	21	test_tmpdir = ''
	22
	23	def setUpModule():
	24	global test_tmpdir
	25	test_tmpdir = tempfile.mkdtemp()
	26
	27	def tearDownModule():
	28	shutil.rmtree(test_tmpdir)
	29
	30	def get_absolute_path(path):
	31	return os.path.join(os.path.dirname(__file__), path)
	32
	33	class KconfigTest(unittest.TestCase):
	34
	35	def test_is_subset_of(self):
	36	kconfig0 = kunit_config.Kconfig()
	37	self.assertTrue(kconfig0.is_subset_of(kconfig0))
	38
	39	kconfig1 = kunit_config.Kconfig()
97752c39	40	kconfig1.add_entry(kunit_config.KconfigEntry('TEST', 'y'))
6ebf5866 FG	41	self.assertTrue(kconfig1.is_subset_of(kconfig1))
	42	self.assertTrue(kconfig0.is_subset_of(kconfig1))
	43	self.assertFalse(kconfig1.is_subset_of(kconfig0))
	44
	45	def test_read_from_file(self):
	46	kconfig = kunit_config.Kconfig()
	47	kconfig_path = get_absolute_path(
	48	'test_data/test_read_from_file.kconfig')
	49
	50	kconfig.read_from_file(kconfig_path)
	51
	52	expected_kconfig = kunit_config.Kconfig()
	53	expected_kconfig.add_entry(
97752c39	54	kunit_config.KconfigEntry('UML', 'y'))
6ebf5866	55	expected_kconfig.add_entry(
97752c39	56	kunit_config.KconfigEntry('MMU', 'y'))
6ebf5866	57	expected_kconfig.add_entry(
97752c39	58	kunit_config.KconfigEntry('TEST', 'y'))
6ebf5866	59	expected_kconfig.add_entry(
97752c39	60	kunit_config.KconfigEntry('EXAMPLE_TEST', 'y'))
6ebf5866	61	expected_kconfig.add_entry(
97752c39	62	kunit_config.KconfigEntry('MK8', 'n'))
6ebf5866 FG	63
	64	self.assertEqual(kconfig.entries(), expected_kconfig.entries())
	65
	66	def test_write_to_file(self):
	67	kconfig_path = os.path.join(test_tmpdir, '.config')
	68
	69	expected_kconfig = kunit_config.Kconfig()
	70	expected_kconfig.add_entry(
97752c39	71	kunit_config.KconfigEntry('UML', 'y'))
6ebf5866	72	expected_kconfig.add_entry(
97752c39	73	kunit_config.KconfigEntry('MMU', 'y'))
6ebf5866	74	expected_kconfig.add_entry(
97752c39	75	kunit_config.KconfigEntry('TEST', 'y'))
6ebf5866	76	expected_kconfig.add_entry(
97752c39	77	kunit_config.KconfigEntry('EXAMPLE_TEST', 'y'))
6ebf5866	78	expected_kconfig.add_entry(
97752c39	79	kunit_config.KconfigEntry('MK8', 'n'))
6ebf5866 FG	80
	81	expected_kconfig.write_to_file(kconfig_path)
	82
	83	actual_kconfig = kunit_config.Kconfig()
	84	actual_kconfig.read_from_file(kconfig_path)
	85
	86	self.assertEqual(actual_kconfig.entries(),
	87	expected_kconfig.entries())
	88
	89	class KUnitParserTest(unittest.TestCase):
	90
	91	def assertContains(self, needle, haystack):
	92	for line in haystack:
	93	if needle in line:
	94	return
	95	raise AssertionError('"' +
	96	str(needle) + '" not found in "' + str(haystack) + '"!')
	97
	98	def test_output_isolated_correctly(self):
	99	log_path = get_absolute_path(
	100	'test_data/test_output_isolated_correctly.log')
	101	file = open(log_path)
	102	result = kunit_parser.isolate_kunit_output(file.readlines())
	103	self.assertContains('TAP version 14\n', result)
	104	self.assertContains(' # Subtest: example', result)
	105	self.assertContains(' 1..2', result)
	106	self.assertContains(' ok 1 - example_simple_test', result)
	107	self.assertContains(' ok 2 - example_mock_test', result)
	108	self.assertContains('ok 1 - example', result)
	109	file.close()
	110
afc63da6 HF	111	def test_output_with_prefix_isolated_correctly(self):
	112	log_path = get_absolute_path(
	113	'test_data/test_pound_sign.log')
	114	with open(log_path) as file:
	115	result = kunit_parser.isolate_kunit_output(file.readlines())
	116	self.assertContains('TAP version 14\n', result)
	117	self.assertContains(' # Subtest: kunit-resource-test', result)
	118	self.assertContains(' 1..5', result)
	119	self.assertContains(' ok 1 - kunit_resource_test_init_resources', result)
	120	self.assertContains(' ok 2 - kunit_resource_test_alloc_resource', result)
	121	self.assertContains(' ok 3 - kunit_resource_test_destroy_resource', result)
	122	self.assertContains(' foo bar #', result)
	123	self.assertContains(' ok 4 - kunit_resource_test_cleanup_resources', result)
	124	self.assertContains(' ok 5 - kunit_resource_test_proper_free_ordering', result)
	125	self.assertContains('ok 1 - kunit-resource-test', result)
	126	self.assertContains(' foo bar # non-kunit output', result)
	127	self.assertContains(' # Subtest: kunit-try-catch-test', result)
	128	self.assertContains(' 1..2', result)
	129	self.assertContains(' ok 1 - kunit_test_try_catch_successful_try_no_catch',
	130	result)
	131	self.assertContains(' ok 2 - kunit_test_try_catch_unsuccessful_try_does_catch',
	132	result)
	133	self.assertContains('ok 2 - kunit-try-catch-test', result)
	134	self.assertContains(' # Subtest: string-stream-test', result)
	135	self.assertContains(' 1..3', result)
	136	self.assertContains(' ok 1 - string_stream_test_empty_on_creation', result)
	137	self.assertContains(' ok 2 - string_stream_test_not_empty_after_add', result)
	138	self.assertContains(' ok 3 - string_stream_test_get_string', result)
	139	self.assertContains('ok 3 - string-stream-test', result)
	140
6ebf5866 FG	141	def test_parse_successful_test_log(self):
	142	all_passed_log = get_absolute_path(
	143	'test_data/test_is_test_passed-all_passed.log')
	144	file = open(all_passed_log)
	145	result = kunit_parser.parse_run_tests(file.readlines())
	146	self.assertEqual(
	147	kunit_parser.TestStatus.SUCCESS,
	148	result.status)
	149	file.close()
	150
	151	def test_parse_failed_test_log(self):
	152	failed_log = get_absolute_path(
	153	'test_data/test_is_test_passed-failure.log')
	154	file = open(failed_log)
	155	result = kunit_parser.parse_run_tests(file.readlines())
	156	self.assertEqual(
	157	kunit_parser.TestStatus.FAILURE,
	158	result.status)
	159	file.close()
	160
	161	def test_no_tests(self):
	162	empty_log = get_absolute_path(
	163	'test_data/test_is_test_passed-no_tests_run.log')
	164	file = open(empty_log)
	165	result = kunit_parser.parse_run_tests(
	166	kunit_parser.isolate_kunit_output(file.readlines()))
	167	self.assertEqual(0, len(result.suites))
	168	self.assertEqual(
	169	kunit_parser.TestStatus.NO_TESTS,
	170	result.status)
	171	file.close()
	172
e173b8b8 UG	173	def test_no_kunit_output(self):
	174	crash_log = get_absolute_path(
	175	'test_data/test_insufficient_memory.log')
	176	file = open(crash_log)
	177	print_mock = mock.patch('builtins.print').start()
	178	result = kunit_parser.parse_run_tests(
	179	kunit_parser.isolate_kunit_output(file.readlines()))
	180	print_mock.assert_any_call(StrContains("no kunit output detected"))
	181	print_mock.stop()
	182	file.close()
	183
6ebf5866 FG	184	def test_crashed_test(self):
	185	crashed_log = get_absolute_path(
	186	'test_data/test_is_test_passed-crash.log')
	187	file = open(crashed_log)
	188	result = kunit_parser.parse_run_tests(file.readlines())
	189	self.assertEqual(
	190	kunit_parser.TestStatus.TEST_CRASHED,
	191	result.status)
	192	file.close()
	193
afc63da6 HF	194	def test_ignores_prefix_printk_time(self):
	195	prefix_log = get_absolute_path(
	196	'test_data/test_config_printk_time.log')
	197	with open(prefix_log) as file:
	198	result = kunit_parser.parse_run_tests(file.readlines())
	199	self.assertEqual('kunit-resource-test', result.suites[0].name)
	200
	201	def test_ignores_multiple_prefixes(self):
	202	prefix_log = get_absolute_path(
	203	'test_data/test_multiple_prefixes.log')
	204	with open(prefix_log) as file:
	205	result = kunit_parser.parse_run_tests(file.readlines())
	206	self.assertEqual('kunit-resource-test', result.suites[0].name)
	207
	208	def test_prefix_mixed_kernel_output(self):
	209	mixed_prefix_log = get_absolute_path(
	210	'test_data/test_interrupted_tap_output.log')
	211	with open(mixed_prefix_log) as file:
	212	result = kunit_parser.parse_run_tests(file.readlines())
	213	self.assertEqual('kunit-resource-test', result.suites[0].name)
	214
	215	def test_prefix_poundsign(self):
	216	pound_log = get_absolute_path('test_data/test_pound_sign.log')
	217	with open(pound_log) as file:
	218	result = kunit_parser.parse_run_tests(file.readlines())
	219	self.assertEqual('kunit-resource-test', result.suites[0].name)
	220
	221	def test_kernel_panic_end(self):
	222	panic_log = get_absolute_path('test_data/test_kernel_panic_interrupt.log')
	223	with open(panic_log) as file:
	224	result = kunit_parser.parse_run_tests(file.readlines())
	225	self.assertEqual('kunit-resource-test', result.suites[0].name)
	226
	227	def test_pound_no_prefix(self):
	228	pound_log = get_absolute_path('test_data/test_pound_no_prefix.log')
	229	with open(pound_log) as file:
	230	result = kunit_parser.parse_run_tests(file.readlines())
	231	self.assertEqual('kunit-resource-test', result.suites[0].name)
	232
6ebf5866 FG	233	class StrContains(str):
	234	def __eq__(self, other):
	235	return self in other
	236
	237	class KUnitMainTest(unittest.TestCase):
	238	def setUp(self):
	239	path = get_absolute_path('test_data/test_is_test_passed-all_passed.log')
	240	file = open(path)
	241	all_passed_log = file.readlines()
	242	self.print_patch = mock.patch('builtins.print')
	243	self.print_mock = self.print_patch.start()
	244	self.linux_source_mock = mock.Mock()
	245	self.linux_source_mock.build_reconfig = mock.Mock(return_value=True)
	246	self.linux_source_mock.build_um_kernel = mock.Mock(return_value=True)
	247	self.linux_source_mock.run_kernel = mock.Mock(return_value=all_passed_log)
	248
	249	def tearDown(self):
	250	self.print_patch.stop()
	251	pass
	252
45ba7a89 DG	253	def test_config_passes_args_pass(self):
	254	kunit.main(['config'], self.linux_source_mock)
	255	assert self.linux_source_mock.build_reconfig.call_count == 1
	256	assert self.linux_source_mock.run_kernel.call_count == 0
	257
	258	def test_build_passes_args_pass(self):
	259	kunit.main(['build'], self.linux_source_mock)
	260	assert self.linux_source_mock.build_reconfig.call_count == 0
	261	self.linux_source_mock.build_um_kernel.assert_called_once_with(False, 8, '', None)
	262	assert self.linux_source_mock.run_kernel.call_count == 0
	263
	264	def test_exec_passes_args_pass(self):
	265	kunit.main(['exec'], self.linux_source_mock)
	266	assert self.linux_source_mock.build_reconfig.call_count == 0
	267	assert self.linux_source_mock.run_kernel.call_count == 1
	268	self.linux_source_mock.run_kernel.assert_called_once_with(build_dir='', timeout=300)
	269	self.print_mock.assert_any_call(StrContains('Testing complete.'))
	270
6ebf5866 FG	271	def test_run_passes_args_pass(self):
	272	kunit.main(['run'], self.linux_source_mock)
	273	assert self.linux_source_mock.build_reconfig.call_count == 1
	274	assert self.linux_source_mock.run_kernel.call_count == 1
021ed9f5 HF	275	self.linux_source_mock.run_kernel.assert_called_once_with(
021ed9f5 HF	276	build_dir='', timeout=300)
6ebf5866 FG	277	self.print_mock.assert_any_call(StrContains('Testing complete.'))
6ebf5866 FG	278
45ba7a89 DG	279	def test_exec_passes_args_fail(self):
	280	self.linux_source_mock.run_kernel = mock.Mock(return_value=[])
	281	with self.assertRaises(SystemExit) as e:
	282	kunit.main(['exec'], self.linux_source_mock)
	283	assert type(e.exception) == SystemExit
	284	assert e.exception.code == 1
	285
6ebf5866 FG	286	def test_run_passes_args_fail(self):
	287	self.linux_source_mock.run_kernel = mock.Mock(return_value=[])
	288	with self.assertRaises(SystemExit) as e:
	289	kunit.main(['run'], self.linux_source_mock)
	290	assert type(e.exception) == SystemExit
	291	assert e.exception.code == 1
	292	assert self.linux_source_mock.build_reconfig.call_count == 1
	293	assert self.linux_source_mock.run_kernel.call_count == 1
	294	self.print_mock.assert_any_call(StrContains(' 0 tests run'))
	295
45ba7a89 DG	296	def test_exec_raw_output(self):
	297	self.linux_source_mock.run_kernel = mock.Mock(return_value=[])
	298	kunit.main(['exec', '--raw_output'], self.linux_source_mock)
	299	assert self.linux_source_mock.run_kernel.call_count == 1
	300	for kall in self.print_mock.call_args_list:
	301	assert kall != mock.call(StrContains('Testing complete.'))
	302	assert kall != mock.call(StrContains(' 0 tests run'))
	303
6ebf5866 FG	304	def test_run_raw_output(self):
6ebf5866 FG	305	self.linux_source_mock.run_kernel = mock.Mock(return_value=[])
45ba7a89	306	kunit.main(['run', '--raw_output'], self.linux_source_mock)
6ebf5866 FG	307	assert self.linux_source_mock.build_reconfig.call_count == 1
6ebf5866 FG	308	assert self.linux_source_mock.run_kernel.call_count == 1
45ba7a89 DG	309	for kall in self.print_mock.call_args_list:
	310	assert kall != mock.call(StrContains('Testing complete.'))
	311	assert kall != mock.call(StrContains(' 0 tests run'))
	312
	313	def test_exec_timeout(self):
	314	timeout = 3453
	315	kunit.main(['exec', '--timeout', str(timeout)], self.linux_source_mock)
	316	self.linux_source_mock.run_kernel.assert_called_once_with(build_dir='', timeout=timeout)
	317	self.print_mock.assert_any_call(StrContains('Testing complete.'))
6ebf5866 FG	318
	319	def test_run_timeout(self):
	320	timeout = 3453
	321	kunit.main(['run', '--timeout', str(timeout)], self.linux_source_mock)
	322	assert self.linux_source_mock.build_reconfig.call_count == 1
021ed9f5 HF	323	self.linux_source_mock.run_kernel.assert_called_once_with(
021ed9f5 HF	324	build_dir='', timeout=timeout)
6ebf5866 FG	325	self.print_mock.assert_any_call(StrContains('Testing complete.'))
6ebf5866 FG	326
b1b35201 SP	327	def test_run_builddir(self):
	328	build_dir = '.kunit'
	329	kunit.main(['run', '--build_dir', build_dir], self.linux_source_mock)
	330	assert self.linux_source_mock.build_reconfig.call_count == 1
021ed9f5 HF	331	self.linux_source_mock.run_kernel.assert_called_once_with(
021ed9f5 HF	332	build_dir=build_dir, timeout=300)
b1b35201 SP	333	self.print_mock.assert_any_call(StrContains('Testing complete.'))
b1b35201 SP	334
45ba7a89 DG	335	def test_config_builddir(self):
	336	build_dir = '.kunit'
	337	kunit.main(['config', '--build_dir', build_dir], self.linux_source_mock)
	338	assert self.linux_source_mock.build_reconfig.call_count == 1
	339
	340	def test_build_builddir(self):
	341	build_dir = '.kunit'
	342	kunit.main(['build', '--build_dir', build_dir], self.linux_source_mock)
	343	self.linux_source_mock.build_um_kernel.assert_called_once_with(False, 8, build_dir, None)
	344
	345	def test_exec_builddir(self):
	346	build_dir = '.kunit'
	347	kunit.main(['exec', '--build_dir', build_dir], self.linux_source_mock)
	348	self.linux_source_mock.run_kernel.assert_called_once_with(build_dir=build_dir, timeout=300)
	349	self.print_mock.assert_any_call(StrContains('Testing complete.'))
	350
6ebf5866 FG	351	if __name__ == '__main__':
6ebf5866 FG	352	unittest.main()