1 /*

     2  * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /*

    25  * @test

    26  * @summary Tests for HttpHeaders.of factory method

    27  * @run testng HttpHeadersOf

    28  */

    29 

    30 import java.net.http.HttpHeaders;

    31 import java.util.ArrayList;

    32 import java.util.LinkedList;

    33 import java.util.List;

    34 import java.util.Map;

    35 import java.util.function.BiPredicate;

    36 import org.testng.annotations.DataProvider;

    37 import org.testng.annotations.Test;

    38 import static org.testng.Assert.assertFalse;

    39 import static org.testng.Assert.assertEquals;

    40 import static org.testng.Assert.assertThrows;

    41 import static org.testng.Assert.assertTrue;

    42 import static org.testng.Assert.fail;

    43 

    44 public class HttpHeadersOf {

    45 

    46     static final Class<NullPointerException> NPE = NullPointerException.class;

    47     static final Class<NumberFormatException> NFE = NumberFormatException.class;

    48     static final Class<UnsupportedOperationException> UOE = UnsupportedOperationException.class;

    49 

    50     static final BiPredicate<String,String> ACCEPT_ALL =

    51         new BiPredicate<>() {

    52             @Override public boolean test(String name, String value) { return true; }

    53             @Override public String toString() { return "ACCEPT_ALL"; }

    54         };

    55 

    56     static final BiPredicate<String,String> REJECT_ALL =

    57         new BiPredicate<>() {

    58             @Override public boolean test(String name, String value) { return false; }

    59             @Override public String toString() { return "REJECT_ALL"; }

    60         };

    61 

    62     @DataProvider(name = "predicates")

    63     public Object[][] predicates() {

    64         return new Object[][] { { ACCEPT_ALL }, { REJECT_ALL } };

    65     }

    66 

    67     @Test(dataProvider = "predicates")

    68     public void testNull(BiPredicate<String,String> filter) {

    69         assertThrows(NPE, () -> HttpHeaders.of(null, null));

    70         assertThrows(NPE, () -> HttpHeaders.of(null, filter));

    71         assertThrows(NPE, () -> HttpHeaders.of(Map.of(), null));

    72         assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of("value")), null));

    73 

    74         // nulls in the Map

    75         assertThrows(NPE, () -> HttpHeaders.of(Map.of(null, List.of("value)")), filter));

    76         assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", null), filter));

    77         assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of(null)), filter));

    78         assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of("aValue", null)), filter));

    79         assertThrows(NPE, () -> HttpHeaders.of(Map.of("name", List.of(null, "aValue")), filter));

    80     }

    81 

    82 

    83     @DataProvider(name = "filterMaps")

    84     public Object[][] filterMaps() {

    85         List<Map<String, List<String>>> maps = List.of(

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

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

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

    89         );

    90         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);

    91     }

    92 

    93     @Test(dataProvider = "filterMaps")

    94     public void testFilter(Map<String,List<String>> map) {

    95         HttpHeaders headers = HttpHeaders.of(map, REJECT_ALL);

    96         assertEquals(headers.map().size(), 0);

    97         assertFalse(headers.firstValue("A").isPresent());

    98         assertEquals(headers.allValues("A").size(), 0);

    99 

   100         headers = HttpHeaders.of(map, (name, value) -> {

   101             if (name.equals("A")) return true; else return false; });

   102         assertEquals(headers.map().size(), 1);

   103         assertTrue(headers.firstValue("A").isPresent());

   104         assertEquals(headers.allValues("A"), map.get("A"));

   105         assertEquals(headers.allValues("A").size(), map.get("A").size());

   106         assertFalse(headers.firstValue("X").isPresent());

   107 

   108         headers = HttpHeaders.of(map, (name, value) -> {

   109             if (name.equals("X")) return true; else return false; });

   110         assertEquals(headers.map().size(), 1);

   111         assertTrue(headers.firstValue("X").isPresent());

   112         assertEquals(headers.allValues("X"), map.get("X"));

   113         assertEquals(headers.allValues("X").size(), map.get("X").size());

   114         assertFalse(headers.firstValue("A").isPresent());

   115     }

   116 

   117 

   118     @DataProvider(name = "mapValues")

   119     public Object[][] mapValues() {

   120         List<Map<String, List<String>>> maps = List.of(

   121             Map.of("A", List.of("B")),

   122             Map.of("A", List.of("B", "C")),

   123             Map.of("A", List.of("B", "C", "D")),

   124 

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

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

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

   128 

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

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

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

   132 

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

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

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

   136         );

   137         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);

   138     }

   139 

   140     @Test(dataProvider = "mapValues")

   141     public void testMapValues(Map<String,List<String>> map) {

   142         HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);

   143 

   144         assertEquals(headers.map().size(), map.size());

   145         assertTrue(headers.firstValue("A").isPresent());

   146         assertTrue(headers.firstValue("a").isPresent());

   147         assertEquals(headers.firstValue("A").get(), "B");

   148         assertEquals(headers.firstValue("a").get(), "B");

   149         assertEquals(headers.allValues("A"), map.get("A"));

   150         assertEquals(headers.allValues("a"), map.get("A"));

   151         assertEquals(headers.allValues("F").size(), 0);

   152         assertTrue(headers.map().get("A").contains("B"));

   153         assertFalse(headers.map().get("A").contains("F"));

   154         assertThrows(NFE, () -> headers.firstValueAsLong("A"));

   155 

   156         // a non-exhaustive list of mutators

   157         assertThrows(UOE, () -> headers.map().put("Z", List.of("Z")));

   158         assertThrows(UOE, () -> headers.map().remove("A"));

   159         assertThrows(UOE, () -> headers.map().remove("A", "B"));

   160         assertThrows(UOE, () -> headers.map().clear());

   161         assertThrows(UOE, () -> headers.allValues("A").remove("B"));

   162         assertThrows(UOE, () -> headers.allValues("A").remove(1));

   163         assertThrows(UOE, () -> headers.allValues("A").clear());

   164         assertThrows(UOE, () -> headers.allValues("A").add("Z"));

   165         assertThrows(UOE, () -> headers.allValues("A").addAll(List.of("Z")));

   166         assertThrows(UOE, () -> headers.allValues("A").add(1, "Z"));

   167     }

   168 

   169 

   170     @DataProvider(name = "caseInsensitivity")

   171     public Object[][] caseInsensitivity() {

   172         List<Map<String, List<String>>> maps = List.of(

   173              Map.of("Accept-Encoding", List.of("gzip, deflate")),

   174              Map.of("accept-encoding", List.of("gzip, deflate")),

   175              Map.of("AccePT-ENCoding", List.of("gzip, deflate")),

   176              Map.of("ACCept-EncodING", List.of("gzip, deflate")),

   177              Map.of("ACCEPT-ENCODING", List.of("gzip, deflate"))

   178         );

   179         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);

   180     }

   181 

   182     @Test(dataProvider = "caseInsensitivity")

   183     public void testCaseInsensitivity(Map<String,List<String>> map) {

   184         HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);

   185 

   186         for (String name : List.of("Accept-Encoding", "accept-encoding",

   187                                    "aCCept-EnCODing", "accepT-encodinG")) {

   188             assertTrue(headers.firstValue(name).isPresent());

   189             assertTrue(headers.allValues(name).contains("gzip, deflate"));

   190             assertEquals(headers.firstValue(name).get(), "gzip, deflate");

   191             assertEquals(headers.allValues(name).size(), 1);

   192             assertEquals(headers.map().size(), 1);

   193             assertEquals(headers.map().get(name).size(), 1);

   194             assertEquals(headers.map().get(name).get(0), "gzip, deflate");

   195         }

   196     }

   197 

   198     @DataProvider(name = "valueAsLong")

   199     public Object[][] valueAsLong() {

   200         return new Object[][] {

   201             new Object[] { Map.of("Content-Length", List.of("10")), 10l },

   202             new Object[] { Map.of("Content-Length", List.of("101")), 101l },

   203             new Object[] { Map.of("Content-Length", List.of("56789")), 56789l },

   204             new Object[] { Map.of("Content-Length", List.of(Long.toString(Long.MAX_VALUE))), Long.MAX_VALUE },

   205             new Object[] { Map.of("Content-Length", List.of(Long.toString(Long.MIN_VALUE))), Long.MIN_VALUE }

   206         };

   207     }

   208 

   209     @Test(dataProvider = "valueAsLong")

   210     public void testValueAsLong(Map<String,List<String>> map, long expected) {

   211         HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);

   212         assertEquals(headers.firstValueAsLong("Content-Length").getAsLong(), expected);

   213     }

   214 

   215 

   216     @DataProvider(name = "duplicateNames")

   217     public Object[][] duplicateNames() {

   218         List<Map<String, List<String>>> maps = List.of(

   219                 Map.of("X-name", List.of(),

   220                        "x-name", List.of()),

   221                 Map.of("X-name", List.of(""),

   222                        "x-name", List.of("")),

   223                 Map.of("X-name", List.of("C"),

   224                        "x-name", List.of("D")),

   225                 Map.of("X-name", List.of("E"),

   226                        "Y-name", List.of("F"),

   227                        "X-Name", List.of("G")),

   228                 Map.of("X-chegar", List.of("H"),

   229                        "y-dfuchs", List.of("I"),

   230                        "Y-dfuchs", List.of("J")),

   231                 Map.of("X-name ", List.of("K"),

   232                        "X-Name", List.of("L")),

   233                 Map.of("X-name", List.of("M"),

   234                        "\rX-Name", List.of("N"))

   235         );

   236         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);

   237     }

   238 

   239     @Test(dataProvider = "duplicateNames")

   240     public void testDuplicates(Map<String,List<String>> map) {

   241         HttpHeaders headers;

   242         try {

   243             headers = HttpHeaders.of(map, ACCEPT_ALL);

   244             fail("UNEXPECTED: " + headers);

   245         } catch (IllegalArgumentException iae) {

   246             System.out.println("caught EXPECTED IAE:" + iae);

   247             assertTrue(iae.getMessage().contains("duplicate"));

   248         }

   249     }

   250 

   251 

   252     @DataProvider(name = "noSplittingJoining")

   253     public Object[][] noSplittingJoining() {

   254         List<Map<String, List<String>>> maps = List.of(

   255                 Map.of("A", List.of("B")),

   256                 Map.of("A", List.of("B", "C")),

   257                 Map.of("A", List.of("B", "C", "D")),

   258                 Map.of("A", List.of("B", "C", "D", "E")),

   259                 Map.of("A", List.of("B", "C", "D", "E", "F")),

   260                 Map.of("A", List.of("B, C")),

   261                 Map.of("A", List.of("B, C, D")),

   262                 Map.of("A", List.of("B, C, D, E")),

   263                 Map.of("A", List.of("B, C, D, E, F")),

   264                 Map.of("A", List.of("B, C", "D", "E", "F")),

   265                 Map.of("A", List.of("B", "C, D", "E", "F")),

   266                 Map.of("A", List.of("B", "C, D", "E, F")),

   267                 Map.of("A", List.of("B", "C, D, E", "F")),

   268                 Map.of("A", List.of("B", "C, D, E, F"))

   269         );

   270         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);

   271     }

   272 

   273     @Test(dataProvider = "noSplittingJoining")

   274     public void testNoSplittingJoining(Map<String,List<String>> map) {

   275         HttpHeaders headers = HttpHeaders.of(map, ACCEPT_ALL);

   276         Map<String,List<String>> headersMap = headers.map();

   277 

   278         assertEquals(headers.map().size(), map.size());

   279         for (Map.Entry<String,List<String>> entry : map.entrySet()) {

   280             String headerName = entry.getKey();

   281             List<String> headerValues = entry.getValue();

   282             assertEquals(headerValues, headersMap.get(headerName));

   283             assertEquals(headerValues, headers.allValues(headerName));

   284             assertEquals(headerValues.get(0), headers.firstValue(headerName).get());

   285         }

   286     }

   287 

   288 

   289     @DataProvider(name = "trimming")

   290     public Object[][] trimming() {

   291         List<Map<String, List<String>>> maps = List.of(

   292                 Map.of("A", List.of("B")),

   293                 Map.of(" A", List.of("B")),

   294                 Map.of("A ", List.of("B")),

   295                 Map.of("A", List.of(" B")),

   296                 Map.of("A", List.of("B ")),

   297                 Map.of("\tA", List.of("B")),

   298                 Map.of("A\t", List.of("B")),

   299                 Map.of("A", List.of("\tB")),

   300                 Map.of("A", List.of("B\t")),

   301                 Map.of("A\r", List.of("B")),

   302                 Map.of("A\n", List.of("B")),

   303                 Map.of("A\r\n", List.of("B"))

   304         );

   305         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);

   306     }

   307 

   308     @Test(dataProvider = "trimming")

   309     public void testTrimming(Map<String,List<String>> map) {

   310         HttpHeaders headers = HttpHeaders.of(map, (name, value) -> {

   311             assertEquals(name, "A");

   312             assertEquals(value, "B");

   313             return true;

   314         });

   315 

   316         assertEquals(headers.map().size(), 1);

   317         assertEquals(headers.firstValue("A").get(), "B");

   318         assertEquals(headers.allValues("A"), List.of("B"));

   319         assertTrue(headers.map().get("A").equals(List.of("B")));

   320     }

   321 

   322 

   323     @DataProvider(name = "emptyKey")

   324     public Object[][] emptyKey() {

   325         List<Map<String, List<String>>> maps = List.of(

   326                 Map.of("", List.of("B")),

   327                 Map.of(" ", List.of("B")),

   328                 Map.of("  ", List.of("B")),

   329                 Map.of("\t", List.of("B")),

   330                 Map.of("\t\t", List.of("B"))

   331         );

   332         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);

   333     }

   334 

   335     @Test(dataProvider = "emptyKey")

   336     public void testEmptyKey(Map<String,List<String>> map) {

   337         HttpHeaders headers;

   338         try {

   339             headers = HttpHeaders.of(map, ACCEPT_ALL);

   340             fail("UNEXPECTED: " + headers);

   341         } catch (IllegalArgumentException iae) {

   342             System.out.println("caught EXPECTED IAE:" + iae);

   343             assertTrue(iae.getMessage().contains("empty"));

   344         }

   345     }

   346 

   347 

   348     @DataProvider(name = "emptyValue")

   349     public Object[][] emptyValue() {

   350         List<Map<String, List<String>>> maps = List.of(

   351                 Map.of("A", List.of("")),

   352                 Map.of("A", List.of("", "")),

   353                 Map.of("A", List.of("", "", " ")),

   354                 Map.of("A", List.of("\t")),

   355                 Map.of("A", List.of("\t\t"))

   356         );

   357         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);

   358     }

   359 

   360     @Test(dataProvider = "emptyValue")

   361     public void testEmptyValue(Map<String,List<String>> map) {

   362         HttpHeaders headers = HttpHeaders.of(map, (name, value) -> {

   363             assertEquals(value, "");

   364             return true;

   365         });

   366         assertEquals(headers.map().size(), map.size());

   367         assertEquals(headers.map().get("A").get(0), "");

   368         headers.allValues("A").forEach(v -> assertEquals(v, ""));

   369         assertEquals(headers.firstValue("A").get(), "");

   370     }

   371 

   372 

   373     @DataProvider(name = "noValues")

   374     public Object[][] noValues() {

   375         List<Map<String, List<String>>> maps = List.of(

   376                 Map.of("A", List.of()),

   377                 Map.of("A", List.of(), "B", List.of()),

   378                 Map.of("A", List.of(), "B", List.of(), "C", List.of()),

   379                 Map.of("A", new ArrayList()),

   380                 Map.of("A", new LinkedList())

   381         );

   382         return maps.stream().map(p -> new Object[] { p }).toArray(Object[][]::new);

   383     }

   384 

   385     @Test(dataProvider = "noValues")

   386     public void testNoValues(Map<String,List<String>> map) {

   387         HttpHeaders headers = HttpHeaders.of(map, (name, value) -> {

   388             fail("UNEXPECTED call to filter");

   389             return true;

   390         });

   391         assertEquals(headers.map().size(), 0);

   392         assertEquals(headers.map().get("A"), null);

   393         assertEquals(headers.allValues("A").size(), 0);

   394         assertFalse(headers.firstValue("A").isPresent());

   395     }

   396 }