00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202 import mango.io.Uri,
00203 mango.io.Stdio,
00204 mango.io.Token,
00205 mango.io.Reader,
00206 mango.io.Writer,
00207 mango.io.Buffer,
00208 mango.io.Socket,
00209 mango.io.Conduit,
00210 mango.io.FilePath,
00211 mango.io.FileStyle,
00212 mango.io.FileProxy,
00213 mango.io.Tokenizer,
00214 mango.io.TextReader,
00215 mango.io.TextWriter,
00216 mango.io.FileBucket,
00217 mango.io.FileConduit,
00218 mango.io.TextLayout,
00219 mango.io.TextFormat,
00220 mango.io.ColumnWriter,
00221 mango.io.DisplayWriter,
00222 mango.io.PickleReader,
00223 mango.io.PickleWriter,
00224 mango.io.SocketConduit,
00225 mango.io.SocketListener,
00226 mango.io.ArrayAllocator,
00227 mango.io.PickleRegistry,
00228 mango.io.DatagramSocket,
00229 mango.io.MulticastSocket;
00230
00231
00232 import mango.log.Logger,
00233 mango.log.Layout,
00234 mango.log.Manager,
00235 mango.log.DateLayout,
00236 mango.log.Configurator,
00237 mango.log.FileAppender,
00238 mango.log.StdioAppender,
00239 mango.log.ConsoleAppender,
00240 mango.log.RollingFileAppender;
00241
00242
00243 import mango.io.model.IReader,
00244 mango.io.model.IWriter,
00245 mango.io.model.IPickle;
00246
00247
00248 import mango.http.server.HttpParams,
00249 mango.http.server.HttpCookies,
00250 mango.http.server.HttpHeaders,
00251 mango.http.server.HttpServer,
00252 mango.http.server.HttpRequest,
00253 mango.http.server.HttpResponse,
00254 mango.http.server.HttpProvider;
00255
00256 import mango.http.server.model.IProvider,
00257 mango.http.server.model.IProviderBridge;
00258
00259 import mango.http.client.HttpClient;
00260
00261 import mango.servlet.Servlet,
00262 mango.servlet.ServletConfig,
00263 mango.servlet.ServletContext,
00264 mango.servlet.ServletProvider;
00265
00266 import mango.cache.PlainCache,
00267 mango.cache.HashMap,
00268 mango.cache.Payload,
00269 mango.cache.QueuedCache,
00270 mango.cache.VirtualCache;
00271
00272 import mango.cluster.Message,
00273 mango.cluster.NetworkQueue,
00274 mango.cluster.NetworkCache,
00275 mango.cluster.CacheInvalidator,
00276 mango.cluster.CacheInvalidatee;
00277
00278 import mango.cluster.qos.socket.Cluster,
00279 mango.cluster.qos.socket.ClusterServer,
00280 mango.cluster.qos.socket.ProtocolReader,
00281 mango.cluster.qos.socket.ProtocolWriter;
00282
00283
00284
00285
00286
00287
00288
00289 private Logger logger;
00290
00291
00292
00293
00294
00295
00296
00297
00298 static void testBuffer()
00299 {
00300
00301 Buffer buf = new Buffer (256);
00302
00303
00304 Writer w = new Writer (buf);
00305 Reader r = new Reader (buf);
00306
00307 int i = 10;
00308 int j = 20;
00309 double d = 3.14159;
00310 char[] c = "testing";
00311
00312
00313 w << c << i << j << d;
00314
00315
00316 r >> c >> i >> j >> d;
00317
00318 assert(i==10);
00319 assert(j==20);
00320 assert(d==3.14159);
00321 assert(c=="testing");
00322
00323
00324 buf.clear();
00325
00326
00327 w.put(c).put(i).put(j).put(d);
00328 r.get(c).get(j).get(i).get(d);
00329
00330 assert(i==20);
00331 assert(j==10);
00332 assert(d==3.14159);
00333 assert(c=="testing");
00334 }
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345 static void testAppend()
00346 {
00347 char[] foo = "to write some D code";
00348
00349
00350 Buffer buf = new Buffer (256);
00351
00352
00353 buf.append("now is the time for all good men ").append(foo);
00354
00355
00356 Stdout.put (buf.toString).cr();
00357 }
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367 static void testToken1()
00368 {
00369
00370 static ubyte[128] storage;
00371 Buffer buf = new Buffer (storage);
00372
00373
00374 IWriter w = new TextWriter (buf, ",");
00375
00376
00377 BoundToken token = new BoundToken (Tokenizers.comma);
00378
00379
00380 w.put("now is the time for all good men").put(3.14159);
00381
00382
00383 while (token.next (buf))
00384 Stdout.put (token).cr();
00385 }
00386
00387
00388
00389
00390
00391
00392
00393 static void testToken2()
00394 {
00395
00396 Buffer buf = new Buffer (256);
00397
00398
00399 IWriter w = new TextWriter (buf, ",");
00400
00401
00402 w << "now is the time for all good men" << 3.14159;
00403
00404
00405 ReaderToken text = new ReaderToken (Tokenizers.comma);
00406 ReaderToken number = new ReaderToken (Tokenizers.comma);
00407
00408
00409 IReader r = new Reader (buf);
00410
00411
00412 r >> text >> number;
00413
00414
00415 Stdout << text << ':' << number;
00416 Stdout.cr();
00417 }
00418
00419
00420
00421
00422
00423
00424
00425
00426 static void testToken3()
00427 {
00428
00429 Buffer buf = new Buffer (256);
00430
00431
00432 TextWriter tw = new TextWriter (buf, ",");
00433
00434
00435 tw << 101 << 3.14159;
00436
00437
00438 TextReader tr = new TextReader (buf, Tokenizers.comma);
00439
00440 real pi;
00441 int integer;
00442
00443
00444 tr >> integer >> pi;
00445
00446
00447 Stdout << integer << ',' << pi;
00448 Stdout.cr();
00449 }
00450
00451
00452
00453
00454
00455
00456
00457
00458 version (ArrayReaderSupport)
00459 {
00460 static void testToken4()
00461 {
00462
00463 FileConduit fc = new FileConduit ("test.txt");
00464
00465
00466 IBuffer buffer = fc.createBuffer ();
00467
00468
00469 TextReader tr = new TextReader (buffer, Tokenizers.line);
00470
00471 char[] ca;
00472
00473
00474 tr.get (ca);
00475
00476
00477 Stdout.put (ca).cr();
00478 }
00479 }
00480
00481
00482
00483
00484
00485
00486
00487
00488 static void testFormat()
00489 {
00490
00491 TextFormat tf = new TextFormat (256);
00492
00493
00494 Stdout.put (tf.format ("there are %d arguments to every %.*s", 3, "contradiction")).cr();
00495 }
00496
00497
00498
00499
00500
00501
00502
00503
00504 static void testLayout()
00505 {
00506
00507 TextLayout!(char) tl = new TextLayout!(char)(256);
00508
00509
00510 Stdout.put (tl.format ("%2 %1", "one", "two")).cr();
00511 }
00512
00513
00514
00515
00516
00517
00518
00519
00520 static void testClassIO()
00521 {
00522
00523 class Foo : IReadable, IWritable
00524 {
00525 private int x = 11;
00526 private int y = 112;
00527
00528 void write(IWriter writer)
00529 {
00530
00531 writer << x << y;
00532 }
00533
00534 void read(IReader reader)
00535 {
00536
00537 reader.get(x).get(y);
00538 }
00539 }
00540
00541
00542 Buffer buf = new Buffer (256);
00543
00544
00545 Writer w = new Writer(buf);
00546 Reader r = new Reader(buf);
00547
00548
00549 Foo foo = new Foo();
00550
00551
00552 w << foo;
00553
00554
00555 r >> foo;
00556 }
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570 static void testClassSerialization()
00571 {
00572
00573 class Bar : IPickle, IPickleFactory
00574 {
00575 private int x = 11;
00576 private int y = 112;
00577
00578 void write (IWriter writer)
00579 {
00580 writer.put(x).put(y);
00581 }
00582
00583 void read (IReader reader)
00584 {
00585 reader.get(x).get(y);
00586 assert (x == 11 && y == 112);
00587 }
00588
00589 Object create (IReader reader)
00590 {
00591 Bar bar = new Bar ();
00592 bar.read (reader);
00593 return bar;
00594 }
00595
00596 char[] getGuid ()
00597 {
00598 return "unittest.Bar";
00599 }
00600 }
00601
00602 static Object create (IReader reader)
00603 {
00604 Bar bar = new Bar();
00605 bar.read (reader);
00606 return bar;
00607 }
00608
00609
00610 Buffer buf = new Buffer (256);
00611 PickleWriter w = new PickleWriter (buf);
00612 PickleReader r = new PickleReader (buf);
00613
00614 r.setAllocator (new BufferAllocator(r));
00615
00616
00617 Bar bar = new Bar ();
00618
00619
00620
00621 PickleRegistry.enroll (bar);
00622
00623
00624 w.freeze (bar);
00625
00626
00627
00628 Object o = r.thaw ();
00629 }
00630
00631
00632
00633
00634
00635
00636
00637
00638 static void testFile4()
00639 {
00640
00641 FileConduit fc = new FileConduit ("test.txt");
00642
00643
00644 Stdio.stdout.copy (fc);
00645 }
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655 static void testRandomAccess()
00656 {
00657
00658 auto FileConduit fc = new FileConduit ("random.bin", FileStyle.ReadWriteCreate);
00659
00660
00661 Reader r = new Reader(fc);
00662 Writer w = new Writer(fc);
00663
00664 int x=10, y=20;
00665
00666
00667 w.put(x).put(y);
00668
00669
00670 w.flush();
00671
00672
00673 fc.seek (0);
00674
00675
00676 r.get(y).get(x);
00677
00678 assert (y==10);
00679 assert (x==20);
00680 }
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690 static void testConduitFilters()
00691 {
00692 class MyFilter1 : ConduitSource
00693 {
00694 int reader (void[] dst)
00695 {
00696 printf ("filtering input ...\n");
00697 return next.reader (dst);
00698 }
00699 }
00700
00701 class MyFilter2 : ConduitSink
00702 {
00703 int writer (void[] src)
00704 {
00705 printf ("filtering output ...\n");
00706 return next.writer (src);
00707 }
00708 }
00709
00710
00711 auto FileConduit fc = new FileConduit ("random.bin", FileStyle.ReadWriteCreate);
00712 fc.attach (new MyFilter2);
00713 fc.attach (new MyFilter1);
00714 fc.attach (new MyFilter1);
00715
00716
00717 Reader r = new Reader(fc);
00718 Writer w = new Writer(fc);
00719
00720 int x=1;
00721
00722
00723 w.put(x).flush();
00724
00725
00726 fc.seek (0);
00727
00728
00729 r.get(x);
00730 }
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740 static void testFile5()
00741 {
00742
00743 FileConduit fc = new FileConduit ("test.txt");
00744
00745
00746 IBuffer buffer = fc.createBuffer ();
00747
00748
00749
00750 while (fc.read (buffer) != fc.Eof)
00751 Stdio.stdout.write (buffer);
00752
00753
00754 Stdio.stdout.flush (buffer);
00755 }
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765 static void testFile1()
00766 {
00767
00768 FileConduit fc = new FileConduit ("test.txt");
00769
00770
00771 CompositeToken line = new CompositeToken (Tokenizers.line, fc);
00772
00773
00774
00775 while (line.get)
00776 Stdout.put(line).cr();
00777 }
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787 static void testFile2()
00788 {
00789
00790 FileConduit fc = new FileConduit ("test.txt");
00791
00792
00793 IBuffer buffer = fc.createBuffer();
00794
00795
00796 BoundToken line = new BoundToken (Tokenizers.line);
00797
00798
00799
00800 while (line.next(buffer) || line.getLength())
00801 Stdout.put(line).cr();
00802 }
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812 static void testFile3()
00813 {
00814
00815 FileConduit fc = new FileConduit ("test.txt");
00816
00817
00818 IBuffer buffer = fc.createBuffer();
00819
00820
00821 Token token = new Token ();
00822
00823
00824
00825 while (Tokenizers.line.next(buffer, token) || token.getLength())
00826 Stdout.put(token).cr();
00827 }
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837 void testScanFiles()
00838 {
00839
00840
00841
00842
00843 struct Dependencies
00844 {
00845 FileProxy[] mods;
00846 FilePath[] pkgs;
00847 }
00848
00849
00850
00851
00852
00853 void scanFiles (inout Dependencies deps, FilePath base)
00854 {
00855
00856
00857
00858
00859
00860
00861
00862 bit filter (FilePath fp)
00863 {
00864 char[] sbuf = fp.getExtension();
00865
00866 if (fp.getName[0] != '.')
00867 if (sbuf.length == 0 || sbuf == "d")
00868 return true;
00869
00870 return false;
00871 }
00872
00873
00874
00875
00876
00877 FileProxy proxy = new FileProxy (base);
00878 FilePath[] paths = proxy.toList (&filter);
00879
00880
00881 if (paths.length)
00882 deps.pkgs ~= base;
00883
00884 foreach (FilePath x; paths)
00885 {
00886
00887 FilePath spliced = new FilePath (x.splice (base));
00888
00889
00890 proxy = new FileProxy (spliced);
00891 if (proxy.isDirectory)
00892 scanFiles (deps, spliced);
00893 else
00894 deps.mods ~= proxy;
00895 }
00896 }
00897
00898
00899
00900
00901
00902
00903 Dependencies deps;
00904 scanFiles (deps, new FilePath (r"\dmd\src\mango"));
00905
00906 Stdout.put ("-----------------").cr();
00907 foreach (FileProxy mod; deps.mods)
00908 Stdout.put (mod.getPath()).cr();
00909
00910 Stdout.put ("-----------------").cr();
00911 foreach (FilePath pkg; deps.pkgs)
00912 Stdout.put (pkg).cr();
00913 }
00914
00915
00916
00917
00918
00919
00920
00921
00922
00923
00924
00925 static void testSocket()
00926 {
00927
00928 SocketConduit sc = new SocketConduit();
00929 sc.connect (new InternetAddress("www.digitalmars.com", 80));
00930
00931
00932 IWriter w = new DisplayWriter (new FlushBuffer(1024, sc));
00933
00934
00935 w << "GET /d/intro.html HTTP/1.1\r\n"
00936 "Host: www.digitalmars.com\r\n"
00937 "\r\n";
00938
00939
00940 sc.setTimeout (System.Interval.Millisec * 500);
00941
00942
00943 Stdio.stdout.copy (sc);
00944 }
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954 static void testColumn()
00955 {
00956 static int[] columns = [0, 4, 14, 24];
00957
00958
00959 ColumnWriter cw = new ColumnWriter (Stdout.getBuffer(), new ColumnList(columns));
00960
00961
00962 cw.setPrecision (2);
00963
00964
00965 cw.put(1);
00966 cw.put(20.34);
00967 cw.put("test");
00968 cw.cr();
00969 cw.put("next");
00970 }
00971
00972
00973
00974
00975
00976
00977
00978
00979 static void testStdin()
00980 {
00981 int x;
00982
00983
00984 Stdout << "Enter a number: ";
00985
00986
00987 Stdin >> x;
00988 }
00989
00990
00991 import std.regexp;
00992
00993
00994
00995
00996
00997
00998
00999 static void wordRegex (IBuffer buffer)
01000 {
01001
01002 RegexTokenizer rt = new RegexTokenizer (new RegExp(r"\w+", null));
01003
01004
01005 CompositeToken word = new CompositeToken (rt, buffer);
01006
01007
01008
01009 while (word.next)
01010 Stdout.put(word).cr();
01011 }
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022 static void testFileRegex()
01023 {
01024
01025 FileConduit fc = new FileConduit ("test.txt");
01026
01027
01028 wordRegex (fc.createBuffer);
01029 }
01030
01031
01032
01033
01034
01035
01036
01037
01038 static void testSocketRegex()
01039 {
01040
01041 SocketConduit sc = new SocketConduit();
01042 sc.connect (new InternetAddress("www.digitalmars.com", 80));
01043
01044
01045 IWriter w = new DisplayWriter (new FlushBuffer(256, sc));
01046
01047
01048 w << "GET /d/intro.html HTTP/1.1\r\n"
01049 "Host: www.digitalmars.com\r\n"
01050 "\r\n";
01051
01052
01053 sc.setTimeout (System.Interval.Millisec * 500);
01054
01055
01056 wordRegex (sc.createBuffer);
01057 }
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068 static void testLineRegex()
01069 {
01070
01071 FileConduit fc = new FileConduit ("test.txt");
01072
01073
01074 CompositeToken line = new CompositeToken (Tokenizers.line, fc);
01075
01076
01077
01078
01079
01080
01081
01082 Buffer rescan = new Buffer;
01083
01084
01085 while (line.get)
01086 {
01087
01088 rescan.setValidContent (line.toString);
01089
01090
01091 wordRegex (rescan);
01092 }
01093
01094 }
01095
01096
01097
01098
01099
01100
01101
01102 static void testFileSize()
01103 {
01104 FileProxy fp = new FileProxy ("test.txt");
01105
01106 Stdout.put (fp.getPath)
01107 .put(" is ")
01108 .put(fp.getSize)
01109 .put(" bytes long")
01110 .cr();
01111 }
01112
01113
01114
01115
01116
01117
01118
01119
01120 static void testFileList()
01121 {
01122 FileProxy proxy = new FileProxy (r".");
01123
01124 foreach (FilePath path; proxy.toList())
01125 Stdout.put(path).cr();
01126 }
01127
01128
01129
01130
01131
01132
01133
01134 static void testFilePath()
01135 {
01136 FilePath path = new FilePath (r"c:\1\2\3\4\abc.foo.bar");
01137
01138 Stdout << path << Writer.newline;
01139
01140 Uri uri = path.toUri();
01141 Stdout << uri.getScheme() << Writer.newline
01142 << uri.getHost() << Writer.newline
01143 << uri.getPath() << Writer.newline
01144 << uri.getPort() << Writer.newline
01145 << uri << Writer.newline;
01146
01147 uri = new Uri (uri.toString());
01148 Stdout << uri.getScheme() << Writer.newline
01149 << uri.getHost() << Writer.newline
01150 << uri.getPath() << Writer.newline
01151 << uri.getPort() << Writer.newline
01152 << uri << Writer.newline;
01153
01154 path = new FilePath (uri);
01155
01156 Stdout << path << Writer.newline;
01157 }
01158
01159
01160
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170
01171
01172 void testMappedFile()
01173 {
01174 FileConduit conduit = new FileConduit ("test.bin", FileStyle.ReadWriteCreate);
01175 conduit.seek (200_000_000);
01176 conduit.truncate ();
01177
01178 MappedBuffer buffer = conduit.createMappedBuffer;
01179 buffer.setPosition (100_000_000);
01180 buffer.append ("test");
01181 buffer.close ();
01182
01183 conduit.close ();
01184 }
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194 static void testCompositeIO()
01195 {
01196
01197 class Wumpus : IReadable, IWritable
01198 {
01199 private int x = 11,
01200 y = 112,
01201 z = 1024;
01202
01203 void write(IWriter writer)
01204 {
01205 writer.put(x).put(y).put(z);
01206 }
01207
01208 void read(IReader reader)
01209 {
01210 reader.get(x).get(y).get(z);
01211 }
01212
01213 }
01214
01215
01216 Wumpus wumpus = new Wumpus();
01217
01218
01219 FileConduit fc = new FileConduit ("random.bin", FileStyle.ReadWriteCreate);
01220
01221
01222 IWriter w = new Writer(fc);
01223 IReader r = new Reader(fc);
01224
01225
01226 w.put(wumpus).flush();
01227
01228
01229 fc.seek (0);
01230
01231
01232 r.get (wumpus);
01233
01234 fc.close();
01235 }
01236
01237
01238
01239
01240
01241
01242
01243
01244
01245
01246
01247
01248
01249
01250
01251 static void testDirectIO()
01252 {
01253
01254 auto FileConduit fc = new FileConduit ("random.bin", FileStyle.ReadWriteCreate);
01255
01256
01257 ubyte[1024] content;
01258
01259
01260
01261
01262 IBuffer direct = new Buffer(content, content.length);
01263
01264
01265 direct.setConduit(fc);
01266
01267
01268
01269
01270
01271
01272
01273 fc.write (direct);
01274
01275
01276 fc.seek (0);
01277
01278
01279 direct.clear();
01280
01281
01282 int count = fc.read (direct);
01283 delete fc;
01284
01285 }
01286
01287
01288
01289
01290
01291
01292 static void testUri()
01293 {
01294 MutableUri uri;
01295
01296 uri = new MutableUri ("ftp1://Me:My@a:21");
01297 Stdout << uri << Writer.newline;
01298
01299 uri.parse ("http://a:8080/b/c/d;p?q=bar of soap#fragmented");
01300 Stdout << uri << Writer.newline;
01301
01302 Stdin.wait();
01303
01304 for (int i=10_000_000; i > 0; --i)
01305 uri.parse ("http://a:8080/b/c/d;p?q=bar of soap#fragmented");
01306 }
01307
01308
01309
01310
01311
01312
01313
01314
01315
01316
01317
01318
01319
01320
01321
01322
01323
01324
01325
01326
01327
01328
01329 void testClient ()
01330 {
01331 Buffer buf = new Buffer(1024);
01332 InternetAddress addr = new InternetAddress("127.0.0.1", 80);
01333
01334 for (int i=50000; --i >= 0;)
01335 {
01336
01337 SocketConduit socket = new SocketConduit ();
01338 socket.connect (addr);
01339
01340
01341 socket.setLingerPeriod (0);
01342
01343
01344 buf.clear ();
01345
01346
01347
01348
01349
01350 buf.append ("GET / HTTP/1.1\n\n");
01351 /+
01352 buf.append("POST /RPC2 HTTP/1.1\n"
01353 "Content-Length: 157\n"
01354 "Content-Type: text/xml\n"
01355 "Cache-Control: no-cache\n"
01356 "Pragma: no-cache\n"
01357 "User-Agent: Java/1.4.2_05\n"
01358 "Host: localhost:8181\n"
01359 "Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2\n"
01360 "Connection: keep-alive\n\n"
01361 "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><methodCall>"
01362 "<methodName>nnCore.getNode</methodName><params><param>"
01363 "<value>1@1</value></param></params></methodCall>");
01364 +/
01365 socket.write (buf);
01366
01367
01368 socket.read (buf);
01369
01370
01371
01372
01373
01374 socket.shutdown ();
01375
01376
01377 socket.close ();
01378 delete socket;
01379 }
01380 }
01381
01382
01383
01384
01385
01386
01387
01388
01389 void testServer (IProvider provider)
01390 {
01391
01392 InternetAddress addr = new InternetAddress (80);
01393
01394
01395 HttpServer server = new HttpServer (provider, addr, 1);
01396
01397
01398 server.start ();
01399
01400
01401 Stdout << "hit return to start the client test ...";
01402 Stdin.wait ();
01403
01404
01405 long time = System.getMillisecs;
01406 testClient ();
01407 Stdout.put (System.getMillisecs - time).cr();
01408 }
01409
01410
01411
01412
01413
01414
01415
01416
01417
01418 void testHttpServer ()
01419 {
01420 class Provider : HttpProvider
01421 {
01422 void service (HttpRequest request, HttpResponse response)
01423 {
01424 response.sendError (HttpResponses.OK);
01425 }
01426 }
01427
01428
01429 testServer (new Provider());
01430 }
01431
01432
01433
01434
01435
01436
01437
01438
01439
01440 void testServletEngine ()
01441 {
01442
01443
01444
01445
01446
01447
01448 class FileServlet : MethodServlet
01449 {
01450 void doGet (IServletRequest request, IServletResponse response)
01451 {
01452 response.copyFile (request.getContext(), request.getPathInfo());
01453 }
01454 }
01455
01456
01457
01458
01459
01460
01461
01462
01463
01464 class MyServlet : Servlet
01465 {
01466 void service (IServletRequest request, IServletResponse response)
01467 {
01468 Uri uri = request.getUri();
01469
01470
01471 Stdout.put ("------------------------")
01472 .cr ()
01473 .put ("Uri: ")
01474 .put (uri)
01475 .cr ()
01476 .put ("------------------------")
01477 .cr ()
01478 .put ("Headers:")
01479 .cr ()
01480 .put (request.getHeaders())
01481 .put ("------------------------")
01482 .cr ()
01483 .put ("Cookies:")
01484 .cr ()
01485 .put (request.getCookies())
01486 .put ("------------------------")
01487 .cr ()
01488 .put ("Parameters:")
01489 .cr ()
01490 .put (request.getParameters())
01491 .put ("------------------------")
01492 .cr ();
01493
01494
01495 Stdout.put("encoding: ")
01496 .put(request.getCharacterEncoding())
01497 .cr ()
01498 .put("content length: ").put(request.getContentLength())
01499 .cr ()
01500 .put("content type: ").put(request.getContentType())
01501 .cr ()
01502 .put("protocol: ").put(request.getProtocol())
01503 .cr ()
01504 .put("scheme: ").put(uri.getScheme())
01505 .cr ()
01506 .put("method: ").put(request.getMethod())
01507 .cr ()
01508 .put("host name: ").put(request.getServerName())
01509 .cr ()
01510 .put("host port: ").put(request.getServerPort())
01511 .cr ()
01512
01513
01514 .put("path info: ").put(request.getPathInfo())
01515 .cr ()
01516 .put("query: ").put(uri.getQuery())
01517 .cr ()
01518 .put("path: ").put(uri.getPath())
01519 .cr ()
01520 .put("context path: ").put(request.getContextPath())
01521 .cr ()
01522 .cr ()
01523 .cr ();
01524
01525 int i = request.getContentLength();
01526
01527 if (i > 0)
01528 {
01529 byte[] content = new byte[i];
01530
01531 request.getReader.getPostData (content);
01532 printf ("Content:\n>>%.*s<<\n\n\n", content);
01533 }
01534
01535
01536 response.getCookies().add (new Cookie ("fu", "'bar of soap'"));
01537
01538
01539 IWriter writer = response.getWriter();
01540 writer.put ("<HTML><HEAD><TITLE>Form</TITLE></HEAD>")
01541 .put ("<BODY><FORM method=POST action=\"/context/test\">")
01542 .put ("Enter a POST parameter: ")
01543 .put ("<INPUT type=text name=\"name\"><P>")
01544 .put ("<INPUT type=hidden name=\"hidden\" value=\"test\"><P>")
01545 .put ("<INPUT type=submit>")
01546 .put ("<?FORM></BODY></HTML>")
01547 .cr ();
01548
01549 }
01550 }
01551
01552
01553
01554 ServletProvider sp = new ServletProvider();
01555
01556
01557 IRegisteredServlet files = sp.addServlet (new FileServlet(), "files");
01558 sp.addMapping ("*.html", files);
01559 sp.addMapping ("*.htm", files);
01560
01561
01562 IRegisteredServlet test = sp.addServlet (new MyServlet(), "test");
01563 sp.addMapping ("/", test);
01564
01565
01566 testServer (sp);
01567 }
01568
01569
01570
01571
01572
01573
01574
01575
01576
01577 void testHttpClient ()
01578 {
01579
01580
01581
01582
01583
01584
01585 void readBulk (IConduit conduit)
01586 {
01587
01588 Stdio.stdout.copy (conduit);
01589 }
01590
01591
01592
01593
01594
01595
01596
01597
01598 void readBulkExplicit (IConduit conduit)
01599 {
01600
01601 IBuffer buffer = conduit.createBuffer ();
01602
01603
01604
01605 while (conduit.read (buffer) != conduit.Eof)
01606 Stdio.stdout.write (buffer);
01607
01608
01609 assert (Stdio.stdout.flush (buffer));
01610 }
01611
01612
01613
01614
01615
01616
01617
01618
01619 void readLines (IConduit conduit)
01620 {
01621
01622 CompositeToken line = new CompositeToken (Tokenizers.line, conduit);
01623
01624
01625
01626 while (line.get)
01627 Stdout.put(line).cr();
01628 }
01629
01630
01631
01632
01633
01634
01635
01636
01637
01638
01639
01640
01641 void readChars (IConduit conduit)
01642 {
01643
01644 Reader reader = new Reader (conduit);
01645
01646
01647
01648
01649 try {
01650 while (true)
01651 {
01652 char c;
01653 reader.get (c);
01654 Stdout.put (c);
01655 }
01656 } catch (IOException x){}
01657 }
01658
01659
01660
01661
01662
01663
01664
01665
01666
01667 void readChunks (IConduit conduit)
01668 {
01669 IBuffer buffer = new Buffer(1024);
01670
01671 while (conduit.read (buffer) != conduit.Eof)
01672 {
01673 Stdout.put (buffer.toString);
01674 buffer.clear ();
01675 }
01676 }
01677
01678
01679
01680
01681
01682
01683
01684
01685
01686
01687
01688
01689 void readChunksExplicit (IConduit conduit)
01690 {
01691 char[1024] content;
01692
01693 IBuffer buffer = new Buffer (content);
01694
01695 while (conduit.read (buffer) != conduit.Eof)
01696 {
01697 Stdout.put (content[0..buffer.readable()]);
01698 buffer.clear ();
01699 }
01700 }
01701
01702
01703
01704
01705
01706
01707
01708
01709
01710 SocketConduit sc = new SocketConduit();
01711 sc.connect (new InternetAddress("www.digitalmars.com", 80));
01712
01713
01714 IWriter w = new DisplayWriter (new FlushBuffer (256, sc));
01715
01716
01717 w.put ("GET /d/intro.html HTTP/1.1")
01718 .cr ()
01719 .put ("Host: www.digitalmars.com")
01720 .cr ()
01721 .cr ();
01722
01723
01724 sc.setTimeout (System.Interval.Second);
01725
01726
01727
01728
01729
01730
01731 readChunksExplicit(sc);
01732 }
01733
01734
01735
01736
01737
01738
01739
01740
01741 void testHttpClient2 ()
01742 {
01743
01744 SocketConduit sc = new SocketConduit;
01745 sc.connect (new InternetAddress("www.digitalmars.com", 80));
01746
01747
01748 IWriter w = new DisplayWriter (new FlushBuffer (256, sc));
01749
01750
01751 w.put ("GET /d/intro.html HTTP/1.1")
01752 .cr ()
01753 .put ("Host: www.digitalmars.com")
01754 .cr ()
01755 .cr ();
01756
01757
01758 sc.setTimeout (System.Interval.Second);
01759
01760
01761 IBuffer buffer = sc.createBuffer;
01762
01763
01764 HttpHeaders headers = new HttpHeaders;
01765 headers.parse (buffer);
01766
01767
01768 foreach (HeaderElement header; headers)
01769 Stdout.put (header.name.value)
01770 .put (header.value)
01771 .cr ();
01772
01773
01774 while (sc.read (buffer) != sc.Eof)
01775 {
01776 Stdout.put (buffer.toString);
01777 buffer.clear ();
01778 }
01779 }
01780
01781
01782
01783
01784
01785
01786
01787 void testHttpClient3()
01788 {
01789
01790 void sink (char[] content)
01791 {
01792 Stdout.put (content);
01793 }
01794
01795
01796 auto HttpClient client = new HttpClient (HttpClient.Get, "http://www.digitalmars.com/d/intro.html");
01797
01798
01799 client.getRequestHeaders.add (HttpHeader.Host, client.getUri.getHost);
01800
01801
01802 client.open ();
01803
01804
01805 if (client.isResponseOK)
01806 {
01807
01808 int length = client.getResponseHeaders.getInt (HttpHeader.ContentLength);
01809 if (length < 0)
01810 length = int.max;
01811
01812
01813 Stdout.put (client.getResponseHeaders);
01814
01815
01816
01817 client.read (delegate (char[] c){Stdout.put(c);}, length);
01818 }
01819 else
01820 Stderr.put (client.getResponse);
01821 }
01822
01823
01824
01825
01826
01827
01828
01829
01830
01831
01832
01833
01834
01835
01836
01837 void testPlainCache()
01838 {
01839 PlainCache cache = new PlainCache (2);
01840
01841 cache.put ("a", new Payload);
01842 cache.put ("b", new Payload);
01843 cache.put ("c", new Payload);
01844 cache.put ("c", new Payload);
01845
01846 cache.extract ("b");
01847 assert (cache.get("a"));
01848 assert (cache.get("c"));
01849 assert (cache.get("b") is null);
01850 }
01851
01852
01853
01854
01855
01856
01857
01858
01859
01860
01861
01862
01863
01864
01865
01866
01867
01868 void testQueuedCache()
01869 {
01870 QueuedCache cache = new QueuedCache (2);
01871
01872 cache.put ("a", new Payload);
01873 cache.put ("b", new Payload);
01874 cache.put ("c", new Payload);
01875 cache.put ("c", new Payload);
01876
01877 assert (cache.get("a") is null);
01878 assert (cache.get("c"));
01879 }
01880
01881
01882
01883
01884
01885
01886
01887 void testFileBucket()
01888 {
01889 char[] text = "this is a test";
01890
01891 FileBucket bucket = new FileBucket (new FilePath ("bucket.bin"), FileBucket.HalfK, 0);
01892
01893
01894 bucket.put ("a", text);
01895 char[] b = cast(char[]) bucket.get ("a");
01896
01897 assert (b == text);
01898 bucket.close();
01899 }
01900
01901
01902
01903
01904
01905
01906
01907
01908
01909
01910
01911 void testVirtualCache()
01912 {
01913 FileBucket bucket = new FileBucket (new FilePath ("bucket.bin"), FileBucket.HalfK);
01914 VirtualCache cache = new VirtualCache (bucket, 2);
01915 PickleRegistry.enroll (new Payload);
01916
01917 cache.put ("a", new Payload);
01918 cache.put ("b", new Payload);
01919 cache.put ("c", new Payload);
01920
01921 assert (cache.get("a"));
01922 assert (cache.get("c"));
01923 assert (cache.get("b"));
01924 bucket.close();
01925 }
01926
01927
01928
01929
01930
01931
01932 void testProtocol()
01933 {
01934 class Protocol : Payload
01935 {
01936 char[] x;
01937 int y = 10;
01938 bool z = true;
01939
01940 this ()
01941 {
01942 x = "fred";
01943 }
01944
01945 static this()
01946 {
01947 PickleRegistry.enroll (new Protocol);
01948 }
01949
01950 void write (IWriter w)
01951 {
01952 super.write (w);
01953 w.put (x)
01954 .put (y)
01955 .put (z);
01956 }
01957
01958 void read (IReader r)
01959 {
01960 super.read (r);
01961 r.get (x)
01962 .get (y)
01963 .get (z);
01964
01965 assert (x == "fred");
01966 assert (y == 10);
01967 assert (z == true);
01968 }
01969
01970 Payload create ()
01971 {
01972 return new Protocol;
01973 }
01974
01975 char[] getGuid ()
01976 {
01977 return this.classinfo.name;
01978 }
01979 }
01980
01981 Protocol p = new Protocol;
01982
01983 Buffer b = new Buffer (1024);
01984 ProtocolWriter w = new ProtocolWriter (b);
01985 ProtocolReader r = new ProtocolReader (b);
01986
01987 w.put (w.Command.Exception, "mychannel", p);
01988
01989 ubyte cmd;
01990 char[] channel,
01991 element;
01992
01993 p = cast(Protocol) r.getPayload (channel, element, cmd);
01994 }
01995
01996
01997
01998
01999
02000
02001
02002 void testHashMap()
02003 {
02004 class AAPut
02005 {
02006 Object[char[]] aa;
02007
02008 synchronized void put (char[] k, Object v)
02009 {
02010 aa[k] = v;
02011 }
02012
02013 synchronized Object get (char[] k)
02014 {
02015 if (k in aa)
02016 return aa[k];
02017 return null;
02018 }
02019
02020 synchronized void del (char[] k)
02021 {
02022 delete aa[k];
02023 }
02024 }
02025
02026
02027 static const char[] key = "dkfsdflksdjf s;dklf kdfjf;lskdfjs d;flskdfjs dfl";
02028
02029 AAPut aa = new AAPut;
02030 HashMap map = new HashMap (1024);
02031
02032 map.put (key, Client.EmptyMessage);
02033 aa.put (key, Client.EmptyMessage);
02034
02035 map.put ("asdfasdfasdfasdfasdfasdfasdfasdfasdfasdf", Client.EmptyMessage);
02036 aa.put ("asdfasdfasdfasdfasdfasdfasdfasdfasdfasdf", Client.EmptyMessage);
02037
02038 map.put ("asdfasdfasdfasdfasdfasdfasdfasdfasdfasdf 34534 5345", Client.EmptyMessage);
02039 aa.put ("asdfasdfasdfasdfasdfasdfasdfasdfasdfasdf 3453453535", Client.EmptyMessage);
02040
02041 logger.info ("A");
02042 for (int i=5_000_000; --i;)
02043 {
02044 map.put (key, Client.EmptyMessage);
02045 map.remove (key);
02046
02047 }
02048
02049 logger.info ("B");
02050 for (int i=5_000_000; --i;)
02051 {
02052 aa.put (key, Client.EmptyMessage);
02053 aa.del (key);
02054
02055 }
02056
02057
02058
02059
02060
02061
02062
02063
02064
02065 }
02066
02067
02068
02069
02070
02071
02072
02073 version (Mango)
02074 {
02075 void testRollingFileLog()
02076 {
02077 Logger l = Logger.getLogger ("test");
02078 l.addAppender (new RollingFileAppender (new FilePath (r"e:\test.log"), 3, 1024, new DateLayout));
02079
02080 for (int i=100; --i;)
02081 l.error ("weqwer er wer werqwer wer wer wer wr wqrwe qrw rwe rwqerw");
02082 }
02083 }
02084
02085
02086
02087
02088
02089
02090
02091
02092
02093
02094
02095
02096
02097
02098
02099 void testMulticast()
02100 {
02101 class MyListener : SocketListener
02102 {
02103 this (ISocketReader reader, IBuffer buffer)
02104 {
02105 super (reader, buffer);
02106 }
02107
02108 void notify (IBuffer buffer)
02109 {
02110 printf ("listener received %d bytes\n", buffer.readable());
02111 }
02112
02113 void exception (char[] msg)
02114 {
02115 printf ("listener error: %.*s\n", msg);
02116 }
02117 }
02118
02119
02120 MulticastSocket ms = new MulticastSocket ();
02121 InternetAddress ia = new InternetAddress ("226.1.1.1", 4444);
02122
02123 ms.join (ia);
02124 MyListener s = new MyListener (ms, new Buffer (2000));
02125 s.start ();
02126
02127 Stdin.wait ();
02128
02129
02130
02131 byte[1000] xx;
02132 Buffer b = new Buffer (xx, xx.length);
02133
02134 ms.write (b, ia);
02135 Stdin.wait ();
02136
02137 }
02138
02139
02140
02141
02142
02143 void testClusterCache()
02144 {
02145
02146
02147
02148
02149
02150 Cluster cluster = new Cluster (logger, 4567);
02151
02152
02153 NetworkCache cc = new NetworkCache (cluster, "myChannel");
02154
02155 InvalidatorPayload p = new InvalidatorPayload;
02156
02157 cc.put ("key", p);
02158
02159 for (int i=100_000; i; --i)
02160 {
02161
02162
02163
02164 IPayload p = cc.get ("key");
02165
02166
02167
02168
02169
02170
02171
02172
02173
02174
02175 }
02176
02177
02178
02179
02180
02181 }
02182
02183
02184
02185
02186
02187
02188 void testClusterQueue()
02189 {
02190 class Listen : IEventListener
02191 {
02192 void notify (IEvent event, IPayload payload)
02193 {
02194 printf ("recieved queue entry from channel '%.*s'\n", event.getChannel.getName);
02195 }
02196 }
02197
02198
02199
02200
02201 Cluster cluster = new Cluster (logger, 4567);
02202 NetworkQueue queue = new NetworkQueue (cluster, "queue.channel");
02203
02204 queue.createConsumer (new Listen);
02205 queue.put (new InvalidatorPayload);
02206 queue.put (new InvalidatorPayload);
02207
02208 Stdin.wait ();
02209 }
02210
02211
02212
02213
02214
02215
02216 void testInvalidatee()
02217 {
02218 ICluster c = new Cluster (logger);
02219
02220 CacheInvalidatee dst = new CacheInvalidatee (c, "abc", new PlainCache);
02221 CacheInvalidator src = new CacheInvalidator (c, "abc");
02222
02223 src.invalidate ("key1");
02224
02225 Stdin.wait ();
02226 }
02227
02228
02229
02230
02231
02232
02233
02234 void testClusterServer()
02235 {
02236 ClusterServer cs = new ClusterServer (new InternetAddress(81), 1);
02237 SocketConduit sc = new SocketConduit ();
02238 cs.start();
02239
02240 sc.connect (new InternetAddress ("127.0.0.1", 81));
02241 Stdin.wait ();
02242 }
02243
02244
02245
02246
02247
02248
02249
02250
02251 void testClusterMessage()
02252 {
02253 class MessageListener : IEventListener
02254 {
02255 void notify (IEvent event, IPayload payload)
02256 {
02257 IMessage message = cast(IMessage) payload;
02258
02259 printf ("Replying to message\n");
02260 event.reply (message.getReply, new InvalidatorPayload);
02261 }
02262 }
02263
02264 class ReplyListener : IEventListener
02265 {
02266 void notify (IEvent event, IPayload payload)
02267 {
02268 printf ("Received reply\n");
02269 }
02270 }
02271
02272
02273
02274
02275
02276 Cluster cluster = new Cluster (logger, 4567);
02277
02278
02279 NetworkMessage msg = new NetworkMessage (cluster, "message.channel", new ReplyListener);
02280
02281
02282 msg.put (new NullMessage);
02283
02284
02285 msg.createConsumer (new MessageListener);
02286
02287
02288 Stdin.wait ();
02289 }
02290
02291
02292
02293
02294
02295
02296
02297 void testCacheLoader()
02298 {
02299 class CacheLoader : ICacheLoader
02300 {
02301 bool test (IPayload p)
02302 {
02303 return false;
02304 }
02305
02306 IPayload load (char[] key, long time)
02307 {
02308 printf ("loading local cache instance\n");
02309 return new NullMessage;
02310 }
02311 }
02312
02313 IMutableCache mc = new PlainCache;
02314 ICache c = mc.bind (new CacheLoader);
02315
02316 c.get ("abcde");
02317 }
02318
02319
02320
02321
02322
02323
02324
02325 void testRemoteCacheLoader()
02326 {
02327 class RemoteCacheLoader : Payload, IRemoteCacheLoader
02328 {
02329 bool test (IPayload p)
02330 {
02331 return false;
02332 }
02333
02334 IPayload load (char[] key, long time)
02335 {
02336 printf ("loading remote cache instance\n");
02337 return new NullMessage;
02338 }
02339
02340
02341
02342
02343
02344
02345
02346 void read (IReader reader)
02347 {
02348 super.read (reader);
02349 }
02350
02351
02352
02353
02354
02355
02356
02357 void write (IWriter writer)
02358 {
02359 super.write (writer);
02360 }
02361
02362
02363
02364
02365
02366
02367
02368
02369 Object create (IReader reader)
02370 {
02371 Payload r = new RemoteCacheLoader;
02372 r.read (reader);
02373 return r;
02374 }
02375
02376
02377
02378
02379
02380
02381
02382
02383
02384
02385 char[] getGuid ()
02386 {
02387 return this.classinfo.name;
02388 }
02389
02390
02391 uint pause (uint wait)
02392 {
02393 return 100_000;
02394 }
02395 }
02396
02397 Cluster cluster = new Cluster (logger, 4567);
02398 NetworkCache nc = new NetworkCache (cluster, "my.channel");
02399 IRemoteCacheLoader cl = new RemoteCacheLoader;
02400 ICache c = nc.bind (cl);
02401
02402 c.get ("abcde");
02403 }
02404
02405
02406
02407
02408
02409
02410
02411 void testDisplay ()
02412 {
02413 class Encoder : IStringEncoder
02414 {
02415 void char8 (void* src, uint count)
02416 {
02417 printf ("%.*s", count, src);
02418 }
02419
02420 void char16 (void* src, uint count)
02421 {
02422 assert (0);
02423 }
02424
02425 void char32 (void* src, uint count)
02426 {
02427 assert (0);
02428 }
02429 }
02430
02431 IWriter w = new DisplayWriter (Stdio.stdout.createBuffer());
02432 w.setStringEncoder (new Encoder);
02433
02434 ubyte b = 129;
02435 uint ui = uint.max;
02436 int i = -3;
02437
02438 w.put (1);
02439 w.put (' ');
02440 w.put (1.12);
02441
02442 w.put(b).put(' ')
02443 .put(ui).put(' ')
02444 .put(i).put(' ')
02445 .put("hello")
02446 .cr()
02447 .flush();
02448 }
02449
02450
02451
02452
02453
02454
02455
02456 void testTextWriter ()
02457 {
02458 class Encoder1 : IStringEncoder
02459 {
02460 void char8 (void* src, uint count)
02461 {
02462 printf ("%.*s", count, src);
02463 }
02464
02465 void char16 (void* src, uint count)
02466 {
02467 assert (0);
02468 }
02469
02470 void char32 (void* src, uint count)
02471 {
02472 assert (0);
02473 }
02474 }
02475
02476 IWriter w = new TextWriter (Stdout.getBuffer(), ", ");
02477 w.setStringEncoder (new Encoder1);
02478
02479 ubyte b = 129;
02480 uint ui = uint.max;
02481 int i = -3;
02482
02483 w.put(b)
02484 .put(ui)
02485 .put(i)
02486 .put("hello")
02487 .cr();
02488 w.put("test");
02489 w.flush();
02490 }
02491
02492
02493
02494
02495
02496
02497
02498 int main(char[][] args)
02499 {
02500 BasicConfigurator.configure ();
02501
02502 logger = Logger.getLogger ("mango.unittest");
02503
02504
02505
02506
02507 try {
02508
02509
02510
02511
02512
02513
02514
02515
02516
02517
02518
02519
02520
02521
02522
02523
02524
02525
02526
02527
02528
02529
02530
02531
02532
02533
02534
02535
02536
02537
02538
02539
02540
02541
02542
02543
02544
02545
02546
02547
02548
02549
02550
02551
02552
02553
02554
02555
02556
02557
02558
02559 logger.info ("Done");
02560 } catch (Object x)
02561 {
02562 logger.fatal (x.toString);
02563 }
02564
02565 return 0;
02566 }
02567