| /* |
| * Copyright (C) 2011 The Guava Authors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.google.common.net; |
| |
| import com.google.common.annotations.GwtCompatible; |
| import com.google.common.testing.SerializableTester; |
| |
| import junit.framework.TestCase; |
| |
| /** |
| * Tests for {@link HostAndPort} |
| * |
| * @author Paul Marks |
| */ |
| @GwtCompatible |
| public class HostAndPortTest extends TestCase { |
| |
| public void testFromStringWellFormed() { |
| // Well-formed inputs. |
| checkFromStringCase("google.com", 80, "google.com", 80, false); |
| checkFromStringCase("google.com", 80, "google.com", 80, false); |
| checkFromStringCase("192.0.2.1", 82, "192.0.2.1", 82, false); |
| checkFromStringCase("[2001::1]", 84, "2001::1", 84, false); |
| checkFromStringCase("2001::3", 86, "2001::3", 86, false); |
| checkFromStringCase("host:", 80, "host", 80, false); |
| } |
| |
| public void testFromStringBadDefaultPort() { |
| // Well-formed strings with bad default ports. |
| checkFromStringCase("gmail.com:81", -1, "gmail.com", 81, true); |
| checkFromStringCase("192.0.2.2:83", -1, "192.0.2.2", 83, true); |
| checkFromStringCase("[2001::2]:85", -1, "2001::2", 85, true); |
| checkFromStringCase("goo.gl:65535", 65536, "goo.gl", 65535, true); |
| // No port, bad default. |
| checkFromStringCase("google.com", -1, "google.com", -1, false); |
| checkFromStringCase("192.0.2.1", 65536, "192.0.2.1", -1, false); |
| checkFromStringCase("[2001::1]", -1, "2001::1", -1, false); |
| checkFromStringCase("2001::3", 65536, "2001::3", -1, false); |
| } |
| |
| public void testFromStringUnusedDefaultPort() { |
| // Default port, but unused. |
| checkFromStringCase("gmail.com:81", 77, "gmail.com", 81, true); |
| checkFromStringCase("192.0.2.2:83", 77, "192.0.2.2", 83, true); |
| checkFromStringCase("[2001::2]:85", 77, "2001::2", 85, true); |
| } |
| |
| public void testFromStringBadPort() { |
| // Out-of-range ports. |
| checkFromStringCase("google.com:65536", 1, null, 99, false); |
| checkFromStringCase("google.com:9999999999", 1, null, 99, false); |
| // Invalid port parts. |
| checkFromStringCase("google.com:port", 1, null, 99, false); |
| checkFromStringCase("google.com:-25", 1, null, 99, false); |
| checkFromStringCase("google.com:+25", 1, null, 99, false); |
| checkFromStringCase("google.com:25 ", 1, null, 99, false); |
| checkFromStringCase("google.com:25\t", 1, null, 99, false); |
| checkFromStringCase("google.com:0x25 ", 1, null, 99, false); |
| } |
| |
| public void testFromStringUnparseableNonsense() { |
| // Some nonsense that causes parse failures. |
| checkFromStringCase("[goo.gl]", 1, null, 99, false); |
| checkFromStringCase("[goo.gl]:80", 1, null, 99, false); |
| checkFromStringCase("[", 1, null, 99, false); |
| checkFromStringCase("[]:", 1, null, 99, false); |
| checkFromStringCase("[]:80", 1, null, 99, false); |
| checkFromStringCase("[]bad", 1, null, 99, false); |
| } |
| |
| public void testFromStringParseableNonsense() { |
| // Examples of nonsense that gets through. |
| checkFromStringCase("[[:]]", 86, "[:]", 86, false); |
| checkFromStringCase("x:y:z", 87, "x:y:z", 87, false); |
| checkFromStringCase("", 88, "", 88, false); |
| checkFromStringCase(":", 99, "", 99, false); |
| checkFromStringCase(":123", -1, "", 123, true); |
| checkFromStringCase("\nOMG\t", 89, "\nOMG\t", 89, false); |
| } |
| |
| private static void checkFromStringCase( |
| String hpString, |
| int defaultPort, |
| String expectHost, |
| int expectPort, |
| boolean expectHasExplicitPort) { |
| HostAndPort hp; |
| try { |
| hp = HostAndPort.fromString(hpString); |
| } catch (IllegalArgumentException e) { |
| // Make sure we expected this. |
| assertNull(expectHost); |
| return; |
| } |
| assertNotNull(expectHost); |
| |
| // Apply withDefaultPort(), yielding hp2. |
| final boolean badDefaultPort = (defaultPort < 0 || defaultPort > 65535); |
| HostAndPort hp2 = null; |
| try { |
| hp2 = hp.withDefaultPort(defaultPort); |
| assertFalse(badDefaultPort); |
| } catch (IllegalArgumentException e) { |
| assertTrue(badDefaultPort); |
| } |
| |
| // Check the pre-withDefaultPort() instance. |
| if (expectHasExplicitPort) { |
| assertTrue(hp.hasPort()); |
| assertEquals(expectPort, hp.getPort()); |
| } else { |
| assertFalse(hp.hasPort()); |
| try { |
| hp.getPort(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| } |
| assertEquals(expectHost, hp.getHostText()); |
| |
| // Check the post-withDefaultPort() instance (if any). |
| if (!badDefaultPort) { |
| try { |
| int port = hp2.getPort(); |
| assertTrue(expectPort != -1); |
| assertEquals(expectPort, port); |
| } catch (IllegalStateException e) { |
| // Make sure we expected this to fail. |
| assertEquals(-1, expectPort); |
| } |
| assertEquals(expectHost, hp2.getHostText()); |
| } |
| } |
| |
| public void testFromParts() { |
| HostAndPort hp = HostAndPort.fromParts("gmail.com", 81); |
| assertEquals("gmail.com", hp.getHostText()); |
| assertTrue(hp.hasPort()); |
| assertEquals(81, hp.getPort()); |
| |
| try { |
| HostAndPort.fromParts("gmail.com:80", 81); |
| fail("Expected IllegalArgumentException"); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| try { |
| HostAndPort.fromParts("gmail.com", -1); |
| fail("Expected IllegalArgumentException"); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| public void testFromHost() { |
| HostAndPort hp = HostAndPort.fromHost("gmail.com"); |
| assertEquals("gmail.com", hp.getHostText()); |
| assertFalse(hp.hasPort()); |
| |
| hp = HostAndPort.fromHost("[::1]"); |
| assertEquals("::1", hp.getHostText()); |
| assertFalse(hp.hasPort()); |
| |
| try { |
| HostAndPort.fromHost("gmail.com:80"); |
| fail("Expected IllegalArgumentException"); |
| } catch (IllegalArgumentException expected) { |
| } |
| |
| try { |
| HostAndPort.fromHost("[gmail.com]"); |
| fail("Expected IllegalArgumentException"); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| public void testGetPortOrDefault() { |
| assertEquals(80, HostAndPort.fromString("host:80").getPortOrDefault(123)); |
| assertEquals(123, HostAndPort.fromString("host").getPortOrDefault(123)); |
| } |
| |
| public void testHashCodeAndEquals() { |
| HostAndPort hp1 = HostAndPort.fromString("foo::123"); |
| HostAndPort hp2 = HostAndPort.fromString("foo::123"); |
| HostAndPort hp3 = HostAndPort.fromString("[foo::123]"); |
| HostAndPort hp4 = HostAndPort.fromParts("[foo::123]", 80); |
| HostAndPort hp5 = HostAndPort.fromString("[foo::123]:80"); |
| assertEquals(hp1.hashCode(), hp1.hashCode()); |
| assertEquals(hp1.hashCode(), hp2.hashCode()); |
| assertFalse(hp1.hashCode() == hp3.hashCode()); |
| assertFalse(hp3.hashCode() == hp4.hashCode()); |
| assertEquals(hp4.hashCode(), hp5.hashCode()); |
| |
| assertTrue(hp1.equals(hp1)); |
| assertTrue(hp1.equals(hp2)); |
| assertFalse(hp1.equals(hp3)); |
| assertFalse(hp3.equals(hp4)); |
| assertTrue(hp4.equals(hp5)); |
| assertFalse(hp1.equals(null)); |
| } |
| |
| public void testRequireBracketsForIPv6() { |
| // Bracketed IPv6 works fine. |
| assertEquals("::1", HostAndPort.fromString("[::1]").requireBracketsForIPv6().getHostText()); |
| assertEquals("::1", HostAndPort.fromString("[::1]:80").requireBracketsForIPv6().getHostText()); |
| // Non-bracketed non-IPv6 works fine. |
| assertEquals("x", HostAndPort.fromString("x").requireBracketsForIPv6().getHostText()); |
| assertEquals("x", HostAndPort.fromString("x:80").requireBracketsForIPv6().getHostText()); |
| |
| // Non-bracketed IPv6 fails. |
| try { |
| HostAndPort.fromString("::1").requireBracketsForIPv6(); |
| fail("Expected IllegalArgumentException"); |
| } catch (IllegalArgumentException expected) { |
| } |
| } |
| |
| public void testToString() { |
| // With ports. |
| assertEquals("foo:101", "" + HostAndPort.fromString("foo:101")); |
| assertEquals(":102", HostAndPort.fromString(":102").toString()); |
| assertEquals("[1::2]:103", HostAndPort.fromParts("1::2", 103).toString()); |
| assertEquals("[::1]:104", HostAndPort.fromString("[::1]:104").toString()); |
| |
| // Without ports. |
| assertEquals("foo", "" + HostAndPort.fromString("foo")); |
| assertEquals("", HostAndPort.fromString("").toString()); |
| assertEquals("[1::2]", HostAndPort.fromString("1::2").toString()); |
| assertEquals("[::1]", HostAndPort.fromString("[::1]").toString()); |
| |
| // Garbage in, garbage out. |
| assertEquals("[::]]:107", HostAndPort.fromParts("::]", 107).toString()); |
| assertEquals("[[:]]:108", HostAndPort.fromString("[[:]]:108").toString()); |
| } |
| |
| public void testSerialization() { |
| SerializableTester.reserializeAndAssert(HostAndPort.fromParts("host", 80)); |
| SerializableTester.reserializeAndAssert(HostAndPort.fromString("host")); |
| SerializableTester.reserializeAndAssert(HostAndPort.fromString("host:80")); |
| SerializableTester.reserializeAndAssert(HostAndPort.fromString("[::1]:104")); |
| SerializableTester.reserializeAndAssert(HostAndPort.fromParts("1::2", 103)); |
| } |
| } |