diff --git a/lib/dart/test/protocol/t_protocol_test.dart b/lib/dart/test/protocol/t_protocol_test.dart
index dc63dbb..15d973c 100644
--- a/lib/dart/test/protocol/t_protocol_test.dart
+++ b/lib/dart/test/protocol/t_protocol_test.dart
@@ -18,42 +18,42 @@
 library thrift.test.transport.t_json_protocol_test;
 
 import 'dart:async';
+import 'dart:convert' show utf8;
 import 'dart:typed_data' show Uint8List;
 
-import 'package:dart2_constant/convert.dart' show utf8;
 import 'package:test/test.dart';
 import 'package:thrift/thrift.dart';
 
 void main() {
-  final message = new TMessage('my message', TMessageType.ONEWAY, 123);
+  final message = TMessage('my message', TMessageType.ONEWAY, 123);
 
   TProtocol protocol;
 
   Primitive getPrimitive(int tType) {
     switch (tType) {
       case TType.BOOL:
-        return new Primitive(protocol.readBool, protocol.writeBool, false);
+        return Primitive(protocol.readBool, protocol.writeBool, false);
 
       case TType.BYTE:
-        return new Primitive(protocol.readByte, protocol.writeByte, 0);
+        return Primitive(protocol.readByte, protocol.writeByte, 0);
 
       case TType.I16:
-        return new Primitive(protocol.readI16, protocol.writeI16, 0);
+        return Primitive(protocol.readI16, protocol.writeI16, 0);
 
       case TType.I32:
-        return new Primitive(protocol.readI32, protocol.writeI32, 0);
+        return Primitive(protocol.readI32, protocol.writeI32, 0);
 
       case TType.I64:
-        return new Primitive(protocol.readI64, protocol.writeI64, 0);
+        return Primitive(protocol.readI64, protocol.writeI64, 0);
 
       case TType.DOUBLE:
-        return new Primitive(protocol.readDouble, protocol.writeDouble, 0);
+        return Primitive(protocol.readDouble, protocol.writeDouble, 0);
 
       case TType.STRING:
-        return new Primitive(protocol.readString, protocol.writeString, '');
+        return Primitive(protocol.readString, protocol.writeString, '');
 
       default:
-        throw new UnsupportedError("Unsupported TType $tType");
+        throw UnsupportedError("Unsupported TType $tType");
     }
   }
 
@@ -95,7 +95,7 @@
     });
 
     test('Test struct', () async {
-      var input = new TStruct();
+      var input = TStruct();
 
       protocol.writeStructBegin(input);
       protocol.writeStructEnd();
@@ -111,7 +111,7 @@
     });
 
     test('Test field', () async {
-      var input = new TField('my field', TType.MAP, 123);
+      var input = TField('my field', TType.MAP, 123);
 
       protocol.writeFieldBegin(input);
       protocol.writeFieldEnd();
@@ -128,7 +128,7 @@
     });
 
     test('Test map', () async {
-      var input = new TMap(TType.STRING, TType.STRUCT, 123);
+      var input = TMap(TType.STRING, TType.STRUCT, 123);
 
       protocol.writeMapBegin(input);
       protocol.writeMapEnd();
@@ -145,7 +145,7 @@
     });
 
     test('Test list', () async {
-      var input = new TList(TType.STRING, 123);
+      var input = TList(TType.STRING, 123);
 
       protocol.writeListBegin(input);
       protocol.writeListEnd();
@@ -161,7 +161,7 @@
     });
 
     test('Test set', () async {
-      var input = new TSet(TType.STRING, 123);
+      var input = TSet(TType.STRING, 123);
 
       protocol.writeSetBegin(input);
       protocol.writeSetEnd();
@@ -235,7 +235,7 @@
     });
 
     test('Test binary', () async {
-      var input = new Uint8List.fromList(new List.filled(100, 123));
+      var input = Uint8List.fromList(List.filled(100, 123));
 
       protocol.writeBinary(input);
       protocol.writeMessageEnd();
@@ -251,18 +251,18 @@
 
     test('Test complex struct', () async {
       // {1: {10: 20}, 2: {30: 40}}
-      protocol.writeStructBegin(new TStruct());
-      protocol.writeFieldBegin(new TField('success', TType.MAP, 0));
-      protocol.writeMapBegin(new TMap(TType.I32, TType.MAP, 2));
+      protocol.writeStructBegin(TStruct());
+      protocol.writeFieldBegin(TField('success', TType.MAP, 0));
+      protocol.writeMapBegin(TMap(TType.I32, TType.MAP, 2));
 
       protocol.writeI32(1); // key
-      protocol.writeMapBegin(new TMap(TType.I32, TType.I32, 1));
+      protocol.writeMapBegin(TMap(TType.I32, TType.I32, 1));
       protocol.writeI32(10); // key
       protocol.writeI32(20); // value
       protocol.writeMapEnd();
 
       protocol.writeI32(2); // key
-      protocol.writeMapBegin(new TMap(TType.I32, TType.I32, 1));
+      protocol.writeMapBegin(TMap(TType.I32, TType.I32, 1));
       protocol.writeI32(30); // key
       protocol.writeI32(40); // value
       protocol.writeMapEnd();
@@ -300,19 +300,19 @@
 
     test('Test nested maps and lists', () async {
       // {1: [{10: 20}], 2: [{30: 40}]}
-      protocol.writeMapBegin(new TMap(TType.I32, TType.LIST, 2));
+      protocol.writeMapBegin(TMap(TType.I32, TType.LIST, 2));
 
       protocol.writeI32(1); // key
-      protocol.writeListBegin(new TList(TType.MAP, 1));
-      protocol.writeMapBegin(new TMap(TType.I32, TType.I32, 1));
+      protocol.writeListBegin(TList(TType.MAP, 1));
+      protocol.writeMapBegin(TMap(TType.I32, TType.I32, 1));
       protocol.writeI32(10); // key
       protocol.writeI32(20); // value
       protocol.writeMapEnd();
       protocol.writeListEnd();
 
       protocol.writeI32(2); // key
-      protocol.writeListBegin(new TList(TType.MAP, 1));
-      protocol.writeMapBegin(new TMap(TType.I32, TType.I32, 1));
+      protocol.writeListBegin(TList(TType.MAP, 1));
+      protocol.writeMapBegin(TMap(TType.I32, TType.I32, 1));
       protocol.writeI32(30); // key
       protocol.writeI32(40); // value
       protocol.writeMapEnd();
@@ -349,7 +349,7 @@
 
   group('JSON', () {
     setUp(() {
-      protocol = new TJsonProtocol(new TBufferedTransport());
+      protocol = TJsonProtocol(TBufferedTransport());
       protocol.writeMessageBegin(message);
     });
 
@@ -363,10 +363,10 @@
            UTF-16: 0xD834 0xDD1E
        */
       var buffer = utf8.encode(r'"\u0001\u0e01 \ud834\udd1e"');
-      var transport = new TBufferedTransport();
+      var transport = TBufferedTransport();
       transport.writeAll(buffer);
 
-      var protocol = new TJsonProtocol(transport);
+      var protocol = TJsonProtocol(transport);
 
       await protocol.transport.flush();
 
@@ -380,7 +380,7 @@
 
   group('binary', () {
     setUp(() {
-      protocol = new TBinaryProtocol(new TBufferedTransport());
+      protocol = TBinaryProtocol(TBufferedTransport());
       protocol.writeMessageBegin(message);
     });
 
@@ -389,7 +389,7 @@
 
   group('compact', () {
     setUp(() {
-      protocol = new TCompactProtocol(new TBufferedTransport());
+      protocol = TCompactProtocol(TBufferedTransport());
       protocol.writeMessageBegin(message);
     });
 
diff --git a/lib/dart/test/serializer/serializer_test.dart b/lib/dart/test/serializer/serializer_test.dart
index 2f76503..89883cb 100644
--- a/lib/dart/test/serializer/serializer_test.dart
+++ b/lib/dart/test/serializer/serializer_test.dart
@@ -30,22 +30,22 @@
     TestTObject testTObject;
 
     setUp(() {
-      serializer = new TSerializer();
-      deserializer = new TDeserializer();
-      
-      testTObject = new TestTObject();
+      serializer = TSerializer();
+      deserializer = TDeserializer();
+
+      testTObject = TestTObject();
       testTObject.b = true;
       testTObject.s = "TEST";
       testTObject.d = 15.25;
       testTObject.i = 10;
-      
-      var testList = new List<String>();
+
+      var testList = List<String>();
       testList.add("TEST 1");
       testList.add("TEST 2");
-      
+
       testTObject.l = testList;
     });
-    
+
     assertNewObjectEqualsTObject(TestTObject newObject) {
       expect(newObject.l, equals(testTObject.l));
       expect(newObject.b, equals(testTObject.b));
@@ -53,63 +53,63 @@
       expect(newObject.d, equals(testTObject.d));
       expect(newObject.s, equals(testTObject.s));
     }
-    
+
     runWriteStringTest() {
       var s = serializer.writeString(testTObject);
 
-      var newObject = new TestTObject();
+      var newObject = TestTObject();
       deserializer.readString(newObject, s);
 
       assertNewObjectEqualsTObject(newObject);
-    };
+    }
 
     runWriteTest() {
       var s = serializer.write(testTObject);
 
-      var newObject = new TestTObject();
+      var newObject = TestTObject();
       deserializer.read(newObject, s);
 
       assertNewObjectEqualsTObject(newObject);
-    };
+    }
 
     test('JSON Protocol String', () {
-      serializer.protocol = new TJsonProtocol(serializer.transport);
-      deserializer.protocol = new TJsonProtocol(deserializer.transport);
-      
+      serializer.protocol = TJsonProtocol(serializer.transport);
+      deserializer.protocol = TJsonProtocol(deserializer.transport);
+
       runWriteStringTest();
     });
 
     test('JSON Protocol', () {
-      serializer.protocol = new TJsonProtocol(serializer.transport);
-      deserializer.protocol = new TJsonProtocol(deserializer.transport);
+      serializer.protocol = TJsonProtocol(serializer.transport);
+      deserializer.protocol = TJsonProtocol(deserializer.transport);
 
       runWriteTest();
     });
 
     test('Binary Protocol String', () {
-      serializer.protocol = new TBinaryProtocol(serializer.transport);
-      deserializer.protocol = new TBinaryProtocol(deserializer.transport);
+      serializer.protocol = TBinaryProtocol(serializer.transport);
+      deserializer.protocol = TBinaryProtocol(deserializer.transport);
 
       runWriteStringTest();
     });
 
     test('Binary Protocol', () {
-      serializer.protocol = new TBinaryProtocol(serializer.transport);
-      deserializer.protocol = new TBinaryProtocol(deserializer.transport);
+      serializer.protocol = TBinaryProtocol(serializer.transport);
+      deserializer.protocol = TBinaryProtocol(deserializer.transport);
 
       runWriteTest();
     });
 
     test('Compact Protocol String', () {
-      serializer.protocol = new TCompactProtocol(serializer.transport);
-      deserializer.protocol = new TCompactProtocol(deserializer.transport);
+      serializer.protocol = TCompactProtocol(serializer.transport);
+      deserializer.protocol = TCompactProtocol(deserializer.transport);
 
       runWriteStringTest();
     });
 
     test('Compact Protocol', () {
-      serializer.protocol = new TCompactProtocol(serializer.transport);
-      deserializer.protocol = new TCompactProtocol(deserializer.transport);
+      serializer.protocol = TCompactProtocol(serializer.transport);
+      deserializer.protocol = TCompactProtocol(deserializer.transport);
 
       runWriteTest();
     });
diff --git a/lib/dart/test/serializer/serializer_test_data.dart b/lib/dart/test/serializer/serializer_test_data.dart
index 3586f08..fc488f4 100644
--- a/lib/dart/test/serializer/serializer_test_data.dart
+++ b/lib/dart/test/serializer/serializer_test_data.dart
@@ -23,12 +23,12 @@
 
 /// TestTObject is a simple test struct
 class TestTObject implements TBase {
-  static final TStruct _STRUCT_DESC = new TStruct("TestTObject");
-  static final TField _I_FIELD_DESC = new TField("i", TType.I32, 1);
-  static final TField _D_FIELD_DESC = new TField("d", TType.DOUBLE, 2);
-  static final TField _S_FIELD_DESC = new TField("s", TType.STRING, 3);
-  static final TField _L_FIELD_DESC = new TField("l", TType.LIST, 4);
-  static final TField _B_FIELD_DESC = new TField("b", TType.BOOL, 5);
+  static final TStruct _STRUCT_DESC = TStruct("TestTObject");
+  static final TField _I_FIELD_DESC = TField("i", TType.I32, 1);
+  static final TField _D_FIELD_DESC = TField("d", TType.DOUBLE, 2);
+  static final TField _S_FIELD_DESC = TField("s", TType.STRING, 3);
+  static final TField _L_FIELD_DESC = TField("l", TType.LIST, 4);
+  static final TField _B_FIELD_DESC = TField("b", TType.BOOL, 5);
 
   int _i;
   static const int I = 1;
@@ -45,8 +45,7 @@
   bool __isset_d = false;
   bool __isset_b = false;
 
-  TestTObject() {
-  }
+  TestTObject();
 
   // i
   int get i => this._i;
@@ -116,6 +115,7 @@
     this.__isset_b = false;
   }
 
+  @override
   getFieldValue(int fieldID) {
     switch (fieldID) {
       case I:
@@ -129,10 +129,11 @@
       case B:
         return this.b;
       default:
-        throw new ArgumentError("Field $fieldID doesn't exist!");
+        throw ArgumentError("Field $fieldID doesn't exist!");
     }
   }
 
+  @override
   setFieldValue(int fieldID, Object value) {
     switch (fieldID) {
       case I:
@@ -176,11 +177,12 @@
         break;
 
       default:
-        throw new ArgumentError("Field $fieldID doesn't exist!");
+        throw ArgumentError("Field $fieldID doesn't exist!");
     }
   }
 
   // Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise
+  @override
   bool isSet(int fieldID) {
     switch (fieldID) {
       case I:
@@ -194,10 +196,11 @@
       case B:
         return isSetB();
       default:
-        throw new ArgumentError("Field $fieldID doesn't exist!");
+        throw ArgumentError("Field $fieldID doesn't exist!");
     }
   }
 
+  @override
   read(TProtocol iprot) {
     TField field;
     iprot.readStructBegin();
@@ -234,7 +237,7 @@
           if (field.type == TType.LIST) {
             {
               TList _list74 = iprot.readListBegin();
-              this.l = new List<String>();
+              this.l = List<String>();
               for (int _i75 = 0; _i75 < _list74.length; ++_i75) {
                 String _elem76;
                 _elem76 = iprot.readString();
@@ -266,6 +269,7 @@
     validate();
   }
 
+  @override
   write(TProtocol oprot) {
     validate();
 
@@ -284,7 +288,7 @@
     if (this.l != null) {
       oprot.writeFieldBegin(_L_FIELD_DESC);
       {
-        oprot.writeListBegin(new TList(TType.STRING, this.l.length));
+        oprot.writeListBegin(TList(TType.STRING, this.l.length));
         for (var elem77 in this.l) {
           oprot.writeString(elem77);
         }
@@ -299,8 +303,9 @@
     oprot.writeStructEnd();
   }
 
+  @override
   String toString() {
-    StringBuffer ret = new StringBuffer("TestTObject(");
+    StringBuffer ret = StringBuffer("TestTObject(");
 
     ret.write("i:");
     ret.write(this.i);
@@ -338,5 +343,4 @@
     // check for required fields
     // check that fields of type enum have valid values
   }
-
 }
diff --git a/lib/dart/test/t_application_error_test.dart b/lib/dart/test/t_application_error_test.dart
index 511d8d6..848ce56 100644
--- a/lib/dart/test/t_application_error_test.dart
+++ b/lib/dart/test/t_application_error_test.dart
@@ -24,15 +24,14 @@
   TProtocol protocol;
 
   setUp(() {
-    protocol = new TBinaryProtocol(new TBufferedTransport());
+    protocol = TBinaryProtocol(TBufferedTransport());
   });
 
   test('Write and read an application error', () {
     var expectedType = TApplicationErrorType.INTERNAL_ERROR;
     var expectedMessage = 'test error message';
 
-    TApplicationError error =
-        new TApplicationError(expectedType, expectedMessage);
+    TApplicationError error = TApplicationError(expectedType, expectedMessage);
     error.write(protocol);
 
     protocol.transport.flush();
diff --git a/lib/dart/test/transport/t_framed_transport_test.dart b/lib/dart/test/transport/t_framed_transport_test.dart
index 7ab4905..d9a15a5 100644
--- a/lib/dart/test/transport/t_framed_transport_test.dart
+++ b/lib/dart/test/transport/t_framed_transport_test.dart
@@ -18,15 +18,15 @@
 library thrift.test.transport.t_framed_transport_test;
 
 import 'dart:async';
+import 'dart:convert' show utf8;
 import 'dart:typed_data' show Uint8List;
 
-import 'package:dart2_constant/convert.dart' show utf8;
 import 'package:test/test.dart';
 import 'package:thrift/thrift.dart';
 
 void main() {
   group('TFramedTransport partial reads', () {
-    final flushAwaitDuration = new Duration(seconds: 10);
+    final flushAwaitDuration = Duration(seconds: 10);
 
     FakeReadOnlySocket socket;
     TSocketTransport socketTransport;
@@ -34,22 +34,24 @@
     var messageAvailable;
 
     setUp(() {
-      socket = new FakeReadOnlySocket();
-      socketTransport = new TClientSocketTransport(socket);
-      transport = new TFramedTransport(socketTransport);
+      socket = FakeReadOnlySocket();
+      socketTransport = TClientSocketTransport(socket);
+      transport = TFramedTransport(socketTransport);
       messageAvailable = false;
     });
 
     expectNoReadableBytes() {
-      var readBuffer = new Uint8List(128);
+      var readBuffer = Uint8List(128);
       var readBytes = transport.read(readBuffer, 0, readBuffer.lengthInBytes);
       expect(readBytes, 0);
       expect(messageAvailable, false);
     }
 
-    test('Test transport reads messages where header and body are sent separately', () async {
+    test(
+        'Test transport reads messages where header and body are sent separately',
+        () async {
       // buffer into which we'll read
-      var readBuffer = new Uint8List(10);
+      var readBuffer = Uint8List(10);
       var readBytes;
 
       // registers for readable bytes
@@ -59,21 +61,22 @@
       });
 
       // write header bytes
-      socket.messageController.add(new Uint8List.fromList([0x00, 0x00, 0x00, 0x06]));
+      socket.messageController
+          .add(Uint8List.fromList([0x00, 0x00, 0x00, 0x06]));
 
       // you shouldn't be able to get any bytes from the read,
       // because the header has been consumed internally
       expectNoReadableBytes();
 
       // write first batch of body
-      socket.messageController.add(new Uint8List.fromList(utf8.encode("He")));
+      socket.messageController.add(Uint8List.fromList(utf8.encode("He")));
 
       // you shouldn't be able to get any bytes from the read,
       // because the frame has been consumed internally
       expectNoReadableBytes();
 
       // write second batch of body
-      socket.messageController.add(new Uint8List.fromList(utf8.encode("llo!")));
+      socket.messageController.add(Uint8List.fromList(utf8.encode("llo!")));
 
       // have to wait for the flush to complete,
       // because it's only then that the frame is available for reading
@@ -86,10 +89,11 @@
       expect(readBuffer.sublist(0, 6), utf8.encode("Hello!"));
     });
 
-    test('Test transport reads messages where header is sent in pieces '
-         'and body is also sent in pieces', () async {
+    test(
+        'Test transport reads messages where header is sent in pieces '
+        'and body is also sent in pieces', () async {
       // buffer into which we'll read
-      var readBuffer = new Uint8List(10);
+      var readBuffer = Uint8List(10);
       var readBytes;
 
       // registers for readable bytes
@@ -99,27 +103,27 @@
       });
 
       // write first part of header bytes
-      socket.messageController.add(new Uint8List.fromList([0x00, 0x00]));
+      socket.messageController.add(Uint8List.fromList([0x00, 0x00]));
 
       // you shouldn't be able to get any bytes from the read
       expectNoReadableBytes();
 
       // write second part of header bytes
-      socket.messageController.add(new Uint8List.fromList([0x00, 0x03]));
+      socket.messageController.add(Uint8List.fromList([0x00, 0x03]));
 
       // you shouldn't be able to get any bytes from the read again
       // because only the header was read, and there's no frame body
       readBytes = expectNoReadableBytes();
 
       // write first batch of body
-      socket.messageController.add(new Uint8List.fromList(utf8.encode("H")));
+      socket.messageController.add(Uint8List.fromList(utf8.encode("H")));
 
       // you shouldn't be able to get any bytes from the read,
       // because the frame has been consumed internally
       expectNoReadableBytes();
 
       // write second batch of body
-      socket.messageController.add(new Uint8List.fromList(utf8.encode("i!")));
+      socket.messageController.add(Uint8List.fromList(utf8.encode("i!")));
 
       // have to wait for the flush to complete,
       // because it's only then that the frame is available for reading
@@ -134,17 +138,18 @@
   });
 }
 
-
-
 class FakeReadOnlySocket extends TSocket {
-
-  StreamController<Uint8List> messageController = new StreamController<Uint8List>(sync: true);
-  StreamController<Object> errorController = new StreamController<Object>();
-  StreamController<TSocketState> stateController = new StreamController<TSocketState>();
+  StreamController<Uint8List> messageController =
+      StreamController<Uint8List>(sync: true);
+  StreamController<Object> errorController = StreamController<Object>();
+  StreamController<TSocketState> stateController =
+      StreamController<TSocketState>();
 
   @override
-  Future close() {
-    // noop
+  Future close() async {
+    messageController.close();
+    errorController.close();
+    stateController.close();
   }
 
   @override
@@ -163,7 +168,7 @@
   Stream<TSocketState> get onState => stateController.stream;
 
   @override
-  Future open() {
+  Future open() async {
     // noop
   }
 
@@ -172,4 +177,3 @@
     // noop
   }
 }
-
diff --git a/lib/dart/test/transport/t_http_transport_test.dart b/lib/dart/test/transport/t_http_transport_test.dart
index 03ccede..13f0ee9 100644
--- a/lib/dart/test/transport/t_http_transport_test.dart
+++ b/lib/dart/test/transport/t_http_transport_test.dart
@@ -20,9 +20,9 @@
 import 'dart:async';
 import 'dart:convert' show Encoding;
 import 'dart:convert' show Utf8Codec;
+import 'dart:convert' show base64;
 import 'dart:typed_data' show Uint8List;
 
-import 'package:dart2_constant/convert.dart' show base64;
 import 'package:http/http.dart' show BaseRequest;
 import 'package:http/http.dart' show Client;
 import 'package:http/http.dart' show Response;
@@ -31,16 +31,16 @@
 import 'package:thrift/thrift.dart';
 
 void main() {
-  const utf8Codec = const Utf8Codec();
+  const utf8Codec = Utf8Codec();
 
   group('THttpClientTransport', () {
     FakeHttpClient client;
     THttpClientTransport transport;
 
     setUp(() {
-      client = new FakeHttpClient(sync: false);
-      var config = new THttpConfig(Uri.parse('http://localhost'), {});
-      transport = new THttpClientTransport(client, config);
+      client = FakeHttpClient(sync: false);
+      var config = THttpConfig(Uri.parse('http://localhost'), {});
+      transport = THttpClientTransport(client, config);
     });
 
     test('Test transport sends body', () async {
@@ -69,7 +69,7 @@
 
       expect(transport.hasReadData, isTrue);
 
-      var buffer = new Uint8List(expectedBytes.length);
+      var buffer = Uint8List(expectedBytes.length);
       transport.readAll(buffer, 0, expectedBytes.length);
 
       var bufferText = utf8Codec.decode(buffer);
@@ -82,9 +82,9 @@
     THttpClientTransport transport;
 
     setUp(() {
-      client = new FakeHttpClient(sync: true);
-      var config = new THttpConfig(Uri.parse('http://localhost'), {});
-      transport = new THttpClientTransport(client, config);
+      client = FakeHttpClient(sync: true);
+      var config = THttpConfig(Uri.parse('http://localhost'), {});
+      transport = THttpClientTransport(client, config);
     });
 
     test('Test read correct buffer after flush', () async {
@@ -97,7 +97,7 @@
       client.postResponse = base64.encode(expectedBytes);
 
       Future responseReady = transport.flush().then((_) {
-        var buffer = new Uint8List(expectedBytes.length);
+        var buffer = Uint8List(expectedBytes.length);
         transport.readAll(buffer, 0, expectedBytes.length);
         bufferText = utf8Codec.decode(buffer);
       });
@@ -120,45 +120,55 @@
 
   final bool sync;
 
-  FakeHttpClient({this.sync: false});
+  FakeHttpClient({this.sync = false});
 
+  @override
   Future<Response> post(url,
       {Map<String, String> headers, body, Encoding encoding}) {
     postRequest = body;
-    var response = new Response(postResponse, 200);
+    var response = Response(postResponse, 200);
 
     if (sync) {
-      return new Future.sync(() => response);
+      return Future.sync(() => response);
     } else {
-      return new Future.value(response);
+      return Future.value(response);
     }
   }
 
+  @override
   Future<Response> head(url, {Map<String, String> headers}) =>
-      throw new UnimplementedError();
+      throw UnimplementedError();
 
+  @override
   Future<Response> get(url, {Map<String, String> headers}) =>
-      throw new UnimplementedError();
+      throw UnimplementedError();
 
+  @override
   Future<Response> put(url,
           {Map<String, String> headers, body, Encoding encoding}) =>
-      throw new UnimplementedError();
+      throw UnimplementedError();
 
+  @override
   Future<Response> patch(url,
           {Map<String, String> headers, body, Encoding encoding}) =>
-      throw new UnimplementedError();
+      throw UnimplementedError();
 
+  @override
   Future<Response> delete(url, {Map<String, String> headers}) =>
-      throw new UnimplementedError();
+      throw UnimplementedError();
 
+  @override
   Future<String> read(url, {Map<String, String> headers}) =>
-      throw new UnimplementedError();
+      throw UnimplementedError();
 
+  @override
   Future<Uint8List> readBytes(url, {Map<String, String> headers}) =>
-      throw new UnimplementedError();
+      throw UnimplementedError();
 
+  @override
   Future<StreamedResponse> send(BaseRequest request) =>
-      throw new UnimplementedError();
+      throw UnimplementedError();
 
-  void close() => throw new UnimplementedError();
+  @override
+  void close() => throw UnimplementedError();
 }
diff --git a/lib/dart/test/transport/t_socket_transport_test.dart b/lib/dart/test/transport/t_socket_transport_test.dart
index 90bffbe..d46f5ed 100644
--- a/lib/dart/test/transport/t_socket_transport_test.dart
+++ b/lib/dart/test/transport/t_socket_transport_test.dart
@@ -18,24 +18,22 @@
 library thrift.test.transport.t_socket_transport_test;
 
 import 'dart:async';
-import 'dart:convert' show Utf8Codec;
+import 'dart:convert' show Utf8Codec, base64;
 import 'dart:typed_data' show Uint8List;
 
-import 'package:dart2_constant/convert.dart' show base64;
-import 'package:dart2_constant/core.dart' as core;
 import 'package:mockito/mockito.dart';
 import 'package:test/test.dart';
 import 'package:thrift/thrift.dart';
 
 void main() {
-  const utf8Codec = const Utf8Codec();
+  const utf8Codec = Utf8Codec();
 
   final requestText = 'my test request';
-  final requestBytes = new Uint8List.fromList(utf8Codec.encode(requestText));
+  final requestBytes = Uint8List.fromList(utf8Codec.encode(requestText));
   final requestBase64 = base64.encode(requestBytes);
 
   final responseText = 'response 1';
-  final responseBytes = new Uint8List.fromList(utf8Codec.encode(responseText));
+  final responseBytes = Uint8List.fromList(utf8Codec.encode(responseText));
   final responseBase64 = base64.encode(responseBytes);
 
   final framedResponseBase64 = base64.encode(_getFramedResponse(responseBytes));
@@ -45,9 +43,9 @@
     TTransport transport;
 
     setUp(() async {
-      socket = new FakeSocket(sync: false);
+      socket = FakeSocket(sync: false);
       await socket.open();
-      transport = new TClientSocketTransport(socket);
+      transport = TClientSocketTransport(socket);
       await transport.open();
       transport.writeAll(requestBytes);
     });
@@ -58,7 +56,7 @@
       Future responseReady = transport.flush();
 
       // allow microtask events to finish
-      await new Future.value();
+      await Future.value();
 
       expect(socket.sendPayload, isNotNull);
       expect(socket.sendPayload, requestBytes);
@@ -67,23 +65,23 @@
       socket.receiveFakeMessage(responseBase64);
 
       await responseReady;
-      var buffer = new Uint8List(responseBytes.length);
+      var buffer = Uint8List(responseBytes.length);
       transport.readAll(buffer, 0, responseBytes.length);
       var bufferText = utf8Codec.decode(buffer);
 
       expect(bufferText, responseText);
     });
-  }, timeout: new Timeout(new Duration(seconds: 1)));
+  }, timeout: Timeout(Duration(seconds: 1)));
 
   group('TClientSocketTransport with FramedTransport', () {
     FakeSocket socket;
     TTransport transport;
 
     setUp(() async {
-      socket = new FakeSocket(sync: true);
+      socket = FakeSocket(sync: true);
       await socket.open();
 
-      transport = new TFramedTransport(new TClientSocketTransport(socket));
+      transport = TFramedTransport(TClientSocketTransport(socket));
       await transport.open();
       transport.writeAll(requestBytes);
     });
@@ -92,7 +90,7 @@
       String bufferText;
 
       Future responseReady = transport.flush().then((_) {
-        var buffer = new Uint8List(responseBytes.length);
+        var buffer = Uint8List(responseBytes.length);
         transport.readAll(buffer, 0, responseBytes.length);
         bufferText = utf8Codec.decode(buffer);
       });
@@ -103,7 +101,7 @@
       await responseReady;
       expect(bufferText, responseText);
     });
-  }, timeout: new Timeout(new Duration(seconds: 1)));
+  }, timeout: Timeout(Duration(seconds: 1)));
 
   group('TAsyncClientSocketTransport', () {
     FakeSocket socket;
@@ -111,14 +109,14 @@
     TTransport transport;
 
     setUp(() async {
-      socket = new FakeSocket(sync: true);
+      socket = FakeSocket(sync: true);
       await socket.open();
 
-      protocolFactory = new FakeProtocolFactory();
-      protocolFactory.message = new TMessage('foo', TMessageType.CALL, 123);
-      transport = new TAsyncClientSocketTransport(
-          socket, new TMessageReader(protocolFactory),
-          responseTimeout: core.Duration.zero);
+      protocolFactory = FakeProtocolFactory();
+      protocolFactory.message = TMessage('foo', TMessageType.CALL, 123);
+      transport = TAsyncClientSocketTransport(
+          socket, TMessageReader(protocolFactory),
+          responseTimeout: Duration.zero);
       await transport.open();
       transport.writeAll(requestBytes);
     });
@@ -127,21 +125,20 @@
       String bufferText;
 
       Future responseReady = transport.flush().then((_) {
-        var buffer = new Uint8List(responseBytes.length);
+        var buffer = Uint8List(responseBytes.length);
         transport.readAll(buffer, 0, responseBytes.length);
         bufferText = utf8Codec.decode(buffer);
       });
 
       // simulate a response
-      protocolFactory.message = new TMessage('foo', TMessageType.REPLY, 123);
+      protocolFactory.message = TMessage('foo', TMessageType.REPLY, 123);
       socket.receiveFakeMessage(responseBase64);
 
       // simulate a second response
       var response2Text = 'response 2';
-      var response2Bytes =
-          new Uint8List.fromList(utf8Codec.encode(response2Text));
+      var response2Bytes = Uint8List.fromList(utf8Codec.encode(response2Text));
       var response2Base64 = base64.encode(response2Bytes);
-      protocolFactory.message = new TMessage('foo2', TMessageType.REPLY, 124);
+      protocolFactory.message = TMessage('foo2', TMessageType.REPLY, 124);
       socket.receiveFakeMessage(response2Base64);
 
       await responseReady;
@@ -150,9 +147,9 @@
 
     test('Test response timeout', () async {
       Future responseReady = transport.flush();
-      expect(responseReady, throwsA(new isInstanceOf<TimeoutException>()));
+      expect(responseReady, throwsA(isA<TimeoutException>()));
     });
-  }, timeout: new Timeout(new Duration(seconds: 1)));
+  }, timeout: Timeout(Duration(seconds: 1)));
 
   group('TAsyncClientSocketTransport with TFramedTransport', () {
     FakeSocket socket;
@@ -160,17 +157,17 @@
     TTransport transport;
 
     setUp(() async {
-      socket = new FakeSocket(sync: true);
+      socket = FakeSocket(sync: true);
       await socket.open();
 
-      protocolFactory = new FakeProtocolFactory();
-      protocolFactory.message = new TMessage('foo', TMessageType.CALL, 123);
-      var messageReader = new TMessageReader(protocolFactory,
+      protocolFactory = FakeProtocolFactory();
+      protocolFactory.message = TMessage('foo', TMessageType.CALL, 123);
+      var messageReader = TMessageReader(protocolFactory,
           byteOffset: TFramedTransport.headerByteCount);
 
-      transport = new TFramedTransport(new TAsyncClientSocketTransport(
+      transport = TFramedTransport(TAsyncClientSocketTransport(
           socket, messageReader,
-          responseTimeout: core.Duration.zero));
+          responseTimeout: Duration.zero));
       await transport.open();
       transport.writeAll(requestBytes);
     });
@@ -179,37 +176,37 @@
       String bufferText;
 
       Future responseReady = transport.flush().then((_) {
-        var buffer = new Uint8List(responseBytes.length);
+        var buffer = Uint8List(responseBytes.length);
         transport.readAll(buffer, 0, responseBytes.length);
         bufferText = utf8Codec.decode(buffer);
       });
 
       // simulate a response
-      protocolFactory.message = new TMessage('foo', TMessageType.REPLY, 123);
+      protocolFactory.message = TMessage('foo', TMessageType.REPLY, 123);
       socket.receiveFakeMessage(framedResponseBase64);
 
       await responseReady;
       expect(bufferText, responseText);
     });
-  }, timeout: new Timeout(new Duration(seconds: 1)));
+  }, timeout: Timeout(Duration(seconds: 1)));
 
   group('TServerTransport', () {
     test('Test server transport listens to socket', () async {
-      var socket = new FakeSocket();
+      var socket = FakeSocket();
       await socket.open();
       expect(socket.isOpen, isTrue);
 
-      var transport = new TServerSocketTransport(socket);
+      var transport = TServerSocketTransport(socket);
       expect(transport.hasReadData, isFalse);
 
       socket.receiveFakeMessage(requestBase64);
 
       // allow microtask events to finish
-      await new Future.value();
+      await Future.value();
 
       expect(transport.hasReadData, isTrue);
 
-      var buffer = new Uint8List(requestBytes.length);
+      var buffer = Uint8List(requestBytes.length);
       transport.readAll(buffer, 0, requestBytes.length);
 
       var bufferText = utf8Codec.decode(buffer);
@@ -217,10 +214,10 @@
     });
 
     test('Test server sending data over transport', () async {
-      var socket = new FakeSocket();
+      var socket = FakeSocket();
       await socket.open();
 
-      var transport = new TServerSocketTransport(socket);
+      var transport = TServerSocketTransport(socket);
 
       transport.writeAll(responseBytes);
       expect(socket.sendPayload, isNull);
@@ -228,40 +225,47 @@
       transport.flush();
 
       // allow microtask events to finish
-      await new Future.value();
+      await Future.value();
 
       expect(socket.sendPayload, isNotNull);
       expect(socket.sendPayload, responseBytes);
     });
-  }, timeout: new Timeout(new Duration(seconds: 1)));
+  }, timeout: Timeout(Duration(seconds: 1)));
 }
 
 class FakeSocket extends TSocket {
   final StreamController<TSocketState> _onStateController;
+  @override
   Stream<TSocketState> get onState => _onStateController.stream;
 
   final StreamController<Object> _onErrorController;
+  @override
   Stream<Object> get onError => _onErrorController.stream;
 
   final StreamController<Uint8List> _onMessageController;
+  @override
   Stream<Uint8List> get onMessage => _onMessageController.stream;
 
-  FakeSocket({bool sync: false})
-      : _onStateController = new StreamController.broadcast(sync: sync),
-        _onErrorController = new StreamController.broadcast(sync: sync),
-        _onMessageController = new StreamController.broadcast(sync: sync);
+  FakeSocket({bool sync =  false})
+      : _onStateController = StreamController.broadcast(sync: sync),
+        _onErrorController = StreamController.broadcast(sync: sync),
+        _onMessageController = StreamController.broadcast(sync: sync);
 
   bool _isOpen;
 
+  @override
   bool get isOpen => _isOpen;
 
+  @override
   bool get isClosed => !isOpen;
 
+  @override
   Future open() async {
     _isOpen = true;
     _onStateController.add(TSocketState.OPEN);
   }
 
+  @override
   Future close() async {
     _isOpen = false;
     _onStateController.add(TSocketState.CLOSED);
@@ -270,16 +274,17 @@
   Uint8List _sendPayload;
   Uint8List get sendPayload => _sendPayload;
 
+  @override
   void send(Uint8List data) {
-    if (!isOpen) throw new StateError('The socket is not open');
+    if (!isOpen) throw StateError('The socket is not open');
 
     _sendPayload = data;
   }
 
   void receiveFakeMessage(String base64text) {
-    if (!isOpen) throw new StateError('The socket is not open');
+    if (!isOpen) throw StateError('The socket is not open');
 
-    var message = new Uint8List.fromList(base64.decode(base64text));
+    var message = Uint8List.fromList(base64.decode(base64text));
     _onMessageController.add(message);
   }
 }
@@ -289,7 +294,8 @@
 
   TMessage message;
 
-  getProtocol(TTransport transport) => new FakeProtocol(message);
+  @override
+  getProtocol(TTransport transport) => FakeProtocol(message);
 }
 
 class FakeProtocol extends Mock implements TProtocol {
@@ -297,12 +303,13 @@
 
   TMessage _message;
 
+  @override
   readMessageBegin() => _message;
 }
 
 Uint8List _getFramedResponse(Uint8List responseBytes) {
   var byteOffset = TFramedTransport.headerByteCount;
-  var response = new Uint8List(byteOffset + responseBytes.length);
+  var response = Uint8List(byteOffset + responseBytes.length);
 
   response.buffer.asByteData().setInt32(0, responseBytes.length);
   response.setAll(byteOffset, responseBytes);
diff --git a/lib/dart/test/transport/t_transport_test.dart b/lib/dart/test/transport/t_transport_test.dart
index 0bb381a..4758593 100644
--- a/lib/dart/test/transport/t_transport_test.dart
+++ b/lib/dart/test/transport/t_transport_test.dart
@@ -25,14 +25,14 @@
   group('TTransportFactory', () {
     test('transport is returned from base factory', () async {
       TTransport result;
-      TTransport transport = null;
+      TTransport transport;
 
-      var factory = new TTransportFactory();
+      var factory = TTransportFactory();
 
       result = await factory.getTransport(transport);
       expect(result, isNull);
 
-      transport = new TBufferedTransport();
+      transport = TBufferedTransport();
       result = await factory.getTransport(transport);
 
       expect(result, transport);