1 files changed, 210 insertions, 0 deletions
diff --git a/hicn-light/src/hicn/base/test/test-pool.cc b/hicn-light/src/hicn/base/test/test-pool.cc
new file mode 100644
index 000000000..fd0d5988b
--- /dev/null
+++ b/hicn-light/src/hicn/base/test/test-pool.cc
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 2020 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 <gtest/gtest.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <netinet/in.h>
+
+extern "C" {
+#define WITH_TESTS
+#include <hicn/base/pool.h>
+}
+
+/*
+ * TODO
+ * - test max_size
+ */
+
+#define DEFAULT_SIZE 10
+
+class PoolTest : public ::testing::Test {
+protected:
+    PoolTest() { }
+    virtual ~PoolTest() { }
+
+    int *pool;
+};
+
+TEST_F(PoolTest, PoolAllocation)
+{
+    int rc;
+
+    pool_init(pool, DEFAULT_SIZE, 0);
+
+    size_t pool_size = next_pow2(DEFAULT_SIZE);
+
+    EXPECT_EQ(pool_get_alloc_size(pool), pool_size);
+
+    /* Check that free indices and bitmaps are correctly initialize */
+    off_t * fi = pool_get_free_indices(pool);
+    EXPECT_EQ(vector_len(fi), pool_size);
+    EXPECT_EQ(fi[0], (long) (pool_size - 1));
+    EXPECT_EQ(fi[pool_size - 1], 0);
+
+    /* The allocated size of the underlying vector should be the next power of two */
+    EXPECT_EQ(vector_get_alloc_size(fi), pool_size);
+
+    bitmap_t * fb = pool_get_free_bitmap(pool);
+    EXPECT_TRUE(bitmap_is_set(fb, 0));
+    EXPECT_TRUE(bitmap_is_set(fb, pool_size - 2));
+    EXPECT_TRUE(bitmap_is_set(fb, pool_size - 1));
+    EXPECT_TRUE(bitmap_is_unset(fb, pool_size));
+
+    /* Getting elements from the pool should correctly update the free indices
+     * and bitmap */
+    int * elt;
+
+    rc = pool_get(pool, elt);
+    EXPECT_GE(rc, 0);
+    EXPECT_EQ(vector_len(fi), pool_size - 1);
+    EXPECT_TRUE(bitmap_is_unset(fb, 0));
+
+    rc = pool_get(pool, elt);
+    EXPECT_GE(rc, 0);
+    EXPECT_EQ(vector_len(fi), pool_size - 2);
+    EXPECT_TRUE(bitmap_is_unset(fb, 1));
+
+    for (unsigned i = 0; i < pool_size - 4; i++) {
+        rc = pool_get(pool, elt);
+        EXPECT_GE(rc, 0);
+    }
+
+    rc = pool_get(pool, elt);
+    EXPECT_GE(rc, 0);
+    EXPECT_EQ(vector_len(fi), 1UL);
+    EXPECT_TRUE(bitmap_is_unset(fb, pool_size - 2));
+
+    rc = pool_get(pool, elt);
+    EXPECT_GE(rc, 0);
+    EXPECT_EQ(vector_len(fi), 0UL);
+    EXPECT_TRUE(bitmap_is_unset(fb, pool_size - 1));
+
+    /*
+     * Getting elements within the allocated range should not have triggered a
+     * resize
+     */
+    EXPECT_EQ(pool_len(pool), pool_size);
+
+    /*
+     * Getting elements once the allocated range has been exceeded should
+     * trigger a resize
+     */
+    rc = pool_get(pool, elt);
+    EXPECT_GE(rc, 0);
+
+    EXPECT_EQ(pool_get_alloc_size(pool), pool_size * 2);
+
+    EXPECT_EQ(pool_len(pool), pool_size + 1);
+
+    /*
+     * Doubling the size, we should have again pool_size elements free, minus 1
+     */
+    EXPECT_EQ(pool_get_free_indices_size(pool), pool_size - 1);
+
+    /*
+     * NOTE: this is wrong as there has been a realloc and the old fi
+     * pointer is now invalid
+     */
+    //EXPECT_EQ(vector_len(fi), pool_size - 1);
+
+    /* And the bitmap should also be correctly modified */
+    fb = pool_get_free_bitmap(pool);
+    EXPECT_TRUE(bitmap_is_unset(fb, pool_size));
+
+    /* Check that surrounding values are also correct */
+    EXPECT_TRUE(bitmap_is_unset(fb, pool_size - 1));
+    EXPECT_TRUE(bitmap_is_set(fb, pool_size + 1));
+
+    /* Setting elements after should through */
+
+    /* Check that free indices and bitmaps are correctly updated */
+
+    pool_free(pool);
+}
+
+TEST_F(PoolTest, PoolPut)
+{
+    pool_init(pool, DEFAULT_SIZE, 0);
+
+    int* elt;
+    pool_get(pool, elt);
+    *elt = 10;
+    pool_put(pool, elt);
+
+    pool_free(pool);
+}
+
+TEST_F(PoolTest, PoolGetForceBitmapRealloc)
+{
+    const int N = 64;
+    int *elts[N];
+    int *elt = NULL;
+    pool_init(pool, N, 0);
+
+    for (int i = 0; i < N; i++)
+        pool_get(pool, elts[i]);
+    pool_get(pool, elt);
+
+    pool_free(pool);
+}
+
+TEST_F(PoolTest, PoolGetAfterReleasing)
+{
+    int *elt1 = NULL, *elt2 = NULL, *tmp = NULL;
+    pool_init(pool, DEFAULT_SIZE, 0);
+
+    // If two elements are requested...
+    off_t id1 = pool_get(pool, elt1);
+    pool_get(pool, tmp);
+
+    // ...and the first one is released...
+    pool_put(pool, elt1);
+
+    // ...requesting a new one should return
+    // the first one (that was freed)
+    off_t id2 = pool_get(pool, elt2);
+    EXPECT_EQ(id1, id2);
+    EXPECT_EQ(elt1, elt2);
+
+    pool_free(pool);
+}
+
+TEST_F(PoolTest, PoolGetMultipleElementsAfterReleasing)
+{
+    const int N = 2;
+    int *elts[N];
+    pool_init(pool, N, 0);
+
+    for (int i = 0; i < N; i++)
+        pool_get(pool, elts[i]);
+    for (int i = 0; i < N; i++)
+        pool_put(pool, elts[i]);
+    for (int i = 0; i < N; i++)
+        pool_get(pool, elts[i]);
+
+    pool_free(pool);
+}
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}