js/src/jsapi-tests/testLargeArrayBuffers.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  */
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #include "js/ArrayBuffer.h"
   9 #include "js/ArrayBufferMaybeShared.h"
  10 #include "js/experimental/TypedData.h"
  11 #include "js/SharedArrayBuffer.h"
  12
  13 #include "jsapi-tests/tests.h"
  14
  15 using namespace js;
  16
  17 BEGIN_TEST(testLargeArrayBuffers) {
  18 #ifdef JS_64BIT
  19   constexpr size_t nbytes = size_t(6) * 1024 * 1024 * 1024;  // 6 GB.
  20
  21   RootedObject buffer(cx, JS::NewArrayBuffer(cx, nbytes));
  22   CHECK(buffer);
  23   CHECK(JS::IsArrayBufferObject(buffer));
  24
  25   size_t length;
  26   bool isShared;
  27   uint8_t* data;
  28
  29   // ArrayBuffer
  30   {
  31     CHECK_EQUAL(JS::GetArrayBufferByteLength(buffer), nbytes);
  32
  33     JS::GetArrayBufferLengthAndData(buffer, &length, &isShared, &data);
  34     CHECK_EQUAL(length, nbytes);
  35
  36     length = 0;
  37     JS::GetArrayBufferMaybeSharedLengthAndData(buffer, &length, &isShared,
  38                                                &data);
  39     CHECK_EQUAL(length, nbytes);
  40
  41     length = 0;
  42     CHECK(GetObjectAsArrayBuffer(buffer, &length, &data));
  43     CHECK_EQUAL(length, nbytes);
  44   }
  45
  46   // New Uint8Array
  47   {
  48     RootedObject tarr(cx, JS_NewUint8Array(cx, nbytes));
  49     CHECK(JS_IsTypedArrayObject(tarr));
  50     CHECK_EQUAL(JS_GetArrayBufferViewByteOffset(tarr), 0u);
  51     CHECK_EQUAL(JS_GetArrayBufferViewByteLength(tarr), nbytes);
  52     CHECK_EQUAL(JS_GetTypedArrayByteOffset(tarr), 0u);
  53     CHECK_EQUAL(JS_GetTypedArrayByteLength(tarr), nbytes);
  54     CHECK_EQUAL(JS_GetTypedArrayLength(tarr), nbytes);
  55
  56     length = 0;
  57     js::GetArrayBufferViewLengthAndData(tarr, &length, &isShared, &data);
  58     CHECK_EQUAL(length, nbytes);
  59
  60     length = 0;
  61     js::GetUint8ArrayLengthAndData(tarr, &length, &isShared, &data);
  62     CHECK_EQUAL(length, nbytes);
  63
  64     length = 0;
  65     JS::AutoCheckCannotGC nogc(cx);
  66     mozilla::Span<uint8_t> span =
  67         JS::TypedArray<Scalar::Uint8>::unwrap(tarr).getData(&isShared, nogc);
  68     CHECK_EQUAL(span.Length(), nbytes);
  69
  70     length = 0;
  71     CHECK(JS_GetObjectAsArrayBufferView(tarr, &length, &isShared, &data));
  72     CHECK_EQUAL(length, nbytes);
  73   }
  74
  75   // Int16Array
  76   {
  77     RootedObject tarr(cx,
  78                       JS_NewInt16ArrayWithBuffer(cx, buffer, 0, nbytes / 2));
  79     CHECK(JS_IsTypedArrayObject(tarr));
  80     CHECK_EQUAL(JS_GetArrayBufferViewByteOffset(tarr), 0u);
  81     CHECK_EQUAL(JS_GetArrayBufferViewByteLength(tarr), nbytes);
  82     CHECK_EQUAL(JS_GetTypedArrayByteOffset(tarr), 0u);
  83     CHECK_EQUAL(JS_GetTypedArrayByteLength(tarr), nbytes);
  84     CHECK_EQUAL(JS_GetTypedArrayLength(tarr), nbytes / 2);
  85
  86     length = 0;
  87     js::GetArrayBufferViewLengthAndData(tarr, &length, &isShared, &data);
  88     CHECK_EQUAL(length, nbytes);
  89
  90     length = 0;
  91     int16_t* int16Data;
  92     js::GetInt16ArrayLengthAndData(tarr, &length, &isShared, &int16Data);
  93     CHECK_EQUAL(length, nbytes / 2);
  94
  95     length = 0;
  96     JS::AutoCheckCannotGC nogc(cx);
  97     mozilla::Span<short> span =
  98         JS::TypedArray<Scalar::Int16>::unwrap(tarr).getData(&isShared, nogc);
  99     CHECK_EQUAL(span.Length(), nbytes / 2);
 100
 101     length = 0;
 102     CHECK(JS_GetObjectAsArrayBufferView(tarr, &length, &isShared, &data));
 103     CHECK_EQUAL(length, nbytes);
 104   }
 105
 106   // DataView
 107   {
 108     RootedObject dv(cx, JS_NewDataView(cx, buffer, 0, nbytes - 10));
 109     CHECK(JS_IsArrayBufferViewObject(dv));
 110     CHECK_EQUAL(JS_GetArrayBufferViewByteOffset(dv), 0u);
 111     CHECK_EQUAL(JS_GetArrayBufferViewByteLength(dv), nbytes - 10);
 112
 113     length = 0;
 114     js::GetArrayBufferViewLengthAndData(dv, &length, &isShared, &data);
 115     CHECK_EQUAL(length, nbytes - 10);
 116
 117     length = 0;
 118     CHECK(JS_GetObjectAsArrayBufferView(dv, &length, &isShared, &data));
 119     CHECK_EQUAL(length, nbytes - 10);
 120   }
 121
 122   // Int8Array with large byteOffset.
 123   {
 124     RootedObject tarr(cx,
 125                       JS_NewInt8ArrayWithBuffer(cx, buffer, nbytes - 200, 32));
 126     CHECK(JS_IsTypedArrayObject(tarr));
 127     CHECK_EQUAL(JS_GetArrayBufferViewByteOffset(tarr), nbytes - 200);
 128     CHECK_EQUAL(JS_GetArrayBufferViewByteLength(tarr), 32u);
 129     CHECK_EQUAL(JS_GetTypedArrayByteOffset(tarr), nbytes - 200);
 130     CHECK_EQUAL(JS_GetTypedArrayByteLength(tarr), 32u);
 131     CHECK_EQUAL(JS_GetTypedArrayLength(tarr), 32u);
 132   }
 133
 134   // DataView with large byteOffset.
 135   {
 136     RootedObject dv(cx, JS_NewDataView(cx, buffer, nbytes - 200, 32));
 137     CHECK(JS_IsArrayBufferViewObject(dv));
 138     CHECK_EQUAL(JS_GetArrayBufferViewByteOffset(dv), nbytes - 200);
 139     CHECK_EQUAL(JS_GetArrayBufferViewByteLength(dv), 32u);
 140   }
 141 #endif
 142
 143   return true;
 144 }
 145 END_TEST(testLargeArrayBuffers)
 146
 147 BEGIN_TEST(testLargeSharedArrayBuffers) {
 148 #ifdef JS_64BIT
 149   constexpr size_t nbytes = size_t(5) * 1024 * 1024 * 1024;  // 5 GB.
 150
 151   RootedObject buffer(cx, JS::NewSharedArrayBuffer(cx, nbytes));
 152   CHECK(buffer);
 153   CHECK(JS::IsSharedArrayBufferObject(buffer));
 154   CHECK_EQUAL(GetSharedArrayBufferByteLength(buffer), nbytes);
 155
 156   size_t length;
 157   bool isShared;
 158   uint8_t* data;
 159   JS::GetSharedArrayBufferLengthAndData(buffer, &length, &isShared, &data);
 160   CHECK_EQUAL(length, nbytes);
 161 #endif
 162
 163   return true;
 164 }
 165 END_TEST(testLargeSharedArrayBuffers)