THRIFT-3299 Create an Apache Thrift language binding for Dart (dartlang.org).
Client: Dart
Patch: Mark Erickson <mark.erickson@workiva.com>
This closes #608
diff --git a/test/dart/test_client/bin/main.dart b/test/dart/test_client/bin/main.dart
new file mode 100644
index 0000000..3733a08
--- /dev/null
+++ b/test/dart/test_client/bin/main.dart
@@ -0,0 +1,288 @@
+/// 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.
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:collection/equality.dart';
+import 'package:thrift/thrift.dart';
+import 'package:thrift/thrift_console.dart';
+import 'package:thrift_test/thrift_test.dart';
+
+ThriftTestClient client;
+bool verbose;
+
+/// Adapted from TestClient.php
+main(List<String> args) async {
+ var parser = new ArgParser();
+ parser.addOption('host', defaultsTo: 'localhost', help: 'The server host');
+ parser.addOption('port', defaultsTo: '9090', help: 'The port to connect to');
+ parser.addOption('transport',
+ defaultsTo: 'buffered',
+ allowed: ['buffered', 'framed'],
+ help: 'The transport name',
+ allowedHelp: {
+ 'buffered': 'TBufferedTransport',
+ 'framed': 'TFramedTransport'
+ });
+ parser.addOption('protocol',
+ defaultsTo: 'binary',
+ allowed: ['binary', 'json'],
+ help: 'The protocol name',
+ allowedHelp: {'binary': 'TBinaryProtocol', 'json': 'TJsonProtocol'});
+ parser.addFlag('verbose', defaultsTo: false);
+
+ ArgResults results;
+ try {
+ results = parser.parse(args);
+ } catch (e) {
+ stdout.writeln('$e\n');
+ results = null;
+ }
+
+ if (results == null) {
+ print(parser.usage);
+ exit(0);
+ }
+
+ verbose = results['verbose'] == true;
+
+ await init(
+ host: results['host'],
+ port: int.parse(results['port']),
+ transportType: results['transport'],
+ protocolType: results['protocol']).then((_) {
+ exit(0);
+ }).catchError((e) {
+ stdout.writeln('Error:');
+ stdout.writeln('$e');
+ if (e is Error) {
+ stdout.writeln('${e.stackTrace}');
+ }
+ exit(1);
+ });
+ exit(0);
+}
+
+TProtocolFactory getProtocolFactory(String protocolType) {
+ if (protocolType == 'binary') {
+ return new TBinaryProtocolFactory();
+ } else if (protocolType == 'json') {
+ return new TJsonProtocolFactory();
+ }
+
+ throw new ArgumentError.value(protocolType);
+}
+
+Future init(
+ {String host, int port, String transportType, String protocolType}) async {
+ TTransport transport;
+ var protocolFactory = getProtocolFactory(protocolType);
+
+ if (transportType == 'http') {
+ var httpClient = new HttpClient();
+ var config = new THttpConfig(Uri.parse('http://localhost'), {});
+ transport = new THttpClientTransport(httpClient, config);
+ } else {
+ var socket = await Socket.connect(host, port);
+ transport = new TClientSocketTransport(new TTcpSocket(socket));
+ if (transportType == 'framed') {
+ transport = new TFramedTransport(transport);
+ }
+ }
+
+ var protocol = protocolFactory.getProtocol(transport);
+ client = new ThriftTestClient(protocol);
+
+ await transport.open();
+
+ await runTests();
+}
+
+Future _test(String name, Function testFunc) async {
+ if (verbose) stdout.write('$name... ');
+ await testFunc();
+ if (verbose) stdout.writeln('success!');
+}
+
+Future runTests() async {
+ var xtruct = new Xtruct()
+ ..string_thing = 'Zero'
+ ..byte_thing = 1
+ ..i32_thing = -3
+ ..i64_thing = -5;
+
+ await _test('testVoid', () async {
+ await client.testVoid();
+ });
+
+ await _test('testString', () async {
+ var input = 'Test';
+ var result = await client.testString(input);
+ if (result != input) throw new StateError('$result != $input');
+ });
+
+ await _test('testBool', () async {
+ var input = true;
+ var result = await client.testBool(input);
+ if (result != input) throw new StateError('$result != $input');
+ });
+
+ await _test('testByte', () async {
+ var input = 64;
+ var result = await client.testByte(input);
+ if (result != input) throw new StateError('$result != $input');
+ });
+
+ await _test('testI32', () async {
+ var input = 2147483647;
+ var result = await client.testI32(input);
+ if (result != input) throw new StateError('$result != $input');
+ });
+
+ await _test('testI64', () async {
+ var input = 9223372036854775807;
+ var result = await client.testI64(input);
+ if (result != input) throw new StateError('$result != $input');
+ });
+
+ await _test('testDouble', () async {
+ var input = 3.1415926;
+ var result = await client.testDouble(input);
+ if (result != input) throw new StateError('$result != $input');
+ });
+
+ await _test('testBinary', () async {
+ var utf8Codec = const Utf8Codec();
+ var input = utf8Codec.encode('foo');
+ var result = await client.testBinary(input);
+ var equality = const ListEquality();
+ if (!equality.equals(
+ result, input)) throw new StateError('$result != $input');
+ });
+
+ await _test('testStruct', () async {
+ var result = await client.testStruct(xtruct);
+ if ('$result' != '$xtruct') throw new StateError('$result != $xtruct');
+ });
+
+ await _test('testNest', () async {
+ var input = new Xtruct2()
+ ..byte_thing = 1
+ ..struct_thing = xtruct
+ ..i32_thing = -3;
+
+ var result = await client.testNest(input);
+ if ('$result' != '$input') throw new StateError('$result != $input');
+ });
+
+ await _test('testMap', () async {
+ Map<int, int> input = {1: -10, 2: -9, 3: -8, 4: -7, 5: -6};
+
+ var result = await client.testMap(input);
+ var equality = const MapEquality();
+ if (!equality.equals(
+ result, input)) throw new StateError('$result != $input');
+ });
+
+ await _test('testSet', () async {
+ var input = new Set.from([-2, -1, 0, 1, 2]);
+ var result = await client.testSet(input);
+ var equality = const SetEquality();
+ if (!equality.equals(
+ result, input)) throw new StateError('$result != $input');
+ });
+
+ await _test('testList', () async {
+ var input = [-2, -1, 0, 1, 2];
+ var result = await client.testList(input);
+ var equality = const ListEquality();
+ if (!equality.equals(
+ result, input)) throw new StateError('$result != $input');
+ });
+
+ await _test('testEnum', () async {
+ await _testEnum(Numberz.ONE);
+ await _testEnum(Numberz.TWO);
+ await _testEnum(Numberz.THREE);
+ await _testEnum(Numberz.FIVE);
+ await _testEnum(Numberz.EIGHT);
+ });
+
+ await _test('testTypedef', () async {
+ var input = 309858235082523;
+ var result = await client.testTypedef(input);
+ if (result != input) throw new StateError('$result != $input');
+ });
+
+ await _test('testMapMap', () async {
+ Map<int, Map<int, int>> result = await client.testMapMap(1);
+ if (result.isEmpty ||
+ result[result.keys.first].isEmpty) throw new StateError(
+ 'expected Map<int, Map<int, int>> got $result');
+ });
+
+ await _test('testInsanity', () async {
+ var input = new Insanity();
+ input.userMap = {Numberz.FIVE: 5000};
+ input.xtructs = [xtruct];
+
+ Map<int, Map<int, Insanity>> result = await client.testInsanity(input);
+ if (result.isEmpty ||
+ result[result.keys.first].isEmpty) throw new StateError(
+ 'expected Map<int, Map<int, Insanity>> got $result');
+ });
+
+ await _test('testMulti', () async {
+ var input = new Xtruct()
+ ..string_thing = 'Hello2'
+ ..byte_thing = 123
+ ..i32_thing = 456
+ ..i64_thing = 789;
+
+ var result = await client.testMulti(input.byte_thing, input.i32_thing,
+ input.i64_thing, {1: 'one'}, Numberz.EIGHT, 5678);
+ if ('$result' != '$input') throw new StateError('$result != $input');
+ });
+
+ await _test('testException', () async {
+ try {
+ await client.testException('Xception');
+ } on Xception catch (x) {
+ return;
+ }
+
+ throw new StateError('expected an Xception');
+ });
+
+ await _test('testMultiException', () async {
+ try {
+ await client.testMultiException('Xception2', 'foo');
+ } on Xception2 catch (x) {
+ return;
+ }
+
+ throw new StateError('expected an Xception2');
+ });
+}
+
+Future _testEnum(int input) async {
+ var result = await client.testEnum(input);
+ if (result != input) throw new StateError('$result != $input');
+}