Fix remaining RequestDatum tests.

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:unittest/unittest.dart';
@@ skipping 232 matching lines @@
 
 class InvalidParameterResponseMatcher extends Matcher {
   static const int ERROR_CODE = -2;
 
   @override
   Description describe(Description description) =>
       description.add("an 'invalid parameter' response (code $ERROR_CODE)");
 
   @override
   bool matches(item, Map matchState) {
-    if (item is! Response) {
+    if (item is! RequestFailure) {
       return false;
     }
-    Response response = item;
+    var response = item.response;
+    if (response is! Response) {
+      return false;
+    }
     if (response.error is! RequestError) {
       return false;
     }
     RequestError requestError = response.error;
     if (requestError.code != ERROR_CODE) {
       return false;
     }
     return true;
   }
 }
 
 class RequestDatumTest {
   static Request request;
 
   static Matcher _throwsInvalidParameter = throwsA(
       new InvalidParameterResponseMatcher());
   static Matcher isRequestDatum = new isInstanceOf<RequestDatum>("RequestDatum"
       );
 
   static void setUp() {
     request = new Request('myId', 'myMethod');
   }
 
   static RequestDatum makeDatum(dynamic datum) {
     return new RequestDatum(request, 'myPath', datum);
   }
 
   @runTest
   static void indexOperator_nonMap() {
-    //TODO fails
-//    expect(() => makeDatum(1)['foo'], _throwsInvalidParameter);
+    setUp();
+    expect(() => makeDatum(1)['foo'], _throwsInvalidParameter);
   }
 
   @runTest
   static void indexOperator_missingKey() {
-    //TODO fails
-//    expect(() => makeDatum({
-//      'foo': 'bar'
-//    })['baz'], _throwsInvalidParameter);
+    setUp();
+    expect(() => makeDatum({
+      'foo': 'bar'
+    })['baz'], _throwsInvalidParameter);
   }
 
   @runTest
   static void indexOperator_hasKey() {
+    setUp();
     var indexResult = makeDatum({
       'foo': 'bar'
     })['foo'];
     expect(indexResult, isRequestDatum);
     expect(indexResult.datum, equals('bar'));
     expect(indexResult.path, equals('myPath.foo'));
   }
 
   @runTest
   static void hasKey() {
+    setUp();
     var datum = makeDatum({
       'foo': 'bar'
     });
     expect(datum.hasKey('foo'), isTrue);
     expect(datum.hasKey('bar'), isFalse);
     expect(datum.hasKey('baz'), isFalse);
   }
 
   @runTest
   static void forEachMap_nonMap() {
-    //TODO fails
-//    expect(() => makeDatum(1).forEachMap((key, value) {
-//      fail('Non-map should not be iterated');
-//    }), _throwsInvalidParameter);
+    setUp();
+    expect(() => makeDatum(1).forEachMap((key, value) {
+      fail('Non-map should not be iterated');
+    }), _throwsInvalidParameter);
   }
 
   @runTest
   static void forEachMap_emptyMap() {
+    setUp();
     makeDatum({}).forEachMap((key, value) {
       fail('Empty map should not be iterated');
     });
   }
 
   @runTest
   static void forEachMap_oneElementMap() {
+    setUp();
     int callCount = 0;
     makeDatum({
       'key': 'value'
     }).forEachMap((key, value) {
       callCount++;
       expect(key, equals('key'));
       expect(value, isRequestDatum);
       expect(value.datum, equals('value'));
     });
     expect(callCount, equals(1));
   }
 
   @runTest
   static void forEachMap_twoElementMap() {
+    setUp();
     int callCount = 0;
     Map<String, String> map = {
       'key1': 'value1',
       'key2': 'value2'
     };
     Map iterationResult = {};
     makeDatum(map).forEachMap((key, value) {
       callCount++;
       expect(value, isRequestDatum);
       iterationResult[key] = value.datum;
     });
     expect(callCount, equals(2));
     expect(iterationResult, equals(map));
   }
 
   @runTest
   static void asBool() {
+    setUp();
     expect(makeDatum(true).asBool(), isTrue);
     expect(makeDatum(false).asBool(), isFalse);
     expect(makeDatum('true').asBool(), isTrue);
     expect(makeDatum('false').asBool(), isFalse);
-    //TODO fails
-//    expect(() => makeDatum('abc').asBool(), _throwsInvalidParameter);
+    expect(() => makeDatum('abc').asBool(), _throwsInvalidParameter);
   }
 
   @runTest
   static void asInt() {
+    setUp();
     expect(makeDatum(1).asInt(), equals(1));
     expect(makeDatum('2').asInt(), equals(2));
-    //TODO fails
-//    expect(() => makeDatum('xxx').asInt(), _throwsInvalidParameter);
-//    expect(() => makeDatum(true).asInt(), _throwsInvalidParameter);
+    expect(() => makeDatum('xxx').asInt(), _throwsInvalidParameter);
+    expect(() => makeDatum(true).asInt(), _throwsInvalidParameter);
   }
 
   @runTest
   static void asString() {
+    setUp();
     expect(makeDatum('foo').asString(), equals('foo'));
-    //TODO fails
-//    expect(() => makeDatum(3).asString(), _throwsInvalidParameter);
+    expect(() => makeDatum(3).asString(), _throwsInvalidParameter);
   }
 
   @runTest
   static void asStringList() {
+    setUp();
     expect(makeDatum(['foo', 'bar']).asStringList(), equals(['foo', 'bar']));
     expect(makeDatum([]).asStringList(), equals([]));
-    //TODO fails
-//    expect(() => makeDatum(['foo', 1]).asStringList(), _throwsInvalidParameter);
-//    expect(() => makeDatum({}).asStringList(), _throwsInvalidParameter);
+    expect(() => makeDatum(['foo', 1]).asStringList(), _throwsInvalidParameter);
+    expect(() => makeDatum({}).asStringList(), _throwsInvalidParameter);
   }
 
   @runTest
   static void asStringMap() {
+    setUp();
     expect(makeDatum({
       'key1': 'value1',
       'key2': 'value2'
     }).asStringMap(), equals({
       'key1': 'value1',
       'key2': 'value2'
     }));
     expect(makeDatum({}).asStringMap(), equals({}));
-    //TODO fails
-//    expect(() => makeDatum({
-//      'key1': 'value1',
-//      'key2': 2
-//    }).asStringMap(), _throwsInvalidParameter);
-//    expect(() => makeDatum({
-//      'key1': 1,
-//      'key2': 2
-//    }).asStringMap(), _throwsInvalidParameter);
-//    expect(() => makeDatum({
-//      1: 'value1',
-//      2: 'value2'
-//    }).asStringMap(), _throwsInvalidParameter);
-//    expect(() => makeDatum([]).asStringMap(), _throwsInvalidParameter);
+    expect(() => makeDatum({
+      'key1': 'value1',
+      'key2': 2
+    }).asStringMap(), _throwsInvalidParameter);
+    expect(() => makeDatum({
+      'key1': 1,
+      'key2': 2
+    }).asStringMap(), _throwsInvalidParameter);
+    expect(() => makeDatum([]).asStringMap(), _throwsInvalidParameter);
   }
 }
 
 class ResponseTest {
   @runTest
   static void create_contextDoesNotExist() {
     Response response = new Response.contextDoesNotExist(new Request('0', ''));
     expect(response.id, equals('0'));
     expect(response.error, isNotNull);
     expect(response.toJson(), equals({
@@ skipping 85 matching lines @@
     original.setResult('foo', 'bar');
     Response response = new Response.fromJson(original.toJson());
     expect(response.id, equals('myId'));
     Map<String, Object> result = response.result;
     expect(result.length, equals(1));
     expect(result['foo'], equals('bar'));
   }
 }
 
 Matcher _throwsRequestFailure = throwsA(new isInstanceOf<RequestFailure>());