| <!DOCTYPE html> |
| <script src="../resources/testharness.js"></script> |
| <script src="../resources/testharnessreport.js"></script> |
| <script> |
| setup(() => { |
| converter = internals.typeConversions(); |
| }); |
| |
| function verifyAttribute(attribute) |
| { |
| assert_true(attribute in converter); |
| assert_equals(typeof converter[attribute], "number"); |
| converter[attribute] = 123; |
| assert_equals(converter[attribute], 123); |
| converter[attribute] = 0; |
| assert_equals(converter[attribute], 0); |
| } |
| |
| function convert(attribute, value, expected) |
| { |
| if (arguments.length < 3) { |
| expected = value; |
| } |
| converter[attribute] = value; |
| assert_equals(converter[attribute], expected); |
| } |
| |
| function testNonNumericToNumeric(attribute) |
| { |
| convert(attribute, false, 0); |
| convert(attribute, true, 1); |
| convert(attribute, '', 0); |
| convert(attribute, '1', 1); |
| convert(attribute, 'abc', 0); |
| convert(attribute, null, 0); |
| convert(attribute, undefined, 0); |
| } |
| |
| function testNonNumericToNumericEnforceRange(attribute) |
| { |
| convert(attribute, false, 0); |
| convert(attribute, true, 1); |
| convert(attribute, '', 0); |
| convert(attribute, '1', 1); |
| assert_throws(new TypeError(), () => { converter[attribute] = 'abc' }); |
| convert(attribute, null, 0); |
| assert_throws(new TypeError(), () => { converter[attribute] = undefined }); |
| } |
| |
| test(() => { |
| type = "testLong"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| convert(type, -0x80); |
| convert(type, -0x81); |
| convert(type, 0x7FFF); |
| convert(type, 0x8000); |
| convert(type, 0xFFFF); |
| convert(type, -0x8000); |
| convert(type, -0x8001); |
| convert(type, 0x7FFFFFFF); |
| convert(type, 0x80000000, -0x80000000); |
| convert(type, 0xFFFFFFFF, -1); |
| convert(type, -0x80000000); |
| convert(type, -0x80000001, 0x7FFFFFFF); |
| convert(type, 0xDCBA9876543210, 0x76543210); |
| convert(type, Number.MAX_VALUE, 0); |
| convert(type, Number.MIN_VALUE, 0); |
| convert(type, -Number.MAX_VALUE, 0); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, -1); |
| convert(type, Infinity, 0); |
| convert(type, -Infinity, 0); |
| convert(type, NaN, 0); |
| testNonNumericToNumeric(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversions of long types"); |
| |
| test(() => { |
| type = "testEnforceRangeLong"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| convert(type, -0x80); |
| convert(type, -0x81); |
| convert(type, 0x7FFF); |
| convert(type, 0x8000); |
| convert(type, 0xFFFF); |
| convert(type, -0x8000); |
| convert(type, -0x8001); |
| convert(type, 0x7FFFFFFF); |
| assert_throws(new TypeError(), () => { converter[type] = 0x80000000 }); |
| assert_throws(new TypeError(), () => { converter[type] = 0xFFFFFFFF }); |
| convert(type, -0x80000000); |
| assert_throws(new TypeError(), () => { converter[type] = 0x80000001 }); |
| assert_throws(new TypeError(), () => { converter[type] = 0xDCBA9876543210 }); |
| assert_throws(new TypeError(), () => { converter[type] = Number.MAX_VALUE }); |
| convert(type, Number.MIN_VALUE, 0); |
| assert_throws(new TypeError(), () => { converter[type] = -Number.MAX_VALUE }); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, -1); |
| assert_throws(new TypeError(), () => { converter[type] = Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = -Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = NaN }); |
| testNonNumericToNumericEnforceRange(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversions of [EnforceRange] long types"); |
| |
| test(() => { |
| type = "testUnsignedLong"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1, 0xFFFFFFFF); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| convert(type, -0x80, 0xFFFFFF80); |
| convert(type, -0x81, 0xFFFFFF7F); |
| convert(type, 0x7FFF); |
| convert(type, 0x8000); |
| convert(type, 0xFFFF); |
| convert(type, -0x8000, 0xFFFF8000); |
| convert(type, -0x8001, 0xFFFF7FFF); |
| convert(type, 0x7FFFFFFF); |
| convert(type, 0x80000000); |
| convert(type, 0xFFFFFFFF); |
| convert(type, -0x80000000, 0x80000000); |
| convert(type, -0x80000001, 0x7FFFFFFF); |
| convert(type, 0xDCBA9876543210, 0x76543210); |
| convert(type, Number.MAX_VALUE, 0); |
| convert(type, Number.MIN_VALUE, 0); |
| convert(type, -Number.MAX_VALUE, 0); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, 0xFFFFFFFF); |
| convert(type, Infinity, 0); |
| convert(type, -Infinity, 0); |
| convert(type, NaN, 0); |
| testNonNumericToNumeric(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversions of unsigned long types"); |
| |
| test(() => { |
| type = "testEnforceRangeUnsignedLong"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| assert_throws(new TypeError(), () => { converter[type] = -1 }); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| assert_throws(new TypeError(), () => { converter[type] = -0x80 }); |
| assert_throws(new TypeError(), () => { converter[type] = -0x81 }); |
| convert(type, 0x7FFF); |
| convert(type, 0x8000); |
| convert(type, 0xFFFF); |
| assert_throws(new TypeError(), () => { converter[type] = -0x8000 }); |
| assert_throws(new TypeError(), () => { converter[type] = -0x8001 }); |
| convert(type, 0x7FFFFFFF); |
| convert(type, 0x80000000); |
| convert(type, 0xFFFFFFFF); |
| assert_throws(new TypeError(), () => { converter[type] = -0x80000000 }); |
| assert_throws(new TypeError(), () => { converter[type] = -0x80000001 }); |
| assert_throws(new TypeError(), () => { converter[type] = 0xDCBA9876543210 }); |
| assert_throws(new TypeError(), () => { converter[type] = Number.MAX_VALUE }); |
| convert(type, Number.MIN_VALUE, 0); |
| assert_throws(new TypeError(), () => { converter[type] = -Number.MAX_VALUE }); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, 1.99, 1); |
| assert_throws(new TypeError(), () => { converter[type] = -1.99 }); |
| assert_throws(new TypeError(), () => { converter[type] = Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = -Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = NaN }); |
| testNonNumericToNumericEnforceRange(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversions of [EnforceRange] unsigned long types"); |
| |
| test(() => { |
| type = "testLongLong"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| convert(type, -0x80); |
| convert(type, -0x81); |
| convert(type, 0x7FFF); |
| convert(type, 0x8000); |
| convert(type, 0xFFFF); |
| convert(type, -0x8000); |
| convert(type, -0x8001); |
| convert(type, 0x7FFFFFFF); |
| convert(type, 0x80000000); |
| convert(type, 0xFFFFFFFF); |
| convert(type, -0x80000000); |
| convert(type, -0x80000001); |
| convert(type, -Math.pow(2, 53) + 1); |
| convert(type, -Math.pow(2, 53)); |
| convert(type, Math.pow(2, 53) - 1); |
| convert(type, Math.pow(2, 53)); |
| convert(type, 0xDCBA9876543210); |
| convert(type, Number.MIN_VALUE, 0); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, Number.MAX_VALUE, 0); |
| convert(type, -Number.MAX_VALUE, 0); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, -1); |
| convert(type, Infinity, 0); |
| convert(type, -Infinity, 0); |
| convert(type, NaN, 0); |
| testNonNumericToNumeric(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversions of long long types"); |
| |
| test(() => { |
| type = "testEnforceRangeLongLong"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| convert(type, -0x80); |
| convert(type, -0x81); |
| convert(type, 0x7FFF); |
| convert(type, 0x8000); |
| convert(type, 0xFFFF); |
| convert(type, -0x8000); |
| convert(type, -0x8001); |
| convert(type, 0x7FFFFFFF); |
| convert(type, 0x80000000); |
| convert(type, 0xFFFFFFFF); |
| convert(type, -0x80000000); |
| convert(type, -0x80000001); |
| convert(type, -Math.pow(2, 53) + 1); |
| assert_throws(new TypeError(), () => { converter[type] = -Math.pow(2, 53) }); |
| convert(type, Math.pow(2, 53) - 1); |
| assert_throws(new TypeError(), () => { converter[type] = Math.pow(2, 53) + 1 }); |
| assert_throws(new TypeError(), () => { converter[type] = 0xDCBA9876543210 }); |
| convert(type, Number.MIN_VALUE, 0); |
| convert(type, -Number.MIN_VALUE, 0); |
| assert_throws(new TypeError(), () => { converter[type] = Number.MAX_VALUE }); |
| assert_throws(new TypeError(), () => { converter[type] = -Number.MAX_VALUE }); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, -1); |
| assert_throws(new TypeError(), () => { converter[type] = Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = -Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = NaN }); |
| testNonNumericToNumericEnforceRange(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversion of [EnforceRange] long long types"); |
| |
| test(() => { |
| type = "testUnsignedLongLong"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1, 0xFFFFFFFFFFFFFFFF); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| convert(type, -0x80, 0xFFFFFFFFFFFFFF80); |
| convert(type, -0x81, 0xFFFFFFFFFFFFFF7F); |
| convert(type, 0x7FFF); |
| convert(type, 0x8000); |
| convert(type, 0xFFFF); |
| convert(type, -0x8000, 0xFFFFFFFFFFFF8000); |
| convert(type, -0x8001, 0xFFFFFFFFFFFF7FFF); |
| convert(type, 0x7FFFFFFF); |
| convert(type, 0x80000000); |
| convert(type, 0xFFFFFFFF); |
| convert(type, -0x80000000, 0xFFFFFFFF80000000); |
| convert(type, -0x80000001, 0xFFFFFFFF7FFFFFFF); |
| convert(type, -Math.pow(2, 53) + 1, Math.pow(2, 64) - Math.pow(2, 53)); |
| convert(type, -Math.pow(2, 53), Math.pow(2, 64) - Math.pow(2, 53)); |
| convert(type, Math.pow(2, 53) - 1); |
| convert(type, Math.pow(2, 53)); |
| convert(type, 0xDCBA9876543210); |
| convert(type, Number.MIN_VALUE, 0); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, Number.MAX_VALUE, 0); |
| convert(type, -Number.MAX_VALUE, 0); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, 0xFFFFFFFFFFFFFFFF); |
| convert(type, Infinity, 0); |
| convert(type, -Infinity, 0); |
| convert(type, NaN, 0); |
| testNonNumericToNumeric(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversion of unsigned long long types"); |
| |
| test(() => { |
| type = "testEnforceRangeUnsignedLongLong"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| assert_throws(new TypeError(), () => { converter[type] = -1 }); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| assert_throws(new TypeError(), () => { converter[type] = -0x80 }); |
| assert_throws(new TypeError(), () => { converter[type] = -0x81 }); |
| convert(type, 0x7FFF); |
| convert(type, 0x8000); |
| convert(type, 0xFFFF); |
| assert_throws(new TypeError(), () => { converter[type] = -0x8000 }); |
| assert_throws(new TypeError(), () => { converter[type] = -0x8001 }); |
| convert(type, 0x7FFFFFFF); |
| convert(type, 0x80000000); |
| convert(type, 0xFFFFFFFF); |
| assert_throws(new TypeError(), () => { converter[type] = -0x80000000 }); |
| assert_throws(new TypeError(), () => { converter[type] = -0x80000001 }); |
| assert_throws(new TypeError(), () => { converter[type] = -Math.pow(2, 53) + 1 }); |
| assert_throws(new TypeError(), () => { converter[type] = -Math.pow(2, 53) }); |
| convert(type, Math.pow(2, 53) - 1); |
| assert_throws(new TypeError(), () => { converter[type] = Math.pow(2, 53) }); |
| assert_throws(new TypeError(), () => { converter[type] = 0xDCBA9876543210 }); |
| convert(type, Number.MIN_VALUE, 0); |
| convert(type, -Number.MIN_VALUE, 0); |
| assert_throws(new TypeError(), () => { converter[type] = Number.MAX_VALUE }); |
| assert_throws(new TypeError(), () => { converter[type] = -Number.MAX_VALUE }); |
| convert(type, 1.99, 1); |
| assert_throws(new TypeError(), () => { converter[type] = -1.99 }); |
| assert_throws(new TypeError(), () => { converter[type] = Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = -Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = NaN }); |
| testNonNumericToNumericEnforceRange(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversion of [EnforceRange] unsigned long long types"); |
| |
| test(() => { |
| type = "testByte"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80, -0x80); |
| convert(type, -0x7F); |
| convert(type, -0x80); |
| convert(type, -0x81, 0x7F); |
| convert(type, 0x1234, 0x34); |
| convert(type, 0xDCBA9876543210, 0x10); |
| convert(type, Number.MIN_VALUE, 0); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, Number.MAX_VALUE, 0); |
| convert(type, -Number.MAX_VALUE, 0); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, -1); |
| convert(type, 4660.99, 0x34); |
| convert(type, Infinity, 0); |
| convert(type, -Infinity, 0); |
| convert(type, NaN, 0); |
| testNonNumericToNumeric(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversion of byte types"); |
| |
| test(() => { |
| type = "testEnforceRangeByte"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1); |
| convert(type, 1); |
| convert(type, 0x7F); |
| assert_throws(new TypeError(), () => { converter[type] = 0x80 }); |
| convert(type, -0x7F); |
| convert(type, -0x80); |
| assert_throws(new TypeError(), () => { converter[type] = -0x81 }); |
| assert_throws(new TypeError(), () => { converter[type] = 0x1234 }); |
| convert(type, Number.MIN_VALUE, 0); |
| convert(type, -Number.MIN_VALUE, 0); |
| assert_throws(new TypeError(), () => { converter[type] = Number.MAX_VALUE }); |
| assert_throws(new TypeError(), () => { converter[type] = -Number.MAX_VALUE }); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, -1); |
| assert_throws(new TypeError(), () => { converter[type] = 4660.99 }); |
| assert_throws(new TypeError(), () => { converter[type] = Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = -Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = NaN }); |
| testNonNumericToNumericEnforceRange(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversion of [EnforceRange] byte types"); |
| |
| test(() => { |
| type = "testOctet"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1, 0xFF); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| convert(type, 0x100, 0); |
| convert(type, 0x101, 1); |
| convert(type, -0x80, 0x80); |
| convert(type, -0x81, 0x7F); |
| convert(type, 0x1234, 0x34); |
| convert(type, 0xDCBA9876543210, 0x10); |
| convert(type, Number.MAX_VALUE, 0); |
| convert(type, Number.MIN_VALUE, 0); |
| convert(type, -Number.MAX_VALUE, 0); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, 0xFF); |
| convert(type, 4660.99, 0x34); |
| convert(type, Infinity, 0); |
| convert(type, -Infinity, 0); |
| convert(type, NaN, 0); |
| testNonNumericToNumeric(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversion of octet types"); |
| |
| test(() => { |
| type = "testEnforceRangeOctet"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| assert_throws(new TypeError(), () => { converter[type] = -1 }); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| assert_throws(new TypeError(), () => { converter[type] = 0x100 }); |
| assert_throws(new TypeError(), () => { converter[type] = 0x101 }); |
| assert_throws(new TypeError(), () => { converter[type] = -0x80 }); |
| assert_throws(new TypeError(), () => { converter[type] = -0x81 }); |
| assert_throws(new TypeError(), () => { converter[type] = 0x1234 }); |
| assert_throws(new TypeError(), () => { converter[type] = Number.MAX_VALUE }); |
| convert(type, Number.MIN_VALUE, 0); |
| assert_throws(new TypeError(), () => { converter[type] = -Number.MAX_VALUE }); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, 1.99, 1); |
| assert_throws(new TypeError(), () => { converter[type] = -1.99 }); |
| assert_throws(new TypeError(), () => { converter[type] = 4660.99 }); |
| assert_throws(new TypeError(), () => { converter[type] = Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = -Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = NaN }); |
| testNonNumericToNumericEnforceRange(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversion of [EnforceRange] octet types"); |
| |
| test(() => { |
| type = "testShort"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| convert(type, -0x80); |
| convert(type, -0x81); |
| convert(type, 0x7FFF); |
| convert(type, 0x8000, -0x8000); |
| convert(type, 0xFFFF, -1); |
| convert(type, -0x8000); |
| convert(type, -0x8001, 0x7FFF); |
| convert(type, 0xDCBA9876543210, 0x3210); |
| convert(type, Number.MAX_VALUE, 0); |
| convert(type, Number.MIN_VALUE, 0); |
| convert(type, -Number.MAX_VALUE, 0); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, -1); |
| convert(type, Infinity, 0); |
| convert(type, -Infinity, 0); |
| convert(type, NaN, 0); |
| testNonNumericToNumeric(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversion of short types"); |
| |
| test(() => { |
| type = "testEnforceRangeShort"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| convert(type, -0x80); |
| convert(type, -0x81); |
| convert(type, 0x7FFF); |
| assert_throws(new TypeError(), () => { converter[type] = 0x8000 }); |
| assert_throws(new TypeError(), () => { converter[type] = 0xFFFF }); |
| convert(type, -0x8000); |
| assert_throws(new TypeError(), () => { converter[type] = -0x8001 }); |
| assert_throws(new TypeError(), () => { converter[type] = 0xDCBA9876543210 }); |
| assert_throws(new TypeError(), () => { converter[type] = Number.MAX_VALUE }); |
| convert(type, Number.MIN_VALUE, 0); |
| assert_throws(new TypeError(), () => { converter[type] = -Number.MAX_VALUE }); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, -1); |
| assert_throws(new TypeError(), () => { converter[type] = Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = -Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = NaN }); |
| testNonNumericToNumericEnforceRange(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversion of [EnforceRange] short types"); |
| |
| test(() => { |
| type = "testUnsignedShort"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| convert(type, -1, 0xFFFF); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| convert(type, -0x80, 0xFF80); |
| convert(type, -0x81, 0xFF7F); |
| convert(type, 0x7FFF); |
| convert(type, 0x8000); |
| convert(type, 0xFFFF); |
| convert(type, 0x10000, 0); |
| convert(type, -0x8000, 0x8000); |
| convert(type, -0x8001, 0x7FFF); |
| convert(type, 0xDCBA9876543210, 0x3210); |
| convert(type, Number.MAX_VALUE, 0); |
| convert(type, Number.MIN_VALUE, 0); |
| convert(type, -Number.MAX_VALUE, 0); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, 1.99, 1); |
| convert(type, -1.99, 0xFFFF); |
| convert(type, Infinity, 0); |
| convert(type, -Infinity, 0); |
| convert(type, NaN, 0); |
| testNonNumericToNumeric(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversion of unsigned short types"); |
| |
| test(() => { |
| type = "testEnforceRangeUnsignedShort"; |
| verifyAttribute(type); |
| convert(type, 0); |
| convert(type, -0, 0); |
| assert_throws(new TypeError(), () => { converter[type] = -1 }); |
| convert(type, 1); |
| convert(type, 0x7F); |
| convert(type, 0x80); |
| convert(type, 0xFF); |
| assert_throws(new TypeError(), () => { converter[type] = -0x80 }); |
| assert_throws(new TypeError(), () => { converter[type] = -0x81 }); |
| convert(type, 0x7FFF); |
| convert(type, 0x8000); |
| convert(type, 0xFFFF); |
| assert_throws(new TypeError(), () => { converter[type] = 0x10000 }); |
| assert_throws(new TypeError(), () => { converter[type] = -0x8000 }); |
| assert_throws(new TypeError(), () => { converter[type] = -0x8001 }); |
| convert(type, 0x3210); |
| assert_throws(new TypeError(), () => { converter[type] = Number.MAX_VALUE }); |
| convert(type, Number.MIN_VALUE, 0); |
| assert_throws(new TypeError(), () => { converter[type] = -Number.MAX_VALUE }); |
| convert(type, -Number.MIN_VALUE, 0); |
| convert(type, 1.99, 1); |
| assert_throws(new TypeError(), () => { converter[type] = -1.99 }); |
| assert_throws(new TypeError(), () => { converter[type] = Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = -Infinity }); |
| assert_throws(new TypeError(), () => { converter[type] = NaN }); |
| testNonNumericToNumericEnforceRange(type); |
| assert_throws(new Error(), () => { |
| converter[type] = { |
| valueOf: () => { throw new Error('custom') } |
| } |
| }); |
| }, "Test conversion of [EnforceRange] unsigned short types"); |
| |
| test(() => { |
| converter.testByteString = '!@#123ABCabc\x00\x80\xFF\r\n\t'; |
| assert_equals(converter.testByteString, "!@#123ABCabc\x00\x80\xFF\r\n\t"); |
| assert_throws(new TypeError(), () => { converter.testByteString = '\u0100' }); |
| assert_throws(new Error(), () => { |
| converter.testByteString = { |
| toString: () => { throw Error() } |
| } |
| }); |
| assert_equals(converter.testByteString, "!@#123ABCabc\x00\x80\xFF\r\n\t"); |
| |
| [{input: true, expected: "true"}, |
| {input: 123, expected: "123"}, |
| {input: null, expected: "null"}, |
| {input: undefined, expected: "undefined"}].forEach(function(test) { |
| converter.testByteString = test.input; |
| assert_equals(converter.testByteString, test.expected); |
| }); |
| converter.setTestByteString('abc'); |
| converter.setTestByteStringDefaultNull('abc'); |
| assert_throws(new TypeError(), () => { converter.setTestByteString('\u0100') }); |
| assert_throws(new TypeError(), () => { converter.setTestByteStringDefaultNull('\u0100') }); |
| assert_throws(new TypeError(), () => { converter.setTestByteString() }); |
| converter.setTestByteStringDefaultNull(); |
| assert_equals(converter.testByteString, ""); |
| }, "Test conversion of ByteString types"); |
| |
| test(() => { |
| converter.testUSVString = '!@#123ABCabc\x00\x80\xFF\r\n\t'; |
| assert_equals(converter.testUSVString, "!@#123ABCabc\x00\x80\xFF\r\n\t"); |
| converter.testUSVString = '\u0100'; |
| assert_equals(converter.testUSVString, "\u0100"); |
| assert_throws(new Error(), () => { |
| converter.testUSVString = { |
| toString: () => { throw Error() } |
| } |
| }); |
| assert_equals(converter.testUSVString, "\u0100"); |
| [{input: "\uD800", expected: "\uFFFD"}, |
| {input: "\uDC00", expected: "\uFFFD"}, |
| {input: "\uD800\u0000", expected: "\uFFFD\u0000"}, |
| {input: "\uDC00\u0000", expected: "\uFFFD\u0000"}, |
| {input: "\uDC00\uD800", expected: "\uFFFD\uFFFD"}, |
| {input: "\uD834\uDD1E", expected: "\uD834\uDD1E"}, |
| ].forEach(function(test) { |
| converter.testUSVString = test.input; |
| assert_equals(converter.testUSVString, test.expected); |
| }); |
| [{input: true, expected: "true"}, |
| {input: 123, expected: "123"}, |
| {input: null, expected: "null"}, |
| {input: undefined, expected: "undefined"}].forEach(function(test) { |
| converter.testUSVString = test.input; |
| assert_equals(converter.testUSVString, test.expected); |
| }); |
| converter.setTestUSVString('abc'); |
| converter.setTestUSVStringDefaultNull('abc'); |
| converter.setTestUSVString('\u0100'); |
| converter.setTestUSVStringDefaultNull('\u0100'); |
| assert_throws(new TypeError(), () => { converter.setTestUSVString() }); |
| converter.setTestUSVStringDefaultNull(); |
| assert_equals(converter.testUSVString, ""); |
| }, "Test conversion of USVString types"); |
| |
| test(() => { |
| [{input: 123, expected: "123"}, |
| {input: true, expected: "true"}, |
| {input: false, expected: "false"}].forEach(function(test) { |
| converter.testUSVStringOrNull = test.input; |
| assert_equals(converter.testUSVStringOrNull, test.expected); |
| }); |
| [null, undefined].forEach(function(value) { |
| converter.testUSVStringOrNull = value; |
| assert_equals(converter.testUSVStringOrNull, null); |
| |
| // Assign a random string to ensure the function call below really has an |
| // effect. |
| converter.testUSVStringOrNull = 'dummy'; |
| |
| converter.setTestUSVStringOrNull(value); |
| assert_equals(converter.testUSVStringOrNull, null); |
| }); |
| }, "Test conversion of nullable USVString types"); |
| </script> |
