1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.google.common.net;
18
19 import com.google.common.annotations.GwtCompatible;
20 import com.google.common.testing.SerializableTester;
21
22 import junit.framework.TestCase;
23
24
25
26
27
28
29 @GwtCompatible
30 public class HostAndPortTest extends TestCase {
31
32 public void testFromStringWellFormed() {
33
34 checkFromStringCase("google.com", 80, "google.com", 80, false);
35 checkFromStringCase("google.com", 80, "google.com", 80, false);
36 checkFromStringCase("192.0.2.1", 82, "192.0.2.1", 82, false);
37 checkFromStringCase("[2001::1]", 84, "2001::1", 84, false);
38 checkFromStringCase("2001::3", 86, "2001::3", 86, false);
39 checkFromStringCase("host:", 80, "host", 80, false);
40 }
41
42 public void testFromStringBadDefaultPort() {
43
44 checkFromStringCase("gmail.com:81", -1, "gmail.com", 81, true);
45 checkFromStringCase("192.0.2.2:83", -1, "192.0.2.2", 83, true);
46 checkFromStringCase("[2001::2]:85", -1, "2001::2", 85, true);
47 checkFromStringCase("goo.gl:65535", 65536, "goo.gl", 65535, true);
48
49 checkFromStringCase("google.com", -1, "google.com", -1, false);
50 checkFromStringCase("192.0.2.1", 65536, "192.0.2.1", -1, false);
51 checkFromStringCase("[2001::1]", -1, "2001::1", -1, false);
52 checkFromStringCase("2001::3", 65536, "2001::3", -1, false);
53 }
54
55 public void testFromStringUnusedDefaultPort() {
56
57 checkFromStringCase("gmail.com:81", 77, "gmail.com", 81, true);
58 checkFromStringCase("192.0.2.2:83", 77, "192.0.2.2", 83, true);
59 checkFromStringCase("[2001::2]:85", 77, "2001::2", 85, true);
60 }
61
62 public void testFromStringBadPort() {
63
64 checkFromStringCase("google.com:65536", 1, null, 99, false);
65 checkFromStringCase("google.com:9999999999", 1, null, 99, false);
66
67 checkFromStringCase("google.com:port", 1, null, 99, false);
68 checkFromStringCase("google.com:-25", 1, null, 99, false);
69 checkFromStringCase("google.com:+25", 1, null, 99, false);
70 checkFromStringCase("google.com:25 ", 1, null, 99, false);
71 checkFromStringCase("google.com:25\t", 1, null, 99, false);
72 checkFromStringCase("google.com:0x25 ", 1, null, 99, false);
73 }
74
75 public void testFromStringUnparseableNonsense() {
76
77 checkFromStringCase("[goo.gl]", 1, null, 99, false);
78 checkFromStringCase("[goo.gl]:80", 1, null, 99, false);
79 checkFromStringCase("[", 1, null, 99, false);
80 checkFromStringCase("[]:", 1, null, 99, false);
81 checkFromStringCase("[]:80", 1, null, 99, false);
82 checkFromStringCase("[]bad", 1, null, 99, false);
83 }
84
85 public void testFromStringParseableNonsense() {
86
87 checkFromStringCase("[[:]]", 86, "[:]", 86, false);
88 checkFromStringCase("x:y:z", 87, "x:y:z", 87, false);
89 checkFromStringCase("", 88, "", 88, false);
90 checkFromStringCase(":", 99, "", 99, false);
91 checkFromStringCase(":123", -1, "", 123, true);
92 checkFromStringCase("\nOMG\t", 89, "\nOMG\t", 89, false);
93 }
94
95 private static void checkFromStringCase(
96 String hpString,
97 int defaultPort,
98 String expectHost,
99 int expectPort,
100 boolean expectHasExplicitPort) {
101 HostAndPort hp;
102 try {
103 hp = HostAndPort.fromString(hpString);
104 } catch (IllegalArgumentException e) {
105
106 assertNull(expectHost);
107 return;
108 }
109 assertNotNull(expectHost);
110
111
112 final boolean badDefaultPort = (defaultPort < 0 || defaultPort > 65535);
113 HostAndPort hp2 = null;
114 try {
115 hp2 = hp.withDefaultPort(defaultPort);
116 assertFalse(badDefaultPort);
117 } catch (IllegalArgumentException e) {
118 assertTrue(badDefaultPort);
119 }
120
121
122 if (expectHasExplicitPort) {
123 assertTrue(hp.hasPort());
124 assertEquals(expectPort, hp.getPort());
125 } else {
126 assertFalse(hp.hasPort());
127 try {
128 hp.getPort();
129 fail("Expected IllegalStateException");
130 } catch (IllegalStateException expected) {
131 }
132 }
133 assertEquals(expectHost, hp.getHostText());
134
135
136 if (!badDefaultPort) {
137 try {
138 int port = hp2.getPort();
139 assertTrue(expectPort != -1);
140 assertEquals(expectPort, port);
141 } catch (IllegalStateException e) {
142
143 assertEquals(-1, expectPort);
144 }
145 assertEquals(expectHost, hp2.getHostText());
146 }
147 }
148
149 public void testFromParts() {
150 HostAndPort hp = HostAndPort.fromParts("gmail.com", 81);
151 assertEquals("gmail.com", hp.getHostText());
152 assertTrue(hp.hasPort());
153 assertEquals(81, hp.getPort());
154
155 try {
156 HostAndPort.fromParts("gmail.com:80", 81);
157 fail("Expected IllegalArgumentException");
158 } catch (IllegalArgumentException expected) {
159 }
160
161 try {
162 HostAndPort.fromParts("gmail.com", -1);
163 fail("Expected IllegalArgumentException");
164 } catch (IllegalArgumentException expected) {
165 }
166 }
167
168 public void testFromHost() {
169 HostAndPort hp = HostAndPort.fromHost("gmail.com");
170 assertEquals("gmail.com", hp.getHostText());
171 assertFalse(hp.hasPort());
172
173 hp = HostAndPort.fromHost("[::1]");
174 assertEquals("::1", hp.getHostText());
175 assertFalse(hp.hasPort());
176
177 try {
178 HostAndPort.fromHost("gmail.com:80");
179 fail("Expected IllegalArgumentException");
180 } catch (IllegalArgumentException expected) {
181 }
182
183 try {
184 HostAndPort.fromHost("[gmail.com]");
185 fail("Expected IllegalArgumentException");
186 } catch (IllegalArgumentException expected) {
187 }
188 }
189
190 public void testGetPortOrDefault() {
191 assertEquals(80, HostAndPort.fromString("host:80").getPortOrDefault(123));
192 assertEquals(123, HostAndPort.fromString("host").getPortOrDefault(123));
193 }
194
195 public void testHashCodeAndEquals() {
196 HostAndPort hp1 = HostAndPort.fromString("foo::123");
197 HostAndPort hp2 = HostAndPort.fromString("foo::123");
198 HostAndPort hp3 = HostAndPort.fromString("[foo::123]");
199 HostAndPort hp4 = HostAndPort.fromParts("[foo::123]", 80);
200 HostAndPort hp5 = HostAndPort.fromString("[foo::123]:80");
201 assertEquals(hp1.hashCode(), hp1.hashCode());
202 assertEquals(hp1.hashCode(), hp2.hashCode());
203 assertFalse(hp1.hashCode() == hp3.hashCode());
204 assertFalse(hp3.hashCode() == hp4.hashCode());
205 assertEquals(hp4.hashCode(), hp5.hashCode());
206
207 assertTrue(hp1.equals(hp1));
208 assertTrue(hp1.equals(hp2));
209 assertFalse(hp1.equals(hp3));
210 assertFalse(hp3.equals(hp4));
211 assertTrue(hp4.equals(hp5));
212 assertFalse(hp1.equals(null));
213 }
214
215 public void testRequireBracketsForIPv6() {
216
217 assertEquals("::1", HostAndPort.fromString("[::1]").requireBracketsForIPv6().getHostText());
218 assertEquals("::1", HostAndPort.fromString("[::1]:80").requireBracketsForIPv6().getHostText());
219
220 assertEquals("x", HostAndPort.fromString("x").requireBracketsForIPv6().getHostText());
221 assertEquals("x", HostAndPort.fromString("x:80").requireBracketsForIPv6().getHostText());
222
223
224 try {
225 HostAndPort.fromString("::1").requireBracketsForIPv6();
226 fail("Expected IllegalArgumentException");
227 } catch (IllegalArgumentException expected) {
228 }
229 }
230
231 public void testToString() {
232
233 assertEquals("foo:101", "" + HostAndPort.fromString("foo:101"));
234 assertEquals(":102", HostAndPort.fromString(":102").toString());
235 assertEquals("[1::2]:103", HostAndPort.fromParts("1::2", 103).toString());
236 assertEquals("[::1]:104", HostAndPort.fromString("[::1]:104").toString());
237
238
239 assertEquals("foo", "" + HostAndPort.fromString("foo"));
240 assertEquals("", HostAndPort.fromString("").toString());
241 assertEquals("[1::2]", HostAndPort.fromString("1::2").toString());
242 assertEquals("[::1]", HostAndPort.fromString("[::1]").toString());
243
244
245 assertEquals("[::]]:107", HostAndPort.fromParts("::]", 107).toString());
246 assertEquals("[[:]]:108", HostAndPort.fromString("[[:]]:108").toString());
247 }
248
249 public void testSerialization() {
250 SerializableTester.reserializeAndAssert(HostAndPort.fromParts("host", 80));
251 SerializableTester.reserializeAndAssert(HostAndPort.fromString("host"));
252 SerializableTester.reserializeAndAssert(HostAndPort.fromString("host:80"));
253 SerializableTester.reserializeAndAssert(HostAndPort.fromString("[::1]:104"));
254 SerializableTester.reserializeAndAssert(HostAndPort.fromParts("1::2", 103));
255 }
256 }