Protocol conformity and serialization tests for UUIDs - Haxe
diff --git a/lib/haxe/test/src/tests/ConstantsTest.hx b/lib/haxe/test/src/tests/ConstantsTest.hx
new file mode 100644
index 0000000..11b266c
--- /dev/null
+++ b/lib/haxe/test/src/tests/ConstantsTest.hx
@@ -0,0 +1,150 @@
+/*
+ * 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 tests;
+
+import haxe.Int64;
+import haxe.io.BytesBuffer;
+import tests.TestBase;
+
+import org.apache.thrift.*;
+import org.apache.thrift.protocol.*;
+import org.apache.thrift.transport.*;
+import org.apache.thrift.server.*;
+import org.apache.thrift.meta_data.*;
+
+import constantsDemo.*; // generated code
+
+
+class ConstantsTest extends tests.TestBase {
+
+ public static function Run(server : Bool) : Void
+ {
+ TestConstants();
+ TestProtocolConformity();
+ }
+
+
+ private static function TestConstants() : Void
+ {
+ tests.TestBase.Expect( ConstantsDemoConstants.myInt == 3, "myInt = 3");
+ tests.TestBase.Expect( ConstantsDemoConstants.hex_const == 0x0001F, "hex_const = 31");
+ tests.TestBase.Expect( ConstantsDemoConstants.negative_hex_constant == -0x0001F, "negative_hex_constant = -31");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_ME == -3523553, "GEN_ME = -3523553");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEn_DUB == 325.532, "GEn_DUB = 325.532");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEn_DU == 85.2355, "GEn_DU = 85.2355");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_STRING == "asldkjasfd", "GEN_STRING = \"asldkjasfd\"");
+ tests.TestBase.Expect( ConstantsDemoConstants.e10 == 1e+10, "e10 = 1e+10");
+ tests.TestBase.Expect( ConstantsDemoConstants.e11 == -1e+10, "e11 = -1e+10");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_UUID == "00000000-4444-CCCC-ffff-0123456789ab", "GEN_UUID = \"00000000-4444-CCCC-ffff-0123456789ab\"");
+
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_MAP.get(35532) == 233, "GEN_MAP.get(35532) == 233");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_MAP.get(43523) == 853, "GEN_MAP.get(43523) == 853");
+
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_LIST.length == 3, "GEN_LIST.size() == 3");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_LIST.join("/") == "235235/23598352/3253523", "GEN_LIST elements");
+
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_MAPMAP.get(235).get(532) == 53255, "GEN_MAPMAP.get(235).get(532) == 53255");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_MAPMAP.get(235).get(235) == 235, "GEN_MAPMAP.get(235).get(235) == 235");
+
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_MAP2.get("hello") == 233, "GEN_MAP2.get(\"hello\") == 233");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_MAP2.get("lkj98d") == 853, "GEN_MAP2.get(\"lkj98d\") == 853");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_MAP2.get('lkjsdf') == 98325, "GEN_MAP2.get('lkjsdf') == 98325");
+
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_THING.hello == 325, "GEN_THING.hello == 325");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_THING.goodbye == 325352, "GEN_THING.goodbye == 325352");
+
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_WHAT.get(35).hello == 325, "GEN_WHAT.get(35).hello == 325");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_WHAT.get(35).goodbye == 325352, "GEN_WHAT.get(35).goodbye == 325352");
+
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_SET.size == 2, "GEN_SET.size() == 2");
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_SET.contains(235), "GEN_SET.contains(235)"); // added twice, but this is a set
+ tests.TestBase.Expect( ConstantsDemoConstants.GEN_SET.contains(53235), "GEN_SET.contains(53235)");
+ }
+
+ private static function TestProtocolConformity() : Void
+ {
+ for( factory in [new TBinaryProtocolFactory(), new TCompactProtocolFactory(), new TJSONProtocolFactory()])
+ {
+ DeserializeGuidData(factory);
+ }
+ }
+
+ private static function DeserializeGuidData(factory : TProtocolFactory) : Void
+ {
+ var data = new BytesBuffer();
+ var sCase = Type.getClassName(Type.getClass(factory)).split('.').pop();
+ switch(sCase)
+ {
+ case "TJSONProtocolFactory":
+ data.addString('"00112233-4455-6677-8899-aabbccddeeff"');
+
+ case "TCompactProtocolFactory":
+ data.addByte(0x00);
+ data.addByte(0x11);
+ data.addByte(0x22);
+ data.addByte(0x33);
+ data.addByte(0x44);
+ data.addByte(0x55);
+ data.addByte(0x66);
+ data.addByte(0x77);
+ data.addByte(0x88);
+ data.addByte(0x99);
+ data.addByte(0xaa);
+ data.addByte(0xbb);
+ data.addByte(0xcc);
+ data.addByte(0xdd);
+ data.addByte(0xee);
+ data.addByte(0xff);
+
+ case "TBinaryProtocolFactory":
+ data.addByte(0x00);
+ data.addByte(0x11);
+ data.addByte(0x22);
+ data.addByte(0x33);
+ data.addByte(0x44);
+ data.addByte(0x55);
+ data.addByte(0x66);
+ data.addByte(0x77);
+ data.addByte(0x88);
+ data.addByte(0x99);
+ data.addByte(0xaa);
+ data.addByte(0xbb);
+ data.addByte(0xcc);
+ data.addByte(0xdd);
+ data.addByte(0xee);
+ data.addByte(0xff);
+
+ default:
+ tests.TestBase.Expect( false, 'Unhandled ${sCase}');
+ }
+
+ var stream = new TMemoryStream(data.getBytes());
+ stream.Position = 0;
+
+ var config = new TConfiguration();
+ var transport = new TStreamTransport(stream, stream, config);
+ var protocol = factory.getProtocol(transport);
+
+ var sUuid = protocol.readUuid();
+ tests.TestBase.Expect( sUuid == "00112233-4455-6677-8899-aabbccddeeff", 'DeserializeGuidData(${sCase}): ${sUuid}');
+ }
+}
+
+
diff --git a/lib/haxe/test/src/tests/MultiplexTest.hx b/lib/haxe/test/src/tests/MultiplexTest.hx
new file mode 100644
index 0000000..8676082
--- /dev/null
+++ b/lib/haxe/test/src/tests/MultiplexTest.hx
@@ -0,0 +1,227 @@
+/*
+ * 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 tests;
+import tests.TestBase;
+
+#if ! (flash || html5 || js)
+
+import haxe.Int64;
+import haxe.Int32;
+
+import org.apache.thrift.*;
+import org.apache.thrift.protocol.*;
+import org.apache.thrift.transport.*;
+import org.apache.thrift.server.*;
+import org.apache.thrift.meta_data.*;
+
+// debug only
+import org.apache.thrift.protocol.TProtocolDecorator;
+import org.apache.thrift.protocol.TMultiplexedProtocol;
+import org.apache.thrift.protocol.TMultiplexedProcessor;
+
+// generated code imports
+import Aggr;
+import AggrImpl;
+import AggrProcessor;
+import BenchmarkService;
+import BenchmarkServiceImpl;
+import BenchmarkServiceProcessor;
+import Error;
+
+class BenchmarkServiceHandler implements BenchmarkService_service
+{
+ public function new() {
+ }
+
+ public function fibonacci(n : haxe.Int32) : haxe.Int32 {
+ trace('Benchmark.fibonacci($n)');
+ var next : Int;
+ var prev = 0;
+ var result = 1;
+ while( n > 0)
+ {
+ next = result + prev;
+ prev = result;
+ result = next;
+ --n;
+ }
+ return result;
+ }
+}
+
+
+class AggrServiceHandler implements Aggr_service
+{
+ private var values : List<haxe.Int32> = new List<haxe.Int32>();
+
+ public function new() {
+ }
+
+ public function addValue(value : haxe.Int32) : Void {
+ trace('Aggr.addValue($value)');
+ values.add( value);
+ }
+
+ public function getValues() : List< haxe.Int32> {
+ trace('Aggr.getValues()');
+ return values;
+ }
+}
+
+
+
+class MultiplexTest extends tests.TestBase {
+
+ private inline static var NAME_BENCHMARKSERVICE : String = "BenchmarkService";
+ private inline static var NAME_AGGR : String = "Aggr";
+
+
+ public static function Run(server : Bool) : Void {
+ if ( server) {
+ RunMultiplexServer();
+ } else {
+ RunMultiplexClient();
+ RunDefaultClient();
+ }
+ }
+
+
+ // run the multiplex server
+ public static function RunMultiplexServer() : Void {
+ try
+ {
+ var benchHandler : BenchmarkService_service = new BenchmarkServiceHandler();
+ var benchProcessor : TProcessor = new BenchmarkServiceProcessor( benchHandler);
+
+ var aggrHandler : Aggr_service = new AggrServiceHandler();
+ var aggrProcessor : TProcessor = new AggrProcessor( aggrHandler);
+
+ var multiplex : TMultiplexedProcessor = new TMultiplexedProcessor();
+ multiplex.RegisterProcessor( NAME_BENCHMARKSERVICE, benchProcessor, true); // default
+ multiplex.RegisterProcessor( NAME_AGGR, aggrProcessor);
+
+ // protocol+transport stack
+ var protfact : TProtocolFactory = new TBinaryProtocolFactory(true,true);
+ var servertrans : TServerTransport = new TServerSocket( 9090, 5, false);
+ var transfact : TTransportFactory = new TFramedTransportFactory();
+
+ var server : TServer = new TSimpleServer( multiplex, servertrans, transfact, protfact);
+
+ trace("Starting the server ...");
+ server.Serve();
+ }
+ catch( e : TApplicationException)
+ {
+ tests.TestBase.Expect(false,'${e.errorID} ${e.errorMsg}');
+ }
+ catch( e : TException)
+ {
+ tests.TestBase.Expect(false,'$e');
+ }
+ }
+
+
+ // run multiplex client against multiplex server
+ public static function RunMultiplexClient() : Void {
+ try
+ {
+ var trans : TTransport;
+ trans = new TSocket("localhost", 9090);
+ trans = new TFramedTransport(trans);
+ trans.open();
+
+ var protocol : TProtocol = new TBinaryProtocol(trans,true,true);
+ var multiplex : TMultiplexedProtocol;
+
+ multiplex = new TMultiplexedProtocol( protocol, NAME_BENCHMARKSERVICE);
+ var bench = new BenchmarkServiceImpl( multiplex);
+
+ multiplex = new TMultiplexedProtocol( protocol, NAME_AGGR);
+ var aggr = new AggrImpl( multiplex);
+
+ trace('calling aggr.add( bench.fibo())...');
+ for( i in 1 ... 10)
+ {
+ trace('$i');
+ aggr.addValue( bench.fibonacci(i));
+ }
+
+ trace('calling aggr ...');
+ var i = 1;
+ var values = aggr.getValues();
+ tests.TestBase.Expect(values != null,'aggr.getValues() == null');
+ for( k in values)
+ {
+ trace('fib($i) = $k');
+ ++i;
+ }
+
+ trans.close();
+ trace('done.');
+
+ }
+ catch( e : TApplicationException)
+ {
+ tests.TestBase.Expect(false,'${e.errorID} ${e.errorMsg}');
+ }
+ catch( e : TException)
+ {
+ tests.TestBase.Expect(false,'$e');
+ }
+ }
+
+
+ // run non-multiplex client against multiplex server to test default fallback
+ public static function RunDefaultClient() : Void {
+ try
+ {
+ var trans : TTransport;
+ trans = new TSocket("localhost", 9090);
+ trans = new TFramedTransport(trans);
+ trans.open();
+
+ var protocol : TProtocol = new TBinaryProtocol(trans,true,true);
+
+ var bench = new BenchmarkServiceImpl( protocol);
+
+ trace('calling bench (via default) ...');
+ for( i in 1 ... 10)
+ {
+ var k = bench.fibonacci(i);
+ trace('fib($i) = $k');
+ }
+
+ trans.close();
+ trace('done.');
+ }
+ catch( e : TApplicationException)
+ {
+ tests.TestBase.Expect(false,'${e.errorID} ${e.errorMsg}');
+ }
+ catch( e : TException)
+ {
+ tests.TestBase.Expect(false,'$e');
+ }
+ }
+
+}
+
+#end
+
diff --git a/lib/haxe/test/src/tests/StreamTest.hx b/lib/haxe/test/src/tests/StreamTest.hx
new file mode 100644
index 0000000..97af6f3
--- /dev/null
+++ b/lib/haxe/test/src/tests/StreamTest.hx
@@ -0,0 +1,100 @@
+/*
+ * 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 tests;
+import tests.TestBase;
+#if sys
+
+import haxe.Int64;
+import sys.FileSystem;
+
+import org.apache.thrift.*;
+import org.apache.thrift.protocol.*;
+import org.apache.thrift.transport.*;
+import org.apache.thrift.server.*;
+import org.apache.thrift.meta_data.*;
+
+import thrift.test.*; // generated code
+
+
+class StreamTest extends tests.TestBase {
+
+
+ private inline static var tmpfile : String = "data.tmp";
+
+
+ private static function MakeTestData() : Xtruct {
+ var data : Xtruct = new Xtruct();
+ data.string_thing = "Streamtest";
+ data.byte_thing = -128;
+ data.i32_thing = 4711;
+ data.i64_thing = Int64.make(0x12345678,0x9ABCDEF0);
+ return data;
+ }
+
+ public static function WriteData() : Xtruct
+ {
+ var config : TConfiguration = new TConfiguration();
+ var stream : TStream = new TFileStream( tmpfile, CreateNew);
+ var trans : TTransport = new TStreamTransport( null, stream, config);
+ var prot = new TJSONProtocol( trans);
+
+ var data = MakeTestData();
+ data.write(prot);
+ trans.close();
+
+ return data;
+ }
+
+ public static function ReadData() : Xtruct
+ {
+ var config : TConfiguration = new TConfiguration();
+ var stream : TStream = new TFileStream( tmpfile, Read);
+ var trans : TTransport = new TStreamTransport( stream, null, config);
+ var prot = new TJSONProtocol( trans);
+
+ var data : Xtruct = new Xtruct();
+ data.read(prot);
+ trans.close();
+
+ return data;
+ }
+
+ public static function Run(server : Bool) : Void
+ {
+ try {
+ var written = WriteData();
+ var read = ReadData();
+ FileSystem.deleteFile(tmpfile);
+
+ tests.TestBase.Expect( read.string_thing == written.string_thing, "string data");
+ tests.TestBase.Expect( read.byte_thing == written.byte_thing, "byte data");
+ tests.TestBase.Expect( read.i32_thing == written.i32_thing, "i32 data");
+ tests.TestBase.Expect( Int64.compare( read.i64_thing, written.i64_thing) == 0, "i64 data");
+
+ } catch(e:Dynamic) {
+ FileSystem.deleteFile(tmpfile);
+ throw e;
+ }
+ }
+
+}
+
+
+#end
diff --git a/lib/haxe/test/src/tests/TestBase.hx b/lib/haxe/test/src/tests/TestBase.hx
new file mode 100644
index 0000000..7545a65
--- /dev/null
+++ b/lib/haxe/test/src/tests/TestBase.hx
@@ -0,0 +1,47 @@
+/*
+ * 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 tests;
+
+import org.apache.thrift.*;
+import org.apache.thrift.protocol.*;
+import org.apache.thrift.transport.*;
+import org.apache.thrift.server.*;
+import org.apache.thrift.meta_data.*;
+
+
+class TestBase {
+
+ private function new() {
+ // override, if necessary
+ }
+
+ public static function Run(server : Bool) : Void {
+ throw new AbstractMethodError();
+ }
+
+ public static function Expect( expr : Bool, info : String, ?pos : haxe.PosInfos) : Void {
+ if( ! expr) {
+ throw ('Test "$info" failed at '+pos.methodName+' in '+pos.fileName+':'+pos.lineNumber);
+ }
+ trace('Test "$info" - OK');
+ }
+
+}
+
\ No newline at end of file