Allow "null" as a synonym for [] or {} in the analysis server API.

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 57 matching lines @@
   @runTest
   static void getParameter_defined() {
     String name = 'name';
     String value = 'value';
     Request request = new Request('0', '');
     request.setParameter(name, value);
     expect(request.getParameter(name, null).datum, equals(value));
   }
 
   @runTest
+  static void getParameter_null() {
+    String name = 'name';
+    Request request = new Request('0', '');
+    request.setParameter(name, null);
+    expect(request.getParameter(name, 'default').datum, equals(null));
+  }
+
+  @runTest
   static void getParameter_undefined() {
     String name = 'name';
     String defaultValue = 'default value';
     Request request = new Request('0', '');
     expect(request.getParameter(name, defaultValue).datum, equals(defaultValue));
   }
 
   @runTest
   static void getRequiredParameter_defined() {
     String name = 'name';
     String value = 'value';
     Request request = new Request('0', '');
     request.setParameter(name, value);
     expect(request.getRequiredParameter(name).datum, equals(value));
   }
 
   @runTest
+  static void getRequiredParameter_null() {
+    String name = 'name';
+    Request request = new Request('0', '');
+    request.setParameter(name, null);
+    expect(request.getRequiredParameter(name).datum, equals(null));
+  }
+
+  @runTest
   static void getRequiredParameter_undefined() {
     String name = 'name';
     Request request = new Request('0', '');
     expect(() => request.getRequiredParameter(name), _throwsRequestFailure);
   }
 
   @runTest
   static void fromJson() {
     Request original = new Request('one', 'aMethod');
     String json = JSON.encode(original.toJson());
@@ skipping 179 matching lines @@
     return new RequestDatum(request, 'myPath', datum);
   }
 
   @runTest
   static void indexOperator_nonMap() {
     setUp();
     expect(() => makeDatum(1)['foo'], _throwsInvalidParameter);
   }
 
   @runTest
+  static void indexOperator_null() {
+    setUp();
+    expect(() => makeDatum(null)['foo'], _throwsInvalidParameter);
+  }
+
+  @runTest
   static void indexOperator_missingKey() {
     setUp();
     expect(() => makeDatum({
       'foo': 'bar'
     })['baz'], _throwsInvalidParameter);
   }
 
   @runTest
   static void indexOperator_hasKey() {
     setUp();
@@ skipping 10 matching lines @@
     setUp();
     var datum = makeDatum({
       'foo': 'bar'
     });
     expect(datum.hasKey('foo'), isTrue);
     expect(datum.hasKey('bar'), isFalse);
     expect(datum.hasKey('baz'), isFalse);
   }
 
   @runTest
+  static void hasKey_null() {
+    setUp();
+    expect(makeDatum(null).hasKey('foo'), isFalse);
+  }
+
+  @runTest
   static void forEachMap_nonMap() {
     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_null() {
+    setUp();
+    makeDatum(null).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'));
@@ skipping 32 matching lines @@
   @runTest
   static void asInt() {
     setUp();
     expect(makeDatum(1).asInt(), equals(1));
     expect(makeDatum('2').asInt(), equals(2));
     expect(() => makeDatum('xxx').asInt(), _throwsInvalidParameter);
     expect(() => makeDatum(true).asInt(), _throwsInvalidParameter);
   }
 
   @runTest
+  static void isList() {
+    setUp();
+    expect(makeDatum(3).isList, isFalse);
+    expect(makeDatum(null).isList, isTrue);
+    expect(makeDatum([]).isList, isTrue);
+    expect(makeDatum(['foo', 'bar']).isList, isTrue);
+  }
+
+  @runTest
   static void asList_nonList() {
     setUp();
     expect(() => makeDatum(3).asList((datum) => null), _throwsInvalidParameter);
   }
 
   @runTest
+  static void asList_null() {
+    setUp();
+    expect(makeDatum(null).asList((datum) => datum.asString()), equals([]));
+  }
+
+  @runTest
   static void asList_emptyList() {
     setUp();
     expect(makeDatum([]).asList((datum) => datum.asString()), equals([]));
   }
 
   @runTest
   static void asList_nonEmptyList() {
     setUp();
     expect(makeDatum(['foo', 'bar']).asList((datum) => datum.asString()), equals(['foo', 'bar']));
   }
 
   @runTest
   static void asString() {
     setUp();
     expect(makeDatum('foo').asString(), equals('foo'));
     expect(() => makeDatum(3).asString(), _throwsInvalidParameter);
   }
 
   @runTest
+  static void isStringList() {
+    setUp();
+    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);
+  }
+
+  @runTest
   static void asStringList() {
     setUp();
     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);
   }
 
   @runTest
+  static void isMap() {
+    setUp();
+    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);
+  }
+
+  @runTest
+  static void isStringMap() {
+    setUp();
+    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);
+  }
+
+  @runTest
   static void asStringMap() {
     setUp();
     expect(makeDatum({
       'key1': 'value1',
       'key2': 'value2'
     }).asStringMap(), equals({
       'key1': 'value1',
       'key2': 'value2'
     }));
     expect(makeDatum({}).asStringMap(), equals({}));
     expect(() => makeDatum({
       'key1': 'value1',
       'key2': 2
     }).asStringMap(), _throwsInvalidParameter);
     expect(() => makeDatum({
       'key1': 1,
       'key2': 2
     }).asStringMap(), _throwsInvalidParameter);
     expect(() => makeDatum([]).asStringMap(), _throwsInvalidParameter);
   }
 
   @runTest
+  static void isStringListMap() {
+    setUp();
+    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);
+  }
+
+  @runTest
   static void asStringListMap() {
     setUp();
     {
       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);
     }
+    expect(makeDatum({}).asStringListMap(), equals({}));
+    expect(makeDatum(null).asStringListMap(), equals({}));
+    expect(() => makeDatum(3).asStringListMap(), _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 96 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>());