blob: d5d417fe3ce0861d6d617598ade3c827552986cc [file] [log] [blame] [edit]
// Copyright (c) 2011, 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 json_map_test;
import "package:expect/expect.dart";
import 'dart:convert' show json;
import 'dart:collection' show LinkedHashMap, HashMap;
bool useReviver = false;
Map<String, dynamic> jsonify(Map map) {
String encoded = json.encode(map);
return useReviver
? json.decode(encoded, reviver: (key, value) => value)
: json.decode(encoded);
}
List listEach(Map map) {
var result = [];
map.forEach((key, value) {
result.add(key);
result.add(value);
});
return result;
}
void main() {
test(false);
test(true);
}
void test(bool revive) {
useReviver = revive;
testEmpty(jsonify({}));
testAtoB(jsonify({'a': 'b'}));
// You can write 'Map<String, dynamic>' here (or 'var' which infers the
// same), but if you write just 'Map' as the type, then the type of the
// constant argument in the addAll below is not inferred correctly.
var map = jsonify({});
map['a'] = 'b';
testAtoB(map);
map = jsonify({});
Expect.equals('b', map.putIfAbsent('a', () => 'b'));
testAtoB(map);
map = jsonify({});
map.addAll({'a': 'b'});
testAtoB(map);
testOrder(['a', 'b', 'c', 'd', 'e', 'f']);
testProto();
testToString();
testConcurrentModifications();
testType();
testClear();
testListEntry();
testMutation();
}
void testEmpty(Map map) {
for (int i = 0; i < 2; i++) {
Expect.equals(0, map.length);
Expect.isTrue(map.isEmpty);
Expect.isFalse(map.isNotEmpty);
Expect.listEquals([], map.keys.toList());
Expect.listEquals([], map.values.toList());
Expect.isNull(map['a']);
Expect.listEquals([], listEach(map));
Expect.isFalse(map.containsKey('a'));
Expect.isFalse(map.containsValue('a'));
Expect.isNull(map.remove('a'));
testLookupNonExistingKeys(map);
testLookupNonExistingValues(map);
map.clear();
}
}
void testAtoB(Map map) {
Expect.equals(1, map.length);
Expect.isFalse(map.isEmpty);
Expect.isTrue(map.isNotEmpty);
Expect.listEquals(['a'], map.keys.toList());
Expect.listEquals(['b'], map.values.toList());
Expect.equals('b', map['a']);
Expect.listEquals(['a', 'b'], listEach(map));
Expect.isTrue(map.containsKey('a'));
Expect.isFalse(map.containsKey('b'));
Expect.isTrue(map.containsValue('b'));
Expect.isFalse(map.containsValue('a'));
testLookupNonExistingKeys(map);
testLookupNonExistingValues(map);
Expect.equals('b', map.remove('a'));
Expect.isNull(map.remove('b'));
testLookupNonExistingKeys(map);
testLookupNonExistingValues(map);
map.clear();
testEmpty(map);
}
void testLookupNonExistingKeys(Map map) {
for (String key in ['__proto__', 'null', null]) {
Expect.isNull(map[key]);
Expect.isFalse(map.containsKey(key));
}
}
void testLookupNonExistingValues(Map map) {
for (var value in ['__proto__', 'null', null]) {
Expect.isFalse(map.containsValue(value));
}
}
void testOrder(List list) {
if (list.isEmpty)
return;
else
testOrder(list.skip(1).toList());
Map original = {};
for (int i = 0; i < list.length; i++) {
original[list[i]] = i;
}
Map map = jsonify(original);
Expect.equals(list.length, map.length);
Expect.listEquals(list, map.keys.toList());
for (int i = 0; i < 10; i++) {
map["$i"] = i;
Expect.equals(list.length + i + 1, map.length);
Expect.listEquals(list, map.keys.take(list.length).toList());
}
}
void testProto() {
Map map = jsonify({'__proto__': 0});
Expect.equals(1, map.length);
Expect.isTrue(map.containsKey('__proto__'));
Expect.listEquals(['__proto__'], map.keys.toList());
Expect.equals(0, map['__proto__']);
Expect.equals(0, map.remove('__proto__'));
testEmpty(map);
map = jsonify({'__proto__': null});
Expect.equals(1, map.length);
Expect.isTrue(map.containsKey('__proto__'));
Expect.listEquals(['__proto__'], map.keys.toList());
Expect.isNull(map['__proto__']);
Expect.isNull(map.remove('__proto__'));
testEmpty(map);
}
void testToString() {
Expect.equals("{}", jsonify({}).toString());
Expect.equals("{a: 0}", jsonify({'a': 0}).toString());
}
void testConcurrentModifications() {
void testIterate(Map map, Iterable iterable, Function f) {
Iterator iterator = iterable.iterator;
f(map);
iterator.moveNext();
}
void testKeys(Map map, Function f) => testIterate(map, map.keys, f);
void testValues(Map map, Function f) => testIterate(map, map.values, f);
void testForEach(Map map, Function f) {
map.forEach((key, value) {
f(map);
});
}
bool throwsCME(Function f) {
try {
f();
} on ConcurrentModificationError catch (e) {
return true;
} catch (e) {
return false;
}
return false;
}
Map map = {};
Expect.isTrue(throwsCME(() => testKeys(jsonify(map), (map) => map['a'] = 0)));
Expect
.isTrue(throwsCME(() => testValues(jsonify(map), (map) => map['a'] = 0)));
Expect.isFalse(
throwsCME(() => testForEach(jsonify(map), (map) => map['a'] = 0)));
Expect.isFalse(throwsCME(() => testKeys(jsonify(map), (map) => map.clear())));
Expect
.isFalse(throwsCME(() => testValues(jsonify(map), (map) => map.clear())));
Expect.isFalse(
throwsCME(() => testForEach(jsonify(map), (map) => map.clear())));
Expect.isFalse(
throwsCME(() => testKeys(jsonify(map), (map) => map.remove('a'))));
Expect.isFalse(
throwsCME(() => testValues(jsonify(map), (map) => map.remove('a'))));
Expect.isFalse(
throwsCME(() => testForEach(jsonify(map), (map) => map.remove('a'))));
Expect.isTrue(throwsCME(
() => testKeys(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
Expect.isTrue(throwsCME(
() => testValues(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
Expect.isFalse(throwsCME(
() => testForEach(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
Expect.isFalse(
throwsCME(() => testKeys(jsonify(map), (map) => map.addAll({}))));
Expect.isFalse(
throwsCME(() => testValues(jsonify(map), (map) => map.addAll({}))));
Expect.isFalse(
throwsCME(() => testForEach(jsonify(map), (map) => map.addAll({}))));
Expect.isTrue(
throwsCME(() => testKeys(jsonify(map), (map) => map.addAll({'a': 0}))));
Expect.isTrue(
throwsCME(() => testValues(jsonify(map), (map) => map.addAll({'a': 0}))));
Expect.isFalse(throwsCME(
() => testForEach(jsonify(map), (map) => map.addAll({'a': 0}))));
map = {'a': 1};
Expect
.isFalse(throwsCME(() => testKeys(jsonify(map), (map) => map['a'] = 0)));
Expect.isFalse(
throwsCME(() => testValues(jsonify(map), (map) => map['a'] = 0)));
Expect.isFalse(
throwsCME(() => testForEach(jsonify(map), (map) => map['a'] = 0)));
Expect.isTrue(throwsCME(() => testKeys(jsonify(map), (map) => map['b'] = 0)));
Expect
.isTrue(throwsCME(() => testValues(jsonify(map), (map) => map['b'] = 0)));
Expect.isTrue(
throwsCME(() => testForEach(jsonify(map), (map) => map['b'] = 0)));
Expect.isTrue(throwsCME(() => testKeys(jsonify(map), (map) => map.clear())));
Expect
.isTrue(throwsCME(() => testValues(jsonify(map), (map) => map.clear())));
Expect
.isTrue(throwsCME(() => testForEach(jsonify(map), (map) => map.clear())));
Expect.isTrue(
throwsCME(() => testKeys(jsonify(map), (map) => map.remove('a'))));
Expect.isTrue(
throwsCME(() => testValues(jsonify(map), (map) => map.remove('a'))));
Expect.isTrue(
throwsCME(() => testForEach(jsonify(map), (map) => map.remove('a'))));
Expect.isFalse(
throwsCME(() => testKeys(jsonify(map), (map) => map.remove('b'))));
Expect.isFalse(
throwsCME(() => testValues(jsonify(map), (map) => map.remove('b'))));
Expect.isFalse(
throwsCME(() => testForEach(jsonify(map), (map) => map.remove('b'))));
Expect.isFalse(throwsCME(
() => testKeys(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
Expect.isFalse(throwsCME(
() => testValues(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
Expect.isFalse(throwsCME(
() => testForEach(jsonify(map), (map) => map.putIfAbsent('a', () => 0))));
Expect.isTrue(throwsCME(
() => testKeys(jsonify(map), (map) => map.putIfAbsent('b', () => 0))));
Expect.isTrue(throwsCME(
() => testValues(jsonify(map), (map) => map.putIfAbsent('b', () => 0))));
Expect.isTrue(throwsCME(
() => testForEach(jsonify(map), (map) => map.putIfAbsent('b', () => 0))));
Expect.isFalse(
throwsCME(() => testKeys(jsonify(map), (map) => map.addAll({}))));
Expect.isFalse(
throwsCME(() => testValues(jsonify(map), (map) => map.addAll({}))));
Expect.isFalse(
throwsCME(() => testForEach(jsonify(map), (map) => map.addAll({}))));
Expect.isFalse(
throwsCME(() => testKeys(jsonify(map), (map) => map.addAll({'a': 0}))));
Expect.isFalse(
throwsCME(() => testValues(jsonify(map), (map) => map.addAll({'a': 0}))));
Expect.isFalse(throwsCME(
() => testForEach(jsonify(map), (map) => map.addAll({'a': 0}))));
Expect.isTrue(
throwsCME(() => testKeys(jsonify(map), (map) => map.addAll({'b': 0}))));
Expect.isTrue(
throwsCME(() => testValues(jsonify(map), (map) => map.addAll({'b': 0}))));
Expect.isTrue(throwsCME(
() => testForEach(jsonify(map), (map) => map.addAll({'b': 0}))));
}
void testType() {
var map = jsonify({});
var type = "${map.runtimeType}";
// The documentation of json.decode doesn't actually specify that it returns
// a map (it's marked dynamic), but it's a reasonable expectation if you
// don't provide a reviver function.
Expect.isTrue(map is Map, type);
Expect.isTrue(map is Map<String, dynamic>, type);
Expect.isFalse(map is Map<int, dynamic>, type);
}
void testClear() {
Map map = jsonify({'a': 0});
map.clear();
Expect.equals(0, map.length);
}
void testListEntry() {
Map map = jsonify({
'a': [
7,
8,
{'b': 9}
]
});
List list = map['a'];
Expect.equals(3, list.length);
Expect.equals(7, list[0]);
Expect.equals(8, list[1]);
Expect.equals(9, list[2]['b']);
}
void testMutation() {
Map map = jsonify({'a': 0});
Expect.listEquals(['a', 0], listEach(map));
map['a'] = 1;
Expect.listEquals(['a', 1], listEach(map));
map['a']++;
Expect.listEquals(['a', 2], listEach(map));
}