def test_use_random_randint(self):
result = str_test.run_tests(TARGET_CODE_20, TEST_CODE9, 'random_int')
self.assertTrue(result.success)
self.assertEqual(1, result.total_tests)
result = str_test.run_tests(TARGET_CODE_21, TEST_CODE9, 'random_int')
self.assertTrue(result.success)
self.assertEqual(1, result.total_tests)
result = str_test.run_tests(TARGET_CODE_22, TEST_CODE9, 'random_int')
self.assertFalse(result.success)
self.assertTrue(
'Não deveria executar o randint com os argumentos 1, 10' in
result.failure_msgs[0])
self.assertEqual(1, result.total_tests)
def test_get_stdout(self):
result = str_test.run_tests(TARGET_CODE_24, TEST_CODE11, None)
self.assertFalse(result.success)
self.assertEqual([('Começando', ), ('Continuar? ', 'sim'),
('Continuar? ', 'sim'), ('Continuar? ', 'não'),
('Fim', )], result.stdouts[0])
self.assertEqual(1, result.total_tests)
def test_run_program_with_error(self):
result = str_test.run_tests(TARGET_CODE_10, TEST_CODE4, None)
self.assertFalse(result.success)
self.assertEqual(2, len(result.failure_msgs))
for i in range(2):
self.assertEqual('Não funcionou para algum teste',
result.failure_msgs[i])
self.assertEqual(2, result.total_tests)
def test_one_failure(self):
result = str_test.run_tests(TARGET_CODE_3, TEST_CODE1, 'ex1')
self.assertEqual(2, result.result_obj.testsRun)
self.assertFalse(result.success)
self.assertEqual(1, len(result.failure_msgs))
self.assertEqual('Não funcionou para caso com zero.',
result.failure_msgs[0])
self.assertEqual(2, result.total_tests)
def test_timeout(self):
result = str_test.run_tests(TARGET_CODE_2, TEST_CODE1, 'ex1')
self.assertEqual(2, result.result_obj.testsRun)
self.assertFalse(result.success)
self.assertEqual(2, len(result.failure_msgs))
self.assertEqual(str_test.TIME_LIMIT_EXCEEDED, result.failure_msgs[0])
self.assertEqual(str_test.TIME_LIMIT_EXCEEDED, result.failure_msgs[1])
self.assertEqual(2, result.total_tests)
def test_division_by_zero(self):
result = str_test.run_tests(TARGET_CODE_4, TEST_CODE1, 'ex1')
self.assertEqual(2, result.result_obj.testsRun)
self.assertFalse(result.success)
self.assertEqual(2, len(result.failure_msgs))
self.assertEqual('Não funcionou para caso com zero.',
result.failure_msgs[0])
self.assertEqual(str_test.DEFAULT_MSG, result.failure_msgs[1])
self.assertEqual(2, result.total_tests)
def test_doesnt_break_with_missing_function(self):
f_name = 'wrong_name'
result = str_test.run_tests(TARGET_CODE_1, TEST_CODE1, f_name)
self.assertFalse(result.success)
self.assertEqual(1, len(result.failure_msgs))
self.assertEqual(
'Função não encontrada. Sua função deveria se chamar {}'.format(
f_name), result.failure_msgs[0])
self.assertEqual(2, result.total_tests)
def test_doesnt_break_with_syntax_error(self):
result = str_test.run_tests(TARGET_CODE_0, TEST_CODE1, 'ex1')
print(result)
print("_____________________________")
self.assertFalse(result.success)
self.assertEqual(1, len(result.failure_msgs))
self.assertEqual('Erro de sintaxe (código Python inválido)',
result.failure_msgs[0])
print(str(result.stack_traces[0]))
self.assertEqual(2, result.total_tests)
def lambda_handler(event, context):
code = event['code']
test_code = event['test_code']
function_name = event.get('function_name')
result = str_test.run_tests(code, test_code, function_name)
retval = {
'failure_msgs': result.failure_msgs,
'success': result.success,
'stack_traces': result.stack_traces,
'stdouts': result.stdouts,
'total_tests': result.total_tests,
}
return {'statusCode': 200, 'body': json.dumps(retval)}
def post_code(event, context):
data = json.loads(event['body'])
code = data['code']
test_code = data['test_code']
function_name = data.get('function_name')
result = str_test.run_tests(code, test_code, function_name)
retval = {
'failure_msgs': result.failure_msgs,
'success': result.success,
'stack_traces': result.stack_traces,
'stdouts': result.stdouts,
'total_tests': result.total_tests,
}
return {
'statusCode': 200,
'body': json.dumps(retval)
}
def test_run_program_if_none_function(self):
result = str_test.run_tests(TARGET_CODE_9, TEST_CODE4, None)
self.assertEqual(2, result.result_obj.testsRun)
self.assertTrue(result.success)
self.assertEqual(2, result.total_tests)
def test_doesnt_break_with_multiple_inputs(self):
result = str_test.run_tests(TARGET_CODE_23, TEST_CODE10, None)
self.assertTrue(result.success)
self.assertEqual(2, result.total_tests)
def test_doesnt_allow_input_in_function_test(self):
result = str_test.run_tests(TARGET_CODE_19, TEST_CODE8, 'do_nothing')
self.assertFalse(result.success)
self.assertTrue('input' in result.failure_msgs[0])
self.assertEqual(1, result.total_tests)
def test_write(self):
result = str_test.run_tests(TARGET_CODE_17, TEST_CODE6, None)
self.assertTrue(result.success)
self.assertEqual(1, result.total_tests)
def test_append(self):
result = str_test.run_tests(TARGET_CODE_18, TEST_CODE7, None)
self.assertTrue(result.success)
self.assertEqual(1, result.total_tests)
def test_open_file_that_doesnt_exist(self):
result = str_test.run_tests(TARGET_CODE_13, TEST_CODE5, None)
self.assertFalse(result.success)
self.assertTrue('FileNotFoundError' in result.stack_traces[0])
self.assertEqual(1, result.total_tests)
def test_write_file_opened_for_reading(self):
result = str_test.run_tests(TARGET_CODE_16, TEST_CODE5, None)
self.assertFalse(result.success)
self.assertTrue('UnsupportedOperation' in result.stack_traces[0])
self.assertTrue('not writable' in result.stack_traces[0])
self.assertEqual(1, result.total_tests)
def test_with_open(self):
result = str_test.run_tests(TARGET_CODE_12, TEST_CODE5, None)
self.assertTrue(result.success)
self.assertEqual(1, result.total_tests)
def test_pass_all_tests(self):
result = str_test.run_tests(TARGET_CODE_1, TEST_CODE1, 'ex1')
self.assertEqual(2, result.result_obj.testsRun)
self.assertTrue(result.success)
self.assertEqual(0, len(result.failure_msgs))
self.assertEqual(2, result.total_tests)
def aplica_teste(arq_codigo, arq_testes, nome_funcao):
codigo = carrega_arquivo(arq_codigo)
testes = carrega_arquivo(arq_testes)
resultado = str_test.run_tests(codigo, testes, nome_funcao)
esperado = 'solucao' in str(arq_codigo)
assert esperado == resultado.success, f'Resultado diferente do esperado para o arquivo {arq_codigo}'
def test_fail_input(self):
result = str_test.run_tests(TARGET_CODE_8, TEST_CODE3, 'input_and_sum')
self.assertEqual(2, result.result_obj.testsRun)
self.assertFalse(result.success)
self.assertEqual(2, result.total_tests)
def test_print_failure(self):
result = str_test.run_tests(TARGET_CODE_6, TEST_CODE2,
'code_with_print')
self.assertEqual(1, result.result_obj.testsRun)
self.assertFalse(result.success)
self.assertEqual(1, result.total_tests)
def load_code(filename):
code = None
try:
with open(filename) as f:
code = f.read()
except FileNotFoundError:
print('File {} not found'.format(filename))
return code
target_code = load_code(args.target_filename)
test_code = load_code(args.test_filename)
result = None
if target_code is not None and test_code is not None:
result = ch.run_tests(target_code, test_code, args.function_name)
if result:
print(result)
if result.success:
print(str(result))
# print('Passed all tests!')
else:
print('Did not pass all tests :(')
print('Failure messages:')
for msg in result.failure_msgs:
print(str(result))
print(msg)
if args.verbose:
print('\nStack traces:')
def run_test(code_file, test_file, function_name):
code = load_file(code_file)
tests = load_file(test_file)
result = str_test.run_tests(code, tests, function_name)
expected = 'solution' in str(code_file)
assert expected == result.success, f'Result was different than the expected for the file {code_file}'
