Revision and refactor of the VPP plugin with fixes for the

packet generator. Hash table for the packet cache has been
changed with the bihash.

Co-authored-by: Mauro Sardara <msardara@cisco.com>
Signed-off-by: Luca Muscariello <muscariello@ieee.org>
Change-Id: I0e0191a9f109d37081d32cc55d577ea43533f8c0
Signed-off-by: Mauro Sardara <msardara@cisco.com>

5 files changed, 1296 insertions, 0 deletions

diff --git a/hicn-plugin/src/test/CMakeLists.txt b/hicn-plugin/src/test/CMakeLists.txt
new file mode 100644
index 000000000..89ad24fbb
--- /dev/null
+++ b/hicn-plugin/src/test/CMakeLists.txt
@@ -0,0 +1,67 @@
+# Copyright (c) 2022 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.
+
+#############################################################
+# Dependencies
+#############################################################
+
+# We need a pure C test framework for the hicn-plugin.
+include (UnityTestFrameworkImport)
+find_package(Threads REQUIRED)
+
+##############################################################
+# Test sources
+##############################################################
+list(APPEND TESTS_SRC
+  main.c
+  vpp.c
+  test_pcs.c
+)
+
+
+##############################################################
+# Link libraries
+##############################################################
+set(TEST_LIBRARIES
+  ${VPP_LIBRARIES}
+  ${UNITY_LIBRARIES}
+  ${LIBHICN_SHARED}
+  ${HICNPLUGIN_SHARED}
+  Threads::Threads
+)
+
+set (
+  LINK_FLAGS
+  "-Wl,-unresolved-symbols=ignore-all"
+)
+
+
+##############################################################
+# Build single unit test executable and add it to test list
+##############################################################
+build_executable(hicnplugin_tests
+    NO_INSTALL
+    SOURCES ${TESTS_SRC}
+    LINK_LIBRARIES
+      ${TEST_LIBRARIES}
+    INCLUDE_DIRS
+      $<TARGET_PROPERTY:${HICNPLUGIN_SHARED},INCLUDE_DIRECTORIES>
+      ${UNITY_INCLUDE_DIRS}
+    DEPENDS unity ${HICNPLUGIN_SHARED}
+    COMPONENT ${HICN_PLUGIN}
+    DEFINITIONS ${COMPILER_DEFINITIONS}
+    COMPILE_OPTIONS ${COMPILER_OPTIONS}
+    LINK_FLAGS ${LINK_FLAGS}
+)
+
+unity_add_test_internal(hicnplugin_tests)
diff --git a/hicn-plugin/src/test/main.c b/hicn-plugin/src/test/main.c
new file mode 100644
index 000000000..82caba18a
--- /dev/null
+++ b/hicn-plugin/src/test/main.c
@@ -0,0 +1,31 @@
+
+/*
+ * Copyright (c) 20022 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 <unity_fixture.h>
+#include "vpp.h"
+
+static void
+RunAllTests (void)
+{
+  RUN_TEST_GROUP (PCS);
+}
+
+int
+main (int argc, const char *argv[])
+{
+  vpp_init ();
+  return UnityMain (argc, argv, RunAllTests);
+}
\ No newline at end of file
diff --git a/hicn-plugin/src/test/test_pcs.c b/hicn-plugin/src/test/test_pcs.c
new file mode 100644
index 000000000..8e7416b8b
--- /dev/null
+++ b/hicn-plugin/src/test/test_pcs.c
@@ -0,0 +1,622 @@
+/*
+ * Copyright (c) 20022 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.
+ */
+
+#define HICN_PCS_TESTING
+#include "vpp.h"
+#include <pcs.h>
+
+#include <unity.h>
+#include <unity_fixture.h>
+
+/*
+ *  Global PCS instance common to each test
+ */
+static hicn_pit_cs_t global_pcs;
+
+TEST_GROUP (PCS);
+
+/**
+ * Default PIT elements
+ */
+#define MAX_PIT_ELEMENTS 1000000
+
+/**
+ * Default CS elements
+ */
+#define MAX_CS_ELEMENTS (MAX_PIT_ELEMENTS / 10)
+
+TEST_SETUP (PCS)
+{
+  hicn_pit_cs_t *pcs = &global_pcs;
+  hicn_pit_create (pcs, MAX_PIT_ELEMENTS, MAX_CS_ELEMENTS);
+}
+
+TEST_TEAR_DOWN (PCS)
+{
+  hicn_pit_cs_t *pcs = &global_pcs;
+  hicn_pit_destroy (pcs);
+}
+
+TEST (PCS, Create)
+{
+  hicn_pit_cs_t *pcs = &global_pcs;
+
+  // Check counters
+  TEST_ASSERT_EQUAL (0, pcs->pcs_pit_count);
+  TEST_ASSERT_EQUAL (0, pcs->pcs_cs_count);
+  TEST_ASSERT_EQUAL (0, pcs->pcs_pcs_alloc);
+  TEST_ASSERT_EQUAL (0, pcs->pcs_pcs_dealloc);
+  TEST_ASSERT_EQUAL (MAX_PIT_ELEMENTS, pcs->max_pit_size);
+  TEST_ASSERT_EQUAL (MAX_CS_ELEMENTS, pcs->policy_state.max);
+
+  printf ("PIT entry size: %lu", sizeof (hicn_pcs_entry_t));
+}
+
+TEST (PCS, Destroy)
+{
+  // Global PCS instance
+}
+
+TEST (PCS, LookupEmpty)
+{
+  hicn_pit_cs_t *pcs = &global_pcs;
+
+  hicn_name_t name;
+  int ret = hicn_name_create ("b001::abcd", 0, &name);
+  TEST_ASSERT_EQUAL (0, ret);
+
+  hicn_pcs_entry_t *pcs_entry;
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry);
+
+  TEST_ASSERT_EQUAL (HICN_ERROR_PCS_NOT_FOUND, ret);
+  TEST_ASSERT_EQUAL (NULL, pcs_entry);
+}
+
+TEST (PCS, InsertPITEntryAndLookup)
+{
+  hicn_pit_cs_t *pcs = &global_pcs;
+
+  // Add entry to the PCS
+  int ret = 0;
+
+  // Allocate name
+  hicn_name_t name;
+  hicn_name_create ("b001::1234", 0, &name);
+
+  // Create PCS entry
+  hicn_pcs_entry_t *pcs_entry;
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry);
+
+  // We will not find the entry
+  TEST_ASSERT_EQUAL (ret, HICN_ERROR_PCS_NOT_FOUND);
+  TEST_ASSERT_EQUAL (NULL, pcs_entry);
+
+  // Get a new PIT entry from the pool
+  // TODO Check if the hicn_pcs_entry_pit_get is needed here
+  pcs_entry = hicn_pcs_entry_pit_get (pcs, 0, 0);
+  TEST_ASSERT_NOT_NULL (pcs_entry);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pcs_alloc (pcs), 1);
+
+  // Insert PIT entry
+  ret = hicn_pcs_pit_insert (pcs, pcs_entry, &name);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 1);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), 0);
+
+  // Lookup PIT entry
+  hicn_pcs_entry_t *pcs_entry_ret = NULL;
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry_ret);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_NOT_NULL (pcs_entry_ret);
+  TEST_ASSERT_EQUAL (pcs_entry, pcs_entry_ret);
+
+  // Release PIT entry
+  hicn_pcs_entry_remove_lock (pcs, pcs_entry);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pcs_dealloc (pcs), 1);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 0);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), 0);
+
+  // Lookup PIT entry again, we should not find it
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry_ret);
+  TEST_ASSERT_EQUAL (HICN_ERROR_PCS_NOT_FOUND, ret);
+  TEST_ASSERT_EQUAL (NULL, pcs_entry_ret);
+}
+
+TEST (PCS, InsertCSEntryAndLookup)
+{
+  hicn_pit_cs_t *pcs = &global_pcs;
+
+  // Add entry to the PCS
+  int ret = 0;
+
+  // Allocate name
+  hicn_name_t name;
+  hicn_name_create ("b008::5555", 0, &name);
+
+  // Create PCS entry
+  hicn_pcs_entry_t *pcs_entry;
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry);
+
+  // We will not find the entry
+  TEST_ASSERT_EQUAL (ret, HICN_ERROR_PCS_NOT_FOUND);
+  TEST_ASSERT_EQUAL (NULL, pcs_entry);
+
+  // Get a buffer
+  u32 buffer_index = 198274;
+
+  // Get a new entry from the pool
+  pcs_entry = hicn_pcs_entry_cs_get (pcs, 0, buffer_index);
+  TEST_ASSERT_NOT_NULL (pcs_entry);
+  TEST_ASSERT_EQUAL (1, hicn_pcs_get_pcs_alloc (pcs));
+
+  // Insert CS entry
+  ret = hicn_pcs_cs_insert (pcs, pcs_entry, &name);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 0);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), 1);
+
+  // Lookup CS entry
+  hicn_pcs_entry_t *pcs_entry_ret = NULL;
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry_ret);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_TRUE (pcs_entry_ret->flags & HICN_PCS_ENTRY_CS_FLAG);
+  TEST_ASSERT_NOT_NULL (pcs_entry_ret);
+  TEST_ASSERT_EQUAL (pcs_entry, pcs_entry_ret);
+
+  // Release CS entry
+  hicn_pcs_entry_remove_lock (pcs, pcs_entry);
+  TEST_ASSERT_EQUAL (1, hicn_pcs_get_pcs_dealloc (pcs));
+  TEST_ASSERT_EQUAL (0, hicn_pcs_get_pit_count (pcs));
+  TEST_ASSERT_EQUAL (0, hicn_pcs_get_cs_count (pcs));
+
+  // Lookup CS entry again, we should not find it
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry_ret);
+  TEST_ASSERT_EQUAL (HICN_ERROR_PCS_NOT_FOUND, ret);
+  TEST_ASSERT_EQUAL (NULL, pcs_entry_ret);
+}
+
+TEST (PCS, PitToCS)
+{
+  hicn_pit_cs_t *pcs = &global_pcs;
+
+  // Add entry to the PCS
+  int ret = 0;
+
+  // Allocate name
+  hicn_name_t name;
+  hicn_name_create ("b001::1234", 0, &name);
+
+  // Create PCS entry
+  hicn_pcs_entry_t *pcs_entry;
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry);
+
+  // We will not find the entry
+  TEST_ASSERT_EQUAL (ret, HICN_ERROR_PCS_NOT_FOUND);
+  TEST_ASSERT_EQUAL (NULL, pcs_entry);
+
+  // Get a new entry from the pool
+  // TODO Check if the hicn_pcs_entry_pit_get is needed here
+  pcs_entry = hicn_pcs_entry_pit_get (pcs, 0, 0);
+  TEST_ASSERT_NOT_NULL (pcs_entry);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pcs_alloc (pcs), 1);
+
+  // Insert PIT entry
+  ret = hicn_pcs_pit_insert (pcs, pcs_entry, &name);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 1);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), 0);
+
+  // Lookup PIT entry
+  hicn_pcs_entry_t *pcs_entry_ret = NULL;
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry_ret);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_NOT_NULL (pcs_entry_ret);
+  TEST_ASSERT_EQUAL (pcs_entry, pcs_entry_ret);
+
+  // Found the PIT entry we inserted before.
+  // Double check is not a CS
+  TEST_ASSERT_FALSE (pcs_entry_ret->flags & HICN_PCS_ENTRY_CS_FLAG);
+
+  // Turn the PIT entry into a CS
+  hicn_pit_to_cs (pcs, pcs_entry, /* random buffer index */ 12345);
+
+  // Check counters
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 0);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), 1);
+
+  // Make sure entry is now a CS
+  TEST_ASSERT_TRUE (pcs_entry_ret->flags & HICN_PCS_ENTRY_CS_FLAG);
+}
+
+TEST (PCS, CheckCSLruConsistency)
+{
+  hicn_pit_cs_t *pcs = &global_pcs;
+
+  // Add entry to the PCS
+  int ret = 0;
+
+  // Allocate name
+  hicn_name_t name;
+  hicn_name_create ("b001::1234", 0, &name);
+
+  // Create CS entry
+  hicn_pcs_entry_t *pcs_entry;
+  // Get a new entry from the pool
+  // TODO Check if the hicn_pcs_entry_pit_get is needed here
+  pcs_entry = hicn_pcs_entry_cs_get (pcs, 0, 0);
+  TEST_ASSERT_NOT_NULL (pcs_entry);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pcs_alloc (pcs), 1);
+
+  // Insert CS entry
+  ret = hicn_pcs_cs_insert (pcs, pcs_entry, &name);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), 1);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 0);
+
+  // Get pcs_entry index
+  uint32_t pcs_entry_index = hicn_pcs_entry_get_index (pcs, pcs_entry);
+
+  // Check LRU
+  hicn_cs_policy_t *policy_state = hicn_pcs_get_policy_state (pcs);
+
+  // Make sure MAX corresponds to what we set
+  TEST_ASSERT_EQUAL (MAX_CS_ELEMENTS, hicn_cs_policy_get_max (policy_state));
+
+  TEST_ASSERT_EQUAL (pcs_entry_index, hicn_cs_policy_get_head (policy_state));
+  TEST_ASSERT_EQUAL (pcs_entry_index, hicn_cs_policy_get_tail (policy_state));
+  TEST_ASSERT_EQUAL (1, hicn_cs_policy_get_count (policy_state));
+
+  // Check pointers of the entry
+  TEST_ASSERT_EQUAL (HICN_CS_POLICY_END_OF_CHAIN,
+		     hicn_pcs_entry_cs_get_next (pcs_entry));
+  TEST_ASSERT_EQUAL (HICN_CS_POLICY_END_OF_CHAIN,
+		     hicn_pcs_entry_cs_get_prev (pcs_entry));
+
+  // Lookup the entry itself
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry);
+
+  // Check again the pointers of the entry
+  TEST_ASSERT_EQUAL (HICN_CS_POLICY_END_OF_CHAIN,
+		     hicn_pcs_entry_cs_get_next (pcs_entry));
+  TEST_ASSERT_EQUAL (HICN_CS_POLICY_END_OF_CHAIN,
+		     hicn_pcs_entry_cs_get_prev (pcs_entry));
+
+  // Remove CS entry
+  hicn_pcs_entry_remove_lock (pcs, pcs_entry);
+  TEST_ASSERT_EQUAL (1, hicn_pcs_get_pcs_dealloc (pcs));
+  TEST_ASSERT_EQUAL (0, hicn_pcs_get_pit_count (pcs));
+  TEST_ASSERT_EQUAL (0, hicn_pcs_get_cs_count (pcs));
+
+  // Check again LRU
+  TEST_ASSERT_EQUAL (HICN_CS_POLICY_END_OF_CHAIN,
+		     hicn_cs_policy_get_head (policy_state));
+  TEST_ASSERT_EQUAL (HICN_CS_POLICY_END_OF_CHAIN,
+		     hicn_cs_policy_get_tail (policy_state));
+  TEST_ASSERT_EQUAL (0, hicn_cs_policy_get_count (policy_state));
+
+  // Let's insert now 2 entries
+  hicn_pcs_entry_t *pcs_entry0;
+  hicn_pcs_entry_t *pcs_entry1;
+
+  pcs_entry0 = hicn_pcs_entry_cs_get (pcs, 0, 0);
+  TEST_ASSERT_NOT_NULL (pcs_entry0);
+  hicn_name_t name0;
+  hicn_name_create ("b001::abcd", 123, &name0);
+  u32 index0 = hicn_pcs_entry_get_index (pcs, pcs_entry0);
+
+  pcs_entry1 = hicn_pcs_entry_cs_get (pcs, 0, 0);
+  TEST_ASSERT_NOT_NULL (pcs_entry1);
+  hicn_name_t name1;
+  hicn_name_create ("b001::9999", 321, &name1);
+  u32 index1 = hicn_pcs_entry_get_index (pcs, pcs_entry1);
+
+  // Insert CS entry
+  ret = hicn_pcs_cs_insert (pcs, pcs_entry0, &name0);
+  ret = hicn_pcs_cs_insert (pcs, pcs_entry1, &name1);
+
+  // Check LRU. index1 was inserted last, so it should be at the head
+  TEST_ASSERT_EQUAL (index1, hicn_cs_policy_get_head (policy_state));
+  // index0 was inserted first, so it should be at the tail
+  TEST_ASSERT_EQUAL (index0, hicn_cs_policy_get_tail (policy_state));
+  // And count shoould be 2
+  TEST_ASSERT_EQUAL (2, hicn_cs_policy_get_count (policy_state));
+
+  // Check pointers of the entries
+
+  // pcs_entry0 should be at the tail
+  TEST_ASSERT_EQUAL (HICN_CS_POLICY_END_OF_CHAIN,
+		     hicn_pcs_entry_cs_get_next (pcs_entry0));
+  TEST_ASSERT_EQUAL (index1, hicn_pcs_entry_cs_get_prev (pcs_entry0));
+
+  // pcs_entry1 should be at the head
+  TEST_ASSERT_EQUAL (index0, hicn_pcs_entry_cs_get_next (pcs_entry1));
+  TEST_ASSERT_EQUAL (HICN_CS_POLICY_END_OF_CHAIN,
+		     hicn_pcs_entry_cs_get_prev (pcs_entry1));
+
+  // Let's lookup for entry 0 and check if the LRU is updated correctly
+  ret = hicn_pcs_lookup_one (pcs, &name0, &pcs_entry);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_EQUAL (index0, hicn_pcs_entry_get_index (pcs, pcs_entry));
+
+  // Check pointers of the entries
+
+  // pcs_entry1 should be at the tail
+  TEST_ASSERT_EQUAL (HICN_CS_POLICY_END_OF_CHAIN,
+		     hicn_pcs_entry_cs_get_next (pcs_entry1));
+  TEST_ASSERT_EQUAL (index0, hicn_pcs_entry_cs_get_prev (pcs_entry1));
+
+  // pcs_entry0 should be at the head
+  TEST_ASSERT_EQUAL (index1, hicn_pcs_entry_cs_get_next (pcs_entry0));
+  TEST_ASSERT_EQUAL (HICN_CS_POLICY_END_OF_CHAIN,
+		     hicn_pcs_entry_cs_get_prev (pcs_entry0));
+
+  // index0 should be now the head
+  TEST_ASSERT_EQUAL (index0, hicn_cs_policy_get_head (policy_state));
+  // index1 should be now the tail
+  TEST_ASSERT_EQUAL (index1, hicn_cs_policy_get_tail (policy_state));
+}
+
+TEST (PCS, CheckCSLruMax)
+{
+  hicn_pit_cs_t *pcs = &global_pcs;
+  int i, ret = 0;
+  ;
+  u32 pcs_entry_index = 0;
+  u32 pcs_entry_index0 = 0;
+  u32 pcs_entry_index1 = 0;
+  hicn_pcs_entry_t *pcs_entry = NULL;
+  hicn_name_t name;
+
+  const hicn_cs_policy_t *policy_state = hicn_pcs_get_policy_state (pcs);
+
+  for (i = 0; i < MAX_CS_ELEMENTS; i++)
+    {
+      // Allocate name
+      ret = hicn_name_create ("b004::aaaa", i, &name);
+      TEST_ASSERT_EQUAL (0, ret);
+
+      // Create CS entry
+      // Get a new entry from the pool
+      // TODO Check if the hicn_pcs_entry_pit_get is needed here
+      pcs_entry = hicn_pcs_entry_cs_get (pcs, 0, i);
+      TEST_ASSERT_NOT_NULL (pcs_entry);
+      TEST_ASSERT_EQUAL (i + 1, hicn_pcs_get_pcs_alloc (pcs));
+
+      pcs_entry_index = hicn_pcs_entry_get_index (pcs, pcs_entry);
+
+      if (i == 0)
+	{
+	  pcs_entry_index0 = pcs_entry_index;
+	}
+
+      if (i == 1)
+	{
+	  pcs_entry_index1 = pcs_entry_index;
+	}
+
+      // Insert CS entry
+      ret = hicn_pcs_cs_insert (pcs, pcs_entry, &name);
+      TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+      TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), i + 1);
+      TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 0);
+
+      // Check LRU
+      TEST_ASSERT_EQUAL (pcs_entry_index,
+			 hicn_cs_policy_get_head (policy_state));
+      TEST_ASSERT_EQUAL (pcs_entry_index0,
+			 hicn_cs_policy_get_tail (policy_state));
+      TEST_ASSERT_EQUAL (i + 1, hicn_cs_policy_get_count (policy_state));
+    }
+
+  // In this moment the CS should be full
+  TEST_ASSERT_EQUAL (hicn_cs_policy_get_max (policy_state),
+		     hicn_cs_policy_get_count (policy_state));
+
+  // Next insertion should:
+  // - evict the tail
+  // - update the head
+  // - make a coffee because I am tired
+  ret = hicn_name_create ("b004::aaaa", i, &name);
+  TEST_ASSERT_EQUAL (0, ret);
+
+  pcs_entry = hicn_pcs_entry_cs_get (pcs, 0, i);
+  TEST_ASSERT_NOT_NULL (pcs_entry);
+  TEST_ASSERT_EQUAL (i + 1, hicn_pcs_get_pcs_alloc (pcs));
+
+  pcs_entry_index = hicn_pcs_entry_get_index (pcs, pcs_entry);
+
+  // Insert CS entry
+  ret = hicn_pcs_cs_insert (pcs, pcs_entry, &name);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), i);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 0);
+
+  // Check LRU
+  TEST_ASSERT_EQUAL (pcs_entry_index, hicn_cs_policy_get_head (policy_state));
+  // pcs_entry_index1 should be have eveicted, and pcs_entry_index1 should be
+  // the tail
+  TEST_ASSERT_EQUAL (pcs_entry_index1, hicn_cs_policy_get_tail (policy_state));
+
+  // Make pcs_entry_index0 was freed.
+  TEST_ASSERT_TRUE (
+    pool_is_free_index (pcs->pcs_entries_pool, pcs_entry_index0));
+}
+
+TEST (PCS, AddIngressFacesToPITEntry)
+{
+  hicn_pit_cs_t *pcs = &global_pcs;
+
+  // Add entry to the PCS
+  int ret = 0;
+
+  // Allocate name
+  hicn_name_t name;
+  hicn_name_create ("b001::9876", 0, &name);
+
+  // Create PCS entry
+  hicn_pcs_entry_t *pcs_entry;
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry);
+
+  // We will not find the entry
+  TEST_ASSERT_EQUAL (ret, HICN_ERROR_PCS_NOT_FOUND);
+  TEST_ASSERT_EQUAL (NULL, pcs_entry);
+
+  // Get a new entry from the pool
+  // TODO Check if the hicn_pcs_entry_pit_get is needed here
+  f64 tnow = 10.0;
+  pcs_entry = hicn_pcs_entry_pit_get (pcs, tnow, 0);
+  TEST_ASSERT_NOT_NULL (pcs_entry);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pcs_alloc (pcs), 1);
+
+  const u32 faceid = 20;
+
+  // The face should not be in the PIT entry
+  TEST_ASSERT_EQUAL (0, hicn_pcs_entry_pit_search (pcs_entry, faceid));
+
+  // Add ingress face to pit entry
+  hicn_pcs_entry_pit_add_face (pcs_entry, faceid);
+
+  // Insert PIT entry
+  ret = hicn_pcs_pit_insert (pcs, pcs_entry, &name);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 1);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), 0);
+
+  // Lookup PIT entry
+  hicn_pcs_entry_t *pcs_entry_ret = NULL;
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry_ret);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_NOT_NULL (pcs_entry_ret);
+  TEST_ASSERT_EQUAL (pcs_entry, pcs_entry_ret);
+
+  // Check everything is fine
+  ret = hicn_pcs_entry_pit_search (pcs_entry_ret, faceid);
+  // Face 20 should be in the entry
+  TEST_ASSERT_EQUAL (ret, 1);
+
+  // Get faces and make sure
+  // - there is only one face
+  // - the face is 20
+  TEST_ASSERT_EQUAL (1, hicn_pcs_entry_pit_get_n_faces (pcs_entry_ret));
+  TEST_ASSERT_EQUAL (20, hicn_pcs_entry_pit_get_dpo_face (pcs_entry_ret, 0));
+
+  // Release PIT entry
+  hicn_pcs_entry_remove_lock (pcs, pcs_entry_ret);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pcs_dealloc (pcs), 1);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 0);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), 0);
+
+  // Lookup PIT entry again, we should not find it
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry_ret);
+  TEST_ASSERT_EQUAL (HICN_ERROR_PCS_NOT_FOUND, ret);
+  TEST_ASSERT_EQUAL (NULL, pcs_entry_ret);
+}
+
+TEST (PCS, AddIngressFacesToPitEntryCornerCases)
+{
+  hicn_pit_cs_t *pcs = &global_pcs;
+
+  // Add entry to the PCS
+  int ret = 0;
+
+  // Allocate name
+  hicn_name_t name;
+  hicn_name_create ("b001::9876", 0, &name);
+
+  // Create PCS entry
+  hicn_pcs_entry_t *pcs_entry;
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry);
+
+  // We will not find the entry
+  TEST_ASSERT_EQUAL (ret, HICN_ERROR_PCS_NOT_FOUND);
+  TEST_ASSERT_EQUAL (NULL, pcs_entry);
+
+  // Get a new entry from the pool
+  // TODO Check if the hicn_pcs_entry_pit_get is needed here
+  f64 tnow = 10.0;
+  pcs_entry = hicn_pcs_entry_pit_get (pcs, tnow, 0);
+  TEST_ASSERT_NOT_NULL (pcs_entry);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pcs_alloc (pcs), 1);
+
+  // Let's initialize HICN_FACE_DB_INLINE_FACES + 1 face IDs
+  u32 faceids[HICN_FACE_DB_INLINE_FACES + 1];
+  for (u32 i = 0; i < HICN_FACE_DB_INLINE_FACES + 1; i++)
+    faceids[i] = rand () % HICN_PARAM_FACES_MAX;
+
+  // The faces should not be in the PIT entry
+  for (u32 i = 0; i < HICN_FACE_DB_INLINE_FACES + 1; i++)
+    TEST_ASSERT_EQUAL (0, hicn_pcs_entry_pit_search (pcs_entry, faceids[i]));
+
+  // Add ingress faces to pit entry
+  for (u32 i = 0; i < HICN_FACE_DB_INLINE_FACES + 1; i++)
+    hicn_pcs_entry_pit_add_face (pcs_entry, faceids[i]);
+
+  // Insert PIT entry
+  ret = hicn_pcs_pit_insert (pcs, pcs_entry, &name);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 1);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), 0);
+
+  // Lookup PIT entry
+  hicn_pcs_entry_t *pcs_entry_ret = NULL;
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry_ret);
+  TEST_ASSERT_EQUAL (HICN_ERROR_NONE, ret);
+  TEST_ASSERT_NOT_NULL (pcs_entry_ret);
+  TEST_ASSERT_EQUAL (pcs_entry, pcs_entry_ret);
+
+  // Check everything is fine
+  for (u32 i = 0; i < HICN_FACE_DB_INLINE_FACES + 1; i++)
+    {
+      ret = hicn_pcs_entry_pit_search (pcs_entry_ret, faceids[i]);
+      // Face 20 should be in the entry
+      TEST_ASSERT_EQUAL (1, ret);
+    }
+
+  // Get faces and make sure
+  // - there are HICN_FACE_DB_INLINE_FACES + 1 faces
+  // - the first HICN_FACE_DB_INLINE_FACES are stored in the PIT entry
+  // - the face HICN_FACE_DB_INLINE_FACES + 1 is stored in the array of
+  // additional faces, so outside PIT entry
+  TEST_ASSERT_EQUAL (HICN_FACE_DB_INLINE_FACES + 1,
+		     hicn_pcs_entry_pit_get_n_faces (pcs_entry_ret));
+  for (u32 i = 0; i < HICN_FACE_DB_INLINE_FACES + 1; i++)
+    TEST_ASSERT_EQUAL (faceids[i],
+		       hicn_pcs_entry_pit_get_dpo_face (pcs_entry_ret, i));
+
+  // Release PIT entry
+  hicn_pcs_entry_remove_lock (pcs, pcs_entry_ret);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pcs_dealloc (pcs), 1);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_pit_count (pcs), 0);
+  TEST_ASSERT_EQUAL (hicn_pcs_get_cs_count (pcs), 0);
+
+  // Lookup PIT entry again, we should not find it
+  ret = hicn_pcs_lookup_one (pcs, &name, &pcs_entry_ret);
+  TEST_ASSERT_EQUAL (HICN_ERROR_PCS_NOT_FOUND, ret);
+  TEST_ASSERT_EQUAL (NULL, pcs_entry_ret);
+}
+
+TEST_GROUP_RUNNER (PCS)
+{
+  RUN_TEST_CASE (PCS, Create)
+  RUN_TEST_CASE (PCS, Destroy)
+  RUN_TEST_CASE (PCS, LookupEmpty)
+  RUN_TEST_CASE (PCS, InsertPITEntryAndLookup)
+  RUN_TEST_CASE (PCS, InsertCSEntryAndLookup)
+  RUN_TEST_CASE (PCS, PitToCS)
+  RUN_TEST_CASE (PCS, CheckCSLruConsistency)
+  RUN_TEST_CASE (PCS, CheckCSLruMax)
+  RUN_TEST_CASE (PCS, AddIngressFacesToPITEntry)
+  RUN_TEST_CASE (PCS, AddIngressFacesToPitEntryCornerCases)
+}
diff --git a/hicn-plugin/src/test/vpp.c b/hicn-plugin/src/test/vpp.c
new file mode 100644
index 000000000..fc96e6e16
--- /dev/null
+++ b/hicn-plugin/src/test/vpp.c
@@ -0,0 +1,555 @@
+/*
+ * Copyright (c) 2022 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.
+ */
+
+#define _GNU_SOURCE
+#include <pthread.h>
+#include <sched.h>
+
+#include <vppinfra/cpu.h>
+#include <vlib/vlib.h>
+#include <vlib/unix/unix.h>
+#include <vlib/threads.h>
+#include <vnet/plugin/plugin.h>
+#include <vnet/ethernet/ethernet.h>
+#include <vpp/vnet/config.h>
+#include <vlibmemory/memclnt.api_enum.h> /* To get the last static message id */
+#include <limits.h>
+
+/*
+ * Load plugins from /usr/lib/vpp_plugins by default
+ */
+char *vlib_plugin_path = NULL;
+char *vat_plugin_path = NULL;
+
+static void
+vpp_find_plugin_path ()
+{
+  extern char *vat_plugin_path;
+  char *p, path[PATH_MAX];
+  int rv;
+  u8 *s;
+
+  /* find executable path */
+  if ((rv = readlink ("/proc/self/exe", path, PATH_MAX - 1)) == -1)
+    return;
+
+  /* readlink doesn't provide null termination */
+  path[rv] = 0;
+
+  /* strip filename */
+  if ((p = strrchr (path, '/')) == 0)
+    return;
+  *p = 0;
+
+  /* strip bin/ */
+  if ((p = strrchr (path, '/')) == 0)
+    return;
+  *p = 0;
+
+  s = format (0, "%s/" CLIB_LIB_DIR "/vpp_plugins", path, path);
+  vec_add1 (s, 0);
+  vlib_plugin_path = (char *) s;
+
+  s = format (0, "%s/" CLIB_LIB_DIR "/vpp_api_test_plugins", path, path);
+  vec_add1 (s, 0);
+  vat_plugin_path = (char *) s;
+}
+
+static void
+vpe_main_init (vlib_main_t *vm)
+{
+#if VPP_API_TEST_BUILTIN > 0
+  void vat_plugin_hash_create (void);
+#endif
+
+  if (CLIB_DEBUG > 0)
+    vlib_unix_cli_set_prompt ("DBGvpp# ");
+  else
+    vlib_unix_cli_set_prompt ("vpp# ");
+
+  /* Turn off network stack components which we don't want */
+  vlib_mark_init_function_complete (vm, srp_init);
+
+  /*
+   * Create the binary api plugin hashes before loading plugins
+   */
+#if VPP_API_TEST_BUILTIN > 0
+  vat_plugin_hash_create ();
+#endif
+
+  if (!vlib_plugin_path)
+    vpp_find_plugin_path ();
+}
+
+/*
+ * Default path for runtime data
+ */
+char *vlib_default_runtime_dir = "vpp";
+
+int
+vpp_init_internal (int argc, char *argv[])
+{
+  int i;
+  void vl_msg_api_set_first_available_msg_id (u16);
+  uword main_heap_size = (1ULL << 30);
+  u8 *sizep;
+  u32 size;
+  clib_mem_page_sz_t main_heap_log2_page_sz = CLIB_MEM_PAGE_SZ_DEFAULT;
+  clib_mem_page_sz_t default_log2_hugepage_sz = CLIB_MEM_PAGE_SZ_UNKNOWN;
+  unformat_input_t input, sub_input;
+  u8 *s = 0, *v = 0;
+  int main_core = 1;
+  cpu_set_t cpuset;
+  void *main_heap;
+
+#if __x86_64__
+  CLIB_UNUSED (const char *msg) =
+    "ERROR: This binary requires CPU with %s extensions.\n";
+#define _(a, b)                                                               \
+  if (!clib_cpu_supports_##a ())                                              \
+    {                                                                         \
+      fprintf (stderr, msg, b);                                               \
+      exit (1);                                                               \
+    }
+
+#if __AVX2__
+  _ (avx2, "AVX2")
+#endif
+#if __AVX__
+  _ (avx, "AVX")
+#endif
+#if __SSE4_2__
+  _ (sse42, "SSE4.2")
+#endif
+#if __SSE4_1__
+  _ (sse41, "SSE4.1")
+#endif
+#if __SSSE3__
+  _ (ssse3, "SSSE3")
+#endif
+#if __SSE3__
+  _ (sse3, "SSE3")
+#endif
+#undef _
+#endif
+  /*
+   * Load startup config from file.
+   * usage: vpp -c /etc/vpp/startup.conf
+   */
+  if ((argc == 3) && !strncmp (argv[1], "-c", 2))
+    {
+      FILE *fp;
+      char inbuf[4096];
+      int argc_ = 1;
+      char **argv_ = NULL;
+      char *arg = NULL;
+      char *p;
+
+      fp = fopen (argv[2], "r");
+      if (fp == NULL)
+	{
+	  fprintf (stderr, "open configuration file '%s' failed\n", argv[2]);
+	  return 1;
+	}
+      argv_ = calloc (1, sizeof (char *));
+      if (argv_ == NULL)
+	{
+	  fclose (fp);
+	  return 1;
+	}
+      arg = strndup (argv[0], 1024);
+      if (arg == NULL)
+	{
+	  fclose (fp);
+	  free (argv_);
+	  return 1;
+	}
+      argv_[0] = arg;
+
+      while (1)
+	{
+	  if (fgets (inbuf, 4096, fp) == 0)
+	    break;
+	  p = strtok (inbuf, " \t\n");
+	  while (p != NULL)
+	    {
+	      if (*p == '#')
+		break;
+	      argc_++;
+	      char **tmp = realloc (argv_, argc_ * sizeof (char *));
+	      if (tmp == NULL)
+		return 1;
+	      argv_ = tmp;
+	      arg = strndup (p, 1024);
+	      if (arg == NULL)
+		return 1;
+	      argv_[argc_ - 1] = arg;
+	      p = strtok (NULL, " \t\n");
+	    }
+	}
+
+      fclose (fp);
+
+      char **tmp = realloc (argv_, (argc_ + 1) * sizeof (char *));
+      if (tmp == NULL)
+	return 1;
+      argv_ = tmp;
+      argv_[argc_] = NULL;
+
+      argc = argc_;
+      argv = argv_;
+    }
+
+  /*
+   * Look for and parse the "heapsize" config parameter.
+   * Manual since none of the clib infra has been bootstrapped yet.
+   *
+   * Format: heapsize <nn>[mM][gG]
+   */
+
+  for (i = 1; i < (argc - 1); i++)
+    {
+      if (!strncmp (argv[i], "plugin_path", 11))
+	{
+	  if (i < (argc - 1))
+	    vlib_plugin_path = argv[++i];
+	}
+      if (!strncmp (argv[i], "test_plugin_path", 16))
+	{
+	  if (i < (argc - 1))
+	    vat_plugin_path = argv[++i];
+	}
+      else if (!strncmp (argv[i], "heapsize", 8))
+	{
+	  sizep = (u8 *) argv[i + 1];
+	  size = 0;
+	  while (*sizep >= '0' && *sizep <= '9')
+	    {
+	      size *= 10;
+	      size += *sizep++ - '0';
+	    }
+	  if (size == 0)
+	    {
+	      fprintf (
+		stderr,
+		"warning: heapsize parse error '%s', use default %lld\n",
+		argv[i], (long long int) main_heap_size);
+	      goto defaulted;
+	    }
+
+	  main_heap_size = size;
+
+	  if (*sizep == 'g' || *sizep == 'G')
+	    main_heap_size <<= 30;
+	  else if (*sizep == 'm' || *sizep == 'M')
+	    main_heap_size <<= 20;
+	}
+      else if (!strncmp (argv[i], "main-core", 9))
+	{
+	  if (i < (argc - 1))
+	    {
+	      errno = 0;
+	      unsigned long x = strtol (argv[++i], 0, 0);
+	      if (errno == 0)
+		main_core = x;
+	    }
+	}
+    }
+defaulted:
+
+  /* temporary heap */
+  clib_mem_init (0, 1 << 20);
+  unformat_init_command_line (&input, (char **) argv);
+
+  while (unformat_check_input (&input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (&input, "memory %v", &v))
+	{
+	  unformat_init_vector (&sub_input, v);
+	  v = 0;
+	  while (unformat_check_input (&sub_input) != UNFORMAT_END_OF_INPUT)
+	    {
+	      if (unformat (&sub_input, "main-heap-size %U",
+			    unformat_memory_size, &main_heap_size))
+		;
+	      else if (unformat (&sub_input, "main-heap-page-size %U",
+				 unformat_log2_page_size,
+				 &main_heap_log2_page_sz))
+		;
+	      else if (unformat (&sub_input, "default-hugepage-size %U",
+				 unformat_log2_page_size,
+				 &default_log2_hugepage_sz))
+		;
+	      else
+		{
+		  fformat (stderr, "unknown 'memory' config input '%U'\n",
+			   format_unformat_error, &sub_input);
+		  exit (1);
+		}
+	    }
+	  unformat_free (&sub_input);
+	}
+      else if (!unformat (&input, "%s %v", &s, &v))
+	break;
+
+      vec_reset_length (s);
+      vec_reset_length (v);
+    }
+  vec_free (s);
+  vec_free (v);
+
+  unformat_free (&input);
+
+  /* set process affinity for main thread */
+  CPU_ZERO (&cpuset);
+  CPU_SET (main_core, &cpuset);
+  pthread_setaffinity_np (pthread_self (), sizeof (cpu_set_t), &cpuset);
+
+  /* Set up the plugin message ID allocator right now... */
+  vl_msg_api_set_first_available_msg_id (VL_MSG_MEMCLNT_LAST + 1);
+
+  /* destroy temporary heap and create main one */
+  clib_mem_destroy ();
+
+  if ((main_heap = clib_mem_init_with_page_size (main_heap_size,
+						 main_heap_log2_page_sz)))
+    {
+      /* Figure out which numa runs the main thread */
+      __os_numa_index = clib_get_current_numa_node ();
+
+      if (default_log2_hugepage_sz != CLIB_MEM_PAGE_SZ_UNKNOWN)
+	clib_mem_set_log2_default_hugepage_size (default_log2_hugepage_sz);
+
+      /* and use the main heap as that numa's numa heap */
+      clib_mem_set_per_numa_heap (main_heap);
+      vlib_main_init ();
+      vpe_main_init (vlib_get_first_main ());
+      return 0;
+    }
+  else
+    {
+      {
+	int rv __attribute__ ((unused)) =
+	  write (2, "Main heap allocation failure!\r\n", 31);
+      }
+      return 1;
+    }
+}
+
+static clib_error_t *
+memory_config (vlib_main_t *vm, unformat_input_t *input)
+{
+  return 0;
+}
+
+VLIB_CONFIG_FUNCTION (memory_config, "memory");
+
+static clib_error_t *
+heapsize_config (vlib_main_t *vm, unformat_input_t *input)
+{
+  return 0;
+}
+
+VLIB_CONFIG_FUNCTION (heapsize_config, "heapsize");
+
+static clib_error_t *
+placeholder_path_config (vlib_main_t *vm, unformat_input_t *input)
+{
+  u8 *junk;
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (input, "%s", &junk))
+	{
+	  vec_free (junk);
+	  return 0;
+	}
+      else
+	return clib_error_return (0, "unknown input '%U'",
+				  format_unformat_error, input);
+    }
+  return 0;
+}
+
+static clib_error_t *
+plugin_path_config (vlib_main_t *vm, unformat_input_t *input)
+{
+  return placeholder_path_config (vm, input);
+}
+
+VLIB_CONFIG_FUNCTION (plugin_path_config, "plugin_path");
+
+static clib_error_t *
+test_plugin_path_config (vlib_main_t *vm, unformat_input_t *input)
+{
+  return placeholder_path_config (vm, input);
+}
+
+VLIB_CONFIG_FUNCTION (test_plugin_path_config, "test_plugin_path");
+
+void vl_msg_api_post_mortem_dump (void);
+void vlib_post_mortem_dump (void);
+
+void
+os_panic (void)
+{
+  vl_msg_api_post_mortem_dump ();
+  vlib_post_mortem_dump ();
+  abort ();
+}
+
+void vhost_user_unmap_all (void) __attribute__ ((weak));
+void
+vhost_user_unmap_all (void)
+{
+}
+
+void
+os_exit (int code)
+{
+  static int recursion_block;
+
+  if (code)
+    {
+      if (recursion_block)
+	abort ();
+
+      recursion_block = 1;
+
+      vl_msg_api_post_mortem_dump ();
+      vlib_post_mortem_dump ();
+      vhost_user_unmap_all ();
+      abort ();
+    }
+  exit (code);
+}
+
+#ifdef BARRIER_TRACING
+void
+vl_msg_api_barrier_trace_context (const char *context)
+{
+  vlib_worker_threads[0].barrier_context = context;
+}
+#endif
+
+void
+vl_msg_api_barrier_sync (void)
+{
+  vlib_worker_thread_barrier_sync (vlib_get_main ());
+}
+
+void
+vl_msg_api_barrier_release (void)
+{
+  vlib_worker_thread_barrier_release (vlib_get_main ());
+}
+
+/* This application needs 1 thread stack for the stats pthread */
+u32
+vlib_app_num_thread_stacks_needed (void)
+{
+  return 1;
+}
+
+/*
+ * Depending on the configuration selected above,
+ * it may be necessary to generate stub graph nodes.
+ * It is never OK to ignore "node 'x' refers to unknown node 'y'
+ * messages!
+ */
+
+#include <vppinfra/bihash_8_8.h>
+
+static clib_error_t *
+show_bihash_command_fn (vlib_main_t *vm, unformat_input_t *input,
+			vlib_cli_command_t *cmd)
+{
+  int i;
+  clib_bihash_8_8_t *h;
+  int verbose = 0;
+
+  if (unformat (input, "verbose"))
+    verbose = 1;
+
+  for (i = 0; i < vec_len (clib_all_bihashes); i++)
+    {
+      h = (clib_bihash_8_8_t *) clib_all_bihashes[i];
+      vlib_cli_output (vm, "\n%U", h->fmt_fn, h, verbose);
+    }
+
+  return 0;
+}
+
+/* *INDENT-OFF* */
+VLIB_CLI_COMMAND (show_bihash_command, static) = {
+  .path = "show bihash",
+  .short_help = "show bihash",
+  .function = show_bihash_command_fn,
+};
+/* *INDENT-ON* */
+
+#ifdef CLIB_SANITIZE_ADDR
+/* default options for Address Sanitizer */
+const char *
+__asan_default_options (void)
+{
+  return VPP_SANITIZE_ADDR_OPTIONS;
+}
+#endif /* CLIB_SANITIZE_ADDR */
+
+/***********************************
+ * Missing Symbol in vpp libraries
+ ***********************************/
+
+typedef struct stat_segment_directory_entry_s stat_segment_directory_entry_t;
+typedef void (*stat_segment_update_fn) (stat_segment_directory_entry_t *e,
+					u32 i);
+clib_error_t *
+stat_segment_register_gauge (u8 *name, stat_segment_update_fn update_fn,
+			     u32 caller_index)
+{
+  return NULL;
+}
+
+u8 *
+format_vl_api_address_union (u8 *s, va_list *args)
+{
+  return NULL;
+}
+
+int
+vpp_init ()
+{
+#define N_ARGS	   3
+#define BUFFER_LEN 1024
+  // Get executable path
+  char buffer[BUFFER_LEN];
+  int ret = readlink ("/proc/self/exe", buffer, BUFFER_LEN);
+
+  ASSERT (ret < BUFFER_LEN);
+
+  buffer[ret] = '\0';
+
+  char *argv[N_ARGS] = { buffer, "unix { nodaemon }", NULL };
+  return vpp_init_internal (N_ARGS - 1, argv);
+}
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/hicn-plugin/src/test/vpp.h b/hicn-plugin/src/test/vpp.h
new file mode 100644
index 000000000..fe680f6b6
--- /dev/null
+++ b/hicn-plugin/src/test/vpp.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2022 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.
+ */
+
+#ifndef __VPP__
+#define __VPP__
+
+int vpp_init ();
+
+#endif
\ No newline at end of file