headers-basic.any.js (9106B)
1 // META: title=Headers structure 2 // META: global=window,worker 3 4 "use strict"; 5 6 test(function() { 7 new Headers(); 8 }, "Create headers from no parameter"); 9 10 test(function() { 11 new Headers(undefined); 12 }, "Create headers from undefined parameter"); 13 14 test(function() { 15 new Headers({}); 16 }, "Create headers from empty object"); 17 18 var parameters = [null, 1]; 19 parameters.forEach(function(parameter) { 20 test(function() { 21 assert_throws_js(TypeError, function() { new Headers(parameter) }); 22 }, "Create headers with " + parameter + " should throw"); 23 }); 24 25 var headerDict = {"name1": "value1", 26 "name2": "value2", 27 "name3": "value3", 28 "name4": null, 29 "name5": undefined, 30 "name6": 1, 31 "Content-Type": "value4" 32 }; 33 34 var headerSeq = []; 35 for (var name in headerDict) 36 headerSeq.push([name, headerDict[name]]); 37 38 test(function() { 39 var headers = new Headers(headerSeq); 40 for (name in headerDict) { 41 assert_equals(headers.get(name), String(headerDict[name]), 42 "name: " + name + " has value: " + headerDict[name]); 43 } 44 assert_equals(headers.get("length"), null, "init should be treated as a sequence, not as a dictionary"); 45 }, "Create headers with sequence"); 46 47 test(function() { 48 var headers = new Headers(headerDict); 49 for (name in headerDict) { 50 assert_equals(headers.get(name), String(headerDict[name]), 51 "name: " + name + " has value: " + headerDict[name]); 52 } 53 }, "Create headers with record"); 54 55 test(function() { 56 var headers = new Headers(headerDict); 57 var headers2 = new Headers(headers); 58 for (name in headerDict) { 59 assert_equals(headers2.get(name), String(headerDict[name]), 60 "name: " + name + " has value: " + headerDict[name]); 61 } 62 }, "Create headers with existing headers"); 63 64 test(function() { 65 var headers = new Headers() 66 headers[Symbol.iterator] = function *() { 67 yield ["test", "test"] 68 } 69 var headers2 = new Headers(headers) 70 assert_equals(headers2.get("test"), "test") 71 }, "Create headers with existing headers with custom iterator"); 72 73 test(function() { 74 var headers = new Headers(); 75 for (name in headerDict) { 76 headers.append(name, headerDict[name]); 77 assert_equals(headers.get(name), String(headerDict[name]), 78 "name: " + name + " has value: " + headerDict[name]); 79 } 80 }, "Check append method"); 81 82 test(function() { 83 var headers = new Headers(); 84 for (name in headerDict) { 85 headers.set(name, headerDict[name]); 86 assert_equals(headers.get(name), String(headerDict[name]), 87 "name: " + name + " has value: " + headerDict[name]); 88 } 89 }, "Check set method"); 90 91 test(function() { 92 var headers = new Headers(headerDict); 93 for (name in headerDict) 94 assert_true(headers.has(name),"headers has name " + name); 95 96 assert_false(headers.has("nameNotInHeaders"),"headers do not have header: nameNotInHeaders"); 97 }, "Check has method"); 98 99 test(function() { 100 var headers = new Headers(headerDict); 101 for (name in headerDict) { 102 assert_true(headers.has(name),"headers have a header: " + name); 103 headers.delete(name) 104 assert_true(!headers.has(name),"headers do not have anymore a header: " + name); 105 } 106 }, "Check delete method"); 107 108 test(function() { 109 var headers = new Headers(headerDict); 110 for (name in headerDict) 111 assert_equals(headers.get(name), String(headerDict[name]), 112 "name: " + name + " has value: " + headerDict[name]); 113 114 assert_equals(headers.get("nameNotInHeaders"), null, "header: nameNotInHeaders has no value"); 115 }, "Check get method"); 116 117 var headerEntriesDict = {"name1": "value1", 118 "Name2": "value2", 119 "name": "value3", 120 "content-Type": "value4", 121 "Content-Typ": "value5", 122 "Content-Types": "value6" 123 }; 124 var sortedHeaderDict = {}; 125 var headerValues = []; 126 var sortedHeaderKeys = Object.keys(headerEntriesDict).map(function(value) { 127 sortedHeaderDict[value.toLowerCase()] = headerEntriesDict[value]; 128 headerValues.push(headerEntriesDict[value]); 129 return value.toLowerCase(); 130 }).sort(); 131 132 var iteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())); 133 function checkIteratorProperties(iterator) { 134 var prototype = Object.getPrototypeOf(iterator); 135 assert_equals(Object.getPrototypeOf(prototype), iteratorPrototype); 136 137 var descriptor = Object.getOwnPropertyDescriptor(prototype, "next"); 138 assert_true(descriptor.configurable, "configurable"); 139 assert_true(descriptor.enumerable, "enumerable"); 140 assert_true(descriptor.writable, "writable"); 141 } 142 143 test(function() { 144 var headers = new Headers(headerEntriesDict); 145 var actual = headers.keys(); 146 checkIteratorProperties(actual); 147 148 sortedHeaderKeys.forEach(function(key) { 149 const entry = actual.next(); 150 assert_false(entry.done); 151 assert_equals(entry.value, key); 152 }); 153 assert_true(actual.next().done); 154 assert_true(actual.next().done); 155 156 for (const key of headers.keys()) 157 assert_true(sortedHeaderKeys.indexOf(key) != -1); 158 }, "Check keys method"); 159 160 test(function() { 161 var headers = new Headers(headerEntriesDict); 162 var actual = headers.values(); 163 checkIteratorProperties(actual); 164 165 sortedHeaderKeys.forEach(function(key) { 166 const entry = actual.next(); 167 assert_false(entry.done); 168 assert_equals(entry.value, sortedHeaderDict[key]); 169 }); 170 assert_true(actual.next().done); 171 assert_true(actual.next().done); 172 173 for (const value of headers.values()) 174 assert_true(headerValues.indexOf(value) != -1); 175 }, "Check values method"); 176 177 test(function() { 178 var headers = new Headers(headerEntriesDict); 179 var actual = headers.entries(); 180 checkIteratorProperties(actual); 181 182 sortedHeaderKeys.forEach(function(key) { 183 const entry = actual.next(); 184 assert_false(entry.done); 185 assert_equals(entry.value[0], key); 186 assert_equals(entry.value[1], sortedHeaderDict[key]); 187 }); 188 assert_true(actual.next().done); 189 assert_true(actual.next().done); 190 191 for (const entry of headers.entries()) 192 assert_equals(entry[1], sortedHeaderDict[entry[0]]); 193 }, "Check entries method"); 194 195 test(function() { 196 var headers = new Headers(headerEntriesDict); 197 var actual = headers[Symbol.iterator](); 198 199 sortedHeaderKeys.forEach(function(key) { 200 const entry = actual.next(); 201 assert_false(entry.done); 202 assert_equals(entry.value[0], key); 203 assert_equals(entry.value[1], sortedHeaderDict[key]); 204 }); 205 assert_true(actual.next().done); 206 assert_true(actual.next().done); 207 }, "Check Symbol.iterator method"); 208 209 test(function() { 210 var headers = new Headers(headerEntriesDict); 211 var reference = sortedHeaderKeys[Symbol.iterator](); 212 headers.forEach(function(value, key, container) { 213 assert_equals(headers, container); 214 const entry = reference.next(); 215 assert_false(entry.done); 216 assert_equals(key, entry.value); 217 assert_equals(value, sortedHeaderDict[entry.value]); 218 }); 219 assert_true(reference.next().done); 220 }, "Check forEach method"); 221 222 test(() => { 223 const headers = new Headers({"foo": "2", "baz": "1", "BAR": "0"}); 224 const actualKeys = []; 225 const actualValues = []; 226 for (const [header, value] of headers) { 227 actualKeys.push(header); 228 actualValues.push(value); 229 headers.delete("foo"); 230 } 231 assert_array_equals(actualKeys, ["bar", "baz"]); 232 assert_array_equals(actualValues, ["0", "1"]); 233 }, "Iteration skips elements removed while iterating"); 234 235 test(() => { 236 const headers = new Headers({"foo": "2", "baz": "1", "BAR": "0", "quux": "3"}); 237 const actualKeys = []; 238 const actualValues = []; 239 for (const [header, value] of headers) { 240 actualKeys.push(header); 241 actualValues.push(value); 242 if (header === "baz") 243 headers.delete("bar"); 244 } 245 assert_array_equals(actualKeys, ["bar", "baz", "quux"]); 246 assert_array_equals(actualValues, ["0", "1", "3"]); 247 }, "Removing elements already iterated over causes an element to be skipped during iteration"); 248 249 test(() => { 250 const headers = new Headers({"foo": "2", "baz": "1", "BAR": "0", "quux": "3"}); 251 const actualKeys = []; 252 const actualValues = []; 253 for (const [header, value] of headers) { 254 actualKeys.push(header); 255 actualValues.push(value); 256 if (header === "baz") 257 headers.append("X-yZ", "4"); 258 } 259 assert_array_equals(actualKeys, ["bar", "baz", "foo", "quux", "x-yz"]); 260 assert_array_equals(actualValues, ["0", "1", "2", "3", "4"]); 261 }, "Appending a value pair during iteration causes it to be reached during iteration"); 262 263 test(() => { 264 const headers = new Headers({"foo": "2", "baz": "1", "BAR": "0", "quux": "3"}); 265 const actualKeys = []; 266 const actualValues = []; 267 for (const [header, value] of headers) { 268 actualKeys.push(header); 269 actualValues.push(value); 270 if (header === "baz") 271 headers.append("abc", "-1"); 272 } 273 assert_array_equals(actualKeys, ["bar", "baz", "baz", "foo", "quux"]); 274 assert_array_equals(actualValues, ["0", "1", "1", "2", "3"]); 275 }, "Prepending a value pair before the current element position causes it to be skipped during iteration and adds the current element a second time");