/*
* 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.testing.SerializableTester;
import junit.framework.TestCase;
/**
* Tests for {@link HostAndPort}
*
* @author Paul Marks
*/
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);
}
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("host:", 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(":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 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));
}
}