The Tor Browser: content/test/unit/test

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 function run_test()

3 {

     5   /**

     6    * NOTE: [i] is not allowed in this test, since it's done via classinfo and

     7    * we don't have that in xpcshell.

     8    */

    10   test_getElementsByTagName();

    11   test_getElementsByTagNameNS();

    12   test_getElementsByAttribute();

    13   test_getElementsByAttributeNS();

    15   // What else should we test?

    16   // XXXbz we need more tests here to test liveness!

    18 }

    20 function test_getElementsByTagName()

    21 {

    22   var doc = ParseFile("nodelist_data_1.xml");

    23   var root = doc.documentElement;

    25   // Check that getElementsByTagName returns a nodelist.

    26   do_check_true(doc.getElementsByTagName("*") instanceof nsIDOMNodeList);

    27   do_check_true(root.getElementsByTagName("*") instanceof nsIDOMNodeList);

    29   // Check that getElementsByTagName excludes the element it's called on.

    30   do_check_eq(doc.getElementsByTagName("*").length,

    31               root.getElementsByTagName("*").length + 1);

    32   do_check_eq(doc.getElementById("test2").getElementsByTagName("*").length,

    33               8);

    34   do_check_eq(doc.getElementById("test2").getElementsByTagName("test").length,

    35               3);

    37   // Check that the first element of getElementsByTagName on the document is

    38   // the right thing.

    39   do_check_eq(doc.getElementsByTagName("*").item(0), root);

    41   // Check that we get the right things in the right order

    42   var numTests = doc.getElementsByTagName("test").length;

    43   do_check_eq(numTests, 5);

    45   for (var i = 1; i <= numTests; ++i) {

    46     do_check_true(doc.getElementById("test" + i) instanceof nsIDOMElement);

    47     do_check_eq(doc.getElementById("test" + i),

    48                 doc.getElementsByTagName("test").item(i-1));

    49   }

    51   // Check that we handle tagnames containing ':' correctly

    52   do_check_true(doc.getElementsByTagName("foo:test")

    53                 instanceof nsIDOMNodeList);

    54   do_check_eq(doc.getElementsByTagName("foo:test").length, 2);

    56   do_check_true(doc.getElementsByTagName("foo2:test")

    57                 instanceof nsIDOMNodeList);

    58   do_check_eq(doc.getElementsByTagName("foo2:test").length, 3);

    60   do_check_true(doc.getElementsByTagName("bar:test")

    61                 instanceof nsIDOMNodeList);

    62   do_check_eq(doc.getElementsByTagName("bar:test").length, 4);

    63 }

    65 function test_getElementsByTagNameNS()

    66 {

    67   var doc = ParseFile("nodelist_data_1.xml");

    68   var root = doc.documentElement;

    70   // Check that getElementsByTagNameNS returns a nodelist.

    71   do_check_true(doc.getElementsByTagNameNS("*", "*") instanceof nsIDOMNodeList);

    72   do_check_true(root.getElementsByTagNameNS("*", "*") instanceof nsIDOMNodeList);

    74   // Check that passing "" and null for the namespace URI gives the same result

    75   var list1 = doc.getElementsByTagNameNS("", "test");

    76   var list2 = doc.getElementsByTagNameNS(null, "test");

    77   do_check_eq(list1.length, list2.length);

    78   for (var i = 0; i < list1.length; ++i) {

    79     do_check_eq(list1.item(i), list2.item(i));

    80   }

    82   // Check that getElementsByTagNameNS excludes the element it's called on.

    83   do_check_eq(doc.getElementsByTagNameNS("*", "*").length,

    84               root.getElementsByTagNameNS("*", "*").length + 1);

    85   do_check_eq(doc.getElementById("test2")

    86                  .getElementsByTagNameNS("*", "*").length,

    87               8);

    88   do_check_eq(doc.getElementById("test2")

    89                  .getElementsByTagNameNS("", "test").length,

    90               1);

    91   do_check_eq(doc.getElementById("test2")

    92                  .getElementsByTagNameNS("*", "test").length,

    93               7);

    95   // Check that the first element of getElementsByTagNameNS on the document is

    96   // the right thing.

    97   do_check_eq(doc.getElementsByTagNameNS("*", "*").item(0), root);

    98   do_check_eq(doc.getElementsByTagNameNS(null, "*").item(0), root);

   100   // Check that we get the right things in the right order

   103   var numTests = doc.getElementsByTagNameNS("*", "test").length;

   104   do_check_eq(numTests, 14);

   106   for (var i = 1; i <= numTests; ++i) {

   107     do_check_true(doc.getElementById("test" + i) instanceof nsIDOMElement);

   108     do_check_eq(doc.getElementById("test" + i),

   109                 doc.getElementsByTagNameNS("*", "test").item(i-1));

   110   }

   112   // Check general proper functioning of having a non-wildcard namespace.

   113   var test2 = doc.getElementById("test2");

   114   do_check_eq(doc.getElementsByTagNameNS("", "test").length,

   115               3);

   116   do_check_eq(test2.getElementsByTagNameNS("", "test").length,

   117               1);

   118   do_check_eq(doc.getElementsByTagNameNS("foo", "test").length,

   119               7);

   120   do_check_eq(test2.getElementsByTagNameNS("foo", "test").length,

   121               4);

   122   do_check_eq(doc.getElementsByTagNameNS("foo2", "test").length,

   123               0);

   124   do_check_eq(test2.getElementsByTagNameNS("foo2", "test").length,

   125               0);

   126   do_check_eq(doc.getElementsByTagNameNS("bar", "test").length,

   127               4);

   128   do_check_eq(test2.getElementsByTagNameNS("bar", "test").length,

   129               2);

   131   // Check that we handle tagnames containing ':' correctly

   132   do_check_true(doc.getElementsByTagNameNS(null, "foo:test")

   133                 instanceof nsIDOMNodeList);

   134   do_check_eq(doc.getElementsByTagNameNS(null, "foo:test").length, 0);

   135   do_check_eq(doc.getElementsByTagNameNS("foo", "foo:test").length, 0);

   136   do_check_eq(doc.getElementsByTagNameNS("bar", "foo:test").length, 0);

   137   do_check_eq(doc.getElementsByTagNameNS("*", "foo:test").length, 0);

   139   do_check_true(doc.getElementsByTagNameNS(null, "foo2:test")

   140                 instanceof nsIDOMNodeList);

   141   do_check_eq(doc.getElementsByTagNameNS(null, "foo2:test").length, 0);

   142   do_check_eq(doc.getElementsByTagNameNS("foo2", "foo2:test").length, 0);

   143   do_check_eq(doc.getElementsByTagNameNS("bar", "foo2:test").length, 0);

   144   do_check_eq(doc.getElementsByTagNameNS("*", "foo2:test").length, 0);

   146   do_check_true(doc.getElementsByTagNameNS(null, "bar:test")

   147                 instanceof nsIDOMNodeList);

   148   do_check_eq(doc.getElementsByTagNameNS(null, "bar:test").length, 0);

   149   do_check_eq(doc.getElementsByTagNameNS("bar", "bar:test").length, 0);

   150   do_check_eq(doc.getElementsByTagNameNS("*", "bar:test").length, 0);

   152   // Check that previously-unknown namespaces are handled right.  Note that we

   153   // can just hardcode the strings, since we're running only once in XPCshell.

   154   // If someone wants to run these in a browser, some use of Math.random() may

   155   // be in order.

   156   list1 = doc.getElementsByTagNameNS("random-bogus-namespace", "foo");

   157   list2 = doc.documentElement.getElementsByTagNameNS("random-bogus-namespace2",

   158                                                      "foo");

   159   do_check_neq(list1, list2);

   160   do_check_eq(list1.length, 0);

   161   do_check_eq(list2.length, 0);

   162   var newNode = doc.createElementNS("random-bogus-namespace", "foo");

   163   doc.documentElement.appendChild(newNode);

   164   var newNode = doc.createElementNS("random-bogus-namespace2", "foo");

   165   doc.documentElement.appendChild(newNode);

   166   do_check_eq(list1.length, 1);

   167   do_check_eq(list2.length, 1);

   168 }

   170 function test_getElementsByAttribute()

   171 {

   172   var doc = ParseFile("nodelist_data_2.xul");

   173   var root = doc.documentElement;

   175   // Sadly, DOMParser can't create XULDocument objects.  But at least we have a

   176   // XULElement!

   178   do_check_true(root instanceof nsIDOMXULElement);

   180   do_check_true(root.getElementsByAttribute("foo", "foo") instanceof

   181                 nsIDOMNodeList);

   183   var master1 = doc.getElementById("master1");

   184   var master2 = doc.getElementById("master2");

   185   var master3 = doc.getElementById("master3");

   186   var external = doc.getElementById("external");

   188   do_check_true(master1 instanceof nsIDOMXULElement);

   189   do_check_true(master2 instanceof nsIDOMXULElement);

   190   do_check_true(master3 instanceof nsIDOMXULElement);

   191   do_check_true(external instanceof nsIDOMXULElement);

   193   // Basic tests

   194   do_check_eq(root.getElementsByAttribute("foo", "foo").length,

   195               14);

   196   do_check_eq(master1.getElementsByAttribute("foo", "foo").length,

   197               4);

   199   do_check_eq(root.getElementsByAttribute("foo", "bar").length,

   200               7);

   201   do_check_eq(master1.getElementsByAttribute("foo", "bar").length,

   202               2);

   204   do_check_eq(root.getElementsByAttribute("bar", "bar").length,

   205               7);

   206   do_check_eq(master1.getElementsByAttribute("bar", "bar").length,

   207               2);

   209   do_check_eq(root.getElementsByAttribute("foo", "*").length,

   210               21);

   211   do_check_eq(master1.getElementsByAttribute("foo", "*").length,

   212               6);

   214   // Test the various combinations of attributes with colons in the name

   215   do_check_eq(root.getElementsByAttribute("foo:foo", "foo").length,

   216               16);

   217   do_check_eq(master1.getElementsByAttribute("foo:foo", "foo").length,

   218               5);

   219   do_check_eq(master2.getElementsByAttribute("foo:foo", "foo").length,

   220               4);

   221   do_check_eq(master3.getElementsByAttribute("foo:foo", "foo").length,

   222               4);

   223   do_check_eq(external.getElementsByAttribute("foo:foo", "foo").length,

   224               2);

   226   do_check_eq(root.getElementsByAttribute("foo:foo", "bar").length,

   227               9);

   228   do_check_eq(master1.getElementsByAttribute("foo:foo", "bar").length,

   229               2);

   230   do_check_eq(master2.getElementsByAttribute("foo:foo", "bar").length,

   231               3);

   232   do_check_eq(master3.getElementsByAttribute("foo:foo", "bar").length,

   233               2);

   234   do_check_eq(external.getElementsByAttribute("foo:foo", "bar").length,

   235               1);

   237   do_check_eq(root.getElementsByAttribute("foo:bar", "foo").length,

   238               7);

   239   do_check_eq(master1.getElementsByAttribute("foo:bar", "foo").length,

   240               2);

   241   do_check_eq(master2.getElementsByAttribute("foo:bar", "foo").length,

   242               2);

   243   do_check_eq(master3.getElementsByAttribute("foo:bar", "foo").length,

   244               2);

   245   do_check_eq(external.getElementsByAttribute("foo:bar", "foo").length,

   246               1);

   248   do_check_eq(root.getElementsByAttribute("foo:bar", "bar").length,

   249               14);

   250   do_check_eq(master1.getElementsByAttribute("foo:bar", "bar").length,

   251               4);

   252   do_check_eq(master2.getElementsByAttribute("foo:bar", "bar").length,

   253               4);

   254   do_check_eq(master3.getElementsByAttribute("foo:bar", "bar").length,

   255               4);

   256   do_check_eq(external.getElementsByAttribute("foo:bar", "bar").length,

   257               2);

   259   do_check_eq(root.getElementsByAttribute("foo2:foo", "foo").length,

   260               8);

   261   do_check_eq(master1.getElementsByAttribute("foo2:foo", "foo").length,

   262               2);

   263   do_check_eq(master2.getElementsByAttribute("foo2:foo", "foo").length,

   264               2);

   265   do_check_eq(master3.getElementsByAttribute("foo2:foo", "foo").length,

   266               3);

   267   do_check_eq(external.getElementsByAttribute("foo2:foo", "foo").length,

   268               1);

   270   do_check_eq(root.getElementsByAttribute("foo:foo", "*").length,

   271               25);

   272   do_check_eq(master1.getElementsByAttribute("foo:foo", "*").length,

   273               7);

   274   do_check_eq(master2.getElementsByAttribute("foo:foo", "*").length,

   275               7);

   276   do_check_eq(master3.getElementsByAttribute("foo:foo", "*").length,

   277               6);

   278   do_check_eq(external.getElementsByAttribute("foo:foo", "*").length,

   279               3);

   281   do_check_eq(root.getElementsByAttribute("foo2:foo", "bar").length,

   282               0);

   283   do_check_eq(root.getElementsByAttribute("foo:foo", "baz").length,

   284               0);

   285 }

   287 function test_getElementsByAttributeNS()

   288 {

   289   var doc = ParseFile("nodelist_data_2.xul");

   290   var root = doc.documentElement;

   292   // Sadly, DOMParser can't create XULDocument objects.  But at least we have a

   293   // XULElement!

   295   do_check_true(root instanceof nsIDOMXULElement);

   297   // Check that getElementsByAttributeNS returns a nodelist.

   298   do_check_true(root.getElementsByAttributeNS("*", "*", "*") instanceof

   299                 nsIDOMNodeList);

   301   var master1 = doc.getElementById("master1");

   302   var master2 = doc.getElementById("master2");

   303   var master3 = doc.getElementById("master3");

   304   var external = doc.getElementById("external");

   306   do_check_true(master1 instanceof nsIDOMXULElement);

   307   do_check_true(master2 instanceof nsIDOMXULElement);

   308   do_check_true(master3 instanceof nsIDOMXULElement);

   309   do_check_true(external instanceof nsIDOMXULElement);

   311   // Test wildcard namespace

   312   do_check_eq(root.getElementsByAttributeNS("*", "foo", "foo").length,

   313               38);

   314   do_check_eq(master1.getElementsByAttributeNS("*", "foo", "foo").length,

   315               11);

   316   do_check_eq(master2.getElementsByAttributeNS("*", "foo", "foo").length,

   317               10);

   318   do_check_eq(master3.getElementsByAttributeNS("*", "foo", "foo").length,

   319               11);

   321   do_check_eq(root.getElementsByAttributeNS("*", "foo", "bar").length,

   322               16);

   323   do_check_eq(master1.getElementsByAttributeNS("*", "foo", "bar").length,

   324               4);

   325   do_check_eq(master2.getElementsByAttributeNS("*", "foo", "bar").length,

   326               5);

   327   do_check_eq(master3.getElementsByAttributeNS("*", "foo", "bar").length,

   328               4);

   330   do_check_eq(root.getElementsByAttributeNS("*", "bar", "bar").length,

   331               21);

   332   do_check_eq(master1.getElementsByAttributeNS("*", "bar", "bar").length,

   333               6);

   334   do_check_eq(master2.getElementsByAttributeNS("*", "bar", "bar").length,

   335               6);

   336   do_check_eq(master3.getElementsByAttributeNS("*", "bar", "bar").length,

   337               6);

   339   do_check_eq(root.getElementsByAttributeNS("*", "foo", "*").length,

   340               54);

   341   do_check_eq(master1.getElementsByAttributeNS("*", "foo", "*").length,

   342               15);

   343   do_check_eq(master2.getElementsByAttributeNS("*", "foo", "*").length,

   344               15);

   345   do_check_eq(master3.getElementsByAttributeNS("*", "foo", "*").length,

   346               15);

   348   // Test null namespace. This should be the same as getElementsByAttribute.

   349   do_check_eq(root.getElementsByAttributeNS("", "foo", "foo").length,

   350               root.getElementsByAttribute("foo", "foo").length);

   351   do_check_eq(master1.getElementsByAttributeNS("", "foo", "foo").length,

   352               master1.getElementsByAttribute("foo", "foo").length);

   353   do_check_eq(master2.getElementsByAttributeNS("", "foo", "foo").length,

   354               master2.getElementsByAttribute("foo", "foo").length);

   355   do_check_eq(master3.getElementsByAttributeNS("", "foo", "foo").length,

   356               master3.getElementsByAttribute("foo", "foo").length);

   358   // Test namespace "foo"

   359   do_check_eq(root.getElementsByAttributeNS("foo", "foo", "foo").length,

   360               24);

   361   do_check_eq(master1.getElementsByAttributeNS("foo", "foo", "foo").length,

   362               7);

   363   do_check_eq(master2.getElementsByAttributeNS("foo", "foo", "foo").length,

   364               6);

   365   do_check_eq(master3.getElementsByAttributeNS("foo", "foo", "foo").length,

   366               7);

   368   do_check_eq(root.getElementsByAttributeNS("foo", "foo", "bar").length,

   369               9);

   370   do_check_eq(master1.getElementsByAttributeNS("foo", "foo", "bar").length,

   371               2);

   372   do_check_eq(master2.getElementsByAttributeNS("foo", "foo", "bar").length,

   373               3);

   374   do_check_eq(master3.getElementsByAttributeNS("foo", "foo", "bar").length,

   375               2);

   377   do_check_eq(root.getElementsByAttributeNS("foo", "bar", "foo").length,

   378               7);

   379   do_check_eq(master1.getElementsByAttributeNS("foo", "bar", "foo").length,

   380               2);

   381   do_check_eq(master2.getElementsByAttributeNS("foo", "bar", "foo").length,

   382               2);

   383   do_check_eq(master3.getElementsByAttributeNS("foo", "bar", "foo").length,

   384               2);

   386   do_check_eq(root.getElementsByAttributeNS("foo", "bar", "bar").length,

   387               14);

   388   do_check_eq(master1.getElementsByAttributeNS("foo", "bar", "bar").length,

   389               4);

   390   do_check_eq(master2.getElementsByAttributeNS("foo", "bar", "bar").length,

   391               4);

   392   do_check_eq(master3.getElementsByAttributeNS("foo", "bar", "bar").length,

   393               4);

   394 }

The Tor Browser / file revision

content/test/unit/test_nodelist.js@129ffea94266

content/test/unit/test_nodelist.js