| Index: third_party/WebKit/LayoutTests/imported/web-platform-tests/html/webappapis/atob/base64.html
|
| diff --git a/third_party/WebKit/LayoutTests/imported/web-platform-tests/html/webappapis/atob/base64.html b/third_party/WebKit/LayoutTests/imported/web-platform-tests/html/webappapis/atob/base64.html
|
| deleted file mode 100644
|
| index 9f81076157362e415a81a5dac787410da8fe74bf..0000000000000000000000000000000000000000
|
| --- a/third_party/WebKit/LayoutTests/imported/web-platform-tests/html/webappapis/atob/base64.html
|
| +++ /dev/null
|
| @@ -1,306 +0,0 @@
|
| -<!doctype html>
|
| -<!-- Originally developed by Aryeh Gregor, funded by Google. Copyright belongs
|
| -to Google. -->
|
| -<title>atob()/btoa() tests</title>
|
| -<meta charset=utf-8>
|
| -<div id=log></div>
|
| -<script src=../../../../../resources/testharness.js></script>
|
| -<script src=../../../../../resources/testharnessreport.js></script>
|
| -<script>
|
| -/**
|
| - * btoa() as defined by the HTML5 spec, which mostly just references RFC4648.
|
| - */
|
| -function mybtoa(s) {
|
| - // String conversion as required by WebIDL.
|
| - s = String(s);
|
| -
|
| - // "The btoa() method must throw an INVALID_CHARACTER_ERR exception if the
|
| - // method's first argument contains any character whose code point is
|
| - // greater than U+00FF."
|
| - for (var i = 0; i < s.length; i++) {
|
| - if (s.charCodeAt(i) > 255) {
|
| - return "INVALID_CHARACTER_ERR";
|
| - }
|
| - }
|
| -
|
| - var out = "";
|
| - for (var i = 0; i < s.length; i += 3) {
|
| - var groupsOfSix = [undefined, undefined, undefined, undefined];
|
| - groupsOfSix[0] = s.charCodeAt(i) >> 2;
|
| - groupsOfSix[1] = (s.charCodeAt(i) & 0x03) << 4;
|
| - if (s.length > i + 1) {
|
| - groupsOfSix[1] |= s.charCodeAt(i + 1) >> 4;
|
| - groupsOfSix[2] = (s.charCodeAt(i + 1) & 0x0f) << 2;
|
| - }
|
| - if (s.length > i + 2) {
|
| - groupsOfSix[2] |= s.charCodeAt(i + 2) >> 6;
|
| - groupsOfSix[3] = s.charCodeAt(i + 2) & 0x3f;
|
| - }
|
| - for (var j = 0; j < groupsOfSix.length; j++) {
|
| - if (typeof groupsOfSix[j] == "undefined") {
|
| - out += "=";
|
| - } else {
|
| - out += btoaLookup(groupsOfSix[j]);
|
| - }
|
| - }
|
| - }
|
| - return out;
|
| -}
|
| -
|
| -/**
|
| - * Lookup table for mybtoa(), which converts a six-bit number into the
|
| - * corresponding ASCII character.
|
| - */
|
| -function btoaLookup(idx) {
|
| - if (idx < 26) {
|
| - return String.fromCharCode(idx + 'A'.charCodeAt(0));
|
| - }
|
| - if (idx < 52) {
|
| - return String.fromCharCode(idx - 26 + 'a'.charCodeAt(0));
|
| - }
|
| - if (idx < 62) {
|
| - return String.fromCharCode(idx - 52 + '0'.charCodeAt(0));
|
| - }
|
| - if (idx == 62) {
|
| - return '+';
|
| - }
|
| - if (idx == 63) {
|
| - return '/';
|
| - }
|
| - // Throw INVALID_CHARACTER_ERR exception here -- won't be hit in the tests.
|
| -}
|
| -
|
| -/**
|
| - * Implementation of atob() according to the HTML spec, except that instead of
|
| - * throwing INVALID_CHARACTER_ERR we return null.
|
| - */
|
| -function myatob(input) {
|
| - // WebIDL requires DOMStrings to just be converted using ECMAScript
|
| - // ToString, which in our case amounts to calling String().
|
| - input = String(input);
|
| -
|
| - // "Remove all space characters from input."
|
| - input = input.replace(/[ \t\n\f\r]/g, "");
|
| -
|
| - // "If the length of input divides by 4 leaving no remainder, then: if
|
| - // input ends with one or two U+003D EQUALS SIGN (=) characters, remove
|
| - // them from input."
|
| - if (input.length % 4 == 0 && /==?$/.test(input)) {
|
| - input = input.replace(/==?$/, "");
|
| - }
|
| -
|
| - // "If the length of input divides by 4 leaving a remainder of 1, throw an
|
| - // INVALID_CHARACTER_ERR exception and abort these steps."
|
| - //
|
| - // "If input contains a character that is not in the following list of
|
| - // characters and character ranges, throw an INVALID_CHARACTER_ERR
|
| - // exception and abort these steps:
|
| - //
|
| - // U+002B PLUS SIGN (+)
|
| - // U+002F SOLIDUS (/)
|
| - // U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9)
|
| - // U+0041 LATIN CAPITAL LETTER A to U+005A LATIN CAPITAL LETTER Z
|
| - // U+0061 LATIN SMALL LETTER A to U+007A LATIN SMALL LETTER Z"
|
| - if (input.length % 4 == 1
|
| - || !/^[+/0-9A-Za-z]*$/.test(input)) {
|
| - return null;
|
| - }
|
| -
|
| - // "Let output be a string, initially empty."
|
| - var output = "";
|
| -
|
| - // "Let buffer be a buffer that can have bits appended to it, initially
|
| - // empty."
|
| - //
|
| - // We append bits via left-shift and or. accumulatedBits is used to track
|
| - // when we've gotten to 24 bits.
|
| - var buffer = 0;
|
| - var accumulatedBits = 0;
|
| -
|
| - // "While position does not point past the end of input, run these
|
| - // substeps:"
|
| - for (var i = 0; i < input.length; i++) {
|
| - // "Find the character pointed to by position in the first column of
|
| - // the following table. Let n be the number given in the second cell of
|
| - // the same row."
|
| - //
|
| - // "Append to buffer the six bits corresponding to number, most
|
| - // significant bit first."
|
| - //
|
| - // atobLookup() implements the table from the spec.
|
| - buffer <<= 6;
|
| - buffer |= atobLookup(input[i]);
|
| -
|
| - // "If buffer has accumulated 24 bits, interpret them as three 8-bit
|
| - // big-endian numbers. Append the three characters with code points
|
| - // equal to those numbers to output, in the same order, and then empty
|
| - // buffer."
|
| - accumulatedBits += 6;
|
| - if (accumulatedBits == 24) {
|
| - output += String.fromCharCode((buffer & 0xff0000) >> 16);
|
| - output += String.fromCharCode((buffer & 0xff00) >> 8);
|
| - output += String.fromCharCode(buffer & 0xff);
|
| - buffer = accumulatedBits = 0;
|
| - }
|
| -
|
| - // "Advance position by one character."
|
| - }
|
| -
|
| - // "If buffer is not empty, it contains either 12 or 18 bits. If it
|
| - // contains 12 bits, discard the last four and interpret the remaining
|
| - // eight as an 8-bit big-endian number. If it contains 18 bits, discard the
|
| - // last two and interpret the remaining 16 as two 8-bit big-endian numbers.
|
| - // Append the one or two characters with code points equal to those one or
|
| - // two numbers to output, in the same order."
|
| - if (accumulatedBits == 12) {
|
| - buffer >>= 4;
|
| - output += String.fromCharCode(buffer);
|
| - } else if (accumulatedBits == 18) {
|
| - buffer >>= 2;
|
| - output += String.fromCharCode((buffer & 0xff00) >> 8);
|
| - output += String.fromCharCode(buffer & 0xff);
|
| - }
|
| -
|
| - // "Return output."
|
| - return output;
|
| -}
|
| -
|
| -/**
|
| - * A lookup table for atob(), which converts an ASCII character to the
|
| - * corresponding six-bit number.
|
| - */
|
| -function atobLookup(chr) {
|
| - if (/[A-Z]/.test(chr)) {
|
| - return chr.charCodeAt(0) - "A".charCodeAt(0);
|
| - }
|
| - if (/[a-z]/.test(chr)) {
|
| - return chr.charCodeAt(0) - "a".charCodeAt(0) + 26;
|
| - }
|
| - if (/[0-9]/.test(chr)) {
|
| - return chr.charCodeAt(0) - "0".charCodeAt(0) + 52;
|
| - }
|
| - if (chr == "+") {
|
| - return 62;
|
| - }
|
| - if (chr == "/") {
|
| - return 63;
|
| - }
|
| - // Throw exception; should not be hit in tests
|
| -}
|
| -
|
| -function btoaException(input) {
|
| - input = String(input);
|
| - for (var i = 0; i < input.length; i++) {
|
| - if (input.charCodeAt(i) > 255) {
|
| - return true;
|
| - }
|
| - }
|
| - return false;
|
| -}
|
| -
|
| -function testBtoa(input) {
|
| - // "The btoa() method must throw an INVALID_CHARACTER_ERR exception if the
|
| - // method's first argument contains any character whose code point is
|
| - // greater than U+00FF."
|
| - var normalizedInput = String(input);
|
| - for (var i = 0; i < normalizedInput.length; i++) {
|
| - if (normalizedInput.charCodeAt(i) > 255) {
|
| - assert_throws("InvalidCharacterError", function() { btoa(input); },
|
| - "Code unit " + i + " has value " + normalizedInput.charCodeAt(i) + ", which is greater than 255");
|
| - return;
|
| - }
|
| - }
|
| - assert_equals(btoa(input), mybtoa(input));
|
| - assert_equals(atob(btoa(input)), String(input), "atob(btoa(input)) must be the same as String(input)");
|
| -}
|
| -
|
| -var tests = ["עברית", "", "ab", "abc", "abcd", "abcde",
|
| - // This one is thrown in because IE9 seems to fail atob(btoa()) on it. Or
|
| - // possibly to fail btoa(). I actually can't tell what's happening here,
|
| - // but it doesn't hurt.
|
| - "\xff\xff\xc0",
|
| - // Is your DOM implementation binary-safe?
|
| - "\0a", "a\0b",
|
| - // WebIDL tests.
|
| - undefined, null, 7, 12, 1.5, true, false, NaN, +Infinity, -Infinity, 0, -0,
|
| - {toString: function() { return "foo" }},
|
| -];
|
| -for (var i = 0; i < 258; i++) {
|
| - tests.push(String.fromCharCode(i));
|
| -}
|
| -tests.push(String.fromCharCode(10000));
|
| -tests.push(String.fromCharCode(65534));
|
| -tests.push(String.fromCharCode(65535));
|
| -
|
| -// This is supposed to be U+10000.
|
| -tests.push(String.fromCharCode(0xd800, 0xdc00));
|
| -tests = tests.map(
|
| - function(elem) {
|
| - var expected = mybtoa(elem);
|
| - if (expected === "INVALID_CHARACTER_ERR") {
|
| - return ["btoa(" + format_value(elem) + ") must raise INVALID_CHARACTER_ERR", elem];
|
| - }
|
| - return ["btoa(" + format_value(elem) + ") == " + format_value(mybtoa(elem)), elem];
|
| - }
|
| -);
|
| -
|
| -var everything = "";
|
| -for (var i = 0; i < 256; i++) {
|
| - everything += String.fromCharCode(i);
|
| -}
|
| -tests.push(["btoa(first 256 code points concatenated)", everything]);
|
| -
|
| -generate_tests(testBtoa, tests);
|
| -
|
| -function testAtob(input) {
|
| - var expected = myatob(input);
|
| - if (expected === null) {
|
| - assert_throws("InvalidCharacterError", function() { atob(input) });
|
| - return;
|
| - }
|
| -
|
| - assert_equals(atob(input), expected);
|
| -}
|
| -
|
| -var tests = ["", "abcd", " abcd", "abcd ", " abcd===", "abcd=== ",
|
| - "abcd ===", "a", "ab", "abc", "abcde", String.fromCharCode(0xd800, 0xdc00),
|
| - "=", "==", "===", "====", "=====",
|
| - "a=", "a==", "a===", "a====", "a=====",
|
| - "ab=", "ab==", "ab===", "ab====", "ab=====",
|
| - "abc=", "abc==", "abc===", "abc====", "abc=====",
|
| - "abcd=", "abcd==", "abcd===", "abcd====", "abcd=====",
|
| - "abcde=", "abcde==", "abcde===", "abcde====", "abcde=====",
|
| - "=a", "=a=", "a=b", "a=b=", "ab=c", "ab=c=", "abc=d", "abc=d=",
|
| - // With whitespace
|
| - "ab\tcd", "ab\ncd", "ab\fcd", "ab\rcd", "ab cd", "ab\u00a0cd",
|
| - "ab\t\n\f\r cd", " \t\n\f\r ab\t\n\f\r cd\t\n\f\r ",
|
| - "ab\t\n\f\r =\t\n\f\r =\t\n\f\r ",
|
| - // Test if any bits are set at the end. These should all be fine, since
|
| - // they end with A, which becomes 0:
|
| - "A", "/A", "//A", "///A", "////A",
|
| - // These are all bad, since they end in / (= 63, all bits set) but their
|
| - // length isn't a multiple of four characters, so they can't be output by
|
| - // btoa(). Thus one might expect some UAs to throw exceptions or otherwise
|
| - // object, since they could never be output by btoa(), so they're good to
|
| - // test.
|
| - "/", "A/", "AA/", "AAAA/",
|
| - // But this one is possible:
|
| - "AAA/",
|
| - // Binary-safety tests
|
| - "\0nonsense", "abcd\0nonsense",
|
| - // WebIDL tests
|
| - undefined, null, 7, 12, 1.5, true, false, NaN, +Infinity, -Infinity, 0, -0,
|
| - {toString: function() { return "foo" }},
|
| - {toString: function() { return "abcd" }},
|
| -];
|
| -tests = tests.map(
|
| - function(elem) {
|
| - if (myatob(elem) === null) {
|
| - return ["atob(" + format_value(elem) + ") must raise InvalidCharacterError", elem];
|
| - }
|
| - return ["atob(" + format_value(elem) + ") == " + format_value(myatob(elem)), elem];
|
| - }
|
| -);
|
| -
|
| -generate_tests(testAtob, tests);
|
| -</script>
|
|
|