/*
* 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());
}
}
quality 87%
¤ Dauer der Verarbeitung: 0.17 Sekunden
(vorverarbeitet)
¤
*© Formatika GbR, Deutschland