summaryrefslogtreecommitdiffstats
path: root/libparc/parc/memory
diff options
context:
space:
mode:
Diffstat (limited to 'libparc/parc/memory')
-rw-r--r--libparc/parc/memory/parc_BufferPool.c236
-rw-r--r--libparc/parc/memory/parc_BufferPool.h344
-rw-r--r--libparc/parc/memory/test/CMakeLists.txt13
-rw-r--r--libparc/parc/memory/test/test_parc_BufferPool.c370
4 files changed, 963 insertions, 0 deletions
diff --git a/libparc/parc/memory/parc_BufferPool.c b/libparc/parc/memory/parc_BufferPool.c
new file mode 100644
index 00000000..d6695fdf
--- /dev/null
+++ b/libparc/parc/memory/parc_BufferPool.c
@@ -0,0 +1,236 @@
+/*
+ * 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 <config.h>
+
+#include <parc/algol/parc_Object.h>
+#include <parc/algol/parc_DisplayIndented.h>
+#include <parc/algol/parc_Memory.h>
+
+#include <parc/algol/parc_LinkedList.h>
+
+#include "parc_BufferPool.h"
+
+struct PARCBufferPool {
+ size_t bufferSize;
+ size_t limit;
+ size_t largestPoolSize;
+ size_t totalInstances;
+ size_t cacheHits;
+ PARCLinkedList *freeList;
+ PARCObjectDescriptor *descriptor;
+ const PARCObjectDescriptor *originalDescriptor;
+};
+
+static bool
+_parcBufferPool_Destructor(PARCBufferPool **instancePtr)
+{
+ assertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCBufferPool pointer.");
+
+ PARCBufferPool *pool = *instancePtr;
+
+ parcLinkedList_Apply(pool->freeList, (void (*))parcObject_SetDescriptor, (const void *) &PARCBuffer_Descriptor);
+
+ parcLinkedList_Release(&pool->freeList);
+ parcObjectDescriptor_Destroy(&pool->descriptor);
+
+ return true;
+}
+
+static bool
+_parcBufferPool_ObjectDestructor(PARCBuffer **bufferPtr)
+{
+ PARCBuffer *buffer = *bufferPtr;
+
+ PARCBufferPool *bufferPool = parcObjectDescriptor_GetTypeState(parcObject_GetDescriptor(buffer));
+
+ parcObject_Synchronize(bufferPool->freeList)
+ {
+ size_t freeListSize = parcLinkedList_Size(bufferPool->freeList);
+
+ if (bufferPool->limit > freeListSize) {
+ parcLinkedList_Append(bufferPool->freeList, buffer);
+ freeListSize++;
+ if (bufferPool->largestPoolSize < freeListSize) {
+ bufferPool->largestPoolSize = freeListSize;
+ }
+ } else {
+ parcBuffer_Acquire(buffer);
+ parcObject_SetDescriptor(buffer, &PARCBuffer_Descriptor);
+ parcBuffer_Release(&buffer);
+ }
+ }
+
+ *bufferPtr = 0;
+ return false;
+}
+
+parcObject_ImplementAcquire(parcBufferPool, PARCBufferPool);
+
+parcObject_ImplementRelease(parcBufferPool, PARCBufferPool);
+
+parcObject_Override(PARCBufferPool, PARCObject,
+ .destructor = (PARCObjectDestructor *) _parcBufferPool_Destructor,
+ .isLockable = true);
+
+
+void
+parcBufferPool_AssertValid(const PARCBufferPool *instance)
+{
+ assertTrue(parcBufferPool_IsValid(instance),
+ "PARCBufferPool is not valid.");
+}
+
+PARCBufferPool *
+parcBufferPool_CreateExtending(const PARCObjectDescriptor *originalDescriptor, size_t limit, size_t bufferSize)
+{
+ PARCBufferPool *result = parcObject_CreateInstance(PARCBufferPool);
+
+ if (result != NULL) {
+ result->limit = limit;
+ result->totalInstances = 0;
+ result->cacheHits = 0;
+ result->largestPoolSize = 0;
+ result->bufferSize = bufferSize;
+ result->freeList = parcLinkedList_Create();
+
+ result->originalDescriptor = originalDescriptor;
+
+ char *string = parcMemory_Format("PARCBufferPool=%zu", bufferSize);
+ result->descriptor = parcObjectDescriptor_CreateExtension(result->originalDescriptor, string);
+ result->descriptor->destructor = (PARCObjectDestructor *) _parcBufferPool_ObjectDestructor;
+ result->descriptor->typeState = (PARCObjectTypeState *) result;
+ parcMemory_Deallocate(&string);
+ }
+
+ return result;
+}
+
+PARCBufferPool *
+parcBufferPool_Create(size_t limit, size_t bufferSize)
+{
+ PARCBufferPool *result = parcBufferPool_CreateExtending(&parcObject_DescriptorName(PARCBuffer), limit, bufferSize);
+
+ return result;
+}
+
+void
+parcBufferPool_Display(const PARCBufferPool *instance, int indentation)
+{
+ parcDisplayIndented_PrintLine(indentation, "PARCBufferPool@%p {", instance);
+ /* Call Display() functions for the fields here. */
+ parcDisplayIndented_PrintLine(indentation, "}");
+}
+
+bool
+parcBufferPool_IsValid(const PARCBufferPool *bufferPool)
+{
+ bool result = false;
+
+ if (bufferPool != NULL) {
+ result = parcLinkedList_IsValid(bufferPool->freeList);
+ }
+
+ return result;
+}
+
+PARCBuffer *
+parcBufferPool_GetInstance(PARCBufferPool *bufferPool)
+{
+ PARCBuffer *result = NULL;
+
+ parcObject_Synchronize(bufferPool->freeList)
+ {
+ if (parcLinkedList_Size(bufferPool->freeList) > 0) {
+ result = parcLinkedList_RemoveFirst(bufferPool->freeList);
+ bufferPool->cacheHits++;
+ } else {
+ result = parcBuffer_Allocate(bufferPool->bufferSize);
+ parcObject_SetDescriptor(result, bufferPool->descriptor);
+ }
+ bufferPool->totalInstances++;
+ }
+
+ return result;
+}
+
+size_t
+parcBufferPool_Drain(PARCBufferPool *bufferPool)
+{
+ size_t result = 0;
+
+ parcObject_Synchronize(bufferPool->freeList)
+ {
+ size_t freeListSize = parcLinkedList_Size(bufferPool->freeList);
+ if (freeListSize > bufferPool->limit) {
+ result = freeListSize - bufferPool->limit;
+ for (size_t i = bufferPool->limit; i < freeListSize; i++) {
+ PARCObject *object = parcLinkedList_RemoveLast(bufferPool->freeList);
+ parcObject_SetDescriptor(object, &PARCBuffer_Descriptor);
+ parcObject_Release(&object);
+ }
+ }
+ }
+
+ return result;
+}
+
+size_t
+parcBufferPool_SetLimit(PARCBufferPool *bufferPool, size_t limit)
+{
+ size_t oldLimit = bufferPool->limit;
+
+ if (limit < bufferPool->limit) {
+ bufferPool->largestPoolSize = bufferPool->limit;
+ }
+
+ bufferPool->limit = limit;
+
+ return oldLimit;
+}
+
+size_t
+parcBufferPool_GetLimit(const PARCBufferPool *bufferPool)
+{
+ return bufferPool->limit;
+}
+
+size_t
+parcBufferPool_GetCurrentPoolSize(const PARCBufferPool *bufferPool)
+{
+ size_t result = parcLinkedList_Size(bufferPool->freeList);
+
+ return result;
+}
+
+size_t
+parcBufferPool_GetLargestPoolSize(const PARCBufferPool *bufferPool)
+{
+ return bufferPool->largestPoolSize;
+}
+
+size_t
+parcBufferPool_GetTotalInstances(const PARCBufferPool *bufferPool)
+{
+ return bufferPool->totalInstances;
+}
+
+size_t
+parcBufferPool_GetCacheHits(const PARCBufferPool *bufferPool)
+{
+ return bufferPool->cacheHits;
+}
diff --git a/libparc/parc/memory/parc_BufferPool.h b/libparc/parc/memory/parc_BufferPool.h
new file mode 100644
index 00000000..33028920
--- /dev/null
+++ b/libparc/parc/memory/parc_BufferPool.h
@@ -0,0 +1,344 @@
+/*
+ * 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.
+ */
+
+/**
+ * @file parc_BufferPool.h
+ * @ingroup memory
+ * @brief A simple pool of uniformly sized PARCBuffer instances.
+ *
+ * The client uses `parcBufferPool_GetInstance` to obtain instances which are placed attempted to be placed
+ * into the pool when the `PARCBuffer_Release` function is called.
+ * The pool has a maxmimum number of instances that it will cache.
+ *
+ */
+#ifndef PARCLibrary_parc_BufferPool
+#define PARCLibrary_parc_BufferPool
+#include <stdbool.h>
+
+#include <parc/algol/parc_Object.h>
+
+parcObject_Declare(PARCBufferPool);
+
+/**
+ * Increase the number of references to a `PARCBufferPool` instance.
+ *
+ * Note that new `PARCBufferPool` is not created,
+ * only that the given `PARCBufferPool` reference count is incremented.
+ * Discard the reference by invoking `parcBufferPool_Release`.
+ *
+ * @param [in] instance A pointer to a valid PARCBufferPool instance.
+ *
+ * @return The same value as the parameter @p instance.
+ *
+ * Example:
+ * @code
+ * {
+ * PARCBufferPool *a = parcBufferPool_Create(5, 10);
+ *
+ * PARCBufferPool *b = parcBufferPool_Acquire(a);
+ *
+ * parcBufferPool_Release(&a);
+ * parcBufferPool_Release(&b);
+ * }
+ * @endcode
+ */
+PARCBufferPool *parcBufferPool_Acquire(const PARCBufferPool *instance);
+
+#ifdef PARCLibrary_DISABLE_VALIDATION
+# define parcBufferPool_OptionalAssertValid(_instance_)
+#else
+# define parcBufferPool_OptionalAssertValid(_instance_) parcBufferPool_AssertValid(_instance_)
+#endif
+
+/**
+ * Assert that the given `PARCBufferPool` instance is valid.
+ *
+ * @param [in] instance A pointer to a valid PARCBufferPool instance.
+ *
+ * Example:
+ * @code
+ * {
+ * PARCBufferPool *a = parcBufferPool_Create(5, 10);
+ *
+ * parcBufferPool_AssertValid(a);
+ *
+ * parcBufferPool_Release(&a);
+ * }
+ * @endcode
+ */
+void parcBufferPool_AssertValid(const PARCBufferPool *instance);
+
+/**
+ * Create an instance of PARCBufferPool containing instances of `PARCBuffer`.
+ *
+ * This function is equivalent to invoking
+ * @code
+ * PARCBufferPool *a = parcBufferPool_CreateExtending(&parcObject_DescriptorName(PARCBuffer), 5, 10);
+ * @endcode
+ *
+ * The value of @p limit is the maximum number of instances that the pool will cache,
+ * and @p bufferSize is the size of the `PARCBuffer` instances cached.
+ *
+ * @return non-NULL A pointer to a valid PARCBufferPool instance.
+ * @return NULL An error occurred.
+ *
+ * Example:
+ * @code
+ * {
+ * PARCBufferPool *a = parcBufferPool_Create(5, 10);
+ *
+ * parcBufferPool_Release(&a);
+ * }
+ * @endcode
+ */
+PARCBufferPool *parcBufferPool_Create(size_t limit, size_t bufferSize);
+
+/**
+ * Create an instance of PARCBufferPool containing instances of object specified by the given `PARCObjectDescriptor`.
+ *
+ * The value of @p limit is the maximum number of instances that the pool will cache,
+ * and @p bufferSize is the size of the `PARCBuffer` instances cached.
+ *
+ * This function creates a PARCBufferPool that creates and manages instances of PARCBuffer which may have been extended.
+ *
+ * @return non-NULL A pointer to a valid PARCBufferPool instance.
+ * @return NULL An error occurred.
+ *
+ * Example:
+ * @code
+ * {
+ * PARCBufferPool *a = parcBufferPool_CreateExtending(&parcObject_DescriptorName(MyPARCBuffer), 5, 10);
+ *
+ * parcBufferPool_Release(&a);
+ * }
+ * @endcode
+ */
+PARCBufferPool *parcBufferPool_CreateExtending(const PARCObjectDescriptor *originalDescriptor, size_t limit, size_t bufferSize);
+
+/**
+ * Print a human readable representation of the given `PARCBufferPool`.
+ *
+ * @param [in] instance A pointer to a valid PARCBufferPool instance.
+ * @param [in] indentation The indentation level to use for printing.
+ *
+ * Example:
+ * @code
+ * {
+ * PARCBufferPool *a = parcBufferPool_Create(5, 10);
+ *
+ * parcBufferPool_Display(a, 0);
+ *
+ * parcBufferPool_Release(&a);
+ * }
+ * @endcode
+ */
+void parcBufferPool_Display(const PARCBufferPool *instance, int indentation);
+
+/**
+ * Determine if an instance of `PARCBufferPool` is valid.
+ *
+ * Valid means the internal state of the type is consistent with its required current or future behaviour.
+ * This may include the validation of internal instances of types.
+ *
+ * @param [in] instance A pointer to a valid PARCBufferPool instance.
+ *
+ * @return true The instance is valid.
+ * @return false The instance is not valid.
+ *
+ * Example:
+ * @code
+ * {
+ * PARCBufferPool *a = parcBufferPool_Create(5, 10);
+ *
+ * if (parcBufferPool_IsValid(a)) {
+ * printf("Instance is valid.\n");
+ * }
+ *
+ * parcBufferPool_Release(&a);
+ * }
+ * @endcode
+ *
+ */
+bool parcBufferPool_IsValid(const PARCBufferPool *instance);
+
+/**
+ * Release a previously acquired reference to the given `PARCBufferPool` instance,
+ * decrementing the reference count for the instance.
+ *
+ * The pointer to the instance is set to NULL as a side-effect of this function.
+ *
+ * If the invocation causes the last reference to the instance to be released,
+ * the instance is deallocated and the instance's implementation will perform
+ * additional cleanup and release other privately held references.
+ *
+ * @param [in,out] instancePtr A pointer to a pointer to the instance to release.
+ *
+ * Example:
+ * @code
+ * {
+ * PARCBufferPool *a = parcBufferPool_Create(5, 10);
+ *
+ * parcBufferPool_Release(&a);
+ * }
+ * @endcode
+ */
+void parcBufferPool_Release(PARCBufferPool **instancePtr);
+
+/**
+ * Get an instance of a `PARCBuffer`.
+ *
+ * If the PARCBufferPool contains a cached instance, it will be returned.
+ * Otherwise a new instance will be created.
+ *
+ * Any `PARCBuffer` instance which is later released, will be a candidate for caching by the given `PARCBufferPool`.
+ *
+ * @param [in] bufferPool A pointer to a valid PARCBufferPool instance.
+ *
+ * @return non-NULL A pointer to a valid `PARCBuffer`.
+ * @return NULL An error occurred.
+ *
+ * Example:
+ * @code
+ * {
+ *
+ * PARCBufferPool *pool = parcBufferPool_Create(5, 10);
+ * ...
+ *
+ * parcBufferPool_Release(&pool);
+ * }
+ * @endcode
+ */
+PARCBuffer *parcBufferPool_GetInstance(PARCBufferPool *bufferPool);
+
+/**
+ * Set the largest number of buffers the pool will cache.
+ *
+ * If the new limit is less than the current limit, and the current pool size is greater than the new limit,
+ * the number of buffers the pool will cache will decay as they are obtained and released from the pool during use.
+ *
+ * @param [in] bufferPool A pointer to a valid PARCBufferPool instance.
+ * @param [in] limit the largest number of buffers the pool will cache.
+ *
+ * @return The previous value of the largest number of buffers the pool cached.
+ *
+ * Example:
+ * @code
+ * {
+ *
+ * PARCBufferPool *pool = parcBufferPool_Create(5, 10);
+ * ...
+ *
+ * size_t limit = parcBufferPool_SetLimit(pool, 3);
+ *
+ * parcBufferPool_Release(&pool);
+ * }
+ * @endcode
+ */
+size_t parcBufferPool_SetLimit(PARCBufferPool *bufferPool, size_t limit);
+
+/**
+ * Get the largest number of buffers the pool will cache.
+ *
+ * @param [in] bufferPool A pointer to a valid PARCBufferPool instance.
+ *
+ * @return The value of the largest number of buffers the pool will cache.
+ *
+ * Example:
+ * @code
+ * {
+ *
+ * PARCBufferPool *pool = parcBufferPool_Create(5, 10);
+ * ...
+ *
+ * size_t limit = parcBufferPool_GetLimit(pool);
+ *
+ * parcBufferPool_Release(&pool);
+ * }
+ * @endcode
+ */
+size_t parcBufferPool_GetLimit(const PARCBufferPool *bufferPool);
+
+/**
+ * Get the current number of buffers the pool has cached.
+ *
+ * The value is always greater than or equal to 0 and less than or equal to the limit.
+ *
+ * @param [in] bufferPool A pointer to a valid PARCBufferPool instance.
+ *
+ * @return the largest number of buffers the pool has ever cached.
+ *
+ * Example:
+ * @code
+ * {
+ * PARCBufferPool *pool = parcBufferPool_Create(5, 10);
+ * ...
+ *
+ * size_t poolSize = parcBufferPool_GetCurrentPoolSize(pool);
+ *
+ * parcBufferPool_Release(&pool);
+ * }
+ * @endcode
+ */
+size_t parcBufferPool_GetCurrentPoolSize(const PARCBufferPool *bufferPool);
+
+/**
+ * Get the largest number of buffers the pool has ever cached.
+ *
+ * The value is always greater than or equal to 0 and less than or equal to the limit.
+ *
+ * @param [in] bufferPool A pointer to a valid PARCBufferPool instance.
+ *
+ * @return the largest number of buffers the pool has ever cached.
+ *
+ * Example:
+ * @code
+ * {
+ * PARCBufferPool *pool = parcBufferPool_Create(5, 10);
+ * ...
+ *
+ * size_t allTimeHigh = parcBufferPool_GetLargestPoolSize(pool);
+ *
+ * parcBufferPool_Release(&pool);
+ * }
+ * @endcode
+ */
+size_t parcBufferPool_GetLargestPoolSize(const PARCBufferPool *bufferPool);
+
+/**
+ * Forcibly drain the PARCBufferPool of an excess (more than the pool's limit) `PARCBuffer` instances.
+ *
+ * The number of PARCBuffer instances can exceed the PARCBufferPool's limit if `parcBufferPool_SetLimit` is used to set the limit
+ * to less than Pool's current pool size.
+ *
+ * @param [in] bufferPool A pointer to a valid PARCBufferPool instance.
+ *
+ * @return the largest number of buffers released from the Pool's cache.
+ *
+ * Example:
+ * @code
+ * {
+ *
+ * PARCBufferPool *pool = parcBufferPool_Create(5, 10);
+ * ...
+ *
+ * size_t limit = parcBufferPool_SetLimit(pool, 3);
+ * size_t drained = parcBufferPool_Drain(pool);
+ *
+ * parcBufferPool_Release(&pool);
+ * }
+ * @endcode
+ */
+size_t parcBufferPool_Drain(PARCBufferPool *bufferPool);
+#endif
diff --git a/libparc/parc/memory/test/CMakeLists.txt b/libparc/parc/memory/test/CMakeLists.txt
new file mode 100644
index 00000000..61a5608b
--- /dev/null
+++ b/libparc/parc/memory/test/CMakeLists.txt
@@ -0,0 +1,13 @@
+set(TestsExpectedToPass
+ test_parc_BufferPool
+ )
+
+# Enable gcov output for the tests
+add_definitions(--coverage)
+set(CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS} " --coverage")
+
+foreach(test ${TestsExpectedToPass})
+ AddTest(${test})
+endforeach()
+
+
diff --git a/libparc/parc/memory/test/test_parc_BufferPool.c b/libparc/parc/memory/test/test_parc_BufferPool.c
new file mode 100644
index 00000000..b7c18d08
--- /dev/null
+++ b/libparc/parc/memory/test/test_parc_BufferPool.c
@@ -0,0 +1,370 @@
+/*
+ * 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_BufferPool.c"
+
+#include <LongBow/testing.h>
+#include <LongBow/debugging.h>
+#include <parc/algol/parc_Memory.h>
+#include <parc/algol/parc_SafeMemory.h>
+#include <parc/algol/parc_DisplayIndented.h>
+
+#include <parc/testing/parc_MemoryTesting.h>
+#include <parc/testing/parc_ObjectTesting.h>
+
+LONGBOW_TEST_RUNNER(parc_BufferPool)
+{
+ // 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(CreateAcquireRelease);
+ LONGBOW_RUN_TEST_FIXTURE(Object);
+ LONGBOW_RUN_TEST_FIXTURE(Specialization);
+}
+
+// The Test Runner calls this function once before any Test Fixtures are run.
+LONGBOW_TEST_RUNNER_SETUP(parc_BufferPool)
+{
+ parcMemory_SetInterface(&PARCSafeMemoryAsPARCMemory);
+ return LONGBOW_STATUS_SUCCEEDED;
+}
+
+// The Test Runner calls this function once after all the Test Fixtures are run.
+LONGBOW_TEST_RUNNER_TEARDOWN(parc_BufferPool)
+{
+ return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE(CreateAcquireRelease)
+{
+ LONGBOW_RUN_TEST_CASE(CreateAcquireRelease, CreateRelease);
+}
+
+LONGBOW_TEST_FIXTURE_SETUP(CreateAcquireRelease)
+{
+ return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(CreateAcquireRelease)
+{
+ if (!parcMemoryTesting_ExpectedOutstanding(0, "%s leaked memory.", longBowTestCase_GetFullName(testCase))) {
+ parcSafeMemory_ReportAllocation(1);
+ return LONGBOW_STATUS_MEMORYLEAK;
+ }
+
+ return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_CASE(CreateAcquireRelease, CreateRelease)
+{
+ PARCBufferPool *instance = parcBufferPool_Create(3, 10);
+ assertNotNull(instance, "Expected non-null result from parcBufferPool_Create();");
+
+ parcObjectTesting_AssertAcquireReleaseContract(parcBufferPool_Acquire, instance);
+
+ parcBufferPool_Release(&instance);
+ assertNull(instance, "Expected null result from parcBufferPool_Release();");
+}
+
+LONGBOW_TEST_FIXTURE(Object)
+{
+ LONGBOW_RUN_TEST_CASE(Object, parcBufferPool_Display);
+ LONGBOW_RUN_TEST_CASE(Object, parcBufferPool_IsValid);
+ LONGBOW_RUN_TEST_CASE(Object, parcBufferPool_AssertValid);
+}
+
+LONGBOW_TEST_FIXTURE_SETUP(Object)
+{
+ return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(Object)
+{
+ if (!parcMemoryTesting_ExpectedOutstanding(0, "%s mismanaged memory.", longBowTestCase_GetFullName(testCase))) {
+ return LONGBOW_STATUS_MEMORYLEAK;
+ }
+
+ return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_CASE(Object, parcBufferPool_Display)
+{
+ PARCBufferPool *instance = parcBufferPool_Create(3, 10);
+ parcBufferPool_Display(instance, 0);
+ parcBufferPool_Release(&instance);
+}
+
+LONGBOW_TEST_CASE(Object, parcBufferPool_IsValid)
+{
+ PARCBufferPool *instance = parcBufferPool_Create(3, 10);
+ assertTrue(parcBufferPool_IsValid(instance), "Expected parcBufferPool_Create to result in a valid instance.");
+
+ parcBufferPool_Release(&instance);
+ assertFalse(parcBufferPool_IsValid(instance), "Expected parcBufferPool_Release to result in an invalid instance.");
+}
+
+LONGBOW_TEST_CASE(Object, parcBufferPool_AssertValid)
+{
+ PARCBufferPool *instance = parcBufferPool_Create(3, 10);
+ parcBufferPool_AssertValid(instance);
+
+ parcBufferPool_Release(&instance);
+ assertFalse(parcBufferPool_IsValid(instance), "Expected parcBufferPool_Release to result in an invalid instance.");
+}
+
+LONGBOW_TEST_FIXTURE(Specialization)
+{
+ LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetInstance);
+ LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetLargestPoolSize);
+ LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetCurrentPoolSize);
+ LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetTotalInstances);
+ LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetCacheHits);
+ LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_GetLimit);
+ LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_SetLimit_Increasing);
+ LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_SetLimit_Decreasing);
+ LONGBOW_RUN_TEST_CASE(Specialization, parcBufferPool_Drain);
+}
+
+LONGBOW_TEST_FIXTURE_SETUP(Specialization)
+{
+ longBowTestCase_SetInt(testCase, "initialAllocations", parcMemory_Outstanding());
+ return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_FIXTURE_TEARDOWN(Specialization)
+{
+ int initialAllocations = longBowTestCase_GetInt(testCase, "initialAllocations");
+
+ if (parcMemory_Outstanding() > initialAllocations) {
+ parcSafeMemory_ReportAllocation(1);
+ return LONGBOW_STATUS_MEMORYLEAK;
+ }
+
+ return LONGBOW_STATUS_SUCCEEDED;
+}
+
+LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetInstance)
+{
+ PARCBufferPool *pool = parcBufferPool_Create(3, 10);
+
+ PARCBuffer *buffer = parcBufferPool_GetInstance(pool);
+
+ parcBuffer_AssertValid(buffer);
+ parcBuffer_Release(&buffer);
+
+ size_t largestPoolSize = parcBufferPool_GetLargestPoolSize(pool);
+
+ assertTrue(largestPoolSize == 1, "Expected the largestPoolSize to be 1, actual %zu", largestPoolSize);
+
+ parcBufferPool_Release(&pool);
+}
+
+LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetLargestPoolSize)
+{
+ PARCBufferPool *pool = parcBufferPool_Create(3, 10);
+ size_t largestPoolSize = parcBufferPool_GetLargestPoolSize(pool);
+
+ assertTrue(largestPoolSize == 0, "Expected the largestPoolSize to be 0, actual %zu", largestPoolSize);
+
+ PARCBuffer *buffer = parcBufferPool_GetInstance(pool);
+
+ parcBuffer_AssertValid(buffer);
+ parcBuffer_Release(&buffer);
+
+ largestPoolSize = parcBufferPool_GetLargestPoolSize(pool);
+
+ assertTrue(largestPoolSize == 1, "Expected the largestPoolSize to be 1, actual %zu", largestPoolSize);
+
+ parcBufferPool_Release(&pool);
+}
+
+LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetTotalInstances)
+{
+ PARCBufferPool *pool = parcBufferPool_Create(3, 10);
+ size_t totalInstances = parcBufferPool_GetTotalInstances(pool);
+
+ assertTrue(totalInstances == 0, "Expected the totalInstances to be 0, actual %zu", totalInstances);
+
+ PARCBuffer *buffer = parcBufferPool_GetInstance(pool);
+
+ parcBuffer_AssertValid(buffer);
+ parcBuffer_Release(&buffer);
+
+ totalInstances = parcBufferPool_GetTotalInstances(pool);
+
+ assertTrue(totalInstances == 1, "Expected the totalInstances to be 1, actual %zu", totalInstances);
+
+ parcBufferPool_Release(&pool);
+}
+
+LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetCacheHits)
+{
+ PARCBufferPool *pool = parcBufferPool_Create(3, 10);
+ size_t cacheHits = parcBufferPool_GetCacheHits(pool);
+
+ assertTrue(cacheHits == 0, "Expected the cacheHits to be 0, actual %zu", cacheHits);
+
+ PARCBuffer *buffer = parcBufferPool_GetInstance(pool);
+ parcBuffer_AssertValid(buffer);
+ parcBuffer_Release(&buffer);
+
+ cacheHits = parcBufferPool_GetCacheHits(pool);
+ assertTrue(cacheHits == 0, "Expected the cacheHits to be 0, actual %zu", cacheHits);
+
+ buffer = parcBufferPool_GetInstance(pool);
+ parcBuffer_AssertValid(buffer);
+ parcBuffer_Release(&buffer);
+
+ cacheHits = parcBufferPool_GetCacheHits(pool);
+ assertTrue(cacheHits == 1, "Expected the cacheHits to be 1, actual %zu", cacheHits);
+
+ parcBufferPool_Release(&pool);
+}
+
+LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetLimit)
+{
+ size_t expected = 20;
+
+ PARCBufferPool *pool = parcBufferPool_Create(expected, 10);
+ size_t limit = parcBufferPool_GetLimit(pool);
+
+ assertTrue(limit == expected, "Expected the limit to be %zu, actual %zu", expected, limit);
+ parcBufferPool_Release(&pool);
+}
+
+LONGBOW_TEST_CASE(Specialization, parcBufferPool_GetCurrentPoolSize)
+{
+ size_t expectedLimit = 3;
+
+ PARCBufferPool *pool = parcBufferPool_Create(expectedLimit, 10);
+ size_t poolSize = parcBufferPool_GetCurrentPoolSize(pool);
+
+ assertTrue(poolSize == 0, "Expected the poolSize to be 0, actual %zu", poolSize);
+
+ PARCBuffer *buffer1 = parcBufferPool_GetInstance(pool);
+ PARCBuffer *buffer2 = parcBufferPool_GetInstance(pool);
+ PARCBuffer *buffer3 = parcBufferPool_GetInstance(pool);
+ PARCBuffer *buffer4 = parcBufferPool_GetInstance(pool);
+ PARCBuffer *buffer5 = parcBufferPool_GetInstance(pool);
+
+ parcBuffer_Release(&buffer1);
+ parcBuffer_Release(&buffer2);
+ parcBuffer_Release(&buffer3);
+ parcBuffer_Release(&buffer4);
+ parcBuffer_Release(&buffer5);
+
+ poolSize = parcBufferPool_GetCurrentPoolSize(pool);
+
+ assertTrue(poolSize == expectedLimit, "Expected the poolSize to be %zu, actual %zu", expectedLimit, poolSize);
+
+ parcBufferPool_Release(&pool);
+}
+
+LONGBOW_TEST_CASE(Specialization, parcBufferPool_SetLimit_Increasing)
+{
+ size_t oldLimit = 3;
+ size_t newLimit = 5;
+
+ PARCBufferPool *pool = parcBufferPool_Create(oldLimit, 10);
+ size_t limit = parcBufferPool_GetLimit(pool);
+
+ assertTrue(limit == oldLimit, "Expected the limit to be %zu, actual %zu", oldLimit, limit);
+
+ PARCBuffer *buffer1 = parcBufferPool_GetInstance(pool);
+ PARCBuffer *buffer2 = parcBufferPool_GetInstance(pool);
+ PARCBuffer *buffer3 = parcBufferPool_GetInstance(pool);
+ parcBuffer_AssertValid(buffer1);
+ parcBuffer_AssertValid(buffer2);
+ parcBuffer_AssertValid(buffer3);
+ parcBuffer_Release(&buffer1);
+ parcBuffer_Release(&buffer2);
+ parcBuffer_Release(&buffer3);
+
+ limit = parcBufferPool_SetLimit(pool, newLimit);
+ assertTrue(limit == 3, "Expected the old limit to be %zu, actual %zu", oldLimit, limit);
+
+ size_t largestPoolSize = parcBufferPool_GetLargestPoolSize(pool);
+ assertTrue(largestPoolSize == oldLimit, "Expected largest pool size to be %zu, actual %zu", oldLimit, largestPoolSize);
+
+
+ parcBufferPool_Release(&pool);
+}
+
+LONGBOW_TEST_CASE(Specialization, parcBufferPool_SetLimit_Decreasing)
+{
+ size_t oldLimit = 3;
+ size_t newLimit = 2;
+
+ PARCBufferPool *pool = parcBufferPool_Create(oldLimit, 10);
+ size_t limit = parcBufferPool_GetLimit(pool);
+
+ assertTrue(limit == oldLimit, "Expected the limit to be %zu, actual %zu", oldLimit, limit);
+
+ PARCBuffer *buffer1 = parcBufferPool_GetInstance(pool);
+ PARCBuffer *buffer2 = parcBufferPool_GetInstance(pool);
+ PARCBuffer *buffer3 = parcBufferPool_GetInstance(pool);
+ parcBuffer_AssertValid(buffer1);
+ parcBuffer_AssertValid(buffer2);
+ parcBuffer_AssertValid(buffer3);
+ parcBuffer_Release(&buffer1);
+ parcBuffer_Release(&buffer2);
+ parcBuffer_Release(&buffer3);
+
+ limit = parcBufferPool_SetLimit(pool, newLimit);
+ assertTrue(limit == 3, "Expected the old limit to be %zu, actual %zu", oldLimit, limit);
+
+ size_t largestPoolSize = parcBufferPool_GetLargestPoolSize(pool);
+ assertTrue(largestPoolSize == oldLimit, "Expected largest pool size to be %zu, actual %zu", oldLimit, largestPoolSize);
+
+
+ parcBufferPool_Release(&pool);
+}
+
+LONGBOW_TEST_CASE(Specialization, parcBufferPool_Drain)
+{
+ size_t oldLimit = 3;
+ size_t newLimit = 2;
+
+ PARCBufferPool *pool = parcBufferPool_Create(oldLimit, 10);
+
+ PARCBuffer *buffer1 = parcBufferPool_GetInstance(pool);
+ PARCBuffer *buffer2 = parcBufferPool_GetInstance(pool);
+ PARCBuffer *buffer3 = parcBufferPool_GetInstance(pool);
+ parcBuffer_AssertValid(buffer1);
+ parcBuffer_AssertValid(buffer2);
+ parcBuffer_AssertValid(buffer3);
+ parcBuffer_Release(&buffer1);
+ parcBuffer_Release(&buffer2);
+ parcBuffer_Release(&buffer3);
+
+ size_t limit = parcBufferPool_SetLimit(pool, newLimit);
+ assertTrue(limit == oldLimit, "Expected the limit to be %zu, actual %zu", oldLimit, limit);
+
+ size_t drained = parcBufferPool_Drain(pool);
+ assertTrue(drained == 1, "Expected the drained to be 1, actual %zu", drained);
+
+ parcBufferPool_Release(&pool);
+}
+
+int
+main(int argc, char *argv[argc])
+{
+ LongBowRunner *testRunner = LONGBOW_TEST_RUNNER_CREATE(parc_BufferPool);
+ int exitStatus = longBowMain(argc, argv, testRunner, NULL);
+ longBowTestRunner_Destroy(&testRunner);
+ exit(exitStatus);
+}