1berry/nodejs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

test: skip instead of fail when mem constrained

Browse Source 
The current implementation of tests for strings with length at or
exceeding kStringMaxLength allocate a temporary buffer inside a try
block to skip the test if there is insufficient memory. This commit adds
an invocation of the garbage collector after the temporary buffer is
allocated so that memory is freed for later allocations.

Change the corresponding catch block to rethrow the original exception
instead of asserting the exception message to provide more information
about the exception.

Add an additional check before trying to allocate memory to immediately
skip the test on machines with insufficient total memory.

PR-URL: https://github.com/nodejs/node/pull/3697
Reviewed-By: Trevor Norris <trev.norris@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Michaël Zasso <mic.besace@gmail.com>
Reviewed-By: Jeremiah Senkpiel <fishrock123@rocketmail.com>
This commit is contained in:
Michael Cornacchia 2015-11-06 12:51:48 -05:00 committed by Trevor Norris
parent b619831381
commit a40b9cab0a
9 changed files with 140 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
test/common.js
View File

@ -22,6 +22,8 @@ exports.isLinuxPPCBE = (process.platform === 'linux') &&
exports.isSunOS = process.platform === 'sunos';
exports.isFreeBSD = process.platform === 'freebsd';
exports.enoughTestMem = os.totalmem() > 0x20000000; /* 512MB */
function rimrafSync(p) {
try {
var st = fs.lstatSync(p);

24
test/parallel/test-stringbytes-external-at-max.js
View File

@ -1,22 +1,32 @@
'use strict';
// Flags: --expose-gc
require('../common');
const common = require('../common');
const assert = require('assert');
// v8 fails silently if string length > v8::String::kMaxLength
// v8::String::kMaxLength defined in v8.h
const kStringMaxLength = process.binding('buffer').kStringMaxLength;
const skipMessage =
'1..0 # Skipped: intensive toString tests due to memory confinements';
if (!common.enoughTestMem) {
console.log(skipMessage);
return;
}
assert(typeof gc === 'function', 'Run this test with --expose-gc');
try {
new Buffer(kStringMaxLength * 3);
var buf = new Buffer(kStringMaxLength);
// Try to allocate memory first then force gc so future allocations succeed.
new Buffer(2 * kStringMaxLength);
gc();
} catch(e) {
assert.equal(e.message, 'Invalid array buffer length');
console.log(
'1..0 # Skipped: intensive toString tests due to memory confinements');
// If the exception is not due to memory confinement then rethrow it.
if (e.message !== 'Invalid array buffer length') throw (e);
console.log(skipMessage);
return;
}
const buf = new Buffer(kStringMaxLength);
const maxString = buf.toString('binary');
assert.equal(maxString.length, kStringMaxLength);

24
test/parallel/test-stringbytes-external-exceed-max-by-1-ascii.js
View File

@ -1,23 +1,33 @@
'use strict';
// Flags: --expose-gc
require('../common');
const common = require('../common');
const assert = require('assert');
const skipMessage =
'1..0 # Skipped: intensive toString tests due to memory confinements';
if (!common.enoughTestMem) {
console.log(skipMessage);
return;
}
assert(typeof gc === 'function', 'Run this test with --expose-gc');
// v8 fails silently if string length > v8::String::kMaxLength
// v8::String::kMaxLength defined in v8.h
const kStringMaxLength = process.binding('buffer').kStringMaxLength;
try {
new Buffer(kStringMaxLength * 3);
var buf = new Buffer(kStringMaxLength + 1);
// Try to allocate memory first then force gc so future allocations succeed.
new Buffer(2 * kStringMaxLength);
gc();
} catch(e) {
assert.equal(e.message, 'Invalid array buffer length');
console.log(
'1..0 # Skipped: intensive toString tests due to memory confinements');
// If the exception is not due to memory confinement then rethrow it.
if (e.message !== 'Invalid array buffer length') throw (e);
console.log(skipMessage);
return;
}
const buf = new Buffer(kStringMaxLength + 1);
assert.throws(function() {
buf.toString('ascii');
}, /"toString\(\)" failed/);

24
test/parallel/test-stringbytes-external-exceed-max-by-1-base64.js
View File

@ -1,23 +1,33 @@
'use strict';
// Flags: --expose-gc
require('../common');
const common = require('../common');
const assert = require('assert');
const skipMessage =
'1..0 # Skipped: intensive toString tests due to memory confinements';
if (!common.enoughTestMem) {
console.log(skipMessage);
return;
}
assert(typeof gc === 'function', 'Run this test with --expose-gc');
// v8 fails silently if string length > v8::String::kMaxLength
// v8::String::kMaxLength defined in v8.h
const kStringMaxLength = process.binding('buffer').kStringMaxLength;
try {
new Buffer(kStringMaxLength * 3);
var buf = new Buffer(kStringMaxLength + 1);
// Try to allocate memory first then force gc so future allocations succeed.
new Buffer(2 * kStringMaxLength);
gc();
} catch(e) {
assert.equal(e.message, 'Invalid array buffer length');
console.log(
'1..0 # Skipped: intensive toString tests due to memory confinements');
// If the exception is not due to memory confinement then rethrow it.
if (e.message !== 'Invalid array buffer length') throw (e);
console.log(skipMessage);
return;
}
const buf = new Buffer(kStringMaxLength + 1);
assert.throws(function() {
buf.toString('base64');
}, /"toString\(\)" failed/);

24
test/parallel/test-stringbytes-external-exceed-max-by-1-binary.js
View File

@ -1,23 +1,33 @@
'use strict';
// Flags: --expose-gc
require('../common');
const common = require('../common');
const assert = require('assert');
const skipMessage =
'1..0 # Skipped: intensive toString tests due to memory confinements';
if (!common.enoughTestMem) {
console.log(skipMessage);
return;
}
assert(typeof gc === 'function', 'Run this test with --expose-gc');
// v8 fails silently if string length > v8::String::kMaxLength
// v8::String::kMaxLength defined in v8.h
const kStringMaxLength = process.binding('buffer').kStringMaxLength;
try {
new Buffer(kStringMaxLength * 3);
var buf = new Buffer(kStringMaxLength + 1);
// Try to allocate memory first then force gc so future allocations succeed.
new Buffer(2 * kStringMaxLength);
gc();
} catch(e) {
assert.equal(e.message, 'Invalid array buffer length');
console.log(
'1..0 # Skipped: intensive toString tests due to memory confinements');
// If the exception is not due to memory confinement then rethrow it.
if (e.message !== 'Invalid array buffer length') throw (e);
console.log(skipMessage);
return;
}
const buf = new Buffer(kStringMaxLength + 1);
assert.throws(function() {
buf.toString('binary');
}, /"toString\(\)" failed/);

24
test/parallel/test-stringbytes-external-exceed-max-by-1-hex.js
View File

@ -1,23 +1,33 @@
'use strict';
// Flags: --expose-gc
require('../common');
const common = require('../common');
const assert = require('assert');
const skipMessage =
'1..0 # Skipped: intensive toString tests due to memory confinements';
if (!common.enoughTestMem) {
console.log(skipMessage);
return;
}
assert(typeof gc === 'function', 'Run this test with --expose-gc');
// v8 fails silently if string length > v8::String::kMaxLength
// v8::String::kMaxLength defined in v8.h
const kStringMaxLength = process.binding('buffer').kStringMaxLength;
try {
new Buffer(kStringMaxLength * 3);
var buf = new Buffer(kStringMaxLength + 1);
// Try to allocate memory first then force gc so future allocations succeed.
new Buffer(2 * kStringMaxLength);
gc();
} catch(e) {
assert.equal(e.message, 'Invalid array buffer length');
console.log(
'1..0 # Skipped: intensive toString tests due to memory confinements');
// If the exception is not due to memory confinement then rethrow it.
if (e.message !== 'Invalid array buffer length') throw (e);
console.log(skipMessage);
return;
}
const buf = new Buffer(kStringMaxLength + 1);
assert.throws(function() {
buf.toString('hex');
}, /"toString\(\)" failed/);

24
test/parallel/test-stringbytes-external-exceed-max-by-1-utf8.js
View File

@ -1,23 +1,33 @@
'use strict';
// Flags: --expose-gc
require('../common');
const common = require('../common');
const assert = require('assert');
const skipMessage =
'1..0 # Skipped: intensive toString tests due to memory confinements';
if (!common.enoughTestMem) {
console.log(skipMessage);
return;
}
assert(typeof gc === 'function', 'Run this test with --expose-gc');
// v8 fails silently if string length > v8::String::kMaxLength
// v8::String::kMaxLength defined in v8.h
const kStringMaxLength = process.binding('buffer').kStringMaxLength;
try {
new Buffer(kStringMaxLength * 3);
var buf = new Buffer(kStringMaxLength + 1);
// Try to allocate memory first then force gc so future allocations succeed.
new Buffer(2 * kStringMaxLength);
gc();
} catch(e) {
assert.equal(e.message, 'Invalid array buffer length');
console.log(
'1..0 # Skipped: intensive toString tests due to memory confinements');
// If the exception is not due to memory confinement then rethrow it.
if (e.message !== 'Invalid array buffer length') throw (e);
console.log(skipMessage);
return;
}
const buf = new Buffer(kStringMaxLength + 1);
assert.throws(function() {
buf.toString();
}, /"toString\(\)" failed|Invalid array buffer length/);

26
test/parallel/test-stringbytes-external-exceed-max-by-2.js
View File

@ -1,22 +1,32 @@
'use strict';
// Flags: --expose-gc
require('../common');
const common = require('../common');
const assert = require('assert');
const skipMessage =
'1..0 # Skipped: intensive toString tests due to memory confinements';
if (!common.enoughTestMem) {
console.log(skipMessage);
return;
}
assert(typeof gc === 'function', 'Run this test with --expose-gc');
// v8 fails silently if string length > v8::String::kMaxLength
// v8::String::kMaxLength defined in v8.h
const kStringMaxLength = process.binding('buffer').kStringMaxLength;
try {
new Buffer(kStringMaxLength * 3);
var buf = new Buffer(kStringMaxLength + 2);
// Try to allocate memory first then force gc so future allocations succeed.
new Buffer(2 * kStringMaxLength);
gc();
} catch(e) {
assert.equal(e.message, 'Invalid array buffer length');
console.log(
'1..0 # Skipped: intensive toString tests due to memory confinements');
// If the exception is not due to memory confinement then rethrow it.
if (e.message !== 'Invalid array buffer length') throw (e);
console.log(skipMessage);
return;
}
const buf2 = new Buffer(kStringMaxLength + 2);
const maxString = buf2.toString('utf16le');
const maxString = buf.toString('utf16le');
assert.equal(maxString.length, (kStringMaxLength + 2) / 2);

26
test/parallel/test-stringbytes-external-exceed-max.js
View File

@ -1,23 +1,33 @@
'use strict';
// Flags: --expose-gc
require('../common');
const common = require('../common');
const assert = require('assert');
const skipMessage =
'1..0 # Skipped: intensive toString tests due to memory confinements';
if (!common.enoughTestMem) {
console.log(skipMessage);
return;
}
assert(typeof gc === 'function', 'Run this test with --expose-gc');
// v8 fails silently if string length > v8::String::kMaxLength
// v8::String::kMaxLength defined in v8.h
const kStringMaxLength = process.binding('buffer').kStringMaxLength;
try {
new Buffer(kStringMaxLength * 3);
var buf = new Buffer(kStringMaxLength * 2 + 2);
// Try to allocate memory first then force gc so future allocations succeed.
new Buffer(2 * kStringMaxLength);
gc();
} catch(e) {
assert.equal(e.message, 'Invalid array buffer length');
console.log(
'1..0 # Skipped: intensive toString tests due to memory confinements');
// If the exception is not due to memory confinement then rethrow it.
if (e.message !== 'Invalid array buffer length') throw (e);
console.log(skipMessage);
return;
}
const buf0 = new Buffer(kStringMaxLength * 2 + 2);
assert.throws(function() {
buf0.toString('utf16le');
buf.toString('utf16le');
}, /"toString\(\)" failed/);