llvm/unittests/BinaryFormat/MsgPackDocumentTest.cpp

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