diff options
Diffstat (limited to 'libparc/parc/algol/test/test_parc_SafeMemory.c')
| -rw-r--r-- | libparc/parc/algol/test/test_parc_SafeMemory.c | 813 |
1 files changed, 813 insertions, 0 deletions
diff --git a/libparc/parc/algol/test/test_parc_SafeMemory.c b/libparc/parc/algol/test/test_parc_SafeMemory.c new file mode 100644 index 00000000..53c0b3c8 --- /dev/null +++ b/libparc/parc/algol/test/test_parc_SafeMemory.c @@ -0,0 +1,813 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * 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. + */ + +/** + */ +#include "../parc_SafeMemory.c" + +#include <LongBow/unit-test.h> + +#include <fcntl.h> + +LONGBOW_TEST_RUNNER(safetyMemory) +{ + LONGBOW_RUN_TEST_FIXTURE(Static); + LONGBOW_RUN_TEST_FIXTURE(ReportAllocation); + LONGBOW_RUN_TEST_FIXTURE(Global); + LONGBOW_RUN_TEST_FIXTURE(Errors); + + LONGBOW_RUN_TEST_FIXTURE(Performance); +} + +LONGBOW_TEST_RUNNER_SETUP(safetyMemory) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_RUNNER_TEARDOWN(safetyMemory) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE(Static) +{ + LONGBOW_RUN_TEST_CASE(Static, PARCSafeMemory_Report); + LONGBOW_RUN_TEST_CASE(Static, _parcSafeMemory_StateToString); + LONGBOW_RUN_TEST_CASE(Static, _parcSafeMemory_GetPrefixState_OK); + LONGBOW_RUN_TEST_CASE(Static, _parcSafeMemory_GetPrefixState_ALREADYFREE); + LONGBOW_RUN_TEST_CASE(Static, _parcSafeMemory_GetPrefixState_UNDERRUN); + LONGBOW_RUN_TEST_CASE(Static, _parcSafeMemory_FormatPrefix); + LONGBOW_RUN_TEST_CASE(Static, _computeUsableMemoryLength); +} + +LONGBOW_TEST_FIXTURE_SETUP(Static) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Static) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_CASE(Static, PARCSafeMemory_Report) +{ + size_t expectedSize = 100; + void *memory = parcSafeMemory_Allocate(expectedSize); + int fd = open("/dev/null", O_WRONLY); + _parcSafeMemory_Report(memory, fd); + close(fd); + parcSafeMemory_Deallocate(&memory); +} + +LONGBOW_TEST_CASE(Static, _parcSafeMemory_StateToString) +{ + assertNotNull(_parcSafeMemory_StateToString(PARCSafeMemoryState_OK), + "PARCSafeMemoryState_OK cannot be a NULL string."); + assertNotNull(_parcSafeMemory_StateToString(PARCSafeMemoryState_MISMATCHED), + "PARCSafeMemoryState_MISMATCHED cannot be a NULL string."); + assertNotNull(_parcSafeMemory_StateToString(PARCSafeMemoryState_UNDERRUN), + "PARCSafeMemoryState_UNDERRUN cannot be a NULL string."); + assertNotNull(_parcSafeMemory_StateToString(PARCSafeMemoryState_OVERRUN), + "PARCSafeMemoryState_OVERRUN cannot be a NULL string."); + assertNotNull(_parcSafeMemory_StateToString(PARCSafeMemoryState_NOTHINGALLOCATED), + "PARCSafeMemoryState_NOTHINGALLOCATED cannot be a NULL string."); + assertNotNull(_parcSafeMemory_StateToString(PARCSafeMemoryState_ALREADYFREE), + "PARCSafeMemoryState_ALREADYFREE cannot be a NULL string."); + assertNotNull(_parcSafeMemory_StateToString(-1), + "Garbage cannot be represented by a NULL string."); +} + +LONGBOW_TEST_CASE(Static, _parcSafeMemory_GetPrefixState_OK) +{ + size_t expectedLength = 5; + int expectedAlignment = sizeof(void *); + char origin[100]; // just some number + + void *memory = _parcSafeMemory_FormatPrefix((PARCSafeMemoryOrigin *) origin, expectedLength, expectedAlignment); + PARCSafeMemoryState actual = _parcSafeMemory_GetPrefixState(memory); + assertTrue(actual == PARCSafeMemoryState_OK, + "Expected PARCSafeMemoryState_OK, actual = %d", actual); +} + +LONGBOW_TEST_CASE(Static, _parcSafeMemory_GetPrefixState_ALREADYFREE) +{ + PARCSafeMemoryUsable *usable = parcSafeMemory_Allocate(10); + PARCSafeMemoryUsable *saved = usable; + + parcSafeMemory_Deallocate((void **) &usable); + + PARCSafeMemoryState actual = _parcSafeMemory_GetPrefixState(saved); + assertTrue(actual == PARCSafeMemoryState_ALREADYFREE, + "Expected PARCSafeMemoryState_ALREADYFREE, actual = %d", actual); +} + +LONGBOW_TEST_CASE(Static, _parcSafeMemory_GetPrefixState_UNDERRUN) +{ + char *usable = parcSafeMemory_Allocate(10); + + char savedByte = usable[-1]; + usable[-1] = 0; + + PARCSafeMemoryState actual = _parcSafeMemory_GetPrefixState((PARCSafeMemoryUsable *) usable); + assertTrue(actual == PARCSafeMemoryState_UNDERRUN, + "Expected PARCSafeMemoryState_UNDERRUN, actual = %d", actual); + usable[-1] = savedByte; + parcSafeMemory_Deallocate((void **) &usable); +} + +LONGBOW_TEST_CASE(Static, _parcSafeMemory_FormatPrefix) +{ + size_t expectedLength = 5; + int expectedAlignment = sizeof(void *) - 1; + char base[100]; // just some number + void *memory = _parcSafeMemory_FormatPrefix((PARCSafeMemoryOrigin *) base, expectedLength, expectedAlignment); + + assertNull(memory, + "Expected _parcSafeMemory_FormatPrefix to return NULL for bad alignment specification."); +} + +LONGBOW_TEST_CASE(Static, _computeUsableMemoryLength) +{ + size_t actual = _computeUsableMemoryLength(100, sizeof(void *)); + + // The result must be >= to the requested length and an even multiple of sizeof(void *) + assertTrue(actual >= 100 && (actual % sizeof(void *)) == 0, + "Expected the result to be >= to the requested length and an even multiple of sizeof(void *)"); +} + +LONGBOW_TEST_FIXTURE(ReportAllocation) +{ + LONGBOW_RUN_TEST_CASE(ReportAllocation, parcSafeMemory_ReportAllocation_Empty); + LONGBOW_RUN_TEST_CASE(ReportAllocation, parcSafeMemory_ReportAllocation_One); + LONGBOW_RUN_TEST_CASE(ReportAllocation, parcSafeMemory_ReportAllocation_Deallocated); +} + +LONGBOW_TEST_CASE(ReportAllocation, parcSafeMemory_ReportAllocation_Empty) +{ + _parcSafeMemory_DeallocateAll(); + int fd = open("/dev/null", O_WRONLY); + size_t result = parcSafeMemory_ReportAllocation(fd); + close(fd); + assertTrue(result == 0, "Expected 0, was %zd", result); +} + +LONGBOW_TEST_CASE(ReportAllocation, parcSafeMemory_ReportAllocation_One) +{ + void *memory; + size_t size = 100; + + memory = parcSafeMemory_Allocate(size); + + int fd = open("/dev/null", O_WRONLY); + size_t result = parcSafeMemory_ReportAllocation(fd); + close(fd); + assertTrue(result == 1, "Expected 1, was %zd", result); + + parcSafeMemory_Deallocate(&memory); +} + +LONGBOW_TEST_CASE(ReportAllocation, parcSafeMemory_ReportAllocation_Deallocated) +{ + size_t size = 100; + void *memory = parcSafeMemory_Allocate(size); + assertTrue(parcSafeMemory_Outstanding() != 0, "No memory allocated!"); + PARCSafeMemoryState state = _parcSafeMemory_GetState(memory); + parcSafeMemory_Deallocate(&memory); + assertTrue(state == PARCSafeMemoryState_OK, "Expected uncorrupted memory."); + + int fd = open("/dev/null", O_WRONLY); + size_t result = parcSafeMemory_ReportAllocation(fd); + close(fd); + + assertTrue(result == 0, "Expected 0, was %zd", result); +} + +LONGBOW_TEST_FIXTURE_SETUP(ReportAllocation) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(ReportAllocation) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE(Global) +{ + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_Allocate); + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_MemAlign); + + LONGBOW_RUN_TEST_CASE(Global, PARCSafeMemory_Realloc_Larger); + LONGBOW_RUN_TEST_CASE(Global, PARCSafeMemory_Realloc_Smaller); + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_Reallocate_Zero); + LONGBOW_RUN_TEST_CASE(Global, PARCSafeMemory_Validate); + + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_Allocate_BadAlignment); + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_Allocate_BadSize); + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_AllocateAndClear); + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_Reallocate); + + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_Deallocate_NothingAllocated); + + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_IsValid_True); + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_IsValid_False); + + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_Display); + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_Display_NULL); + + LONGBOW_RUN_TEST_CASE(Global, compute_prefix_length); + LONGBOW_RUN_TEST_CASE(Global, _parcSafeMemory_FormatMemory); + LONGBOW_RUN_TEST_CASE(Global, memory_prefix_format); + LONGBOW_RUN_TEST_CASE(Global, memory_prefix_validate); + LONGBOW_RUN_TEST_CASE(Global, memory_suffix_format); + LONGBOW_RUN_TEST_CASE(Global, memory_suffix_validate); + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_StringDuplicate); + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_StringDuplicate_Long); + LONGBOW_RUN_TEST_CASE(Global, parcSafeMemory_StringDuplicate_Short); + LONGBOW_RUN_TEST_CASE(Global, validateAlignment); +} + +LONGBOW_TEST_FIXTURE_SETUP(Global) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Global) +{ + assertTrue(parcSafeMemory_Outstanding() == 0, "Expected 0 outstanding allocations") + { + printf("Leaking test case: %s", longBowTestCase_GetName(testCase)); + } + return LONGBOW_STATUS_SUCCEEDED; +} + + +LONGBOW_TEST_CASE(Global, validateAlignment) +{ + assertTrue(_alignmentIsValid(sizeof(void *)), + "Expected alignment of sizeof(void *) failed."); + assertTrue(_alignmentIsValid(16), + "Expected alignment of 16 failed."); +} + +LONGBOW_TEST_CASE(Global, compute_prefix_length) +{ + // Test that the result is a multiple of the alignment value and greater than the size of _MemoryPrefix. + for (int i = 0; i < 9; i++) { + size_t alignment = 1 << i; + size_t actual = _computePrefixLength(alignment); + assertTrue((actual & (alignment - 1)) == 0, + "Alignment needs to be a multiple of %zd", alignment); + } +} + +LONGBOW_TEST_CASE(Global, memory_prefix_format) +{ + size_t expectedLength = 5; + int expectedAlignment = sizeof(void *); + char base[100]; + void *memory = _parcSafeMemory_FormatPrefix((PARCSafeMemoryOrigin *) base, expectedLength, expectedAlignment); + + _MemoryPrefix *prefix = _parcSafeMemory_GetPrefix(memory); + + assertAligned(prefix, sizeof(void *), + "prefix address %p is not aligned to %d", + memory, expectedAlignment); + assertAligned(memory, expectedAlignment, + "memory address %p is not aligned to %d", + memory, expectedAlignment); + + assertTrue((void *) prefix >= (void *) base, + "Expected >= %p, actual %p", (void *) base, (void *) prefix); + assertTrue(_parcSafeMemory_PrefixMagic == prefix->magic, + "Prefix magic is wrong."); + assertTrue(expectedLength == prefix->requestedLength, + "Expected length %zd, actual %zd", expectedLength, prefix->requestedLength); + assertTrue(expectedAlignment == prefix->alignment, + "Expected alignment %d, actual %zu", + expectedAlignment, prefix->alignment); + assertTrue(_parcSafeMemory_Guard == prefix->guard, + "Prefix guard is wrong."); +} + +LONGBOW_TEST_CASE(Global, memory_suffix_format) +{ + size_t expectedLength = 5; + int expectedAlignment = sizeof(void *); + char base[100]; + void *memory = _parcSafeMemory_FormatPrefix((PARCSafeMemoryOrigin *) base, expectedLength, expectedAlignment); + + _MemorySuffix *suffix = _parcSafeMemory_FormatSuffix(memory); + assertAligned(suffix, sizeof(void *), "suffix pointer is not aligned to %zu", sizeof(void*)); +} + +LONGBOW_TEST_CASE(Global, memory_suffix_validate) +{ + size_t expectedLength = 5; + int expectedAlignment = sizeof(void *); + char base[100]; + void *memory = _parcSafeMemory_FormatPrefix((PARCSafeMemoryOrigin *) base, expectedLength, expectedAlignment); + + _MemorySuffix *suffix = _parcSafeMemory_FormatSuffix(memory); + assertAligned(suffix, sizeof(void *), + "suffix pointer is not aligned to %zu", sizeof(void*)); + + PARCSafeMemoryState suffixState = _parcSafeMemory_GetSuffixState(memory); + assertTrue(suffixState == PARCSafeMemoryState_OK, + "Expected PARCSafeMemoryState_OK suffix state, actual %s", _parcSafeMemory_StateToString(suffixState)); +} + +LONGBOW_TEST_CASE(Global, memory_prefix_validate) +{ + size_t expectedLength = 5; + int expectedAlignment = sizeof(void *); + char base[100]; + + void *memory = _parcSafeMemory_FormatPrefix((PARCSafeMemoryOrigin *) base, expectedLength, expectedAlignment); + PARCSafeMemoryState actual = _parcSafeMemory_GetPrefixState(memory); + assertTrue(actual == PARCSafeMemoryState_OK, + "Expected valid prefix, actual = %d", actual); +} + +LONGBOW_TEST_CASE(Global, _parcSafeMemory_FormatMemory) +{ + size_t expectedLength = 5; + int expectedAlignment = sizeof(void *); + char base[100]; + + void *memory = _parcSafeMemory_FormatMemory((PARCSafeMemoryOrigin *) base, expectedLength, expectedAlignment); + + PARCSafeMemoryState state = _parcSafeMemory_GetState(memory); + + assertTrue(state == PARCSafeMemoryState_OK, + "Memory did not validate. Actual %d", state); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_Allocate) +{ + void *memory; + size_t size = 100; + + memory = parcSafeMemory_Allocate(size); + + assertTrue(memory != NULL, + "Expected non-NULL return."); + + assertTrue((_parcSafeMemory_GetPrefixState(memory)) == PARCSafeMemoryState_OK, + "Prefix did not validate."); + parcSafeMemory_Deallocate(&memory); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_MemAlign) +{ + void *memory; + size_t size = 100; + + int failure = parcSafeMemory_MemAlign(&memory, sizeof(void *), size); + assertTrue(failure == 0, + "parcSafeMemory_MemAlign failed: %d", failure); + + assertTrue(memory != NULL, + "Expected non-NULL return."); + + assertTrue((_parcSafeMemory_GetPrefixState(memory)) == PARCSafeMemoryState_OK, + "Prefix did not validate."); + parcSafeMemory_Deallocate(&memory); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_ReportAllocation) +{ + void *memory; + size_t size = 100; + + memory = parcSafeMemory_Allocate(size); + assertTrue(memory != NULL, "Expected non-NULL return."); + PARCSafeMemoryState prefixState = _parcSafeMemory_GetPrefixState(memory); + assertTrue(prefixState == PARCSafeMemoryState_OK, + "Prefix did not validate."); + + parcSafeMemory_ReportAllocation(1); +} + +LONGBOW_TEST_CASE(Global, PARCSafeMemory_Validate) +{ + void *memory; + size_t size = 100; + + memory = parcSafeMemory_Allocate(size); + + assertTrue(_parcSafeMemory_GetState(memory) == PARCSafeMemoryState_OK, + "Memory did not validate."); + parcSafeMemory_Deallocate(&memory); +} + +LONGBOW_TEST_CASE(Global, PARCSafeMemory_Realloc_Larger) +{ + void *memory = parcSafeMemory_Allocate(100); + + for (unsigned char i = 0; i < 100; i++) { + ((unsigned char *) memory)[i] = i; + } + + assertTrue(_parcSafeMemory_GetState(memory) == PARCSafeMemoryState_OK, + "Expected memory to be OK."); + + size_t expectedLength = 100 + 1; + unsigned char *newMemory = parcSafeMemory_Reallocate(memory, expectedLength); + + assertTrue(_parcSafeMemory_GetState((PARCSafeMemoryUsable *) memory) != PARCSafeMemoryState_OK, + "Expected original memory to NOT be OK."); + assertTrue(_parcSafeMemory_GetState((PARCSafeMemoryUsable *) newMemory) == PARCSafeMemoryState_OK, + "Expected new memory to be OK."); + + _MemoryPrefix *prefix = _parcSafeMemory_GetPrefix((PARCSafeMemoryUsable *) newMemory); + assertTrue(prefix->requestedLength == expectedLength, + "Prefix Expected length %zd, actual %zd", expectedLength, prefix->requestedLength); + + for (int i = 0; i < 100; i++) { + assertTrue(((unsigned char *) newMemory)[i] == i, + "PARCSafeMemory_Realloc did not copy old memory correctly"); + } + + assertTrue(parcSafeMemory_Outstanding() != 0, + "No memory allocated!"); + PARCSafeMemoryState state = _parcSafeMemory_GetState((PARCSafeMemoryUsable *) newMemory); + parcSafeMemory_Deallocate((void **) &newMemory); + assertTrue(state == PARCSafeMemoryState_OK, + "Expected PARCSafeMemory_Deallocate of new memory to be OK, actual =%d", state); + assertTrue(_parcSafeMemory_GetState(memory) != PARCSafeMemoryState_OK, + "Expected old memory to be invalid."); +} + +LONGBOW_TEST_CASE(Global, PARCSafeMemory_Realloc_Smaller) +{ + void *memory = parcSafeMemory_Allocate(100); + assertTrue(_parcSafeMemory_GetState(memory) == PARCSafeMemoryState_OK, + "Memory did not validate."); + + for (unsigned char i = 0; i < 100; i++) { + ((unsigned char *) memory)[i] = i; + } + + size_t expectedLength = 100 - 1; + unsigned char *newMemory = parcSafeMemory_Reallocate(memory, expectedLength); + + assertTrue(_parcSafeMemory_GetState(memory) != PARCSafeMemoryState_OK, + "Expected original memory to NOT be OK."); + assertTrue(_parcSafeMemory_GetState((PARCSafeMemoryUsable *) newMemory) == PARCSafeMemoryState_OK, + "Expected new memory to be OK."); + + _MemoryPrefix *prefix = _parcSafeMemory_GetPrefix((PARCSafeMemoryUsable *) newMemory); + assertTrue(prefix->requestedLength == expectedLength, + "Prefix Expected length %zd, actual %zd", expectedLength, prefix->requestedLength); + + for (int i = 0; i < expectedLength; i++) { + assertTrue(((unsigned char *) newMemory)[i] == i, + "PARCSafeMemory_Realloc did not copy correctly"); + } + + assertTrue(parcSafeMemory_Outstanding() != 0, + "No memory allocated!"); + PARCSafeMemoryState state = _parcSafeMemory_GetState((PARCSafeMemoryUsable *) newMemory); + parcSafeMemory_Deallocate((void **) &newMemory); + assertTrue(state == PARCSafeMemoryState_OK, + "Expected PARCSafeMemory_Deallocate of new memory to be OK, actual =%d", state); + assertTrue(_parcSafeMemory_GetState(memory) != PARCSafeMemoryState_OK, + "Expected old memory to be invalid."); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_Reallocate_Zero) +{ + void *memory = parcSafeMemory_Allocate(100); + assertTrue(_parcSafeMemory_GetState(memory) == PARCSafeMemoryState_OK, + "Memory did not validate."); + + for (unsigned char i = 0; i < 100; i++) { + ((unsigned char *) memory)[i] = i; + } + + size_t expectedLength = 0; + unsigned char *newMemory = parcSafeMemory_Reallocate(memory, expectedLength); + + assertTrue(newMemory == NULL, + "Expected NULL, actual %p", (void *) newMemory); + + parcSafeMemory_Deallocate(&memory); + assertNull(memory, + "Expected memory pointer to be NULL."); +} + +LONGBOW_TEST_CASE(Global, PARCSafeMemory_DoubleFree) +{ + size_t expectedSize = 100; + + void *memory = parcSafeMemory_Allocate(expectedSize); + assertTrue(_parcSafeMemory_GetState(memory) == PARCSafeMemoryState_OK, + "Memory did not validate."); + + for (unsigned char i = 0; i < expectedSize; i++) { + ((unsigned char *) memory)[i] = i; + } + + assertTrue(parcSafeMemory_Outstanding() != 0, + "No memory allocated!"); + PARCSafeMemoryState state = _parcSafeMemory_GetState(memory); + parcSafeMemory_Deallocate(&memory); + assertTrue(state == PARCSafeMemoryState_OK, + "Expected memory to validate"); + assertTrue(parcSafeMemory_Outstanding() != 0, + "No memory allocated!"); + state = _parcSafeMemory_GetState(memory); + parcSafeMemory_Deallocate(&memory); + assertTrue(state == PARCSafeMemoryState_UNDERRUN, + "Expected memory to be underrun (double free)."); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_StringDuplicate) +{ + char *string = "hello world"; + char *actual = parcSafeMemory_StringDuplicate(string, strlen(string)); + + assertTrue(strcmp(string, actual) == 0, + "Expected %s, actual %s", string, actual); + parcSafeMemory_Deallocate((void **) &actual); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_StringDuplicate_Long) +{ + char *string = "hello world"; + char *actual = parcSafeMemory_StringDuplicate(string, SIZE_MAX); + + assertTrue(strcmp(string, actual) == 0, + "Expected %s, actual %s", string, actual); + parcSafeMemory_Deallocate((void **) &actual); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_StringDuplicate_Short) +{ + char *string = "hello world"; + char *expected = "hello"; + char *actual = parcSafeMemory_StringDuplicate(string, 5); + + assertTrue(strcmp(expected, actual) == 0, + "Expected %s, actual %s", expected, actual); + parcSafeMemory_Deallocate((void **) &actual); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_Allocate_BadAlignment) +{ + void *result; + size_t alignment = 3; + size_t size = 100; + + int failure = parcSafeMemory_MemAlign(&result, alignment, size); + assertTrue(failure == EINVAL, + "parcSafeMemory_MemAlign failed to report bad aligment specification"); + assertTrue(parcSafeMemory_Outstanding() == 0, + "Expected 0 outstanding allocations, actual %d", parcSafeMemory_Outstanding()); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_Allocate_BadSize) +{ + void *result; + size_t alignment = sizeof(void *); + size_t size = 0; + + int failure = parcSafeMemory_MemAlign(&result, alignment, size); + assertTrue(failure == EINVAL, + "parcSafeMemory_MemAlign failed to report bad aligment specification"); + assertTrue(parcSafeMemory_Outstanding() == 0, + "Expected 0 outstanding allocation, actual %d", parcSafeMemory_Outstanding()); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_AllocateAndClear) +{ + void *result; + size_t size = 100; + + result = parcSafeMemory_AllocateAndClear(size); + assertNotNull(result, + "parcSafeMemory_AllocateAndClear failed: NULL result."); + + for (size_t i = 0; i < size; i++) { + assertTrue(((char *) result)[i] == 0, + "parcSafeMemory_AllocateAndClear failed to zero memory at index %zd", i); + } + assertTrue(parcSafeMemory_Outstanding() == 1, + "Expected 1 outstanding allocation, actual %d", parcSafeMemory_Outstanding()); + parcSafeMemory_Deallocate(&result); + assertTrue(parcSafeMemory_Outstanding() == 0, + "Expected 0 outstanding allocation, actual %d", parcSafeMemory_Outstanding()); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_Reallocate) +{ + size_t size = 100; + + void *result = parcSafeMemory_AllocateAndClear(size); + assertNotNull(result, + "parcSafeMemory_Allocate failed: NULL."); + + for (size_t i = 0; i < size; i++) { + assertTrue(((char *) result)[i] == 0, + "parcSafeMemory_AllocateAndClear failed to zero memory at index %zd", i); + } + + result = parcSafeMemory_Reallocate(result, size * 2); + + assertTrue(parcSafeMemory_Outstanding() == 1, + "Expected 1 outstanding allocation, actual %d", parcSafeMemory_Outstanding()); + parcSafeMemory_Deallocate(&result); + assertTrue(parcSafeMemory_Outstanding() == 0, + "Expected 0 outstanding allocations, actual %d", parcSafeMemory_Outstanding()); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_Deallocate_NothingAllocated) +{ + void *result = 0; + + parcSafeMemory_Deallocate(&result); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_IsValid_True) +{ + void *result = parcSafeMemory_AllocateAndClear(5); + + assertTrue(parcSafeMemory_IsValid(result), "Expected properly allocated memory to be valid PARC Safe Memory."); + + parcSafeMemory_Deallocate(&result); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_IsValid_False) +{ + char *memory[10]; + + assertFalse(parcSafeMemory_IsValid(memory), "Expected improperly allocated memory to be invalid PARC Safe Memory."); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_Display) +{ + void *result = parcSafeMemory_AllocateAndClear(5); + + parcSafeMemory_Display(result, 0); + parcSafeMemory_Deallocate(&result); +} + +LONGBOW_TEST_CASE(Global, parcSafeMemory_Display_NULL) +{ + parcSafeMemory_Display(NULL, 0); +} + +LONGBOW_TEST_FIXTURE(Errors) +{ + LONGBOW_RUN_TEST_CASE(Errors, parcSafeMemory_Reallocate_NULL); + LONGBOW_RUN_TEST_CASE(Errors, PARCSafeMemory_Deallocate_Overrun); + LONGBOW_RUN_TEST_CASE(Errors, PARCSafeMemory_Deallocate_Underrun); +} + +LONGBOW_TEST_FIXTURE_SETUP(Errors) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Errors) +{ + // The tests purposefully wreck the various per-allocation accounting structures for the allocated memory in order to test for + // properly catching the overrun, underrun or other damage. + // As a result any cleanup of allocated memory is not possible, so these tests leak allocated memory. + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_CASE(Errors, parcSafeMemory_Reallocate_NULL) +{ + void *result = NULL; + size_t size = 100; + + result = parcSafeMemory_Reallocate(result, size * 2); + + assertTrue(parcSafeMemory_Outstanding() == 1, + "Expected 1 outstanding allocation, actual %d", parcSafeMemory_Outstanding()); + parcSafeMemory_Deallocate(&result); + assertTrue(parcSafeMemory_Outstanding() == 0, + "Expected 0 outstanding allocations, actual %d", parcSafeMemory_Outstanding()); +} + +LONGBOW_TEST_CASE_EXPECTS(Errors, PARCSafeMemory_Deallocate_Underrun, .event = &LongBowTrapUnexpectedStateEvent) +{ + size_t expectedSize = sizeof(void *) * 2; + void *memory = parcSafeMemory_Allocate(expectedSize); + assertTrue(_parcSafeMemory_GetState(memory) == PARCSafeMemoryState_OK, + "Memory did not validate."); + + for (int i = -2; i < (int) expectedSize; i++) { + ((unsigned char *) memory)[i] = (unsigned char) i; + } + + assertTrue(_parcSafeMemory_GetState(memory) == PARCSafeMemoryState_UNDERRUN, + "Memory did not underrun."); + + assertTrue(parcSafeMemory_Outstanding() != 0, + "No memory allocated!"); + PARCSafeMemoryState state = _parcSafeMemory_GetState(memory); + parcSafeMemory_Deallocate(&memory); + + assertTrue(state == PARCSafeMemoryState_UNDERRUN, + "Expected memory to be underrun"); +} + +LONGBOW_TEST_CASE_EXPECTS(Errors, PARCSafeMemory_Deallocate_Overrun, .event = &LongBowTrapUnexpectedStateEvent) +{ + size_t expectedSize = 100; + void *memory = parcSafeMemory_Allocate(expectedSize); + assertTrue(_parcSafeMemory_GetState(memory) == PARCSafeMemoryState_OK, + "Memory did not validate."); + + for (unsigned char i = 0; i < expectedSize + 5; i++) { + ((unsigned char *) memory)[i] = i; + } + + assertTrue(parcSafeMemory_Outstanding() != 0, + "No memory allocated!"); + assertTrue(_parcSafeMemory_GetState(memory) != PARCSafeMemoryState_OK, + "Expected not OK, actual %s", _parcSafeMemory_StateToString(_parcSafeMemory_GetState(memory))); + // this is expected to fail + parcSafeMemory_Deallocate(&memory); +} + +LONGBOW_TEST_FIXTURE_OPTIONS(Performance, .enabled = false) +{ + LONGBOW_RUN_TEST_CASE(Performance, parcSafeMemory_AllocateDeallocate_1000000_WorstCase); + LONGBOW_RUN_TEST_CASE(Performance, parcSafeMemory_AllocateDeallocate_1000000_BestCase); + + LONGBOW_RUN_TEST_CASE(Performance, _computeUsableMemoryLength); +} + +LONGBOW_TEST_FIXTURE_SETUP(Performance) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Performance) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +void *memory[1000000]; + +LONGBOW_TEST_CASE(Performance, parcSafeMemory_AllocateDeallocate_1000000_WorstCase) +{ + size_t size = 100; + + for (int i = 0; i < sizeof(memory) / sizeof(memory[0]); i++) { + memory[i] = parcSafeMemory_Allocate(size); + } + for (int i = 0; i < sizeof(memory) / sizeof(memory[0]); i++) { + parcSafeMemory_Deallocate(&memory[i]); + } +} + +LONGBOW_TEST_CASE(Performance, parcSafeMemory_AllocateDeallocate_1000000_BestCase) +{ + size_t size = 100; + + for (int i = 0; i < sizeof(memory) / sizeof(memory[0]); i++) { + memory[i] = parcSafeMemory_Allocate(size); + } + + int i = sizeof(memory) / sizeof(memory[0]); + do { + i--; + parcSafeMemory_Deallocate(&memory[i]); + } while (i > 0); +} + +LONGBOW_TEST_CASE(Performance, _computeUsableMemoryLength) +{ + for (int i = 0; i < 100000000; i++) { + size_t alignment = sizeof(void *); + size_t requestedLength = 10; + _computeUsableMemoryLength(requestedLength, alignment); + } +} + +int +main(int argc, char *argv[argc]) +{ + LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(safetyMemory); + int exitStatus = LONGBOW_TEST_MAIN(argc, argv, testRunner); + longBowTestRunner_Destroy(&testRunner); + exit(exitStatus); +} |