| OLD | NEW |
|---|
| (Empty) | |
| 1 //===- llvm/unittest/Bitcode/NaClAbbrevTest.cpp - Tests for NaCl Abbrevs --===// |
| 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 // Tests if we properly sort abbreviations when building an |
| 11 // abbreviation trie. |
| 12 |
| 13 #include "llvm/Bitcode/NaCl/AbbrevTrieNode.h" |
| 14 #include "llvm/Bitcode/NaCl/NaClBitCodes.h" |
| 15 #include "llvm/Bitcode/NaCl/NaClBitcodeValueDist.h" |
| 16 #include "gtest/gtest.h" |
| 17 |
| 18 #include <iostream> |
| 19 #include <sstream> |
| 20 |
| 21 using namespace llvm; |
| 22 |
| 23 namespace { |
| 24 |
| 25 static const unsigned MaxValueIndex = NaClValueIndexCutoff + 1; |
| 26 |
| 27 typedef SmallVector<NaClBitCodeAbbrev*, 32> AbbrevVector; |
| 28 |
| 29 static void Clear(AbbrevVector &Vector) { |
| 30 for (AbbrevVector::iterator Iter = Vector.begin(), IterEnd = Vector.end(); |
| 31 Iter != IterEnd; ++Iter) { |
| 32 (*Iter)->dropRef(); |
| 33 } |
| 34 } |
| 35 |
| 36 static void Clear(AbbrevLookupSizeMap &LookupMap) { |
| 37 for (AbbrevLookupSizeMap::iterator |
| 38 Iter = LookupMap.begin(), IterEnd = LookupMap.end(); |
| 39 Iter != IterEnd; ++Iter) { |
| 40 delete Iter->second; |
| 41 } |
| 42 } |
| 43 |
| 44 static std::string DescribeAbbreviations(AbbrevVector &Abbrevs) { |
| 45 std::string Message; |
| 46 raw_string_ostream ostrm(Message); |
| 47 for (AbbrevVector::const_iterator |
| 48 Iter = Abbrevs.begin(), IterEnd = Abbrevs.end(); |
| 49 Iter != IterEnd; ++Iter) { |
| 50 (*Iter)->Print(ostrm); |
| 51 } |
| 52 return ostrm.str(); |
| 53 } |
| 54 |
| 55 static std::string DescribeAbbrevTrieNode(const AbbrevTrieNode *Node, |
| 56 bool LocalOnly) { |
| 57 std::string Message; |
| 58 raw_string_ostream ostrm(Message); |
| 59 if (Node) |
| 60 Node->Print(ostrm, "", LocalOnly); |
| 61 else |
| 62 ostrm << "NULL"; |
| 63 return ostrm.str(); |
| 64 } |
| 65 |
| 66 static std::string DescribeAbbrevTrie(const AbbrevTrieNode *Node) { |
| 67 return DescribeAbbrevTrieNode(Node, false); |
| 68 } |
| 69 |
| 70 static std::string DescribeAbbrevTrieNode(const AbbrevTrieNode *Node) { |
| 71 return DescribeAbbrevTrieNode(Node, true); |
| 72 } |
| 73 |
| 74 static std::string DescribeRecord(const NaClBitcodeRecordData &Record) { |
| 75 std::string Message; |
| 76 raw_string_ostream ostrm(Message); |
| 77 Record.Print(ostrm); |
| 78 return ostrm.str(); |
| 79 } |
| 80 |
| 81 TEST(NaClAbbrevTrieTest, Simple) { |
| 82 // Test example of multiple abbreviations of length 2. |
| 83 AbbrevVector Abbrevs; |
| 84 // [1, VBR(6)] |
| 85 NaClBitCodeAbbrev *Abbrev = new NaClBitCodeAbbrev(); |
| 86 Abbrev->Add(NaClBitCodeAbbrevOp(1)); |
| 87 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 88 Abbrevs.push_back(Abbrev); |
| 89 // [4, VBR(8)] |
| 90 Abbrev = new NaClBitCodeAbbrev(); |
| 91 Abbrev->Add(NaClBitCodeAbbrevOp(4)); |
| 92 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 8)); |
| 93 Abbrevs.push_back(Abbrev); |
| 94 // [4, 0] |
| 95 Abbrev = new NaClBitCodeAbbrev(); |
| 96 Abbrev->Add(NaClBitCodeAbbrevOp(4)); |
| 97 Abbrev->Add(NaClBitCodeAbbrevOp(0)); |
| 98 Abbrevs.push_back(Abbrev); |
| 99 // [1, 2] |
| 100 Abbrev = new NaClBitCodeAbbrev(); |
| 101 Abbrev->Add(NaClBitCodeAbbrevOp(1)); |
| 102 Abbrev->Add(NaClBitCodeAbbrevOp(2)); |
| 103 Abbrevs.push_back(Abbrev); |
| 104 // [1, 0] |
| 105 Abbrev = new NaClBitCodeAbbrev(); |
| 106 Abbrev->Add(NaClBitCodeAbbrevOp(1)); |
| 107 Abbrev->Add(NaClBitCodeAbbrevOp(0)); |
| 108 Abbrevs.push_back(Abbrev); |
| 109 // [VBR(6), VBR(6)] |
| 110 Abbrev = new NaClBitCodeAbbrev(); |
| 111 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 112 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 113 Abbrevs.push_back(Abbrev); |
| 114 // [VBR(6), 0] |
| 115 Abbrev = new NaClBitCodeAbbrev(); |
| 116 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 117 Abbrev->Add(NaClBitCodeAbbrevOp(0)); |
| 118 Abbrevs.push_back(Abbrev); |
| 119 |
| 120 // Verify we built the expected abbreviations. |
| 121 EXPECT_EQ(std::string( |
| 122 "[1, VBR(6)]\n" |
| 123 "[4, VBR(8)]\n" |
| 124 "[4, 0]\n" |
| 125 "[1, 2]\n" |
| 126 "[1, 0]\n" |
| 127 "[VBR(6), VBR(6)]\n" |
| 128 "[VBR(6), 0]\n"), |
| 129 DescribeAbbreviations(Abbrevs)); |
| 130 |
| 131 // Build lookup map, and check that we build the expected trie. |
| 132 AbbrevLookupSizeMap LookupMap; |
| 133 NaClBuildAbbrevLookupMap(LookupMap, Abbrevs); |
| 134 EXPECT_EQ((size_t)1, LookupMap.size()) |
| 135 << "There should only be one entry in the Lookup map " |
| 136 << "for abbreviations of length 2"; |
| 137 for (AbbrevLookupSizeMap::iterator |
| 138 Iter = LookupMap.begin(), IterEnd = LookupMap.end(); |
| 139 Iter != IterEnd; ++Iter) { |
| 140 EXPECT_EQ(Iter->first, (size_t)2) |
| 141 << "Expecting abbreviations to be of length 2"; |
| 142 EXPECT_EQ(std::string( |
| 143 "Abbreviations:\n" |
| 144 " [VBR(6), VBR(6)] (abbrev #5)\n" |
| 145 "Successor Map:\n" |
| 146 " Record.Code = 1\n" |
| 147 " Abbreviations:\n" |
| 148 " [1, VBR(6)] (abbrev #0)\n" |
| 149 " [VBR(6), VBR(6)] (abbrev #5)\n" |
| 150 " Successor Map:\n" |
| 151 " Record.Values[0] = 0\n" |
| 152 " Abbreviations:\n" |
| 153 " [1, VBR(6)] (abbrev #0)\n" |
| 154 " [1, 0] (abbrev #4)\n" |
| 155 " [VBR(6), VBR(6)] (abbrev #5)\n" |
| 156 " [VBR(6), 0] (abbrev #6)\n" |
| 157 " Record.Values[0] = 2\n" |
| 158 " Abbreviations:\n" |
| 159 " [1, VBR(6)] (abbrev #0)\n" |
| 160 " [1, 2] (abbrev #3)\n" |
| 161 " [VBR(6), VBR(6)] (abbrev #5)\n" |
| 162 " Record.Code = 4\n" |
| 163 " Abbreviations:\n" |
| 164 " [4, VBR(8)] (abbrev #1)\n" |
| 165 " [VBR(6), VBR(6)] (abbrev #5)\n" |
| 166 " Successor Map:\n" |
| 167 " Record.Values[0] = 0\n" |
| 168 " Abbreviations:\n" |
| 169 " [4, VBR(8)] (abbrev #1)\n" |
| 170 " [4, 0] (abbrev #2)\n" |
| 171 " [VBR(6), VBR(6)] (abbrev #5)\n" |
| 172 " [VBR(6), 0] (abbrev #6)\n" |
| 173 " Record.Values[0] = 0\n" |
| 174 " Abbreviations:\n" |
| 175 " [VBR(6), VBR(6)] (abbrev #5)\n" |
| 176 " [VBR(6), 0] (abbrev #6)\n"), |
| 177 DescribeAbbrevTrie(Iter->second)); |
| 178 } |
| 179 |
| 180 // Test matching [1, 0]. |
| 181 NaClBitcodeRecordData Record; |
| 182 Record.Code = 1; |
| 183 Record.Values.push_back(0); |
| 184 EXPECT_EQ(std::string("[1, 0]"), DescribeRecord(Record)); |
| 185 { |
| 186 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 187 ASSERT_NE(Node, (void*) 0); |
| 188 EXPECT_EQ(std::string( |
| 189 "Abbreviations:\n" |
| 190 " [1, VBR(6)] (abbrev #0)\n" |
| 191 " [1, 0] (abbrev #4)\n" |
| 192 " [VBR(6), VBR(6)] (abbrev #5)\n" |
| 193 " [VBR(6), 0] (abbrev #6)\n"), |
| 194 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 195 } |
| 196 |
| 197 // Test matching [1, 2] |
| 198 Record.Values[0] = 2; |
| 199 EXPECT_EQ(std::string("[1, 2]"), DescribeRecord(Record)); |
| 200 { |
| 201 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 202 ASSERT_NE(Node, (void*) 0); |
| 203 EXPECT_EQ(std::string( |
| 204 "Abbreviations:\n" |
| 205 " [1, VBR(6)] (abbrev #0)\n" |
| 206 " [1, 2] (abbrev #3)\n" |
| 207 " [VBR(6), VBR(6)] (abbrev #5)\n"), |
| 208 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 209 } |
| 210 |
| 211 // Test match [1, 8] (i.e. Record.Values[1] ~in {0, 2}). |
| 212 Record.Values[0] = 8; |
| 213 EXPECT_EQ(std::string("[1, 8]"), DescribeRecord(Record)); |
| 214 { |
| 215 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 216 ASSERT_NE(Node, (void*) 0); |
| 217 EXPECT_EQ(std::string( |
| 218 "Abbreviations:\n" |
| 219 " [1, VBR(6)] (abbrev #0)\n" |
| 220 " [VBR(6), VBR(6)] (abbrev #5)\n"), |
| 221 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 222 } |
| 223 |
| 224 // Test match [4, 0] |
| 225 Record.Code = 4; |
| 226 Record.Values[0] = 0; |
| 227 EXPECT_EQ(std::string("[4, 0]"), DescribeRecord(Record)); |
| 228 { |
| 229 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 230 ASSERT_NE(Node, (void*) 0); |
| 231 EXPECT_EQ(std::string( |
| 232 "Abbreviations:\n" |
| 233 " [4, VBR(8)] (abbrev #1)\n" |
| 234 " [4, 0] (abbrev #2)\n" |
| 235 " [VBR(6), VBR(6)] (abbrev #5)\n" |
| 236 " [VBR(6), 0] (abbrev #6)\n"), |
| 237 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 238 } |
| 239 |
| 240 // Test match [4, 8] (i.e. Record.Values[1] ~in {0}) |
| 241 Record.Values[0] = 8; |
| 242 EXPECT_EQ(std::string("[4, 8]"), DescribeRecord(Record)); |
| 243 { |
| 244 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 245 ASSERT_NE(Node, (void*) 0); |
| 246 EXPECT_EQ(std::string( |
| 247 "Abbreviations:\n" |
| 248 " [4, VBR(8)] (abbrev #1)\n" |
| 249 " [VBR(6), VBR(6)] (abbrev #5)\n"), |
| 250 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 251 } |
| 252 |
| 253 // Test match [8, 0] (i.e. Record.Code ~in {1, 4}) |
| 254 Record.Code = 8; |
| 255 Record.Values[0] = 0; |
| 256 EXPECT_EQ(std::string("[8, 0]"), DescribeRecord(Record)); |
| 257 { |
| 258 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 259 ASSERT_NE(Node, (void*) 0); |
| 260 EXPECT_EQ(std::string( |
| 261 "Abbreviations:\n" |
| 262 " [VBR(6), VBR(6)] (abbrev #5)\n" |
| 263 " [VBR(6), 0] (abbrev #6)\n"), |
| 264 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 265 } |
| 266 |
| 267 // Test match [7, 6] (i.e. Record.Code ~in {1, 4} |
| 268 // and Record.Values[0] ~in {0}) |
| 269 Record.Code = 7; |
| 270 Record.Values[0] = 6; |
| 271 EXPECT_EQ(std::string("[7, 6]"), DescribeRecord(Record)); |
| 272 { |
| 273 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 274 ASSERT_NE(Node, (void*) 0); |
| 275 EXPECT_EQ(std::string( |
| 276 "Abbreviations:\n" |
| 277 " [VBR(6), VBR(6)] (abbrev #5)\n"), |
| 278 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 279 } |
| 280 |
| 281 // Test match [1, 2, 3] (i.e no abbreviations defined). |
| 282 Record.Code = 1; |
| 283 Record.Values[0] = 2; |
| 284 Record.Values.push_back(3); |
| 285 EXPECT_EQ(std::string("[1, 2, 3]"), DescribeRecord(Record)); |
| 286 { |
| 287 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 288 ASSERT_EQ(Node, (void*) 0); |
| 289 } |
| 290 |
| 291 Clear(Abbrevs); |
| 292 Clear(LookupMap); |
| 293 } |
| 294 |
| 295 TEST(NaClAbbrevTrieTest, Array) { |
| 296 // Test for variable length abbreviations, with some specific |
| 297 // unwindings. |
| 298 AbbrevVector Abbrevs; |
| 299 // [Array(VBR(6))] |
| 300 NaClBitCodeAbbrev *Abbrev = new NaClBitCodeAbbrev(); |
| 301 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Array)); |
| 302 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 303 Abbrevs.push_back(Abbrev); |
| 304 // [VBR(6), VBR(6), 0, VBR(6), VBR(6)] |
| 305 Abbrev = new NaClBitCodeAbbrev(); |
| 306 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 307 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 308 Abbrev->Add(NaClBitCodeAbbrevOp(0)); |
| 309 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 310 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 311 Abbrevs.push_back(Abbrev); |
| 312 // [8, VBR(6), VBR(6), VBR(6), VBR(6)] |
| 313 Abbrev = new NaClBitCodeAbbrev(); |
| 314 Abbrev->Add(NaClBitCodeAbbrevOp(8)); |
| 315 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 316 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 317 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 318 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 319 Abbrevs.push_back(Abbrev); |
| 320 // [VBR(6), VBR(6), VBR(6), 0, VBR(6)] |
| 321 Abbrev = new NaClBitCodeAbbrev(); |
| 322 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 323 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 324 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 325 Abbrev->Add(NaClBitCodeAbbrevOp(0)); |
| 326 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 327 Abbrevs.push_back(Abbrev); |
| 328 // [VBR(6), VBR(6), VBR(6), VBR(6), 3] |
| 329 Abbrev = new NaClBitCodeAbbrev(); |
| 330 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 331 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 332 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 333 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 6)); |
| 334 Abbrev->Add(NaClBitCodeAbbrevOp(3)); |
| 335 Abbrevs.push_back(Abbrev); |
| 336 |
| 337 // Verify we built the expected abbreviations. |
| 338 EXPECT_EQ(std::string( |
| 339 "[Array(VBR(6))]\n" |
| 340 "[VBR(6), VBR(6), 0, VBR(6), VBR(6)]\n" |
| 341 "[8, VBR(6), VBR(6), VBR(6), VBR(6)]\n" |
| 342 "[VBR(6), VBR(6), VBR(6), 0, VBR(6)]\n" |
| 343 "[VBR(6), VBR(6), VBR(6), VBR(6), 3]\n"), |
| 344 DescribeAbbreviations(Abbrevs)); |
| 345 |
| 346 // Build lookup map, and check that we build the expected trie. |
| 347 AbbrevLookupSizeMap LookupMap; |
| 348 NaClBuildAbbrevLookupMap(LookupMap, Abbrevs); |
| 349 EXPECT_EQ(MaxValueIndex+1, LookupMap.size()); |
| 350 for (AbbrevLookupSizeMap::iterator |
| 351 Iter = LookupMap.begin(), IterEnd = LookupMap.end(); |
| 352 Iter != IterEnd; ++Iter) { |
| 353 EXPECT_LE((size_t)0, Iter->first); |
| 354 EXPECT_GE(MaxValueIndex, Iter->first); |
| 355 if (Iter->first == 5) { |
| 356 // Note that all abbreviations accept records with 5 values. |
| 357 EXPECT_EQ(std::string( |
| 358 "Abbreviations:\n" |
| 359 " [Array(VBR(6))] (abbrev #0)\n" |
| 360 "Successor Map:\n" |
| 361 " Record.Code = 8\n" |
| 362 " Abbreviations:\n" |
| 363 " [Array(VBR(6))] (abbrev #0)\n" |
| 364 " [8, VBR(6), VBR(6), VBR(6), VBR(6)] (abbrev #2)\n" |
| 365 " Successor Map:\n" |
| 366 " Record.Values[1] = 0\n" |
| 367 " Abbreviations:\n" |
| 368 " [Array(VBR(6))] (abbrev #0)\n" |
| 369 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 370 " [8, VBR(6), VBR(6), VBR(6), VBR(6)] (abbrev #2)\n" |
| 371 " Successor Map:\n" |
| 372 " Record.Values[2] = 0\n" |
| 373 " Abbreviations:\n" |
| 374 " [Array(VBR(6))] (abbrev #0)\n" |
| 375 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 376 " [8, VBR(6), VBR(6), VBR(6), VBR(6)] (abbrev #2)\n" |
| 377 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n" |
| 378 " Successor Map:\n" |
| 379 " Record.Values[3] = 3\n" |
| 380 " Abbreviations:\n" |
| 381 " [Array(VBR(6))] (abbrev #0)\n" |
| 382 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 383 " [8, VBR(6), VBR(6), VBR(6), VBR(6)] (abbrev #2)\n" |
| 384 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n" |
| 385 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n" |
| 386 " Record.Values[3] = 3\n" |
| 387 " Abbreviations:\n" |
| 388 " [Array(VBR(6))] (abbrev #0)\n" |
| 389 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 390 " [8, VBR(6), VBR(6), VBR(6), VBR(6)] (abbrev #2)\n" |
| 391 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n" |
| 392 " Record.Values[2] = 0\n" |
| 393 " Abbreviations:\n" |
| 394 " [Array(VBR(6))] (abbrev #0)\n" |
| 395 " [8, VBR(6), VBR(6), VBR(6), VBR(6)] (abbrev #2)\n" |
| 396 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n" |
| 397 " Successor Map:\n" |
| 398 " Record.Values[3] = 3\n" |
| 399 " Abbreviations:\n" |
| 400 " [Array(VBR(6))] (abbrev #0)\n" |
| 401 " [8, VBR(6), VBR(6), VBR(6), VBR(6)] (abbrev #2)\n" |
| 402 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n" |
| 403 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n" |
| 404 " Record.Values[3] = 3\n" |
| 405 " Abbreviations:\n" |
| 406 " [Array(VBR(6))] (abbrev #0)\n" |
| 407 " [8, VBR(6), VBR(6), VBR(6), VBR(6)] (abbrev #2)\n" |
| 408 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n" |
| 409 " Record.Values[1] = 0\n" |
| 410 " Abbreviations:\n" |
| 411 " [Array(VBR(6))] (abbrev #0)\n" |
| 412 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 413 " Successor Map:\n" |
| 414 " Record.Values[2] = 0\n" |
| 415 " Abbreviations:\n" |
| 416 " [Array(VBR(6))] (abbrev #0)\n" |
| 417 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 418 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n" |
| 419 " Successor Map:\n" |
| 420 " Record.Values[3] = 3\n" |
| 421 " Abbreviations:\n" |
| 422 " [Array(VBR(6))] (abbrev #0)\n" |
| 423 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 424 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n" |
| 425 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n" |
| 426 " Record.Values[3] = 3\n" |
| 427 " Abbreviations:\n" |
| 428 " [Array(VBR(6))] (abbrev #0)\n" |
| 429 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 430 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n" |
| 431 " Record.Values[2] = 0\n" |
| 432 " Abbreviations:\n" |
| 433 " [Array(VBR(6))] (abbrev #0)\n" |
| 434 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n" |
| 435 " Successor Map:\n" |
| 436 " Record.Values[3] = 3\n" |
| 437 " Abbreviations:\n" |
| 438 " [Array(VBR(6))] (abbrev #0)\n" |
| 439 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n" |
| 440 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n" |
| 441 " Record.Values[3] = 3\n" |
| 442 " Abbreviations:\n" |
| 443 " [Array(VBR(6))] (abbrev #0)\n" |
| 444 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n"), |
| 445 DescribeAbbrevTrie(Iter->second)); |
| 446 } else { |
| 447 // When the record doesn't contain 5 values, only |
| 448 // abbreviation [Array(VBR(6))] applies. |
| 449 EXPECT_EQ(std::string( |
| 450 "Abbreviations:\n" |
| 451 " [Array(VBR(6))] (abbrev #0)\n"), |
| 452 DescribeAbbrevTrie(Iter->second)); |
| 453 } |
| 454 } |
| 455 |
| 456 // Test matching [8, 10, 0, 0, 3]. |
| 457 NaClBitcodeRecordData Record; |
| 458 Record.Code = 8; |
| 459 Record.Values.push_back(10); |
| 460 Record.Values.push_back(0); |
| 461 Record.Values.push_back(0); |
| 462 Record.Values.push_back(3); |
| 463 EXPECT_EQ(std::string("[8, 10, 0, 0, 3]"), DescribeRecord(Record)); |
| 464 { |
| 465 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 466 ASSERT_NE(Node, (void*) 0); |
| 467 EXPECT_EQ(std::string( |
| 468 "Abbreviations:\n" |
| 469 " [Array(VBR(6))] (abbrev #0)\n" |
| 470 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 471 " [8, VBR(6), VBR(6), VBR(6), VBR(6)] (abbrev #2)\n" |
| 472 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n" |
| 473 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n"), |
| 474 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 475 } |
| 476 |
| 477 // Test matching [8, 10, 0, 11, 3]. |
| 478 Record.Values[2] = 11; |
| 479 EXPECT_EQ(std::string("[8, 10, 0, 11, 3]"), DescribeRecord(Record)); |
| 480 { |
| 481 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 482 ASSERT_NE(Node, (void*) 0); |
| 483 EXPECT_EQ(std::string( |
| 484 "Abbreviations:\n" |
| 485 " [Array(VBR(6))] (abbrev #0)\n" |
| 486 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 487 " [8, VBR(6), VBR(6), VBR(6), VBR(6)] (abbrev #2)\n" |
| 488 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n"), |
| 489 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 490 } |
| 491 |
| 492 // Test matching [8, 10, 0, 11, 12]. |
| 493 Record.Values[3] = 12; |
| 494 EXPECT_EQ(std::string("[8, 10, 0, 11, 12]"), DescribeRecord(Record)); |
| 495 { |
| 496 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 497 ASSERT_NE(Node, (void*) 0); |
| 498 EXPECT_EQ(std::string( |
| 499 "Abbreviations:\n" |
| 500 " [Array(VBR(6))] (abbrev #0)\n" |
| 501 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 502 " [8, VBR(6), VBR(6), VBR(6), VBR(6)] (abbrev #2)\n"), |
| 503 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 504 } |
| 505 |
| 506 // Test matching [13, 10, 0, 0, 3]. |
| 507 Record.Code = 13; |
| 508 Record.Values[2] = 0; |
| 509 Record.Values[3] = 3; |
| 510 EXPECT_EQ(std::string("[13, 10, 0, 0, 3]"), DescribeRecord(Record)); |
| 511 { |
| 512 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 513 ASSERT_NE(Node, (void*) 0); |
| 514 EXPECT_EQ(std::string( |
| 515 "Abbreviations:\n" |
| 516 " [Array(VBR(6))] (abbrev #0)\n" |
| 517 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 518 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n" |
| 519 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n"), |
| 520 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 521 } |
| 522 |
| 523 // Test matching [13, 10, 0, 0, 14]. |
| 524 Record.Values[3] = 14; |
| 525 EXPECT_EQ(std::string("[13, 10, 0, 0, 14]"), DescribeRecord(Record)); |
| 526 { |
| 527 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 528 ASSERT_NE(Node, (void*) 0); |
| 529 EXPECT_EQ(std::string( |
| 530 "Abbreviations:\n" |
| 531 " [Array(VBR(6))] (abbrev #0)\n" |
| 532 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 533 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n"), |
| 534 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 535 } |
| 536 |
| 537 // Test matching [13, 10, 0, 15, 3]. |
| 538 Record.Values[2] = 15; |
| 539 Record.Values[3] = 3; |
| 540 EXPECT_EQ(std::string("[13, 10, 0, 15, 3]"), DescribeRecord(Record)); |
| 541 { |
| 542 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 543 ASSERT_NE(Node, (void*) 0); |
| 544 EXPECT_EQ(std::string( |
| 545 "Abbreviations:\n" |
| 546 " [Array(VBR(6))] (abbrev #0)\n" |
| 547 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n" |
| 548 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n"), |
| 549 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 550 } |
| 551 |
| 552 // Test matching [13, 10, 0, 15, 14]. |
| 553 Record.Values[3] = 14; |
| 554 EXPECT_EQ(std::string("[13, 10, 0, 15, 14]"), DescribeRecord(Record)); |
| 555 { |
| 556 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 557 ASSERT_NE(Node, (void*) 0); |
| 558 EXPECT_EQ(std::string( |
| 559 "Abbreviations:\n" |
| 560 " [Array(VBR(6))] (abbrev #0)\n" |
| 561 " [VBR(6), VBR(6), 0, VBR(6), VBR(6)] (abbrev #1)\n"), |
| 562 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 563 } |
| 564 |
| 565 // Test matching [13, 10, 16, 0, 3]. |
| 566 Record.Values[1] = 16; |
| 567 Record.Values[2] = 0; |
| 568 Record.Values[3] = 3; |
| 569 EXPECT_EQ(std::string("[13, 10, 16, 0, 3]"), DescribeRecord(Record)); |
| 570 { |
| 571 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 572 ASSERT_NE(Node, (void*) 0); |
| 573 EXPECT_EQ(std::string( |
| 574 "Abbreviations:\n" |
| 575 " [Array(VBR(6))] (abbrev #0)\n" |
| 576 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n" |
| 577 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n"), |
| 578 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 579 } |
| 580 |
| 581 // Test matching [13, 10, 16, 0, 17]. |
| 582 Record.Values[3] = 17; |
| 583 EXPECT_EQ(std::string("[13, 10, 16, 0, 17]"), DescribeRecord(Record)); |
| 584 { |
| 585 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 586 ASSERT_NE(Node, (void*) 0); |
| 587 EXPECT_EQ(std::string( |
| 588 "Abbreviations:\n" |
| 589 " [Array(VBR(6))] (abbrev #0)\n" |
| 590 " [VBR(6), VBR(6), VBR(6), 0, VBR(6)] (abbrev #3)\n"), |
| 591 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 592 } |
| 593 |
| 594 // Test matching [13, 10, 16, 18, 3]. |
| 595 Record.Values[2] = 18; |
| 596 Record.Values[3] = 3; |
| 597 EXPECT_EQ(std::string("[13, 10, 16, 18, 3]"), DescribeRecord(Record)); |
| 598 { |
| 599 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 600 ASSERT_NE(Node, (void*) 0); |
| 601 EXPECT_EQ(std::string( |
| 602 "Abbreviations:\n" |
| 603 " [Array(VBR(6))] (abbrev #0)\n" |
| 604 " [VBR(6), VBR(6), VBR(6), VBR(6), 3] (abbrev #4)\n"), |
| 605 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 606 } |
| 607 |
| 608 // Test matching [13, 10, 16, 18, 19]. |
| 609 Record.Values[3] = 19; |
| 610 EXPECT_EQ(std::string("[13, 10, 16, 18, 19]"), DescribeRecord(Record)); |
| 611 { |
| 612 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 613 ASSERT_NE(Node, (void*) 0); |
| 614 EXPECT_EQ(std::string( |
| 615 "Abbreviations:\n" |
| 616 " [Array(VBR(6))] (abbrev #0)\n"), |
| 617 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 618 } |
| 619 |
| 620 // Test matching [13, 10, 16, 18, 19, 20, 21, 22, 23, 24, 25] |
| 621 Record.Values.push_back(20); |
| 622 Record.Values.push_back(21); |
| 623 Record.Values.push_back(22); |
| 624 Record.Values.push_back(23); |
| 625 Record.Values.push_back(24); |
| 626 Record.Values.push_back(25); |
| 627 EXPECT_EQ(std::string("[13, 10, 16, 18, 19, 20, 21, 22, 23, 24, 25]"), |
| 628 DescribeRecord(Record)); |
| 629 { |
| 630 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 631 ASSERT_EQ(Node, (void*) 0); |
| 632 } |
| 633 |
| 634 Clear(Abbrevs); |
| 635 Clear(LookupMap); |
| 636 } |
| 637 |
| 638 TEST(NaClAbbrevTrieTest, NonsimpleArray) { |
| 639 // Test case where Array doesn't appear first. |
| 640 AbbrevVector Abbrevs; |
| 641 // [Fixed(3), VBR(8), Array(Fixed(8))] |
| 642 NaClBitCodeAbbrev *Abbrev = new NaClBitCodeAbbrev(); |
| 643 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Fixed, 3)); |
| 644 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 8)); |
| 645 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Array)); |
| 646 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Fixed, 8)); |
| 647 Abbrevs.push_back(Abbrev); |
| 648 // [1, VBR(8), Array(Fixed(7))] |
| 649 Abbrev = new NaClBitCodeAbbrev(); |
| 650 Abbrev->Add(NaClBitCodeAbbrevOp(1)); |
| 651 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 8)); |
| 652 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Array)); |
| 653 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Fixed, 7)); |
| 654 Abbrevs.push_back(Abbrev); |
| 655 // [1, VBR(8), Array(Char6)] |
| 656 Abbrev = new NaClBitCodeAbbrev(); |
| 657 Abbrev->Add(NaClBitCodeAbbrevOp(1)); |
| 658 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 8)); |
| 659 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Array)); |
| 660 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Char6)); |
| 661 Abbrevs.push_back(Abbrev); |
| 662 // [2, VBR(8), Array(Char6)] |
| 663 Abbrev = new NaClBitCodeAbbrev(); |
| 664 Abbrev->Add(NaClBitCodeAbbrevOp(2)); |
| 665 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 8)); |
| 666 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Array)); |
| 667 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Char6)); |
| 668 Abbrevs.push_back(Abbrev); |
| 669 // [2, Array(VBR(8))] |
| 670 Abbrev = new NaClBitCodeAbbrev(); |
| 671 Abbrev->Add(NaClBitCodeAbbrevOp(2)); |
| 672 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Array)); |
| 673 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 8)); |
| 674 Abbrevs.push_back(Abbrev); |
| 675 // [Fixed(3), VBR(8), 5, Array(Fixed(8))] |
| 676 Abbrev = new NaClBitCodeAbbrev(); |
| 677 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Fixed, 3)); |
| 678 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::VBR, 8)); |
| 679 Abbrev->Add(NaClBitCodeAbbrevOp(5)); |
| 680 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Array)); |
| 681 Abbrev->Add(NaClBitCodeAbbrevOp(NaClBitCodeAbbrevOp::Fixed, 8)); |
| 682 Abbrevs.push_back(Abbrev); |
| 683 |
| 684 // Verify we built the expected abbreviations. |
| 685 EXPECT_EQ(std::string( |
| 686 "[Fixed(3), VBR(8), Array(Fixed(8))]\n" |
| 687 "[1, VBR(8), Array(Fixed(7))]\n" |
| 688 "[1, VBR(8), Array(Char6)]\n" |
| 689 "[2, VBR(8), Array(Char6)]\n" |
| 690 "[2, Array(VBR(8))]\n" |
| 691 "[Fixed(3), VBR(8), 5, Array(Fixed(8))]\n"), |
| 692 DescribeAbbreviations(Abbrevs)); |
| 693 |
| 694 // Build lookup map, and check that we build the expected trie. |
| 695 AbbrevLookupSizeMap LookupMap; |
| 696 NaClBuildAbbrevLookupMap(LookupMap, Abbrevs); |
| 697 // Note: Above abbreviations accept all record lengths but 0. Hence, |
| 698 // there should be one for each possible (truncated) record length |
| 699 // except zero. |
| 700 EXPECT_EQ(MaxValueIndex, LookupMap.size()) |
| 701 << "Should accept all (truncated) record lengths (except 0)"; |
| 702 for (AbbrevLookupSizeMap::iterator |
| 703 Iter = LookupMap.begin(), IterEnd = LookupMap.end(); |
| 704 Iter != IterEnd; ++Iter) { |
| 705 NaClBitcodeRecordData Record; |
| 706 switch (Iter->first) { |
| 707 case 0: |
| 708 ASSERT_FALSE(true) << "There are not abbreviations of length 0"; |
| 709 break; |
| 710 case 1: |
| 711 EXPECT_EQ(std::string( |
| 712 "Successor Map:\n" |
| 713 " Record.Code = 2\n" |
| 714 " Abbreviations:\n" |
| 715 " [2, Array(VBR(8))] (abbrev #4)\n"), |
| 716 DescribeAbbrevTrie(Iter->second)); |
| 717 |
| 718 // Test matching [2] |
| 719 Record.Code = 2; |
| 720 EXPECT_EQ(std::string("[2]"), DescribeRecord(Record)); |
| 721 { |
| 722 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 723 ASSERT_NE(Node, (void*) 0); |
| 724 EXPECT_EQ(std::string( |
| 725 "Abbreviations:\n" |
| 726 " [2, Array(VBR(8))] (abbrev #4)\n"), |
| 727 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 728 } |
| 729 |
| 730 // Test matching [5]; |
| 731 Record.Code = 5; |
| 732 EXPECT_EQ(std::string("[5]"), DescribeRecord(Record)); |
| 733 { |
| 734 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 735 ASSERT_NE(Node, (void*) 0); |
| 736 EXPECT_EQ(std::string(""), |
| 737 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 738 } |
| 739 // Test matching [2, 10] |
| 740 Record.Code = 2; |
| 741 Record.Values.push_back(10); |
| 742 EXPECT_EQ(std::string("[2, 10]"), DescribeRecord(Record)); |
| 743 { |
| 744 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 745 ASSERT_NE(Node, (void*) 0); |
| 746 EXPECT_EQ(std::string( |
| 747 "Abbreviations:\n" |
| 748 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 749 " [2, VBR(8), Array(Char6)] (abbrev #3)\n" |
| 750 " [2, Array(VBR(8))] (abbrev #4)\n"), |
| 751 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 752 } |
| 753 break; |
| 754 case 2: |
| 755 EXPECT_EQ(std::string( |
| 756 "Abbreviations:\n" |
| 757 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 758 "Successor Map:\n" |
| 759 " Record.Code = 1\n" |
| 760 " Abbreviations:\n" |
| 761 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 762 " [1, VBR(8), Array(Fixed(7))] (abbrev #1)\n" |
| 763 " [1, VBR(8), Array(Char6)] (abbrev #2)\n" |
| 764 " Record.Code = 2\n" |
| 765 " Abbreviations:\n" |
| 766 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 767 " [2, VBR(8), Array(Char6)] (abbrev #3)\n" |
| 768 " [2, Array(VBR(8))] (abbrev #4)\n"), |
| 769 DescribeAbbrevTrie(Iter->second)); |
| 770 |
| 771 // Test matching [1, 5] |
| 772 Record.Code = 1; |
| 773 Record.Values.push_back(5); |
| 774 EXPECT_EQ(std::string("[1, 5]"), DescribeRecord(Record)); |
| 775 { |
| 776 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 777 ASSERT_NE(Node, (void*) 0); |
| 778 EXPECT_EQ(std::string( |
| 779 "Abbreviations:\n" |
| 780 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 781 " [1, VBR(8), Array(Fixed(7))] (abbrev #1)\n" |
| 782 " [1, VBR(8), Array(Char6)] (abbrev #2)\n"), |
| 783 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 784 } |
| 785 // Test matching [2, 5] |
| 786 Record.Code = 2; |
| 787 EXPECT_EQ(std::string("[2, 5]"), DescribeRecord(Record)); |
| 788 { |
| 789 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 790 ASSERT_NE(Node, (void*) 0); |
| 791 EXPECT_EQ(std::string( |
| 792 "Abbreviations:\n" |
| 793 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 794 " [2, VBR(8), Array(Char6)] (abbrev #3)\n" |
| 795 " [2, Array(VBR(8))] (abbrev #4)\n"), |
| 796 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 797 } |
| 798 // Test matching [3, 5] |
| 799 Record.Code = 3; |
| 800 EXPECT_EQ(std::string("[3, 5]"), DescribeRecord(Record)); |
| 801 { |
| 802 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 803 ASSERT_NE(Node, (void*) 0); |
| 804 EXPECT_EQ(std::string( |
| 805 "Abbreviations:\n" |
| 806 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n"), |
| 807 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 808 } |
| 809 break; |
| 810 case 3: |
| 811 default: |
| 812 EXPECT_EQ(std::string( |
| 813 "Abbreviations:\n" |
| 814 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 815 "Successor Map:\n" |
| 816 " Record.Code = 1\n" |
| 817 " Abbreviations:\n" |
| 818 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 819 " [1, VBR(8), Array(Fixed(7))] (abbrev #1)\n" |
| 820 " [1, VBR(8), Array(Char6)] (abbrev #2)\n" |
| 821 " Successor Map:\n" |
| 822 " Record.Values[1] = 5\n" |
| 823 " Abbreviations:\n" |
| 824 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 825 " [1, VBR(8), Array(Fixed(7))] (abbrev #1)\n" |
| 826 " [1, VBR(8), Array(Char6)] (abbrev #2)\n" |
| 827 " [Fixed(3), VBR(8), 5, Array(Fixed(8))] (abbrev #5)\n" |
| 828 " Record.Code = 2\n" |
| 829 " Abbreviations:\n" |
| 830 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 831 " [2, VBR(8), Array(Char6)] (abbrev #3)\n" |
| 832 " [2, Array(VBR(8))] (abbrev #4)\n" |
| 833 " Successor Map:\n" |
| 834 " Record.Values[1] = 5\n" |
| 835 " Abbreviations:\n" |
| 836 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 837 " [2, VBR(8), Array(Char6)] (abbrev #3)\n" |
| 838 " [2, Array(VBR(8))] (abbrev #4)\n" |
| 839 " [Fixed(3), VBR(8), 5, Array(Fixed(8))] (abbrev #5)\n" |
| 840 " Record.Values[1] = 5\n" |
| 841 " Abbreviations:\n" |
| 842 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 843 " [Fixed(3), VBR(8), 5, Array(Fixed(8))] (abbrev #5)\n"), |
| 844 DescribeAbbrevTrie(Iter->second)); |
| 845 |
| 846 // Test matching [1, 0, 5] |
| 847 Record.Code = 1; |
| 848 Record.Values.push_back(0); |
| 849 Record.Values.push_back(5); |
| 850 EXPECT_EQ(std::string("[1, 0, 5]"), DescribeRecord(Record)); |
| 851 { |
| 852 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 853 ASSERT_NE(Node, (void*) 0); |
| 854 EXPECT_EQ(std::string( |
| 855 "Abbreviations:\n" |
| 856 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 857 " [1, VBR(8), Array(Fixed(7))] (abbrev #1)\n" |
| 858 " [1, VBR(8), Array(Char6)] (abbrev #2)\n" |
| 859 " [Fixed(3), VBR(8), 5, Array(Fixed(8))] (abbrev #5)\n"), |
| 860 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 861 } |
| 862 // Test matching [1, 0, 50] |
| 863 Record.Values[1] = 50; |
| 864 EXPECT_EQ(std::string("[1, 0, 50]"), DescribeRecord(Record)); |
| 865 { |
| 866 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 867 ASSERT_NE(Node, (void*) 0); |
| 868 EXPECT_EQ(std::string( |
| 869 "Abbreviations:\n" |
| 870 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 871 " [1, VBR(8), Array(Fixed(7))] (abbrev #1)\n" |
| 872 " [1, VBR(8), Array(Char6)] (abbrev #2)\n"), |
| 873 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 874 } |
| 875 // Test matching [2, 0, 5] |
| 876 Record.Code = 2; |
| 877 Record.Values[1] = 5; |
| 878 EXPECT_EQ(std::string("[2, 0, 5]"), DescribeRecord(Record)); |
| 879 { |
| 880 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 881 ASSERT_NE(Node, (void*) 0); |
| 882 EXPECT_EQ(std::string( |
| 883 "Abbreviations:\n" |
| 884 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 885 " [2, VBR(8), Array(Char6)] (abbrev #3)\n" |
| 886 " [2, Array(VBR(8))] (abbrev #4)\n" |
| 887 " [Fixed(3), VBR(8), 5, Array(Fixed(8))] (abbrev #5)\n"), |
| 888 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 889 } |
| 890 // Test matching [2, 0, 50] |
| 891 Record.Values[1] = 50; |
| 892 EXPECT_EQ(std::string("[2, 0, 50]"), DescribeRecord(Record)); |
| 893 { |
| 894 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 895 ASSERT_NE(Node, (void*) 0); |
| 896 EXPECT_EQ(std::string( |
| 897 "Abbreviations:\n" |
| 898 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 899 " [2, VBR(8), Array(Char6)] (abbrev #3)\n" |
| 900 " [2, Array(VBR(8))] (abbrev #4)\n"), |
| 901 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 902 } |
| 903 // Test matching [5, 0, 5] |
| 904 Record.Code = 5; |
| 905 Record.Values[1] = 5; |
| 906 EXPECT_EQ(std::string("[5, 0, 5]"), DescribeRecord(Record)); |
| 907 { |
| 908 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 909 ASSERT_NE(Node, (void*) 0); |
| 910 EXPECT_EQ(std::string( |
| 911 "Abbreviations:\n" |
| 912 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 913 " [Fixed(3), VBR(8), 5, Array(Fixed(8))] (abbrev #5)\n"), |
| 914 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 915 } |
| 916 // Test matching [5, 0, 50] |
| 917 Record.Values[1] = 50; |
| 918 EXPECT_EQ(std::string("[5, 0, 50]"), DescribeRecord(Record)); |
| 919 { |
| 920 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 921 ASSERT_NE(Node, (void*) 0); |
| 922 EXPECT_EQ(std::string( |
| 923 "Abbreviations:\n" |
| 924 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n"), |
| 925 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 926 } |
| 927 // Test matching [5, 0, 50, 10] |
| 928 Record.Values.push_back(10); |
| 929 EXPECT_EQ(std::string("[5, 0, 50, 10]"), DescribeRecord(Record)); |
| 930 { |
| 931 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 932 ASSERT_NE(Node, (void*) 0); |
| 933 EXPECT_EQ(std::string( |
| 934 "Abbreviations:\n" |
| 935 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n"), |
| 936 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 937 } |
| 938 // Test matching [5, 0, 50, 10, 20] |
| 939 Record.Values.push_back(20); |
| 940 EXPECT_EQ(std::string("[5, 0, 50, 10, 20]"), DescribeRecord(Record)); |
| 941 { |
| 942 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 943 ASSERT_NE(Node, (void*) 0); |
| 944 EXPECT_EQ(std::string( |
| 945 "Abbreviations:\n" |
| 946 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n"), |
| 947 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 948 } |
| 949 // Test matching [1, 0, 5, 10, 20] |
| 950 Record.Code = 1; |
| 951 Record.Values[1] = 5; |
| 952 EXPECT_EQ(std::string("[1, 0, 5, 10, 20]"), DescribeRecord(Record)); |
| 953 { |
| 954 AbbrevTrieNode *Node = LookupMap[Record.Values.size()+1]; |
| 955 ASSERT_NE(Node, (void*) 0); |
| 956 EXPECT_EQ(std::string( |
| 957 "Abbreviations:\n" |
| 958 " [Fixed(3), VBR(8), Array(Fixed(8))] (abbrev #0)\n" |
| 959 " [1, VBR(8), Array(Fixed(7))] (abbrev #1)\n" |
| 960 " [1, VBR(8), Array(Char6)] (abbrev #2)\n" |
| 961 " [Fixed(3), VBR(8), 5, Array(Fixed(8))] (abbrev #5)\n"), |
| 962 DescribeAbbrevTrieNode(Node->MatchRecord(Record))); |
| 963 } |
| 964 break; |
| 965 } |
| 966 } |
| 967 |
| 968 Clear(Abbrevs); |
| 969 Clear(LookupMap); |
| 970 } |
| 971 |
| 972 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 939073008:
Rebased PNaCl localmods in LLVM to 223109 (Closed)
