The Tor Browser: js/src/tests/js1_8_5/extensions/dataview.js@129ffea94266

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 // |reftest| skip-if(!xulRuntime.shell)

     2 /*

     3  * Any copyright is dedicated to the Public Domain.

     4  * http://creativecommons.org/licenses/publicdomain/

     5  * Contributor: Tobias Schneider <schneider@jancona.com>

     6  */

     8 //------------------------------------------------------------------------------

     9 var BUGNUMBER = 575688;

    10 var summary = 'DataView tests';

    12 function test() {

    13     function die(message, uplevel) {

    14         var e = new Error(message);

    15         var frame = e.stack.split("\n")[uplevel];

    16         print(message + " at " + frame.split("@")[1]);

    17         print("Stack:\n" + e.stack);

    18         throw(e);

    19     }

    21     function checkThrow(fun, type) {

    22         var thrown = false;

    23         try {

    24             fun();

    25         } catch (x) {

    26             thrown = x;

    27         }

    29         if (!thrown) {

    30             die('no exception thrown, expected ' + type.name, 2);

    31         } else if (!(thrown instanceof type)) {

    32             die('expected ' + type.name + ', got ' + thrown, 2);

    33         }

    34     }

    36     function checkThrowTODO(fun, type) {

    37         var thrown = false;

    38         try {

    39             fun();

    40         } catch (x) {

    41             thrown = x;

    42         }

    44         if (!thrown) {

    45             print('(TODO) no exception thrown, expected ' + type.name);

    46         } else if (!(thrown instanceof type)) {

    47             print('(TODO) expected ' + type.name + ', got ' + thrown);

    48         } else {

    49             print('test unexpectedly passed: expected ' + type.name + ' exception');

    50         }

    51     }

    53     enterFunc ('test');

    54     printBugNumber(BUGNUMBER);

    55     printStatus(summary);

    57     // testConstructor

    58     buffer = (new Uint8Array([1, 2])).buffer;

    59     checkThrow(function () new DataView(buffer, 0, 3), RangeError);

    60     checkThrow(function () new DataView(buffer, 1, 2), RangeError);

    61     checkThrow(function () new DataView(buffer, 2, 1), RangeError);

    62     checkThrow(function () new DataView(buffer, 2147483649, 0), RangeError);

    63     checkThrow(function () new DataView(buffer, 0, 2147483649), RangeError);

    64     checkThrow(function() new DataView(), TypeError);

    65     checkThrow(function() new DataView(Object.create(new ArrayBuffer(5))), TypeError);

    67     // testGetMethods

    69     // testIntegerGets(start=0, length=16)

    70     var data1 = [0,1,2,3,0x64,0x65,0x66,0x67,0x80,0x81,0x82,0x83,252,253,254,255];

    71     var data1_r = data1.slice().reverse();

    72     var buffer1 = new Uint8Array(data1).buffer;

    73     var view1 = new DataView(buffer1, 0, 16);

    74     view = view1;

    75     assertEq(view.getInt8(0), 0);

    76     assertEq(view.getInt8(8), -128);

    77     assertEq(view.getInt8(15), -1);

    78     assertEq(view.getUint8(0), 0);

    79     assertEq(view.getUint8(8), 128);

    80     assertEq(view.getUint8(15), 255);

    81     //   Little endian.

    82     assertEq(view.getInt16(0, true), 256);

    83     assertEq(view.getInt16(5, true), 0x6665);

    84     assertEq(view.getInt16(9, true), -32127);

    85     assertEq(view.getInt16(14, true), -2);

    86     // Big endian.

    87     assertEq(view.getInt16(0), 1);

    88     assertEq(view.getInt16(5), 0x6566);

    89     assertEq(view.getInt16(9), -32382);

    90     assertEq(view.getInt16(14), -257);

    91     // Little endian.

    92     assertEq(view.getUint16(0, true), 256);

    93     assertEq(view.getUint16(5, true), 0x6665);

    94     assertEq(view.getUint16(9, true), 0x8281);

    95     assertEq(view.getUint16(14, true), 0xfffe);

    96     // Big endian.

    97     assertEq(view.getUint16(0), 1);

    98     assertEq(view.getUint16(5), 0x6566);

    99     assertEq(view.getUint16(9), 0x8182);

   100     assertEq(view.getUint16(14), 0xfeff);

   101     // Little endian.

   102     assertEq(view.getInt32(0, true), 0x3020100);

   103     assertEq(view.getInt32(3, true), 0x66656403);

   104     assertEq(view.getInt32(6, true), -2122291354);

   105     assertEq(view.getInt32(9, true), -58490239);

   106     assertEq(view.getInt32(12, true), -66052);

   107     // Big endian.

   108     assertEq(view.getInt32(0), 0x10203);

   109     assertEq(view.getInt32(3), 0x3646566);

   110     assertEq(view.getInt32(6), 0x66678081);

   111     assertEq(view.getInt32(9), -2122152964);

   112     assertEq(view.getInt32(12), -50462977);

   113     // Little endian.

   114     assertEq(view.getUint32(0, true), 0x3020100);

   115     assertEq(view.getUint32(3, true), 0x66656403);

   116     assertEq(view.getUint32(6, true), 0x81806766);

   117     assertEq(view.getUint32(9, true), 0xfc838281);

   118     assertEq(view.getUint32(12, true), 0xfffefdfc);

   119     // Big endian.

   120     assertEq(view.getUint32(0), 0x10203);

   121     assertEq(view.getUint32(3), 0x3646566);

   122     assertEq(view.getUint32(6), 0x66678081);

   123     assertEq(view.getUint32(9), 0x818283fc);

   124     assertEq(view.getUint32(12), 0xfcfdfeff);

   126     // testFloatGets(start=0)

   128     // testFloatGet expected=10

   129     //   Little endian

   130     var data2 = [0,0,32,65];

   131     var data2_r = data2.slice().reverse();

   132     var buffer2 = new Uint8Array(data2).buffer;

   133     view = new DataView(buffer2, 0, 4);

   134     assertEq(view.getFloat32(0, true), 10);

   135     var buffer2_pad3 = new Uint8Array(Array(3).concat(data2)).buffer;

   136     view = new DataView(buffer2_pad3, 0, 7);

   137     assertEq(view.getFloat32(3, true), 10);

   138     var buffer2_pad7 = new Uint8Array(Array(7).concat(data2)).buffer;

   139     view = new DataView(buffer2_pad7, 0, 11);

   140     assertEq(view.getFloat32(7, true), 10);

   141     var buffer2_pad10 = new Uint8Array(Array(10).concat(data2)).buffer;

   142     view = new DataView(buffer2_pad10, 0, 14);

   143     assertEq(view.getFloat32(10, true), 10);

   144     //   Big endian.

   145     var buffer2_r = new Uint8Array(data2_r).buffer;

   146     view = new DataView(buffer2_r, 0, 4);

   147     assertEq(view.getFloat32(0, false), 10);

   148     var buffer2_r_pad3 = new Uint8Array(Array(3).concat(data2_r)).buffer;

   149     view = new DataView(buffer2_r_pad3, 0, 7);

   150     assertEq(view.getFloat32(3, false), 10);

   151     var buffer2_r_pad7 = new Uint8Array(Array(7).concat(data2_r)).buffer;

   152     view = new DataView(buffer2_r_pad7, 0, 11);

   153     assertEq(view.getFloat32(7, false), 10);

   154     var buffer2_r_pad10 = new Uint8Array(Array(10).concat(data2_r)).buffer;

   155     view = new DataView(buffer2_r_pad10, 0, 14);

   156     assertEq(view.getFloat32(10, false), 10);

   158     // testFloatGet expected=1.2300000190734863

   159     //   Little endian

   160     var data3 = [164,112,157,63];

   161     var data3_r = data3.slice().reverse();

   162     var buffer3 = new Uint8Array(data3).buffer;

   163     view = new DataView(buffer3, 0, 4);

   164     assertEq(view.getFloat32(0, true), 1.2300000190734863);

   165     var buffer3_pad3 = new Uint8Array(Array(3).concat(data3)).buffer;

   166     view = new DataView(buffer3_pad3, 0, 7);

   167     assertEq(view.getFloat32(3, true), 1.2300000190734863);

   168     var buffer3_pad7 = new Uint8Array(Array(7).concat(data3)).buffer;

   169     view = new DataView(buffer3_pad7, 0, 11);

   170     assertEq(view.getFloat32(7, true), 1.2300000190734863);

   171     var buffer3_pad10 = new Uint8Array(Array(10).concat(data3)).buffer;

   172     view = new DataView(buffer3_pad10, 0, 14);

   173     assertEq(view.getFloat32(10, true), 1.2300000190734863);

   174     //   Big endian.

   175     var buffer3_r = new Uint8Array(data3_r).buffer;

   176     view = new DataView(buffer3_r, 0, 4);

   177     assertEq(view.getFloat32(0, false), 1.2300000190734863);

   178     var buffer3_r_pad3 = new Uint8Array(Array(3).concat(data3_r)).buffer;

   179     view = new DataView(buffer3_r_pad3, 0, 7);

   180     assertEq(view.getFloat32(3, false), 1.2300000190734863);

   181     var buffer3_r_pad7 = new Uint8Array(Array(7).concat(data3_r)).buffer;

   182     view = new DataView(buffer3_r_pad7, 0, 11);

   183     assertEq(view.getFloat32(7, false), 1.2300000190734863);

   184     var buffer3_r_pad10 = new Uint8Array(Array(10).concat(data3_r)).buffer;

   185     view = new DataView(buffer3_r_pad10, 0, 14);

   186     assertEq(view.getFloat32(10, false), 1.2300000190734863);

   188     // testFloatGet expected=-45621.37109375

   189     //   Little endian

   190     var data4 = [95,53,50,199];

   191     var data4_r = data4.slice().reverse();

   192     var buffer4 = new Uint8Array(data4).buffer;

   193     view = new DataView(buffer4, 0, 4);

   194     assertEq(view.getFloat32(0, true), -45621.37109375);

   195     var buffer4_pad3 = new Uint8Array(Array(3).concat(data4)).buffer;

   196     view = new DataView(buffer4_pad3, 0, 7);

   197     assertEq(view.getFloat32(3, true), -45621.37109375);

   198     var buffer4_pad7 = new Uint8Array(Array(7).concat(data4)).buffer;

   199     view = new DataView(buffer4_pad7, 0, 11);

   200     assertEq(view.getFloat32(7, true), -45621.37109375);

   201     var buffer4_pad10 = new Uint8Array(Array(10).concat(data4)).buffer;

   202     view = new DataView(buffer4_pad10, 0, 14);

   203     assertEq(view.getFloat32(10, true), -45621.37109375);

   204     //   Big endian.

   205     var buffer4_r = new Uint8Array(data4_r).buffer;

   206     view = new DataView(buffer4_r, 0, 4);

   207     assertEq(view.getFloat32(0, false), -45621.37109375);

   208     var buffer4_r_pad3 = new Uint8Array(Array(3).concat(data4_r)).buffer;

   209     view = new DataView(buffer4_r_pad3, 0, 7);

   210     assertEq(view.getFloat32(3, false), -45621.37109375);

   211     var buffer4_r_pad7 = new Uint8Array(Array(7).concat(data4_r)).buffer;

   212     view = new DataView(buffer4_r_pad7, 0, 11);

   213     assertEq(view.getFloat32(7, false), -45621.37109375);

   214     var buffer4_r_pad10 = new Uint8Array(Array(10).concat(data4_r)).buffer;

   215     view = new DataView(buffer4_r_pad10, 0, 14);

   216     assertEq(view.getFloat32(10, false), -45621.37109375);

   218     // testFloatGet expected=NaN

   219     //   Little endian

   220     var data5 = [255,255,255,127];

   221     var data5_r = data5.slice().reverse();

   222     var buffer5 = new Uint8Array(data5).buffer;

   223     view = new DataView(buffer5, 0, 4);

   224     assertEq(view.getFloat32(0, true), NaN);

   225     var buffer5_pad3 = new Uint8Array(Array(3).concat(data5)).buffer;

   226     view = new DataView(buffer5_pad3, 0, 7);

   227     assertEq(view.getFloat32(3, true), NaN);

   228     var buffer5_pad7 = new Uint8Array(Array(7).concat(data5)).buffer;

   229     view = new DataView(buffer5_pad7, 0, 11);

   230     assertEq(view.getFloat32(7, true), NaN);

   231     var buffer5_pad10 = new Uint8Array(Array(10).concat(data5)).buffer;

   232     view = new DataView(buffer5_pad10, 0, 14);

   233     assertEq(view.getFloat32(10, true), NaN);

   234     //   Big endian.

   235     var buffer5_r = new Uint8Array(data5_r).buffer;

   236     view = new DataView(buffer5_r, 0, 4);

   237     assertEq(view.getFloat32(0, false), NaN);

   238     var buffer5_r_pad3 = new Uint8Array(Array(3).concat(data5_r)).buffer;

   239     view = new DataView(buffer5_r_pad3, 0, 7);

   240     assertEq(view.getFloat32(3, false), NaN);

   241     var buffer5_r_pad7 = new Uint8Array(Array(7).concat(data5_r)).buffer;

   242     view = new DataView(buffer5_r_pad7, 0, 11);

   243     assertEq(view.getFloat32(7, false), NaN);

   244     var buffer5_r_pad10 = new Uint8Array(Array(10).concat(data5_r)).buffer;

   245     view = new DataView(buffer5_r_pad10, 0, 14);

   246     assertEq(view.getFloat32(10, false), NaN);

   248     // testFloatGet expected=NaN

   249     //   Little endian

   250     var data6 = [255,255,255,255];

   251     var data6_r = data6.slice().reverse();

   252     var buffer6 = new Uint8Array(data6).buffer;

   253     view = new DataView(buffer6, 0, 4);

   254     assertEq(view.getFloat32(0, true), NaN);

   255     var buffer6_pad3 = new Uint8Array(Array(3).concat(data6)).buffer;

   256     view = new DataView(buffer6_pad3, 0, 7);

   257     assertEq(view.getFloat32(3, true), NaN);

   258     var buffer6_pad7 = new Uint8Array(Array(7).concat(data6)).buffer;

   259     view = new DataView(buffer6_pad7, 0, 11);

   260     assertEq(view.getFloat32(7, true), NaN);

   261     var buffer6_pad10 = new Uint8Array(Array(10).concat(data6)).buffer;

   262     view = new DataView(buffer6_pad10, 0, 14);

   263     assertEq(view.getFloat32(10, true), NaN);

   264     //   Big endian.

   265     var buffer6_r = new Uint8Array(data6_r).buffer;

   266     view = new DataView(buffer6_r, 0, 4);

   267     assertEq(view.getFloat32(0, false), NaN);

   268     var buffer6_r_pad3 = new Uint8Array(Array(3).concat(data6_r)).buffer;

   269     view = new DataView(buffer6_r_pad3, 0, 7);

   270     assertEq(view.getFloat32(3, false), NaN);

   271     var buffer6_r_pad7 = new Uint8Array(Array(7).concat(data6_r)).buffer;

   272     view = new DataView(buffer6_r_pad7, 0, 11);

   273     assertEq(view.getFloat32(7, false), NaN);

   274     var buffer6_r_pad10 = new Uint8Array(Array(10).concat(data6_r)).buffer;

   275     view = new DataView(buffer6_r_pad10, 0, 14);

   276     assertEq(view.getFloat32(10, false), NaN);

   278     // testFloatGet expected=10

   279     //   Little endian

   280     var data7 = [0,0,0,0,0,0,36,64];

   281     var data7_r = data7.slice().reverse();

   282     var buffer7 = new Uint8Array(data7).buffer;

   283     view = new DataView(buffer7, 0, 8);

   284     assertEq(view.getFloat64(0, true), 10);

   285     var buffer7_pad3 = new Uint8Array(Array(3).concat(data7)).buffer;

   286     view = new DataView(buffer7_pad3, 0, 11);

   287     assertEq(view.getFloat64(3, true), 10);

   288     var buffer7_pad7 = new Uint8Array(Array(7).concat(data7)).buffer;

   289     view = new DataView(buffer7_pad7, 0, 15);

   290     assertEq(view.getFloat64(7, true), 10);

   291     var buffer7_pad10 = new Uint8Array(Array(10).concat(data7)).buffer;

   292     view = new DataView(buffer7_pad10, 0, 18);

   293     assertEq(view.getFloat64(10, true), 10);

   294     //   Big endian.

   295     var buffer7_r = new Uint8Array(data7_r).buffer;

   296     view = new DataView(buffer7_r, 0, 8);

   297     assertEq(view.getFloat64(0, false), 10);

   298     var buffer7_r_pad3 = new Uint8Array(Array(3).concat(data7_r)).buffer;

   299     view = new DataView(buffer7_r_pad3, 0, 11);

   300     assertEq(view.getFloat64(3, false), 10);

   301     var buffer7_r_pad7 = new Uint8Array(Array(7).concat(data7_r)).buffer;

   302     view = new DataView(buffer7_r_pad7, 0, 15);

   303     assertEq(view.getFloat64(7, false), 10);

   304     var buffer7_r_pad10 = new Uint8Array(Array(10).concat(data7_r)).buffer;

   305     view = new DataView(buffer7_r_pad10, 0, 18);

   306     assertEq(view.getFloat64(10, false), 10);

   308     // testFloatGet expected=1.23

   309     //   Little endian

   310     var data8 = [174,71,225,122,20,174,243,63];

   311     var data8_r = data8.slice().reverse();

   312     var buffer8 = new Uint8Array(data8).buffer;

   313     view = new DataView(buffer8, 0, 8);

   314     assertEq(view.getFloat64(0, true), 1.23);

   315     var buffer8_pad3 = new Uint8Array(Array(3).concat(data8)).buffer;

   316     view = new DataView(buffer8_pad3, 0, 11);

   317     assertEq(view.getFloat64(3, true), 1.23);

   318     var buffer8_pad7 = new Uint8Array(Array(7).concat(data8)).buffer;

   319     view = new DataView(buffer8_pad7, 0, 15);

   320     assertEq(view.getFloat64(7, true), 1.23);

   321     var buffer8_pad10 = new Uint8Array(Array(10).concat(data8)).buffer;

   322     view = new DataView(buffer8_pad10, 0, 18);

   323     assertEq(view.getFloat64(10, true), 1.23);

   324     //   Big endian.

   325     var buffer8_r = new Uint8Array(data8_r).buffer;

   326     view = new DataView(buffer8_r, 0, 8);

   327     assertEq(view.getFloat64(0, false), 1.23);

   328     var buffer8_r_pad3 = new Uint8Array(Array(3).concat(data8_r)).buffer;

   329     view = new DataView(buffer8_r_pad3, 0, 11);

   330     assertEq(view.getFloat64(3, false), 1.23);

   331     var buffer8_r_pad7 = new Uint8Array(Array(7).concat(data8_r)).buffer;

   332     view = new DataView(buffer8_r_pad7, 0, 15);

   333     assertEq(view.getFloat64(7, false), 1.23);

   334     var buffer8_r_pad10 = new Uint8Array(Array(10).concat(data8_r)).buffer;

   335     view = new DataView(buffer8_r_pad10, 0, 18);

   336     assertEq(view.getFloat64(10, false), 1.23);

   338     // testFloatGet expected=-6213576.4839

   339     //   Little endian

   340     var data9 = [181,55,248,30,242,179,87,193];

   341     var data9_r = data9.slice().reverse();

   342     var buffer9 = new Uint8Array(data9).buffer;

   343     view = new DataView(buffer9, 0, 8);

   344     assertEq(view.getFloat64(0, true), -6213576.4839);

   345     var buffer9_pad3 = new Uint8Array(Array(3).concat(data9)).buffer;

   346     view = new DataView(buffer9_pad3, 0, 11);

   347     assertEq(view.getFloat64(3, true), -6213576.4839);

   348     var buffer9_pad7 = new Uint8Array(Array(7).concat(data9)).buffer;

   349     view = new DataView(buffer9_pad7, 0, 15);

   350     assertEq(view.getFloat64(7, true), -6213576.4839);

   351     var buffer9_pad10 = new Uint8Array(Array(10).concat(data9)).buffer;

   352     view = new DataView(buffer9_pad10, 0, 18);

   353     assertEq(view.getFloat64(10, true), -6213576.4839);

   354     //   Big endian.

   355     var buffer9_r = new Uint8Array(data9_r).buffer;

   356     view = new DataView(buffer9_r, 0, 8);

   357     assertEq(view.getFloat64(0, false), -6213576.4839);

   358     var buffer9_r_pad3 = new Uint8Array(Array(3).concat(data9_r)).buffer;

   359     view = new DataView(buffer9_r_pad3, 0, 11);

   360     assertEq(view.getFloat64(3, false), -6213576.4839);

   361     var buffer9_r_pad7 = new Uint8Array(Array(7).concat(data9_r)).buffer;

   362     view = new DataView(buffer9_r_pad7, 0, 15);

   363     assertEq(view.getFloat64(7, false), -6213576.4839);

   364     var buffer9_r_pad10 = new Uint8Array(Array(10).concat(data9_r)).buffer;

   365     view = new DataView(buffer9_r_pad10, 0, 18);

   366     assertEq(view.getFloat64(10, false), -6213576.4839);

   368     // testFloatGet expected=NaN

   369     //   Little endian

   370     var data10 = [255,255,255,255,255,255,255,127];

   371     var data10_r = data10.slice().reverse();

   372     var buffer10 = new Uint8Array(data10).buffer;

   373     view = new DataView(buffer10, 0, 8);

   374     assertEq(view.getFloat64(0, true), NaN);

   375     var buffer10_pad3 = new Uint8Array(Array(3).concat(data10)).buffer;

   376     view = new DataView(buffer10_pad3, 0, 11);

   377     assertEq(view.getFloat64(3, true), NaN);

   378     var buffer10_pad7 = new Uint8Array(Array(7).concat(data10)).buffer;

   379     view = new DataView(buffer10_pad7, 0, 15);

   380     assertEq(view.getFloat64(7, true), NaN);

   381     var buffer10_pad10 = new Uint8Array(Array(10).concat(data10)).buffer;

   382     view = new DataView(buffer10_pad10, 0, 18);

   383     assertEq(view.getFloat64(10, true), NaN);

   384     //   Big endian.

   385     var buffer10_r = new Uint8Array(data10_r).buffer;

   386     view = new DataView(buffer10_r, 0, 8);

   387     assertEq(view.getFloat64(0, false), NaN);

   388     var buffer10_r_pad3 = new Uint8Array(Array(3).concat(data10_r)).buffer;

   389     view = new DataView(buffer10_r_pad3, 0, 11);

   390     assertEq(view.getFloat64(3, false), NaN);

   391     var buffer10_r_pad7 = new Uint8Array(Array(7).concat(data10_r)).buffer;

   392     view = new DataView(buffer10_r_pad7, 0, 15);

   393     assertEq(view.getFloat64(7, false), NaN);

   394     var buffer10_r_pad10 = new Uint8Array(Array(10).concat(data10_r)).buffer;

   395     view = new DataView(buffer10_r_pad10, 0, 18);

   396     assertEq(view.getFloat64(10, false), NaN);

   398     // testFloatGet expected=NaN

   399     //   Little endian

   400     var data11 = [255,255,255,255,255,255,255,255];

   401     var data11_r = data11.slice().reverse();

   402     var buffer11 = new Uint8Array(data11).buffer;

   403     view = new DataView(buffer11, 0, 8);

   404     assertEq(view.getFloat64(0, true), NaN);

   405     var buffer11_pad3 = new Uint8Array(Array(3).concat(data11)).buffer;

   406     view = new DataView(buffer11_pad3, 0, 11);

   407     assertEq(view.getFloat64(3, true), NaN);

   408     var buffer11_pad7 = new Uint8Array(Array(7).concat(data11)).buffer;

   409     view = new DataView(buffer11_pad7, 0, 15);

   410     assertEq(view.getFloat64(7, true), NaN);

   411     var buffer11_pad10 = new Uint8Array(Array(10).concat(data11)).buffer;

   412     view = new DataView(buffer11_pad10, 0, 18);

   413     assertEq(view.getFloat64(10, true), NaN);

   414     //   Big endian.

   415     var buffer11_r = new Uint8Array(data11_r).buffer;

   416     view = new DataView(buffer11_r, 0, 8);

   417     assertEq(view.getFloat64(0, false), NaN);

   418     var buffer11_r_pad3 = new Uint8Array(Array(3).concat(data11_r)).buffer;

   419     view = new DataView(buffer11_r_pad3, 0, 11);

   420     assertEq(view.getFloat64(3, false), NaN);

   421     var buffer11_r_pad7 = new Uint8Array(Array(7).concat(data11_r)).buffer;

   422     view = new DataView(buffer11_r_pad7, 0, 15);

   423     assertEq(view.getFloat64(7, false), NaN);

   424     var buffer11_r_pad10 = new Uint8Array(Array(10).concat(data11_r)).buffer;

   425     view = new DataView(buffer11_r_pad10, 0, 18);

   426     assertEq(view.getFloat64(10, false), NaN);

   428     // testIntegerGets(start=3, length=2)

   429     var data12 = [31,32,33,0,1,2,3,100,101,102,103,128,129,130,131,252,253,254,255];

   430     var data12_r = data12.slice().reverse();

   431     var buffer12 = new Uint8Array(data12).buffer;

   432     view = new DataView(buffer12, 3, 2);

   433     assertEq(view.getInt8(0), 0);

   434     checkThrow(function () view.getInt8(8), RangeError);

   435     checkThrow(function () view.getInt8(15), RangeError);

   436     assertEq(view.getUint8(0), 0);

   437     checkThrow(function () view.getUint8(8), RangeError);

   438     checkThrow(function () view.getUint8(15), RangeError);

   439     //   Little endian.

   440     assertEq(view.getInt16(0, true), 256);

   441     checkThrow(function () view.getInt16(5, true), RangeError);

   442     checkThrow(function () view.getInt16(9, true), RangeError);

   443     checkThrow(function () view.getInt16(14, true), RangeError);

   444     // Big endian.

   445     assertEq(view.getInt16(0), 1);

   446     checkThrow(function () view.getInt16(5), RangeError);

   447     checkThrow(function () view.getInt16(9), RangeError);

   448     checkThrow(function () view.getInt16(14), RangeError);

   449     // Little endian.

   450     assertEq(view.getUint16(0, true), 256);

   451     checkThrow(function () view.getUint16(5, true), RangeError);

   452     checkThrow(function () view.getUint16(9, true), RangeError);

   453     checkThrow(function () view.getUint16(14, true), RangeError);

   454     // Big endian.

   455     assertEq(view.getUint16(0), 1);

   456     checkThrow(function () view.getUint16(5), RangeError);

   457     checkThrow(function () view.getUint16(9), RangeError);

   458     checkThrow(function () view.getUint16(14), RangeError);

   459     // Little endian.

   460     checkThrow(function () view.getInt32(0, true), RangeError);

   461     checkThrow(function () view.getInt32(3, true), RangeError);

   462     checkThrow(function () view.getInt32(6, true), RangeError);

   463     checkThrow(function () view.getInt32(9, true), RangeError);

   464     checkThrow(function () view.getInt32(12, true), RangeError);

   465     // Big endian.

   466     checkThrow(function () view.getInt32(0), RangeError);

   467     checkThrow(function () view.getInt32(3), RangeError);

   468     checkThrow(function () view.getInt32(6), RangeError);

   469     checkThrow(function () view.getInt32(9), RangeError);

   470     checkThrow(function () view.getInt32(12), RangeError);

   471     // Little endian.

   472     checkThrow(function () view.getUint32(0, true), RangeError);

   473     checkThrow(function () view.getUint32(3, true), RangeError);

   474     checkThrow(function () view.getUint32(6, true), RangeError);

   475     checkThrow(function () view.getUint32(9, true), RangeError);

   476     checkThrow(function () view.getUint32(12, true), RangeError);

   477     // Big endian.

   478     checkThrow(function () view.getUint32(0), RangeError);

   479     checkThrow(function () view.getUint32(3), RangeError);

   480     checkThrow(function () view.getUint32(6), RangeError);

   481     checkThrow(function () view.getUint32(9), RangeError);

   482     checkThrow(function () view.getUint32(12), RangeError);

   484     // testFloatGets(start=3)

   486     // testFloatGet expected=10

   487     //   Little endian

   488     view = new DataView(buffer2, 3, 1);

   489     checkThrow(function () view.getFloat32(0, true), RangeError);

   490     view = new DataView(buffer2_pad3, 3, 4);

   491     checkThrow(function () view.getFloat32(3, true), RangeError);

   492     view = new DataView(buffer2_pad7, 3, 8);

   493     checkThrow(function () view.getFloat32(7, true), RangeError);

   494     view = new DataView(buffer2_pad10, 3, 11);

   495     checkThrow(function () view.getFloat32(10, true), RangeError);

   496     //   Big endian.

   497     view = new DataView(buffer2_r, 3, 1);

   498     checkThrow(function () view.getFloat32(0, false), RangeError);

   499     view = new DataView(buffer2_r_pad3, 3, 4);

   500     checkThrow(function () view.getFloat32(3, false), RangeError);

   501     view = new DataView(buffer2_r_pad7, 3, 8);

   502     checkThrow(function () view.getFloat32(7, false), RangeError);

   503     view = new DataView(buffer2_r_pad10, 3, 11);

   504     checkThrow(function () view.getFloat32(10, false), RangeError);

   506     // testFloatGet expected=1.2300000190734863

   507     //   Little endian

   508     view = new DataView(buffer3, 3, 1);

   509     checkThrow(function () view.getFloat32(0, true), RangeError);

   510     view = new DataView(buffer3_pad3, 3, 4);

   511     checkThrow(function () view.getFloat32(3, true), RangeError);

   512     view = new DataView(buffer3_pad7, 3, 8);

   513     checkThrow(function () view.getFloat32(7, true), RangeError);

   514     view = new DataView(buffer3_pad10, 3, 11);

   515     checkThrow(function () view.getFloat32(10, true), RangeError);

   516     //   Big endian.

   517     view = new DataView(buffer3_r, 3, 1);

   518     checkThrow(function () view.getFloat32(0, false), RangeError);

   519     view = new DataView(buffer3_r_pad3, 3, 4);

   520     checkThrow(function () view.getFloat32(3, false), RangeError);

   521     view = new DataView(buffer3_r_pad7, 3, 8);

   522     checkThrow(function () view.getFloat32(7, false), RangeError);

   523     view = new DataView(buffer3_r_pad10, 3, 11);

   524     checkThrow(function () view.getFloat32(10, false), RangeError);

   526     // testFloatGet expected=-45621.37109375

   527     //   Little endian

   528     view = new DataView(buffer4, 3, 1);

   529     checkThrow(function () view.getFloat32(0, true), RangeError);

   530     view = new DataView(buffer4_pad3, 3, 4);

   531     checkThrow(function () view.getFloat32(3, true), RangeError);

   532     view = new DataView(buffer4_pad7, 3, 8);

   533     checkThrow(function () view.getFloat32(7, true), RangeError);

   534     view = new DataView(buffer4_pad10, 3, 11);

   535     checkThrow(function () view.getFloat32(10, true), RangeError);

   536     //   Big endian.

   537     view = new DataView(buffer4_r, 3, 1);

   538     checkThrow(function () view.getFloat32(0, false), RangeError);

   539     view = new DataView(buffer4_r_pad3, 3, 4);

   540     checkThrow(function () view.getFloat32(3, false), RangeError);

   541     view = new DataView(buffer4_r_pad7, 3, 8);

   542     checkThrow(function () view.getFloat32(7, false), RangeError);

   543     view = new DataView(buffer4_r_pad10, 3, 11);

   544     checkThrow(function () view.getFloat32(10, false), RangeError);

   546     // testFloatGet expected=NaN

   547     //   Little endian

   548     view = new DataView(buffer5, 3, 1);

   549     checkThrow(function () view.getFloat32(0, true), RangeError);

   550     view = new DataView(buffer5_pad3, 3, 4);

   551     checkThrow(function () view.getFloat32(3, true), RangeError);

   552     view = new DataView(buffer5_pad7, 3, 8);

   553     checkThrow(function () view.getFloat32(7, true), RangeError);

   554     view = new DataView(buffer5_pad10, 3, 11);

   555     checkThrow(function () view.getFloat32(10, true), RangeError);

   556     //   Big endian.

   557     view = new DataView(buffer5_r, 3, 1);

   558     checkThrow(function () view.getFloat32(0, false), RangeError);

   559     view = new DataView(buffer5_r_pad3, 3, 4);

   560     checkThrow(function () view.getFloat32(3, false), RangeError);

   561     view = new DataView(buffer5_r_pad7, 3, 8);

   562     checkThrow(function () view.getFloat32(7, false), RangeError);

   563     view = new DataView(buffer5_r_pad10, 3, 11);

   564     checkThrow(function () view.getFloat32(10, false), RangeError);

   566     // testFloatGet expected=NaN

   567     //   Little endian

   568     view = new DataView(buffer6, 3, 1);

   569     checkThrow(function () view.getFloat32(0, true), RangeError);

   570     view = new DataView(buffer6_pad3, 3, 4);

   571     checkThrow(function () view.getFloat32(3, true), RangeError);

   572     view = new DataView(buffer6_pad7, 3, 8);

   573     checkThrow(function () view.getFloat32(7, true), RangeError);

   574     view = new DataView(buffer6_pad10, 3, 11);

   575     checkThrow(function () view.getFloat32(10, true), RangeError);

   576     //   Big endian.

   577     view = new DataView(buffer6_r, 3, 1);

   578     checkThrow(function () view.getFloat32(0, false), RangeError);

   579     view = new DataView(buffer6_r_pad3, 3, 4);

   580     checkThrow(function () view.getFloat32(3, false), RangeError);

   581     view = new DataView(buffer6_r_pad7, 3, 8);

   582     checkThrow(function () view.getFloat32(7, false), RangeError);

   583     view = new DataView(buffer6_r_pad10, 3, 11);

   584     checkThrow(function () view.getFloat32(10, false), RangeError);

   586     // testFloatGet expected=10

   587     //   Little endian

   588     view = new DataView(buffer7, 3, 5);

   589     checkThrow(function () view.getFloat64(0, true), RangeError);

   590     view = new DataView(buffer7_pad3, 3, 8);

   591     checkThrow(function () view.getFloat64(3, true), RangeError);

   592     view = new DataView(buffer7_pad7, 3, 12);

   593     checkThrow(function () view.getFloat64(7, true), RangeError);

   594     view = new DataView(buffer7_pad10, 3, 15);

   595     checkThrow(function () view.getFloat64(10, true), RangeError);

   596     //   Big endian.

   597     view = new DataView(buffer7_r, 3, 5);

   598     checkThrow(function () view.getFloat64(0, false), RangeError);

   599     view = new DataView(buffer7_r_pad3, 3, 8);

   600     checkThrow(function () view.getFloat64(3, false), RangeError);

   601     view = new DataView(buffer7_r_pad7, 3, 12);

   602     checkThrow(function () view.getFloat64(7, false), RangeError);

   603     view = new DataView(buffer7_r_pad10, 3, 15);

   604     checkThrow(function () view.getFloat64(10, false), RangeError);

   606     // testFloatGet expected=1.23

   607     //   Little endian

   608     view = new DataView(buffer8, 3, 5);

   609     checkThrow(function () view.getFloat64(0, true), RangeError);

   610     view = new DataView(buffer8_pad3, 3, 8);

   611     checkThrow(function () view.getFloat64(3, true), RangeError);

   612     view = new DataView(buffer8_pad7, 3, 12);

   613     checkThrow(function () view.getFloat64(7, true), RangeError);

   614     view = new DataView(buffer8_pad10, 3, 15);

   615     checkThrow(function () view.getFloat64(10, true), RangeError);

   616     //   Big endian.

   617     view = new DataView(buffer8_r, 3, 5);

   618     checkThrow(function () view.getFloat64(0, false), RangeError);

   619     view = new DataView(buffer8_r_pad3, 3, 8);

   620     checkThrow(function () view.getFloat64(3, false), RangeError);

   621     view = new DataView(buffer8_r_pad7, 3, 12);

   622     checkThrow(function () view.getFloat64(7, false), RangeError);

   623     view = new DataView(buffer8_r_pad10, 3, 15);

   624     checkThrow(function () view.getFloat64(10, false), RangeError);

   626     // testFloatGet expected=-6213576.4839

   627     //   Little endian

   628     view = new DataView(buffer9, 3, 5);

   629     checkThrow(function () view.getFloat64(0, true), RangeError);

   630     view = new DataView(buffer9_pad3, 3, 8);

   631     checkThrow(function () view.getFloat64(3, true), RangeError);

   632     view = new DataView(buffer9_pad7, 3, 12);

   633     checkThrow(function () view.getFloat64(7, true), RangeError);

   634     view = new DataView(buffer9_pad10, 3, 15);

   635     checkThrow(function () view.getFloat64(10, true), RangeError);

   636     //   Big endian.

   637     view = new DataView(buffer9_r, 3, 5);

   638     checkThrow(function () view.getFloat64(0, false), RangeError);

   639     view = new DataView(buffer9_r_pad3, 3, 8);

   640     checkThrow(function () view.getFloat64(3, false), RangeError);

   641     view = new DataView(buffer9_r_pad7, 3, 12);

   642     checkThrow(function () view.getFloat64(7, false), RangeError);

   643     view = new DataView(buffer9_r_pad10, 3, 15);

   644     checkThrow(function () view.getFloat64(10, false), RangeError);

   646     // testFloatGet expected=NaN

   647     //   Little endian

   648     view = new DataView(buffer10, 3, 5);

   649     checkThrow(function () view.getFloat64(0, true), RangeError);

   650     view = new DataView(buffer10_pad3, 3, 8);

   651     checkThrow(function () view.getFloat64(3, true), RangeError);

   652     view = new DataView(buffer10_pad7, 3, 12);

   653     checkThrow(function () view.getFloat64(7, true), RangeError);

   654     view = new DataView(buffer10_pad10, 3, 15);

   655     checkThrow(function () view.getFloat64(10, true), RangeError);

   656     //   Big endian.

   657     view = new DataView(buffer10_r, 3, 5);

   658     checkThrow(function () view.getFloat64(0, false), RangeError);

   659     view = new DataView(buffer10_r_pad3, 3, 8);

   660     checkThrow(function () view.getFloat64(3, false), RangeError);

   661     view = new DataView(buffer10_r_pad7, 3, 12);

   662     checkThrow(function () view.getFloat64(7, false), RangeError);

   663     view = new DataView(buffer10_r_pad10, 3, 15);

   664     checkThrow(function () view.getFloat64(10, false), RangeError);

   666     // testFloatGet expected=NaN

   667     //   Little endian

   668     view = new DataView(buffer11, 3, 5);

   669     checkThrow(function () view.getFloat64(0, true), RangeError);

   670     view = new DataView(buffer11_pad3, 3, 8);

   671     checkThrow(function () view.getFloat64(3, true), RangeError);

   672     view = new DataView(buffer11_pad7, 3, 12);

   673     checkThrow(function () view.getFloat64(7, true), RangeError);

   674     view = new DataView(buffer11_pad10, 3, 15);

   675     checkThrow(function () view.getFloat64(10, true), RangeError);

   676     //   Big endian.

   677     view = new DataView(buffer11_r, 3, 5);

   678     checkThrow(function () view.getFloat64(0, false), RangeError);

   679     view = new DataView(buffer11_r_pad3, 3, 8);

   680     checkThrow(function () view.getFloat64(3, false), RangeError);

   681     view = new DataView(buffer11_r_pad7, 3, 12);

   682     checkThrow(function () view.getFloat64(7, false), RangeError);

   683     view = new DataView(buffer11_r_pad10, 3, 15);

   684     checkThrow(function () view.getFloat64(10, false), RangeError);

   686     // testGetNegativeIndexes

   687     view = new DataView(buffer1, 0, 16);

   688     checkThrow(function () view.getInt8(-1), RangeError);

   689     checkThrow(function () view.getInt8(-2), RangeError);

   690     checkThrow(function () view.getUint8(-1), RangeError);

   691     checkThrow(function () view.getUint8(-2), RangeError);

   692     checkThrow(function () view.getInt16(-1), RangeError);

   693     checkThrow(function () view.getInt16(-2), RangeError);

   694     checkThrow(function () view.getInt16(-3), RangeError);

   695     checkThrow(function () view.getUint16(-1), RangeError);

   696     checkThrow(function () view.getUint16(-2), RangeError);

   697     checkThrow(function () view.getUint16(-3), RangeError);

   698     checkThrow(function () view.getInt32(-1), RangeError);

   699     checkThrow(function () view.getInt32(-3), RangeError);

   700     checkThrow(function () view.getInt32(-5), RangeError);

   701     checkThrow(function () view.getUint32(-1), RangeError);

   702     checkThrow(function () view.getUint32(-3), RangeError);

   703     checkThrow(function () view.getUint32(-5), RangeError);

   704     view = new DataView(buffer7, 0, 8);

   705     checkThrow(function () view.getFloat32(-1), RangeError);

   706     checkThrow(function () view.getFloat32(-3), RangeError);

   707     checkThrow(function () view.getFloat32(-5), RangeError);

   708     checkThrow(function () view.getFloat64(-1), RangeError);

   709     checkThrow(function () view.getFloat64(-5), RangeError);

   710     checkThrow(function () view.getFloat64(-9), RangeError);

   712     // Too large for signed 32 bit integer index

   713     checkThrow(function () view.getInt8(2147483648), RangeError);

   714     checkThrow(function () view.getInt8(2147483649), RangeError);

   715     checkThrow(function () view.getUint8(2147483648), RangeError);

   716     checkThrow(function () view.getUint8(2147483649), RangeError);

   717     checkThrow(function () view.getInt16(2147483648), RangeError);

   718     checkThrow(function () view.getInt16(2147483649), RangeError);

   719     checkThrow(function () view.getUint16(2147483648), RangeError);

   720     checkThrow(function () view.getUint16(2147483649), RangeError);

   721     checkThrow(function () view.getInt32(2147483648), RangeError);

   722     checkThrow(function () view.getInt32(2147483649), RangeError);

   723     checkThrow(function () view.getUint32(2147483648), RangeError);

   724     checkThrow(function () view.getUint32(2147483649), RangeError);

   725     checkThrow(function () view.getFloat32(2147483648), RangeError);

   726     checkThrow(function () view.getFloat32(2147483649), RangeError);

   727     checkThrow(function () view.getFloat64(2147483648), RangeError);

   728     checkThrow(function () view.getFloat64(2147483649), RangeError);

   730     // Test for wrong arguments passed to get methods

   731     //

   732     // See http://www.w3.org/TR/WebIDL/#es-operations and the step saying "If entry is null, throw a TypeError."

   733     checkThrow(function () view.getInt8(), TypeError);

   734     checkThrow(function () view.getUint8(), TypeError);

   735     checkThrow(function () view.getInt16(), TypeError);

   736     checkThrow(function () view.getUint16(), TypeError);

   737     checkThrow(function () view.getInt32(), TypeError);

   738     checkThrow(function () view.getUint32(), TypeError);

   739     checkThrow(function () view.getFloat32(), TypeError);

   740     checkThrow(function () view.getFloat64(), TypeError);

   742     // Test for wrong type of |this|

   743     checkThrow(function () view.getInt8.apply("dead", [0]), TypeError);

   744     checkThrow(function () view.getUint8.apply("puppies", [0]), TypeError);

   745     checkThrow(function () view.getInt16.apply("aren", [0]), TypeError);

   746     checkThrow(function () view.getUint16.apply("t", [0]), TypeError);

   747     checkThrow(function () view.getInt32.apply("much", [0]), TypeError);

   748     checkThrow(function () view.getUint32.apply("fun", [0]), TypeError);

   749     checkThrow(function () view.getFloat32.apply("(in", [0]), TypeError);

   750     checkThrow(function () view.getFloat64.apply("bed)", [0]), TypeError);

   751     checkThrow(function () view.setInt8.apply("dead", [0, 0]), TypeError);

   752     checkThrow(function () view.setUint8.apply("puppies", [0, 0]), TypeError);

   753     checkThrow(function () view.setInt16.apply("aren", [0, 0]), TypeError);

   754     checkThrow(function () view.setUint16.apply("t", [0, 0]), TypeError);

   755     checkThrow(function () view.setInt32.apply("much", [0, 0]), TypeError);

   756     checkThrow(function () view.setUint32.apply("fun", [0, 0]), TypeError);

   757     checkThrow(function () view.setFloat32.apply("(in", [0, 0]), TypeError);

   758     checkThrow(function () view.setFloat64.apply("bed)", [0, 0]), TypeError);

   760     // testSetMethods

   762     //   Test for set methods that work

   764     // testIntegerSets(start=0, length=16)

   765     var data13 = [204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204];

   766     var data13_r = data13.slice().reverse();

   767     var buffer13 = new Uint8Array(data13).buffer;

   768     view = new DataView(buffer13, 0, 16);

   769     view.setInt8(0, 0);

   770     assertEq(view.getInt8(0), 0);

   771     view.setInt8(8, -128);

   772     assertEq(view.getInt8(8), -128);

   773     view.setInt8(15, -1);

   774     assertEq(view.getInt8(15), -1);

   775     view.setUint8(0, 0);

   776     assertEq(view.getUint8(0), 0);

   777     view.setUint8(8, 128);

   778     assertEq(view.getUint8(8), 128);

   779     view.setUint8(15, 255);

   780     assertEq(view.getUint8(15), 255);

   781     view.setInt16(0, 256, true);

   782     assertEq(view.getInt16(0, true), 256);

   783     view.setInt16(5, 26213, true);

   784     assertEq(view.getInt16(5, true), 26213);

   785     view.setInt16(9, -32127, true);

   786     assertEq(view.getInt16(9, true), -32127);

   787     view.setInt16(14, -2, true);

   788     assertEq(view.getInt16(14, true), -2);

   789     view.setInt16(0, 1);

   790     assertEq(view.getInt16(0), 1);

   791     view.setInt16(5, 25958);

   792     assertEq(view.getInt16(5), 25958);

   793     view.setInt16(9, -32382);

   794     assertEq(view.getInt16(9), -32382);

   795     view.setInt16(14, -257);

   796     assertEq(view.getInt16(14), -257);

   797     view.setUint16(0, 256, true);

   798     assertEq(view.getUint16(0, true), 256);

   799     view.setUint16(5, 26213, true);

   800     assertEq(view.getUint16(5, true), 26213);

   801     view.setUint16(9, 33409, true);

   802     assertEq(view.getUint16(9, true), 33409);

   803     view.setUint16(14, 65534, true);

   804     assertEq(view.getUint16(14, true), 65534);

   805     view.setUint16(0, 1);

   806     assertEq(view.getUint16(0), 1);

   807     view.setUint16(5, 25958);

   808     assertEq(view.getUint16(5), 25958);

   809     view.setUint16(9, 33154);

   810     assertEq(view.getUint16(9), 33154);

   811     view.setUint16(14, 65279);

   812     assertEq(view.getUint16(14), 65279);

   813     view.setInt32(0, 50462976, true);

   814     assertEq(view.getInt32(0, true), 50462976);

   815     view.setInt32(3, 1717920771, true);

   816     assertEq(view.getInt32(3, true), 1717920771);

   817     view.setInt32(6, -2122291354, true);

   818     assertEq(view.getInt32(6, true), -2122291354);

   819     view.setInt32(9, -58490239, true);

   820     assertEq(view.getInt32(9, true), -58490239);

   821     view.setInt32(12, -66052, true);

   822     assertEq(view.getInt32(12, true), -66052);

   823     view.setInt32(0, 66051);

   824     assertEq(view.getInt32(0), 66051);

   825     view.setInt32(3, 56911206);

   826     assertEq(view.getInt32(3), 56911206);

   827     view.setInt32(6, 1718059137);

   828     assertEq(view.getInt32(6), 1718059137);

   829     view.setInt32(9, -2122152964);

   830     assertEq(view.getInt32(9), -2122152964);

   831     view.setInt32(12, -50462977);

   832     assertEq(view.getInt32(12), -50462977);

   833     view.setUint32(0, 50462976, true);

   834     assertEq(view.getUint32(0, true), 50462976);

   835     view.setUint32(3, 1717920771, true);

   836     assertEq(view.getUint32(3, true), 1717920771);

   837     view.setUint32(6, 2172675942, true);

   838     assertEq(view.getUint32(6, true), 2172675942);

   839     view.setUint32(9, 4236477057, true);

   840     assertEq(view.getUint32(9, true), 4236477057);

   841     view.setUint32(12, 4294901244, true);

   842     assertEq(view.getUint32(12, true), 4294901244);

   843     view.setUint32(0, 66051);

   844     assertEq(view.getUint32(0), 66051);

   845     view.setUint32(3, 56911206);

   846     assertEq(view.getUint32(3), 56911206);

   847     view.setUint32(6, 1718059137);

   848     assertEq(view.getUint32(6), 1718059137);

   849     view.setUint32(9, 2172814332);

   850     assertEq(view.getUint32(9), 2172814332);

   851     view.setUint32(12, 4244504319);

   852     assertEq(view.getUint32(12), 4244504319);

   854     // testFloatSets(start=undefined)

   856     // testFloatSet expected=10

   857     //   Little endian

   858     view = new DataView(buffer13, 0, 16);

   859     view.setFloat32(0, 10, true);

   860     assertEq(view.getFloat32(0, true), 10);

   861     var buffer13_pad3 = new Uint8Array(Array(3).concat(data13)).buffer;

   862     view = new DataView(buffer13_pad3, 0, 19);

   863     view.setFloat32(3, 10, true);

   864     assertEq(view.getFloat32(3, true), 10);

   865     var buffer13_pad7 = new Uint8Array(Array(7).concat(data13)).buffer;

   866     view = new DataView(buffer13_pad7, 0, 23);

   867     view.setFloat32(7, 10, true);

   868     assertEq(view.getFloat32(7, true), 10);

   869     var buffer13_pad10 = new Uint8Array(Array(10).concat(data13)).buffer;

   870     view = new DataView(buffer13_pad10, 0, 26);

   871     view.setFloat32(10, 10, true);

   872     assertEq(view.getFloat32(10, true), 10);

   873     //   Big endian.

   874     var buffer13_r = new Uint8Array(data13_r).buffer;

   875     view = new DataView(buffer13_r, 0, 16);

   876     view.setFloat32(0, 10, false);

   877     assertEq(view.getFloat32(0, false), 10);

   878     var buffer13_r_pad3 = new Uint8Array(Array(3).concat(data13_r)).buffer;

   879     view = new DataView(buffer13_r_pad3, 0, 19);

   880     view.setFloat32(3, 10, false);

   881     assertEq(view.getFloat32(3, false), 10);

   882     var buffer13_r_pad7 = new Uint8Array(Array(7).concat(data13_r)).buffer;

   883     view = new DataView(buffer13_r_pad7, 0, 23);

   884     view.setFloat32(7, 10, false);

   885     assertEq(view.getFloat32(7, false), 10);

   886     var buffer13_r_pad10 = new Uint8Array(Array(10).concat(data13_r)).buffer;

   887     view = new DataView(buffer13_r_pad10, 0, 26);

   888     view.setFloat32(10, 10, false);

   889     assertEq(view.getFloat32(10, false), 10);

   891     // testFloatSet expected=1.2300000190734863

   892     //   Little endian

   893     view = new DataView(buffer13, 0, 16);

   894     view.setFloat32(0, 1.2300000190734863, true);

   895     assertEq(view.getFloat32(0, true), 1.2300000190734863);

   896     view = new DataView(buffer13_pad3, 0, 19);

   897     view.setFloat32(3, 1.2300000190734863, true);

   898     assertEq(view.getFloat32(3, true), 1.2300000190734863);

   899     view = new DataView(buffer13_pad7, 0, 23);

   900     view.setFloat32(7, 1.2300000190734863, true);

   901     assertEq(view.getFloat32(7, true), 1.2300000190734863);

   902     view = new DataView(buffer13_pad10, 0, 26);

   903     view.setFloat32(10, 1.2300000190734863, true);

   904     assertEq(view.getFloat32(10, true), 1.2300000190734863);

   905     //   Big endian.

   906     view = new DataView(buffer13_r, 0, 16);

   907     view.setFloat32(0, 1.2300000190734863, false);

   908     assertEq(view.getFloat32(0, false), 1.2300000190734863);

   909     view = new DataView(buffer13_r_pad3, 0, 19);

   910     view.setFloat32(3, 1.2300000190734863, false);

   911     assertEq(view.getFloat32(3, false), 1.2300000190734863);

   912     view = new DataView(buffer13_r_pad7, 0, 23);

   913     view.setFloat32(7, 1.2300000190734863, false);

   914     assertEq(view.getFloat32(7, false), 1.2300000190734863);

   915     view = new DataView(buffer13_r_pad10, 0, 26);

   916     view.setFloat32(10, 1.2300000190734863, false);

   917     assertEq(view.getFloat32(10, false), 1.2300000190734863);

   919     // testFloatSet expected=-45621.37109375

   920     //   Little endian

   921     view = new DataView(buffer13, 0, 16);

   922     view.setFloat32(0, -45621.37109375, true);

   923     assertEq(view.getFloat32(0, true), -45621.37109375);

   924     view = new DataView(buffer13_pad3, 0, 19);

   925     view.setFloat32(3, -45621.37109375, true);

   926     assertEq(view.getFloat32(3, true), -45621.37109375);

   927     view = new DataView(buffer13_pad7, 0, 23);

   928     view.setFloat32(7, -45621.37109375, true);

   929     assertEq(view.getFloat32(7, true), -45621.37109375);

   930     view = new DataView(buffer13_pad10, 0, 26);

   931     view.setFloat32(10, -45621.37109375, true);

   932     assertEq(view.getFloat32(10, true), -45621.37109375);

   933     //   Big endian.

   934     view = new DataView(buffer13_r, 0, 16);

   935     view.setFloat32(0, -45621.37109375, false);

   936     assertEq(view.getFloat32(0, false), -45621.37109375);

   937     view = new DataView(buffer13_r_pad3, 0, 19);

   938     view.setFloat32(3, -45621.37109375, false);

   939     assertEq(view.getFloat32(3, false), -45621.37109375);

   940     view = new DataView(buffer13_r_pad7, 0, 23);

   941     view.setFloat32(7, -45621.37109375, false);

   942     assertEq(view.getFloat32(7, false), -45621.37109375);

   943     view = new DataView(buffer13_r_pad10, 0, 26);

   944     view.setFloat32(10, -45621.37109375, false);

   945     assertEq(view.getFloat32(10, false), -45621.37109375);

   947     // testFloatSet expected=NaN

   948     //   Little endian

   949     view = new DataView(buffer13, 0, 16);

   950     view.setFloat32(0, NaN, true);

   951     assertEq(view.getFloat32(0, true), NaN);

   952     view = new DataView(buffer13_pad3, 0, 19);

   953     view.setFloat32(3, NaN, true);

   954     assertEq(view.getFloat32(3, true), NaN);

   955     view = new DataView(buffer13_pad7, 0, 23);

   956     view.setFloat32(7, NaN, true);

   957     assertEq(view.getFloat32(7, true), NaN);

   958     view = new DataView(buffer13_pad10, 0, 26);

   959     view.setFloat32(10, NaN, true);

   960     assertEq(view.getFloat32(10, true), NaN);

   961     //   Big endian.

   962     view = new DataView(buffer13_r, 0, 16);

   963     view.setFloat32(0, NaN, false);

   964     assertEq(view.getFloat32(0, false), NaN);

   965     view = new DataView(buffer13_r_pad3, 0, 19);

   966     view.setFloat32(3, NaN, false);

   967     assertEq(view.getFloat32(3, false), NaN);

   968     view = new DataView(buffer13_r_pad7, 0, 23);

   969     view.setFloat32(7, NaN, false);

   970     assertEq(view.getFloat32(7, false), NaN);

   971     view = new DataView(buffer13_r_pad10, 0, 26);

   972     view.setFloat32(10, NaN, false);

   973     assertEq(view.getFloat32(10, false), NaN);

   975     // testFloatSet expected=-NaN

   976     //   Little endian

   977     view = new DataView(buffer13, 0, 16);

   978     view.setFloat32(0, -NaN, true);

   979     assertEq(view.getFloat32(0, true), -NaN);

   980     view = new DataView(buffer13_pad3, 0, 19);

   981     view.setFloat32(3, -NaN, true);

   982     assertEq(view.getFloat32(3, true), -NaN);

   983     view = new DataView(buffer13_pad7, 0, 23);

   984     view.setFloat32(7, -NaN, true);

   985     assertEq(view.getFloat32(7, true), -NaN);

   986     view = new DataView(buffer13_pad10, 0, 26);

   987     view.setFloat32(10, -NaN, true);

   988     assertEq(view.getFloat32(10, true), -NaN);

   989     //   Big endian.

   990     view = new DataView(buffer13_r, 0, 16);

   991     view.setFloat32(0, -NaN, false);

   992     assertEq(view.getFloat32(0, false), -NaN);

   993     view = new DataView(buffer13_r_pad3, 0, 19);

   994     view.setFloat32(3, -NaN, false);

   995     assertEq(view.getFloat32(3, false), -NaN);

   996     view = new DataView(buffer13_r_pad7, 0, 23);

   997     view.setFloat32(7, -NaN, false);

   998     assertEq(view.getFloat32(7, false), -NaN);

   999     view = new DataView(buffer13_r_pad10, 0, 26);

  1000     view.setFloat32(10, -NaN, false);

  1001     assertEq(view.getFloat32(10, false), -NaN);

  1003     // testFloatSet expected=10

  1004     //   Little endian

  1005     view = new DataView(buffer13, 0, 16);

  1006     view.setFloat64(0, 10, true);

  1007     assertEq(view.getFloat64(0, true), 10);

  1008     view = new DataView(buffer13_pad3, 0, 19);

  1009     view.setFloat64(3, 10, true);

  1010     assertEq(view.getFloat64(3, true), 10);

  1011     view = new DataView(buffer13_pad7, 0, 23);

  1012     view.setFloat64(7, 10, true);

  1013     assertEq(view.getFloat64(7, true), 10);

  1014     view = new DataView(buffer13_pad10, 0, 26);

  1015     view.setFloat64(10, 10, true);

  1016     assertEq(view.getFloat64(10, true), 10);

  1017     //   Big endian.

  1018     view = new DataView(buffer13_r, 0, 16);

  1019     view.setFloat64(0, 10, false);

  1020     assertEq(view.getFloat64(0, false), 10);

  1021     view = new DataView(buffer13_r_pad3, 0, 19);

  1022     view.setFloat64(3, 10, false);

  1023     assertEq(view.getFloat64(3, false), 10);

  1024     view = new DataView(buffer13_r_pad7, 0, 23);

  1025     view.setFloat64(7, 10, false);

  1026     assertEq(view.getFloat64(7, false), 10);

  1027     view = new DataView(buffer13_r_pad10, 0, 26);

  1028     view.setFloat64(10, 10, false);

  1029     assertEq(view.getFloat64(10, false), 10);

  1031     // testFloatSet expected=1.23

  1032     //   Little endian

  1033     view = new DataView(buffer13, 0, 16);

  1034     view.setFloat64(0, 1.23, true);

  1035     assertEq(view.getFloat64(0, true), 1.23);

  1036     view = new DataView(buffer13_pad3, 0, 19);

  1037     view.setFloat64(3, 1.23, true);

  1038     assertEq(view.getFloat64(3, true), 1.23);

  1039     view = new DataView(buffer13_pad7, 0, 23);

  1040     view.setFloat64(7, 1.23, true);

  1041     assertEq(view.getFloat64(7, true), 1.23);

  1042     view = new DataView(buffer13_pad10, 0, 26);

  1043     view.setFloat64(10, 1.23, true);

  1044     assertEq(view.getFloat64(10, true), 1.23);

  1045     //   Big endian.

  1046     view = new DataView(buffer13_r, 0, 16);

  1047     view.setFloat64(0, 1.23, false);

  1048     assertEq(view.getFloat64(0, false), 1.23);

  1049     view = new DataView(buffer13_r_pad3, 0, 19);

  1050     view.setFloat64(3, 1.23, false);

  1051     assertEq(view.getFloat64(3, false), 1.23);

  1052     view = new DataView(buffer13_r_pad7, 0, 23);

  1053     view.setFloat64(7, 1.23, false);

  1054     assertEq(view.getFloat64(7, false), 1.23);

  1055     view = new DataView(buffer13_r_pad10, 0, 26);

  1056     view.setFloat64(10, 1.23, false);

  1057     assertEq(view.getFloat64(10, false), 1.23);

  1059     // testFloatSet expected=-6213576.4839

  1060     //   Little endian

  1061     view = new DataView(buffer13, 0, 16);

  1062     view.setFloat64(0, -6213576.4839, true);

  1063     assertEq(view.getFloat64(0, true), -6213576.4839);

  1064     view = new DataView(buffer13_pad3, 0, 19);

  1065     view.setFloat64(3, -6213576.4839, true);

  1066     assertEq(view.getFloat64(3, true), -6213576.4839);

  1067     view = new DataView(buffer13_pad7, 0, 23);

  1068     view.setFloat64(7, -6213576.4839, true);

  1069     assertEq(view.getFloat64(7, true), -6213576.4839);

  1070     view = new DataView(buffer13_pad10, 0, 26);

  1071     view.setFloat64(10, -6213576.4839, true);

  1072     assertEq(view.getFloat64(10, true), -6213576.4839);

  1073     //   Big endian.

  1074     view = new DataView(buffer13_r, 0, 16);

  1075     view.setFloat64(0, -6213576.4839, false);

  1076     assertEq(view.getFloat64(0, false), -6213576.4839);

  1077     view = new DataView(buffer13_r_pad3, 0, 19);

  1078     view.setFloat64(3, -6213576.4839, false);

  1079     assertEq(view.getFloat64(3, false), -6213576.4839);

  1080     view = new DataView(buffer13_r_pad7, 0, 23);

  1081     view.setFloat64(7, -6213576.4839, false);

  1082     assertEq(view.getFloat64(7, false), -6213576.4839);

  1083     view = new DataView(buffer13_r_pad10, 0, 26);

  1084     view.setFloat64(10, -6213576.4839, false);

  1085     assertEq(view.getFloat64(10, false), -6213576.4839);

  1087     // testFloatSet expected=NaN

  1088     //   Little endian

  1089     view = new DataView(buffer13, 0, 16);

  1090     view.setFloat64(0, NaN, true);

  1091     assertEq(view.getFloat64(0, true), NaN);

  1092     view = new DataView(buffer13_pad3, 0, 19);

  1093     view.setFloat64(3, NaN, true);

  1094     assertEq(view.getFloat64(3, true), NaN);

  1095     view = new DataView(buffer13_pad7, 0, 23);

  1096     view.setFloat64(7, NaN, true);

  1097     assertEq(view.getFloat64(7, true), NaN);

  1098     view = new DataView(buffer13_pad10, 0, 26);

  1099     view.setFloat64(10, NaN, true);

  1100     assertEq(view.getFloat64(10, true), NaN);

  1101     //   Big endian.

  1102     view = new DataView(buffer13_r, 0, 16);

  1103     view.setFloat64(0, NaN, false);

  1104     assertEq(view.getFloat64(0, false), NaN);

  1105     view = new DataView(buffer13_r_pad3, 0, 19);

  1106     view.setFloat64(3, NaN, false);

  1107     assertEq(view.getFloat64(3, false), NaN);

  1108     view = new DataView(buffer13_r_pad7, 0, 23);

  1109     view.setFloat64(7, NaN, false);

  1110     assertEq(view.getFloat64(7, false), NaN);

  1111     view = new DataView(buffer13_r_pad10, 0, 26);

  1112     view.setFloat64(10, NaN, false);

  1113     assertEq(view.getFloat64(10, false), NaN);

  1115     // testFloatSet expected=-NaN

  1116     //   Little endian

  1117     view = new DataView(buffer13, 0, 16);

  1118     view.setFloat64(0, -NaN, true);

  1119     assertEq(view.getFloat64(0, true), -NaN);

  1120     view = new DataView(buffer13_pad3, 0, 19);

  1121     view.setFloat64(3, -NaN, true);

  1122     assertEq(view.getFloat64(3, true), -NaN);

  1123     view = new DataView(buffer13_pad7, 0, 23);

  1124     view.setFloat64(7, -NaN, true);

  1125     assertEq(view.getFloat64(7, true), -NaN);

  1126     view = new DataView(buffer13_pad10, 0, 26);

  1127     view.setFloat64(10, -NaN, true);

  1128     assertEq(view.getFloat64(10, true), -NaN);

  1129     //   Big endian.

  1130     view = new DataView(buffer13_r, 0, 16);

  1131     view.setFloat64(0, -NaN, false);

  1132     assertEq(view.getFloat64(0, false), -NaN);

  1133     view = new DataView(buffer13_r_pad3, 0, 19);

  1134     view.setFloat64(3, -NaN, false);

  1135     assertEq(view.getFloat64(3, false), -NaN);

  1136     view = new DataView(buffer13_r_pad7, 0, 23);

  1137     view.setFloat64(7, -NaN, false);

  1138     assertEq(view.getFloat64(7, false), -NaN);

  1139     view = new DataView(buffer13_r_pad10, 0, 26);

  1140     view.setFloat64(10, -NaN, false);

  1141     assertEq(view.getFloat64(10, false), -NaN);

  1143     // Test for set methods that might write beyond the range

  1145     // testIntegerSets(start=3, length=2)

  1146     view = new DataView(buffer13, 3, 2);

  1147     view.setInt8(0, 0);

  1148     assertEq(view.getInt8(0), 0);

  1149     checkThrow(function () view.setInt8(8, -128), RangeError);

  1150     checkThrow(function () view.setInt8(15, -1), RangeError);

  1151     view.setUint8(0, 0);

  1152     assertEq(view.getUint8(0), 0);

  1153     checkThrow(function () view.setUint8(8, 128), RangeError);

  1154     checkThrow(function () view.setUint8(15, 255), RangeError);

  1155     view.setInt16(0, 256, true);

  1156     assertEq(view.getInt16(0, true), 256);

  1157     checkThrow(function () view.setInt16(5, 26213, true), RangeError);

  1158     checkThrow(function () view.setInt16(9, -32127, true), RangeError);

  1159     checkThrow(function () view.setInt16(14, -2, true), RangeError);

  1160     view.setInt16(0, 1);

  1161     assertEq(view.getInt16(0), 1);

  1162     checkThrow(function () view.setInt16(5, 25958), RangeError);

  1163     checkThrow(function () view.setInt16(9, -32382), RangeError);

  1164     checkThrow(function () view.setInt16(14, -257), RangeError);

  1165     view.setUint16(0, 256, true);

  1166     assertEq(view.getUint16(0, true), 256);

  1167     checkThrow(function () view.setUint16(5, 26213, true), RangeError);

  1168     checkThrow(function () view.setUint16(9, 33409, true), RangeError);

  1169     checkThrow(function () view.setUint16(14, 65534, true), RangeError);

  1170     view.setUint16(0, 1);

  1171     assertEq(view.getUint16(0), 1);

  1172     checkThrow(function () view.setUint16(5, 25958), RangeError);

  1173     checkThrow(function () view.setUint16(9, 33154), RangeError);

  1174     checkThrow(function () view.setUint16(14, 65279), RangeError);

  1175     checkThrow(function () view.setInt32(0, 50462976, true), RangeError);

  1176     checkThrow(function () view.setInt32(3, 1717920771, true), RangeError);

  1177     checkThrow(function () view.setInt32(6, -2122291354, true), RangeError);

  1178     checkThrow(function () view.setInt32(9, -58490239, true), RangeError);

  1179     checkThrow(function () view.setInt32(12, -66052, true), RangeError);

  1180     checkThrow(function () view.setInt32(0, 66051), RangeError);

  1181     checkThrow(function () view.setInt32(3, 56911206), RangeError);

  1182     checkThrow(function () view.setInt32(6, 1718059137), RangeError);

  1183     checkThrow(function () view.setInt32(9, -2122152964), RangeError);

  1184     checkThrow(function () view.setInt32(12, -50462977), RangeError);

  1185     checkThrow(function () view.setUint32(0, 50462976, true), RangeError);

  1186     checkThrow(function () view.setUint32(3, 1717920771, true), RangeError);

  1187     checkThrow(function () view.setUint32(6, 2172675942, true), RangeError);

  1188     checkThrow(function () view.setUint32(9, 4236477057, true), RangeError);

  1189     checkThrow(function () view.setUint32(12, 4294901244, true), RangeError);

  1190     checkThrow(function () view.setUint32(0, 66051), RangeError);

  1191     checkThrow(function () view.setUint32(3, 56911206), RangeError);

  1192     checkThrow(function () view.setUint32(6, 1718059137), RangeError);

  1193     checkThrow(function () view.setUint32(9, 2172814332), RangeError);

  1194     checkThrow(function () view.setUint32(12, 4244504319), RangeError);

  1196     // testFloatSets(start=7)

  1198     // testFloatSet expected=10

  1199     //   Little endian

  1200     view = new DataView(buffer13, 7, 9);

  1201     view.setFloat32(0, 10, true);

  1202     assertEq(view.getFloat32(0, true), 10);

  1203     view = new DataView(buffer13_pad3, 7, 12);

  1204     view.setFloat32(3, 10, true);

  1205     assertEq(view.getFloat32(3, true), 10);

  1206     view = new DataView(buffer13_pad7, 7, 16);

  1207     view.setFloat32(7, 10, true);

  1208     assertEq(view.getFloat32(7, true), 10);

  1209     view = new DataView(buffer13_pad10, 7, 19);

  1210     view.setFloat32(10, 10, true);

  1211     assertEq(view.getFloat32(10, true), 10);

  1212     //   Big endian.

  1213     view = new DataView(buffer13_r, 7, 9);

  1214     view.setFloat32(0, 10, false);

  1215     assertEq(view.getFloat32(0, false), 10);

  1216     view = new DataView(buffer13_r_pad3, 7, 12);

  1217     view.setFloat32(3, 10, false);

  1218     assertEq(view.getFloat32(3, false), 10);

  1219     view = new DataView(buffer13_r_pad7, 7, 16);

  1220     view.setFloat32(7, 10, false);

  1221     assertEq(view.getFloat32(7, false), 10);

  1222     view = new DataView(buffer13_r_pad10, 7, 19);

  1223     view.setFloat32(10, 10, false);

  1224     assertEq(view.getFloat32(10, false), 10);

  1226     // testFloatSet expected=1.2300000190734863

  1227     //   Little endian

  1228     view = new DataView(buffer13, 7, 9);

  1229     view.setFloat32(0, 1.2300000190734863, true);

  1230     assertEq(view.getFloat32(0, true), 1.2300000190734863);

  1231     view = new DataView(buffer13_pad3, 7, 12);

  1232     view.setFloat32(3, 1.2300000190734863, true);

  1233     assertEq(view.getFloat32(3, true), 1.2300000190734863);

  1234     view = new DataView(buffer13_pad7, 7, 16);

  1235     view.setFloat32(7, 1.2300000190734863, true);

  1236     assertEq(view.getFloat32(7, true), 1.2300000190734863);

  1237     view = new DataView(buffer13_pad10, 7, 19);

  1238     view.setFloat32(10, 1.2300000190734863, true);

  1239     assertEq(view.getFloat32(10, true), 1.2300000190734863);

  1240     //   Big endian.

  1241     view = new DataView(buffer13_r, 7, 9);

  1242     view.setFloat32(0, 1.2300000190734863, false);

  1243     assertEq(view.getFloat32(0, false), 1.2300000190734863);

  1244     view = new DataView(buffer13_r_pad3, 7, 12);

  1245     view.setFloat32(3, 1.2300000190734863, false);

  1246     assertEq(view.getFloat32(3, false), 1.2300000190734863);

  1247     view = new DataView(buffer13_r_pad7, 7, 16);

  1248     view.setFloat32(7, 1.2300000190734863, false);

  1249     assertEq(view.getFloat32(7, false), 1.2300000190734863);

  1250     view = new DataView(buffer13_r_pad10, 7, 19);

  1251     view.setFloat32(10, 1.2300000190734863, false);

  1252     assertEq(view.getFloat32(10, false), 1.2300000190734863);

  1254     // testFloatSet expected=-45621.37109375

  1255     //   Little endian

  1256     view = new DataView(buffer13, 7, 9);

  1257     view.setFloat32(0, -45621.37109375, true);

  1258     assertEq(view.getFloat32(0, true), -45621.37109375);

  1259     view = new DataView(buffer13_pad3, 7, 12);

  1260     view.setFloat32(3, -45621.37109375, true);

  1261     assertEq(view.getFloat32(3, true), -45621.37109375);

  1262     view = new DataView(buffer13_pad7, 7, 16);

  1263     view.setFloat32(7, -45621.37109375, true);

  1264     assertEq(view.getFloat32(7, true), -45621.37109375);

  1265     view = new DataView(buffer13_pad10, 7, 19);

  1266     view.setFloat32(10, -45621.37109375, true);

  1267     assertEq(view.getFloat32(10, true), -45621.37109375);

  1268     //   Big endian.

  1269     view = new DataView(buffer13_r, 7, 9);

  1270     view.setFloat32(0, -45621.37109375, false);

  1271     assertEq(view.getFloat32(0, false), -45621.37109375);

  1272     view = new DataView(buffer13_r_pad3, 7, 12);

  1273     view.setFloat32(3, -45621.37109375, false);

  1274     assertEq(view.getFloat32(3, false), -45621.37109375);

  1275     view = new DataView(buffer13_r_pad7, 7, 16);

  1276     view.setFloat32(7, -45621.37109375, false);

  1277     assertEq(view.getFloat32(7, false), -45621.37109375);

  1278     view = new DataView(buffer13_r_pad10, 7, 19);

  1279     view.setFloat32(10, -45621.37109375, false);

  1280     assertEq(view.getFloat32(10, false), -45621.37109375);

  1282     // testFloatSet expected=NaN

  1283     //   Little endian

  1284     view = new DataView(buffer13, 7, 9);

  1285     view.setFloat32(0, NaN, true);

  1286     assertEq(view.getFloat32(0, true), NaN);

  1287     view = new DataView(buffer13_pad3, 7, 12);

  1288     view.setFloat32(3, NaN, true);

  1289     assertEq(view.getFloat32(3, true), NaN);

  1290     view = new DataView(buffer13_pad7, 7, 16);

  1291     view.setFloat32(7, NaN, true);

  1292     assertEq(view.getFloat32(7, true), NaN);

  1293     view = new DataView(buffer13_pad10, 7, 19);

  1294     view.setFloat32(10, NaN, true);

  1295     assertEq(view.getFloat32(10, true), NaN);

  1296     //   Big endian.

  1297     view = new DataView(buffer13_r, 7, 9);

  1298     view.setFloat32(0, NaN, false);

  1299     assertEq(view.getFloat32(0, false), NaN);

  1300     view = new DataView(buffer13_r_pad3, 7, 12);

  1301     view.setFloat32(3, NaN, false);

  1302     assertEq(view.getFloat32(3, false), NaN);

  1303     view = new DataView(buffer13_r_pad7, 7, 16);

  1304     view.setFloat32(7, NaN, false);

  1305     assertEq(view.getFloat32(7, false), NaN);

  1306     view = new DataView(buffer13_r_pad10, 7, 19);

  1307     view.setFloat32(10, NaN, false);

  1308     assertEq(view.getFloat32(10, false), NaN);

  1310     // testFloatSet expected=-NaN

  1311     //   Little endian

  1312     view = new DataView(buffer13, 7, 9);

  1313     view.setFloat32(0, -NaN, true);

  1314     assertEq(view.getFloat32(0, true), -NaN);

  1315     view = new DataView(buffer13_pad3, 7, 12);

  1316     view.setFloat32(3, -NaN, true);

  1317     assertEq(view.getFloat32(3, true), -NaN);

  1318     view = new DataView(buffer13_pad7, 7, 16);

  1319     view.setFloat32(7, -NaN, true);

  1320     assertEq(view.getFloat32(7, true), -NaN);

  1321     view = new DataView(buffer13_pad10, 7, 19);

  1322     view.setFloat32(10, -NaN, true);

  1323     assertEq(view.getFloat32(10, true), -NaN);

  1324     //   Big endian.

  1325     view = new DataView(buffer13_r, 7, 9);

  1326     view.setFloat32(0, -NaN, false);

  1327     assertEq(view.getFloat32(0, false), -NaN);

  1328     view = new DataView(buffer13_r_pad3, 7, 12);

  1329     view.setFloat32(3, -NaN, false);

  1330     assertEq(view.getFloat32(3, false), -NaN);

  1331     view = new DataView(buffer13_r_pad7, 7, 16);

  1332     view.setFloat32(7, -NaN, false);

  1333     assertEq(view.getFloat32(7, false), -NaN);

  1334     view = new DataView(buffer13_r_pad10, 7, 19);

  1335     view.setFloat32(10, -NaN, false);

  1336     assertEq(view.getFloat32(10, false), -NaN);

  1338     // testFloatSet expected=10

  1339     //   Little endian

  1340     view = new DataView(buffer13, 7, 9);

  1341     view.setFloat64(0, 10, true);

  1342     assertEq(view.getFloat64(0, true), 10);

  1343     view = new DataView(buffer13_pad3, 7, 12);

  1344     view.setFloat64(3, 10, true);

  1345     assertEq(view.getFloat64(3, true), 10);

  1346     view = new DataView(buffer13_pad7, 7, 16);

  1347     view.setFloat64(7, 10, true);

  1348     assertEq(view.getFloat64(7, true), 10);

  1349     view = new DataView(buffer13_pad10, 7, 19);

  1350     view.setFloat64(10, 10, true);

  1351     assertEq(view.getFloat64(10, true), 10);

  1352     //   Big endian.

  1353     view = new DataView(buffer13_r, 7, 9);

  1354     view.setFloat64(0, 10, false);

  1355     assertEq(view.getFloat64(0, false), 10);

  1356     view = new DataView(buffer13_r_pad3, 7, 12);

  1357     view.setFloat64(3, 10, false);

  1358     assertEq(view.getFloat64(3, false), 10);

  1359     view = new DataView(buffer13_r_pad7, 7, 16);

  1360     view.setFloat64(7, 10, false);

  1361     assertEq(view.getFloat64(7, false), 10);

  1362     view = new DataView(buffer13_r_pad10, 7, 19);

  1363     view.setFloat64(10, 10, false);

  1364     assertEq(view.getFloat64(10, false), 10);

  1366     // testFloatSet expected=1.23

  1367     //   Little endian

  1368     view = new DataView(buffer13, 7, 9);

  1369     view.setFloat64(0, 1.23, true);

  1370     assertEq(view.getFloat64(0, true), 1.23);

  1371     view = new DataView(buffer13_pad3, 7, 12);

  1372     view.setFloat64(3, 1.23, true);

  1373     assertEq(view.getFloat64(3, true), 1.23);

  1374     view = new DataView(buffer13_pad7, 7, 16);

  1375     view.setFloat64(7, 1.23, true);

  1376     assertEq(view.getFloat64(7, true), 1.23);

  1377     view = new DataView(buffer13_pad10, 7, 19);

  1378     view.setFloat64(10, 1.23, true);

  1379     assertEq(view.getFloat64(10, true), 1.23);

  1380     //   Big endian.

  1381     view = new DataView(buffer13_r, 7, 9);

  1382     view.setFloat64(0, 1.23, false);

  1383     assertEq(view.getFloat64(0, false), 1.23);

  1384     view = new DataView(buffer13_r_pad3, 7, 12);

  1385     view.setFloat64(3, 1.23, false);

  1386     assertEq(view.getFloat64(3, false), 1.23);

  1387     view = new DataView(buffer13_r_pad7, 7, 16);

  1388     view.setFloat64(7, 1.23, false);

  1389     assertEq(view.getFloat64(7, false), 1.23);

  1390     view = new DataView(buffer13_r_pad10, 7, 19);

  1391     view.setFloat64(10, 1.23, false);

  1392     assertEq(view.getFloat64(10, false), 1.23);

  1394     // testFloatSet expected=-6213576.4839

  1395     //   Little endian

  1396     view = new DataView(buffer13, 7, 9);

  1397     view.setFloat64(0, -6213576.4839, true);

  1398     assertEq(view.getFloat64(0, true), -6213576.4839);

  1399     view = new DataView(buffer13_pad3, 7, 12);

  1400     view.setFloat64(3, -6213576.4839, true);

  1401     assertEq(view.getFloat64(3, true), -6213576.4839);

  1402     view = new DataView(buffer13_pad7, 7, 16);

  1403     view.setFloat64(7, -6213576.4839, true);

  1404     assertEq(view.getFloat64(7, true), -6213576.4839);

  1405     view = new DataView(buffer13_pad10, 7, 19);

  1406     view.setFloat64(10, -6213576.4839, true);

  1407     assertEq(view.getFloat64(10, true), -6213576.4839);

  1408     //   Big endian.

  1409     view = new DataView(buffer13_r, 7, 9);

  1410     view.setFloat64(0, -6213576.4839, false);

  1411     assertEq(view.getFloat64(0, false), -6213576.4839);

  1412     view = new DataView(buffer13_r_pad3, 7, 12);

  1413     view.setFloat64(3, -6213576.4839, false);

  1414     assertEq(view.getFloat64(3, false), -6213576.4839);

  1415     view = new DataView(buffer13_r_pad7, 7, 16);

  1416     view.setFloat64(7, -6213576.4839, false);

  1417     assertEq(view.getFloat64(7, false), -6213576.4839);

  1418     view = new DataView(buffer13_r_pad10, 7, 19);

  1419     view.setFloat64(10, -6213576.4839, false);

  1420     assertEq(view.getFloat64(10, false), -6213576.4839);

  1422     // testFloatSet expected=NaN

  1423     //   Little endian

  1424     view = new DataView(buffer13, 7, 9);

  1425     view.setFloat64(0, NaN, true);

  1426     assertEq(view.getFloat64(0, true), NaN);

  1427     view = new DataView(buffer13_pad3, 7, 12);

  1428     view.setFloat64(3, NaN, true);

  1429     assertEq(view.getFloat64(3, true), NaN);

  1430     view = new DataView(buffer13_pad7, 7, 16);

  1431     view.setFloat64(7, NaN, true);

  1432     assertEq(view.getFloat64(7, true), NaN);

  1433     view = new DataView(buffer13_pad10, 7, 19);

  1434     view.setFloat64(10, NaN, true);

  1435     assertEq(view.getFloat64(10, true), NaN);

  1436     //   Big endian.

  1437     view = new DataView(buffer13_r, 7, 9);

  1438     view.setFloat64(0, NaN, false);

  1439     assertEq(view.getFloat64(0, false), NaN);

  1440     view = new DataView(buffer13_r_pad3, 7, 12);

  1441     view.setFloat64(3, NaN, false);

  1442     assertEq(view.getFloat64(3, false), NaN);

  1443     view = new DataView(buffer13_r_pad7, 7, 16);

  1444     view.setFloat64(7, NaN, false);

  1445     assertEq(view.getFloat64(7, false), NaN);

  1446     view = new DataView(buffer13_r_pad10, 7, 19);

  1447     view.setFloat64(10, NaN, false);

  1448     assertEq(view.getFloat64(10, false), NaN);

  1450     // testFloatSet expected=-NaN

  1451     //   Little endian

  1452     view = new DataView(buffer13, 7, 9);

  1453     view.setFloat64(0, -NaN, true);

  1454     assertEq(view.getFloat64(0, true), -NaN);

  1455     view = new DataView(buffer13_pad3, 7, 12);

  1456     view.setFloat64(3, -NaN, true);

  1457     assertEq(view.getFloat64(3, true), -NaN);

  1458     view = new DataView(buffer13_pad7, 7, 16);

  1459     view.setFloat64(7, -NaN, true);

  1460     assertEq(view.getFloat64(7, true), -NaN);

  1461     view = new DataView(buffer13_pad10, 7, 19);

  1462     view.setFloat64(10, -NaN, true);

  1463     assertEq(view.getFloat64(10, true), -NaN);

  1464     //   Big endian.

  1465     view = new DataView(buffer13_r, 7, 9);

  1466     view.setFloat64(0, -NaN, false);

  1467     assertEq(view.getFloat64(0, false), -NaN);

  1468     view = new DataView(buffer13_r_pad3, 7, 12);

  1469     view.setFloat64(3, -NaN, false);

  1470     assertEq(view.getFloat64(3, false), -NaN);

  1471     view = new DataView(buffer13_r_pad7, 7, 16);

  1472     view.setFloat64(7, -NaN, false);

  1473     assertEq(view.getFloat64(7, false), -NaN);

  1474     view = new DataView(buffer13_r_pad10, 7, 19);

  1475     view.setFloat64(10, -NaN, false);

  1476     assertEq(view.getFloat64(10, false), -NaN);

  1478     // Test for set methods that write to negative index

  1480     // testSetNegativeIndexes

  1481     view = new DataView(buffer1, 0, 16);

  1482     checkThrow(function () view.setInt8(-1, 0), RangeError);

  1483     checkThrow(function () view.setInt8(-2, 0), RangeError);

  1484     checkThrow(function () view.setUint8(-1, 0), RangeError);

  1485     checkThrow(function () view.setUint8(-2, 0), RangeError);

  1486     checkThrow(function () view.setInt16(-1, 0), RangeError);

  1487     checkThrow(function () view.setInt16(-2, 0), RangeError);

  1488     checkThrow(function () view.setInt16(-3, 0), RangeError);

  1489     checkThrow(function () view.setUint16(-1, 0), RangeError);

  1490     checkThrow(function () view.setUint16(-2, 0), RangeError);

  1491     checkThrow(function () view.setUint16(-3, 0), RangeError);

  1492     checkThrow(function () view.setInt32(-1, 0), RangeError);

  1493     checkThrow(function () view.setInt32(-3, 0), RangeError);

  1494     checkThrow(function () view.setInt32(-5, 0), RangeError);

  1495     checkThrow(function () view.setUint32(-1, 0), RangeError);

  1496     checkThrow(function () view.setUint32(-3, 0), RangeError);

  1497     checkThrow(function () view.setUint32(-5, 0), RangeError);

  1498     view = new DataView(buffer7, 0, 8);

  1499     checkThrow(function () view.setFloat32(-1, 0), RangeError);

  1500     checkThrow(function () view.setFloat32(-3, 0), RangeError);

  1501     checkThrow(function () view.setFloat32(-5, 0), RangeError);

  1502     checkThrow(function () view.setFloat64(-1, 0), RangeError);

  1503     checkThrow(function () view.setFloat64(-5, 0), RangeError);

  1504     checkThrow(function () view.setFloat64(-9, 0), RangeError);

  1506     // Too large for signed 32 bit integer index

  1507     checkThrow(function () view.setInt8(2147483649, 1), RangeError);

  1508     checkThrow(function () view.setUint8(2147483649, 1), RangeError);

  1509     checkThrow(function () view.setInt16(2147483649, 1), RangeError);

  1510     checkThrow(function () view.setUint16(2147483649, 1), RangeError);

  1511     checkThrow(function () view.setInt32(2147483649, 1), RangeError);

  1512     checkThrow(function () view.setUint32(2147483649, 1), RangeError);

  1513     checkThrow(function () view.setFloat32(2147483649, 1), RangeError);

  1514     checkThrow(function () view.setFloat64(2147483649, 1), RangeError);

  1516     // Test for wrong arguments passed to set methods

  1517     checkThrow(function () view.setInt8(), Error);

  1518     checkThrow(function () view.setUint8(), Error);

  1519     checkThrow(function () view.setInt16(), Error);

  1520     checkThrow(function () view.setUint16(), Error);

  1521     checkThrow(function () view.setInt32(), Error);

  1522     checkThrow(function () view.setUint32(), Error);

  1523     checkThrow(function () view.setFloat32(), Error);

  1524     checkThrow(function () view.setFloat64(), Error);

  1525     checkThrow(function () view.setInt8(1), Error);

  1526     checkThrow(function () view.setUint8(1), Error);

  1527     checkThrow(function () view.setInt16(1), Error);

  1528     checkThrow(function () view.setUint16(1), Error);

  1529     checkThrow(function () view.setInt32(1), Error);

  1530     checkThrow(function () view.setUint32(1), Error);

  1531     checkThrow(function () view.setFloat32(1), Error);

  1532     checkThrow(function () view.setFloat64(1), Error);

  1534     // testAlignment

  1535     var intArray1 = [0, 1, 2, 3, 100, 101, 102, 103, 128, 129, 130, 131, 252, 253, 254, 255];

  1536     view = new DataView((new Uint8Array(intArray1)).buffer, 0);

  1537     assertEq(view.getUint32(0, false), 0x00010203);

  1538     view = new DataView((new Uint8Array(intArray1)).buffer, 1);

  1539     assertEq(view.getUint32(0, false), 0x01020364);

  1540     view = new DataView((new Uint8Array(intArray1)).buffer, 2);

  1541     assertEq(view.getUint32(0, false), 0x02036465);

  1542     view = new DataView((new Uint8Array(intArray1)).buffer, 3);

  1543     assertEq(view.getUint32(0, false), 0x03646566);

  1544     view = new DataView((new Uint8Array(intArray1)).buffer, 4);

  1545     assertEq(view.getUint32(0, false), 0x64656667);

  1546     view = new DataView((new Uint8Array(intArray1)).buffer, 5);

  1547     assertEq(view.getUint32(0, false), 0x65666780);

  1548     view = new DataView((new Uint8Array(intArray1)).buffer, 6);

  1549     assertEq(view.getUint32(0, false), 0x66678081);

  1550     view = new DataView((new Uint8Array(intArray1)).buffer, 7);

  1551     assertEq(view.getUint32(0, false), 0x67808182);

  1553     // Test for indexing into a DataView, which should not use the ArrayBuffer storage

  1554     view = new DataView((new Uint8Array([1, 2])).buffer);

  1555     assertEq(view[0], undefined);

  1556     view[0] = 3;

  1557     assertEq(view[0], 3);

  1558     assertEq(view.getUint8(0), 1);

  1560     // Test WebIDL-specific class and prototype class names

  1561     assertEq(Object.prototype.toString.apply(new Uint8Array(0)), "[object Uint8Array]");

  1562     assertEq(Object.prototype.toString.apply(new Float32Array(0)), "[object Float32Array]");

  1563     assertEq(Object.prototype.toString.apply(Uint8Array.prototype), "[object Uint8ArrayPrototype]");

  1564     assertEq(Object.prototype.toString.apply(Float32Array.prototype), "[object Float32ArrayPrototype]");

  1565     assertEq(Object.prototype.toString.apply(new ArrayBuffer()), "[object ArrayBuffer]");

  1566     assertEq(Object.prototype.toString.apply(new DataView(view.buffer)), "[object DataView]");

  1567     assertEq(Object.prototype.toString.apply(DataView.prototype), "[object DataViewPrototype]");

  1569     // Accessing DataView fields on DataView.prototype should crash

  1570     checkThrow(function () DataView.prototype.byteLength, TypeError);

  1571     checkThrow(function () DataView.prototype.byteOffset, TypeError);

  1572     checkThrow(function () DataView.prototype.buffer, TypeError);

  1574     // Protos and proxies, oh my!

  1575     var alien = newGlobal();

  1576     var alien_data = alien.eval('data = ' + data1.toSource());

  1577     var alien_buffer = alien.eval('buffer = new Uint8Array(data).buffer');

  1578     var alien_view = alien.eval('view = new DataView(buffer, 0, 16)');

  1580     // proto is view of buffer: should throw

  1581     var o = Object.create(view1);

  1582     checkThrow(function () o.getUint8(4), TypeError); // WebIDL 4.4.7: Operations

  1583     checkThrow(function () o.buffer, TypeError); // WebIDL 4.4.6: Attributes, section 2

  1584     checkThrow(function () o.byteOffset, TypeError);

  1585     checkThrow(function () o.byteLength, TypeError);

  1587     // proxy for view of buffer: should work

  1588     assertEq(alien_view.buffer.byteLength > 0, true);

  1589     assertEq(alien_view.getUint8(4), 100);

  1591     // Bug 753996: when throwing an Error whose message contains the name of a

  1592     // function, the JS engine calls js_ValueToFunction to produce the function

  1593     // name to include in the message. js_ValueToFunction does not unwrap its

  1594     // argument. So if the function is actually a wrapper, then

  1595     // js_ValueToFunction will throw a TypeError ("X is not a function").

  1596     // Confusingly, this TypeError uses the decompiler, which *will* unwrap the

  1597     // object to get the wrapped function name out, so the final error will

  1598     // look something like "SomeFunction() is not a function".)

  1599     var weirdo = Object.create(alien.eval("new Date"));

  1600     var e = null;

  1601     try {

  1602         weirdo.getTime();

  1603     } catch (exc) {

  1604         e = exc;

  1605     }

  1606     if (!e) {

  1607         print("==== TODO but PASSED? ====");

  1608         print("Bug 753996 unexpectedly passed");

  1609     }

  1611     // proto is proxy for view of buffer: should throw TypeError

  1612     //

  1613     // As of this writing, bug 753996 causes this to throw the *wrong*

  1614     // TypeError, and in fact it throws a (thisglobal).TypeError instead of

  1615     // alien.TypeError.

  1616     var av = Object.create(alien_view);

  1617     checkThrowTODO(function () av.getUint8(4), alien.TypeError);

  1618     checkThrowTODO(function () av.buffer, alien.TypeError);

  1620     // view of object whose proto is buffer. This should not work per dherman.

  1621     // Note that DataView throws a TypeError while TypedArrays create a

  1622     // zero-length view. Odd though it seems, this is correct: TypedArrays have

  1623     // a constructor that takes a length argument; DataViews do not. So a

  1624     // TypedArray will do ToUint32 and end up passing a zero as the

  1625     // constructor's length argument.

  1626     buffer = Object.create(buffer1);

  1627     checkThrow(function () new DataView(buffer), TypeError);

  1629     // view of proxy for buffer

  1630     av = new DataView(alien_buffer);

  1631     assertEq(av.getUint8(4), 100);

  1632     assertEq(Object.getPrototypeOf(av), DataView.prototype);

  1634     // Bug 760904: call another compartment's constructor with an ArrayBuffer

  1635     // from this compartment, both as a constructor and as a regular call. (The

  1636     // latter is what was broken in that bug.)

  1637     var alien_constructor = alien.DataView;

  1638     var local_buffer = (new Int8Array(3)).buffer;

  1639     var foreign_exchange_student_1 = alien_constructor(local_buffer);

  1640     var foreign_exchange_student_2 = new alien_constructor(local_buffer);

  1642     // gc bug 787775

  1643     var ab = new ArrayBuffer(4);

  1644     var dv = new DataView(ab);

  1645     dv = 1;

  1646     gc();

  1648     reportCompare(0, 0, 'done.');

  1649     exitFunc ('test');

  1650 }

  1652 test();

The Tor Browser / file revision

js/src/tests/js1_8_5/extensions/dataview.js@129ffea94266

js/src/tests/js1_8_5/extensions/dataview.js