Quelle HttpHeadersOf.java Sprache: JAVA

/*
* 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());
    }
}

quality87%

¤ Dauer der Verarbeitung: 0.2 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.