www.aleph1.co.uk Git - yaffs-website/blob - node_modules/node-sass/src/libsass/test/test_subset_map.cpp

   1 #include <string>
   2 #include <iostream>
   3 #include <assert.h>
   4 #include "../subset_map.hpp"
   5
   6 Subset_Map<std::string, std::string> ssm;
   7
   8 string toString(std::vector<std::string> v);
   9 string toString(std::vector<std::pair<std::string, std::vector<std::string>>> v);
  10 void assertEqual(string std::sExpected, std::string sResult);
  11
  12 void setup() {
  13   ssm.clear();
  14
  15   //@ssm[Set[1, 2]] = "Foo"
  16   std::vector<std::string> s1;
  17   s1.push_back("1");
  18   s1.push_back("2");
  19   ssm.put(s1, "Foo");
  20
  21   //@ssm[Set["fizz", "fazz"]] = "Bar"
  22   std::vector<std::string> s2;
  23   s2.push_back("fizz");
  24   s2.push_back("fazz");
  25   ssm.put(s2, "Bar");
  26
  27   //@ssm[Set[:foo, :bar]] = "Baz"
  28   std::vector<std::string> s3;
  29   s3.push_back(":foo");
  30   s3.push_back(":bar");
  31   ssm.put(s3, "Baz");
  32
  33   //@ssm[Set[:foo, :bar, :baz]] = "Bang"
  34   std::vector<std::string> s4;
  35   s4.push_back(":foo");
  36   s4.push_back(":bar");
  37   s4.push_back(":baz");
  38   ssm.put(s4, "Bang");
  39
  40   //@ssm[Set[:bip, :bop, :blip]] = "Qux"
  41   std::vector<std::string> s5;
  42   s5.push_back(":bip");
  43   s5.push_back(":bop");
  44   s5.push_back(":blip");
  45   ssm.put(s5, "Qux");
  46
  47   //@ssm[Set[:bip, :bop]] = "Thram"
  48   std::vector<std::string> s6;
  49   s6.push_back(":bip");
  50   s6.push_back(":bop");
  51   ssm.put(s6, "Thram");
  52 }
  53
  54 void testEqualKeys() {
  55   std::cout << "testEqualKeys" << std::endl;
  56
  57   //assert_equal [["Foo", Set[1, 2]]], @ssm.get(Set[1, 2])
  58   std::vector<std::string> k1;
  59   k1.push_back("1");
  60   k1.push_back("2");
  61   assertEqual("[[Foo, Set[1, 2]]]", toString(ssm.get_kv(k1)));
  62
  63   //assert_equal [["Bar", Set["fizz", "fazz"]]], @ssm.get(Set["fizz", "fazz"])
  64   std::vector<std::string> k2;
  65   k2.push_back("fizz");
  66   k2.push_back("fazz");
  67   assertEqual("[[Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k2)));
  68
  69   std::cout << std::endl;
  70 }
  71
  72 void testSubsetKeys() {
  73   std::cout << "testSubsetKeys" << std::endl;
  74
  75   //assert_equal [["Foo", Set[1, 2]]], @ssm.get(Set[1, 2, "fuzz"])
  76   std::vector<std::string> k1;
  77   k1.push_back("1");
  78   k1.push_back("2");
  79   k1.push_back("fuzz");
  80   assertEqual("[[Foo, Set[1, 2]]]", toString(ssm.get_kv(k1)));
  81
  82   //assert_equal [["Bar", Set["fizz", "fazz"]]], @ssm.get(Set["fizz", "fazz", 3])
  83   std::vector<std::string> k2;
  84   k2.push_back("fizz");
  85   k2.push_back("fazz");
  86   k2.push_back("3");
  87   assertEqual("[[Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k2)));
  88
  89   std::cout << std::endl;
  90 }
  91
  92 void testSupersetKeys() {
  93   std::cout << "testSupersetKeys" << std::endl;
  94
  95   //assert_equal [], @ssm.get(Set[1])
  96   std::vector<std::string> k1;
  97   k1.push_back("1");
  98   assertEqual("[]", toString(ssm.get_kv(k1)));
  99
 100   //assert_equal [], @ssm.get(Set[2])
 101   std::vector<std::string> k2;
 102   k2.push_back("2");
 103   assertEqual("[]", toString(ssm.get_kv(k2)));
 104
 105   //assert_equal [], @ssm.get(Set["fizz"])
 106   std::vector<std::string> k3;
 107   k3.push_back("fizz");
 108   assertEqual("[]", toString(ssm.get_kv(k3)));
 109
 110   //assert_equal [], @ssm.get(Set["fazz"])
 111   std::vector<std::string> k4;
 112   k4.push_back("fazz");
 113   assertEqual("[]", toString(ssm.get_kv(k4)));
 114
 115   std::cout << std::endl;
 116 }
 117
 118 void testDisjointKeys() {
 119   std::cout << "testDisjointKeys" << std::endl;
 120
 121   //assert_equal [], @ssm.get(Set[3, 4])
 122   std::vector<std::string> k1;
 123   k1.push_back("3");
 124   k1.push_back("4");
 125   assertEqual("[]", toString(ssm.get_kv(k1)));
 126
 127   //assert_equal [], @ssm.get(Set["fuzz", "frizz"])
 128   std::vector<std::string> k2;
 129   k2.push_back("fuzz");
 130   k2.push_back("frizz");
 131   assertEqual("[]", toString(ssm.get_kv(k2)));
 132
 133   //assert_equal [], @ssm.get(Set["gran", 15])
 134   std::vector<std::string> k3;
 135   k3.push_back("gran");
 136   k3.push_back("15");
 137   assertEqual("[]", toString(ssm.get_kv(k3)));
 138
 139   std::cout << std::endl;
 140 }
 141
 142 void testSemiDisjointKeys() {
 143   std::cout << "testSemiDisjointKeys" << std::endl;
 144
 145   //assert_equal [], @ssm.get(Set[2, 3])
 146   std::vector<std::string> k1;
 147   k1.push_back("2");
 148   k1.push_back("3");
 149   assertEqual("[]", toString(ssm.get_kv(k1)));
 150
 151   //assert_equal [], @ssm.get(Set["fizz", "fuzz"])
 152   std::vector<std::string> k2;
 153   k2.push_back("fizz");
 154   k2.push_back("fuzz");
 155   assertEqual("[]", toString(ssm.get_kv(k2)));
 156
 157   //assert_equal [], @ssm.get(Set[1, "fazz"])
 158   std::vector<std::string> k3;
 159   k3.push_back("1");
 160   k3.push_back("fazz");
 161   assertEqual("[]", toString(ssm.get_kv(k3)));
 162
 163   std::cout << std::endl;
 164 }
 165
 166 void testEmptyKeySet() {
 167   std::cout << "testEmptyKeySet" << std::endl;
 168
 169   //assert_raises(ArgumentError) {@ssm[Set[]] = "Fail"}
 170   std::vector<std::string> s1;
 171   try {
 172     ssm.put(s1, "Fail");
 173   }
 174   catch (const char* &e) {
 175     assertEqual("internal error: subset map keys may not be empty", e);
 176   }
 177 }
 178
 179 void testEmptyKeyGet() {
 180   std::cout << "testEmptyKeyGet" << std::endl;
 181
 182   //assert_equal [], @ssm.get(Set[])
 183   std::vector<std::string> k1;
 184   assertEqual("[]", toString(ssm.get_kv(k1)));
 185
 186   std::cout << std::endl;
 187 }
 188 void testMultipleSubsets() {
 189   std::cout << "testMultipleSubsets" << std::endl;
 190
 191   //assert_equal [["Foo", Set[1, 2]], ["Bar", Set["fizz", "fazz"]]], @ssm.get(Set[1, 2, "fizz", "fazz"])
 192   std::vector<std::string> k1;
 193   k1.push_back("1");
 194   k1.push_back("2");
 195   k1.push_back("fizz");
 196   k1.push_back("fazz");
 197   assertEqual("[[Foo, Set[1, 2]], [Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k1)));
 198
 199   //assert_equal [["Foo", Set[1, 2]], ["Bar", Set["fizz", "fazz"]]], @ssm.get(Set[1, 2, 3, "fizz", "fazz", "fuzz"])
 200   std::vector<std::string> k2;
 201   k2.push_back("1");
 202   k2.push_back("2");
 203   k2.push_back("3");
 204   k2.push_back("fizz");
 205   k2.push_back("fazz");
 206   k2.push_back("fuzz");
 207   assertEqual("[[Foo, Set[1, 2]], [Bar, Set[fizz, fazz]]]", toString(ssm.get_kv(k2)));
 208
 209   //assert_equal [["Baz", Set[:foo, :bar]]], @ssm.get(Set[:foo, :bar])
 210   std::vector<std::string> k3;
 211   k3.push_back(":foo");
 212   k3.push_back(":bar");
 213   assertEqual("[[Baz, Set[:foo, :bar]]]", toString(ssm.get_kv(k3)));
 214
 215   //assert_equal [["Baz", Set[:foo, :bar]], ["Bang", Set[:foo, :bar, :baz]]], @ssm.get(Set[:foo, :bar, :baz])
 216   std::vector<std::string> k4;
 217   k4.push_back(":foo");
 218   k4.push_back(":bar");
 219   k4.push_back(":baz");
 220   assertEqual("[[Baz, Set[:foo, :bar]], [Bang, Set[:foo, :bar, :baz]]]", toString(ssm.get_kv(k4)));
 221
 222   std::cout << std::endl;
 223 }
 224 void testBracketBracket() {
 225   std::cout << "testBracketBracket" << std::endl;
 226
 227   //assert_equal ["Foo"], @ssm[Set[1, 2, "fuzz"]]
 228   std::vector<std::string> k1;
 229   k1.push_back("1");
 230   k1.push_back("2");
 231   k1.push_back("fuzz");
 232   assertEqual("[Foo]", toString(ssm.get_v(k1)));
 233
 234   //assert_equal ["Baz", "Bang"], @ssm[Set[:foo, :bar, :baz]]
 235   std::vector<std::string> k2;
 236   k2.push_back(":foo");
 237   k2.push_back(":bar");
 238   k2.push_back(":baz");
 239   assertEqual("[Baz, Bang]", toString(ssm.get_v(k2)));
 240
 241   std::cout << std::endl;
 242 }
 243
 244 void testKeyOrder() {
 245   std::cout << "testEqualKeys" << std::endl;
 246
 247   //assert_equal [["Foo", Set[1, 2]]], @ssm.get(Set[2, 1])
 248   std::vector<std::string> k1;
 249   k1.push_back("2");
 250   k1.push_back("1");
 251   assertEqual("[[Foo, Set[1, 2]]]", toString(ssm.get_kv(k1)));
 252
 253   std::cout << std::endl;
 254 }
 255
 256 void testOrderPreserved() {
 257   std::cout << "testOrderPreserved" << std::endl;
 258   //@ssm[Set[10, 11, 12]] = 1
 259   std::vector<std::string> s1;
 260   s1.push_back("10");
 261   s1.push_back("11");
 262   s1.push_back("12");
 263   ssm.put(s1, "1");
 264
 265   //@ssm[Set[10, 11]] = 2
 266   std::vector<std::string> s2;
 267   s2.push_back("10");
 268   s2.push_back("11");
 269   ssm.put(s2, "2");
 270
 271   //@ssm[Set[11]] = 3
 272   std::vector<std::string> s3;
 273   s3.push_back("11");
 274   ssm.put(s3, "3");
 275
 276   //@ssm[Set[11, 12]] = 4
 277   std::vector<std::string> s4;
 278   s4.push_back("11");
 279   s4.push_back("12");
 280   ssm.put(s4, "4");
 281
 282   //@ssm[Set[9, 10, 11, 12, 13]] = 5
 283   std::vector<std::string> s5;
 284   s5.push_back("9");
 285   s5.push_back("10");
 286   s5.push_back("11");
 287   s5.push_back("12");
 288   s5.push_back("13");
 289   ssm.put(s5, "5");
 290
 291   //@ssm[Set[10, 13]] = 6
 292   std::vector<std::string> s6;
 293   s6.push_back("10");
 294   s6.push_back("13");
 295   ssm.put(s6, "6");
 296
 297   //assert_equal([[1, Set[10, 11, 12]], [2, Set[10, 11]], [3, Set[11]], [4, Set[11, 12]], [5, Set[9, 10, 11, 12, 13]], [6, Set[10, 13]]], @ssm.get(Set[9, 10, 11, 12, 13]))
 298   std::vector<std::string> k1;
 299   k1.push_back("9");
 300   k1.push_back("10");
 301   k1.push_back("11");
 302   k1.push_back("12");
 303   k1.push_back("13");
 304   assertEqual("[[1, Set[10, 11, 12]], [2, Set[10, 11]], [3, Set[11]], [4, Set[11, 12]], [5, Set[9, 10, 11, 12, 13]], [6, Set[10, 13]]]", toString(ssm.get_kv(k1)));
 305
 306   std::cout << std::endl;
 307 }
 308 void testMultipleEqualValues() {
 309   std::cout << "testMultipleEqualValues" << std::endl;
 310   //@ssm[Set[11, 12]] = 1
 311   std::vector<std::string> s1;
 312   s1.push_back("11");
 313   s1.push_back("12");
 314   ssm.put(s1, "1");
 315
 316   //@ssm[Set[12, 13]] = 2
 317   std::vector<std::string> s2;
 318   s2.push_back("12");
 319   s2.push_back("13");
 320   ssm.put(s2, "2");
 321
 322   //@ssm[Set[13, 14]] = 1
 323   std::vector<std::string> s3;
 324   s3.push_back("13");
 325   s3.push_back("14");
 326   ssm.put(s3, "1");
 327
 328   //@ssm[Set[14, 15]] = 1
 329   std::vector<std::string> s4;
 330   s4.push_back("14");
 331   s4.push_back("15");
 332   ssm.put(s4, "1");
 333
 334   //assert_equal([[1, Set[11, 12]], [2, Set[12, 13]], [1, Set[13, 14]], [1, Set[14, 15]]], @ssm.get(Set[11, 12, 13, 14, 15]))
 335   std::vector<std::string> k1;
 336   k1.push_back("11");
 337   k1.push_back("12");
 338   k1.push_back("13");
 339   k1.push_back("14");
 340   k1.push_back("15");
 341   assertEqual("[[1, Set[11, 12]], [2, Set[12, 13]], [1, Set[13, 14]], [1, Set[14, 15]]]", toString(ssm.get_kv(k1)));
 342
 343   std::cout << std::endl;
 344 }
 345
 346 int main()
 347 {
 348   std::vector<std::string> s1;
 349   s1.push_back("1");
 350   s1.push_back("2");
 351
 352   std::vector<std::string> s2;
 353   s2.push_back("2");
 354   s2.push_back("3");
 355
 356   std::vector<std::string> s3;
 357   s3.push_back("3");
 358   s3.push_back("4");
 359
 360   ssm.put(s1, "value1");
 361   ssm.put(s2, "value2");
 362   ssm.put(s3, "value3");
 363
 364   std::vector<std::string> s4;
 365   s4.push_back("1");
 366   s4.push_back("2");
 367   s4.push_back("3");
 368
 369   std::vector<std::pair<string, std::vector<std::string> > > fetched(ssm.get_kv(s4));
 370
 371   std::cout << "PRINTING RESULTS:" << std::endl;
 372   for (size_t i = 0, S = fetched.size(); i < S; ++i) {
 373     std::cout << fetched[i].first << std::endl;
 374   }
 375
 376   Subset_Map<string, string> ssm2;
 377   ssm2.put(s1, "foo");
 378   ssm2.put(s2, "bar");
 379   ssm2.put(s4, "hux");
 380
 381   std::vector<std::pair<string, std::vector<std::string> > > fetched2(ssm2.get_kv(s4));
 382
 383   std::cout << std::endl << "PRINTING RESULTS:" << std::endl;
 384   for (size_t i = 0, S = fetched2.size(); i < S; ++i) {
 385     std::cout << fetched2[i].first << std::endl;
 386   }
 387
 388   std::cout << "TRYING ON A SELECTOR-LIKE OBJECT" << std::endl;
 389
 390   Subset_Map<string, string> sel_ssm;
 391   std::vector<std::string> target;
 392   target.push_back("desk");
 393   target.push_back(".wood");
 394
 395   std::vector<std::string> actual;
 396   actual.push_back("desk");
 397   actual.push_back(".wood");
 398   actual.push_back(".mine");
 399
 400   sel_ssm.put(target, "has-aquarium");
 401   std::vector<std::pair<string, std::vector<std::string> > > fetched3(sel_ssm.get_kv(actual));
 402   std::cout << "RESULTS:" << std::endl;
 403   for (size_t i = 0, S = fetched3.size(); i < S; ++i) {
 404     std::cout << fetched3[i].first << std::endl;
 405   }
 406
 407   std::cout << std::endl;
 408
 409   // BEGIN PORTED RUBY TESTS FROM /test/sass/util/subset_map_test.rb
 410
 411   setup();
 412   testEqualKeys();
 413   testSubsetKeys();
 414   testSupersetKeys();
 415   testDisjointKeys();
 416   testSemiDisjointKeys();
 417   testEmptyKeySet();
 418   testEmptyKeyGet();
 419   testMultipleSubsets();
 420   testBracketBracket();
 421   testKeyOrder();
 422
 423   setup();
 424   testOrderPreserved();
 425
 426   setup();
 427   testMultipleEqualValues();
 428
 429   return 0;
 430 }
 431
 432 string toString(std::vector<std::pair<string, std::vector<std::string>>> v)
 433 {
 434   std::stringstream buffer;
 435   buffer << "[";
 436   for (size_t i = 0, S = v.size(); i < S; ++i) {
 437     buffer << "[" << v[i].first;
 438     buffer << ", Set[";
 439     for (size_t j = 0, S = v[i].second.size(); j < S; ++j) {
 440       buffer << v[i].second[j];
 441       if (j < S-1) {
 442         buffer << ", ";
 443       }
 444     }
 445     buffer << "]]";
 446     if (i < S-1) {
 447       buffer << ", ";
 448     }
 449   }
 450   buffer << "]";
 451   return buffer.str();
 452 }
 453
 454 string toString(std::vector<std::string> v)
 455 {
 456   std::stringstream buffer;
 457   buffer << "[";
 458   for (size_t i = 0, S = v.size(); i < S; ++i) {
 459     buffer << v[i];
 460     if (i < S-1) {
 461       buffer << ", ";
 462     }
 463   }
 464   buffer << "]";
 465   return buffer.str();
 466 }
 467
 468 void assertEqual(string sExpected, string sResult) {
 469   std::cout << "Expected: " << sExpected << std::endl;
 470   std::cout << "Result:   " << sResult << std::endl;
 471   assert(sExpected == sResult);
 472 }