if (self.importScripts) {
  importScripts('../resources/fetch-test-helpers.js');
}

// Tests that invalid names/values throw TypeError.
function testInvalidNamesAndValues(headers) {
  INVALID_HEADER_NAMES.forEach(function(name) {
      assert_throws_js(TypeError,
                       function() { headers.append(name, 'a'); },
                       'Headers.append with an invalid name (' + name +
                       ') must throw');
      assert_throws_js(TypeError,
                       function() { headers.delete(name); },
                       'Headers.delete with an invalid name (' + name +
                       ') must throw');
      assert_throws_js(TypeError,
                       function() { headers.get(name); },
                       'Headers.get with an invalid name (' + name +
                       ') must throw');
      assert_throws_js(TypeError,
                       function() { headers.getAll(name); },
                       'Headers.getAll with an invalid name (' + name +
                       ') must throw');
      assert_throws_js(TypeError,
                       function() { headers.has(name); },
                       'Headers.has with an invalid name (' + name +
                       ') must throw');
      assert_throws_js(TypeError,
                       function() { headers.set(name, 'a'); },
                       'Headers.set with an invalid name (' + name +
                       ') must throw');
    });
  INVALID_HEADER_VALUES.forEach(function(value) {
      assert_throws_js(TypeError,
                       function() { headers.append('a', value); },
                       'Headers.append with an invalid value must throw');
      assert_throws_js(TypeError,
                       function() { headers.set('a', value); },
                       'Headers.set with an invalid value must throw');
    });
}

// Tests that |header| is append()ed to/set() to/delete()d from |headers|.
function testAcceptHeaderName(headers, header) {
  headers.append(header, 'test');
  assert_equals(headers.get(header), 'test',
                header + ' must be append()ed.');

  headers.set(header, 'test2');
  assert_equals(headers.get(header), 'test2',
                header + ' must be overwritten by set().');

  headers.delete(header);
  assert_equals(headers.get(header), null,
                header + ' must be delete()d.');

  headers.set(header, 'test3');
  assert_equals(headers.get(header), 'test3',
                header + ' must be created by set().');

  headers.delete(header);
  assert_equals(headers.get(header), null,
                header + ' must be delete()d.');
}

// Tests that |header| is ignored in append()/set()/delete() of |headers|.
function testIgnoreHeaderName(headers, header) {
  headers.append(header, 'test');
  assert_equals(headers.get(header), null,
                header + ' must be ignored in append().');

  headers.set(header, 'test2');
  assert_equals(headers.get(header), null,
                header + ' must be ignored in set().');

  // Calling delete() does not crash nor throw an exception.
  headers.delete(header);
}

test(function() {
    [new Headers(),
     new Headers((new Request(URL, {mode: 'same-origin'})).headers),
     new Headers((new Response()).headers)]
      .forEach(function(headers) {
          testInvalidNamesAndValues(headers);

          FORBIDDEN_HEADER_NAMES
            .concat(FORBIDDEN_RESPONSE_HEADER_NAMES)
            .concat(SIMPLE_HEADER_NAMES)
            .concat([CONTENT_TYPE])
            .concat(NON_SIMPLE_HEADER_NAMES)
            .forEach(function(header) {
                testAcceptHeaderName(headers, header);
              });
        });
  }, 'Headers guard = none: set/append/delete');

test(function() {
    FORBIDDEN_HEADER_NAMES
      .concat(FORBIDDEN_RESPONSE_HEADER_NAMES)
      .concat(SIMPLE_HEADER_NAMES)
      .concat([CONTENT_TYPE])
      .concat(NON_SIMPLE_HEADER_NAMES)
      .forEach(function(header) {
          var headers = new Headers([[header, 'test']]);
          assert_equals(headers.get(header), 'test',
                        header + ' must be set (1)');
          var headers2 = new Headers(headers);
          assert_equals(headers2.get(header), 'test',
                        header + ' must be set (2)');
      });
  }, 'Headers guard = none: Headers constructor');

test(function() {
    [(new Request(URL, {mode: 'same-origin'})).headers,
     (new Request(URL, {mode: 'same-origin'})).clone().headers,
     (new Request(URL, {mode: 'cors'})).headers,
     (new Request(URL, {mode: 'cors'})).clone().headers]
      .forEach(function(headers) {
          testInvalidNamesAndValues(headers);

          // Forbidden header names must be ignored.
          FORBIDDEN_HEADER_NAMES
            .forEach(function(header) {
                testIgnoreHeaderName(headers, header);
              });

          // Other header names must be accepted.
          FORBIDDEN_RESPONSE_HEADER_NAMES
            .concat(SIMPLE_HEADER_NAMES)
            .concat([CONTENT_TYPE])
            .concat(NON_SIMPLE_HEADER_NAMES)
            .forEach(function(header) {
                testAcceptHeaderName(headers, header);
              });
        });
  }, 'Headers guard = request: set/append/delete');

test(function() {
    ['same-origin', 'cors'].forEach(function(mode) {
        // Forbidden header names must be ignored.
        FORBIDDEN_HEADER_NAMES
          .forEach(function(header) {
              var headers = (new Request('http://localhost/',
                                         {headers: [[header, 'test']],
                                          mode: mode})).headers;
              assert_equals(headers.get(header), null,
                            header + ' must be ignored (1)');

              headers = (new Request('http://localhost/',
                                     {headers: new Headers([[header, 'test']]),
                                      mode: mode})).headers;
              assert_equals(headers.get(header), null,
                            header + ' must be ignored (2)');
            });

        // Other header names must be accepted.
        FORBIDDEN_RESPONSE_HEADER_NAMES
          .concat(SIMPLE_HEADER_NAMES)
          .concat([CONTENT_TYPE])
          .concat(NON_SIMPLE_HEADER_NAMES)
          .forEach(function(header) {
              var headers = (new Request('http://localhost/',
                                         {headers: [[header, 'test']],
                                          mode: mode})).headers;
              assert_equals(headers.get(header), 'test',
                            header + ' must be set (1)');

              headers = (new Request('http://localhost/',
                                     {headers: new Headers([[header, 'test']]),
                                      mode: mode})).headers;
              assert_equals(headers.get(header), 'test',
                            header + ' must be set (2)');
            });
      });
  }, 'Headers guard = request: RequestInit.headers');

test(function() {
    [function() {return (new Request(URL, {mode: 'no-cors'})).headers;},
     function() {return (new Request(URL, {mode: 'no-cors'})).clone().headers;}]
      .forEach(function(createNewHeaders) {
        var headers = createNewHeaders();
        testInvalidNamesAndValues(headers);

        // Non-simple headers must be ignored.
        FORBIDDEN_HEADER_NAMES
          .concat(FORBIDDEN_RESPONSE_HEADER_NAMES)
          .concat(NON_SIMPLE_HEADER_NAMES)
          .forEach(function(header) {
              testIgnoreHeaderName(headers, header);
            });

        // SIMPLE_HEADER_NAMES must be accepted.
        SIMPLE_HEADER_NAMES
          .forEach(function(header) {
              testAcceptHeaderName(headers, header);
            });

        // Content-Type with NON_SIMPLE_HEADER_CONTENT_TYPE_VALUES are
        // ignored in append()/set().
        NON_SIMPLE_HEADER_CONTENT_TYPE_VALUES
          .forEach(function(value) {
              headers.append(CONTENT_TYPE, value);
              assert_equals(headers.get(CONTENT_TYPE), null,
                            'Content-Type/' + value +
                            ' must be ignored in append()');
              headers.set(CONTENT_TYPE, value);
              assert_equals(headers.get(CONTENT_TYPE), null,
                            'Content-Type/' + value +
                            ' must be ignored in set()');
            });

        // Content-Type with values in SIMPLE_HEADER_CONTENT_TYPE_VALUES are
        // accepted by append()/set(), but not delete().
        SIMPLE_HEADER_CONTENT_TYPE_VALUES
          .forEach(function(value) {
              var headers = createNewHeaders();
              headers.append(CONTENT_TYPE, value);
              assert_equals(headers.get(CONTENT_TYPE), value,
                            'Content-Type/' + value +
                            ' must be appended.');

              headers.delete(CONTENT_TYPE);
              assert_equals(headers.get(CONTENT_TYPE), null,
                            'Content-type/' + value +
                            ' must be deleted.');

              var headers = createNewHeaders();
              headers.set(CONTENT_TYPE, value);
              assert_equals(headers.get(CONTENT_TYPE), value,
                            'Content-Type/' + value +
                            ' must be set.');
            });
      });
  }, 'Headers guard = request-no-cors: set/append/delete');

test(function() {
    // Non-simple headers must be ignored.
    FORBIDDEN_HEADER_NAMES
      .concat(FORBIDDEN_RESPONSE_HEADER_NAMES)
      .concat(NON_SIMPLE_HEADER_NAMES)
      .forEach(function(header) {
          var headers = (new Request('http://localhost/',
                                     {headers: [[header, 'test']],
                                      mode: 'no-cors'})).headers;
          assert_equals(headers.get(header), null,
                        header + ' must be ignored (1)');

          headers = (new Request('http://localhost/',
                                 {headers: new Headers([[header, 'test']]),
                                  mode: 'no-cors'})).headers;
          assert_equals(headers.get(header), null,
                        header + ' must be ignored (2)');
        });

    // SIMPLE_HEADER_NAMES must be accepted.
    SIMPLE_HEADER_NAMES.forEach(function(header) {
        var headers = (new Request('http://localhost/',
                                   {headers: [[header, 'test']],
                                    mode: 'no-cors'
                                   })).headers;
        assert_equals(headers.get(header), 'test',
                      header + ' must be set (1)');

        headers = (new Request('http://localhost/',
                               {headers: new Headers([[header, 'test']]),
                                mode: 'no-cors'})).headers;
        assert_equals(headers.get(header), 'test',
                      header + ' must be set (2)');
      });

    // Content-Type with values in SIMPLE_HEADER_CONTENT_TYPE_VALUES must be
    // accepted.
    SIMPLE_HEADER_CONTENT_TYPE_VALUES.forEach(function(value) {
        var headers = (new Request('http://localhost/',
                                   {headers: [[CONTENT_TYPE, value]],
                                    mode: 'no-cors'
                                   })).headers;
        assert_equals(headers.get(CONTENT_TYPE), value,
                      CONTENT_TYPE + '/' + value + ' must be set (1)');

        headers = (new Request('http://localhost/',
                               {headers: new Headers([[CONTENT_TYPE, value]]),
                                mode: 'no-cors'})).headers;
        assert_equals(headers.get(CONTENT_TYPE), value,
                      CONTENT_TYPE + '/' + value + ' must be set (2)');
      });

    // Content-Type with NON_SIMPLE_HEADER_CONTENT_TYPE_VALUES must be
    // ignored.
    NON_SIMPLE_HEADER_CONTENT_TYPE_VALUES.forEach(function(value) {
        var headers = (new Request('http://localhost/',
                                   {headers: [[CONTENT_TYPE, value]],
                                    mode: 'no-cors'
                                   })).headers;
        assert_equals(headers.get(CONTENT_TYPE), null,
                      CONTENT_TYPE + '/' + value + ' must be ignored (1)');

        headers = (new Request('http://localhost/',
                               {headers: new Headers([[CONTENT_TYPE, value]]),
                                mode: 'no-cors'})).headers;
        assert_equals(headers.get(CONTENT_TYPE), null,
                      CONTENT_TYPE + '/' + value + ' must be ignored (2)');
      });
  }, 'Headers guard = request-no-cors: RequestInit.headers');

test(function() {
    [(new Response(new Blob(['']))).headers,
     (new Response(new Blob(['']))).clone().headers]
      .forEach(function(headers) {
          testInvalidNamesAndValues(headers);

          // Forbidden response header names must be ignored.
          FORBIDDEN_RESPONSE_HEADER_NAMES
            .forEach(function(header) {
                testIgnoreHeaderName(headers, header);
              });

          // Other header names must be accepted.
          FORBIDDEN_HEADER_NAMES
            .concat(SIMPLE_HEADER_NAMES)
            .concat([CONTENT_TYPE])
            .concat(NON_SIMPLE_HEADER_NAMES)
            .forEach(function(header) {
                testAcceptHeaderName(headers, header);
              });
        });
  }, 'Headers guard = response: set/append/delete');

test(function() {
    // Forbidden response header names must be ignored.
    FORBIDDEN_RESPONSE_HEADER_NAMES
      .forEach(function(header) {
          var headers = (new Response(new Blob(),
                                      {headers: [[header, 'test']]})).headers;
          assert_equals(headers.get(header), null,
                        header + ' must be ignored (1)');

          var headers = (new Response(new Blob(),
                                      {headers: new Headers([[header, 'test']])}
                                     )).headers;
          assert_equals(headers.get(header), null,
                        header + ' must be ignored (2)');
        });

    // Other header names must be accepted.
    FORBIDDEN_HEADER_NAMES
      .concat(SIMPLE_HEADER_NAMES)
      .concat([CONTENT_TYPE])
      .concat(NON_SIMPLE_HEADER_NAMES)
      .forEach(function(header) {
          var headers = (new Response(new Blob(),
                                      {headers: [[header, 'test']]})).headers;
          assert_equals(headers.get(header), 'test',
                        header + ' must be set (1)');

          headers = (new Response(new Blob(),
                                  {headers: new Headers([[header, 'test']])}
                                 )).headers;
          assert_equals(headers.get(header), 'test',
                        header + ' must be set (2)');
        });
  }, 'Headers guard = response: ResponseInit.headers');

promise_test(function(t) {
  return fetch('../resources/doctype.html')
    .then(function(res) {
        [res.headers,
         res.clone().headers,
         Response.error().headers,
         Response.error().clone().headers,
         Response.redirect('https://www.example.com/test.html').headers,
         Response.redirect('https://www.example.com/test.html').clone().headers
        ].forEach(function(headers) {
            testInvalidNamesAndValues(headers);

            // Test that TypeError is thrown for all header names.
            FORBIDDEN_HEADER_NAMES
              .concat(FORBIDDEN_RESPONSE_HEADER_NAMES)
              .concat(SIMPLE_HEADER_NAMES)
              .concat([CONTENT_TYPE])
              .concat(NON_SIMPLE_HEADER_NAMES)
              .forEach(function(header) {
                  var value = headers.get(header);

                  assert_throws_js(TypeError,
                                   function() { headers.append(header, 'test'); },
                                   'Headers.append(' + header + ') must throw');
                  assert_equals(headers.get(header), value,
                    'header ' + header + ' must be unchanged by append()');

                  assert_throws_js(TypeError,
                                   function() { headers.set(header, 'test'); },
                                   'Headers.set(' + header + ') must throw');
                  assert_equals(headers.get(header), value,
                    'header ' + header + ' must be unchanged by set()');

                  assert_throws_js(TypeError,
                                   function() { headers.delete(header); },
                                   'Headers.delete(' + header + ') must throw');
                  assert_equals(headers.get(header), value,
                    'header ' + header + ' must be unchanged by delete()');
                });
          });
      });
  }, 'Headers guard = immutable: set/append/delete');

done();