diff options
Diffstat (limited to 'libparc/parc/algol/test/test_parc_BufferComposer.c')
| -rw-r--r-- | libparc/parc/algol/test/test_parc_BufferComposer.c | 448 |
1 files changed, 448 insertions, 0 deletions
diff --git a/libparc/parc/algol/test/test_parc_BufferComposer.c b/libparc/parc/algol/test/test_parc_BufferComposer.c new file mode 100644 index 00000000..fad9857c --- /dev/null +++ b/libparc/parc/algol/test/test_parc_BufferComposer.c @@ -0,0 +1,448 @@ +/* + * 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 the file(s) containing the functions to be tested. +// This permits internal static functions to be visible to this Test Framework. +#include "../parc_BufferComposer.c" + +#include <inttypes.h> +#include <LongBow/unit-test.h> +#include <LongBow/debugging.h> + +#include <parc/algol/parc_SafeMemory.h> +#include <parc/testing/parc_ObjectTesting.h> + +typedef struct { + uint32_t setupAllocations; + PARCBufferComposer *composer; +} TestData; + +static TestData* +commonSetup() +{ + uint32_t outstanding = parcSafeMemory_Outstanding(); + TestData *data = parcMemory_AllocateAndClear(sizeof(TestData)); + assertNotNull(data, "parcMemory_AllocateAndClear of %zu bytes returned NULL.", sizeof(TestData)); + data->setupAllocations = outstanding; + data->composer = parcBufferComposer_Create(); + return data; +} + +static uint32_t +commonTearDown(TestData *data) +{ + uint32_t setupAllocations = data->setupAllocations; + + // NOTE: The `parcBufferComposer_AssertValid_IncrementSize` invalidates this object, so we must + // restore it to a good state in order for all memory to be released correctly. + (data->composer)->incrementHeuristic = sizeof(void *); + + parcBufferComposer_Release(&(data->composer)); + parcMemory_Deallocate((void **) &data); + return parcSafeMemory_ReportAllocation(STDOUT_FILENO) - setupAllocations; +} + +LONGBOW_TEST_RUNNER(parc_BufferComposer) +{ + // The following Test Fixtures will run their corresponding Test Cases. + // Test Fixtures are run in the order specified, but all tests should be idempotent. + // Never rely on the execution order of tests or share state between them. + LONGBOW_RUN_TEST_FIXTURE(Global); +} + +// The Test Runner calls this function once before any Test Fixtures are run. +LONGBOW_TEST_RUNNER_SETUP(parc_BufferComposer) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +// The Test Runner calls this function once after all the Test Fixtures are run. +LONGBOW_TEST_RUNNER_TEARDOWN(parc_BufferComposer) +{ + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE(Global) +{ + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_Acquire); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_Allocate); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_Allocate_SizeMax); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_AssertValid); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_AssertValid_NULL); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_AssertValid_IncrementSize); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_Create); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_Equals); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_PutArray); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_PutBuffer); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_PutUint16); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_PutUint32); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_PutUint64); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_PutUint8); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_PutString); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_PutStrings); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_Format); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_PutChar); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_GetBuffer); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_CreateBuffer); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_ProduceBuffer); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_PutString_Extend); + LONGBOW_RUN_TEST_CASE(Global, parcBufferComposer_ToString); +} + +LONGBOW_TEST_FIXTURE_SETUP(Global) +{ + TestData *data = commonSetup(); + longBowTestCase_SetClipBoardData(testCase, data); + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_FIXTURE_TEARDOWN(Global) +{ + TestData *data = longBowTestCase_GetClipBoardData(testCase); + + uint32_t outstandingAllocations = commonTearDown(data); + + if (outstandingAllocations != 0) { + printf("%s leaks %d memory allocations\n", longBowTestCase_GetName(testCase), outstandingAllocations); + return LONGBOW_STATUS_MEMORYLEAK; + } + return LONGBOW_STATUS_SUCCEEDED; +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_Acquire) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + PARCBufferComposer *handle = parcBufferComposer_Acquire(composer); + + assertNotNull(handle, "Acquired PARCBufferComposer handle should be non-NULL."); + assertTrue(parcBufferComposer_Equals(composer, handle), "PARCBufferComposer instances should be equal"); + + parcBufferComposer_Release(&handle); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_Allocate) +{ + size_t size = 10; + PARCBufferComposer *composer = parcBufferComposer_Allocate(size); + PARCBuffer *buffer = parcBufferComposer_GetBuffer(composer); + + assertNotNull(composer, "PARCBufferComposer instance should be non-NULL."); + assertTrue(parcBuffer_Limit(buffer) == size, + "PARCBufferComposer instance's internal PARCBuffer limit must be %zu: %zu", size, parcBuffer_Limit(buffer)); + + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_Allocate_SizeMax) +{ + size_t size = SIZE_MAX; + PARCBufferComposer *composer = parcBufferComposer_Allocate(size); + + assertNull(composer, "PARCBufferComposer instance should be NULL."); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_AssertValid) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + assertNotNull(composer, "PARCBufferComposer instance should be non-NULL."); + parcBufferComposer_AssertValid(composer); + + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE_EXPECTS(Global, parcBufferComposer_AssertValid_NULL, .event = &LongBowTrapIllegalValue) +{ + parcBufferComposer_AssertValid(NULL); +} + +LONGBOW_TEST_CASE_EXPECTS(Global, parcBufferComposer_AssertValid_IncrementSize, .event = &LongBowTrapIllegalValue) +{ + TestData *data = longBowTestCase_GetClipBoardData(testCase); + (data->composer)->incrementHeuristic = 0; // must be >= sizeof(void *) + parcBufferComposer_AssertValid(data->composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_Create) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + assertNotNull(composer, "PARCBufferComposer instance should be non-NULL."); + + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_Equals) +{ + PARCBufferComposer *x = parcBufferComposer_Create(); + PARCBufferComposer *y = parcBufferComposer_Create(); + PARCBufferComposer *z = parcBufferComposer_Create(); + PARCBufferComposer *u = parcBufferComposer_Allocate(10); + + parcObjectTesting_AssertEqualsFunction(parcBufferComposer_Equals, x, y, z, u); + + u->incrementHeuristic = 0; + assertFalse(parcBufferComposer_Equals(x, u), "PARCBufferComposer instances should be unequal due to size increments."); + assertFalse(parcBufferComposer_Equals(x, NULL), "Equals should return false since the second parameter is NULL."); + u->incrementHeuristic = sizeof(void *); + + parcBufferComposer_Release(&x); + parcBufferComposer_Release(&y); + parcBufferComposer_Release(&z); + parcBufferComposer_Release(&u); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_ToString) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + parcBufferComposer_Format(composer, "hello %s", "world"); + + char *string = parcBufferComposer_ToString(composer); + + assertNotNull(string, "Expected non-NULL result from parcBufferComposer_ToString"); + + parcMemory_Deallocate((void **) &string); + + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_GetBuffer) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + PARCBuffer *buffer = parcBufferComposer_GetBuffer(composer); + + assertNotNull(composer, "PARCBufferComposer instance should be non-NULL."); + assertNotNull(buffer, "PARCBufferComposer instance's internal PARCBuffer should not be NULL"); + + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_PutArray) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + uint8_t string[6] = { 'h', 'e', 'l', 'l', 'o', '\0' }; + parcBufferComposer_PutArray(composer, string, 6); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + + char expected[5] = "hello"; + char *actual = parcBuffer_ToString(buffer); + assertTrue(strncmp(expected, actual, 5) == 0, "Expected strings to match. Got %s, expected %s", actual, expected); + + parcMemory_Deallocate((void **) &actual); + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_PutBuffer) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + PARCBuffer *insertee = parcBuffer_WrapCString("hello world"); + parcBufferComposer_PutBuffer(composer, insertee); + parcBuffer_Release(&insertee); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + + char expected[11] = "hello world"; + char *actual = parcBuffer_ToString(buffer); + assertTrue(strncmp(expected, actual, 11) == 0, "Expected strings to match. Got %s, expected %s", actual, expected); + + parcMemory_Deallocate((void **) &actual); + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_PutUint16) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + uint16_t val = 0x0101; + parcBufferComposer_PutUint16(composer, val); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + assertTrue(parcBuffer_GetUint16(buffer) == val, "Expected inserted uint16_t to be equal to %x, got %x", val, parcBuffer_GetUint16(buffer)); + + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_PutUint32) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + uint32_t val = 0x0101FFFF; + parcBufferComposer_PutUint32(composer, val); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + assertTrue(parcBuffer_GetUint32(buffer) == val, "Expected inserted uint32_t to be equal to %x, got %x", val, parcBuffer_GetUint32(buffer)); + + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_PutUint64) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + uint64_t val = 0x0101FFFFABCD0123; + parcBufferComposer_PutUint64(composer, val); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + assertTrue(parcBuffer_GetUint64(buffer) == val, + "Expected inserted uint64_t to be equal to %" PRIu64 ", got %" PRIu64 "", val, parcBuffer_GetUint64(buffer)); + + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_PutUint8) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + uint8_t byte = 0x01; + parcBufferComposer_PutUint8(composer, byte); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + assertTrue(parcBuffer_GetUint8(buffer) == byte, "Expected inserted byte to be equal to %x, got %x", byte, parcBuffer_GetUint8(buffer)); + + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_PutString) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + char string[14] = "Hello, World!"; + parcBufferComposer_PutString(composer, string); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + char *actual = parcBuffer_ToString(buffer); + assertTrue(strncmp(actual, string, strlen(string)) == 0, + "Expected inserted string to be equal to %s, got %s", string, actual); + + parcMemory_Deallocate((void **) &actual); + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_PutStrings) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + char string[14] = "Hello, World!"; + parcBufferComposer_PutStrings(composer, "Hello", ", ", "World!", NULL); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + char *actual = parcBuffer_ToString(buffer); + assertTrue(strncmp(actual, string, strlen(string)) == 0, "Expected inserted string to be equal to %s, got %s", string, actual); + + parcMemory_Deallocate((void **) &actual); + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_Format) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + parcBufferComposer_Format(composer, "hello %s", "world"); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + + char expected[11] = "hello world"; + char *actual = parcBuffer_ToString(buffer); + assertTrue(strncmp(expected, actual, 11) == 0, "Expected strings to match. Got %s, expected %s", actual, expected); + + parcMemory_Deallocate((void **) &actual); + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_PutChar) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + + char byte = 'a'; + parcBufferComposer_PutChar(composer, byte); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + assertTrue(parcBuffer_GetUint8(buffer) == byte, "Expected inserted char to be equal to %c, got %c", byte, parcBuffer_GetUint8(buffer)); + + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_CreateBuffer) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + parcBufferComposer_PutString(composer, "hello world"); + + PARCBuffer *buffer = parcBufferComposer_CreateBuffer(composer); + parcBuffer_Flip(buffer); // flip the buffer since it was returned in write mode + + char expected[11] = "hello world"; + char *actual = parcBuffer_ToString(buffer); + assertTrue(strncmp(expected, actual, 11) == 0, "Expected strings to match. Got %s, expected %s", actual, expected); + + parcMemory_Deallocate((void **) &actual); + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_ProduceBuffer) +{ + PARCBufferComposer *composer = parcBufferComposer_Create(); + parcBufferComposer_PutString(composer, "hello world"); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + + char expected[11] = "hello world"; + char *actual = parcBuffer_ToString(buffer); + assertTrue(strncmp(expected, actual, 11) == 0, "Expected strings to match. Got %s, expected %s", actual, expected); + + parcMemory_Deallocate((void **) &actual); + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +LONGBOW_TEST_CASE(Global, parcBufferComposer_PutString_Extend) +{ + PARCBufferComposer *composer = parcBufferComposer_Allocate(4); + parcBufferComposer_PutString(composer, "hello world"); + + PARCBuffer *buffer = parcBufferComposer_ProduceBuffer(composer); + + char expected[11] = "hello world"; + char *actual = parcBuffer_ToString(buffer); + assertTrue(strncmp(expected, actual, 11) == 0, "Expected strings to match. Got %s, expected %s", actual, expected); + + parcMemory_Deallocate((void **) &actual); + parcBuffer_Release(&buffer); + parcBufferComposer_Release(&composer); +} + +int +main(int argc, char *argv[argc]) +{ + LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_BufferComposer); + int exitStatus = LONGBOW_TEST_MAIN(argc, argv, testRunner, NULL); + longBowTestRunner_Destroy(&testRunner); + exit(exitStatus); +} |