1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 package org.eclipse.jgit.transport;
16
17 import static org.junit.Assert.assertEquals;
18 import static org.junit.Assert.assertFalse;
19 import static org.junit.Assert.assertNull;
20 import static org.junit.Assert.assertTrue;
21
22 import java.io.File;
23 import java.io.IOException;
24 import java.net.URISyntaxException;
25
26 import org.junit.Ignore;
27 import org.junit.Test;
28
29 public class URIishTest {
30
31 private static final String GIT_SCHEME = "git://";
32
33 @SuppressWarnings("unused")
34 @Test(expected = URISyntaxException.class)
35 public void shouldRaiseErrorOnEmptyURI() throws Exception {
36 new URIish("");
37 }
38
39 @SuppressWarnings("unused")
40 @Test(expected = URISyntaxException.class)
41 public void shouldRaiseErrorOnNullURI() throws Exception {
42 new URIish((String) null);
43 }
44
45 @Test
46 public void testUnixFile() throws Exception {
47 final String str = "/home/m y";
48 URIish u = new URIish(str);
49 assertNull(u.getScheme());
50 assertFalse(u.isRemote());
51 assertEquals(str, u.getRawPath());
52 assertEquals(str, u.getPath());
53 assertEquals(str, u.toString());
54 assertEquals(str, u.toASCIIString());
55 assertEquals(u, new URIish(str));
56 }
57
58 @Test
59 public void testWindowsFile() throws Exception {
60 final String str = "D:/m y";
61 URIish u = new URIish(str);
62 assertNull(u.getScheme());
63 assertFalse(u.isRemote());
64 assertEquals(str, u.getRawPath());
65 assertEquals(str, u.getPath());
66 assertEquals(str, u.toString());
67 assertEquals(str, u.toASCIIString());
68 assertEquals(u, new URIish(str));
69 }
70
71 @Test
72 public void testWindowsFile2() throws Exception {
73 final String str = "D:\\m y";
74 URIish u = new URIish(str);
75 assertNull(u.getScheme());
76 assertFalse(u.isRemote());
77 assertEquals("D:\\m y", u.getRawPath());
78 assertEquals("D:\\m y", u.getPath());
79 assertEquals("D:\\m y", u.toString());
80 assertEquals("D:\\m y", u.toASCIIString());
81 assertEquals(u, new URIish(str));
82 }
83
84 @Test
85 public void testRelativePath() throws Exception {
86 final String str = "../../foo/bar";
87 URIish u = new URIish(str);
88 assertNull(u.getScheme());
89 assertFalse(u.isRemote());
90 assertEquals(str, u.getRawPath());
91 assertEquals(str, u.getPath());
92 assertEquals(str, u.toString());
93 assertEquals(str, u.toASCIIString());
94 assertEquals(u, new URIish(str));
95 }
96
97 @Test
98 public void testUNC() throws Exception {
99 final String str = "\\\\some\\place";
100 URIish u = new URIish(str);
101 assertNull(u.getScheme());
102 assertFalse(u.isRemote());
103 assertEquals("\\\\some\\place", u.getRawPath());
104 assertEquals("\\\\some\\place", u.getPath());
105 assertEquals("\\\\some\\place", u.toString());
106 assertEquals("\\\\some\\place", u.toASCIIString());
107 assertEquals(u, new URIish(str));
108 }
109
110 @Test
111 public void testFileProtoUnix() throws Exception {
112 final String str = "file:///home/m y";
113 URIish u = new URIish(str);
114 assertEquals("file", u.getScheme());
115 assertFalse(u.isRemote());
116 assertEquals("/home/m y", u.getRawPath());
117 assertEquals("/home/m y", u.getPath());
118 assertEquals("file:///home/m y", u.toString());
119 assertEquals("file:///home/m%20y", u.toASCIIString());
120 assertEquals(u, new URIish(str));
121 }
122
123 @Test
124 public void testURIEncode_00() throws Exception {
125 final String str = "file:///home/m%00y";
126 URIish u = new URIish(str);
127 assertEquals("file", u.getScheme());
128 assertFalse(u.isRemote());
129 assertEquals("/home/m%00y", u.getRawPath());
130 assertEquals("/home/m\u0000y", u.getPath());
131 assertEquals("file:///home/m%00y", u.toString());
132 assertEquals("file:///home/m%00y", u.toASCIIString());
133 assertEquals(u, new URIish(str));
134 }
135
136 @Test
137 public void testURIEncode_0a() throws Exception {
138 final String str = "file:///home/m%0ay";
139 URIish u = new URIish(str);
140 assertEquals("file", u.getScheme());
141 assertFalse(u.isRemote());
142 assertEquals("/home/m%0ay", u.getRawPath());
143 assertEquals("/home/m\ny", u.getPath());
144 assertEquals("file:///home/m%0ay", u.toString());
145 assertEquals("file:///home/m%0ay", u.toASCIIString());
146 assertEquals(u, new URIish(str));
147 }
148
149 @Test
150 public void testURIEncode_unicode() throws Exception {
151 final String str = "file:///home/m%c3%a5y";
152 URIish u = new URIish(str);
153 assertEquals("file", u.getScheme());
154 assertFalse(u.isRemote());
155 assertEquals("/home/m%c3%a5y", u.getRawPath());
156 assertEquals("/home/m\u00e5y", u.getPath());
157 assertEquals("file:///home/m%c3%a5y", u.toString());
158 assertEquals("file:///home/m%c3%a5y", u.toASCIIString());
159 assertEquals(u, new URIish(str));
160 }
161
162 @Test
163 public void testFileProtoWindows() throws Exception {
164 final String str = "file:///D:/m y";
165 URIish u = new URIish(str);
166 assertEquals("file", u.getScheme());
167 assertFalse(u.isRemote());
168 assertEquals(null, u.getHost());
169 assertEquals(-1, u.getPort());
170 assertEquals(null, u.getUser());
171 assertEquals(null, u.getPass());
172 assertEquals("D:/m y", u.getRawPath());
173 assertEquals("D:/m y", u.getPath());
174 assertEquals("file:///D:/m y", u.toString());
175 assertEquals("file:///D:/m%20y", u.toASCIIString());
176 assertEquals(u, new URIish(str));
177 }
178
179 @Test
180 public void testFileProtoWindowsWithHost() throws Exception {
181 final String str = "file://localhost/D:/m y";
182 URIish u = new URIish(str);
183 assertEquals("file", u.getScheme());
184 assertTrue(u.isRemote());
185 assertEquals("localhost", u.getHost());
186 assertEquals(-1, u.getPort());
187 assertEquals(null, u.getUser());
188 assertEquals(null, u.getPass());
189 assertEquals("D:/m y", u.getRawPath());
190 assertEquals("D:/m y", u.getPath());
191 assertEquals("file://localhost/D:/m y", u.toString());
192 assertEquals("file://localhost/D:/m%20y", u.toASCIIString());
193 assertEquals(u, new URIish(str));
194 }
195
196 @Test
197 public void testFileProtoWindowsWithHostAndPort() throws Exception {
198 final String str = "file://localhost:80/D:/m y";
199 URIish u = new URIish(str);
200 assertEquals("file", u.getScheme());
201 assertTrue(u.isRemote());
202 assertEquals("localhost", u.getHost());
203 assertEquals(80, u.getPort());
204 assertEquals(null, u.getUser());
205 assertEquals(null, u.getPass());
206 assertEquals("D:/m y", u.getRawPath());
207 assertEquals("D:/m y", u.getPath());
208 assertEquals("file://localhost:80/D:/m y", u.toString());
209 assertEquals("file://localhost:80/D:/m%20y", u.toASCIIString());
210 assertEquals(u, new URIish(str));
211 }
212
213 @Test
214 public void testFileProtoWindowsWithHostAndEmptyPortIsAmbiguous()
215 throws Exception {
216 final String str = "file://localhost:/D:/m y";
217 URIish u = new URIish(str);
218 assertEquals("file", u.getScheme());
219 assertFalse(u.isRemote());
220 assertEquals(null, u.getHost());
221 assertEquals(-1, u.getPort());
222 assertEquals(null, u.getUser());
223 assertEquals(null, u.getPass());
224 assertEquals("localhost:/D:/m y", u.getRawPath());
225 assertEquals("localhost:/D:/m y", u.getPath());
226 assertEquals("file:///localhost:/D:/m y", u.toString());
227 assertEquals("file:///localhost:/D:/m%20y", u.toASCIIString());
228 assertEquals(u, new URIish(str));
229 }
230
231 @Test
232 public void testFileProtoWindowsMissingHostSlash() throws Exception {
233 final String str = "file://D:/m y";
234 URIish u = new URIish(str);
235 assertEquals("file", u.getScheme());
236 assertFalse(u.isRemote());
237 assertEquals("D:/m y", u.getRawPath());
238 assertEquals("D:/m y", u.getPath());
239 assertEquals("file:///D:/m y", u.toString());
240 assertEquals("file:///D:/m%20y", u.toASCIIString());
241 assertEquals(u, new URIish(str));
242 }
243
244 @Test
245 public void testFileProtoWindowsMissingHostSlash2() throws Exception {
246 final String str = "file://D: /m y";
247 URIish u = new URIish(str);
248 assertEquals("file", u.getScheme());
249 assertFalse(u.isRemote());
250 assertEquals("D: /m y", u.getRawPath());
251 assertEquals("D: /m y", u.getPath());
252 assertEquals("file:///D: /m y", u.toString());
253 assertEquals("file:///D:%20/m%20y", u.toASCIIString());
254 assertEquals(u, new URIish(str));
255 }
256
257 @Test
258 public void testGitProtoUnix() throws Exception {
259 final String str = "git://example.com/home/m y";
260 URIish u = new URIish(str);
261 assertEquals("git", u.getScheme());
262 assertTrue(u.isRemote());
263 assertEquals("example.com", u.getHost());
264 assertEquals("/home/m y", u.getRawPath());
265 assertEquals("/home/m y", u.getPath());
266 assertEquals("git://example.com/home/m y", u.toString());
267 assertEquals("git://example.com/home/m%20y", u.toASCIIString());
268 assertEquals(u, new URIish(str));
269 }
270
271 @Test
272 public void testGitProtoUnixPort() throws Exception {
273 final String str = "git://example.com:333/home/m y";
274 URIish u = new URIish(str);
275 assertEquals("git", u.getScheme());
276 assertTrue(u.isRemote());
277 assertEquals("example.com", u.getHost());
278 assertEquals("/home/m y", u.getRawPath());
279 assertEquals("/home/m y", u.getPath());
280 assertEquals(333, u.getPort());
281 assertEquals("git://example.com:333/home/m y", u.toString());
282 assertEquals("git://example.com:333/home/m%20y", u.toASCIIString());
283 assertEquals(u, new URIish(str));
284 }
285
286 @Test
287 public void testGitProtoWindowsPort() throws Exception {
288 final String str = "git://example.com:338/D:/m y";
289 URIish u = new URIish(str);
290 assertEquals("git", u.getScheme());
291 assertTrue(u.isRemote());
292 assertEquals("D:/m y", u.getRawPath());
293 assertEquals("D:/m y", u.getPath());
294 assertEquals(338, u.getPort());
295 assertEquals("example.com", u.getHost());
296 assertEquals("git://example.com:338/D:/m y", u.toString());
297 assertEquals("git://example.com:338/D:/m%20y", u.toASCIIString());
298 assertEquals(u, new URIish(str));
299 }
300
301 @Test
302 public void testGitProtoWindows() throws Exception {
303 final String str = "git://example.com/D:/m y";
304 URIish u = new URIish(str);
305 assertEquals("git", u.getScheme());
306 assertTrue(u.isRemote());
307 assertEquals("D:/m y", u.getRawPath());
308 assertEquals("D:/m y", u.getPath());
309 assertEquals("example.com", u.getHost());
310 assertEquals(-1, u.getPort());
311 assertEquals("git://example.com/D:/m y", u.toString());
312 assertEquals("git://example.com/D:/m%20y", u.toASCIIString());
313 assertEquals(u, new URIish(str));
314 }
315
316 @Test
317 public void testScpStyleNoURIDecoding() throws Exception {
318 final String str = "example.com:some/p%20ath";
319 URIish u = new URIish(str);
320 assertNull(u.getScheme());
321 assertTrue(u.isRemote());
322 assertEquals("some/p%20ath", u.getRawPath());
323 assertEquals("some/p%20ath", u.getPath());
324 assertEquals("example.com", u.getHost());
325 assertEquals(-1, u.getPort());
326 assertEquals(str, u.toString());
327 assertEquals(str, u.toASCIIString());
328 assertEquals(u, new URIish(str));
329 }
330
331 @Test
332 public void testScpStyleWithoutUserRelativePath() throws Exception {
333 final String str = "example.com:some/p ath";
334 URIish u = new URIish(str);
335 assertNull(u.getScheme());
336 assertTrue(u.isRemote());
337 assertEquals("some/p ath", u.getRawPath());
338 assertEquals("some/p ath", u.getPath());
339 assertEquals("example.com", u.getHost());
340 assertEquals(-1, u.getPort());
341 assertEquals(str, u.toString());
342 assertEquals(str, u.toASCIIString());
343 assertEquals(u, new URIish(str));
344 }
345
346 @Test
347 public void testScpStyleWithoutUserAbsolutePath() throws Exception {
348 final String str = "example.com:/some/p ath";
349 URIish u = new URIish(str);
350 assertNull(u.getScheme());
351 assertTrue(u.isRemote());
352 assertEquals("/some/p ath", u.getRawPath());
353 assertEquals("/some/p ath", u.getPath());
354 assertEquals("example.com", u.getHost());
355 assertEquals(-1, u.getPort());
356 assertEquals(str, u.toString());
357 assertEquals(str, u.toASCIIString());
358 assertEquals(u, new URIish(str));
359 }
360
361 @Test
362 public void testScpStyleWithUser() throws Exception {
363 final String str = "user@example.com:some/p ath";
364 URIish u = new URIish(str);
365 assertNull(u.getScheme());
366 assertTrue(u.isRemote());
367 assertEquals("some/p ath", u.getRawPath());
368 assertEquals("some/p ath", u.getPath());
369 assertEquals("user", u.getUser());
370 assertEquals("example.com", u.getHost());
371 assertEquals(-1, u.getPort());
372 assertEquals(str, u.toString());
373 assertEquals(str, u.toASCIIString());
374 assertEquals(u, new URIish(str));
375 }
376
377 @Test
378 public void testGitSshProto() throws Exception {
379 final String str = "git+ssh://example.com/some/p ath";
380 URIish u = new URIish(str);
381 assertEquals("git+ssh", u.getScheme());
382 assertTrue(u.isRemote());
383 assertEquals("/some/p ath", u.getRawPath());
384 assertEquals("/some/p ath", u.getPath());
385 assertEquals("example.com", u.getHost());
386 assertEquals(-1, u.getPort());
387 assertEquals("git+ssh://example.com/some/p ath", u.toString());
388 assertEquals("git+ssh://example.com/some/p%20ath", u.toASCIIString());
389 assertEquals(u, new URIish(str));
390 }
391
392 @Test
393 public void testSshGitProto() throws Exception {
394 final String str = "ssh+git://example.com/some/p ath";
395 URIish u = new URIish(str);
396 assertEquals("ssh+git", u.getScheme());
397 assertTrue(u.isRemote());
398 assertEquals("/some/p ath", u.getRawPath());
399 assertEquals("/some/p ath", u.getPath());
400 assertEquals("example.com", u.getHost());
401 assertEquals(-1, u.getPort());
402 assertEquals("ssh+git://example.com/some/p ath", u.toString());
403 assertEquals("ssh+git://example.com/some/p%20ath", u.toASCIIString());
404 assertEquals(u, new URIish(str));
405 }
406
407 @Test
408 public void testSshProto() throws Exception {
409 final String str = "ssh://example.com/some/p ath";
410 URIish u = new URIish(str);
411 assertEquals("ssh", u.getScheme());
412 assertTrue(u.isRemote());
413 assertEquals("/some/p ath", u.getRawPath());
414 assertEquals("/some/p ath", u.getPath());
415 assertEquals("example.com", u.getHost());
416 assertEquals(-1, u.getPort());
417 assertEquals("ssh://example.com/some/p ath", u.toString());
418 assertEquals("ssh://example.com/some/p%20ath", u.toASCIIString());
419 assertEquals(u, new URIish(str));
420 }
421
422 @Test
423 public void testSshProtoHostOnly() throws Exception {
424 final String str = "ssh://example.com/";
425 URIish u = new URIish(str);
426 assertEquals("ssh", u.getScheme());
427 assertTrue(u.isRemote());
428 assertEquals("/", u.getRawPath());
429 assertEquals("/", u.getPath());
430 assertEquals("example.com", u.getHost());
431 assertEquals(-1, u.getPort());
432 assertEquals("ssh://example.com/", u.toString());
433 assertEquals("ssh://example.com/", u.toASCIIString());
434 assertEquals("example.com", u.getHumanishName());
435 assertEquals(u, new URIish(str));
436 }
437
438 @Test
439 public void testSshProtoHostWithAuthentication() throws Exception {
440 final String str = "ssh://user:secret@pass@example.com/";
441 URIish u = new URIish(str);
442 assertEquals("ssh", u.getScheme());
443 assertTrue(u.isRemote());
444 assertEquals("/", u.getRawPath());
445 assertEquals("/", u.getPath());
446 assertEquals("example.com", u.getHost());
447 assertEquals(-1, u.getPort());
448 assertEquals("ssh://user@example.com/", u.toString());
449 assertEquals("ssh://user@example.com/", u.toASCIIString());
450 assertEquals("example.com", u.getHumanishName());
451 assertEquals("user", u.getUser());
452 assertEquals("secret@pass", u.getPass());
453 assertEquals(u, new URIish(str));
454 }
455
456 @Test
457 public void testSshProtoHostWithPort() throws Exception {
458 final String str = "ssh://example.com:2222/";
459 URIish u = new URIish(str);
460 assertEquals("ssh", u.getScheme());
461 assertTrue(u.isRemote());
462 assertEquals("/", u.getRawPath());
463 assertEquals("/", u.getPath());
464 assertEquals("example.com", u.getHost());
465 assertEquals(2222, u.getPort());
466 assertEquals("ssh://example.com:2222/", u.toString());
467 assertEquals("ssh://example.com:2222/", u.toASCIIString());
468 assertEquals("example.com", u.getHumanishName());
469 assertEquals(u, new URIish(str));
470 }
471
472 @Test
473 public void testSshProtoHostWithEmptyPortAndPath() throws Exception {
474 final String str = "ssh://example.com:/path";
475 URIish u = new URIish(str);
476 assertEquals("ssh", u.getScheme());
477 assertTrue(u.isRemote());
478 assertEquals("/path", u.getRawPath());
479 assertEquals("/path", u.getPath());
480 assertEquals("example.com", u.getHost());
481 assertEquals(-1, u.getPort());
482 assertEquals("ssh://example.com/path", u.toString());
483 assertEquals("ssh://example.com/path", u.toASCIIString());
484 assertEquals(u, new URIish(str));
485 assertEquals(u, new URIish("ssh://example.com/path"));
486 }
487
488 @Test
489 public void testSshProtoWithUserAndPort() throws Exception {
490 final String str = "ssh://user@example.com:33/some/p ath";
491 URIish u = new URIish(str);
492 assertEquals("ssh", u.getScheme());
493 assertTrue(u.isRemote());
494 assertEquals("/some/p ath", u.getRawPath());
495 assertEquals("/some/p ath", u.getPath());
496 assertEquals("example.com", u.getHost());
497 assertEquals("user", u.getUser());
498 assertNull(u.getPass());
499 assertEquals(33, u.getPort());
500 assertEquals("ssh://user@example.com:33/some/p ath", u.toString());
501 assertEquals("ssh://user@example.com:33/some/p%20ath",
502 u.toASCIIString());
503 assertEquals(u, new URIish(str));
504 }
505
506 @Test
507 public void testSshProtoWithUserPassAndPort() throws Exception {
508 final String str = "ssh://user:pass@example.com:33/some/p ath";
509 URIish u = new URIish(str);
510 assertEquals("ssh", u.getScheme());
511 assertTrue(u.isRemote());
512 assertEquals("/some/p ath", u.getRawPath());
513 assertEquals("/some/p ath", u.getPath());
514 assertEquals("example.com", u.getHost());
515 assertEquals("user", u.getUser());
516 assertEquals("pass", u.getPass());
517 assertEquals(33, u.getPort());
518 assertEquals("ssh://user:pass@example.com:33/some/p ath",
519 u.toPrivateString());
520 assertEquals("ssh://user:pass@example.com:33/some/p%20ath",
521 u.toPrivateASCIIString());
522 assertEquals(u.setPass(null).toPrivateString(), u.toString());
523 assertEquals(u.setPass(null).toPrivateASCIIString(), u.toASCIIString());
524 assertEquals(u, new URIish(str));
525 }
526
527 @Test
528 public void testSshProtoWithEmailUserAndPort() throws Exception {
529 final String str = "ssh://user.name@email.com@example.com:33/some/p ath";
530 URIish u = new URIish(str);
531 assertEquals("ssh", u.getScheme());
532 assertTrue(u.isRemote());
533 assertEquals("/some/p ath", u.getRawPath());
534 assertEquals("/some/p ath", u.getPath());
535 assertEquals("example.com", u.getHost());
536 assertEquals("user.name@email.com", u.getUser());
537 assertNull(u.getPass());
538 assertEquals(33, u.getPort());
539 assertEquals("ssh://user.name%40email.com@example.com:33/some/p ath",
540 u.toPrivateString());
541 assertEquals("ssh://user.name%40email.com@example.com:33/some/p%20ath",
542 u.toPrivateASCIIString());
543 assertEquals(u.setPass(null).toPrivateString(), u.toString());
544 assertEquals(u.setPass(null).toPrivateASCIIString(), u.toASCIIString());
545 assertEquals(u, new URIish(str));
546 }
547
548 @Test
549 public void testSshProtoWithEmailUserPassAndPort() throws Exception {
550 final String str = "ssh://user.name@email.com:pass@wor:d@example.com:33/some/p ath";
551 URIish u = new URIish(str);
552 assertEquals("ssh", u.getScheme());
553 assertTrue(u.isRemote());
554 assertEquals("/some/p ath", u.getRawPath());
555 assertEquals("/some/p ath", u.getPath());
556 assertEquals("example.com", u.getHost());
557 assertEquals("user.name@email.com", u.getUser());
558 assertEquals("pass@wor:d", u.getPass());
559 assertEquals(33, u.getPort());
560 assertEquals("ssh://user.name%40email.com:pass%40wor%3ad@example.com:33/some/p ath",
561 u.toPrivateString());
562 assertEquals("ssh://user.name%40email.com:pass%40wor%3ad@example.com:33/some/p%20ath",
563 u.toPrivateASCIIString());
564 assertEquals(u.setPass(null).toPrivateString(), u.toString());
565 assertEquals(u.setPass(null).toPrivateASCIIString(), u.toASCIIString());
566 assertEquals(u, new URIish(str));
567 }
568
569 @Test
570 public void testSshProtoWithADUserPassAndPort() throws Exception {
571 final String str = "ssh://DOMAIN\\user:pass@example.com:33/some/p ath";
572 URIish u = new URIish(str);
573 assertEquals("ssh", u.getScheme());
574 assertTrue(u.isRemote());
575 assertEquals("/some/p ath", u.getRawPath());
576 assertEquals("/some/p ath", u.getPath());
577 assertEquals("example.com", u.getHost());
578 assertEquals("DOMAIN\\user", u.getUser());
579 assertEquals("pass", u.getPass());
580 assertEquals(33, u.getPort());
581 assertEquals("ssh://DOMAIN\\user:pass@example.com:33/some/p ath",
582 u.toPrivateString());
583 assertEquals("ssh://DOMAIN\\user:pass@example.com:33/some/p%20ath",
584 u.toPrivateASCIIString());
585 assertEquals(u.setPass(null).toPrivateString(), u.toString());
586 assertEquals(u.setPass(null).toPrivateASCIIString(), u.toASCIIString());
587 assertEquals(u, new URIish(str));
588 }
589
590 @Test
591 public void testSshProtoWithEscapedADUserPassAndPort() throws Exception {
592 final String str = "ssh://DOMAIN%5c\u00fcser:pass@example.com:33/some/p ath";
593 URIish u = new URIish(str);
594 assertEquals("ssh", u.getScheme());
595 assertTrue(u.isRemote());
596 assertEquals("/some/p ath", u.getRawPath());
597 assertEquals("/some/p ath", u.getPath());
598 assertEquals("example.com", u.getHost());
599 assertEquals("DOMAIN\\\u00fcser", u.getUser());
600 assertEquals("pass", u.getPass());
601 assertEquals(33, u.getPort());
602 assertEquals("ssh://DOMAIN\\\u00fcser:pass@example.com:33/some/p ath",
603 u.toPrivateString());
604 assertEquals(
605 "ssh://DOMAIN\\%c3%bcser:pass@example.com:33/some/p%20ath",
606 u.toPrivateASCIIString());
607 assertEquals(u.setPass(null).toPrivateString(), u.toString());
608 assertEquals(u.setPass(null).toPrivateASCIIString(), u.toASCIIString());
609 assertEquals(u, new URIish(str));
610 }
611
612 @Test
613 public void testURIEncodeDecode() throws Exception {
614 final String str = "ssh://%3ax%25:%40%41x@example.com:33/some%c3%a5/p%20a th";
615 URIish u = new URIish(str);
616 assertEquals("ssh", u.getScheme());
617 assertTrue(u.isRemote());
618 assertEquals("/some%c3%a5/p%20a th", u.getRawPath());
619 assertEquals("/some\u00e5/p a th", u.getPath());
620 assertEquals("example.com", u.getHost());
621 assertEquals(":x%", u.getUser());
622 assertEquals("@Ax", u.getPass());
623 assertEquals(33, u.getPort());
624 assertEquals("ssh://%3ax%25:%40Ax@example.com:33/some%c3%a5/p%20a th",
625 u.toPrivateString());
626 assertEquals(
627 "ssh://%3ax%25:%40Ax@example.com:33/some%c3%a5/p%20a%20th",
628 u.toPrivateASCIIString());
629 assertEquals(u.setPass(null).toPrivateString(), u.toString());
630 assertEquals(u.setPass(null).toPrivateASCIIString(), u.toASCIIString());
631 assertEquals(u, new URIish(str));
632 }
633
634 @Test
635 public void testGitWithUserHome() throws Exception {
636 final String str = "git://example.com/~some/p ath";
637 URIish u = new URIish(str);
638 assertEquals("git", u.getScheme());
639 assertTrue(u.isRemote());
640 assertEquals("~some/p ath", u.getRawPath());
641 assertEquals("~some/p ath", u.getPath());
642 assertEquals("example.com", u.getHost());
643 assertNull(u.getUser());
644 assertNull(u.getPass());
645 assertEquals(-1, u.getPort());
646 assertEquals("git://example.com/~some/p ath", u.toPrivateString());
647 assertEquals("git://example.com/~some/p%20ath",
648 u.toPrivateASCIIString());
649 assertEquals(u.setPass(null).toPrivateString(), u.toString());
650 assertEquals(u.setPass(null).toPrivateASCIIString(), u.toASCIIString());
651 assertEquals(u, new URIish(str));
652 }
653
654 @Test
655 @Ignore("Resolving ~user is beyond standard Java API and need more support")
656 public void testFileWithUserHome() throws Exception {
657 final String str = "~some/p ath";
658 URIish u = new URIish(str);
659 assertEquals("git", u.getScheme());
660 assertTrue(u.isRemote());
661 assertEquals("~some/p ath", u.getRawPath());
662 assertEquals("~some/p ath", u.getPath());
663 assertEquals("example.com", u.getHost());
664 assertNull(u.getUser());
665 assertNull(u.getPass());
666 assertEquals(-1, u.getPort());
667 assertEquals(str, u.toPrivateString());
668 assertEquals(str, u.toPrivateASCIIString());
669 assertEquals(u.setPass(null).toPrivateString(), u.toString());
670 assertEquals(u.setPass(null).toPrivateASCIIString(), u.toASCIIString());
671 assertEquals(u, new URIish(str));
672 }
673
674 @Test
675 public void testFileWithNoneUserHomeWithTilde() throws Exception {
676 final String str = "/~some/p ath";
677 URIish u = new URIish(str);
678 assertNull(u.getScheme());
679 assertFalse(u.isRemote());
680 assertEquals("/~some/p ath", u.getRawPath());
681 assertEquals("/~some/p ath", u.getPath());
682 assertNull(u.getHost());
683 assertNull(u.getUser());
684 assertNull(u.getPass());
685 assertEquals(-1, u.getPort());
686 assertEquals(str, u.toPrivateString());
687 assertEquals(str, u.toPrivateASCIIString());
688 assertEquals(u.setPass(null).toPrivateString(), u.toString());
689 assertEquals(u.setPass(null).toPrivateASCIIString(), u.toASCIIString());
690 assertEquals(u, new URIish(str));
691 }
692
693 @Test(expected = IllegalArgumentException.class)
694 public void testGetNullHumanishName() {
695 new URIish().getHumanishName();
696 }
697
698 @Test(expected = IllegalArgumentException.class)
699 public void testGetEmptyHumanishName() throws URISyntaxException {
700 new URIish(GIT_SCHEME).getHumanishName();
701 }
702
703 @Test(expected = IllegalArgumentException.class)
704 public void testGetAbsEmptyHumanishName() {
705 new URIish().getHumanishName();
706 }
707
708 @Test
709 public void testGetSet() throws Exception {
710 final String str = "ssh://DOMAIN\\user:pass@example.com:33/some/p ath%20";
711 URIish u = new URIish(str);
712 u = u.setHost(u.getHost());
713 u = u.setPass(u.getPass());
714 u = u.setPort(u.getPort());
715 assertEquals("ssh", u.getScheme());
716 assertTrue(u.isRemote());
717 u = u.setRawPath(u.getRawPath());
718 assertEquals("/some/p ath%20", u.getRawPath());
719 u = u.setPath(u.getPath());
720 assertEquals("/some/p ath ", u.getRawPath());
721 assertEquals("/some/p ath ", u.getPath());
722 assertEquals("example.com", u.getHost());
723 assertEquals("DOMAIN\\user", u.getUser());
724 assertEquals("pass", u.getPass());
725 assertEquals(33, u.getPort());
726 assertEquals("ssh://DOMAIN\\user:pass@example.com:33/some/p ath ",
727 u.toPrivateString());
728 assertEquals("ssh://DOMAIN\\user:pass@example.com:33/some/p%20ath%20",
729 u.toPrivateASCIIString());
730 assertEquals(u.setPass(null).toPrivateString(), u.toString());
731 assertEquals(u.setPass(null).toPrivateASCIIString(), u.toASCIIString());
732 assertEquals(u, new URIish(str));
733 }
734
735 @Test
736 public void testGetValidWithEmptySlashDotGitHumanishName()
737 throws IllegalArgumentException, URISyntaxException {
738 String humanishName = new URIish("/a/b/.git").getHumanishName();
739 assertEquals("b", humanishName);
740 }
741
742 @Test
743 public void testGetWithSlashDotGitHumanishName() throws URISyntaxException {
744 assertEquals("", new URIish("/.git").getHumanishName());
745 }
746
747 @Test
748 public void testGetTwoSlashesDotGitHumanishName() throws URISyntaxException {
749 assertEquals("", new URIish("//.git").getHumanishName());
750 }
751
752 @Test
753 public void testGetValidHumanishName() throws IllegalArgumentException,
754 URISyntaxException {
755 String humanishName = new URIish(GIT_SCHEME + "abc").getHumanishName();
756 assertEquals("abc", humanishName);
757 }
758
759 @Test
760 public void testGetEmptyHumanishNameWithAuthorityOnly() throws IllegalArgumentException,
761 URISyntaxException {
762 String humanishName = new URIish(GIT_SCHEME + "abc").getHumanishName();
763 assertEquals("abc", humanishName);
764 }
765
766 @Test
767 public void testGetValidSlashHumanishName()
768 throws IllegalArgumentException, URISyntaxException {
769 String humanishName = new URIish(GIT_SCHEME + "host/abc/")
770 .getHumanishName();
771 assertEquals("abc", humanishName);
772 }
773
774 @Test
775 public void testGetSlashValidSlashHumanishName()
776 throws IllegalArgumentException, URISyntaxException {
777 String humanishName = new URIish("/abc/").getHumanishName();
778 assertEquals("abc", humanishName);
779 }
780
781 @Test
782 public void testGetSlashValidSlashDotGitSlashHumanishName()
783 throws IllegalArgumentException, URISyntaxException {
784 String humanishName = new URIish("/abc/.git").getHumanishName();
785 assertEquals("abc", humanishName);
786 }
787
788 @Test
789 public void testGetSlashSlashDotGitSlashHumanishName()
790 throws IllegalArgumentException, URISyntaxException {
791 final String humanishName = new URIish(GIT_SCHEME + "/.git")
792 .getHumanishName();
793 assertEquals("may return an empty humanish name", "", humanishName);
794 }
795
796 @Test
797 public void testGetSlashesValidSlashHumanishName()
798 throws IllegalArgumentException, URISyntaxException {
799 String humanishName = new URIish("/a/b/c/").getHumanishName();
800 assertEquals("c", humanishName);
801 }
802
803 @Test
804 public void testGetValidDotGitHumanishName()
805 throws IllegalArgumentException, URISyntaxException {
806 String humanishName = new URIish(GIT_SCHEME + "abc.git")
807 .getHumanishName();
808 assertEquals("abc", humanishName);
809 }
810
811 @Test
812 public void testGetValidDotGitSlashHumanishName()
813 throws IllegalArgumentException, URISyntaxException {
814 String humanishName = new URIish(GIT_SCHEME + "host.xy/abc.git/")
815 .getHumanishName();
816 assertEquals("abc", humanishName);
817 }
818
819 @Test
820 public void testGetValidWithSlashDotGitHumanishName()
821 throws IllegalArgumentException, URISyntaxException {
822 String humanishName = new URIish("/abc.git").getHumanishName();
823 assertEquals("abc", humanishName);
824 }
825
826 @Test
827 public void testGetValidWithSlashDotGitSlashHumanishName()
828 throws IllegalArgumentException, URISyntaxException {
829 String humanishName = new URIish("/abc.git/").getHumanishName();
830 assertEquals("abc", humanishName);
831 }
832
833 @Test
834 public void testGetValidWithSlashesDotGitHumanishName()
835 throws IllegalArgumentException, URISyntaxException {
836 String humanishName = new URIish("/a/b/c.git").getHumanishName();
837 assertEquals("c", humanishName);
838 }
839
840 @Test
841 public void testGetValidWithSlashesDotGitSlashHumanishName()
842 throws IllegalArgumentException, URISyntaxException {
843 String humanishName = new URIish("/a/b/c.git/").getHumanishName();
844 assertEquals("c", humanishName);
845 }
846
847 @Test
848 public void testGetValidLocalWithTwoSlashesHumanishName()
849 throws IllegalArgumentException, URISyntaxException {
850 String humanishName = new URIish("/a/b/c//").getHumanishName();
851 assertEquals("c", humanishName);
852 }
853
854 @Test
855 public void testGetValidGitSchemeWithTwoSlashesHumanishName()
856 throws IllegalArgumentException, URISyntaxException {
857 String humanishName = new URIish(GIT_SCHEME + "/a/b/c//")
858 .getHumanishName();
859 assertEquals("c", humanishName);
860 }
861
862 @Test
863 public void testGetWindowsPathHumanishName()
864 throws IllegalArgumentException,
865 URISyntaxException {
866 if (File.separatorChar == '\\') {
867 String humanishName = new URIish("file:///C\\a\\b\\c.git/")
868 .getHumanishName();
869 assertEquals("c", humanishName);
870 }
871 }
872
873 @Test
874 public void testUserPasswordAndPort() throws URISyntaxException {
875 String str = "http://user:secret@host.xy:80/some/path";
876 URIish u = new URIish(str);
877 assertEquals("http", u.getScheme());
878 assertTrue(u.isRemote());
879 assertEquals("/some/path", u.getRawPath());
880 assertEquals("/some/path", u.getPath());
881 assertEquals("host.xy", u.getHost());
882 assertEquals(80, u.getPort());
883 assertEquals("user", u.getUser());
884 assertEquals("secret", u.getPass());
885 assertEquals(u, new URIish(str));
886
887 str = "http://user:secret@pass@host.xy:80/some/path";
888 u = new URIish(str);
889 assertEquals("http", u.getScheme());
890 assertTrue(u.isRemote());
891 assertEquals("/some/path", u.getPath());
892 assertEquals("host.xy", u.getHost());
893 assertEquals(80, u.getPort());
894 assertEquals("user", u.getUser());
895 assertEquals("secret@pass", u.getPass());
896 assertEquals(u, new URIish(str));
897 }
898
899
900
901
902
903
904
905 @Test
906 public void testPathSeparator() throws URISyntaxException {
907 String str = "http://user:secret@host.xy:80/some%2Fpath";
908 URIish u = new URIish(str);
909 assertEquals("http", u.getScheme());
910 assertTrue(u.isRemote());
911 assertEquals("/some%2Fpath", u.getRawPath());
912 assertEquals("/some/path", u.getPath());
913 assertEquals("host.xy", u.getHost());
914 assertEquals(80, u.getPort());
915 assertEquals("user", u.getUser());
916 assertEquals("secret", u.getPass());
917 assertEquals(u, new URIish(str));
918 }
919
920 @Test
921 public void testFileProtocol() throws IllegalArgumentException,
922 URISyntaxException, IOException {
923
924 URIish u = new URIish("file:///a/b.txt");
925 assertEquals("file", u.getScheme());
926 assertFalse(u.isRemote());
927 assertNull(u.getHost());
928 assertNull(u.getPass());
929 assertEquals("/a/b.txt", u.getRawPath());
930 assertEquals("/a/b.txt", u.getPath());
931 assertEquals(-1, u.getPort());
932 assertNull(u.getUser());
933 assertEquals("b.txt", u.getHumanishName());
934
935 File tmp = File.createTempFile("jgitUnitTest", ".tmp");
936 u = new URIish(tmp.toURI().toString());
937 assertEquals("file", u.getScheme());
938 assertFalse(u.isRemote());
939 assertNull(u.getHost());
940 assertNull(u.getPass());
941 assertTrue(u.getPath().contains("jgitUnitTest"));
942 assertEquals(-1, u.getPort());
943 assertNull(u.getUser());
944 assertTrue(u.getHumanishName().startsWith("jgitUnitTest"));
945
946 u = new URIish("file:/a/b.txt");
947 assertEquals("file", u.getScheme());
948 assertFalse(u.isRemote());
949 assertNull(u.getHost());
950 assertNull(u.getPass());
951 assertEquals("/a/b.txt", u.getRawPath());
952 assertEquals("/a/b.txt", u.getPath());
953 assertEquals(-1, u.getPort());
954 assertNull(u.getUser());
955 assertEquals("b.txt", u.getHumanishName());
956
957 u = new URIish("file:/a/test.bundle");
958 assertEquals("file", u.getScheme());
959 assertFalse(u.isRemote());
960 assertNull(u.getHost());
961 assertNull(u.getPass());
962 assertEquals("/a/test.bundle", u.getRawPath());
963 assertEquals("/a/test.bundle", u.getPath());
964 assertEquals(-1, u.getPort());
965 assertNull(u.getUser());
966 assertEquals("test", u.getHumanishName());
967 }
968
969 @Test
970 public void testALot() throws URISyntaxException {
971
972
973 String[][] tests = {
974 new String[] { "%1$s://%2$s:%3$s@%4$s:%5$s/%6$s", "%1$s",
975 "%2$s", "%3$s", "%4$s", "%5$s", "%6$s" },
976 new String[] { "%1$s://%2$s@%4$s:%5$s/%6$s", "%1$s", "%2$s",
977 null, "%4$s", "%5$s", "%6$s" },
978 new String[] { "%1$s://%2$s@%4$s/%6$s", "%1$s", "%2$s", null,
979 "%4$s", null, "%6$s" },
980 new String[] { "%1$s://%4$s/%6$s", "%1$s", null, null, "%4$s",
981 null, "%6$s" }, };
982 String[] schemes = new String[] { "ssh", "ssh+git", "http", "https" };
983 String[] users = new String[] { "me", "l usr\\example.com",
984 "lusr\\example" };
985 String[] passes = new String[] { "wtf", };
986 String[] hosts = new String[] { "example.com", "1.2.3.4", "[::1]" };
987 String[] ports = new String[] { "1234", "80" };
988 String[] paths = new String[] { "/", "/abc", "D:/x", "D:\\x" };
989 for (String[] test : tests) {
990 String fmt = test[0];
991 for (String scheme : schemes) {
992 for (String user : users) {
993 for (String pass : passes) {
994 for (String host : hosts) {
995 for (String port : ports) {
996 for (String path : paths) {
997 String url = String.format(fmt, scheme,
998 user, pass, host, port, path);
999 String[] expect = new String[test.length];
1000 for (int i = 1; i < expect.length; ++i)
1001 if (test[i] != null)
1002 expect[i] = String.format(test[i],
1003 scheme, user, pass, host,
1004 port, path);
1005 URIish urIish = new URIish(url);
1006 assertEquals(url, expect[1],
1007 urIish.getScheme());
1008 assertEquals(url, expect[2],
1009 urIish.getUser());
1010 }
1011 }
1012 }
1013 }
1014 }
1015 }
1016 }
1017 }
1018
1019 @Test
1020 public void testStringConstructor() throws Exception {
1021 String str = "http://example.com/";
1022 URIish u = new URIish(str);
1023 assertEquals("example.com", u.getHost());
1024 assertEquals("/", u.getPath());
1025 assertEquals(str, u.toString());
1026
1027 str = "http://example.com";
1028 u = new URIish(str);
1029 assertEquals("example.com", u.getHost());
1030 assertEquals("", u.getPath());
1031 assertEquals(str, u.toString());
1032 }
1033
1034 @Test
1035 public void testEqualsHashcode() throws Exception
1036 {
1037 String[] urls = { "http://user:pass@example.com:8081/path", "../x",
1038 "ssh://x.y:23/z", "ssh://example.com:/path", "D:\\m y",
1039 "\\\\some\\place", "http://localhost:1234",
1040 "user@example.com:some/p ath", "a",
1041 "http://user:pwd@example.com:8081/path",
1042 "http://user:pass@another.com:8081/path",
1043 "http://user:pass@example.com:8083/path" };
1044 URIish w = new URIish("http://user:pass@example.com:8081/path/x");
1045 for (String s : urls) {
1046 URIish u = new URIish(s);
1047 URIish v = new URIish(s);
1048 assertTrue(u.equals(v));
1049 assertTrue(v.equals(u));
1050
1051 assertFalse(u.equals(null));
1052 assertFalse(u.equals(new Object()));
1053 assertFalse(new Object().equals(u));
1054 assertFalse(u.equals(w));
1055 assertFalse(w.equals(u));
1056
1057 assertTrue(u.hashCode() == v.hashCode());
1058 assertFalse(u.hashCode() == new Object().hashCode());
1059 }
1060 }
1061 }