llvm/unittests/BinaryFormat/MsgPackDocumentTest.cpp

   1 //===- MsgPackDocumentTest.cpp --------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/BinaryFormat/MsgPackDocument.h"
  11 #include "gtest/gtest.h"
  12
  13 using namespace llvm;
  14 using namespace msgpack;
  15
  16 TEST(MsgPackDocument, DocNodeTest) {
  17   Document Doc;
  18
  19   DocNode Int1 = Doc.getNode(1), Int2 = Doc.getNode(2);
  20   DocNode Str1 = Doc.getNode("ab"), Str2 = Doc.getNode("ab");
  21
  22   ASSERT_TRUE(Int1 != Int2);
  23   ASSERT_TRUE(Str1 == Str2);
  24 }
  25
  26 TEST(MsgPackDocument, TestReadInt) {
  27   Document Doc;
  28   bool Ok = Doc.readFromBlob(StringRef("\xd0\x00", 2), /*Multi=*/false);
  29   ASSERT_TRUE(Ok);
  30   ASSERT_EQ(Doc.getRoot().getKind(), Type::Int);
  31   ASSERT_EQ(Doc.getRoot().getInt(), 0);
  32 }
  33
  34 TEST(MsgPackDocument, TestReadMergeArray) {
  35   Document Doc;
  36   bool Ok = Doc.readFromBlob(StringRef("\x92\xd0\x01\xc0"), /*Multi=*/false);
  37   ASSERT_TRUE(Ok);
  38   ASSERT_EQ(Doc.getRoot().getKind(), Type::Array);
  39   auto A = Doc.getRoot().getArray();
  40   ASSERT_EQ(A.size(), 2u);
  41   auto SI = A[0];
  42   ASSERT_EQ(SI.getKind(), Type::Int);
  43   ASSERT_EQ(SI.getInt(), 1);
  44   auto SN = A[1];
  45   ASSERT_EQ(SN.getKind(), Type::Nil);
  46
  47   Ok = Doc.readFromBlob(StringRef("\x91\xd0\x2a"), /*Multi=*/false,
  48                         [](DocNode *DestNode, DocNode SrcNode, DocNode MapKey) {
  49                           // Allow array, merging into existing elements, ORing
  50                           // ints.
  51                           if (DestNode->getKind() == Type::Int &&
  52                               SrcNode.getKind() == Type::Int) {
  53                             *DestNode = DestNode->getDocument()->getNode(
  54                                 DestNode->getInt() | SrcNode.getInt());
  55                             return 0;
  56                           }
  57                           return DestNode->isArray() && SrcNode.isArray() ? 0
  58                                                                           : -1;
  59                         });
  60   ASSERT_TRUE(Ok);
  61   A = Doc.getRoot().getArray();
  62   ASSERT_EQ(A.size(), 2u);
  63   SI = A[0];
  64   ASSERT_EQ(SI.getKind(), Type::Int);
  65   ASSERT_EQ(SI.getInt(), 43);
  66   SN = A[1];
  67   ASSERT_EQ(SN.getKind(), Type::Nil);
  68 }
  69
  70 TEST(MsgPackDocument, TestReadAppendArray) {
  71   Document Doc;
  72   bool Ok = Doc.readFromBlob(StringRef("\x92\xd0\x01\xc0"), /*Multi=*/false);
  73   ASSERT_TRUE(Ok);
  74   ASSERT_EQ(Doc.getRoot().getKind(), Type::Array);
  75   auto A = Doc.getRoot().getArray();
  76   ASSERT_EQ(A.size(), 2u);
  77   auto SI = A[0];
  78   ASSERT_EQ(SI.getKind(), Type::Int);
  79   ASSERT_EQ(SI.getInt(), 1);
  80   auto SN = A[1];
  81   ASSERT_EQ(SN.getKind(), Type::Nil);
  82
  83   Ok = Doc.readFromBlob(StringRef("\x91\xd0\x2a"), /*Multi=*/false,
  84                         [](DocNode *DestNode, DocNode SrcNode, DocNode MapKey) {
  85                           // Allow array, appending after existing elements
  86                           return DestNode->isArray() && SrcNode.isArray()
  87                                      ? DestNode->getArray().size()
  88                                      : -1;
  89                         });
  90   ASSERT_TRUE(Ok);
  91   A = Doc.getRoot().getArray();
  92   ASSERT_EQ(A.size(), 3u);
  93   SI = A[0];
  94   ASSERT_EQ(SI.getKind(), Type::Int);
  95   ASSERT_EQ(SI.getInt(), 1);
  96   SN = A[1];
  97   ASSERT_EQ(SN.getKind(), Type::Nil);
  98   SI = A[2];
  99   ASSERT_EQ(SI.getKind(), Type::Int);
 100   ASSERT_EQ(SI.getInt(), 42);
 101 }
 102
 103 TEST(MsgPackDocument, TestReadMergeMap) {
 104   Document Doc;
 105   bool Ok = Doc.readFromBlob(StringRef("\x82\xa3"
 106                                        "foo"
 107                                        "\xd0\x01\xa3"
 108                                        "bar"
 109                                        "\xd0\x02"),
 110                              /*Multi=*/false);
 111   ASSERT_TRUE(Ok);
 112   ASSERT_EQ(Doc.getRoot().getKind(), Type::Map);
 113   auto M = Doc.getRoot().getMap();
 114   ASSERT_EQ(M.size(), 2u);
 115   auto FooS = M["foo"];
 116   ASSERT_EQ(FooS.getKind(), Type::Int);
 117   ASSERT_EQ(FooS.getInt(), 1);
 118   auto BarS = M["bar"];
 119   ASSERT_EQ(BarS.getKind(), Type::Int);
 120   ASSERT_EQ(BarS.getInt(), 2);
 121
 122   Ok = Doc.readFromBlob(StringRef("\x82\xa3"
 123                                   "foz"
 124                                   "\xd0\x03\xa3"
 125                                   "baz"
 126                                   "\xd0\x04"),
 127                         /*Multi=*/false,
 128                         [](DocNode *DestNode, DocNode SrcNode, DocNode MapKey) {
 129                           return DestNode->isMap() && SrcNode.isMap() ? 0 : -1;
 130                         });
 131   ASSERT_TRUE(Ok);
 132   ASSERT_EQ(M.size(), 4u);
 133   FooS = M["foo"];
 134   ASSERT_EQ(FooS.getKind(), Type::Int);
 135   ASSERT_EQ(FooS.getInt(), 1);
 136   BarS = M["bar"];
 137   ASSERT_EQ(BarS.getKind(), Type::Int);
 138   ASSERT_EQ(BarS.getInt(), 2);
 139   auto FozS = M["foz"];
 140   ASSERT_EQ(FozS.getKind(), Type::Int);
 141   ASSERT_EQ(FozS.getInt(), 3);
 142   auto BazS = M["baz"];
 143   ASSERT_EQ(BazS.getKind(), Type::Int);
 144   ASSERT_EQ(BazS.getInt(), 4);
 145
 146   Ok = Doc.readFromBlob(
 147       StringRef("\x82\xa3"
 148                 "foz"
 149                 "\xd0\x06\xa3"
 150                 "bay"
 151                 "\xd0\x08"),
 152       /*Multi=*/false, [](DocNode *Dest, DocNode Src, DocNode MapKey) {
 153         // Merger function that merges two ints by ORing their values, as long
 154         // as the map key is "foz".
 155         if (Src.isMap())
 156           return Dest->isMap();
 157         if (Src.isArray())
 158           return Dest->isArray();
 159         if (MapKey.isString() && MapKey.getString() == "foz" &&
 160             Dest->getKind() == Type::Int && Src.getKind() == Type::Int) {
 161           *Dest = Src.getDocument()->getNode(Dest->getInt() | Src.getInt());
 162           return true;
 163         }
 164         return false;
 165       });
 166   ASSERT_TRUE(Ok);
 167   ASSERT_EQ(M.size(), 5u);
 168   FooS = M["foo"];
 169   ASSERT_EQ(FooS.getKind(), Type::Int);
 170   ASSERT_EQ(FooS.getInt(), 1);
 171   BarS = M["bar"];
 172   ASSERT_EQ(BarS.getKind(), Type::Int);
 173   ASSERT_EQ(BarS.getInt(), 2);
 174   FozS = M["foz"];
 175   ASSERT_EQ(FozS.getKind(), Type::Int);
 176   ASSERT_EQ(FozS.getInt(), 7);
 177   BazS = M["baz"];
 178   ASSERT_EQ(BazS.getKind(), Type::Int);
 179   ASSERT_EQ(BazS.getInt(), 4);
 180   auto BayS = M["bay"];
 181   ASSERT_EQ(BayS.getKind(), Type::Int);
 182   ASSERT_EQ(BayS.getInt(), 8);
 183 }
 184
 185 TEST(MsgPackDocument, TestWriteInt) {
 186   Document Doc;
 187   Doc.getRoot() = 1;
 188   std::string Buffer;
 189   Doc.writeToBlob(Buffer);
 190   ASSERT_EQ(Buffer, "\x01");
 191 }
 192
 193 TEST(MsgPackDocument, TestWriteArray) {
 194   Document Doc;
 195   auto A = Doc.getRoot().getArray(/*Convert=*/true);
 196   A.push_back(Doc.getNode(int64_t(1)));
 197   A.push_back(Doc.getNode());
 198   std::string Buffer;
 199   Doc.writeToBlob(Buffer);
 200   ASSERT_EQ(Buffer, "\x92\x01\xc0");
 201 }
 202
 203 TEST(MsgPackDocument, TestWriteMap) {
 204   Document Doc;
 205   auto M = Doc.getRoot().getMap(/*Convert=*/true);
 206   M["foo"] = 1;
 207   M["bar"] = 2;
 208   std::string Buffer;
 209   Doc.writeToBlob(Buffer);
 210   ASSERT_EQ(Buffer, "\x82\xa3"
 211                     "bar"
 212                     "\x02\xa3"
 213                     "foo"
 214                     "\x01");
 215 }
 216
 217 TEST(MsgPackDocument, TestOutputYAMLArray) {
 218   Document Doc;
 219   auto A = Doc.getRoot().getArray(/*Convert=*/true);
 220   A.push_back(Doc.getNode(int64_t(1)));
 221   A.push_back(Doc.getNode(int64_t(2)));
 222   std::string Buffer;
 223   raw_string_ostream OStream(Buffer);
 224   Doc.toYAML(OStream);
 225   ASSERT_EQ(OStream.str(), "---\n- 1\n- 2\n...\n");
 226 }
 227
 228 TEST(MsgPackDocument, TestInputYAMLArray) {
 229   Document Doc;
 230   bool Ok = Doc.fromYAML("---\n- !int 0x1\n- !str 2\n...\n");
 231   ASSERT_TRUE(Ok);
 232   ASSERT_EQ(Doc.getRoot().getKind(), Type::Array);
 233   auto A = Doc.getRoot().getArray();
 234   ASSERT_EQ(A.size(), 2u);
 235   auto SI = A[0];
 236   ASSERT_EQ(SI.getKind(), Type::UInt);
 237   ASSERT_EQ(SI.getUInt(), 1u);
 238   auto SS = A[1];
 239   ASSERT_EQ(SS.getKind(), Type::String);
 240   ASSERT_EQ(SS.getString(), "2");
 241 }
 242
 243 TEST(MsgPackDocument, TestOutputYAMLMap) {
 244   Document Doc;
 245   auto M = Doc.getRoot().getMap(/*Convert=*/true);
 246   M["foo"] = 1;
 247   M["bar"] = 2U;
 248   auto N = Doc.getMapNode();
 249   M["qux"] = N;
 250   N["baz"] = true;
 251   std::string Buffer;
 252   raw_string_ostream OStream(Buffer);
 253   Doc.toYAML(OStream);
 254   ASSERT_EQ(OStream.str(), "---\n"
 255                            "bar:             2\n"
 256                            "foo:             1\n"
 257                            "qux:\n"
 258                            "  baz:             true\n"
 259                            "...\n");
 260 }
 261
 262 TEST(MsgPackDocument, TestOutputYAMLMapWithErase) {
 263   Document Doc;
 264   auto M = Doc.getRoot().getMap(/*Convert=*/true);
 265   M["foo"] = 1;
 266   M["bar"] = 2U;
 267   auto N = Doc.getMapNode();
 268   M["qux"] = N;
 269   N["baz"] = true;
 270   M.erase(Doc.getNode("bar"));
 271   std::string Buffer;
 272   raw_string_ostream OStream(Buffer);
 273   Doc.toYAML(OStream);
 274   ASSERT_EQ(OStream.str(), "---\n"
 275                            "foo:             1\n"
 276                            "qux:\n"
 277                            "  baz:             true\n"
 278                            "...\n");
 279 }
 280
 281 TEST(MsgPackDocument, TestOutputYAMLMapHex) {
 282   Document Doc;
 283   Doc.setHexMode();
 284   auto M = Doc.getRoot().getMap(/*Convert=*/true);
 285   M["foo"] = 1;
 286   M["bar"] = 2U;
 287   auto N = Doc.getMapNode();
 288   M["qux"] = N;
 289   N["baz"] = true;
 290   std::string Buffer;
 291   raw_string_ostream OStream(Buffer);
 292   Doc.toYAML(OStream);
 293   ASSERT_EQ(OStream.str(), "---\n"
 294                            "bar:             0x2\n"
 295                            "foo:             1\n"
 296                            "qux:\n"
 297                            "  baz:             true\n"
 298                            "...\n");
 299 }
 300
 301 TEST(MsgPackDocument, TestInputYAMLMap) {
 302   Document Doc;
 303   bool Ok = Doc.fromYAML("---\nfoo: !int 0x1\nbaz: !str 2\n...\n");
 304   ASSERT_TRUE(Ok);
 305   ASSERT_EQ(Doc.getRoot().getKind(), Type::Map);
 306   auto M = Doc.getRoot().getMap();
 307   ASSERT_EQ(M.size(), 2u);
 308   auto SI = M["foo"];
 309   ASSERT_EQ(SI.getKind(), Type::UInt);
 310   ASSERT_EQ(SI.getUInt(), 1u);
 311   auto SS = M["baz"];
 312   ASSERT_EQ(SS.getKind(), Type::String);
 313   ASSERT_EQ(SS.getString(), "2");
 314 }