The Tor Browser: js/src/jit-test/tests/basic/testBitopWithConstan.js@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 function test1 (x) {

     2     assertEq(x | -1, -1);

     3     assertEq(-1 | x, -1);

     4     assertEq(x & -1, 1);

     5     assertEq(-1 & x, 1);

     6     assertEq(x ^ -1, -2);

     7     assertEq(-1 ^ x, -2);

     8     assertEq(x >> -1, 0);

     9     assertEq(-1 >> x, -1);

    10     assertEq(x >>> -1, 0);

    11     assertEq(-1 >>> x, 2147483647);

    12     assertEq(x << -1, -2147483648);

    13     assertEq(-1 << x, -2);

    14     assertEq(x | 1, 1);

    15     assertEq(1 | x, 1);

    16     assertEq(x & 1, 1);

    17     assertEq(1 & x, 1);

    18     assertEq(x ^ 1, 0);

    19     assertEq(1 ^ x, 0);

    20     assertEq(x >> 1, 0);

    21     assertEq(1 >> x, 0);

    22     assertEq(x >>> 1, 0);

    23     assertEq(1 >>> x, 0);

    24     assertEq(x << 1, 2);

    25     assertEq(1 << x, 2);

    26     assertEq(x | 0, 1);

    27     assertEq(0 | x, 1);

    28     assertEq(x & 0, 0);

    29     assertEq(0 & x, 0);

    30     assertEq(x ^ 0, 1);

    31     assertEq(0 ^ x, 1);

    32     assertEq(x >> 0, 1);

    33     assertEq(0 >> x, 0);

    34     assertEq(x >>> 0, 1);

    35     assertEq(0 >>> x, 0);

    36     assertEq(x << 0, 1);

    37     assertEq(0 << x, 0);

    38     assertEq(x | 0xffffffff, -1);

    39     assertEq(0xffffffff | x, -1);

    40     assertEq(x & 0xffffffff, 1);

    41     assertEq(0xffffffff & x, 1);

    42     assertEq(x ^ 0xffffffff, -2);

    43     assertEq(0xffffffff ^ x, -2);

    44     assertEq(x >> 0xffffffff, 0);

    45     assertEq(0xffffffff >> x, -1);

    46     assertEq(x >>> 0xffffffff, 0);

    47     assertEq(0xffffffff >>> x, 2147483647);

    48     assertEq(x << 0xffffffff, -2147483648);

    49     assertEq(0xffffffff << x, -2);

    50     assertEq(x | "10.6", 11);

    51     assertEq("10.6" | x, 11);

    52     assertEq(x & "10.6", 0);

    53     assertEq("10.6" & x, 0);

    54     assertEq(x ^ "10.6", 11);

    55     assertEq("10.6" ^ x, 11);

    56     assertEq(x >> "10.6", 0);

    57     assertEq("10.6" >> x, 5);

    58     assertEq(x >>> "10.6", 0);

    59     assertEq("10.6" >>> x, 5);

    60     assertEq(x << "10.6", 1024);

    61     assertEq("10.6" << x, 20);

    62     assertEq(x | 2147483648, -2147483647);

    63     assertEq(2147483648 | x, -2147483647);

    64     assertEq(x & 2147483648, 0);

    65     assertEq(2147483648 & x, 0);

    66     assertEq(x ^ 2147483648, -2147483647);

    67     assertEq(2147483648 ^ x, -2147483647);

    68     assertEq(x >> 2147483648, 1);

    69     assertEq(2147483648 >> x, -1073741824);

    70     assertEq(x >>> 2147483648, 1);

    71     assertEq(2147483648 >>> x, 1073741824);

    72     assertEq(x << 2147483648, 1);

    73     assertEq(2147483648 << x, 0);

    74     assertEq(x | 4294967296, 1);

    75     assertEq(4294967296 | x, 1);

    76     assertEq(x & 4294967296, 0);

    77     assertEq(4294967296 & x, 0);

    78     assertEq(x ^ 4294967296, 1);

    79     assertEq(4294967296 ^ x, 1);

    80     assertEq(x >> 4294967296, 1);

    81     assertEq(4294967296 >> x, 0);

    82     assertEq(x >>> 4294967296, 1);

    83     assertEq(4294967296 >>> x, 0);

    84     assertEq(x << 4294967296, 1);

    85     assertEq(4294967296 << x, 0);

    86     assertEq(x | undefined, 1);

    87     assertEq(undefined | x, 1);

    88     assertEq(x & undefined, 0);

    89     assertEq(undefined & x, 0);

    90     assertEq(x ^ undefined, 1);

    91     assertEq(undefined ^ x, 1);

    92     assertEq(x >> undefined, 1);

    93     assertEq(undefined >> x, 0);

    94     assertEq(x >>> undefined, 1);

    95     assertEq(undefined >>> x, 0);

    96     assertEq(x << undefined, 1);

    97     assertEq(undefined << x, 0);

    98     assertEq(x | null, 1);

    99     assertEq(null | x, 1);

   100     assertEq(x & null, 0);

   101     assertEq(null & x, 0);

   102     assertEq(x ^ null, 1);

   103     assertEq(null ^ x, 1);

   104     assertEq(x >> null, 1);

   105     assertEq(null >> x, 0);

   106     assertEq(x >>> null, 1);

   107     assertEq(null >>> x, 0);

   108     assertEq(x << null, 1);

   109     assertEq(null << x, 0);

   110     assertEq(x | false, 1);

   111     assertEq(false | x, 1);

   112     assertEq(x & false, 0);

   113     assertEq(false & x, 0);

   114     assertEq(x ^ false, 1);

   115     assertEq(false ^ x, 1);

   116     assertEq(x >> false, 1);

   117     assertEq(false >> x, 0);

   118     assertEq(x >>> false, 1);

   119     assertEq(false >>> x, 0);

   120     assertEq(x << false, 1);

   121     assertEq(false << x, 0);

   122     assertEq(x | true, 1);

   123     assertEq(true | x, 1);

   124     assertEq(x & true, 1);

   125     assertEq(true & x, 1);

   126     assertEq(x ^ true, 0);

   127     assertEq(true ^ x, 0);

   128     assertEq(x >> true, 0);

   129     assertEq(true >> x, 0);

   130     assertEq(x >>> true, 0);

   131     assertEq(true >>> x, 0);

   132     assertEq(x << true, 2);

   133     assertEq(true << x, 2);

   134     assertEq(x | -1.5, -1);

   135     assertEq(-1.5 | x, -1);

   136     assertEq(x & -1.5, 1);

   137     assertEq(-1.5 & x, 1);

   138     assertEq(x ^ -1.5, -2);

   139     assertEq(-1.5 ^ x, -2);

   140     assertEq(x >> -1.5, 0);

   141     assertEq(-1.5 >> x, -1);

   142     assertEq(x >>> -1.5, 0);

   143     assertEq(-1.5 >>> x, 2147483647);

   144     assertEq(x << -1.5, -2147483648);

   145     assertEq(-1.5 << x, -2);

   146 }

   147 test1(1)

   149 function test2 (x) {

   150     assertEq(x | -1, -1);

   151     assertEq(-1 | x, -1);

   152     assertEq(x & -1, 0);

   153     assertEq(-1 & x, 0);

   154     assertEq(x ^ -1, -1);

   155     assertEq(-1 ^ x, -1);

   156     assertEq(x >> -1, 0);

   157     assertEq(-1 >> x, -1);

   158     assertEq(x >>> -1, 0);

   159     assertEq(-1 >>> x, 4294967295);

   160     assertEq(x << -1, 0);

   161     assertEq(-1 << x, -1);

   162     assertEq(x | 1, 1);

   163     assertEq(1 | x, 1);

   164     assertEq(x & 1, 0);

   165     assertEq(1 & x, 0);

   166     assertEq(x ^ 1, 1);

   167     assertEq(1 ^ x, 1);

   168     assertEq(x >> 1, 0);

   169     assertEq(1 >> x, 1);

   170     assertEq(x >>> 1, 0);

   171     assertEq(1 >>> x, 1);

   172     assertEq(x << 1, 0);

   173     assertEq(1 << x, 1);

   174     assertEq(x | 0, 0);

   175     assertEq(0 | x, 0);

   176     assertEq(x & 0, 0);

   177     assertEq(0 & x, 0);

   178     assertEq(x ^ 0, 0);

   179     assertEq(0 ^ x, 0);

   180     assertEq(x >> 0, 0);

   181     assertEq(0 >> x, 0);

   182     assertEq(x >>> 0, 0);

   183     assertEq(0 >>> x, 0);

   184     assertEq(x << 0, 0);

   185     assertEq(0 << x, 0);

   186     assertEq(x | 0xffffffff, -1);

   187     assertEq(0xffffffff | x, -1);

   188     assertEq(x & 0xffffffff, 0);

   189     assertEq(0xffffffff & x, 0);

   190     assertEq(x ^ 0xffffffff, -1);

   191     assertEq(0xffffffff ^ x, -1);

   192     assertEq(x >> 0xffffffff, 0);

   193     assertEq(0xffffffff >> x, -1);

   194     assertEq(x >>> 0xffffffff, 0);

   195     assertEq(0xffffffff >>> x, 4294967295);

   196     assertEq(x << 0xffffffff, 0);

   197     assertEq(0xffffffff << x, -1);

   198     assertEq(x | "10.6", 10);

   199     assertEq("10.6" | x, 10);

   200     assertEq(x & "10.6", 0);

   201     assertEq("10.6" & x, 0);

   202     assertEq(x ^ "10.6", 10);

   203     assertEq("10.6" ^ x, 10);

   204     assertEq(x >> "10.6", 0);

   205     assertEq("10.6" >> x, 10);

   206     assertEq(x >>> "10.6", 0);

   207     assertEq("10.6" >>> x, 10);

   208     assertEq(x << "10.6", 0);

   209     assertEq("10.6" << x, 10);

   210     assertEq(x | 2147483648, -2147483648);

   211     assertEq(2147483648 | x, -2147483648);

   212     assertEq(x & 2147483648, 0);

   213     assertEq(2147483648 & x, 0);

   214     assertEq(x ^ 2147483648, -2147483648);

   215     assertEq(2147483648 ^ x, -2147483648);

   216     assertEq(x >> 2147483648, 0);

   217     assertEq(2147483648 >> x, -2147483648);

   218     assertEq(x >>> 2147483648, 0);

   219     assertEq(2147483648 >>> x, 2147483648);

   220     assertEq(x << 2147483648, 0);

   221     assertEq(2147483648 << x, -2147483648);

   222     assertEq(x | 4294967296, 0);

   223     assertEq(4294967296 | x, 0);

   224     assertEq(x & 4294967296, 0);

   225     assertEq(4294967296 & x, 0);

   226     assertEq(x ^ 4294967296, 0);

   227     assertEq(4294967296 ^ x, 0);

   228     assertEq(x >> 4294967296, 0);

   229     assertEq(4294967296 >> x, 0);

   230     assertEq(x >>> 4294967296, 0);

   231     assertEq(4294967296 >>> x, 0);

   232     assertEq(x << 4294967296, 0);

   233     assertEq(4294967296 << x, 0);

   234     assertEq(x | undefined, 0);

   235     assertEq(undefined | x, 0);

   236     assertEq(x & undefined, 0);

   237     assertEq(undefined & x, 0);

   238     assertEq(x ^ undefined, 0);

   239     assertEq(undefined ^ x, 0);

   240     assertEq(x >> undefined, 0);

   241     assertEq(undefined >> x, 0);

   242     assertEq(x >>> undefined, 0);

   243     assertEq(undefined >>> x, 0);

   244     assertEq(x << undefined, 0);

   245     assertEq(undefined << x, 0);

   246     assertEq(x | null, 0);

   247     assertEq(null | x, 0);

   248     assertEq(x & null, 0);

   249     assertEq(null & x, 0);

   250     assertEq(x ^ null, 0);

   251     assertEq(null ^ x, 0);

   252     assertEq(x >> null, 0);

   253     assertEq(null >> x, 0);

   254     assertEq(x >>> null, 0);

   255     assertEq(null >>> x, 0);

   256     assertEq(x << null, 0);

   257     assertEq(null << x, 0);

   258     assertEq(x | false, 0);

   259     assertEq(false | x, 0);

   260     assertEq(x & false, 0);

   261     assertEq(false & x, 0);

   262     assertEq(x ^ false, 0);

   263     assertEq(false ^ x, 0);

   264     assertEq(x >> false, 0);

   265     assertEq(false >> x, 0);

   266     assertEq(x >>> false, 0);

   267     assertEq(false >>> x, 0);

   268     assertEq(x << false, 0);

   269     assertEq(false << x, 0);

   270     assertEq(x | true, 1);

   271     assertEq(true | x, 1);

   272     assertEq(x & true, 0);

   273     assertEq(true & x, 0);

   274     assertEq(x ^ true, 1);

   275     assertEq(true ^ x, 1);

   276     assertEq(x >> true, 0);

   277     assertEq(true >> x, 1);

   278     assertEq(x >>> true, 0);

   279     assertEq(true >>> x, 1);

   280     assertEq(x << true, 0);

   281     assertEq(true << x, 1);

   282     assertEq(x | -1.5, -1);

   283     assertEq(-1.5 | x, -1);

   284     assertEq(x & -1.5, 0);

   285     assertEq(-1.5 & x, 0);

   286     assertEq(x ^ -1.5, -1);

   287     assertEq(-1.5 ^ x, -1);

   288     assertEq(x >> -1.5, 0);

   289     assertEq(-1.5 >> x, -1);

   290     assertEq(x >>> -1.5, 0);

   291     assertEq(-1.5 >>> x, 4294967295);

   292     assertEq(x << -1.5, 0);

   293     assertEq(-1.5 << x, -1);

   294 }

   295 test2(0)

   297 function test3 (x) {

   298     assertEq(x | -1, -1);

   299     assertEq(-1 | x, -1);

   300     assertEq(x & -1, -1);

   301     assertEq(-1 & x, -1);

   302     assertEq(x ^ -1, 0);

   303     assertEq(-1 ^ x, 0);

   304     assertEq(x >> -1, -1);

   305     assertEq(-1 >> x, -1);

   306     assertEq(x >>> -1, 1);

   307     assertEq(-1 >>> x, 1);

   308     assertEq(x << -1, -2147483648);

   309     assertEq(-1 << x, -2147483648);

   310     assertEq(x | 1, -1);

   311     assertEq(1 | x, -1);

   312     assertEq(x & 1, 1);

   313     assertEq(1 & x, 1);

   314     assertEq(x ^ 1, -2);

   315     assertEq(1 ^ x, -2);

   316     assertEq(x >> 1, -1);

   317     assertEq(1 >> x, 0);

   318     assertEq(x >>> 1, 2147483647);

   319     assertEq(1 >>> x, 0);

   320     assertEq(x << 1, -2);

   321     assertEq(1 << x, -2147483648);

   322     assertEq(x | 0, -1);

   323     assertEq(0 | x, -1);

   324     assertEq(x & 0, 0);

   325     assertEq(0 & x, 0);

   326     assertEq(x ^ 0, -1);

   327     assertEq(0 ^ x, -1);

   328     assertEq(x >> 0, -1);

   329     assertEq(0 >> x, 0);

   330     assertEq(x >>> 0, 4294967295);

   331     assertEq(0 >>> x, 0);

   332     assertEq(x << 0, -1);

   333     assertEq(0 << x, 0);

   334     assertEq(x | 0xffffffff, -1);

   335     assertEq(0xffffffff | x, -1);

   336     assertEq(x & 0xffffffff, -1);

   337     assertEq(0xffffffff & x, -1);

   338     assertEq(x ^ 0xffffffff, 0);

   339     assertEq(0xffffffff ^ x, 0);

   340     assertEq(x >> 0xffffffff, -1);

   341     assertEq(0xffffffff >> x, -1);

   342     assertEq(x >>> 0xffffffff, 1);

   343     assertEq(0xffffffff >>> x, 1);

   344     assertEq(x << 0xffffffff, -2147483648);

   345     assertEq(0xffffffff << x, -2147483648);

   346     assertEq(x | "10.6", -1);

   347     assertEq("10.6" | x, -1);

   348     assertEq(x & "10.6", 10);

   349     assertEq("10.6" & x, 10);

   350     assertEq(x ^ "10.6", -11);

   351     assertEq("10.6" ^ x, -11);

   352     assertEq(x >> "10.6", -1);

   353     assertEq("10.6" >> x, 0);

   354     assertEq(x >>> "10.6", 4194303);

   355     assertEq("10.6" >>> x, 0);

   356     assertEq(x << "10.6", -1024);

   357     assertEq("10.6" << x, 0);

   358     assertEq(x | 2147483648, -1);

   359     assertEq(2147483648 | x, -1);

   360     assertEq(x & 2147483648, -2147483648);

   361     assertEq(2147483648 & x, -2147483648);

   362     assertEq(x ^ 2147483648, 2147483647);

   363     assertEq(2147483648 ^ x, 2147483647);

   364     assertEq(x >> 2147483648, -1);

   365     assertEq(2147483648 >> x, -1);

   366     assertEq(x >>> 2147483648, 4294967295);

   367     assertEq(2147483648 >>> x, 1);

   368     assertEq(x << 2147483648, -1);

   369     assertEq(2147483648 << x, 0);

   370     assertEq(x | 4294967296, -1);

   371     assertEq(4294967296 | x, -1);

   372     assertEq(x & 4294967296, 0);

   373     assertEq(4294967296 & x, 0);

   374     assertEq(x ^ 4294967296, -1);

   375     assertEq(4294967296 ^ x, -1);

   376     assertEq(x >> 4294967296, -1);

   377     assertEq(4294967296 >> x, 0);

   378     assertEq(x >>> 4294967296, 4294967295);

   379     assertEq(4294967296 >>> x, 0);

   380     assertEq(x << 4294967296, -1);

   381     assertEq(4294967296 << x, 0);

   382     assertEq(x | undefined, -1);

   383     assertEq(undefined | x, -1);

   384     assertEq(x & undefined, 0);

   385     assertEq(undefined & x, 0);

   386     assertEq(x ^ undefined, -1);

   387     assertEq(undefined ^ x, -1);

   388     assertEq(x >> undefined, -1);

   389     assertEq(undefined >> x, 0);

   390     assertEq(x >>> undefined, 4294967295);

   391     assertEq(undefined >>> x, 0);

   392     assertEq(x << undefined, -1);

   393     assertEq(undefined << x, 0);

   394     assertEq(x | null, -1);

   395     assertEq(null | x, -1);

   396     assertEq(x & null, 0);

   397     assertEq(null & x, 0);

   398     assertEq(x ^ null, -1);

   399     assertEq(null ^ x, -1);

   400     assertEq(x >> null, -1);

   401     assertEq(null >> x, 0);

   402     assertEq(x >>> null, 4294967295);

   403     assertEq(null >>> x, 0);

   404     assertEq(x << null, -1);

   405     assertEq(null << x, 0);

   406     assertEq(x | false, -1);

   407     assertEq(false | x, -1);

   408     assertEq(x & false, 0);

   409     assertEq(false & x, 0);

   410     assertEq(x ^ false, -1);

   411     assertEq(false ^ x, -1);

   412     assertEq(x >> false, -1);

   413     assertEq(false >> x, 0);

   414     assertEq(x >>> false, 4294967295);

   415     assertEq(false >>> x, 0);

   416     assertEq(x << false, -1);

   417     assertEq(false << x, 0);

   418     assertEq(x | true, -1);

   419     assertEq(true | x, -1);

   420     assertEq(x & true, 1);

   421     assertEq(true & x, 1);

   422     assertEq(x ^ true, -2);

   423     assertEq(true ^ x, -2);

   424     assertEq(x >> true, -1);

   425     assertEq(true >> x, 0);

   426     assertEq(x >>> true, 2147483647);

   427     assertEq(true >>> x, 0);

   428     assertEq(x << true, -2);

   429     assertEq(true << x, -2147483648);

   430     assertEq(x | -1.5, -1);

   431     assertEq(-1.5 | x, -1);

   432     assertEq(x & -1.5, -1);

   433     assertEq(-1.5 & x, -1);

   434     assertEq(x ^ -1.5, 0);

   435     assertEq(-1.5 ^ x, 0);

   436     assertEq(x >> -1.5, -1);

   437     assertEq(-1.5 >> x, -1);

   438     assertEq(x >>> -1.5, 1);

   439     assertEq(-1.5 >>> x, 1);

   440     assertEq(x << -1.5, -2147483648);

   441     assertEq(-1.5 << x, -2147483648);

   442 }

   443 test3(-1)

   445 function test4 (x) {

   446     assertEq(x | -1, -1);

   447     assertEq(-1 | x, -1);

   448     assertEq(x & -1, -2147483648);

   449     assertEq(-1 & x, -2147483648);

   450     assertEq(x ^ -1, 2147483647);

   451     assertEq(-1 ^ x, 2147483647);

   452     assertEq(x >> -1, -1);

   453     assertEq(-1 >> x, -1);

   454     assertEq(x >>> -1, 1);

   455     assertEq(-1 >>> x, 4294967295);

   456     assertEq(x << -1, 0);

   457     assertEq(-1 << x, -1);

   458     assertEq(x | 1, -2147483647);

   459     assertEq(1 | x, -2147483647);

   460     assertEq(x & 1, 0);

   461     assertEq(1 & x, 0);

   462     assertEq(x ^ 1, -2147483647);

   463     assertEq(1 ^ x, -2147483647);

   464     assertEq(x >> 1, -1073741824);

   465     assertEq(1 >> x, 1);

   466     assertEq(x >>> 1, 1073741824);

   467     assertEq(1 >>> x, 1);

   468     assertEq(x << 1, 0);

   469     assertEq(1 << x, 1);

   470     assertEq(x | 0, -2147483648);

   471     assertEq(0 | x, -2147483648);

   472     assertEq(x & 0, 0);

   473     assertEq(0 & x, 0);

   474     assertEq(x ^ 0, -2147483648);

   475     assertEq(0 ^ x, -2147483648);

   476     assertEq(x >> 0, -2147483648);

   477     assertEq(0 >> x, 0);

   478     assertEq(x >>> 0, 2147483648);

   479     assertEq(0 >>> x, 0);

   480     assertEq(x << 0, -2147483648);

   481     assertEq(0 << x, 0);

   482     assertEq(x | 0xffffffff, -1);

   483     assertEq(0xffffffff | x, -1);

   484     assertEq(x & 0xffffffff, -2147483648);

   485     assertEq(0xffffffff & x, -2147483648);

   486     assertEq(x ^ 0xffffffff, 2147483647);

   487     assertEq(0xffffffff ^ x, 2147483647);

   488     assertEq(x >> 0xffffffff, -1);

   489     assertEq(0xffffffff >> x, -1);

   490     assertEq(x >>> 0xffffffff, 1);

   491     assertEq(0xffffffff >>> x, 4294967295);

   492     assertEq(x << 0xffffffff, 0);

   493     assertEq(0xffffffff << x, -1);

   494     assertEq(x | "10.6", -2147483638);

   495     assertEq("10.6" | x, -2147483638);

   496     assertEq(x & "10.6", 0);

   497     assertEq("10.6" & x, 0);

   498     assertEq(x ^ "10.6", -2147483638);

   499     assertEq("10.6" ^ x, -2147483638);

   500     assertEq(x >> "10.6", -2097152);

   501     assertEq("10.6" >> x, 10);

   502     assertEq(x >>> "10.6", 2097152);

   503     assertEq("10.6" >>> x, 10);

   504     assertEq(x << "10.6", 0);

   505     assertEq("10.6" << x, 10);

   506     assertEq(x | 2147483648, -2147483648);

   507     assertEq(2147483648 | x, -2147483648);

   508     assertEq(x & 2147483648, -2147483648);

   509     assertEq(2147483648 & x, -2147483648);

   510     assertEq(x ^ 2147483648, 0);

   511     assertEq(2147483648 ^ x, 0);

   512     assertEq(x >> 2147483648, -2147483648);

   513     assertEq(2147483648 >> x, -2147483648);

   514     assertEq(x >>> 2147483648, 2147483648);

   515     assertEq(2147483648 >>> x, 2147483648);

   516     assertEq(x << 2147483648, -2147483648);

   517     assertEq(2147483648 << x, -2147483648);

   518     assertEq(x | 4294967296, -2147483648);

   519     assertEq(4294967296 | x, -2147483648);

   520     assertEq(x & 4294967296, 0);

   521     assertEq(4294967296 & x, 0);

   522     assertEq(x ^ 4294967296, -2147483648);

   523     assertEq(4294967296 ^ x, -2147483648);

   524     assertEq(x >> 4294967296, -2147483648);

   525     assertEq(4294967296 >> x, 0);

   526     assertEq(x >>> 4294967296, 2147483648);

   527     assertEq(4294967296 >>> x, 0);

   528     assertEq(x << 4294967296, -2147483648);

   529     assertEq(4294967296 << x, 0);

   530     assertEq(x | undefined, -2147483648);

   531     assertEq(undefined | x, -2147483648);

   532     assertEq(x & undefined, 0);

   533     assertEq(undefined & x, 0);

   534     assertEq(x ^ undefined, -2147483648);

   535     assertEq(undefined ^ x, -2147483648);

   536     assertEq(x >> undefined, -2147483648);

   537     assertEq(undefined >> x, 0);

   538     assertEq(x >>> undefined, 2147483648);

   539     assertEq(undefined >>> x, 0);

   540     assertEq(x << undefined, -2147483648);

   541     assertEq(undefined << x, 0);

   542     assertEq(x | null, -2147483648);

   543     assertEq(null | x, -2147483648);

   544     assertEq(x & null, 0);

   545     assertEq(null & x, 0);

   546     assertEq(x ^ null, -2147483648);

   547     assertEq(null ^ x, -2147483648);

   548     assertEq(x >> null, -2147483648);

   549     assertEq(null >> x, 0);

   550     assertEq(x >>> null, 2147483648);

   551     assertEq(null >>> x, 0);

   552     assertEq(x << null, -2147483648);

   553     assertEq(null << x, 0);

   554     assertEq(x | false, -2147483648);

   555     assertEq(false | x, -2147483648);

   556     assertEq(x & false, 0);

   557     assertEq(false & x, 0);

   558     assertEq(x ^ false, -2147483648);

   559     assertEq(false ^ x, -2147483648);

   560     assertEq(x >> false, -2147483648);

   561     assertEq(false >> x, 0);

   562     assertEq(x >>> false, 2147483648);

   563     assertEq(false >>> x, 0);

   564     assertEq(x << false, -2147483648);

   565     assertEq(false << x, 0);

   566     assertEq(x | true, -2147483647);

   567     assertEq(true | x, -2147483647);

   568     assertEq(x & true, 0);

   569     assertEq(true & x, 0);

   570     assertEq(x ^ true, -2147483647);

   571     assertEq(true ^ x, -2147483647);

   572     assertEq(x >> true, -1073741824);

   573     assertEq(true >> x, 1);

   574     assertEq(x >>> true, 1073741824);

   575     assertEq(true >>> x, 1);

   576     assertEq(x << true, 0);

   577     assertEq(true << x, 1);

   578     assertEq(x | -1.5, -1);

   579     assertEq(-1.5 | x, -1);

   580     assertEq(x & -1.5, -2147483648);

   581     assertEq(-1.5 & x, -2147483648);

   582     assertEq(x ^ -1.5, 2147483647);

   583     assertEq(-1.5 ^ x, 2147483647);

   584     assertEq(x >> -1.5, -1);

   585     assertEq(-1.5 >> x, -1);

   586     assertEq(x >>> -1.5, 1);

   587     assertEq(-1.5 >>> x, 4294967295);

   588     assertEq(x << -1.5, 0);

   589     assertEq(-1.5 << x, -1);

   590 }

   591 test4(2147483648)

   593 function test5 (x) {

   594     assertEq(x | -1, -1);

   595     assertEq(-1 | x, -1);

   596     assertEq(x & -1, -2147483648);

   597     assertEq(-1 & x, -2147483648);

   598     assertEq(x ^ -1, 2147483647);

   599     assertEq(-1 ^ x, 2147483647);

   600     assertEq(x >> -1, -1);

   601     assertEq(-1 >> x, -1);

   602     assertEq(x >>> -1, 1);

   603     assertEq(-1 >>> x, 4294967295);

   604     assertEq(x << -1, 0);

   605     assertEq(-1 << x, -1);

   606     assertEq(x | 1, -2147483647);

   607     assertEq(1 | x, -2147483647);

   608     assertEq(x & 1, 0);

   609     assertEq(1 & x, 0);

   610     assertEq(x ^ 1, -2147483647);

   611     assertEq(1 ^ x, -2147483647);

   612     assertEq(x >> 1, -1073741824);

   613     assertEq(1 >> x, 1);

   614     assertEq(x >>> 1, 1073741824);

   615     assertEq(1 >>> x, 1);

   616     assertEq(x << 1, 0);

   617     assertEq(1 << x, 1);

   618     assertEq(x | 0, -2147483648);

   619     assertEq(0 | x, -2147483648);

   620     assertEq(x & 0, 0);

   621     assertEq(0 & x, 0);

   622     assertEq(x ^ 0, -2147483648);

   623     assertEq(0 ^ x, -2147483648);

   624     assertEq(x >> 0, -2147483648);

   625     assertEq(0 >> x, 0);

   626     assertEq(x >>> 0, 2147483648);

   627     assertEq(0 >>> x, 0);

   628     assertEq(x << 0, -2147483648);

   629     assertEq(0 << x, 0);

   630     assertEq(x | 0xffffffff, -1);

   631     assertEq(0xffffffff | x, -1);

   632     assertEq(x & 0xffffffff, -2147483648);

   633     assertEq(0xffffffff & x, -2147483648);

   634     assertEq(x ^ 0xffffffff, 2147483647);

   635     assertEq(0xffffffff ^ x, 2147483647);

   636     assertEq(x >> 0xffffffff, -1);

   637     assertEq(0xffffffff >> x, -1);

   638     assertEq(x >>> 0xffffffff, 1);

   639     assertEq(0xffffffff >>> x, 4294967295);

   640     assertEq(x << 0xffffffff, 0);

   641     assertEq(0xffffffff << x, -1);

   642     assertEq(x | "10.6", -2147483638);

   643     assertEq("10.6" | x, -2147483638);

   644     assertEq(x & "10.6", 0);

   645     assertEq("10.6" & x, 0);

   646     assertEq(x ^ "10.6", -2147483638);

   647     assertEq("10.6" ^ x, -2147483638);

   648     assertEq(x >> "10.6", -2097152);

   649     assertEq("10.6" >> x, 10);

   650     assertEq(x >>> "10.6", 2097152);

   651     assertEq("10.6" >>> x, 10);

   652     assertEq(x << "10.6", 0);

   653     assertEq("10.6" << x, 10);

   654     assertEq(x | 2147483648, -2147483648);

   655     assertEq(2147483648 | x, -2147483648);

   656     assertEq(x & 2147483648, -2147483648);

   657     assertEq(2147483648 & x, -2147483648);

   658     assertEq(x ^ 2147483648, 0);

   659     assertEq(2147483648 ^ x, 0);

   660     assertEq(x >> 2147483648, -2147483648);

   661     assertEq(2147483648 >> x, -2147483648);

   662     assertEq(x >>> 2147483648, 2147483648);

   663     assertEq(2147483648 >>> x, 2147483648);

   664     assertEq(x << 2147483648, -2147483648);

   665     assertEq(2147483648 << x, -2147483648);

   666     assertEq(x | 4294967296, -2147483648);

   667     assertEq(4294967296 | x, -2147483648);

   668     assertEq(x & 4294967296, 0);

   669     assertEq(4294967296 & x, 0);

   670     assertEq(x ^ 4294967296, -2147483648);

   671     assertEq(4294967296 ^ x, -2147483648);

   672     assertEq(x >> 4294967296, -2147483648);

   673     assertEq(4294967296 >> x, 0);

   674     assertEq(x >>> 4294967296, 2147483648);

   675     assertEq(4294967296 >>> x, 0);

   676     assertEq(x << 4294967296, -2147483648);

   677     assertEq(4294967296 << x, 0);

   678     assertEq(x | undefined, -2147483648);

   679     assertEq(undefined | x, -2147483648);

   680     assertEq(x & undefined, 0);

   681     assertEq(undefined & x, 0);

   682     assertEq(x ^ undefined, -2147483648);

   683     assertEq(undefined ^ x, -2147483648);

   684     assertEq(x >> undefined, -2147483648);

   685     assertEq(undefined >> x, 0);

   686     assertEq(x >>> undefined, 2147483648);

   687     assertEq(undefined >>> x, 0);

   688     assertEq(x << undefined, -2147483648);

   689     assertEq(undefined << x, 0);

   690     assertEq(x | null, -2147483648);

   691     assertEq(null | x, -2147483648);

   692     assertEq(x & null, 0);

   693     assertEq(null & x, 0);

   694     assertEq(x ^ null, -2147483648);

   695     assertEq(null ^ x, -2147483648);

   696     assertEq(x >> null, -2147483648);

   697     assertEq(null >> x, 0);

   698     assertEq(x >>> null, 2147483648);

   699     assertEq(null >>> x, 0);

   700     assertEq(x << null, -2147483648);

   701     assertEq(null << x, 0);

   702     assertEq(x | false, -2147483648);

   703     assertEq(false | x, -2147483648);

   704     assertEq(x & false, 0);

   705     assertEq(false & x, 0);

   706     assertEq(x ^ false, -2147483648);

   707     assertEq(false ^ x, -2147483648);

   708     assertEq(x >> false, -2147483648);

   709     assertEq(false >> x, 0);

   710     assertEq(x >>> false, 2147483648);

   711     assertEq(false >>> x, 0);

   712     assertEq(x << false, -2147483648);

   713     assertEq(false << x, 0);

   714     assertEq(x | true, -2147483647);

   715     assertEq(true | x, -2147483647);

   716     assertEq(x & true, 0);

   717     assertEq(true & x, 0);

   718     assertEq(x ^ true, -2147483647);

   719     assertEq(true ^ x, -2147483647);

   720     assertEq(x >> true, -1073741824);

   721     assertEq(true >> x, 1);

   722     assertEq(x >>> true, 1073741824);

   723     assertEq(true >>> x, 1);

   724     assertEq(x << true, 0);

   725     assertEq(true << x, 1);

   726     assertEq(x | -1.5, -1);

   727     assertEq(-1.5 | x, -1);

   728     assertEq(x & -1.5, -2147483648);

   729     assertEq(-1.5 & x, -2147483648);

   730     assertEq(x ^ -1.5, 2147483647);

   731     assertEq(-1.5 ^ x, 2147483647);

   732     assertEq(x >> -1.5, -1);

   733     assertEq(-1.5 >> x, -1);

   734     assertEq(x >>> -1.5, 1);

   735     assertEq(-1.5 >>> x, 4294967295);

   736     assertEq(x << -1.5, 0);

   737     assertEq(-1.5 << x, -1);

   738 }

   739 test5(-2147483648)

The Tor Browser / file revision

js/src/jit-test/tests/basic/testBitopWithConstan.js@6474c204b198

js/src/jit-test/tests/basic/testBitopWithConstan.js