koffi 0.9.2 → 0.9.5

package/vendor/node-addon-api/test/dataview/dataview.cc

@@ -1,48 +1,48 @@
-#include "napi.h"
-
-using namespace Napi;
-
-static Value CreateDataView1(const CallbackInfo& info) {
-  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
-  return DataView::New(info.Env(), arrayBuffer);
-}
-
-static Value CreateDataView2(const CallbackInfo& info) {
-  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return DataView::New(info.Env(), arrayBuffer, byteOffset);
-}
-
-static Value CreateDataView3(const CallbackInfo& info) {
-  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  size_t byteLength = info[2].As<Number>().Uint32Value();
-  return DataView::New(info.Env(), arrayBuffer, byteOffset, byteLength);
-}
-
-static Value GetArrayBuffer(const CallbackInfo& info) {
-  return info[0].As<DataView>().ArrayBuffer();
-}
-
-static Value GetByteOffset(const CallbackInfo& info) {
-  return Number::New(info.Env(),
-                     static_cast<double>(info[0].As<DataView>().ByteOffset()));
-}
-
-static Value GetByteLength(const CallbackInfo& info) {
-  return Number::New(info.Env(),
-                     static_cast<double>(info[0].As<DataView>().ByteLength()));
-}
-
-Object InitDataView(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createDataView1"] = Function::New(env, CreateDataView1);
-  exports["createDataView2"] = Function::New(env, CreateDataView2);
-  exports["createDataView3"] = Function::New(env, CreateDataView3);
-  exports["getArrayBuffer"] = Function::New(env, GetArrayBuffer);
-  exports["getByteOffset"] = Function::New(env, GetByteOffset);
-  exports["getByteLength"] = Function::New(env, GetByteLength);
-
-  return exports;
-}
+#include "napi.h"
+
+using namespace Napi;
+
+static Value CreateDataView1(const CallbackInfo& info) {
+  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
+  return DataView::New(info.Env(), arrayBuffer);
+}
+
+static Value CreateDataView2(const CallbackInfo& info) {
+  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return DataView::New(info.Env(), arrayBuffer, byteOffset);
+}
+
+static Value CreateDataView3(const CallbackInfo& info) {
+  ArrayBuffer arrayBuffer = info[0].As<ArrayBuffer>();
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  size_t byteLength = info[2].As<Number>().Uint32Value();
+  return DataView::New(info.Env(), arrayBuffer, byteOffset, byteLength);
+}
+
+static Value GetArrayBuffer(const CallbackInfo& info) {
+  return info[0].As<DataView>().ArrayBuffer();
+}
+
+static Value GetByteOffset(const CallbackInfo& info) {
+  return Number::New(info.Env(),
+                     static_cast<double>(info[0].As<DataView>().ByteOffset()));
+}
+
+static Value GetByteLength(const CallbackInfo& info) {
+  return Number::New(info.Env(),
+                     static_cast<double>(info[0].As<DataView>().ByteLength()));
+}
+
+Object InitDataView(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createDataView1"] = Function::New(env, CreateDataView1);
+  exports["createDataView2"] = Function::New(env, CreateDataView2);
+  exports["createDataView3"] = Function::New(env, CreateDataView3);
+  exports["getArrayBuffer"] = Function::New(env, GetArrayBuffer);
+  exports["getByteOffset"] = Function::New(env, GetByteOffset);
+  exports["getByteLength"] = Function::New(env, GetByteLength);
+
+  return exports;
+}

package/vendor/node-addon-api/test/dataview/dataview.js

@@ -1,35 +1,35 @@
-'use strict';
-
-const assert = require('assert');
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  function testDataViewCreation(factory, arrayBuffer, offset, length) {
-    const view = factory(arrayBuffer, offset, length);
-    offset = offset ? offset : 0;
-    assert.ok(dataview.getArrayBuffer(view) instanceof ArrayBuffer);
-    assert.strictEqual(dataview.getArrayBuffer(view), arrayBuffer);
-    assert.strictEqual(dataview.getByteOffset(view), offset);
-    assert.strictEqual(dataview.getByteLength(view),
-        length ? length : arrayBuffer.byteLength - offset);
-  }
-
-  function testInvalidRange(factory, arrayBuffer, offset, length) {
-    assert.throws(() => {
-      factory(arrayBuffer, offset, length);
-    }, RangeError);
-  }
-
-  const dataview = binding.dataview;
-  const arrayBuffer = new ArrayBuffer(10);
-
-  testDataViewCreation(dataview.createDataView1, arrayBuffer);
-  testDataViewCreation(dataview.createDataView2, arrayBuffer, 2);
-  testDataViewCreation(dataview.createDataView2, arrayBuffer, 10);
-  testDataViewCreation(dataview.createDataView3, arrayBuffer, 2, 4);
-  testDataViewCreation(dataview.createDataView3, arrayBuffer, 10, 0);
-
-  testInvalidRange(dataview.createDataView2, arrayBuffer, 11);
-  testInvalidRange(dataview.createDataView3, arrayBuffer, 11, 0);
-  testInvalidRange(dataview.createDataView3, arrayBuffer, 6, 5);
-}
+'use strict';
+
+const assert = require('assert');
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  function testDataViewCreation(factory, arrayBuffer, offset, length) {
+    const view = factory(arrayBuffer, offset, length);
+    offset = offset ? offset : 0;
+    assert.ok(dataview.getArrayBuffer(view) instanceof ArrayBuffer);
+    assert.strictEqual(dataview.getArrayBuffer(view), arrayBuffer);
+    assert.strictEqual(dataview.getByteOffset(view), offset);
+    assert.strictEqual(dataview.getByteLength(view),
+        length ? length : arrayBuffer.byteLength - offset);
+  }
+
+  function testInvalidRange(factory, arrayBuffer, offset, length) {
+    assert.throws(() => {
+      factory(arrayBuffer, offset, length);
+    }, RangeError);
+  }
+
+  const dataview = binding.dataview;
+  const arrayBuffer = new ArrayBuffer(10);
+
+  testDataViewCreation(dataview.createDataView1, arrayBuffer);
+  testDataViewCreation(dataview.createDataView2, arrayBuffer, 2);
+  testDataViewCreation(dataview.createDataView2, arrayBuffer, 10);
+  testDataViewCreation(dataview.createDataView3, arrayBuffer, 2, 4);
+  testDataViewCreation(dataview.createDataView3, arrayBuffer, 10, 0);
+
+  testInvalidRange(dataview.createDataView2, arrayBuffer, 11);
+  testInvalidRange(dataview.createDataView3, arrayBuffer, 11, 0);
+  testInvalidRange(dataview.createDataView3, arrayBuffer, 6, 5);
+}

package/vendor/node-addon-api/test/dataview/dataview_read_write.cc

@@ -1,115 +1,115 @@
-#include "napi.h"
-
-using namespace Napi;
-
-static Value GetFloat32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetFloat32(byteOffset));
-}
-
-static Value GetFloat64(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetFloat64(byteOffset));
-}
-
-static Value GetInt8(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetInt8(byteOffset));
-}
-
-static Value GetInt16(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetInt16(byteOffset));
-}
-
-static Value GetInt32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetInt32(byteOffset));
-}
-
-static Value GetUint8(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetUint8(byteOffset));
-}
-
-static Value GetUint16(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetUint16(byteOffset));
-}
-
-static Value GetUint32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  return Number::New(info.Env(), info[0].As<DataView>().GetUint32(byteOffset));
-}
-
-static void SetFloat32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().FloatValue();
-  info[0].As<DataView>().SetFloat32(byteOffset, value);
-}
-
-static void SetFloat64(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().DoubleValue();
-  info[0].As<DataView>().SetFloat64(byteOffset, value);
-}
-
-static void SetInt8(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Int32Value();
-  info[0].As<DataView>().SetInt8(byteOffset, value);
-}
-
-static void SetInt16(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Int32Value();
-  info[0].As<DataView>().SetInt16(byteOffset, value);
-}
-
-static void SetInt32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Int32Value();
-  info[0].As<DataView>().SetInt32(byteOffset, value);
-}
-
-static void SetUint8(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Uint32Value();
-  info[0].As<DataView>().SetUint8(byteOffset, value);
-}
-
-static void SetUint16(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Uint32Value();
-  info[0].As<DataView>().SetUint16(byteOffset, value);
-}
-
-static void SetUint32(const CallbackInfo& info) {
-  size_t byteOffset = info[1].As<Number>().Uint32Value();
-  auto value = info[2].As<Number>().Uint32Value();
-  info[0].As<DataView>().SetUint32(byteOffset, value);
-}
-
-Object InitDataViewReadWrite(Env env) {
-  Object exports = Object::New(env);
-
-  exports["getFloat32"] = Function::New(env, GetFloat32);
-  exports["getFloat64"] = Function::New(env, GetFloat64);
-  exports["getInt8"] = Function::New(env, GetInt8);
-  exports["getInt16"] = Function::New(env, GetInt16);
-  exports["getInt32"] = Function::New(env, GetInt32);
-  exports["getUint8"] = Function::New(env, GetUint8);
-  exports["getUint16"] = Function::New(env, GetUint16);
-  exports["getUint32"] = Function::New(env, GetUint32);
-
-  exports["setFloat32"] = Function::New(env, SetFloat32);
-  exports["setFloat64"] = Function::New(env, SetFloat64);
-  exports["setInt8"] = Function::New(env, SetInt8);
-  exports["setInt16"] = Function::New(env, SetInt16);
-  exports["setInt32"] = Function::New(env, SetInt32);
-  exports["setUint8"] = Function::New(env, SetUint8);
-  exports["setUint16"] = Function::New(env, SetUint16);
-  exports["setUint32"] = Function::New(env, SetUint32);
-
-  return exports;
-}
+#include "napi.h"
+
+using namespace Napi;
+
+static Value GetFloat32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetFloat32(byteOffset));
+}
+
+static Value GetFloat64(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetFloat64(byteOffset));
+}
+
+static Value GetInt8(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetInt8(byteOffset));
+}
+
+static Value GetInt16(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetInt16(byteOffset));
+}
+
+static Value GetInt32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetInt32(byteOffset));
+}
+
+static Value GetUint8(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetUint8(byteOffset));
+}
+
+static Value GetUint16(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetUint16(byteOffset));
+}
+
+static Value GetUint32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  return Number::New(info.Env(), info[0].As<DataView>().GetUint32(byteOffset));
+}
+
+static void SetFloat32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().FloatValue();
+  info[0].As<DataView>().SetFloat32(byteOffset, value);
+}
+
+static void SetFloat64(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().DoubleValue();
+  info[0].As<DataView>().SetFloat64(byteOffset, value);
+}
+
+static void SetInt8(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Int32Value();
+  info[0].As<DataView>().SetInt8(byteOffset, value);
+}
+
+static void SetInt16(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Int32Value();
+  info[0].As<DataView>().SetInt16(byteOffset, value);
+}
+
+static void SetInt32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Int32Value();
+  info[0].As<DataView>().SetInt32(byteOffset, value);
+}
+
+static void SetUint8(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Uint32Value();
+  info[0].As<DataView>().SetUint8(byteOffset, value);
+}
+
+static void SetUint16(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Uint32Value();
+  info[0].As<DataView>().SetUint16(byteOffset, value);
+}
+
+static void SetUint32(const CallbackInfo& info) {
+  size_t byteOffset = info[1].As<Number>().Uint32Value();
+  auto value = info[2].As<Number>().Uint32Value();
+  info[0].As<DataView>().SetUint32(byteOffset, value);
+}
+
+Object InitDataViewReadWrite(Env env) {
+  Object exports = Object::New(env);
+
+  exports["getFloat32"] = Function::New(env, GetFloat32);
+  exports["getFloat64"] = Function::New(env, GetFloat64);
+  exports["getInt8"] = Function::New(env, GetInt8);
+  exports["getInt16"] = Function::New(env, GetInt16);
+  exports["getInt32"] = Function::New(env, GetInt32);
+  exports["getUint8"] = Function::New(env, GetUint8);
+  exports["getUint16"] = Function::New(env, GetUint16);
+  exports["getUint32"] = Function::New(env, GetUint32);
+
+  exports["setFloat32"] = Function::New(env, SetFloat32);
+  exports["setFloat64"] = Function::New(env, SetFloat64);
+  exports["setInt8"] = Function::New(env, SetInt8);
+  exports["setInt16"] = Function::New(env, SetInt16);
+  exports["setInt32"] = Function::New(env, SetInt32);
+  exports["setUint8"] = Function::New(env, SetUint8);
+  exports["setUint16"] = Function::New(env, SetUint16);
+  exports["setUint32"] = Function::New(env, SetUint32);
+
+  return exports;
+}

package/vendor/node-addon-api/test/dataview/dataview_read_write.js

@@ -1,90 +1,90 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  function expected(type, value) {
-    return eval(`(new ${type}Array([${value}]))[0]`);
-  }
-
-  function nativeReadDataView(dataview, type, offset, value) {
-    return eval(`binding.dataview_read_write.get${type}(dataview, offset)`);
-  }
-
-  function nativeWriteDataView(dataview, type, offset, value) {
-    eval(`binding.dataview_read_write.set${type}(dataview, offset, value)`);
-  }
-
-  function isLittleEndian() {
-    const buffer = new ArrayBuffer(2);
-    new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
-    return new Int16Array(buffer)[0] === 256;
-  }
-
-  function jsReadDataView(dataview, type, offset, value) {
-    return eval(`dataview.get${type}(offset, isLittleEndian())`);
-  }
-
-  function jsWriteDataView(dataview, type, offset, value) {
-    eval(`dataview.set${type}(offset, value, isLittleEndian())`);
-  }
-
-  function testReadData(dataview, type, offset, value) {
-    jsWriteDataView(dataview, type, offset, 0);
-    assert.strictEqual(jsReadDataView(dataview, type, offset), 0);
-
-    jsWriteDataView(dataview, type, offset, value);
-    assert.strictEqual(
-        nativeReadDataView(dataview, type, offset), expected(type, value));
-  }
-
-  function testWriteData(dataview, type, offset, value) {
-    jsWriteDataView(dataview, type, offset, 0);
-    assert.strictEqual(jsReadDataView(dataview, type, offset), 0);
-
-    nativeWriteDataView(dataview, type, offset, value);
-    assert.strictEqual(
-        jsReadDataView(dataview, type, offset), expected(type, value));
-  }
-
-  function testInvalidOffset(dataview, type, offset, value) {
-    assert.throws(() => {
-      nativeReadDataView(dataview, type, offset);
-    }, RangeError);
-
-    assert.throws(() => {
-      nativeWriteDataView(dataview, type, offset, value);
-    }, RangeError);
-  }
-
-  const dataview = new DataView(new ArrayBuffer(22));
-
-  testReadData(dataview, 'Float32', 0, 10.2);
-  testReadData(dataview, 'Float64', 4, 20.3);
-  testReadData(dataview, 'Int8', 5, 120);
-  testReadData(dataview, 'Int16', 7, 15000);
-  testReadData(dataview, 'Int32', 11, 200000);
-  testReadData(dataview, 'Uint8', 12, 128);
-  testReadData(dataview, 'Uint16', 14, 32768);
-  testReadData(dataview, 'Uint32', 18, 1000000);
-
-  testWriteData(dataview, 'Float32', 0, 10.2);
-  testWriteData(dataview, 'Float64', 4, 20.3);
-  testWriteData(dataview, 'Int8', 5, 120);
-  testWriteData(dataview, 'Int16', 7, 15000);
-  testWriteData(dataview, 'Int32', 11, 200000);
-  testWriteData(dataview, 'Uint8', 12, 128);
-  testWriteData(dataview, 'Uint16', 14, 32768);
-  testWriteData(dataview, 'Uint32', 18, 1000000);
-
-  testInvalidOffset(dataview, 'Float32', 22, 10.2);
-  testInvalidOffset(dataview, 'Float64', 22, 20.3);
-  testInvalidOffset(dataview, 'Int8', 22, 120);
-  testInvalidOffset(dataview, 'Int16', 22, 15000);
-  testInvalidOffset(dataview, 'Int32', 22, 200000);
-  testInvalidOffset(dataview, 'Uint8', 22, 128);
-  testInvalidOffset(dataview, 'Uint16', 22, 32768);
-  testInvalidOffset(dataview, 'Uint32', 22, 1000000);
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  function expected(type, value) {
+    return eval(`(new ${type}Array([${value}]))[0]`);
+  }
+
+  function nativeReadDataView(dataview, type, offset, value) {
+    return eval(`binding.dataview_read_write.get${type}(dataview, offset)`);
+  }
+
+  function nativeWriteDataView(dataview, type, offset, value) {
+    eval(`binding.dataview_read_write.set${type}(dataview, offset, value)`);
+  }
+
+  function isLittleEndian() {
+    const buffer = new ArrayBuffer(2);
+    new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
+    return new Int16Array(buffer)[0] === 256;
+  }
+
+  function jsReadDataView(dataview, type, offset, value) {
+    return eval(`dataview.get${type}(offset, isLittleEndian())`);
+  }
+
+  function jsWriteDataView(dataview, type, offset, value) {
+    eval(`dataview.set${type}(offset, value, isLittleEndian())`);
+  }
+
+  function testReadData(dataview, type, offset, value) {
+    jsWriteDataView(dataview, type, offset, 0);
+    assert.strictEqual(jsReadDataView(dataview, type, offset), 0);
+
+    jsWriteDataView(dataview, type, offset, value);
+    assert.strictEqual(
+        nativeReadDataView(dataview, type, offset), expected(type, value));
+  }
+
+  function testWriteData(dataview, type, offset, value) {
+    jsWriteDataView(dataview, type, offset, 0);
+    assert.strictEqual(jsReadDataView(dataview, type, offset), 0);
+
+    nativeWriteDataView(dataview, type, offset, value);
+    assert.strictEqual(
+        jsReadDataView(dataview, type, offset), expected(type, value));
+  }
+
+  function testInvalidOffset(dataview, type, offset, value) {
+    assert.throws(() => {
+      nativeReadDataView(dataview, type, offset);
+    }, RangeError);
+
+    assert.throws(() => {
+      nativeWriteDataView(dataview, type, offset, value);
+    }, RangeError);
+  }
+
+  const dataview = new DataView(new ArrayBuffer(22));
+
+  testReadData(dataview, 'Float32', 0, 10.2);
+  testReadData(dataview, 'Float64', 4, 20.3);
+  testReadData(dataview, 'Int8', 5, 120);
+  testReadData(dataview, 'Int16', 7, 15000);
+  testReadData(dataview, 'Int32', 11, 200000);
+  testReadData(dataview, 'Uint8', 12, 128);
+  testReadData(dataview, 'Uint16', 14, 32768);
+  testReadData(dataview, 'Uint32', 18, 1000000);
+
+  testWriteData(dataview, 'Float32', 0, 10.2);
+  testWriteData(dataview, 'Float64', 4, 20.3);
+  testWriteData(dataview, 'Int8', 5, 120);
+  testWriteData(dataview, 'Int16', 7, 15000);
+  testWriteData(dataview, 'Int32', 11, 200000);
+  testWriteData(dataview, 'Uint8', 12, 128);
+  testWriteData(dataview, 'Uint16', 14, 32768);
+  testWriteData(dataview, 'Uint32', 18, 1000000);
+
+  testInvalidOffset(dataview, 'Float32', 22, 10.2);
+  testInvalidOffset(dataview, 'Float64', 22, 20.3);
+  testInvalidOffset(dataview, 'Int8', 22, 120);
+  testInvalidOffset(dataview, 'Int16', 22, 15000);
+  testInvalidOffset(dataview, 'Int32', 22, 200000);
+  testInvalidOffset(dataview, 'Uint8', 22, 128);
+  testInvalidOffset(dataview, 'Uint16', 22, 32768);
+  testInvalidOffset(dataview, 'Uint32', 22, 1000000);
+}