Upload Kmake

test/addons/stringbytes-external-exceed-max/binding.cc

@@ -0,0 +1,54 @@
+#include <node.h>
+#include <v8.h>
+#include <stdlib.h>
+
+#ifdef _AIX
+// AIX allows over-allocation, and will SIGKILL when the allocated pages are
+// used if there is not enough VM. Check for available space until
+// out-of-memory.  Don't allow more then some (large) proportion of it to be
+// used for the test strings, so Node & V8 have some space for allocations.
+#include <signal.h>
+#include <sys/vminfo.h>
+
+static void* Allowed(size_t size) {
+  blkcnt_t allowedBlocks = psdanger(SIGKILL);
+
+  if (allowedBlocks < 1) {
+    // Already OOM
+    return nullptr;
+  }
+  const size_t BYTES_PER_BLOCK = 512;
+  size_t allowed = (allowedBlocks * BYTES_PER_BLOCK * 4) / 5;
+  if (size < allowed) {
+    return malloc(size);
+  }
+  return nullptr;
+}
+#else
+// Other systems also allow over-allocation, but this malloc-and-free approach
+// seems to be working for them.
+static void* Allowed(size_t size) {
+  return malloc(size);
+}
+#endif  // _AIX
+
+void EnsureAllocation(const v8::FunctionCallbackInfo<v8::Value> &args) {
+  v8::Isolate* isolate = args.GetIsolate();
+  uintptr_t size = args[0].As<v8::Integer>()->Value();
+  v8::Local<v8::Boolean> success;
+
+  void* buffer = Allowed(size);
+  if (buffer) {
+    success = v8::Boolean::New(isolate, true);
+    free(buffer);
+  } else {
+    success = v8::Boolean::New(isolate, false);
+  }
+  args.GetReturnValue().Set(success);
+}
+
+void init(v8::Local<v8::Object> exports) {
+  NODE_SET_METHOD(exports, "ensureAllocation", EnsureAllocation);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, init)

test/addons/stringbytes-external-exceed-max/binding.gyp

@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'sources': [ 'binding.cc' ],
+      'includes': ['../common.gypi'],
+    }
+  ]
+}

test/addons/stringbytes-external-exceed-max/test-stringbytes-external-at-max.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../../common');
+const skipMessage = 'intensive toString tests due to memory confinements';
+if (!common.enoughTestMem)
+  common.skip(skipMessage);
+
+const binding = require(`./build/${common.buildType}/binding`);
+const assert = require('assert');
+
+// v8 fails silently if string length > v8::String::kMaxLength
+// v8::String::kMaxLength defined in v8.h
+const kStringMaxLength = require('buffer').constants.MAX_STRING_LENGTH;
+
+let buf;
+try {
+  buf = Buffer.allocUnsafe(kStringMaxLength);
+} catch (e) {
+  // If the exception is not due to memory confinement then rethrow it.
+  if (e.message !== 'Array buffer allocation failed') throw (e);
+  common.skip(skipMessage);
+}
+
+// Ensure we have enough memory available for future allocations to succeed.
+if (!binding.ensureAllocation(2 * kStringMaxLength))
+  common.skip(skipMessage);
+
+const maxString = buf.toString('latin1');
+assert.strictEqual(maxString.length, kStringMaxLength);

test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-ascii.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const common = require('../../common');
+const skipMessage = 'intensive toString tests due to memory confinements';
+if (!common.enoughTestMem)
+  common.skip(skipMessage);
+
+const assert = require('assert');
+const binding = require(`./build/${common.buildType}/binding`);
+
+// v8 fails silently if string length > v8::String::kMaxLength
+// v8::String::kMaxLength defined in v8.h
+const kStringMaxLength = require('buffer').constants.MAX_STRING_LENGTH;
+
+let buf;
+try {
+  buf = Buffer.allocUnsafe(kStringMaxLength + 1);
+} catch (e) {
+  // If the exception is not due to memory confinement then rethrow it.
+  if (e.message !== 'Array buffer allocation failed') throw (e);
+  common.skip(skipMessage);
+}
+
+// Ensure we have enough memory available for future allocations to succeed.
+if (!binding.ensureAllocation(2 * kStringMaxLength))
+  common.skip(skipMessage);
+
+const stringLengthHex = kStringMaxLength.toString(16);
+assert.throws(() => {
+  buf.toString('ascii');
+}, {
+  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
+           'characters',
+  code: 'ERR_STRING_TOO_LONG',
+  name: 'Error',
+});

test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-base64.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const common = require('../../common');
+const skipMessage = 'intensive toString tests due to memory confinements';
+if (!common.enoughTestMem)
+  common.skip(skipMessage);
+
+const assert = require('assert');
+const binding = require(`./build/${common.buildType}/binding`);
+
+// v8 fails silently if string length > v8::String::kMaxLength
+// v8::String::kMaxLength defined in v8.h
+const kStringMaxLength = require('buffer').constants.MAX_STRING_LENGTH;
+
+let buf;
+try {
+  buf = Buffer.allocUnsafe(kStringMaxLength + 1);
+} catch (e) {
+  // If the exception is not due to memory confinement then rethrow it.
+  if (e.message !== 'Array buffer allocation failed') throw (e);
+  common.skip(skipMessage);
+}
+
+// Ensure we have enough memory available for future allocations to succeed.
+if (!binding.ensureAllocation(2 * kStringMaxLength))
+  common.skip(skipMessage);
+
+const stringLengthHex = kStringMaxLength.toString(16);
+assert.throws(() => {
+  buf.toString('base64');
+}, {
+  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
+           'characters',
+  code: 'ERR_STRING_TOO_LONG',
+  name: 'Error',
+});

test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-binary.js

@@ -0,0 +1,48 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../../common');
+const skipMessage = 'intensive toString tests due to memory confinements';
+if (!common.enoughTestMem)
+  common.skip(skipMessage);
+
+const binding = require(`./build/${common.buildType}/binding`);
+const assert = require('assert');
+
+// v8 fails silently if string length > v8::String::kMaxLength
+// v8::String::kMaxLength defined in v8.h
+const kStringMaxLength = require('buffer').constants.MAX_STRING_LENGTH;
+
+let buf;
+try {
+  buf = Buffer.allocUnsafe(kStringMaxLength + 1);
+} catch (e) {
+  // If the exception is not due to memory confinement then rethrow it.
+  if (e.message !== 'Array buffer allocation failed') throw (e);
+  common.skip(skipMessage);
+}
+
+// Ensure we have enough memory available for future allocations to succeed.
+if (!binding.ensureAllocation(2 * kStringMaxLength))
+  common.skip(skipMessage);
+
+const stringLengthHex = kStringMaxLength.toString(16);
+assert.throws(() => {
+  buf.toString('latin1');
+}, {
+  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
+           'characters',
+  code: 'ERR_STRING_TOO_LONG',
+  name: 'Error',
+});
+
+// FIXME: Free the memory early to avoid OOM.
+// REF: https://github.com/nodejs/reliability/issues/12#issuecomment-412619655
+global.gc();
+let maxString = buf.toString('latin1', 1);
+assert.strictEqual(maxString.length, kStringMaxLength);
+maxString = undefined;
+global.gc();
+
+maxString = buf.toString('latin1', 0, kStringMaxLength);
+assert.strictEqual(maxString.length, kStringMaxLength);

test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-hex.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const common = require('../../common');
+const skipMessage = 'intensive toString tests due to memory confinements';
+if (!common.enoughTestMem)
+  common.skip(skipMessage);
+
+const assert = require('assert');
+const binding = require(`./build/${common.buildType}/binding`);
+
+// v8 fails silently if string length > v8::String::kMaxLength
+// v8::String::kMaxLength defined in v8.h
+const kStringMaxLength = require('buffer').constants.MAX_STRING_LENGTH;
+
+let buf;
+try {
+  buf = Buffer.allocUnsafe(kStringMaxLength + 1);
+} catch (e) {
+  // If the exception is not due to memory confinement then rethrow it.
+  if (e.message !== 'Array buffer allocation failed') throw (e);
+  common.skip(skipMessage);
+}
+
+// Ensure we have enough memory available for future allocations to succeed.
+if (!binding.ensureAllocation(2 * kStringMaxLength))
+  common.skip(skipMessage);
+
+const stringLengthHex = kStringMaxLength.toString(16);
+assert.throws(() => {
+  buf.toString('hex');
+}, {
+  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
+           'characters',
+  code: 'ERR_STRING_TOO_LONG',
+  name: 'Error',
+});

test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-1-utf8.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const common = require('../../common');
+const skipMessage = 'intensive toString tests due to memory confinements';
+if (!common.enoughTestMem)
+  common.skip(skipMessage);
+
+const binding = require(`./build/${common.buildType}/binding`);
+const assert = require('assert');
+
+// v8 fails silently if string length > v8::String::kMaxLength
+// v8::String::kMaxLength defined in v8.h
+const kStringMaxLength = require('buffer').constants.MAX_STRING_LENGTH;
+
+let buf;
+try {
+  buf = Buffer.allocUnsafe(kStringMaxLength + 1);
+} catch (e) {
+  // If the exception is not due to memory confinement then rethrow it.
+  if (e.message !== 'Array buffer allocation failed') throw (e);
+  common.skip(skipMessage);
+}
+
+// Ensure we have enough memory available for future allocations to succeed.
+if (!binding.ensureAllocation(2 * kStringMaxLength))
+  common.skip(skipMessage);
+
+const stringLengthHex = kStringMaxLength.toString(16);
+
+assert.throws(() => {
+  buf.toString();
+}, (e) => {
+  if (e.message !== 'Array buffer allocation failed') {
+    common.expectsError({
+      message: `Cannot create a string longer than 0x${stringLengthHex} ` +
+               'characters',
+      code: 'ERR_STRING_TOO_LONG',
+      name: 'Error',
+    })(e);
+    return true;
+  }
+  return true;
+});
+
+assert.throws(() => {
+  buf.toString('utf8');
+}, {
+  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
+           'characters',
+  code: 'ERR_STRING_TOO_LONG',
+  name: 'Error',
+});

test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max-by-2.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../../common');
+const skipMessage = 'intensive toString tests due to memory confinements';
+if (!common.enoughTestMem)
+  common.skip(skipMessage);
+
+const binding = require(`./build/${common.buildType}/binding`);
+const assert = require('assert');
+
+// v8 fails silently if string length > v8::String::kMaxLength
+// v8::String::kMaxLength defined in v8.h
+const kStringMaxLength = require('buffer').constants.MAX_STRING_LENGTH;
+
+let buf;
+try {
+  buf = Buffer.allocUnsafe(kStringMaxLength + 2);
+} catch (e) {
+  // If the exception is not due to memory confinement then rethrow it.
+  if (e.message !== 'Array buffer allocation failed') throw (e);
+  common.skip(skipMessage);
+}
+
+// Ensure we have enough memory available for future allocations to succeed.
+if (!binding.ensureAllocation(2 * kStringMaxLength))
+  common.skip(skipMessage);
+
+const maxString = buf.toString('utf16le');
+assert.strictEqual(maxString.length, Math.floor((kStringMaxLength + 2) / 2));

test/addons/stringbytes-external-exceed-max/test-stringbytes-external-exceed-max.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../../common');
+const skipMessage = 'intensive toString tests due to memory confinements';
+if (!common.enoughTestMem)
+  common.skip(skipMessage);
+
+const assert = require('assert');
+const binding = require(`./build/${common.buildType}/binding`);
+
+// v8 fails silently if string length > v8::String::kMaxLength
+// v8::String::kMaxLength defined in v8.h
+const kStringMaxLength = require('buffer').constants.MAX_STRING_LENGTH;
+
+let buf;
+try {
+  buf = Buffer.allocUnsafe(kStringMaxLength * 2 + 2);
+} catch (e) {
+  // If the exception is not due to memory confinement then rethrow it.
+  if (e.message !== 'Array buffer allocation failed') throw (e);
+  common.skip(skipMessage);
+}
+
+// Ensure we have enough memory available for future allocations to succeed.
+if (!binding.ensureAllocation(2 * kStringMaxLength))
+  common.skip(skipMessage);
+
+const stringLengthHex = kStringMaxLength.toString(16);
+
+assert.throws(() => {
+  buf.toString('utf16le');
+}, {
+  message: `Cannot create a string longer than 0x${stringLengthHex} ` +
+           'characters',
+  code: 'ERR_STRING_TOO_LONG',
+  name: 'Error',
+});