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