Extract testing utilities into a separate package.

pkg/analysis_server/test/protocol_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.protocol;
 
 import 'dart:convert';
 
 import 'package:analysis_server/src/protocol.dart';
+import 'package:analysis_testing/reflective_tests.dart';
 import 'package:unittest/unittest.dart';
 
-import 'reflective_tests.dart';
-
 
 Matcher _throwsRequestFailure = throwsA(new isInstanceOf<RequestFailure>());
 
 
 main() {
   groupSep = ' | ';
   group('Notification', () {
     runReflectiveTests(NotificationTest);
   });
   group('Request', () {
@@ skipping 115 matching lines @@
 
   void test_asList_emptyList() {
     expect(makeDatum([]).asList((datum) => datum.asString()), equals([]));
   }
 
   void test_asList_nonEmptyList() {
     expect(makeDatum(['foo', 'bar']).asList((datum) => datum.asString()),
         equals(['foo', 'bar']));
   }
 
-  void test_isList() {
-    expect(makeDatum(3).isList, isFalse);
-    expect(makeDatum(null).isList, isTrue);
-    expect(makeDatum([]).isList, isTrue);
-    expect(makeDatum(['foo', 'bar']).isList, isTrue);
-  }
-
   void test_asList_nonList() {
     expect(() => makeDatum(3).asList((datum) => null), _throwsInvalidParameter);
   }
 
   void test_asList_null() {
     expect(makeDatum(null).asList((datum) => datum.asString()), equals([]));
   }
 
   void test_asString() {
     expect(makeDatum('foo').asString(), equals('foo'));
     expect(() => makeDatum(3).asString(), _throwsInvalidParameter);
   }
 
-  void test_isStringList() {
-    expect(makeDatum(['foo', 'bar']).isStringList, isTrue);
-    expect(makeDatum([]).isStringList, isTrue);
-    expect(makeDatum(null).isStringList, isTrue);
-    expect(makeDatum(['foo', 1]).isStringList, isFalse);
-    expect(makeDatum({}).isStringList, isFalse);
-  }
-
   void test_asStringList() {
     expect(makeDatum(['foo', 'bar']).asStringList(), equals(['foo', 'bar']));
     expect(makeDatum([]).asStringList(), equals([]));
     expect(makeDatum(null).asStringList(), equals([]));
     expect(() => makeDatum(['foo', 1]).asStringList(), _throwsInvalidParameter);
     expect(() => makeDatum({}).asStringList(), _throwsInvalidParameter);
   }
 
-  void test_isStringListMap() {
-    expect(makeDatum({
-      'key1': ['value11', 'value12'],
-      'key2': ['value21', 'value22']
-    }).isStringListMap, isTrue);
-    expect(makeDatum({
-      'key1': 10,
-      'key2': 20
-    }).isStringListMap, isFalse);
-    expect(makeDatum({
-      'key1': [11, 12],
-      'key2': [21, 22]
-    }).isStringListMap, isFalse);
-    expect(makeDatum({}).isStringListMap, isTrue);
-    expect(makeDatum(null).isStringListMap, isTrue);
-    expect(makeDatum(3).isStringListMap, isFalse);
-  }
-
   void test_asStringListMap() {
     {
       var map = {
         'key1': ['value11', 'value12'],
         'key2': ['value21', 'value22']
       };
       expect(makeDatum(map).asStringListMap(), map);
     }
     {
       var map = {
         'key1': 10,
         'key2': 20
       };
       expect(() => makeDatum(map).asStringListMap(), _throwsInvalidParameter);
     }
     {
       var map = {
         'key1': [11, 12],
         'key2': [21, 22]
       };
       expect(() => makeDatum(map).asStringListMap(), _throwsInvalidParameter);
     }
   }
 
-  void test_isMap() {
-    expect(makeDatum({
-      'key1': 'value1',
-      'key2': 'value2'
-    }).isMap, isTrue);
-    expect(makeDatum({}).isMap, isTrue);
-    expect(makeDatum(null).isMap, isTrue);
-    expect(makeDatum({
-      'key1': 'value1',
-      'key2': 2
-    }).isMap, isTrue);
-    expect(makeDatum({
-      'key1': 1,
-      'key2': 2
-    }).isMap, isTrue);
-    expect(makeDatum([]).isMap, isFalse);
-  }
-
-  void test_isStringMap() {
-    expect(makeDatum({
-      'key1': 'value1',
-      'key2': 'value2'
-    }).isStringMap, isTrue);
-    expect(makeDatum({}).isStringMap, isTrue);
-    expect(makeDatum(null).isStringMap, isTrue);
-    expect(makeDatum({
-      'key1': 'value1',
-      'key2': 2
-    }).isStringMap, isFalse);
-    expect(makeDatum({
-      'key1': 1,
-      'key2': 2
-    }).isStringMap, isFalse);
-    expect(makeDatum([]).isMap, isFalse);
-  }
-
   void test_asStringMap() {
     expect(makeDatum({
       'key1': 'value1',
       'key2': 'value2'
     }).asStringMap(), equals({
       'key1': 'value1',
       'key2': 'value2'
     }));
     expect(makeDatum({}).asStringMap(), equals({}));
     expect(() => makeDatum({
@@ skipping 12 matching lines @@
       fail('Empty map should not be iterated');
     });
   }
 
   void test_forEachMap_nonMap() {
     expect(() => makeDatum(1).forEachMap((key, value) {
       fail('Non-map should not be iterated');
     }), _throwsInvalidParameter);
   }
 
-   void test_forEachMap_null() {
+  void test_forEachMap_null() {
     makeDatum(null).forEachMap((key, value) {
       fail('Empty map should not be iterated');
     });
   }
 
   void test_forEachMap_oneElementMap() {
     int callCount = 0;
     makeDatum({
       'key': 'value'
     }).forEachMap((key, value) {
@@ skipping 27 matching lines @@
     });
     expect(datum.hasKey('foo'), isTrue);
     expect(datum.hasKey('bar'), isFalse);
     expect(datum.hasKey('baz'), isFalse);
   }
 
   void test_hasKey_null() {
     expect(makeDatum(null).hasKey('foo'), isFalse);
   }
 
-  void test_indexOperator_hasKey() {
+   void test_indexOperator_hasKey() {
     var indexResult = makeDatum({
       'foo': 'bar'
     })['foo'];
     expect(indexResult, isRequestDatum);
     expect(indexResult.datum, equals('bar'));
     expect(indexResult.path, equals('myPath.foo'));
   }
 
-  void test_indexOperator_null() {
-    expect(() => makeDatum(null)['foo'], _throwsInvalidParameter);
-  }
-
   void test_indexOperator_missingKey() {
     expect(() => makeDatum({
       'foo': 'bar'
     })['baz'], _throwsInvalidParameter);
   }
 
   void test_indexOperator_nonMap() {
     expect(() => makeDatum(1)['foo'], _throwsInvalidParameter);
   }
 
+  void test_indexOperator_null() {
+    expect(() => makeDatum(null)['foo'], _throwsInvalidParameter);
+  }
+
+  void test_isList() {
+    expect(makeDatum(3).isList, isFalse);
+    expect(makeDatum(null).isList, isTrue);
+    expect(makeDatum([]).isList, isTrue);
+    expect(makeDatum(['foo', 'bar']).isList, isTrue);
+  }
+
+  void test_isMap() {
+    expect(makeDatum({
+      'key1': 'value1',
+      'key2': 'value2'
+    }).isMap, isTrue);
+    expect(makeDatum({}).isMap, isTrue);
+    expect(makeDatum(null).isMap, isTrue);
+    expect(makeDatum({
+      'key1': 'value1',
+      'key2': 2
+    }).isMap, isTrue);
+    expect(makeDatum({
+      'key1': 1,
+      'key2': 2
+    }).isMap, isTrue);
+    expect(makeDatum([]).isMap, isFalse);
+  }
+
+  void test_isStringList() {
+    expect(makeDatum(['foo', 'bar']).isStringList, isTrue);
+    expect(makeDatum([]).isStringList, isTrue);
+    expect(makeDatum(null).isStringList, isTrue);
+    expect(makeDatum(['foo', 1]).isStringList, isFalse);
+    expect(makeDatum({}).isStringList, isFalse);
+  }
+
+  void test_isStringListMap() {
+    expect(makeDatum({
+      'key1': ['value11', 'value12'],
+      'key2': ['value21', 'value22']
+    }).isStringListMap, isTrue);
+    expect(makeDatum({
+      'key1': 10,
+      'key2': 20
+    }).isStringListMap, isFalse);
+    expect(makeDatum({
+      'key1': [11, 12],
+      'key2': [21, 22]
+    }).isStringListMap, isFalse);
+    expect(makeDatum({}).isStringListMap, isTrue);
+    expect(makeDatum(null).isStringListMap, isTrue);
+    expect(makeDatum(3).isStringListMap, isFalse);
+  }
+
+  void test_isStringMap() {
+    expect(makeDatum({
+      'key1': 'value1',
+      'key2': 'value2'
+    }).isStringMap, isTrue);
+    expect(makeDatum({}).isStringMap, isTrue);
+    expect(makeDatum(null).isStringMap, isTrue);
+    expect(makeDatum({
+      'key1': 'value1',
+      'key2': 2
+    }).isStringMap, isFalse);
+    expect(makeDatum({
+      'key1': 1,
+      'key2': 2
+    }).isStringMap, isFalse);
+    expect(makeDatum([]).isMap, isFalse);
+  }
+
   static RequestDatum makeDatum(dynamic datum) {
     return new RequestDatum(request, 'myPath', datum);
   }
 }
 
 
 @ReflectiveTestCase()
 class RequestErrorTest {
   void test_create() {
     RequestError error = new RequestError(42, 'msg');
@@ skipping 294 matching lines @@
     response.setResult(resultName, resultValue);
     expect(response.getResult(resultName), same(resultValue));
     expect(response.toJson(), equals({
       Response.ID: '0',
       Response.RESULT: {
         resultName: resultValue
       }
     }));
   }
 }