/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package;

import haxe.Int32;
import haxe.Int64;
import haxe.Timer;
import haxe.ds.IntMap;
import haxe.ds.StringMap;
import haxe.ds.ObjectMap;

import org.apache.thrift.*;
import org.apache.thrift.helper.*;
import org.apache.thrift.protocol.*;
import org.apache.thrift.transport.*;
import org.apache.thrift.server.*;
import org.apache.thrift.meta_data.*;

#if cpp
import cpp.vm.Thread;
#else
// no thread support (yet)
#end

import thrift.test.*;  // generated code


class TestResults {
	private var successCnt : Int = 0;
	private var errorCnt : Int = 0;
	private var failedTests : String = "";
	private var print_direct : Bool = false;
	
	public static var EXITCODE_SUCCESS            = 0x00;  // no errors bits set
	//
	public static var EXITCODE_FAILBIT_BASETYPES  = 0x01;
	public static var EXITCODE_FAILBIT_STRUCTS    = 0x02;
	public static var EXITCODE_FAILBIT_CONTAINERS = 0x04;
	public static var EXITCODE_FAILBIT_EXCEPTIONS = 0x08;
	//
	public static var EXITCODE_ALL_FAILBITS 	  = 0x0F;
	//
	private var testsExecuted : Int = 0;
	private var testsFailed : Int = 0;
	private var currentTest : Int = 0;

	
	public function new(direct : Bool) {
		print_direct = direct;
	}
	
	public function StartTestGroup( groupBit : Int) : Void {
		currentTest = groupBit;
		testsExecuted |= groupBit;
	}
	
	public function Expect( expr : Bool, msg : String) : Void {
		if ( expr) {
			++successCnt;
		} else {
			++errorCnt;
			testsFailed |= currentTest;
			failedTests += "\n  " + msg;
			if( print_direct) {
				trace('FAIL: $msg');
			}
		}
	}

	public function CalculateExitCode() : Int {
		var notExecuted : Int = EXITCODE_ALL_FAILBITS & (~testsExecuted);
		return testsFailed | notExecuted;
	}

	public function PrintSummary() : Void {
		var total = successCnt + errorCnt;
		var sp = (100 * successCnt) / total;
		var ep = (100 * errorCnt) / total;
		
		trace('===========================');
		trace('Tests executed    $total');
		trace('Tests succeeded   $successCnt ($sp%)');
		trace('Tests failed      $errorCnt ($ep%)');
		if ( errorCnt > 0)
		{
			trace('===========================');
  			trace('FAILED TESTS: $failedTests');
		}
		trace('===========================');
	}
}


class TestClient {

	public static function Execute(args : Arguments) :  Void
	{
		var exitCode = 0xFF;
		try
		{
			var difft = Timer.stamp();
	
			if( args.numThreads > 1) {
				var threads = new List<Thread>();
				for( test in 0 ... args.numThreads) {
					threads.add( StartThread( args));
				} 
				exitCode = 0;
				for( thread in threads) {
					exitCode |= Thread.readMessage(true);
				}
			} else {
				var rslt = new TestResults(true);
				RunClient(args,rslt);
				rslt.PrintSummary();
				exitCode = rslt.CalculateExitCode();
			}

			difft = Timer.stamp() - difft;
			trace('total test time: $difft seconds');
		}
		catch (e : TException)
		{
			trace('$e');
			exitCode = 0xFF;
		}
		catch (e : Dynamic)
		{
			trace('$e');
			exitCode = 0xFF;
		}
	
		#if sys
		Sys.exit( exitCode);
		#end
	}

	
	private static function StartThread(args : Arguments) : Thread {
		var thread = Thread.create(
			function() : Void {
				var rslt = new TestResults(false);
				var main : Thread = Thread.readMessage(true);
				try 
				{
					RunClient(args,rslt);
				}
				catch (e : TException)
				{
					rslt.Expect( false, '$e');
					trace('$e');
				}
				catch (e : Dynamic)
				{
					rslt.Expect( false, '$e');
					trace('$e');
				}					
				main.sendMessage( rslt.CalculateExitCode());
			});
		
		thread.sendMessage(Thread.current());
		return thread;
	}

	
	public static function RunClient(args : Arguments, rslt : TestResults)
	{
		var transport : TTransport = null;
		switch (args.transport)
		{
			case socket:
				transport = new TSocket(args.host, args.port);
			case http:
				transport = new THttpClient(args.host);
			default:
				throw "Unhandled transport";
		}

		// optional: layered transport
		if ( args.framed) {
			trace("- framed transport");
			transport = new TFramedTransport(transport);
		} 
		if ( args.buffered) {
			trace("- buffered transport");
			throw "TBufferedTransport not implemented yet";
			//transport = new TBufferedTransport(transport);
		}

		// protocol
		var protocol : TProtocol = null;
		switch( args.protocol)
		{
		case binary:
			trace("- binary protocol");
			protocol = new TBinaryProtocol(transport);
		case json:
			trace("- json protocol");
			protocol = new TJSONProtocol(transport);
		default:
			throw "Unhandled protocol";
		}


		// run the test code
		HaxeBasicsTest( args, rslt);
		for( i in 0 ... args.numIterations) {
			ClientTest( transport, protocol, args, rslt);
		}
	}


	public static function HaxeBasicsTest( args : Arguments, rslt : TestResults) : Void
	{
		// We need to test a few basic things used in the ClientTest
		// Anything else beyond this scope should go into /lib/haxe/ instead
		rslt.StartTestGroup( 0);
		
		var map32 = new IntMap<Int32>();
		var map64 = new Int64Map<Int32>();

		rslt.Expect( map32.keys().hasNext() == map64.keys().hasNext(), "Int64Map<Int32> Test #1");
		rslt.Expect( map32.exists( 4711) == map64.exists( Int64.make(47,11)), "Int64Map<Int32> Test #2");
		rslt.Expect( map32.remove( 4711) == map64.remove( Int64.make(47,11)), "Int64Map<Int32> Test #3");
		rslt.Expect( map32.get( 4711) == map64.get( Int64.make(47,11)), "Int64Map<Int32> Test #4");
		
		map32.set( 42, 815);
		map64.set( Int64.make(0,42), 815);
		map32.set( -517, 23);
		map64.set( Int64.make(-5,17), 23);
		map32.set( 0, -123);
		map64.set( Int64.make(0,0), -123);

		rslt.Expect( map32.keys().hasNext() == map64.keys().hasNext(), "Int64Map<Int32> Test #10");
		rslt.Expect( map32.exists( 4711) == map64.exists( Int64.make(47,11)), "Int64Map<Int32> Test #11");
		rslt.Expect( map32.exists( -517) == map64.exists( Int64.make(-5,17)), "Int64Map<Int32> Test #12");
		rslt.Expect( map32.exists( 42) == map64.exists( Int64.make(0,42)), "Int64Map<Int32> Test #13");
		rslt.Expect( map32.exists( 0) == map64.exists( Int64.make(0,0)), "Int64Map<Int32> Test #14");
		rslt.Expect( map32.get( 4711) == map64.get( Int64.make(47,11)), "Int64Map<Int32> Test #15");
		rslt.Expect( map32.get( -517) == map64.get( Int64.make(-5,17)), "Int64Map<Int32> Test #16");
		rslt.Expect( map32.get( 42) == map64.get( Int64.make(0,42)), "Int64Map<Int32> Test #Int64.make(-5,17)");
		rslt.Expect( map32.get( 0) == map64.get( Int64.make(0,0)), "Int64Map<Int32> Test #18");
		rslt.Expect( map32.remove( 4711) == map64.remove( Int64.make(47,11)), "Int64Map<Int32> Test #19");
		rslt.Expect( map32.remove( -517) == map64.remove( Int64.make(-5,17)), "Int64Map<Int32> Test #20");
		rslt.Expect( map32.exists( 4711) == map64.exists( Int64.make(47,11)), "Int64Map<Int32> Test #21");
		rslt.Expect( map32.exists( -517) == map64.exists( Int64.make(-5,17)), "Int64Map<Int32> Test #22");
		rslt.Expect( map32.exists( 42) == map64.exists( Int64.make(0,42)), "Int64Map<Int32> Test #23");
		rslt.Expect( map32.exists( 0) == map64.exists( Int64.make(0,0)), "Int64Map<Int32> Test #24");
		rslt.Expect( map32.get( 4711) == map64.get( Int64.make(47,11)), "Int64Map<Int32> Test #25");
		rslt.Expect( map32.get( -517) == map64.get( Int64.make(-5,17)), "Int64Map<Int32> Test #26");
		rslt.Expect( map32.get( 42) == map64.get( Int64.make(0,42)), "Int64Map<Int32> Test #27");
		rslt.Expect( map32.get( 0) == map64.get( Int64.make(0,0)), "Int64Map<Int32> Test #28");

		map32.set( 42, 1);
		map64.set( Int64.make(0,42), 1);
		map32.set( -517, -2);
		map64.set( Int64.make(-5,17), -2);
		map32.set( 0, 3);
		map64.set( Int64.make(0,0), 3);

		var c32 = 0;
		for (key in map32.keys()) {
			++c32;
		}
		var c64 = 0;
		for (key in map64.keys()) {
			++c64;
		}
		rslt.Expect( c32 == c64, "Int64Map<Int32> Test #30");

		var s32 = map32.toString();
		var s64 = map64.toString();
		trace("Int64Map<Int32>.toString(): " + ' ("$s32" == "$s64")');

		map32.remove( 42);
		map64.remove( Int64.make(0,42));
		map32.remove( -517);
		map64.remove( Int64.make(-5,17));
		map32.remove( 0);
		map64.remove( Int64.make(0,0));
		
		rslt.Expect( map32.keys().hasNext() == map64.keys().hasNext(), "Int64Map<Int32> Test #90");
		rslt.Expect( map32.exists( 4711) == map64.exists( Int64.make(47,11)), "Int64Map<Int32> Test #91");
		rslt.Expect( map32.exists( -517) == map64.exists( Int64.make(-5,17)), "Int64Map<Int32> Test #92");
		rslt.Expect( map32.exists( 42) == map64.exists( Int64.make(0,42)), "Int64Map<Int32> Test #93");
		rslt.Expect( map32.exists( 0) == map64.exists( Int64.make(0,0)), "Int64Map<Int32> Test #94");
		rslt.Expect( map32.get( 4711) == map64.get( Int64.make(47,11)), "Int64Map<Int32> Test #95");
		rslt.Expect( map32.get( -517) == map64.get( Int64.make(-5,17)), "Int64Map<Int32> Test #96");
		rslt.Expect( map32.get( 42) == map64.get( Int64.make(0,42)), "Int64Map<Int32> Test #97");
		rslt.Expect( map32.get( 0) == map64.get( Int64.make(0,0)), "Int64Map<Int32> Test #98");
	}


	public static function ClientTest( transport : TTransport, protocol : TProtocol, 
									   args : Arguments, rslt : TestResults) : Void
	{
		var client = new ThriftTestImpl(protocol,protocol);
		try
		{
			if (!transport.isOpen())
			{
				transport.open();
			}
		}
		catch (e : TException)
		{
			trace('$e');
			return;
		}
		catch (e : Dynamic)
		{
			trace('$e');
			return;
		}

		var start = Date.now();

		rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_EXCEPTIONS);
	
		// if arg == "Xception" throw Xception with errorCode = 1001 and message = arg
		trace('testException("Xception")');
		try {
			client.testException("Xception");
			rslt.Expect( false, 'testException("Xception") should throw');
		}
		catch (e : Xception)
		{
			rslt.Expect( e.message == "Xception", 'testException("Xception")  -  e.message == "Xception"');
			rslt.Expect( e.errorCode == 1001, 'testException("Xception")  -  e.errorCode == 1001');
		}
		catch (e : Dynamic)
		{
			rslt.Expect( false, 'testException("Xception")  -  $e');
		} 
	
		// if arg == "TException" throw TException
		trace('testException("TException")');
		try {
			client.testException("TException");
			rslt.Expect( false, 'testException("TException") should throw');
		}
		catch (e : TException)
		{
			rslt.Expect( true, 'testException("TException")  -  $e');
		}
		catch (e : Dynamic)
		{
			rslt.Expect( false, 'testException("TException")  -  $e');
		} 
	
		// else do not throw anything
		trace('testException("bla")');
		try {
			client.testException("bla");
			rslt.Expect( true, 'testException("bla") should not throw');
		}
		catch (e : Dynamic)
		{
			rslt.Expect( false, 'testException("bla")  -  $e');
		} 
			
		
		rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_BASETYPES);
		
		trace('testVoid()');
		client.testVoid();
		trace(' = void');
		rslt.Expect(true,"testVoid()");  // bump counter

		trace('testString("Test")');
		var s = client.testString("Test");
		trace(' = "$s"');
		rslt.Expect(s == "Test", '$s == "Test"');

		trace('testByte(1)');
		var i8 = client.testByte(1);
		trace(' = $i8');
		rslt.Expect(i8 == 1, '$i8 == 1');

		trace('testI32(-1)');
		var i32 = client.testI32(-1);
		trace(' = $i32');
		rslt.Expect(i32 == -1, '$i32 == -1');

		trace('testI64(-34359738368)');
		var i64 = client.testI64( Int64.make( 0xFFFFFFF8, 0x00000000)); // -34359738368
		trace(' = $i64');
		rslt.Expect( Int64.compare( i64, Int64.make( 0xFFFFFFF8, 0x00000000)) == 0, 
		             Int64.toStr(i64) +" == "+Int64.toStr(Int64.make( 0xFFFFFFF8, 0x00000000)));

		// edge case: the largest negative Int64 has no positive Int64 equivalent
		trace('testI64(-9223372036854775808)');
		i64 = client.testI64( Int64.make( 0x80000000, 0x00000000)); // -9223372036854775808
		trace(' = $i64');
		rslt.Expect( Int64.compare( i64, Int64.make( 0x80000000, 0x00000000)) == 0, 
		             Int64.toStr(i64) +" == "+Int64.toStr(Int64.make( 0x80000000, 0x00000000)));

		trace('testDouble(5.325098235)');
		var dub = client.testDouble(5.325098235);
		trace(' = $dub');
		rslt.Expect(dub == 5.325098235, '$dub == 5.325098235');

		
		rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_STRUCTS);
		
		trace('testStruct({"Zero", 1, -3, -5})');
		var o = new Xtruct();
		o.string_thing = "Zero";
		o.byte_thing = 1;
		o.i32_thing = -3;
		o.i64_thing = Int64.make(0,-5);
		var i = client.testStruct(o);
		trace(' = {"' + i.string_thing + '", ' + i.byte_thing +', ' 
					  + i.i32_thing +', '+ Int64.toStr(i.i64_thing) + '}');
		rslt.Expect( i.string_thing == o.string_thing, "i.string_thing == o.string_thing");
		rslt.Expect( i.byte_thing == o.byte_thing, "i.byte_thing == o.byte_thing");
		rslt.Expect( i.i32_thing == o.i32_thing, "i.i64_thing == o.i64_thing");
		rslt.Expect( i.i32_thing == o.i32_thing, "i.i64_thing == o.i64_thing");

		trace('testNest({1, {\"Zero\", 1, -3, -5}, 5})');
		var o2 = new Xtruct2();
		o2.byte_thing = 1;
		o2.struct_thing = o;
		o2.i32_thing = 5;
		var i2 = client.testNest(o2);
		i = i2.struct_thing;
		trace(" = {" + i2.byte_thing + ", {\"" + i.string_thing + "\", " 
			  + i.byte_thing + ", " + i.i32_thing + ", " + Int64.toStr(i.i64_thing) + "}, " 
			  + i2.i32_thing + "}");
		rslt.Expect( i2.byte_thing == o2.byte_thing, "i2.byte_thing == o2.byte_thing");
		rslt.Expect( i2.i32_thing == o2.i32_thing, "i2.i32_thing == o2.i32_thing");
		rslt.Expect( i.string_thing == o.string_thing, "i.string_thing == o.string_thing");
		rslt.Expect( i.byte_thing == o.byte_thing, "i.byte_thing == o.byte_thing");
		rslt.Expect( i.i32_thing == o.i32_thing, "i.i32_thing == o.i32_thing");
		rslt.Expect( Int64.compare( i.i64_thing, o.i64_thing) == 0, "i.i64_thing == o.i64_thing");

		
		rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_CONTAINERS);
		
		var mapout = new IntMap< haxe.Int32>();
		for ( j in 0 ... 5)
		{
			mapout.set(j, j - 10);
		}
		trace("testMap({");
		var first : Bool = true;
		for( key in mapout.keys())
		{
			if (first)
			{
				first = false;
			}
			else
			{
				trace(", ");
			}
			trace(key + " => " + mapout.get(key));
		}
		trace("})");

		var mapin = client.testMap(mapout);

		trace(" = {");
		first = true;
		for( key in mapin.keys())
		{
			if (first)
			{
				first = false;
			}
			else
			{
				trace(", ");
			}
			trace(key + " => " + mapin.get(key));
			rslt.Expect( mapin.get(key) == mapout.get(key), ' mapin.get($key) == mapout.get($key)');
		}
		trace("}");
		for( key in mapout.keys())
		{
			rslt.Expect(mapin.exists(key), 'mapin.exists($key)');
		}

		var listout = new List<Int>();
		for (j in -2 ... 3)
		{
			listout.add(j);
		}
		trace("testList({");
		first = true;
		for( j in listout)
		{
			if (first)
			{
				first = false;
			}
			else
			{
				trace(", ");
			}
			trace(j);
		}
		trace("})");

		var listin = client.testList(listout);

		trace(" = {");
		first = true;
		for( j in listin)
		{
			if (first)
			{
				first = false;
			}
			else
			{
				trace(", ");
			}
			trace(j);
		}
		trace("}");

		rslt.Expect(listin.length == listout.length, "listin.length == listout.length");
		var literout = listout.iterator();
		var literin = listin.iterator();
		while( literin.hasNext()) {
			rslt.Expect(literin.next() == literout.next(), "literin[i] == literout[i]");
		}
	
		//set
		var setout = new IntSet();
		for (j in -2 ... 3)
		{
			setout.add(j);
		}
		trace("testSet({");
		first = true;
		for( j in setout)
		{
			if (first)
			{
				first = false;
			}
			else
			{
				trace(", ");
			}
			trace(j);
		}
		trace("})");

		var setin = client.testSet(setout);

		trace(" = {");
		first = true;
		for( j in setin)
		{
			if (first)
			{
				first = false;
			}
			else
			{
				trace(", ");
			}
			trace(j);
			rslt.Expect(setout.contains(j), 'setout.contains($j)');
		}
		trace("}");
		rslt.Expect(setin.size == setout.size, "setin.length == setout.length");
	

		rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_BASETYPES);

		trace("testEnum(ONE)");
		var ret = client.testEnum(Numberz.ONE);
		trace(" = " + ret);
		rslt.Expect(ret == Numberz.ONE, '$ret == Numberz.ONE');

		trace("testEnum(TWO)");
		ret = client.testEnum(Numberz.TWO);
		trace(" = " + ret);
		rslt.Expect(ret == Numberz.TWO, '$ret == Numberz.TWO');

		trace("testEnum(THREE)");
		ret = client.testEnum(Numberz.THREE);
		trace(" = " + ret);
		rslt.Expect(ret == Numberz.THREE, '$ret == Numberz.THREE');

		trace("testEnum(FIVE)");
		ret = client.testEnum(Numberz.FIVE);
		trace(" = " + ret);
		rslt.Expect(ret == Numberz.FIVE, '$ret == Numberz.FIVE');

		trace("testEnum(EIGHT)");
		ret = client.testEnum(Numberz.EIGHT);
		trace(" = " + ret);
		rslt.Expect(ret == Numberz.EIGHT, '$ret == Numberz.EIGHT');

		trace("testTypedef(309858235082523)");
		var uid = client.testTypedef( Int64.make( 0x119D0, 0x7E08671B));  // 309858235082523
		trace(" = " + uid);
		rslt.Expect( Int64.compare( uid, Int64.make( 0x119D0, 0x7E08671B)) == 0,
		             Int64.toStr(uid)+" == "+Int64.toStr(Int64.make( 0x119D0, 0x7E08671B)));


		rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_CONTAINERS);

		trace("testMapMap(1)");
		var mm = client.testMapMap(1);
		trace(" = {");
		for( key in mm.keys())
		{
			trace(key + " => {");
			var m2 = mm.get(key);
			for( k2 in m2.keys())
			{
				trace(k2 + " => " + m2.get(k2) + ", ");
			}
			trace("}, ");
		}
		trace("}");

		var pos = mm.get(4);
		var neg = mm.get(-4);
		rslt.Expect( (pos != null) && (neg != null), "(pos != null) && (neg != null)");
		for (i in 0 ... 5) {
			rslt.Expect( pos.get(i) == i, 'pos.get($i) == $i');
			rslt.Expect( neg.get(-i) == -i, 'neg.get(-$i) == -$i');
	 	}

			
		rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_STRUCTS);

		var insane = new Insanity();
		insane.userMap = new IntMap< Int64>();
		insane.userMap.set( Numberz.FIVE, Int64.make(0,5000));
		var truck = new Xtruct();
		truck.string_thing = "Truck";
		truck.byte_thing = 8;
		truck.i32_thing = 8;
		truck.i64_thing = Int64.make(0,8);
		insane.xtructs = new List<Xtruct>();
		insane.xtructs.add(truck);
		trace("testInsanity()");
		var whoa = client.testInsanity(insane);
		trace(" = {");
		for( key in whoa.keys())
		{
			var val = whoa.get(key);
			trace(key + " => {");

			for( k2 in val.keys())
			{
				var v2 = val.get(k2);

				trace(k2 + " => {");
				var userMap = v2.userMap;

				trace("{");
				if (userMap != null)
				{
					for( k3 in userMap.keys())
					{
						trace(k3 + " => " + userMap.get(k3) + ", ");
					}
				}
				else
				{
					trace("null");
				}
				trace("}, ");

				var xtructs = v2.xtructs;

				trace("{");
				if (xtructs != null)
				{
					for( x in xtructs)
					{
						trace("{\"" + x.string_thing + "\", " 
							  + x.byte_thing + ", " + x.i32_thing + ", " 
							  + x.i32_thing + "}, ");
					}
				}
				else
				{
					trace("null");
				}
				trace("}");

				trace("}, ");
			}
			trace("}, ");
		}
		trace("}");


		var first_map = whoa.get(Int64.make(0,1));
		var second_map = whoa.get(Int64.make(0,2));
		rslt.Expect( (first_map != null) && (second_map != null), "(first_map != null) && (second_map != null)");
		if ((first_map != null) && (second_map != null))
		{
			var crazy2 = first_map.get(Numberz.TWO);
			var crazy3 = first_map.get(Numberz.THREE);
			var looney = second_map.get(Numberz.SIX);
			rslt.Expect( (crazy2 != null) && (crazy3 != null) && (looney != null), 
						"(crazy2 != null) && (crazy3 != null) && (looney != null)");

			rslt.Expect( Int64.compare( crazy2.userMap.get(Numberz.EIGHT), Int64.make(0,8)) == 0, 
						"crazy2.UserMap.get(Numberz.EIGHT) == 8");
			rslt.Expect( Int64.compare( crazy3.userMap.get(Numberz.EIGHT), Int64.make(0,8)) == 0, 
						"crazy3.UserMap.get(Numberz.EIGHT) == 8");
			rslt.Expect( Int64.compare( crazy2.userMap.get(Numberz.FIVE), Int64.make(0,5)) == 0, 
						"crazy2.UserMap.get(Numberz.FIVE) == 5");
			rslt.Expect( Int64.compare( crazy3.userMap.get(Numberz.FIVE), Int64.make(0,5)) == 0, 
						"crazy3.UserMap.get(Numberz.FIVE) == 5");

			var crz2iter = crazy2.xtructs.iterator();
			var crz3iter = crazy3.xtructs.iterator();
			rslt.Expect( crz2iter.hasNext() && crz3iter.hasNext(), "crz2iter.hasNext() && crz3iter.hasNext()");
			var goodbye2 = crz2iter.next();
			var goodbye3 = crz3iter.next();
			rslt.Expect( crz2iter.hasNext() && crz3iter.hasNext(), "crz2iter.hasNext() && crz3iter.hasNext()");
			var hello2 = crz2iter.next();
			var hello3 = crz3iter.next();
			rslt.Expect( ! (crz2iter.hasNext() || crz3iter.hasNext()), "! (crz2iter.hasNext() || crz3iter.hasNext())");

			rslt.Expect( hello2.string_thing == "Hello2", 'hello2.String_thing == "Hello2"');
			rslt.Expect( hello2.byte_thing == 2, 'hello2.Byte_thing == 2');
			rslt.Expect( hello2.i32_thing == 2, 'hello2.I32_thing == 2');
			rslt.Expect( Int64.compare( hello2.i64_thing, Int64.make(0,2)) == 0, 'hello2.I64_thing == 2');
			rslt.Expect( hello3.string_thing == "Hello2", 'hello3.String_thing == "Hello2"');
			rslt.Expect( hello3.byte_thing == 2, 'hello3.Byte_thing == 2');
			rslt.Expect( hello3.i32_thing == 2, 'hello3.I32_thing == 2');
			rslt.Expect( Int64.compare( hello3.i64_thing, Int64.make(0,2)) == 0, 'hello3.I64_thing == 2');

			rslt.Expect( goodbye2.string_thing == "Goodbye4", 'goodbye2.String_thing == "Goodbye4"');
			rslt.Expect( goodbye2.byte_thing == 4, 'goodbye2.Byte_thing == 4');
			rslt.Expect( goodbye2.i32_thing == 4, 'goodbye2.I32_thing == 4');
			rslt.Expect( Int64.compare( goodbye2.i64_thing, Int64.make(0,4)) == 0, 'goodbye2.I64_thing == 4');
			rslt.Expect( goodbye3.string_thing == "Goodbye4", 'goodbye3.String_thing == "Goodbye4"');
			rslt.Expect( goodbye3.byte_thing == 4, 'goodbye3.Byte_thing == 4');
			rslt.Expect( goodbye3.i32_thing == 4, 'goodbye3.I32_thing == 4');
			rslt.Expect( Int64.compare( goodbye3.i64_thing, Int64.make(0,4)) == 0, 'goodbye3.I64_thing == 4');
		}

		var arg0 = 1;
		var arg1 = 2;
		var arg2 = Int64.make( 0x7FFFFFFF,0xFFFFFFFF);
		var multiDict = new IntMap< String>();
		multiDict.set(1, "one");
		var arg4 = Numberz.FIVE;
		var arg5 = Int64.make(0,5000000);
		trace("Test Multi(" + arg0 + "," + arg1 + "," + arg2 + "," + multiDict + "," + arg4 + "," + arg5 + ")");
		var multiResponse = client.testMulti(arg0, arg1, arg2, multiDict, arg4, arg5);
		trace(" = Xtruct(byte_thing:" + multiResponse.byte_thing + ",string_thing:" + multiResponse.string_thing
					+ ",i32_thing:" + multiResponse.i32_thing 
			        + ",i64_thing:" + Int64.toStr(multiResponse.i64_thing) + ")");

		rslt.Expect( multiResponse.string_thing == "Hello2", 'multiResponse.String_thing == "Hello2"');
		rslt.Expect( multiResponse.byte_thing == arg0, 'multiResponse.Byte_thing == arg0');
		rslt.Expect( multiResponse.i32_thing == arg1, 'multiResponse.I32_thing == arg1');
		rslt.Expect( Int64.compare( multiResponse.i64_thing, arg2) == 0, 'multiResponse.I64_thing == arg2');


		rslt.StartTestGroup( 0);

		trace("Test Oneway(1)");
		client.testOneway(1);

		if( ! args.skipSpeedTest) {
			trace("Test Calltime()");
			var difft = Timer.stamp();
			for ( k in 0 ... 1000) {
				client.testVoid();
			}
			difft = Timer.stamp() - difft;
			trace('$difft ms per testVoid() call');
		}
	}
}