test_addrs: adding some addr unittest cases

Some unittest need a new constructor, add a
entity_addr_t(__u32 _type, __u32 _nonce).

Signed-off-by: Zhao Junwang <zhjwpku@gmail.com>

diff --git a/src/msg/msg_types.cc b/src/msg/msg_types.cc
index ae98032c627eb2b47d84e074665ec1846f0d8434..b2294a2876e5487945ad62d9b90b1f9f6811c1d2 100644 (file)
--- a/src/msg/msg_types.cc
+++ b/src/msg/msg_types.cc
@@ -221,7 +221,7 @@ void entity_addrvec_t::encode(bufferlist& bl, uint64_t features) const
     if (v.size() > 0) {
       for (vector<entity_addr_t>::const_iterator p = v.begin();
            p != v.end(); ++p) {
-        if ((*p).type == (*p).TYPE_LEGACY) {
+        if ((*p).type == entity_addr_t::TYPE_LEGACY) {
          ::encode(*p, bl, 0);
          return;
        }

diff --git a/src/msg/msg_types.h b/src/msg/msg_types.h
index 78a6693a73872f2290b4d401e9ba5e4c323b43d3..f74228d1d5bac0f60e890fda29f97c369a1f5824 100644 (file)
--- a/src/msg/msg_types.h
+++ b/src/msg/msg_types.h
@@ -228,6 +228,9 @@ struct entity_addr_t {
   entity_addr_t() : type(0), nonce(0) { 
     memset(&u, 0, sizeof(u));
   }
+  entity_addr_t(__u32 _type, __u32 _nonce) : type(_type), nonce(_nonce) {
+    memset(&u, 0, sizeof(u));
+  }
   explicit entity_addr_t(const ceph_entity_addr &o) {
     type = o.type;
     nonce = o.nonce;

diff --git a/src/test/test_addrs.cc b/src/test/test_addrs.cc
index d8251221ec95b5b1186b3075637d263161a79181..43723e467b6faec20474d1cb330a96ff6b024d0e 100644 (file)
--- a/src/test/test_addrs.cc
+++ b/src/test/test_addrs.cc
@@ -47,15 +47,12 @@ const char *addr_checks[][3] = {
   { NULL, NULL, NULL },
 };
 
-
 TEST(Msgr, TestAddrParsing)
 {
-
   for (unsigned i = 0; addr_checks[i][0]; ++i) {
     entity_addr_t a;
     const char *end = "";
     bool ok = a.parse(addr_checks[i][0], &end);
-    string in = addr_checks[i][0];
     string out;
     if (ok) {
       stringstream ss;
@@ -70,3 +67,180 @@ TEST(Msgr, TestAddrParsing)
     ASSERT_EQ(left, addr_checks[i][2]);
   }
 }
+
+const char *addr_checks2[][3] = {
+  { "127.0.0.1", "127.0.0.1:0/0", "" },
+  { "127.0.0.1 foo", "127.0.0.1:0/0", " foo" },
+  { "127.0.0.1:1234 foo", "127.0.0.1:1234/0", " foo" },
+  { "127.0.0.1:1234/5678 foo", "127.0.0.1:1234/5678", " foo" },
+  { "2607:f298:4:2243::5522", "[2607:f298:4:2243::5522]:0/0", "" },
+  { "[2607:f298:4:2243::5522]", "[2607:f298:4:2243::5522]:0/0", "" },
+  { "[2607:f298:4:2243::5522]a", "[2607:f298:4:2243::5522]:0/0", "a" },
+  { "[2607:f298:4:2243::5522]:1234a", "[2607:f298:4:2243::5522]:1234/0", "a" },
+  { "2001:0db8:85a3:0000:0000:8a2e:0370:7334", "[2001:db8:85a3::8a2e:370:7334]:0/0", "" },
+  { "2001:2db8:85a3:4334:4324:8a2e:1370:7334", "[2001:2db8:85a3:4334:4324:8a2e:1370:7334]:0/0", "" },
+  { "legacy:1.2.3.4", "1.2.3.4:0/0", "" },
+  { "legacy:1.2.3.4:12", "1.2.3.4:12/0", "" },
+  { "legacy:1.2.3.4:12/34", "1.2.3.4:12/34", "" },
+  { NULL, NULL, NULL },
+};
+
+TEST(Msgr, TestAddrEncodeAddrvecDecode)
+{
+  for (unsigned i = 0; addr_checks2[i][0]; ++i) {
+    entity_addr_t addr;
+    entity_addrvec_t addrvec;
+    bufferlist::iterator bli;
+    const char *end = "";
+    bool ok = addr.parse(addr_checks2[i][0], &end);
+    ASSERT_TRUE(ok);
+    bufferlist bl;
+    addr.encode(bl, 0);
+    bli = bl.begin();
+    addrvec.decode(bli);
+    ASSERT_EQ(addr, addrvec.v[0]);
+  }
+}
+
+TEST(Msgr, TestAddrvec0EncodeAddrDecode)
+{
+  for (unsigned i = 0; addr_checks2[i][0]; ++i) {
+    entity_addr_t addr;
+    entity_addrvec_t addrvec;
+    bufferlist bl;
+    bufferlist::iterator bli;
+    const char *end = "";
+    bool ok = addr.parse(addr_checks2[i][0], &end);
+    ASSERT_TRUE(ok);
+    addrvec.v.push_back(addr);
+    addrvec.encode(bl, 0);
+    bli = bl.begin();
+    entity_addr_t a;
+    a.decode(bli);
+    ASSERT_EQ(addr, a);
+  }
+}
+
+TEST(Msgr, TestEmptyAddrvecEncodeAddrDecode)
+{
+  entity_addrvec_t addrvec;
+  entity_addr_t addr;
+  bufferlist bl;
+  bufferlist::iterator bli;
+  addrvec.encode(bl, 0);
+  bli = bl.begin();
+  addr.decode(bli);
+  ASSERT_EQ(addr, entity_addr_t(1, 0));
+}
+
+const char *addrvec_checks[][4] = {
+  { "legacy:1.2.3.4", "msgr2:1.2.3.4", "legacy:1.2.3.4", "msgr2:1.2.3.4" },
+  { "msgr2:1.2.3.5", "legacy:1.2.3.5", "legacy:1.2.3.5", "msgr2:1.2.3.5" },
+  { "msgr2:1.2.3.6", "msgr2:1.2.3.6", "legacy:1.2.3.6", "msgr2:1.2.3.6" },
+  { "msgr2:1.2.3.7", "legacy:1.2.3.7", "legacy:1.2.3.7", "msgr2:1.2.3.7" },
+  { NULL, NULL, NULL, NULL },
+};
+
+/*
+ * multiple addrs where one is legacy and others are not
+ * legacy addr is in position 0
+ */
+TEST(Msgr, TestAddrvecEncodeAddrDecode0)
+{
+  entity_addr_t addr;
+  entity_addrvec_t addrvec;
+  bufferlist bl;
+  bufferlist::iterator bli;
+
+  for (unsigned i = 0; addrvec_checks[i][0]; ++i) {
+    const char *end = "";
+    bool ok = addr.parse(addrvec_checks[i][0], &end);
+    ASSERT_TRUE(ok);
+    addrvec.v.push_back(addr);
+  }
+
+  addrvec.encode(bl, 0);
+  bli = bl.begin();
+
+  addr.decode(bli);
+
+  ASSERT_EQ(addr, addrvec.v[0]);
+}
+
+/*
+ * multiple addrs where one is legacy and others are not
+ * legacy addr is not in position 0
+ */
+TEST(Msgr, TestAddrvecEncodeAddrDecode1)
+{
+  entity_addr_t addr, a;
+  entity_addrvec_t addrvec;
+  bufferlist bl;
+  bufferlist::iterator bli;
+  bool flag = true;
+
+  for (unsigned i = 0; addrvec_checks[i][1]; ++i) {
+    const char *end = "";
+    bool ok = addr.parse(addrvec_checks[i][1], &end);
+    ASSERT_TRUE(ok);
+    if (addr.type == entity_addr_t::TYPE_LEGACY && flag) {
+      a = addr;
+      flag = !flag;
+    }
+    addrvec.v.push_back(addr);
+  }
+
+  addrvec.encode(bl, 0);
+  bli = bl.begin();
+
+  addr.decode(bli);
+
+  ASSERT_EQ(addr, a);
+}
+
+/* multiple legacy addrs */
+TEST(Msgr, TestAddrvecEncodeAddrDecode2)
+{
+  entity_addr_t addr;
+  entity_addrvec_t addrvec;
+  bufferlist bl;
+  bufferlist::iterator bli;
+
+  for (unsigned i = 0; addrvec_checks[i][2]; ++i) {
+    const char *end = "";
+    bool ok = addr.parse(addrvec_checks[i][2], &end);
+    ASSERT_TRUE(ok);
+    addrvec.v.push_back(addr);
+  }
+
+  addrvec.encode(bl, 0);
+  bli = bl.begin();
+
+  addr.decode(bli);
+
+  ASSERT_EQ(addr, addrvec.v[0]);
+}
+
+/* all non-legacy addrs */
+TEST(Msgr, TestAddrvecEncodeAddrDecode3)
+{
+  entity_addr_t addr;
+  entity_addrvec_t addrvec;
+  bufferlist bl;
+  bufferlist::iterator bli;
+
+  for (unsigned i = 0; addrvec_checks[i][3]; ++i) {
+    const char *end = "";
+    bool ok = addr.parse(addrvec_checks[i][3], &end);
+    ASSERT_TRUE(ok);
+    addrvec.v.push_back(addr);
+  }
+
+  addrvec.encode(bl, 0);
+  bli = bl.begin();
+
+  addr.decode(bli);
+
+  ASSERT_NE(addr, addrvec.v[0]); // it's not the first addr(which is non-legacy)
+  ASSERT_NE(addr, entity_addr_t(1, 0)); // it's not a blank addr either
+}