From c75dcb9d9cfd8732dc593cb16cf3a6df79e0526c Mon Sep 17 00:00:00 2001 From: Daniel Micay Date: Sat, 11 Apr 2020 15:26:24 -0400 Subject: [PATCH] compare with negative integers to check signals --- test/simple-memory-corruption/test_smc.py | 44 +++++++++++------------ 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/test/simple-memory-corruption/test_smc.py b/test/simple-memory-corruption/test_smc.py index a1f3adc..182dc6b 100644 --- a/test/simple-memory-corruption/test_smc.py +++ b/test/simple-memory-corruption/test_smc.py @@ -18,33 +18,33 @@ class TestSimpleMemoryCorruption(unittest.TestCase): def test_delete_type_size_mismatch(self): _stdout, stderr, returncode = self.run_test( "delete_type_size_mismatch") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode( "utf-8"), "fatal allocator error: sized deallocation mismatch (small)\n") def test_double_free_large_delayed(self): _stdout, stderr, returncode = self.run_test( "double_free_large_delayed") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: invalid free\n") def test_double_free_large(self): _stdout, stderr, returncode = self.run_test("double_free_large") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: invalid free\n") def test_double_free_small_delayed(self): _stdout, stderr, returncode = self.run_test( "double_free_small_delayed") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: double free (quarantine)\n") def test_double_free_small(self): _stdout, stderr, returncode = self.run_test("double_free_small") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: double free (quarantine)\n") @@ -56,39 +56,39 @@ class TestSimpleMemoryCorruption(unittest.TestCase): def test_eight_byte_overflow_small(self): _stdout, stderr, returncode = self.run_test( "eight_byte_overflow_small") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: canary corrupted\n") def test_invalid_free_protected(self): _stdout, stderr, returncode = self.run_test("invalid_free_protected") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: invalid free\n") def test_invalid_free_small_region_far(self): _stdout, stderr, returncode = self.run_test( "invalid_free_small_region_far") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode( "utf-8"), "fatal allocator error: invalid free within a slab yet to be used\n") def test_invalid_free_small_region(self): _stdout, stderr, returncode = self.run_test( "invalid_free_small_region") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: double free\n") def test_invalid_free_unprotected(self): _stdout, stderr, returncode = self.run_test("invalid_free_unprotected") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: invalid free\n") def test_read_after_free_large(self): _stdout, _stderr, returncode = self.run_test("read_after_free_large") - self.assertEqual(abs(returncode), 11) + self.assertEqual(returncode, -11) def test_read_after_free_small(self): stdout, _stderr, returncode = self.run_test("read_after_free_small") @@ -98,7 +98,7 @@ class TestSimpleMemoryCorruption(unittest.TestCase): def test_read_zero_size(self): _stdout, _stderr, returncode = self.run_test("read_zero_size") - self.assertEqual(abs(returncode), 11) + self.assertEqual(returncode, -11) def test_string_overflow(self): stdout, _stderr, returncode = self.run_test("string_overflow") @@ -107,58 +107,58 @@ class TestSimpleMemoryCorruption(unittest.TestCase): def test_unaligned_free_large(self): _stdout, stderr, returncode = self.run_test("unaligned_free_large") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: invalid free\n") def test_unaligned_free_small(self): _stdout, stderr, returncode = self.run_test("unaligned_free_small") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: invalid unaligned free\n") def test_uninitialized_free(self): _stdout, stderr, returncode = self.run_test("uninitialized_free") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: invalid free\n") def test_uninitialized_malloc_usable_size(self): _stdout, _stderr, returncode = self.run_test( "uninitialized_malloc_usable_size") - self.assertEqual(abs(returncode), 11) + self.assertEqual(returncode, -11) def test_uninitialized_realloc(self): _stdout, stderr, returncode = self.run_test("uninitialized_realloc") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: invalid realloc\n") def test_write_after_free_large_reuse(self): _stdout, _stderr, returncode = self.run_test( "write_after_free_large_reuse") - self.assertEqual(abs(returncode), 11) + self.assertEqual(returncode, -11) def test_write_after_free_large(self): _stdout, _stderr, returncode = self.run_test("write_after_free_large") - self.assertEqual(abs(returncode), 11) + self.assertEqual(returncode, -11) def test_write_after_free_small_reuse(self): _stdout, stderr, returncode = self.run_test( "write_after_free_small_reuse") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: detected write after free\n") def test_write_after_free_small(self): _stdout, stderr, returncode = self.run_test("write_after_free_small") - self.assertEqual(abs(returncode), 6) + self.assertEqual(returncode, -6) self.assertEqual(stderr.decode("utf-8"), "fatal allocator error: detected write after free\n") def test_write_zero_size(self): _stdout, _stderr, returncode = self.run_test("write_zero_size") - self.assertEqual(abs(returncode), 11) + self.assertEqual(returncode, -11) if __name__ == '__main__':