ceph/src/jaegertracing/thrift/test/netstd/Client/TestClient.cs

   1 // Licensed to the Apache Software Foundation(ASF) under one
   2 // or more contributor license agreements.See the NOTICE file
   3 // distributed with this work for additional information
   4 // regarding copyright ownership.The ASF licenses this file
   5 // to you under the Apache License, Version 2.0 (the
   6 // "License"); you may not use this file except in compliance
   7 // with the License. You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing,
  12 // software distributed under the License is distributed on an
  13 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  14 // KIND, either express or implied. See the License for the
  15 // specific language governing permissions and limitations
  16 // under the License.
  17
  18 using System;
  19 using System.Collections.Generic;
  20 using System.Diagnostics;
  21 using System.IO;
  22 using System.Linq;
  23 using System.Net;
  24 using System.Reflection;
  25 using System.Security.Authentication;
  26 using System.Security.Cryptography.X509Certificates;
  27 using System.ServiceModel;
  28 using System.Text;
  29 using System.Threading;
  30 using System.Threading.Tasks;
  31 using Thrift.Collections;
  32 using Thrift.Protocol;
  33 using Thrift.Transport;
  34 using Thrift.Transport.Client;
  35
  36 namespace ThriftTest
  37 {
  38     internal enum ProtocolChoice
  39     {
  40         Binary,
  41         Compact,
  42         Json
  43     }
  44
  45     // it does not make much sense to use buffered when we already use framed
  46     internal enum LayeredChoice
  47     {
  48         None,
  49         Buffered,
  50         Framed
  51     }
  52
  53
  54     internal enum TransportChoice
  55     {
  56         Socket,
  57         TlsSocket,
  58         Http,
  59         NamedPipe
  60     }
  61
  62     public class TestClient
  63     {
  64         private class TestParams
  65         {
  66             public int numIterations = 1;
  67             public string host = "localhost";
  68             public int port = 9090;
  69             public int numThreads = 1;
  70             public string url;
  71             public string pipe;
  72             public LayeredChoice layered = LayeredChoice.None;
  73             public ProtocolChoice protocol = ProtocolChoice.Binary;
  74             public TransportChoice transport = TransportChoice.Socket;
  75
  76             internal void Parse(List<string> args)
  77             {
  78                 for (var i = 0; i < args.Count; ++i)
  79                 {
  80                     if (args[i] == "-u")
  81                     {
  82                         url = args[++i];
  83                         transport = TransportChoice.Http;
  84                     }
  85                     else if (args[i] == "-n")
  86                     {
  87                         numIterations = Convert.ToInt32(args[++i]);
  88                     }
  89                     else if (args[i].StartsWith("--pipe="))
  90                     {
  91                         pipe = args[i].Substring(args[i].IndexOf("=") + 1);
  92                         transport = TransportChoice.NamedPipe;
  93                     }
  94                     else if (args[i].StartsWith("--host="))
  95                     {
  96                         // check there for ipaddress
  97                         host = args[i].Substring(args[i].IndexOf("=") + 1);
  98                         if (transport != TransportChoice.TlsSocket)
  99                             transport = TransportChoice.Socket;
 100                     }
 101                     else if (args[i].StartsWith("--port="))
 102                     {
 103                         port = int.Parse(args[i].Substring(args[i].IndexOf("=") + 1));
 104                         if (transport != TransportChoice.TlsSocket)
 105                             transport = TransportChoice.Socket;
 106                     }
 107                     else if (args[i] == "-b" || args[i] == "--buffered" || args[i] == "--transport=buffered")
 108                     {
 109                         layered = LayeredChoice.Buffered;
 110                     }
 111                     else if (args[i] == "-f" || args[i] == "--framed" || args[i] == "--transport=framed")
 112                     {
 113                         layered = LayeredChoice.Framed;
 114                     }
 115                     else if (args[i] == "-t")
 116                     {
 117                         numThreads = Convert.ToInt32(args[++i]);
 118                     }
 119                     else if (args[i] == "--binary" || args[i] == "--protocol=binary")
 120                     {
 121                         protocol = ProtocolChoice.Binary;
 122                     }
 123                     else if (args[i] == "--compact" || args[i] == "--protocol=compact")
 124                     {
 125                         protocol = ProtocolChoice.Compact;
 126                     }
 127                     else if (args[i] == "--json" || args[i] == "--protocol=json")
 128                     {
 129                         protocol = ProtocolChoice.Json;
 130                     }
 131                     else if (args[i] == "--ssl")
 132                     {
 133                         transport = TransportChoice.TlsSocket;
 134                     }
 135                     else if (args[i] == "--help")
 136                     {
 137                         PrintOptionsHelp();
 138                         return;
 139                     }
 140                     else
 141                     {
 142                         Console.WriteLine("Invalid argument: {0}", args[i]);
 143                         PrintOptionsHelp();
 144                         return;
 145                     }
 146                 }
 147
 148                 switch (transport)
 149                 {
 150                     case TransportChoice.Socket:
 151                         Console.WriteLine("Using socket transport");
 152                         break;
 153                     case TransportChoice.TlsSocket:
 154                         Console.WriteLine("Using encrypted transport");
 155                         break;
 156                     case TransportChoice.Http:
 157                         Console.WriteLine("Using HTTP transport");
 158                         break;
 159                     case TransportChoice.NamedPipe:
 160                         Console.WriteLine("Using named pipes transport");
 161                         break;
 162                     default:  // unhandled case
 163                         Debug.Assert(false);
 164                         break;
 165                 }
 166
 167                 switch (layered)
 168                 {
 169                     case LayeredChoice.Framed:
 170                         Console.WriteLine("Using framed transport");
 171                         break;
 172                     case LayeredChoice.Buffered:
 173                         Console.WriteLine("Using buffered transport");
 174                         break;
 175                     default:  // unhandled case?
 176                         Debug.Assert(layered == LayeredChoice.None);
 177                         break;
 178                 }
 179
 180                 switch (protocol)
 181                 {
 182                     case ProtocolChoice.Binary:
 183                         Console.WriteLine("Using binary protocol");
 184                         break;
 185                     case ProtocolChoice.Compact:
 186                         Console.WriteLine("Using compact protocol");
 187                         break;
 188                     case ProtocolChoice.Json:
 189                         Console.WriteLine("Using JSON protocol");
 190                         break;
 191                     default:  // unhandled case?
 192                         Debug.Assert(false);
 193                         break;
 194                 }
 195             }
 196
 197             private static X509Certificate2 GetClientCert()
 198             {
 199                 var clientCertName = "client.p12";
 200                 var possiblePaths = new List<string>
 201                 {
 202                     "../../../keys/",
 203                     "../../keys/",
 204                     "../keys/",
 205                     "keys/",
 206                 };
 207
 208                 string existingPath = null;
 209                 foreach (var possiblePath in possiblePaths)
 210                 {
 211                     var path = Path.GetFullPath(possiblePath + clientCertName);
 212                     if (File.Exists(path))
 213                     {
 214                         existingPath = path;
 215                         break;
 216                     }
 217                 }
 218
 219                 if (string.IsNullOrEmpty(existingPath))
 220                 {
 221                     throw new FileNotFoundException($"Cannot find file: {clientCertName}");
 222                 }
 223
 224                 var cert = new X509Certificate2(existingPath, "thrift");
 225
 226                 return cert;
 227             }
 228
 229             public TTransport CreateTransport()
 230             {
 231                 // endpoint transport
 232                 TTransport trans = null;
 233
 234                 switch (transport)
 235                 {
 236                     case TransportChoice.Http:
 237                         Debug.Assert(url != null);
 238                         trans = new THttpTransport(new Uri(url), null);
 239                         break;
 240
 241                     case TransportChoice.NamedPipe:
 242                         Debug.Assert(pipe != null);
 243                         trans = new TNamedPipeTransport(pipe);
 244                         break;
 245
 246                     case TransportChoice.TlsSocket:
 247                         var cert = GetClientCert();
 248                         if (cert == null || !cert.HasPrivateKey)
 249                         {
 250                             throw new InvalidOperationException("Certificate doesn't contain private key");
 251                         }
 252
 253                         trans = new TTlsSocketTransport(host, port, 0, cert,
 254                             (sender, certificate, chain, errors) => true,
 255                             null, SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12);
 256                         break;
 257
 258                     case TransportChoice.Socket:
 259                     default:
 260                         trans = new TSocketTransport(host, port);
 261                         break;
 262                 }
 263
 264
 265                 // layered transport
 266                 switch (layered)
 267                 {
 268                     case LayeredChoice.Buffered:
 269                         trans = new TBufferedTransport(trans);
 270                         break;
 271                     case LayeredChoice.Framed:
 272                         trans = new TFramedTransport(trans);
 273                         break;
 274                     default:
 275                         Debug.Assert(layered == LayeredChoice.None);
 276                         break;
 277                 }
 278
 279                 return trans;
 280             }
 281
 282             public TProtocol CreateProtocol(TTransport transport)
 283             {
 284                 switch (protocol)
 285                 {
 286                     case ProtocolChoice.Compact:
 287                         return new TCompactProtocol(transport);
 288                     case ProtocolChoice.Json:
 289                         return new TJsonProtocol(transport);
 290                     case ProtocolChoice.Binary:
 291                     default:
 292                         return new TBinaryProtocol(transport);
 293                 }
 294             }
 295         }
 296
 297
 298         private const int ErrorBaseTypes = 1;
 299         private const int ErrorStructs = 2;
 300         private const int ErrorContainers = 4;
 301         private const int ErrorExceptions = 8;
 302         private const int ErrorUnknown = 64;
 303
 304         private class ClientTest
 305         {
 306             private readonly TTransport transport;
 307             private readonly ThriftTest.Client client;
 308             private readonly int numIterations;
 309             private bool done;
 310
 311             public int ReturnCode { get; set; }
 312
 313             public ClientTest(TestParams param)
 314             {
 315                 transport = param.CreateTransport();
 316                 client = new ThriftTest.Client(param.CreateProtocol(transport));
 317                 numIterations = param.numIterations;
 318             }
 319
 320             public void Execute()
 321             {
 322                 if (done)
 323                 {
 324                     Console.WriteLine("Execute called more than once");
 325                     throw new InvalidOperationException();
 326                 }
 327
 328                 for (var i = 0; i < numIterations; i++)
 329                 {
 330                     try
 331                     {
 332                         if (!transport.IsOpen)
 333                             transport.OpenAsync(MakeTimeoutToken()).GetAwaiter().GetResult();
 334                     }
 335                     catch (TTransportException ex)
 336                     {
 337                         Console.WriteLine("*** FAILED ***");
 338                         Console.WriteLine("Connect failed: " + ex.Message);
 339                         ReturnCode |= ErrorUnknown;
 340                         Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
 341                         continue;
 342                     }
 343                     catch (Exception ex)
 344                     {
 345                         Console.WriteLine("*** FAILED ***");
 346                         Console.WriteLine("Connect failed: " + ex.Message);
 347                         ReturnCode |= ErrorUnknown;
 348                         Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
 349                         continue;
 350                     }
 351
 352                     try
 353                     {
 354                         ReturnCode |= ExecuteClientTestAsync(client).GetAwaiter().GetResult(); ;
 355                     }
 356                     catch (Exception ex)
 357                     {
 358                         Console.WriteLine("*** FAILED ***");
 359                         Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
 360                         ReturnCode |= ErrorUnknown;
 361                     }
 362                 }
 363                 try
 364                 {
 365                     transport.Close();
 366                 }
 367                 catch (Exception ex)
 368                 {
 369                     Console.WriteLine("Error while closing transport");
 370                     Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
 371                 }
 372                 done = true;
 373             }
 374         }
 375
 376         internal static void PrintOptionsHelp()
 377         {
 378             Console.WriteLine("Client options:");
 379             Console.WriteLine("  -u <URL>");
 380             Console.WriteLine("  -t <# of threads to run>        default = 1");
 381             Console.WriteLine("  -n <# of iterations>            per thread");
 382             Console.WriteLine("  --pipe=<pipe name>");
 383             Console.WriteLine("  --host=<IP address>");
 384             Console.WriteLine("  --port=<port number>");
 385             Console.WriteLine("  --transport=<transport name>    one of buffered,framed  (defaults to none)");
 386             Console.WriteLine("  --protocol=<protocol name>      one of compact,json  (defaults to binary)");
 387             Console.WriteLine("  --ssl");
 388             Console.WriteLine();
 389         }
 390
 391         public static int Execute(List<string> args)
 392         {
 393             try
 394             {
 395                 var param = new TestParams();
 396
 397                 try
 398                 {
 399                     param.Parse(args);
 400                 }
 401                 catch (Exception ex)
 402                 {
 403                     Console.WriteLine("*** FAILED ***");
 404                     Console.WriteLine("Error while  parsing arguments");
 405                     Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
 406                     return ErrorUnknown;
 407                 }
 408
 409                 var tests = Enumerable.Range(0, param.numThreads).Select(_ => new ClientTest(param)).ToArray();
 410
 411                 //issue tests on separate threads simultaneously
 412                 var threads = tests.Select(test => new Task(test.Execute)).ToArray();
 413                 var start = DateTime.Now;
 414                 foreach (var t in threads)
 415                 {
 416                     t.Start();
 417                 }
 418
 419                 Task.WaitAll(threads);
 420
 421                 Console.WriteLine("Total time: " + (DateTime.Now - start));
 422                 Console.WriteLine();
 423                 return tests.Select(t => t.ReturnCode).Aggregate((r1, r2) => r1 | r2);
 424             }
 425             catch (Exception outerEx)
 426             {
 427                 Console.WriteLine("*** FAILED ***");
 428                 Console.WriteLine("Unexpected error");
 429                 Console.WriteLine(outerEx.Message + " ST: " + outerEx.StackTrace);
 430                 return ErrorUnknown;
 431             }
 432         }
 433
 434         public static string BytesToHex(byte[] data)
 435         {
 436             return BitConverter.ToString(data).Replace("-", string.Empty);
 437         }
 438
 439
 440         public enum BinaryTestSize
 441         {
 442             Empty,           // Edge case: the zero-length empty binary
 443             Normal,          // Fairly small array of usual size (256 bytes)
 444             Large,           // Large writes/reads may cause range check errors
 445             PipeWriteLimit,  // Windows Limit: Pipe write operations across a network are limited to 65,535 bytes per write.
 446             TwentyMB         // that's quite a bit of data
 447         };
 448
 449         public static byte[] PrepareTestData(bool randomDist, BinaryTestSize testcase)
 450         {
 451             int amount = -1;
 452             switch (testcase)
 453             {
 454                 case BinaryTestSize.Empty:
 455                     amount = 0;
 456                     break;
 457                 case BinaryTestSize.Normal:
 458                     amount = 0x100;
 459                     break;
 460                 case BinaryTestSize.Large:
 461                     amount = 0x8000 + 128;
 462                     break;
 463                 case BinaryTestSize.PipeWriteLimit:
 464                     amount = 0xFFFF + 128;
 465                     break;
 466                 case BinaryTestSize.TwentyMB:
 467                     amount = 20 * 1024 * 1024;
 468                     break;
 469                 default:
 470                     throw new ArgumentException(nameof(testcase));
 471             }
 472
 473             var retval = new byte[amount];
 474
 475             // linear distribution, unless random is requested
 476             if (!randomDist)
 477             {
 478                 for (var i = 0; i < retval.Length; ++i)
 479                 {
 480                     retval[i] = (byte)i;
 481                 }
 482                 return retval;
 483             }
 484
 485             // random distribution
 486             var rnd = new Random();
 487             for (var i = 1; i < retval.Length; ++i)
 488             {
 489                 retval[i] = (byte)rnd.Next(0x100);
 490             }
 491             return retval;
 492         }
 493
 494         private static CancellationToken MakeTimeoutToken(int msec = 5000)
 495         {
 496             var token = new CancellationTokenSource(msec);
 497             return token.Token;
 498         }
 499
 500         public static async Task<int> ExecuteClientTestAsync(ThriftTest.Client client)
 501         {
 502             var returnCode = 0;
 503
 504             Console.Write("testVoid()");
 505             await client.testVoidAsync(MakeTimeoutToken());
 506             Console.WriteLine(" = void");
 507
 508             Console.Write("testString(\"Test\")");
 509             var s = await client.testStringAsync("Test", MakeTimeoutToken());
 510             Console.WriteLine(" = \"" + s + "\"");
 511             if ("Test" != s)
 512             {
 513                 Console.WriteLine("*** FAILED ***");
 514                 returnCode |= ErrorBaseTypes;
 515             }
 516
 517             Console.Write("testBool(true)");
 518             var t = await client.testBoolAsync((bool)true, MakeTimeoutToken());
 519             Console.WriteLine(" = " + t);
 520             if (!t)
 521             {
 522                 Console.WriteLine("*** FAILED ***");
 523                 returnCode |= ErrorBaseTypes;
 524             }
 525             Console.Write("testBool(false)");
 526             var f = await client.testBoolAsync((bool)false, MakeTimeoutToken());
 527             Console.WriteLine(" = " + f);
 528             if (f)
 529             {
 530                 Console.WriteLine("*** FAILED ***");
 531                 returnCode |= ErrorBaseTypes;
 532             }
 533
 534             Console.Write("testByte(1)");
 535             var i8 = await client.testByteAsync((sbyte)1, MakeTimeoutToken());
 536             Console.WriteLine(" = " + i8);
 537             if (1 != i8)
 538             {
 539                 Console.WriteLine("*** FAILED ***");
 540                 returnCode |= ErrorBaseTypes;
 541             }
 542
 543             Console.Write("testI32(-1)");
 544             var i32 = await client.testI32Async(-1, MakeTimeoutToken());
 545             Console.WriteLine(" = " + i32);
 546             if (-1 != i32)
 547             {
 548                 Console.WriteLine("*** FAILED ***");
 549                 returnCode |= ErrorBaseTypes;
 550             }
 551
 552             Console.Write("testI64(-34359738368)");
 553             var i64 = await client.testI64Async(-34359738368, MakeTimeoutToken());
 554             Console.WriteLine(" = " + i64);
 555             if (-34359738368 != i64)
 556             {
 557                 Console.WriteLine("*** FAILED ***");
 558                 returnCode |= ErrorBaseTypes;
 559             }
 560
 561             // TODO: Validate received message
 562             Console.Write("testDouble(5.325098235)");
 563             var dub = await client.testDoubleAsync(5.325098235, MakeTimeoutToken());
 564             Console.WriteLine(" = " + dub);
 565             if (5.325098235 != dub)
 566             {
 567                 Console.WriteLine("*** FAILED ***");
 568                 returnCode |= ErrorBaseTypes;
 569             }
 570             Console.Write("testDouble(-0.000341012439638598279)");
 571             dub = await client.testDoubleAsync(-0.000341012439638598279, MakeTimeoutToken());
 572             Console.WriteLine(" = " + dub);
 573             if (-0.000341012439638598279 != dub)
 574             {
 575                 Console.WriteLine("*** FAILED ***");
 576                 returnCode |= ErrorBaseTypes;
 577             }
 578
 579             // testBinary()
 580             foreach(BinaryTestSize binTestCase in Enum.GetValues(typeof(BinaryTestSize)))
 581             {
 582                 var binOut = PrepareTestData(true, binTestCase);
 583
 584                 Console.Write("testBinary({0} bytes)", binOut.Length);
 585                 try
 586                 {
 587                     var binIn = await client.testBinaryAsync(binOut, MakeTimeoutToken());
 588                     Console.WriteLine(" = {0} bytes", binIn.Length);
 589                     if (binIn.Length != binOut.Length)
 590                     {
 591                         Console.WriteLine("*** FAILED ***");
 592                         returnCode |= ErrorBaseTypes;
 593                     }
 594                     for (var ofs = 0; ofs < Math.Min(binIn.Length, binOut.Length); ++ofs)
 595                     {
 596                         if (binIn[ofs] != binOut[ofs])
 597                         {
 598                             Console.WriteLine("*** FAILED ***");
 599                             returnCode |= ErrorBaseTypes;
 600                         }
 601                     }
 602                 }
 603                 catch (Thrift.TApplicationException ex)
 604                 {
 605                     Console.WriteLine("*** FAILED ***");
 606                     returnCode |= ErrorBaseTypes;
 607                     Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
 608                 }
 609             }
 610
 611             // CrazyNesting
 612             Console.WriteLine("Test CrazyNesting");
 613             var one = new CrazyNesting();
 614             var two = new CrazyNesting();
 615             one.String_field = "crazy";
 616             two.String_field = "crazy";
 617             one.Binary_field = new byte[] { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0xFF };
 618             two.Binary_field = new byte[10] { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0xFF };
 619             if (typeof(CrazyNesting).GetMethod("Equals")?.DeclaringType == typeof(CrazyNesting))
 620             {
 621                 if (!one.Equals(two))
 622                 {
 623                     Console.WriteLine("*** FAILED ***");
 624                     returnCode |= ErrorContainers;
 625                     throw new Exception("CrazyNesting.Equals failed");
 626                 }
 627             }
 628
 629             // TODO: Validate received message
 630             Console.Write("testStruct({\"Zero\", 1, -3, -5})");
 631             var o = new Xtruct();
 632             o.String_thing = "Zero";
 633             o.Byte_thing = (sbyte)1;
 634             o.I32_thing = -3;
 635             o.I64_thing = -5;
 636             var i = await client.testStructAsync(o, MakeTimeoutToken());
 637             Console.WriteLine(" = {\"" + i.String_thing + "\", " + i.Byte_thing + ", " + i.I32_thing + ", " + i.I64_thing + "}");
 638
 639             // TODO: Validate received message
 640             Console.Write("testNest({1, {\"Zero\", 1, -3, -5}, 5})");
 641             var o2 = new Xtruct2();
 642             o2.Byte_thing = (sbyte)1;
 643             o2.Struct_thing = o;
 644             o2.I32_thing = 5;
 645             var i2 = await client.testNestAsync(o2, MakeTimeoutToken());
 646             i = i2.Struct_thing;
 647             Console.WriteLine(" = {" + i2.Byte_thing + ", {\"" + i.String_thing + "\", " + i.Byte_thing + ", " + i.I32_thing + ", " + i.I64_thing + "}, " + i2.I32_thing + "}");
 648
 649             var mapout = new Dictionary<int, int>();
 650             for (var j = 0; j < 5; j++)
 651             {
 652                 mapout[j] = j - 10;
 653             }
 654             Console.Write("testMap({");
 655             var first = true;
 656             foreach (var key in mapout.Keys)
 657             {
 658                 if (first)
 659                 {
 660                     first = false;
 661                 }
 662                 else
 663                 {
 664                     Console.Write(", ");
 665                 }
 666                 Console.Write(key + " => " + mapout[key]);
 667             }
 668             Console.Write("})");
 669
 670             var mapin = await client.testMapAsync(mapout, MakeTimeoutToken());
 671
 672             Console.Write(" = {");
 673             first = true;
 674             foreach (var key in mapin.Keys)
 675             {
 676                 if (first)
 677                 {
 678                     first = false;
 679                 }
 680                 else
 681                 {
 682                     Console.Write(", ");
 683                 }
 684                 Console.Write(key + " => " + mapin[key]);
 685             }
 686             Console.WriteLine("}");
 687
 688             // TODO: Validate received message
 689             var listout = new List<int>();
 690             for (var j = -2; j < 3; j++)
 691             {
 692                 listout.Add(j);
 693             }
 694             Console.Write("testList({");
 695             first = true;
 696             foreach (var j in listout)
 697             {
 698                 if (first)
 699                 {
 700                     first = false;
 701                 }
 702                 else
 703                 {
 704                     Console.Write(", ");
 705                 }
 706                 Console.Write(j);
 707             }
 708             Console.Write("})");
 709
 710             var listin = await client.testListAsync(listout, MakeTimeoutToken());
 711
 712             Console.Write(" = {");
 713             first = true;
 714             foreach (var j in listin)
 715             {
 716                 if (first)
 717                 {
 718                     first = false;
 719                 }
 720                 else
 721                 {
 722                     Console.Write(", ");
 723                 }
 724                 Console.Write(j);
 725             }
 726             Console.WriteLine("}");
 727
 728             //set
 729             // TODO: Validate received message
 730             var setout = new THashSet<int>();
 731             for (var j = -2; j < 3; j++)
 732             {
 733                 setout.Add(j);
 734             }
 735             Console.Write("testSet({");
 736             first = true;
 737             foreach (int j in setout)
 738             {
 739                 if (first)
 740                 {
 741                     first = false;
 742                 }
 743                 else
 744                 {
 745                     Console.Write(", ");
 746                 }
 747                 Console.Write(j);
 748             }
 749             Console.Write("})");
 750
 751             var setin = await client.testSetAsync(setout, MakeTimeoutToken());
 752
 753             Console.Write(" = {");
 754             first = true;
 755             foreach (int j in setin)
 756             {
 757                 if (first)
 758                 {
 759                     first = false;
 760                 }
 761                 else
 762                 {
 763                     Console.Write(", ");
 764                 }
 765                 Console.Write(j);
 766             }
 767             Console.WriteLine("}");
 768
 769
 770             Console.Write("testEnum(ONE)");
 771             var ret = await client.testEnumAsync(Numberz.ONE, MakeTimeoutToken());
 772             Console.WriteLine(" = " + ret);
 773             if (Numberz.ONE != ret)
 774             {
 775                 Console.WriteLine("*** FAILED ***");
 776                 returnCode |= ErrorStructs;
 777             }
 778
 779             Console.Write("testEnum(TWO)");
 780             ret = await client.testEnumAsync(Numberz.TWO, MakeTimeoutToken());
 781             Console.WriteLine(" = " + ret);
 782             if (Numberz.TWO != ret)
 783             {
 784                 Console.WriteLine("*** FAILED ***");
 785                 returnCode |= ErrorStructs;
 786             }
 787
 788             Console.Write("testEnum(THREE)");
 789             ret = await client.testEnumAsync(Numberz.THREE, MakeTimeoutToken());
 790             Console.WriteLine(" = " + ret);
 791             if (Numberz.THREE != ret)
 792             {
 793                 Console.WriteLine("*** FAILED ***");
 794                 returnCode |= ErrorStructs;
 795             }
 796
 797             Console.Write("testEnum(FIVE)");
 798             ret = await client.testEnumAsync(Numberz.FIVE, MakeTimeoutToken());
 799             Console.WriteLine(" = " + ret);
 800             if (Numberz.FIVE != ret)
 801             {
 802                 Console.WriteLine("*** FAILED ***");
 803                 returnCode |= ErrorStructs;
 804             }
 805
 806             Console.Write("testEnum(EIGHT)");
 807             ret = await client.testEnumAsync(Numberz.EIGHT, MakeTimeoutToken());
 808             Console.WriteLine(" = " + ret);
 809             if (Numberz.EIGHT != ret)
 810             {
 811                 Console.WriteLine("*** FAILED ***");
 812                 returnCode |= ErrorStructs;
 813             }
 814
 815             Console.Write("testTypedef(309858235082523)");
 816             var uid = await client.testTypedefAsync(309858235082523L, MakeTimeoutToken());
 817             Console.WriteLine(" = " + uid);
 818             if (309858235082523L != uid)
 819             {
 820                 Console.WriteLine("*** FAILED ***");
 821                 returnCode |= ErrorStructs;
 822             }
 823
 824             // TODO: Validate received message
 825             Console.Write("testMapMap(1)");
 826             var mm = await client.testMapMapAsync(1, MakeTimeoutToken());
 827             Console.Write(" = {");
 828             foreach (var key in mm.Keys)
 829             {
 830                 Console.Write(key + " => {");
 831                 var m2 = mm[key];
 832                 foreach (var k2 in m2.Keys)
 833                 {
 834                     Console.Write(k2 + " => " + m2[k2] + ", ");
 835                 }
 836                 Console.Write("}, ");
 837             }
 838             Console.WriteLine("}");
 839
 840             // TODO: Validate received message
 841             var insane = new Insanity();
 842             insane.UserMap = new Dictionary<Numberz, long>();
 843             insane.UserMap[Numberz.FIVE] = 5000L;
 844             var truck = new Xtruct();
 845             truck.String_thing = "Truck";
 846             truck.Byte_thing = (sbyte)8;
 847             truck.I32_thing = 8;
 848             truck.I64_thing = 8;
 849             insane.Xtructs = new List<Xtruct>();
 850             insane.Xtructs.Add(truck);
 851             Console.Write("testInsanity()");
 852             var whoa = await client.testInsanityAsync(insane, MakeTimeoutToken());
 853             Console.Write(" = {");
 854             foreach (var key in whoa.Keys)
 855             {
 856                 var val = whoa[key];
 857                 Console.Write(key + " => {");
 858
 859                 foreach (var k2 in val.Keys)
 860                 {
 861                     var v2 = val[k2];
 862
 863                     Console.Write(k2 + " => {");
 864                     var userMap = v2.UserMap;
 865
 866                     Console.Write("{");
 867                     if (userMap != null)
 868                     {
 869                         foreach (var k3 in userMap.Keys)
 870                         {
 871                             Console.Write(k3 + " => " + userMap[k3] + ", ");
 872                         }
 873                     }
 874                     else
 875                     {
 876                         Console.Write("null");
 877                     }
 878                     Console.Write("}, ");
 879
 880                     var xtructs = v2.Xtructs;
 881
 882                     Console.Write("{");
 883                     if (xtructs != null)
 884                     {
 885                         foreach (var x in xtructs)
 886                         {
 887                             Console.Write("{\"" + x.String_thing + "\", " + x.Byte_thing + ", " + x.I32_thing + ", " + x.I32_thing + "}, ");
 888                         }
 889                     }
 890                     else
 891                     {
 892                         Console.Write("null");
 893                     }
 894                     Console.Write("}");
 895
 896                     Console.Write("}, ");
 897                 }
 898                 Console.Write("}, ");
 899             }
 900             Console.WriteLine("}");
 901
 902             sbyte arg0 = 1;
 903             var arg1 = 2;
 904             var arg2 = long.MaxValue;
 905             var multiDict = new Dictionary<short, string>();
 906             multiDict[1] = "one";
 907
 908             var tmpMultiDict = new List<string>();
 909             foreach (var pair in multiDict)
 910                 tmpMultiDict.Add(pair.Key +" => "+ pair.Value);
 911
 912             var arg4 = Numberz.FIVE;
 913             long arg5 = 5000000;
 914             Console.Write("Test Multi(" + arg0 + "," + arg1 + "," + arg2 + ",{" + string.Join(",", tmpMultiDict) + "}," + arg4 + "," + arg5 + ")");
 915             var multiResponse = await client.testMultiAsync(arg0, arg1, arg2, multiDict, arg4, arg5, MakeTimeoutToken());
 916             Console.Write(" = Xtruct(byte_thing:" + multiResponse.Byte_thing + ",String_thing:" + multiResponse.String_thing
 917                           + ",i32_thing:" + multiResponse.I32_thing + ",i64_thing:" + multiResponse.I64_thing + ")\n");
 918
 919             try
 920             {
 921                 Console.WriteLine("testException(\"Xception\")");
 922                 await client.testExceptionAsync("Xception", MakeTimeoutToken());
 923                 Console.WriteLine("*** FAILED ***");
 924                 returnCode |= ErrorExceptions;
 925             }
 926             catch (Xception ex)
 927             {
 928                 if (ex.ErrorCode != 1001 || ex.Message != "Xception")
 929                 {
 930                     Console.WriteLine("*** FAILED ***");
 931                     returnCode |= ErrorExceptions;
 932                 }
 933             }
 934             catch (Exception ex)
 935             {
 936                 Console.WriteLine("*** FAILED ***");
 937                 returnCode |= ErrorExceptions;
 938                 Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
 939             }
 940             try
 941             {
 942                 Console.WriteLine("testException(\"TException\")");
 943                 await client.testExceptionAsync("TException", MakeTimeoutToken());
 944                 Console.WriteLine("*** FAILED ***");
 945                 returnCode |= ErrorExceptions;
 946             }
 947             catch (Thrift.TException)
 948             {
 949                 // OK
 950             }
 951             catch (Exception ex)
 952             {
 953                 Console.WriteLine("*** FAILED ***");
 954                 returnCode |= ErrorExceptions;
 955                 Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
 956             }
 957             try
 958             {
 959                 Console.WriteLine("testException(\"ok\")");
 960                 await client.testExceptionAsync("ok", MakeTimeoutToken());
 961                 // OK
 962             }
 963             catch (Exception ex)
 964             {
 965                 Console.WriteLine("*** FAILED ***");
 966                 returnCode |= ErrorExceptions;
 967                 Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
 968             }
 969
 970             try
 971             {
 972                 Console.WriteLine("testMultiException(\"Xception\", ...)");
 973                 await client.testMultiExceptionAsync("Xception", "ignore", MakeTimeoutToken());
 974                 Console.WriteLine("*** FAILED ***");
 975                 returnCode |= ErrorExceptions;
 976             }
 977             catch (Xception ex)
 978             {
 979                 if (ex.ErrorCode != 1001 || ex.Message != "This is an Xception")
 980                 {
 981                     Console.WriteLine("*** FAILED ***");
 982                     returnCode |= ErrorExceptions;
 983                 }
 984             }
 985             catch (Exception ex)
 986             {
 987                 Console.WriteLine("*** FAILED ***");
 988                 returnCode |= ErrorExceptions;
 989                 Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
 990             }
 991             try
 992             {
 993                 Console.WriteLine("testMultiException(\"Xception2\", ...)");
 994                 await client.testMultiExceptionAsync("Xception2", "ignore", MakeTimeoutToken());
 995                 Console.WriteLine("*** FAILED ***");
 996                 returnCode |= ErrorExceptions;
 997             }
 998             catch (Xception2 ex)
 999             {
1000                 if (ex.ErrorCode != 2002 || ex.Struct_thing.String_thing != "This is an Xception2")
1001                 {
1002                     Console.WriteLine("*** FAILED ***");
1003                     returnCode |= ErrorExceptions;
1004                 }
1005             }
1006             catch (Exception ex)
1007             {
1008                 Console.WriteLine("*** FAILED ***");
1009                 returnCode |= ErrorExceptions;
1010                 Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
1011             }
1012             try
1013             {
1014                 Console.WriteLine("testMultiException(\"success\", \"OK\")");
1015                 if ("OK" != (await client.testMultiExceptionAsync("success", "OK", MakeTimeoutToken())).String_thing)
1016                 {
1017                     Console.WriteLine("*** FAILED ***");
1018                     returnCode |= ErrorExceptions;
1019                 }
1020             }
1021             catch (Exception ex)
1022             {
1023                 Console.WriteLine("*** FAILED ***");
1024                 returnCode |= ErrorExceptions;
1025                 Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
1026             }
1027
1028             Console.WriteLine("Test Oneway(1)");
1029             var sw = new Stopwatch();
1030             sw.Start();
1031             await client.testOnewayAsync(1, MakeTimeoutToken());
1032             sw.Stop();
1033             if (sw.ElapsedMilliseconds > 1000)
1034             {
1035                 Console.WriteLine("*** FAILED ***");
1036                 returnCode |= ErrorBaseTypes;
1037             }
1038
1039             Console.Write("Test Calltime()");
1040             var times = 50;
1041             sw.Reset();
1042             sw.Start();
1043             var token = MakeTimeoutToken(20000);
1044             for (var k = 0; k < times; ++k)
1045                 await client.testVoidAsync(token);
1046             sw.Stop();
1047             Console.WriteLine(" = {0} ms a testVoid() call", sw.ElapsedMilliseconds / times);
1048             return returnCode;
1049         }
1050     }
1051 }