test/jdk/java/net/httpclient/HttpHeadersOf.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 /*
  * @test
  * @summary Tests for HttpHeaders.of factory method
  * @run testng HttpHeadersOf
  */

 import java.net.http.HttpHeaders;
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.function.BiPredicate;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 import static org.testng.Assert.assertFalse;
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertThrows;
 import static org.testng.Assert.assertTrue;
 import static org.testng.Assert.fail;

 public class HttpHeadersOf {

     static final Class<NullPointerException> NPE = NullPointerException.class;
     static final Class<NumberFormatException> NFE = NumberFormatException.class;
     static final Class<UnsupportedOperationException> UOE = UnsupportedOperationException.class;

     static final BiPredicate<String,String> ACCEPT_ALL =
         new BiPredicate<>() {
             @Override public boolean test(String name, String value) { return true; }
             @Override public String toString() { return "ACCEPT_ALL"; }
         };

     static final BiPredicate<String,String> REJECT_ALL =
         new BiPredicate<>() {
             @Override public boolean test(String name, String value) { return false; }
             @Override public String toString() { return "REJECT_ALL"; }
         };

     @DataProvider(name = "predicates")
     public Object[][] predicates() {
         return new Object[][] { { ACCEPT_ALL }, { REJECT_ALL } };
     }

     @Test(dataProvider = "predicates")
     public void testNull(BiPredicate<String,String> filter) {
         assertThrows(NPE, () -> HttpHeaders.of(null, null));
         assertThrows(NPE, () -> HttpHeaders.of(null, filter));
         assertThrows(NPE, () -> HttpHeaders.of(Map.of(), null));
         assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of("value")), null));

         // nulls in the Map
         assertThrows(NPE, () -> HttpHeaders.of(Map.of(null, List.of("value)")), filter));
         assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", null), filter));
         assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of(null)), filter));
         assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of("aValue", null)), filter));
         assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of(null, "aValue")), filter));
     }


     @DataProvider(name = "filterMaps")
     public Object[][] filterMaps() {
         List<Map<String, List<String>>> maps = List.of(
                 Map.of("A", List.of("B"),           "X", List.of("Y", "Z")),
                 Map.of("A", List.of("B", "C"),      "X", List.of("Y", "Z")),
                 Map.of("A", List.of("B", "C", "D"), "X", List.of("Y", "Z"))
         );
         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
     }

     @Test(dataProvider = "filterMaps")
     public void testFilter(Map<String,List<String>> map) {
         HttpHeaders headers = HttpHeaders.of(map, REJECT_ALL);
         assertEquals(headers.map().size(), 0);
         assertFalse(headers.firstValue("A").isPresent());
         assertEquals(headers.allValues("A").size(), 0);

         headers = HttpHeaders.of(map, (name, value) -> {
             if (name.equals("A")) return true; else return false; });
         assertEquals(headers.map().size(), 1);
         assertTrue(headers.firstValue("A").isPresent());
         assertEquals(headers.allValues("A"), map.get("A"));
         assertEquals(headers.allValues("A").size(), map.get("A").size());
         assertFalse(headers.firstValue("X").isPresent());

         headers = HttpHeaders.of(map, (name, value) -> {
             if (name.equals("X")) return true; else return false; });
         assertEquals(headers.map().size(), 1);
         assertTrue(headers.firstValue("X").isPresent());
         assertEquals(headers.allValues("X"), map.get("X"));
         assertEquals(headers.allValues("X").size(), map.get("X").size());
         assertFalse(headers.firstValue("A").isPresent());
     }


     @DataProvider(name = "mapValues")
     public Object[][] mapValues() {
         List<Map<String, List<String>>> maps = List.of(
             Map.of("A", List.of("B")),
             Map.of("A", List.of("B", "C")),
             Map.of("A", List.of("B", "C", "D")),

             Map.of("A", List.of("B"),           "X", List.of("Y", "Z")),
             Map.of("A", List.of("B", "C"),      "X", List.of("Y", "Z")),
             Map.of("A", List.of("B", "C", "D"), "X", List.of("Y", "Z")),

             Map.of("A", List.of("B"),           "X", List.of("Y", "Z")),
             Map.of("A", List.of("B", "C"),      "X", List.of("Y", "Z")),
             Map.of("A", List.of("B", "C", "D"), "X", List.of("Y", "Z")),

             Map.of("X", List.of("Y", "Z"), "A", List.of("B")),
             Map.of("X", List.of("Y", "Z"), "A", List.of("B", "C")),
             Map.of("X", List.of("Y", "Z"), "A", List.of("B", "C", "D"))
         );
         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
     }

     @Test(dataProvider = "mapValues")
     public void testMapValues(Map<String,List<String>> map) {
         HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);

         assertEquals(headers.map().size(), map.size());
         assertTrue(headers.firstValue("A").isPresent());
         assertTrue(headers.firstValue("a").isPresent());
         assertEquals(headers.firstValue("A").get(), "B");
         assertEquals(headers.firstValue("a").get(), "B");
         assertEquals(headers.allValues("A"), map.get("A"));
         assertEquals(headers.allValues("a"), map.get("A"));
         assertEquals(headers.allValues("F").size(), 0);
         assertTrue(headers.map().get("A").contains("B"));
         assertFalse(headers.map().get("A").contains("F"));
         assertThrows(NFE, () -> headers.firstValueAsLong("A"));

         // a non-exhaustive list of mutators
         assertThrows(UOE, () -> headers.map().put("Z", List.of("Z")));
         assertThrows(UOE, () -> headers.map().remove("A"));
         assertThrows(UOE, () -> headers.map().remove("A", "B"));
         assertThrows(UOE, () -> headers.map().clear());
         assertThrows(UOE, () -> headers.allValues("A").remove("B"));
         assertThrows(UOE, () -> headers.allValues("A").remove(1));
         assertThrows(UOE, () -> headers.allValues("A").clear());
         assertThrows(UOE, () -> headers.allValues("A").add("Z"));
         assertThrows(UOE, () -> headers.allValues("A").addAll(List.of("Z")));
         assertThrows(UOE, () -> headers.allValues("A").add(1, "Z"));
     }


     @DataProvider(name = "caseInsensitivity")
     public Object[][] caseInsensitivity() {
         List<Map<String, List<String>>> maps = List.of(
              Map.of("Accept-Encoding", List.of("gzip, deflate")),
              Map.of("accept-encoding", List.of("gzip, deflate")),
              Map.of("AccePT-ENCoding", List.of("gzip, deflate")),
              Map.of("ACCept-EncodING", List.of("gzip, deflate")),
              Map.of("ACCEPT-ENCODING", List.of("gzip, deflate"))
         );
         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
     }

     @Test(dataProvider = "caseInsensitivity")
     public void testCaseInsensitivity(Map<String,List<String>> map) {
         HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);

         for (String name : List.of("Accept-Encoding", "accept-encoding",
                                    "aCCept-EnCODing", "accepT-encodinG")) {
             assertTrue(headers.firstValue(name).isPresent());
             assertTrue(headers.allValues(name).contains("gzip, deflate"));
             assertEquals(headers.firstValue(name).get(), "gzip, deflate");
             assertEquals(headers.allValues(name).size(), 1);
             assertEquals(headers.map().size(), 1);
             assertEquals(headers.map().get(name).size(), 1);
             assertEquals(headers.map().get(name).get(0), "gzip, deflate");
         }
     }

     @Test
     public void testEqualsAndHashCode() {
         List<Map<String, List<String>>> maps = List.of(
                 Map.of("Accept-Encoding", List.of("gzip, deflate")),
                 Map.of("accept-encoding", List.of("gzip, deflate")),
                 Map.of("AccePT-ENCoding", List.of("gzip, deflate")),
                 Map.of("ACCept-EncodING", List.of("gzip, deflate")),
                 Map.of("ACCEPT-ENCODING", List.of("gzip, deflate"))
         );
         int mapDiffer = 0;
         int mapHashDiffer = 0;
         for (Map<String, List<String>> m1 : maps) {
             HttpHeaders h1 = HttpHeaders.of(m1, ACCEPT_ALL);
             for (Map<String, List<String>> m2 : maps) {
                 HttpHeaders h2 = HttpHeaders.of(m2, ACCEPT_ALL);
                 if (!m1.equals(m2)) mapDiffer++;
                 if (m1.hashCode() != m2.hashCode()) mapHashDiffer++;
                 assertEquals(h1, h2, "HttpHeaders differ");
                 assertEquals(h1.hashCode(), h2.hashCode(),
                         "hashCode differ for " + List.of(m1,m2));
             }
         }
         assertTrue(mapDiffer > 0, "all maps were equal!");
         assertTrue(mapHashDiffer > 0, "all maps had same hashCode!");
     }

     @DataProvider(name = "valueAsLong")
     public Object[][] valueAsLong() {
         return new Object[][] {
             new Object[] { Map.of("Content-Length", List.of("10")), 10l },
             new Object[] { Map.of("Content-Length", List.of("101")), 101l },
             new Object[] { Map.of("Content-Length", List.of("56789")), 56789l },
             new Object[] { Map.of("Content-Length", List.of(Long.toString(Long.MAX_VALUE))), Long.MAX_VALUE },
             new Object[] { Map.of("Content-Length", List.of(Long.toString(Long.MIN_VALUE))), Long.MIN_VALUE }
         };
     }

     @Test(dataProvider = "valueAsLong")
     public void testValueAsLong(Map<String,List<String>> map, long expected) {
         HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);
         assertEquals(headers.firstValueAsLong("Content-Length").getAsLong(), expected);
     }


     @DataProvider(name = "duplicateNames")
     public Object[][] duplicateNames() {
         List<Map<String, List<String>>> maps = List.of(
                 Map.of("X-name", List.of(),
                        "x-name", List.of()),
                 Map.of("X-name", List.of(""),
                        "x-name", List.of("")),
                 Map.of("X-name", List.of("C"),
                        "x-name", List.of("D")),
                 Map.of("X-name", List.of("E"),
                        "Y-name", List.of("F"),
                        "X-Name", List.of("G")),
                 Map.of("X-chegar", List.of("H"),
                        "y-dfuchs", List.of("I"),
                        "Y-dfuchs", List.of("J")),
                 Map.of("X-name ", List.of("K"),
                        "X-Name", List.of("L")),
                 Map.of("X-name", List.of("M"),
                        "\rX-Name", List.of("N"))
         );
         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
     }

     @Test(dataProvider = "duplicateNames")
     public void testDuplicates(Map<String,List<String>> map) {
         HttpHeaders headers;
         try {
             headers = HttpHeaders.of(map, ACCEPT_ALL);
             fail("UNEXPECTED: " + headers);
         } catch (IllegalArgumentException iae) {
             System.out.println("caught EXPECTED IAE:" + iae);
             assertTrue(iae.getMessage().contains("duplicate"));
         }
     }


     @DataProvider(name = "noSplittingJoining")
     public Object[][] noSplittingJoining() {
         List<Map<String, List<String>>> maps = List.of(
                 Map.of("A", List.of("B")),
                 Map.of("A", List.of("B", "C")),
                 Map.of("A", List.of("B", "C", "D")),
                 Map.of("A", List.of("B", "C", "D", "E")),
                 Map.of("A", List.of("B", "C", "D", "E", "F")),
                 Map.of("A", List.of("B, C")),
                 Map.of("A", List.of("B, C, D")),
                 Map.of("A", List.of("B, C, D, E")),
                 Map.of("A", List.of("B, C, D, E, F")),
                 Map.of("A", List.of("B, C", "D", "E", "F")),
                 Map.of("A", List.of("B", "C, D", "E", "F")),
                 Map.of("A", List.of("B", "C, D", "E, F")),
                 Map.of("A", List.of("B", "C, D, E", "F")),
                 Map.of("A", List.of("B", "C, D, E, F"))
         );
         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
     }

     @Test(dataProvider = "noSplittingJoining")
     public void testNoSplittingJoining(Map<String,List<String>> map) {
         HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);
         Map<String,List<String>> headersMap = headers.map();

         assertEquals(headers.map().size(), map.size());
         for (Map.Entry<String,List<String>> entry : map.entrySet()) {
             String headerName = entry.getKey();
             List<String> headerValues = entry.getValue();
             assertEquals(headerValues, headersMap.get(headerName));
             assertEquals(headerValues, headers.allValues(headerName));
             assertEquals(headerValues.get(0), headers.firstValue(headerName).get());
         }
     }


     @DataProvider(name = "trimming")
     public Object[][] trimming() {
         List<Map<String, List<String>>> maps = List.of(
                 Map.of("A", List.of("B")),
                 Map.of(" A", List.of("B")),
                 Map.of("A ", List.of("B")),
                 Map.of("A", List.of(" B")),
                 Map.of("A", List.of("B ")),
                 Map.of("\tA", List.of("B")),
                 Map.of("A\t", List.of("B")),
                 Map.of("A", List.of("\tB")),
                 Map.of("A", List.of("B\t")),
                 Map.of("A\r", List.of("B")),
                 Map.of("A\n", List.of("B")),
                 Map.of("A\r\n", List.of("B"))
         );
         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
     }

     @Test(dataProvider = "trimming")
     public void testTrimming(Map<String,List<String>> map) {
         HttpHeaders headers = HttpHeaders.of(map, (name, value) -> {
             assertEquals(name, "A");
             assertEquals(value, "B");
             return true;
         });

         assertEquals(headers.map().size(), 1);
         assertEquals(headers.firstValue("A").get(), "B");
         assertEquals(headers.allValues("A"), List.of("B"));
         assertTrue(headers.map().get("A").equals(List.of("B")));
     }


     @DataProvider(name = "emptyKey")
     public Object[][] emptyKey() {
         List<Map<String, List<String>>> maps = List.of(
                 Map.of("", List.of("B")),
                 Map.of(" ", List.of("B")),
                 Map.of("  ", List.of("B")),
                 Map.of("\t", List.of("B")),
                 Map.of("\t\t", List.of("B"))
         );
         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
     }

     @Test(dataProvider = "emptyKey")
     public void testEmptyKey(Map<String,List<String>> map) {
         HttpHeaders headers;
         try {
             headers = HttpHeaders.of(map, ACCEPT_ALL);
             fail("UNEXPECTED: " + headers);
         } catch (IllegalArgumentException iae) {
             System.out.println("caught EXPECTED IAE:" + iae);
             assertTrue(iae.getMessage().contains("empty"));
         }
     }


     @DataProvider(name = "emptyValue")
     public Object[][] emptyValue() {
         List<Map<String, List<String>>> maps = List.of(
                 Map.of("A", List.of("")),
                 Map.of("A", List.of("", "")),
                 Map.of("A", List.of("", "", " ")),
                 Map.of("A", List.of("\t")),
                 Map.of("A", List.of("\t\t"))
         );
         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
     }

     @Test(dataProvider = "emptyValue")
     public void testEmptyValue(Map<String,List<String>> map) {
         HttpHeaders headers = HttpHeaders.of(map, (name, value) -> {
             assertEquals(value, "");
             return true;
         });
         assertEquals(headers.map().size(), map.size());
         assertEquals(headers.map().get("A").get(0), "");
         headers.allValues("A").forEach(v -> assertEquals(v, ""));
         assertEquals(headers.firstValue("A").get(), "");
     }


     @DataProvider(name = "noValues")
     public Object[][] noValues() {
         List<Map<String, List<String>>> maps = List.of(
                 Map.of("A", List.of()),
                 Map.of("A", List.of(), "B", List.of()),
                 Map.of("A", List.of(), "B", List.of(), "C", List.of()),
                 Map.of("A", new ArrayList()),
                 Map.of("A", new LinkedList())
         );
         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
     }

     @Test(dataProvider = "noValues")
     public void testNoValues(Map<String,List<String>> map) {
         HttpHeaders headers = HttpHeaders.of(map, (name, value) -> {
             fail("UNEXPECTED call to filter");
             return true;
         });
         assertEquals(headers.map().size(), 0);
         assertEquals(headers.map().get("A"), null);
         assertEquals(headers.allValues("A").size(), 0);
         assertFalse(headers.firstValue("A").isPresent());
     }
 }
	/*
	* Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/*
	* @test
	* @summary Tests for HttpHeaders.of factory method
	* @run testng HttpHeadersOf
	*/

	import java.net.http.HttpHeaders;
	import java.util.ArrayList;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;
	import java.util.function.BiPredicate;
	import org.testng.annotations.DataProvider;
	import org.testng.annotations.Test;
	import static org.testng.Assert.assertFalse;
	import static org.testng.Assert.assertEquals;
	import static org.testng.Assert.assertThrows;
	import static org.testng.Assert.assertTrue;
	import static org.testng.Assert.fail;

	public class HttpHeadersOf {

	static final Class<NullPointerException> NPE = NullPointerException.class;
	static final Class<NumberFormatException> NFE = NumberFormatException.class;
	static final Class<UnsupportedOperationException> UOE = UnsupportedOperationException.class;

	static final BiPredicate<String,String> ACCEPT_ALL =
	new BiPredicate<>() {
	@Override public boolean test(String name, String value) { return true; }
	@Override public String toString() { return "ACCEPT_ALL"; }
	};

	static final BiPredicate<String,String> REJECT_ALL =
	new BiPredicate<>() {
	@Override public boolean test(String name, String value) { return false; }
	@Override public String toString() { return "REJECT_ALL"; }
	};

	@DataProvider(name = "predicates")
	public Object[][] predicates() {
	return new Object[][] { { ACCEPT_ALL }, { REJECT_ALL } };
	}

	@Test(dataProvider = "predicates")
	public void testNull(BiPredicate<String,String> filter) {
	assertThrows(NPE, () -> HttpHeaders.of(null, null));
	assertThrows(NPE, () -> HttpHeaders.of(null, filter));
	assertThrows(NPE, () -> HttpHeaders.of(Map.of(), null));
	assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of("value")), null));

	// nulls in the Map
	assertThrows(NPE, () -> HttpHeaders.of(Map.of(null, List.of("value)")), filter));
	assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", null), filter));
	assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of(null)), filter));
	assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of("aValue", null)), filter));
	assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of(null, "aValue")), filter));
	}


	@DataProvider(name = "filterMaps")
	public Object[][] filterMaps() {
	List<Map<String, List<String>>> maps = List.of(
	Map.of("A", List.of("B"), "X", List.of("Y", "Z")),
	Map.of("A", List.of("B", "C"), "X", List.of("Y", "Z")),
	Map.of("A", List.of("B", "C", "D"), "X", List.of("Y", "Z"))
	);
	return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
	}

	@Test(dataProvider = "filterMaps")
	public void testFilter(Map<String,List<String>> map) {
	HttpHeaders headers = HttpHeaders.of(map, REJECT_ALL);
	assertEquals(headers.map().size(), 0);
	assertFalse(headers.firstValue("A").isPresent());
	assertEquals(headers.allValues("A").size(), 0);

	headers = HttpHeaders.of(map, (name, value) -> {
	if (name.equals("A")) return true; else return false; });
	assertEquals(headers.map().size(), 1);
	assertTrue(headers.firstValue("A").isPresent());
	assertEquals(headers.allValues("A"), map.get("A"));
	assertEquals(headers.allValues("A").size(), map.get("A").size());
	assertFalse(headers.firstValue("X").isPresent());

	headers = HttpHeaders.of(map, (name, value) -> {
	if (name.equals("X")) return true; else return false; });
	assertEquals(headers.map().size(), 1);
	assertTrue(headers.firstValue("X").isPresent());
	assertEquals(headers.allValues("X"), map.get("X"));
	assertEquals(headers.allValues("X").size(), map.get("X").size());
	assertFalse(headers.firstValue("A").isPresent());
	}


	@DataProvider(name = "mapValues")
	public Object[][] mapValues() {
	List<Map<String, List<String>>> maps = List.of(
	Map.of("A", List.of("B")),
	Map.of("A", List.of("B", "C")),
	Map.of("A", List.of("B", "C", "D")),

	Map.of("A", List.of("B"), "X", List.of("Y", "Z")),
	Map.of("A", List.of("B", "C"), "X", List.of("Y", "Z")),
	Map.of("A", List.of("B", "C", "D"), "X", List.of("Y", "Z")),

	Map.of("A", List.of("B"), "X", List.of("Y", "Z")),
	Map.of("A", List.of("B", "C"), "X", List.of("Y", "Z")),
	Map.of("A", List.of("B", "C", "D"), "X", List.of("Y", "Z")),

	Map.of("X", List.of("Y", "Z"), "A", List.of("B")),
	Map.of("X", List.of("Y", "Z"), "A", List.of("B", "C")),
	Map.of("X", List.of("Y", "Z"), "A", List.of("B", "C", "D"))
	);
	return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
	}

	@Test(dataProvider = "mapValues")
	public void testMapValues(Map<String,List<String>> map) {
	HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);

	assertEquals(headers.map().size(), map.size());
	assertTrue(headers.firstValue("A").isPresent());
	assertTrue(headers.firstValue("a").isPresent());
	assertEquals(headers.firstValue("A").get(), "B");
	assertEquals(headers.firstValue("a").get(), "B");
	assertEquals(headers.allValues("A"), map.get("A"));
	assertEquals(headers.allValues("a"), map.get("A"));
	assertEquals(headers.allValues("F").size(), 0);
	assertTrue(headers.map().get("A").contains("B"));
	assertFalse(headers.map().get("A").contains("F"));
	assertThrows(NFE, () -> headers.firstValueAsLong("A"));

	// a non-exhaustive list of mutators
	assertThrows(UOE, () -> headers.map().put("Z", List.of("Z")));
	assertThrows(UOE, () -> headers.map().remove("A"));
	assertThrows(UOE, () -> headers.map().remove("A", "B"));
	assertThrows(UOE, () -> headers.map().clear());
	assertThrows(UOE, () -> headers.allValues("A").remove("B"));
	assertThrows(UOE, () -> headers.allValues("A").remove(1));
	assertThrows(UOE, () -> headers.allValues("A").clear());
	assertThrows(UOE, () -> headers.allValues("A").add("Z"));
	assertThrows(UOE, () -> headers.allValues("A").addAll(List.of("Z")));
	assertThrows(UOE, () -> headers.allValues("A").add(1, "Z"));
	}


	@DataProvider(name = "caseInsensitivity")
	public Object[][] caseInsensitivity() {
	List<Map<String, List<String>>> maps = List.of(
	Map.of("Accept-Encoding", List.of("gzip, deflate")),
	Map.of("accept-encoding", List.of("gzip, deflate")),
	Map.of("AccePT-ENCoding", List.of("gzip, deflate")),
	Map.of("ACCept-EncodING", List.of("gzip, deflate")),
	Map.of("ACCEPT-ENCODING", List.of("gzip, deflate"))
	);
	return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
	}

	@Test(dataProvider = "caseInsensitivity")
	public void testCaseInsensitivity(Map<String,List<String>> map) {
	HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);

	for (String name : List.of("Accept-Encoding", "accept-encoding",
	"aCCept-EnCODing", "accepT-encodinG")) {
	assertTrue(headers.firstValue(name).isPresent());
	assertTrue(headers.allValues(name).contains("gzip, deflate"));
	assertEquals(headers.firstValue(name).get(), "gzip, deflate");
	assertEquals(headers.allValues(name).size(), 1);
	assertEquals(headers.map().size(), 1);
	assertEquals(headers.map().get(name).size(), 1);
	assertEquals(headers.map().get(name).get(0), "gzip, deflate");
	}
	}

	@Test
	public void testEqualsAndHashCode() {
	List<Map<String, List<String>>> maps = List.of(
	Map.of("Accept-Encoding", List.of("gzip, deflate")),
	Map.of("accept-encoding", List.of("gzip, deflate")),
	Map.of("AccePT-ENCoding", List.of("gzip, deflate")),
	Map.of("ACCept-EncodING", List.of("gzip, deflate")),
	Map.of("ACCEPT-ENCODING", List.of("gzip, deflate"))
	);
	int mapDiffer = 0;
	int mapHashDiffer = 0;
	for (Map<String, List<String>> m1 : maps) {
	HttpHeaders h1 = HttpHeaders.of(m1, ACCEPT_ALL);
	for (Map<String, List<String>> m2 : maps) {
	HttpHeaders h2 = HttpHeaders.of(m2, ACCEPT_ALL);
	if (!m1.equals(m2)) mapDiffer++;
	if (m1.hashCode() != m2.hashCode()) mapHashDiffer++;
	assertEquals(h1, h2, "HttpHeaders differ");
	assertEquals(h1.hashCode(), h2.hashCode(),
	"hashCode differ for " + List.of(m1,m2));
	}
	}
	assertTrue(mapDiffer > 0, "all maps were equal!");
	assertTrue(mapHashDiffer > 0, "all maps had same hashCode!");
	}

	@DataProvider(name = "valueAsLong")
	public Object[][] valueAsLong() {
	return new Object[][] {
	new Object[] { Map.of("Content-Length", List.of("10")), 10l },
	new Object[] { Map.of("Content-Length", List.of("101")), 101l },
	new Object[] { Map.of("Content-Length", List.of("56789")), 56789l },
	new Object[] { Map.of("Content-Length", List.of(Long.toString(Long.MAX_VALUE))), Long.MAX_VALUE },
	new Object[] { Map.of("Content-Length", List.of(Long.toString(Long.MIN_VALUE))), Long.MIN_VALUE }
	};
	}

	@Test(dataProvider = "valueAsLong")
	public void testValueAsLong(Map<String,List<String>> map, long expected) {
	HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);
	assertEquals(headers.firstValueAsLong("Content-Length").getAsLong(), expected);
	}


	@DataProvider(name = "duplicateNames")
	public Object[][] duplicateNames() {
	List<Map<String, List<String>>> maps = List.of(
	Map.of("X-name", List.of(),
	"x-name", List.of()),
	Map.of("X-name", List.of(""),
	"x-name", List.of("")),
	Map.of("X-name", List.of("C"),
	"x-name", List.of("D")),
	Map.of("X-name", List.of("E"),
	"Y-name", List.of("F"),
	"X-Name", List.of("G")),
	Map.of("X-chegar", List.of("H"),
	"y-dfuchs", List.of("I"),
	"Y-dfuchs", List.of("J")),
	Map.of("X-name ", List.of("K"),
	"X-Name", List.of("L")),
	Map.of("X-name", List.of("M"),
	"\rX-Name", List.of("N"))
	);
	return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
	}

	@Test(dataProvider = "duplicateNames")
	public void testDuplicates(Map<String,List<String>> map) {
	HttpHeaders headers;
	try {
	headers = HttpHeaders.of(map, ACCEPT_ALL);
	fail("UNEXPECTED: " + headers);
	} catch (IllegalArgumentException iae) {
	System.out.println("caught EXPECTED IAE:" + iae);
	assertTrue(iae.getMessage().contains("duplicate"));
	}
	}


	@DataProvider(name = "noSplittingJoining")
	public Object[][] noSplittingJoining() {
	List<Map<String, List<String>>> maps = List.of(
	Map.of("A", List.of("B")),
	Map.of("A", List.of("B", "C")),
	Map.of("A", List.of("B", "C", "D")),
	Map.of("A", List.of("B", "C", "D", "E")),
	Map.of("A", List.of("B", "C", "D", "E", "F")),
	Map.of("A", List.of("B, C")),
	Map.of("A", List.of("B, C, D")),
	Map.of("A", List.of("B, C, D, E")),
	Map.of("A", List.of("B, C, D, E, F")),
	Map.of("A", List.of("B, C", "D", "E", "F")),
	Map.of("A", List.of("B", "C, D", "E", "F")),
	Map.of("A", List.of("B", "C, D", "E, F")),
	Map.of("A", List.of("B", "C, D, E", "F")),
	Map.of("A", List.of("B", "C, D, E, F"))
	);
	return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
	}

	@Test(dataProvider = "noSplittingJoining")
	public void testNoSplittingJoining(Map<String,List<String>> map) {
	HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);
	Map<String,List<String>> headersMap = headers.map();

	assertEquals(headers.map().size(), map.size());
	for (Map.Entry<String,List<String>> entry : map.entrySet()) {
	String headerName = entry.getKey();
	List<String> headerValues = entry.getValue();
	assertEquals(headerValues, headersMap.get(headerName));
	assertEquals(headerValues, headers.allValues(headerName));
	assertEquals(headerValues.get(0), headers.firstValue(headerName).get());
	}
	}


	@DataProvider(name = "trimming")
	public Object[][] trimming() {
	List<Map<String, List<String>>> maps = List.of(
	Map.of("A", List.of("B")),
	Map.of(" A", List.of("B")),
	Map.of("A ", List.of("B")),
	Map.of("A", List.of(" B")),
	Map.of("A", List.of("B ")),
	Map.of("\tA", List.of("B")),
	Map.of("A\t", List.of("B")),
	Map.of("A", List.of("\tB")),
	Map.of("A", List.of("B\t")),
	Map.of("A\r", List.of("B")),
	Map.of("A\n", List.of("B")),
	Map.of("A\r\n", List.of("B"))
	);
	return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
	}

	@Test(dataProvider = "trimming")
	public void testTrimming(Map<String,List<String>> map) {
	HttpHeaders headers = HttpHeaders.of(map, (name, value) -> {
	assertEquals(name, "A");
	assertEquals(value, "B");
	return true;
	});

	assertEquals(headers.map().size(), 1);
	assertEquals(headers.firstValue("A").get(), "B");
	assertEquals(headers.allValues("A"), List.of("B"));
	assertTrue(headers.map().get("A").equals(List.of("B")));
	}


	@DataProvider(name = "emptyKey")
	public Object[][] emptyKey() {
	List<Map<String, List<String>>> maps = List.of(
	Map.of("", List.of("B")),
	Map.of(" ", List.of("B")),
	Map.of(" ", List.of("B")),
	Map.of("\t", List.of("B")),
	Map.of("\t\t", List.of("B"))
	);
	return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
	}

	@Test(dataProvider = "emptyKey")
	public void testEmptyKey(Map<String,List<String>> map) {
	HttpHeaders headers;
	try {
	headers = HttpHeaders.of(map, ACCEPT_ALL);
	fail("UNEXPECTED: " + headers);
	} catch (IllegalArgumentException iae) {
	System.out.println("caught EXPECTED IAE:" + iae);
	assertTrue(iae.getMessage().contains("empty"));
	}
	}


	@DataProvider(name = "emptyValue")
	public Object[][] emptyValue() {
	List<Map<String, List<String>>> maps = List.of(
	Map.of("A", List.of("")),
	Map.of("A", List.of("", "")),
	Map.of("A", List.of("", "", " ")),
	Map.of("A", List.of("\t")),
	Map.of("A", List.of("\t\t"))
	);
	return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
	}

	@Test(dataProvider = "emptyValue")
	public void testEmptyValue(Map<String,List<String>> map) {
	HttpHeaders headers = HttpHeaders.of(map, (name, value) -> {
	assertEquals(value, "");
	return true;
	});
	assertEquals(headers.map().size(), map.size());
	assertEquals(headers.map().get("A").get(0), "");
	headers.allValues("A").forEach(v -> assertEquals(v, ""));
	assertEquals(headers.firstValue("A").get(), "");
	}


	@DataProvider(name = "noValues")
	public Object[][] noValues() {
	List<Map<String, List<String>>> maps = List.of(
	Map.of("A", List.of()),
	Map.of("A", List.of(), "B", List.of()),
	Map.of("A", List.of(), "B", List.of(), "C", List.of()),
	Map.of("A", new ArrayList()),
	Map.of("A", new LinkedList())
	);
	return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);
	}

	@Test(dataProvider = "noValues")
	public void testNoValues(Map<String,List<String>> map) {
	HttpHeaders headers = HttpHeaders.of(map, (name, value) -> {
	fail("UNEXPECTED call to filter");
	return true;
	});
	assertEquals(headers.map().size(), 0);
	assertEquals(headers.map().get("A"), null);
	assertEquals(headers.allValues("A").size(), 0);
	assertFalse(headers.firstValue("A").isPresent());
	}
	}