~ubuntu-branches/ubuntu/quantal/aria2/quantal

« back to all changes in this revision

Viewing changes to test/RequestTest.cc

  • Committer: Bazaar Package Importer
  • Author(s): Kartik Mistry
  • Date: 2010-11-24 12:26:31 UTC
  • mfrom: (1.6.1 upstream) (2.3.8 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124122631-upujekj1ek94h3x2
Tags: 1.10.6-1
* New upstream release:
  + Fixed FTBFS on alpha arch (Closes: #590257)
  + Added IPv6 support (Closes: #448390)
* debian/patches/ftbfs_kfreebsd.diff:
  + Dropped, merged upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
5
5
#include "Netrc.h"
6
6
#include "DefaultAuthResolver.h"
7
7
#include "NetrcAuthResolver.h"
 
8
#include "uri.h"
8
9
 
9
10
namespace aria2 {
10
11
 
13
14
  CPPUNIT_TEST_SUITE(RequestTest);
14
15
  CPPUNIT_TEST(testSetUri1);
15
16
  CPPUNIT_TEST(testSetUri2);
16
 
  CPPUNIT_TEST(testSetUri3);
17
 
  CPPUNIT_TEST(testSetUri4);
18
 
  CPPUNIT_TEST(testSetUri5);
19
 
  CPPUNIT_TEST(testSetUri6);
20
17
  CPPUNIT_TEST(testSetUri7);
21
 
  CPPUNIT_TEST(testSetUri8);
22
 
  CPPUNIT_TEST(testSetUri9);
23
 
  CPPUNIT_TEST(testSetUri10);
24
 
  CPPUNIT_TEST(testSetUri11);
25
 
  CPPUNIT_TEST(testSetUri12);
26
 
  CPPUNIT_TEST(testSetUri13);
27
 
  CPPUNIT_TEST(testSetUri14);
28
 
  CPPUNIT_TEST(testSetUri15);
29
 
  CPPUNIT_TEST(testSetUri16);
30
18
  CPPUNIT_TEST(testSetUri17);
31
 
  CPPUNIT_TEST(testSetUri18);
32
 
  CPPUNIT_TEST(testSetUri19);
33
 
  CPPUNIT_TEST(testSetUri20);
34
 
  CPPUNIT_TEST(testSetUri_username);
35
 
  CPPUNIT_TEST(testSetUri_usernamePassword);
36
 
  CPPUNIT_TEST(testSetUri_zeroUsername);
37
19
  CPPUNIT_TEST(testSetUri_supportsPersistentConnection);
38
 
  CPPUNIT_TEST(testSetUri_ipv6);
39
20
  CPPUNIT_TEST(testRedirectUri);
40
21
  CPPUNIT_TEST(testRedirectUri2);
41
22
  CPPUNIT_TEST(testRedirectUri_supportsPersistentConnection);
49
30
public:
50
31
  void testSetUri1();
51
32
  void testSetUri2();
52
 
  void testSetUri3();
53
 
  void testSetUri4();
54
 
  void testSetUri5();
55
 
  void testSetUri6();
56
33
  void testSetUri7();
57
 
  void testSetUri8();
58
 
  void testSetUri9();
59
 
  void testSetUri10();
60
 
  void testSetUri11();
61
 
  void testSetUri12();
62
 
  void testSetUri13();
63
 
  void testSetUri14();
64
 
  void testSetUri15();
65
 
  void testSetUri16();
66
34
  void testSetUri17();
67
 
  void testSetUri18();
68
 
  void testSetUri19();
69
 
  void testSetUri20();
70
 
  void testSetUri_username();
71
 
  void testSetUri_usernamePassword();
72
 
  void testSetUri_zeroUsername();
73
35
  void testSetUri_supportsPersistentConnection();
74
 
  void testSetUri_ipv6();
75
36
  void testRedirectUri();
76
37
  void testRedirectUri2();
77
38
  void testRedirectUri_supportsPersistentConnection();
90
51
  bool v = req.setUri("http://aria.rednoah.com/");
91
52
 
92
53
  CPPUNIT_ASSERT(v);
93
 
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com/"), req.getUri());
94
 
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com/"), req.getCurrentUri());
 
54
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com/"),
 
55
                       req.getUri());
 
56
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com/"),
 
57
                       req.getCurrentUri());
95
58
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPreviousUri());
96
59
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
97
60
  CPPUNIT_ASSERT_EQUAL((uint16_t)80, req.getPort());
112
75
  CPPUNIT_ASSERT(v);
113
76
 
114
77
  // referer is unchaged
115
 
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080"), req.getReferer());
 
78
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080"),
 
79
                       req.getReferer());
116
80
  // previousUri must equal to referer;
117
81
  CPPUNIT_ASSERT_EQUAL(req.getReferer(), req.getPreviousUri());
118
82
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
123
87
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getQuery());
124
88
}
125
89
 
126
 
void RequestTest::testSetUri3() {
127
 
  Request req;
128
 
  bool v = req.setUri("http://aria.rednoah.com/aria2/index.html");
129
 
 
130
 
  CPPUNIT_ASSERT(v);
131
 
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
132
 
  CPPUNIT_ASSERT_EQUAL((uint16_t)80, req.getPort());
133
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
134
 
  CPPUNIT_ASSERT_EQUAL(std::string("/aria2"), req.getDir());
135
 
  CPPUNIT_ASSERT_EQUAL(std::string("index.html"), req.getFile());
136
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getQuery());
137
 
}
138
 
 
139
 
void RequestTest::testSetUri4() {
140
 
  Request req;
141
 
  bool v = req.setUri("http://aria.rednoah.com/aria2/aria3/index.html");
142
 
 
143
 
  CPPUNIT_ASSERT(v);
144
 
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
145
 
  CPPUNIT_ASSERT_EQUAL((uint16_t)80, req.getPort());
146
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
147
 
  CPPUNIT_ASSERT_EQUAL(std::string("/aria2/aria3"), req.getDir());
148
 
  CPPUNIT_ASSERT_EQUAL(std::string("index.html"), req.getFile());
149
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getQuery());
150
 
}
151
 
 
152
 
void RequestTest::testSetUri5() {
153
 
  Request req;
154
 
  bool v = req.setUri("http://aria.rednoah.com/aria2/aria3/");
155
 
 
156
 
  CPPUNIT_ASSERT(v);
157
 
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
158
 
  CPPUNIT_ASSERT_EQUAL((uint16_t)80, req.getPort());
159
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
160
 
  CPPUNIT_ASSERT_EQUAL(std::string("/aria2/aria3"), req.getDir());
161
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getFile());
162
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getQuery());
163
 
}
164
 
 
165
 
void RequestTest::testSetUri6() {
166
 
  Request req;
167
 
  bool v = req.setUri("http://aria.rednoah.com/aria2/aria3");
168
 
 
169
 
  CPPUNIT_ASSERT(v);
170
 
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
171
 
  CPPUNIT_ASSERT_EQUAL((uint16_t)80, req.getPort());
172
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
173
 
  CPPUNIT_ASSERT_EQUAL(std::string("/aria2"), req.getDir());
174
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria3"), req.getFile());
175
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getQuery());
176
 
}
177
 
 
178
90
void RequestTest::testSetUri7() {
179
91
  Request req;
180
92
  bool v = req.setUri("http://");
182
94
  CPPUNIT_ASSERT(!v);
183
95
}
184
96
 
185
 
void RequestTest::testSetUri8() {
186
 
  Request req;
187
 
  bool v = req.setUri("http:/aria.rednoah.com");
188
 
 
189
 
  CPPUNIT_ASSERT(!v);
190
 
}
191
 
 
192
 
void RequestTest::testSetUri9() {
193
 
  Request req;
194
 
  bool v = req.setUri("h");
195
 
 
196
 
  CPPUNIT_ASSERT(!v);
197
 
}
198
 
 
199
 
void RequestTest::testSetUri10() {
200
 
  Request req;
201
 
  bool v = req.setUri("");
202
 
 
203
 
  CPPUNIT_ASSERT(!v);
204
 
}
205
 
 
206
 
void RequestTest::testSetUri11() {
207
 
  Request req;
208
 
  bool v = req.setUri("http://host?query/");
209
 
 
210
 
  CPPUNIT_ASSERT(v);
211
 
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
212
 
  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
213
 
  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
214
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getFile());
215
 
  CPPUNIT_ASSERT_EQUAL(std::string("?query/"), req.getQuery());
216
 
}
217
 
 
218
 
void RequestTest::testSetUri12() {
219
 
  Request req;
220
 
  bool v = req.setUri("http://host?query");
221
 
  
222
 
  CPPUNIT_ASSERT(v);
223
 
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
224
 
  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
225
 
  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
226
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getFile());
227
 
  CPPUNIT_ASSERT_EQUAL(std::string("?query"), req.getQuery());
228
 
}
229
 
 
230
 
void RequestTest::testSetUri13() {
231
 
  Request req;
232
 
  bool v = req.setUri("http://host/?query");
233
 
  
234
 
  CPPUNIT_ASSERT(v);
235
 
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
236
 
  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
237
 
  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
238
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getFile());
239
 
  CPPUNIT_ASSERT_EQUAL(std::string("?query"), req.getQuery());
240
 
}
241
 
 
242
 
void RequestTest::testSetUri14() {
243
 
  Request req;
244
 
  bool v = req.setUri("http://host:8080/abc?query");
245
 
  
246
 
  CPPUNIT_ASSERT(v);
247
 
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
248
 
  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
249
 
  CPPUNIT_ASSERT_EQUAL((uint16_t)8080, req.getPort());
250
 
  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
251
 
  CPPUNIT_ASSERT_EQUAL(std::string("abc"), req.getFile());
252
 
  CPPUNIT_ASSERT_EQUAL(std::string("?query"), req.getQuery());
253
 
}
254
 
 
255
 
void RequestTest::testSetUri15()
256
 
{
257
 
  Request req;
258
 
  // 2 slashes after host name and dir
259
 
  bool v = req.setUri("http://host//dir1/dir2//file");
260
 
  CPPUNIT_ASSERT(v);
261
 
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
262
 
  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
263
 
  CPPUNIT_ASSERT_EQUAL(std::string("/dir1/dir2"), req.getDir());
264
 
  CPPUNIT_ASSERT_EQUAL(std::string("file"), req.getFile());
265
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getQuery());
266
 
}
267
 
 
268
 
void RequestTest::testSetUri16()
269
 
{
270
 
  Request req;
271
 
  // 2 slashes before file
272
 
  bool v = req.setUri("http://host//file");
273
 
  CPPUNIT_ASSERT(v);
274
 
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
275
 
  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
276
 
  CPPUNIT_ASSERT_EQUAL(std::string("/"), req.getDir());
277
 
  CPPUNIT_ASSERT_EQUAL(std::string("file"), req.getFile());
278
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getQuery());
279
 
}
280
 
 
281
97
void RequestTest::testSetUri17()
282
98
{
283
99
  Request req;
284
 
  bool v = req.setUri("http://host:80/file<with%2 %20space/file with space;param%?a=/?");
 
100
  bool v = req.setUri("http://host:80/file<with%2 %20space/"
 
101
                      "file with space;param%?a=/?");
285
102
  CPPUNIT_ASSERT(v);
286
103
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
287
104
  CPPUNIT_ASSERT_EQUAL(std::string("host"), req.getHost());
288
 
  CPPUNIT_ASSERT_EQUAL(std::string("/file%3Cwith%252%20%20space"), req.getDir());
289
 
  CPPUNIT_ASSERT_EQUAL(std::string("file%20with%20space;param%25"), req.getFile());
 
105
  CPPUNIT_ASSERT_EQUAL(std::string("/file%3Cwith%252%20%20space"),
 
106
                       req.getDir());
 
107
  CPPUNIT_ASSERT_EQUAL(std::string("file%20with%20space;param%25"),
 
108
                       req.getFile());
290
109
  CPPUNIT_ASSERT_EQUAL(std::string("?a=/?"), req.getQuery());
291
110
  CPPUNIT_ASSERT_EQUAL(std::string("http://host:80/file%3Cwith%252%20%20space"
292
111
                                   "/file%20with%20space;param%25?a=/?"),
296
115
                       req.getUri());
297
116
}
298
117
 
299
 
void RequestTest::testSetUri18() {
300
 
  Request req;
301
 
  bool v = req.setUri("http://1/");
302
 
 
303
 
  CPPUNIT_ASSERT(v);
304
 
}
305
 
 
306
 
void RequestTest::testSetUri19() {
307
 
  Request req;
308
 
  // No host
309
 
  bool v = req.setUri("http://user@");
310
 
 
311
 
  CPPUNIT_ASSERT(!v);
312
 
}
313
 
 
314
 
void RequestTest::testSetUri20() {
315
 
  Request req;
316
 
  bool v;
317
 
  // Invalid port
318
 
  v = req.setUri("http://localhost:65536");
319
 
  CPPUNIT_ASSERT(!v);
320
 
  v = req.setUri("http://localhost:65535");
321
 
  CPPUNIT_ASSERT(v);
322
 
  v = req.setUri("http://localhost:-80");
323
 
  CPPUNIT_ASSERT(!v);
324
 
}
325
 
 
326
 
void RequestTest::testRedirectUri() {
 
118
void RequestTest::testRedirectUri()
 
119
{
327
120
  Request req;
328
121
  req.supportsPersistentConnection(false);
329
122
  req.setUri("http://aria.rednoah.com:8080/aria2/index.html");
369
162
                       req.getCurrentUri());
370
163
}
371
164
 
372
 
void RequestTest::testRedirectUri2() {
 
165
void RequestTest::testRedirectUri2()
 
166
{
373
167
  Request req;
374
168
  req.setUri("http://aria.rednoah.com/download.html");
375
169
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPreviousUri());
393
187
                       req.getPreviousUri());
394
188
}
395
189
  
396
 
void RequestTest::testResetUri() {
 
190
void RequestTest::testResetUri()
 
191
{
397
192
  Request req;
398
193
  req.setUri("http://aria.rednoah.com:8080/aria2/index.html");
399
194
  req.setReferer("http://aria.rednoah.com:8080/");
402
197
  bool v3 = req.resetUri();
403
198
  CPPUNIT_ASSERT(v3);
404
199
  // currentUri must equal to uri
405
 
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080/aria2/index.html"), req.getUri());
 
200
  CPPUNIT_ASSERT_EQUAL
 
201
    (std::string("http://aria.rednoah.com:8080/aria2/index.html"),
 
202
     req.getUri());
406
203
  CPPUNIT_ASSERT_EQUAL(req.getUri(), req.getCurrentUri());
407
204
  // previousUri must equal to referer
408
 
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080/"), req.getPreviousUri());
 
205
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080/"),
 
206
                       req.getPreviousUri());
409
207
  // referer is unchanged
410
 
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080/"), req.getReferer());
 
208
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com:8080/"),
 
209
                       req.getReferer());
411
210
  CPPUNIT_ASSERT_EQUAL(std::string("http"), req.getProtocol());
412
211
  CPPUNIT_ASSERT_EQUAL((uint16_t)8080, req.getPort());
413
212
  CPPUNIT_ASSERT_EQUAL(std::string("aria.rednoah.com"), req.getHost());
416
215
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getQuery());
417
216
}
418
217
 
419
 
void RequestTest::testInnerLink() {
 
218
void RequestTest::testInnerLink()
 
219
{
420
220
  Request req;
421
221
  bool v = req.setUri("http://aria.rednoah.com/index.html#download");
422
222
  CPPUNIT_ASSERT(v);
429
229
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getQuery());
430
230
}
431
231
 
432
 
void RequestTest::testInnerLinkInReferer() {
 
232
void RequestTest::testInnerLinkInReferer()
 
233
{
433
234
  Request req;
434
235
  req.setReferer("http://aria.rednoah.com/home.html#top");
435
236
  CPPUNIT_ASSERT_EQUAL(std::string("http://aria.rednoah.com/home.html"),
436
237
                       req.getReferer());
437
238
}
438
239
 
439
 
void RequestTest::testSetUri_zeroUsername()
440
 
{
441
 
  Request req;
442
 
  CPPUNIT_ASSERT(req.setUri("ftp://@localhost/download/aria2-1.0.0.tar.bz2"));
443
 
  CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req.getProtocol());
444
 
  CPPUNIT_ASSERT_EQUAL((uint16_t)21, req.getPort());
445
 
  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req.getHost());
446
 
  CPPUNIT_ASSERT_EQUAL(std::string("/download"), req.getDir());
447
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"), req.getFile());
448
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getUsername());
449
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPassword());
450
 
 
451
 
  CPPUNIT_ASSERT(req.setUri("ftp://:@localhost/download/aria2-1.0.0.tar.bz2"));
452
 
  CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req.getProtocol());
453
 
  CPPUNIT_ASSERT_EQUAL((uint16_t)21, req.getPort());
454
 
  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req.getHost());
455
 
  CPPUNIT_ASSERT_EQUAL(std::string("/download"), req.getDir());
456
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"), req.getFile());
457
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getUsername());
458
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPassword());
459
 
 
460
 
  CPPUNIT_ASSERT(req.setUri("ftp://:pass@localhost/download/aria2-1.0.0.tar.bz2"));
461
 
  CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req.getProtocol());
462
 
  CPPUNIT_ASSERT_EQUAL((uint16_t)21, req.getPort());
463
 
  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req.getHost());
464
 
  CPPUNIT_ASSERT_EQUAL(std::string("/download"), req.getDir());
465
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"), req.getFile());
466
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getUsername());
467
 
  CPPUNIT_ASSERT_EQUAL(std::string("pass"), req.getPassword());
468
 
 
469
 
}
470
 
 
471
 
void RequestTest::testSetUri_username()
472
 
{
473
 
  Request req;
474
 
  CPPUNIT_ASSERT(req.setUri("ftp://aria2user@localhost/download/aria2-1.0.0.tar.bz2"));
475
 
  CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req.getProtocol());
476
 
  CPPUNIT_ASSERT_EQUAL((uint16_t)21, req.getPort());
477
 
  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req.getHost());
478
 
  CPPUNIT_ASSERT_EQUAL(std::string("/download"), req.getDir());
479
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"), req.getFile());
480
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria2user"), req.getUsername());
481
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPassword());
482
 
}
483
 
 
484
 
void RequestTest::testSetUri_usernamePassword()
485
 
{
486
 
  Request req;
487
 
  CPPUNIT_ASSERT(req.setUri("ftp://aria2user%40:aria2pass%40@localhost/download/aria2-1.0.0.tar.bz2"));
488
 
  CPPUNIT_ASSERT_EQUAL(std::string("ftp"), req.getProtocol());
489
 
  CPPUNIT_ASSERT_EQUAL((uint16_t)21, req.getPort());
490
 
  CPPUNIT_ASSERT_EQUAL(std::string("localhost"), req.getHost());
491
 
  CPPUNIT_ASSERT_EQUAL(std::string("/download"), req.getDir());
492
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria2-1.0.0.tar.bz2"), req.getFile());
493
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria2user@"), req.getUsername());
494
 
  CPPUNIT_ASSERT_EQUAL(std::string("aria2pass@"), req.getPassword());
495
 
 
496
 
  // make sure that after new uri is set, username and password are updated.
497
 
  CPPUNIT_ASSERT(req.setUri("ftp://localhost/download/aria2-1.0.0.tar.bz2"));
498
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getUsername());
499
 
  CPPUNIT_ASSERT_EQUAL(std::string(""), req.getPassword());
500
 
 
501
 
}
502
 
 
503
240
void RequestTest::testSetUri_supportsPersistentConnection()
504
241
{
505
242
  Request req;
530
267
  CPPUNIT_ASSERT(req.supportsPersistentConnection());
531
268
}
532
269
 
533
 
void RequestTest::testSetUri_ipv6()
534
 
{
535
 
  Request req;
536
 
  CPPUNIT_ASSERT(!req.setUri("http://[::1"));
537
 
  CPPUNIT_ASSERT(req.setUri("http://[::1]"));
538
 
  CPPUNIT_ASSERT_EQUAL(std::string("::1"), req.getHost());
539
 
 
540
 
  CPPUNIT_ASSERT(req.setUri("http://[::1]:8000/dir/file"));
541
 
  CPPUNIT_ASSERT_EQUAL(std::string("::1"), req.getHost());
542
 
  CPPUNIT_ASSERT_EQUAL((uint16_t)8000, req.getPort());
543
 
  CPPUNIT_ASSERT_EQUAL(std::string("/dir"), req.getDir());
544
 
  CPPUNIT_ASSERT_EQUAL(std::string("file"), req.getFile());
545
 
  CPPUNIT_ASSERT(req.isIPv6LiteralAddress());
546
 
}
547
 
 
548
270
void RequestTest::testGetURIHost()
549
271
{
550
272
  Request req;