1 files changed, 401 insertions, 0 deletions
diff --git a/lib/src/test/test_name.cc b/lib/src/test/test_name.cc
new file mode 100644
index 000000000..0cf160f70
--- /dev/null
+++ b/lib/src/test/test_name.cc
@@ -0,0 +1,401 @@
+/*
+ * Copyright (c) 2021-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.
+ */
+
+#include <gtest/gtest.h>
+
+extern "C"
+{
+#include <hicn/name.h>
+#include <hicn/common.h>
+#include <hicn/error.h>
+}
+
+class NameTest : public ::testing::Test
+{
+protected:
+  const char *ipv6_prefix = "b001::abcd:1234:abcd:1234";
+  const char *ipv4_prefix = "12.13.14.15";
+  const uint32_t suffix = 12345;
+
+  NameTest () : name_{}, name4_{}, name6_{}
+  {
+    ipv6_prefix_bytes = {};
+    int rc = inet_pton (AF_INET6, ipv6_prefix, &ipv6_prefix_bytes.v6);
+    EXPECT_EQ (rc, 1);
+
+    ipv4_prefix_bytes = {};
+    rc = inet_pton (AF_INET, ipv4_prefix, &ipv4_prefix_bytes.v4);
+    EXPECT_EQ (rc, 1);
+
+    rc = hicn_name_create (ipv4_prefix, suffix, &name4_);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    rc = hicn_name_create (ipv6_prefix, suffix, &name6_);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  }
+
+  virtual ~NameTest () {}
+
+  void
+  nameHashTest (const char *prefix)
+  {
+    // Create 2 names
+    uint32_t suffix = 13579;
+    hicn_name_t name_a, name_b;
+    int rc = hicn_name_create (prefix, suffix, &name_a);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    rc = hicn_name_create (prefix, suffix, &name_b);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    // The hash should be equal, with and without considering the suffix
+    uint32_t hash_a, hash_b;
+    hash_a = hicn_name_get_hash (&name_a);
+    hash_b = hicn_name_get_hash (&name_b);
+    EXPECT_EQ (hash_a, hash_b);
+
+    hash_a = hicn_name_get_prefix_hash (&name_a);
+    hash_b = hicn_name_get_prefix_hash (&name_b);
+    EXPECT_EQ (hash_a, hash_b);
+
+    // Now let's change the suffix
+    rc = hicn_name_set_suffix (&name_a, 97531);
+    // They should result equal if we do not consider the suffix
+    hash_a = hicn_name_get_prefix_hash (&name_a);
+    hash_b = hicn_name_get_prefix_hash (&name_b);
+    EXPECT_EQ (hash_a, hash_b);
+
+    // And different if we consider it
+    hash_a = hicn_name_get_hash (&name_a);
+    hash_b = hicn_name_get_hash (&name_b);
+    EXPECT_NE (hash_a, hash_b);
+  }
+
+  void
+  nameCopyTest (const char *prefix)
+  {
+    uint32_t suffix = 13579;
+    hicn_name_t name_a, name_b;
+    int rc = hicn_name_create (prefix, suffix, &name_a);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    rc = hicn_name_copy (&name_b, &name_a);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    rc = hicn_name_compare (&name_a, &name_b, 1);
+    EXPECT_EQ (rc, 0);
+  }
+
+  void
+  nameCompareTest (const char *prefix)
+  {
+    // Create 2 names
+    uint32_t suffix = 13579;
+    hicn_name_t name_a, name_b;
+    int rc = hicn_name_create (prefix, suffix, &name_a);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    rc = hicn_name_create (prefix, suffix, &name_b);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    // They should be equal, with and without considering the suffix
+    rc = hicn_name_compare (&name_a, &name_b, 1);
+    EXPECT_EQ (rc, 0);
+    rc = hicn_name_compare (&name_a, &name_b, 0);
+    EXPECT_EQ (rc, 0);
+
+    // Now let's change the suffix
+    rc = hicn_name_set_suffix (&name_a, 97531);
+    // They should result equal if we do not consider the suffix
+    rc = hicn_name_compare (&name_a, &name_b, 0);
+    EXPECT_EQ (rc, 0);
+    // And different if we consider the suffix
+    rc = hicn_name_compare (&name_a, &name_b, 1);
+    EXPECT_NE (rc, 0);
+  }
+
+  void
+  nameFromIpPrefixTest (const hicn_ip_prefix_t &hicn_ip_prefix)
+  {
+    uint32_t suffix = 54321;
+    hicn_name_t name;
+    int rc = hicn_name_create_from_ip_prefix (&hicn_ip_prefix, suffix, &name);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    rc = memcmp (hicn_ip_prefix.address.v6.as_u8, name.prefix.v6.as_u8,
+		 sizeof (name.prefix.v6));
+    EXPECT_EQ (rc, 0);
+    EXPECT_EQ (suffix, name.suffix);
+  }
+
+  void
+  nameToIpPrefixTest (const char *prefix)
+  {
+    uint32_t suffix = 54321;
+    hicn_name_t name;
+    int rc = hicn_name_create (prefix, suffix, &name);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+    // Get family
+    int family;
+    rc = hicn_name_get_family (&name, &family);
+
+    hicn_ip_prefix_t hicn_ip_prefix;
+    rc = hicn_name_to_hicn_ip_prefix (&name, &hicn_ip_prefix);
+    EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+    EXPECT_EQ (hicn_ip_prefix.family, family);
+    rc = hicn_ip_address_cmp (&hicn_ip_prefix.address, &name.prefix);
+    EXPECT_EQ (rc, 0);
+  }
+
+  hicn_name_t name_, name4_, name6_;
+  hicn_ip_address_t ipv6_prefix_bytes, ipv4_prefix_bytes;
+};
+
+/**
+ * Name Initialization
+ */
+TEST_F (NameTest, NameInitialization)
+{
+  EXPECT_TRUE (_is_unspec (&name_));
+  uint32_t suffix = 12345;
+
+  // Initialize ipv6 name
+  hicn_name_t name6;
+  int rc = hicn_name_create (ipv6_prefix, suffix, &name6);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check name is correctly created
+  rc = hicn_ip_address_cmp (&name6.prefix, &ipv6_prefix_bytes);
+  EXPECT_EQ (rc, 0);
+  EXPECT_EQ (name6.suffix, suffix);
+
+  // Initialize ipv4 name
+  hicn_name_t name4;
+  rc = hicn_name_create (ipv4_prefix, suffix, &name4);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check name is correctly created
+  rc = hicn_ip_address_cmp (&name4.prefix, &ipv4_prefix_bytes);
+  EXPECT_EQ (name4.prefix.pad[0], 0UL);
+  EXPECT_EQ (name4.prefix.pad[1], 0UL);
+  EXPECT_EQ (name4.prefix.pad[2], 0UL);
+  EXPECT_EQ (rc, 0);
+  EXPECT_EQ (name4.suffix, suffix);
+
+  // Try also to reuse previously initialized name
+  rc = hicn_name_create (ipv4_prefix, suffix, &name6);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check name is correctly created
+  rc = hicn_ip_address_cmp (&name6.prefix, &ipv4_prefix_bytes);
+  EXPECT_EQ (name6.prefix.pad[0], 0UL);
+  EXPECT_EQ (name6.prefix.pad[1], 0UL);
+  EXPECT_EQ (name6.prefix.pad[2], 0UL);
+  EXPECT_EQ (rc, 0);
+  EXPECT_EQ (name6.suffix, suffix);
+}
+
+/**
+ * Name from ip prefix
+ */
+TEST_F (NameTest, NameFromIpPrefix6)
+{
+  hicn_ip_prefix_t hicn_ip_prefix = { .family = AF_INET6,
+				      .address = {},
+				      .len = 64 };
+
+  hicn_ip_prefix.address.v6.as_u64[0] = ipv6_prefix_bytes.v6.as_u64[0];
+  hicn_ip_prefix.address.v6.as_u64[1] = ipv6_prefix_bytes.v6.as_u64[1];
+
+  nameFromIpPrefixTest (hicn_ip_prefix);
+}
+
+TEST_F (NameTest, NameFromIpPrefix4)
+{
+  hicn_ip_prefix_t hicn_ip_prefix = { .family = AF_INET,
+				      .address = {},
+				      .len = 64 };
+  hicn_ip_prefix.address.v4.as_u32 = ipv4_prefix_bytes.v4.as_u32;
+  hicn_ip_prefix.address.pad[0] = 0;
+  hicn_ip_prefix.address.pad[1] = 0;
+  hicn_ip_prefix.address.pad[2] = 0;
+  nameFromIpPrefixTest (hicn_ip_prefix);
+}
+
+TEST_F (NameTest, NameCompare6) { nameCompareTest (ipv6_prefix); }
+
+TEST_F (NameTest, NameCompare4) { nameCompareTest (ipv4_prefix); }
+
+TEST_F (NameTest, NameHash6) { nameHashTest (ipv6_prefix); }
+
+TEST_F (NameTest, NameHash4) { nameHashTest (ipv4_prefix); }
+
+TEST_F (NameTest, NameEmpty)
+{
+  int rc = hicn_name_empty (&name_);
+  EXPECT_EQ (rc, 1);
+
+  name_.prefix.v6 = ipv6_prefix_bytes.v6;
+  rc = hicn_name_empty (&name_);
+  EXPECT_EQ (rc, 0);
+}
+
+TEST_F (NameTest, NameCopy6) { nameCopyTest (ipv6_prefix); }
+
+TEST_F (NameTest, NameCopy4) { nameCopyTest (ipv4_prefix); }
+
+TEST_F (NameTest, NameCopyToDestination)
+{
+  ipv4_address_t dst4;
+  ipv6_address_t dst6;
+
+  // Copy names to destination
+  int rc = hicn_name_copy_prefix_to_destination (dst4.as_u8, &name4_);
+  EXPECT_EQ (rc, 0);
+  rc = hicn_name_copy_prefix_to_destination (dst6.as_u8, &name6_);
+  EXPECT_EQ (rc, 0);
+
+  // Check copy succeeded
+  EXPECT_TRUE (dst4.as_u32 == name4_.prefix.v4.as_u32);
+  EXPECT_TRUE (dst6.as_u64[0] == name6_.prefix.v6.as_u64[0]);
+  EXPECT_TRUE (dst6.as_u64[1] == name6_.prefix.v6.as_u64[1]);
+}
+
+TEST_F (NameTest, SetGetSuffix)
+{
+  uint32_t suffix2 = 55555, suffix_ret;
+
+  // Check if suffix is correct
+  int rc = hicn_name_get_seq_number (&name6_, &suffix_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (suffix, suffix_ret);
+
+  // Set new suffix
+  rc = hicn_name_set_suffix (&name6_, suffix2);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Check suffix was set
+  rc = hicn_name_get_seq_number (&name6_, &suffix_ret);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (suffix2, suffix_ret);
+}
+
+TEST_F (NameTest, NameToSockAddr)
+{
+  struct sockaddr_in saddr4;
+  struct sockaddr_in6 saddr6;
+
+  int rc =
+    hicn_name_to_sockaddr_address (&name6_, (struct sockaddr *) (&saddr6));
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  rc = memcmp (name6_.prefix.v6.as_u8, saddr6.sin6_addr.s6_addr,
+	       sizeof (name6_.prefix.v6));
+  EXPECT_EQ (rc, 0);
+
+  rc = hicn_name_to_sockaddr_address (&name4_, (struct sockaddr *) (&saddr4));
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+  EXPECT_EQ (name4_.prefix.v4.as_u32, saddr4.sin_addr.s_addr);
+}
+
+TEST_F (NameTest, NameToIpPrefix)
+{
+  nameToIpPrefixTest (ipv4_prefix);
+  nameToIpPrefixTest (ipv6_prefix);
+}
+
+TEST_F (NameTest, NameNToP)
+{
+  char dst[128];
+
+  // V6
+  int rc = hicn_name_ntop (&name6_, dst, 128);
+  EXPECT_EQ (rc, HICN_LIB_ERROR_NONE);
+
+  // Build expected name
+  std::stringstream expected6;
+  expected6 << ipv6_prefix << "|" << suffix;
+
+  rc = strcmp (dst, expected6.str ().c_str ());
+  EXPECT_EQ (rc, 0);
+
+  // V4
+  rc = hicn_name_ntop (&name4_, dst, 128);
+  std::stringstream expected4;
+  expected4 << ipv4_prefix << "|" << suffix;
+
+  rc = strcmp (dst, expected4.str ().c_str ());
+  EXPECT_EQ (rc, 0);
+}
+
+class PrefixTest : public ::testing::Test
+{
+protected:
+  PrefixTest () {}
+
+  virtual ~PrefixTest () {}
+};
+
+#define HICN_PREFIX(P, STR)                                                   \
+  hicn_prefix_t P;                                                            \
+  hicn_ip_prefix_t _##P;                                                      \
+  EXPECT_EQ (hicn_ip_prefix_pton (STR, &_##P), 0);                            \
+  EXPECT_EQ (hicn_prefix_create_from_ip_prefix (&_##P, &P), 0);
+
+TEST_F (PrefixTest, PrefixClear)
+{
+  HICN_PREFIX (hp_all, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128");
+
+  for (unsigned i = 0; i < 127; i++)
+    EXPECT_EQ (hicn_prefix_get_bit (&hp_all, i), 1);
+
+  hicn_prefix_truncate (&hp_all, 127);
+  EXPECT_EQ (hicn_prefix_get_len (&hp_all), 127);
+
+  for (unsigned i = 0; i < 126; i++)
+    EXPECT_EQ (hicn_prefix_get_bit (&hp_all, i), 1) << "bit[" << i << "] != 1";
+  EXPECT_EQ (hicn_prefix_get_bit (&hp_all, 127), 0);
+
+  hicn_prefix_truncate (&hp_all, 126);
+  EXPECT_EQ (hicn_prefix_get_len (&hp_all), 126);
+
+  for (unsigned i = 0; i < 125; i++)
+    EXPECT_EQ (hicn_prefix_get_bit (&hp_all, i), 1);
+  EXPECT_EQ (hicn_prefix_get_bit (&hp_all, 126), 0);
+  EXPECT_EQ (_hicn_prefix_get_bit (&hp_all, 127), 0);
+}
+
+TEST_F (PrefixTest, PrefixClear2)
+{
+  HICN_PREFIX (hp_all, "b002::3");
+
+  EXPECT_EQ (hicn_prefix_get_bit (&hp_all, 125), 0);
+  EXPECT_EQ (hicn_prefix_get_bit (&hp_all, 126), 1);
+  EXPECT_EQ (hicn_prefix_get_bit (&hp_all, 127), 1);
+
+  hicn_prefix_truncate (&hp_all, 127);
+  EXPECT_EQ (hicn_prefix_get_len (&hp_all), 127);
+
+  EXPECT_EQ (hicn_prefix_get_bit (&hp_all, 125), 0);
+  EXPECT_EQ (hicn_prefix_get_bit (&hp_all, 126), 1);
+  EXPECT_EQ (_hicn_prefix_get_bit (&hp_all, 127), 0);
+}
+
+TEST_F (PrefixTest, PrefixLPM)
+{
+  HICN_PREFIX (b007, "b007::/64");
+  HICN_PREFIX (b009, "b009::/64");
+
+  EXPECT_EQ (hicn_prefix_lpm (&b007, &b009), (uint32_t) 12);
+
+  HICN_PREFIX (pfx, "1122:3344:5566:7788:9900:aabb:ccdd:eeff/128");
+  EXPECT_EQ (hicn_prefix_lpm (&pfx, &pfx), (uint32_t) 128);
+}