lrn@google.com
1ec6c5c1db
After discussion, we decided not to change the List interface for something that is just a convenience. Also revert "Mark pkgbuild/pkg/collection as failing when using repository packages" R=sgjesse@google.com Review URL: https://codereview.chromium.org//331833003 git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@37307 260f80e4-7a28-3924-810f-c04153c831b5
665 lines
20 KiB
Dart
665 lines
20 KiB
Dart
// Copyright (c) 2013, 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.
|
|
|
|
/// Tests wrapper utilities.
|
|
|
|
import "dart:collection";
|
|
import "package:collection/collection.dart";
|
|
import "package:unittest/unittest.dart";
|
|
|
|
// Test that any member access/call on the wrapper object is equal to
|
|
// an expected access on the wrapped object.
|
|
// This is implemented by capturing accesses using noSuchMethod and comparing
|
|
// them to expected accesses captured previously.
|
|
|
|
// Compare two Invocations for having equal type and arguments.
|
|
void testInvocations(Invocation i1, Invocation i2) {
|
|
String name = "${i1.memberName}";
|
|
expect(i1.isGetter, equals(i2.isGetter), reason: name);
|
|
expect(i1.isSetter, equals(i2.isSetter), reason: name);
|
|
expect(i1.memberName, equals(i2.memberName), reason: name);
|
|
expect(i1.positionalArguments, equals(i2.positionalArguments), reason: name);
|
|
expect(i1.namedArguments, equals(i2.namedArguments), reason: name);
|
|
}
|
|
|
|
/**
|
|
* Utility class to record a member access and a member access on a wrapped
|
|
* object, and compare them for equality.
|
|
*/
|
|
abstract class Expector {
|
|
getWrappedObject(action(Invocation i));
|
|
// Hack to test assignment ([]=) because it doesn't return the result
|
|
// of the member call. Instead use (expect..[4]=5).equal[4]=5 where
|
|
// you would normally use expect[4].equals[4] for non-assignments.
|
|
var equals;
|
|
|
|
noSuchMethod(Invocation m) => new _Equals(equals = getWrappedObject((m2) {
|
|
testInvocations(m, m2);
|
|
}));
|
|
|
|
toString() => new _Equals(equals = getWrappedObject((m2) {
|
|
testInvocations(TO_STRING_INVOCATION, m2);
|
|
}));
|
|
}
|
|
|
|
// An object with a field called "equals", only introduced into the
|
|
// flow to allow writing expect.xxx.equals.xxx.
|
|
class _Equals {
|
|
final equals;
|
|
_Equals(this.equals);
|
|
}
|
|
|
|
class SyntheticInvocation implements Invocation {
|
|
static const int METHOD = 0x00;
|
|
static const int GETTER = 0x01;
|
|
static const int SETTER = 0x02;
|
|
final Symbol memberName;
|
|
final List positionalArguments;
|
|
final Map namedArguments;
|
|
final int _type;
|
|
const SyntheticInvocation(this.memberName,
|
|
this.positionalArguments,
|
|
this.namedArguments,
|
|
this._type);
|
|
bool get isMethod => _type == METHOD;
|
|
|
|
bool get isGetter => _type == GETTER;
|
|
|
|
bool get isSetter => _type == SETTER;
|
|
|
|
bool get isAccessor => isGetter || isSetter;
|
|
}
|
|
|
|
// Parameterization of noSuchMethod.
|
|
class NSM {
|
|
Function _action;
|
|
NSM(this._action);
|
|
noSuchMethod(Invocation i) => _action(i);
|
|
}
|
|
|
|
const TO_STRING_INVOCATION = const SyntheticInvocation(
|
|
#toString, const[], const{}, SyntheticInvocation.METHOD);
|
|
|
|
// LikeNSM, but has types Iterable, Set and List to allow it as
|
|
// argument to DelegatingIterable/Set/List.
|
|
class IterableNSM extends NSM implements Iterable, Set, List, Queue {
|
|
IterableNSM(action(Invocation i)) : super(action);
|
|
noSuchMethod(Invocation i) => super.noSuchMethod(i); // Silence warnings
|
|
toString() => super.noSuchMethod(TO_STRING_INVOCATION);
|
|
}
|
|
|
|
// Expector that wraps in DelegatingIterable.
|
|
class IterableExpector extends Expector {
|
|
getWrappedObject(void action(Invocation i)) {
|
|
return new DelegatingIterable(new IterableNSM(action));
|
|
}
|
|
}
|
|
|
|
// Expector that wraps in DelegatingList.
|
|
class ListExpector extends Expector {
|
|
getWrappedObject(void action(Invocation i)) {
|
|
return new DelegatingList(new IterableNSM(action));
|
|
}
|
|
}
|
|
|
|
// Expector that wraps in DelegatingSet.
|
|
class SetExpector extends Expector {
|
|
getWrappedObject(void action(Invocation i)) {
|
|
return new DelegatingSet(new IterableNSM(action));
|
|
}
|
|
}
|
|
|
|
// Expector that wraps in DelegatingSet.
|
|
class QueueExpector extends Expector {
|
|
getWrappedObject(void action(Invocation i)) {
|
|
return new DelegatingQueue(new IterableNSM(action));
|
|
}
|
|
}
|
|
|
|
// Like NSM but implements Map to allow as argument for DelegatingMap.
|
|
class MapNSM extends NSM implements Map {
|
|
MapNSM(action(Invocation i)) : super(action);
|
|
noSuchMethod(Invocation i) => super.noSuchMethod(i);
|
|
toString() => super.noSuchMethod(TO_STRING_INVOCATION);
|
|
}
|
|
|
|
// Expector that wraps in DelegatingMap.
|
|
class MapExpector extends Expector {
|
|
getWrappedObject(void action(Invocation i)) {
|
|
return new DelegatingMap(new MapNSM(action));
|
|
}
|
|
}
|
|
|
|
// Utility values to use as arguments in calls.
|
|
func0() {}
|
|
func1(x) {}
|
|
func2(x, y) {}
|
|
var val = new Object();
|
|
|
|
void main() {
|
|
testIterable(var expect) {
|
|
expect.any(func1).equals.any(func1);
|
|
expect.contains(val).equals.contains(val);
|
|
expect.elementAt(0).equals.elementAt(0);
|
|
expect.every(func1).equals.every(func1);
|
|
expect.expand(func1).equals.expand(func1);
|
|
expect.first.equals.first;
|
|
// Default values of the Iterable interface will be added in the
|
|
// second call to firstWhere, so we must record them in our
|
|
// expectation (which doesn't have the interface implementat or
|
|
// its default values).
|
|
expect.firstWhere(func1, orElse: null).equals.firstWhere(func1);
|
|
expect.firstWhere(func1, orElse: func0).equals.
|
|
firstWhere(func1, orElse: func0);
|
|
expect.fold(null, func2).equals.fold(null, func2);
|
|
expect.forEach(func1).equals.forEach(func1);
|
|
expect.isEmpty.equals.isEmpty;
|
|
expect.isNotEmpty.equals.isNotEmpty;
|
|
expect.iterator.equals.iterator;
|
|
expect.join('').equals.join();
|
|
expect.join("X").equals.join("X");
|
|
expect.last.equals.last;
|
|
expect.lastWhere(func1, orElse: null).equals.lastWhere(func1);
|
|
expect.lastWhere(func1, orElse: func0).equals.
|
|
lastWhere(func1, orElse: func0);
|
|
expect.length.equals.length;
|
|
expect.map(func1).equals.map(func1);
|
|
expect.reduce(func2).equals.reduce(func2);
|
|
expect.single.equals.single;
|
|
expect.singleWhere(func1).equals.singleWhere(func1);
|
|
expect.skip(5).equals.skip(5);
|
|
expect.skipWhile(func1).equals.skipWhile(func1);
|
|
expect.take(5).equals.take(5);
|
|
expect.takeWhile(func1).equals.takeWhile(func1);
|
|
expect.toList(growable: true).equals.toList();
|
|
expect.toList(growable: true).equals.toList(growable: true);
|
|
expect.toList(growable: false).equals.toList(growable: false);
|
|
expect.toSet().equals.toSet();
|
|
expect.toString().equals.toString();
|
|
expect.where(func1).equals.where(func1);
|
|
}
|
|
|
|
void testList(var expect) {
|
|
testIterable(expect);
|
|
|
|
expect[4].equals[4];
|
|
(expect..[4] = 5).equals[4] = 5;
|
|
|
|
expect.add(val).equals.add(val);
|
|
expect.addAll([val]).equals.addAll([val]);
|
|
expect.asMap().equals.asMap();
|
|
expect.clear().equals.clear();
|
|
expect.fillRange(4, 5, null).equals.fillRange(4, 5);
|
|
expect.fillRange(4, 5, val).equals.fillRange(4, 5, val);
|
|
expect.getRange(4, 5).equals.getRange(4, 5);
|
|
expect.indexOf(val, 0).equals.indexOf(val);
|
|
expect.indexOf(val, 4).equals.indexOf(val, 4);
|
|
expect.insert(4, val).equals.insert(4, val);
|
|
expect.insertAll(4, [val]).equals.insertAll(4, [val]);
|
|
expect.lastIndexOf(val, null).equals.lastIndexOf(val);
|
|
expect.lastIndexOf(val, 4).equals.lastIndexOf(val, 4);
|
|
(expect..length = 4).equals.length = 4;
|
|
expect.remove(val).equals.remove(val);
|
|
expect.removeAt(4).equals.removeAt(4);
|
|
expect.removeLast().equals.removeLast();
|
|
expect.removeRange(4, 5).equals.removeRange(4, 5);
|
|
expect.removeWhere(func1).equals.removeWhere(func1);
|
|
expect.replaceRange(4, 5, [val]).equals.replaceRange(4, 5, [val]);
|
|
expect.retainWhere(func1).equals.retainWhere(func1);
|
|
expect.reversed.equals.reversed;
|
|
expect.setAll(4, [val]).equals.setAll(4, [val]);
|
|
expect.setRange(4, 5, [val], 0).equals.setRange(4, 5, [val]);
|
|
expect.setRange(4, 5, [val], 3).equals.setRange(4, 5, [val], 3);
|
|
expect.sort(null).equals.sort();
|
|
expect.sort(func2).equals.sort(func2);
|
|
expect.sublist(4, null).equals.sublist(4);
|
|
expect.sublist(4, 5).equals.sublist(4, 5);
|
|
}
|
|
|
|
void testSet(var expect) {
|
|
testIterable(expect);
|
|
Set set = new Set();
|
|
expect.add(val).equals.add(val);
|
|
expect.addAll([val]).equals.addAll([val]);
|
|
expect.clear().equals.clear();
|
|
expect.containsAll([val]).equals.containsAll([val]);
|
|
expect.difference(set).equals.difference(set);
|
|
expect.intersection(set).equals.intersection(set);
|
|
expect.remove(val).equals.remove(val);
|
|
expect.removeAll([val]).equals.removeAll([val]);
|
|
expect.removeWhere(func1).equals.removeWhere(func1);
|
|
expect.retainAll([val]).equals.retainAll([val]);
|
|
expect.retainWhere(func1).equals.retainWhere(func1);
|
|
expect.union(set).equals.union(set);
|
|
}
|
|
|
|
void testQueue(var expect) {
|
|
testIterable(expect);
|
|
expect.add(val).equals.add(val);
|
|
expect.addAll([val]).equals.addAll([val]);
|
|
expect.addFirst(val).equals.addFirst(val);
|
|
expect.addLast(val).equals.addLast(val);
|
|
expect.clear().equals.clear();
|
|
expect.remove(val).equals.remove(val);
|
|
expect.removeFirst().equals.removeFirst();
|
|
expect.removeLast().equals.removeLast();
|
|
}
|
|
|
|
void testMap(var expect) {
|
|
Map map = new Map();
|
|
expect[val].equals[val];
|
|
(expect..[val] = val).equals[val] = val;
|
|
expect.addAll(map).equals.addAll(map);
|
|
expect.clear().equals.clear();
|
|
expect.containsKey(val).equals.containsKey(val);
|
|
expect.containsValue(val).equals.containsValue(val);
|
|
expect.forEach(func2).equals.forEach(func2);
|
|
expect.isEmpty.equals.isEmpty;
|
|
expect.isNotEmpty.equals.isNotEmpty;
|
|
expect.keys.equals.keys;
|
|
expect.length.equals.length;
|
|
expect.putIfAbsent(val, func0).equals.putIfAbsent(val, func0);
|
|
expect.remove(val).equals.remove(val);
|
|
expect.values.equals.values;
|
|
expect.toString().equals.toString();
|
|
}
|
|
|
|
// Runs tests of Set behavior.
|
|
//
|
|
// [setUpSet] should return a set with two elements: "foo" and "bar".
|
|
void testTwoElementSet(Set<String> setUpSet()) {
|
|
group("with two elements", () {
|
|
var set;
|
|
setUp(() => set = setUpSet());
|
|
|
|
test(".any", () {
|
|
expect(set.any((element) => element == "foo"), isTrue);
|
|
expect(set.any((element) => element == "baz"), isFalse);
|
|
});
|
|
|
|
test(".elementAt", () {
|
|
expect(set.elementAt(0), equals("foo"));
|
|
expect(set.elementAt(1), equals("bar"));
|
|
expect(() => set.elementAt(2), throwsRangeError);
|
|
});
|
|
|
|
test(".every", () {
|
|
expect(set.every((element) => element == "foo"), isFalse);
|
|
expect(set.every((element) => element is String), isTrue);
|
|
});
|
|
|
|
test(".expand", () {
|
|
expect(set.expand((element) {
|
|
return [element.substring(0, 1), element.substring(1)];
|
|
}), equals(["f", "oo", "b", "ar"]));
|
|
});
|
|
|
|
test(".first", () {
|
|
expect(set.first, equals("foo"));
|
|
});
|
|
|
|
test(".firstWhere", () {
|
|
expect(set.firstWhere((element) => element is String), equals("foo"));
|
|
expect(set.firstWhere((element) => element.startsWith("b")),
|
|
equals("bar"));
|
|
expect(() => set.firstWhere((element) => element is int),
|
|
throwsStateError);
|
|
expect(set.firstWhere((element) => element is int, orElse: () => "baz"),
|
|
equals("baz"));
|
|
});
|
|
|
|
test(".fold", () {
|
|
expect(set.fold("start", (previous, element) => previous + element),
|
|
equals("startfoobar"));
|
|
});
|
|
|
|
test(".forEach", () {
|
|
var values = [];
|
|
set.forEach(values.add);
|
|
expect(values, equals(["foo", "bar"]));
|
|
});
|
|
|
|
test(".iterator", () {
|
|
var values = [];
|
|
for (var element in set) {
|
|
values.add(element);
|
|
}
|
|
expect(values, equals(["foo", "bar"]));
|
|
});
|
|
|
|
test(".join", () {
|
|
expect(set.join(", "), equals("foo, bar"));
|
|
});
|
|
|
|
test(".last", () {
|
|
expect(set.last, equals("bar"));
|
|
});
|
|
|
|
test(".lastWhere", () {
|
|
expect(set.lastWhere((element) => element is String), equals("bar"));
|
|
expect(set.lastWhere((element) => element.startsWith("f")),
|
|
equals("foo"));
|
|
expect(() => set.lastWhere((element) => element is int),
|
|
throwsStateError);
|
|
expect(set.lastWhere((element) => element is int, orElse: () => "baz"),
|
|
equals("baz"));
|
|
});
|
|
|
|
test(".map", () {
|
|
expect(set.map((element) => element.substring(1)),
|
|
equals(["oo", "ar"]));
|
|
});
|
|
|
|
test(".reduce", () {
|
|
expect(set.reduce((previous, element) => previous + element),
|
|
equals("foobar"));
|
|
});
|
|
|
|
test(".singleWhere", () {
|
|
expect(() => set.singleWhere((element) => element == "baz"),
|
|
throwsStateError);
|
|
expect(set.singleWhere((element) => element == "foo"),
|
|
"foo");
|
|
expect(() => set.singleWhere((element) => element is String),
|
|
throwsStateError);
|
|
});
|
|
|
|
test(".skip", () {
|
|
expect(set.skip(0), equals(["foo", "bar"]));
|
|
expect(set.skip(1), equals(["bar"]));
|
|
expect(set.skip(2), equals([]));
|
|
});
|
|
|
|
test(".skipWhile", () {
|
|
expect(set.skipWhile((element) => element.startsWith("f")),
|
|
equals(["bar"]));
|
|
expect(set.skipWhile((element) => element.startsWith("z")),
|
|
equals(["foo", "bar"]));
|
|
expect(set.skipWhile((element) => element is String),
|
|
equals([]));
|
|
});
|
|
|
|
test(".take", () {
|
|
expect(set.take(0), equals([]));
|
|
expect(set.take(1), equals(["foo"]));
|
|
expect(set.take(2), equals(["foo", "bar"]));
|
|
});
|
|
|
|
test(".takeWhile", () {
|
|
expect(set.takeWhile((element) => element.startsWith("f")),
|
|
equals(["foo"]));
|
|
expect(set.takeWhile((element) => element.startsWith("z")),
|
|
equals([]));
|
|
expect(set.takeWhile((element) => element is String),
|
|
equals(["foo", "bar"]));
|
|
});
|
|
|
|
test(".toList", () {
|
|
expect(set.toList(), equals(["foo", "bar"]));
|
|
expect(() => set.toList(growable: false).add("baz"),
|
|
throwsUnsupportedError);
|
|
expect(set.toList()..add("baz"), equals(["foo", "bar", "baz"]));
|
|
});
|
|
|
|
test(".toSet", () {
|
|
expect(set.toSet(), equals(new Set.from(["foo", "bar"])));
|
|
});
|
|
|
|
test(".where", () {
|
|
expect(set.where((element) => element.startsWith("f")),
|
|
equals(["foo"]));
|
|
expect(set.where((element) => element.startsWith("z")), equals([]));
|
|
expect(set.where((element) => element is String),
|
|
equals(["foo", "bar"]));
|
|
});
|
|
|
|
test(".containsAll", () {
|
|
expect(set.containsAll(["foo", "bar"]), isTrue);
|
|
expect(set.containsAll(["foo"]), isTrue);
|
|
expect(set.containsAll(["foo", "bar", "qux"]), isFalse);
|
|
});
|
|
|
|
test(".difference", () {
|
|
expect(set.difference(new Set.from(["foo", "baz"])),
|
|
equals(new Set.from(["bar"])));
|
|
});
|
|
|
|
test(".intersection", () {
|
|
expect(set.intersection(new Set.from(["foo", "baz"])),
|
|
equals(new Set.from(["foo"])));
|
|
});
|
|
|
|
test(".union", () {
|
|
expect(set.union(new Set.from(["foo", "baz"])),
|
|
equals(new Set.from(["foo", "bar", "baz"])));
|
|
});
|
|
});
|
|
}
|
|
|
|
test("Iterable", () {
|
|
testIterable(new IterableExpector());
|
|
});
|
|
|
|
test("List", () {
|
|
testList(new ListExpector());
|
|
});
|
|
|
|
test("Set", () {
|
|
testSet(new SetExpector());
|
|
});
|
|
|
|
test("Queue", () {
|
|
testQueue(new QueueExpector());
|
|
});
|
|
|
|
test("Map", () {
|
|
testMap(new MapExpector());
|
|
});
|
|
|
|
group("MapKeySet", () {
|
|
var map;
|
|
var set;
|
|
|
|
setUp(() {
|
|
map = new Map<String, int>();
|
|
set = new MapKeySet<String>(map);
|
|
});
|
|
|
|
testTwoElementSet(() {
|
|
map["foo"] = 1;
|
|
map["bar"] = 2;
|
|
return set;
|
|
});
|
|
|
|
test(".single", () {
|
|
expect(() => set.single, throwsStateError);
|
|
map["foo"] = 1;
|
|
expect(set.single, equals("foo"));
|
|
map["bar"] = 1;
|
|
expect(() => set.single, throwsStateError);
|
|
});
|
|
|
|
test(".toString", () {
|
|
expect(set.toString(), equals("{}"));
|
|
map["foo"] = 1;
|
|
map["bar"] = 2;
|
|
expect(set.toString(), equals("{foo, bar}"));
|
|
});
|
|
|
|
test(".contains", () {
|
|
expect(set.contains("foo"), isFalse);
|
|
map["foo"] = 1;
|
|
expect(set.contains("foo"), isTrue);
|
|
});
|
|
|
|
test(".isEmpty", () {
|
|
expect(set.isEmpty, isTrue);
|
|
map["foo"] = 1;
|
|
expect(set.isEmpty, isFalse);
|
|
});
|
|
|
|
test(".isNotEmpty", () {
|
|
expect(set.isNotEmpty, isFalse);
|
|
map["foo"] = 1;
|
|
expect(set.isNotEmpty, isTrue);
|
|
});
|
|
|
|
test(".length", () {
|
|
expect(set, hasLength(0));
|
|
map["foo"] = 1;
|
|
expect(set, hasLength(1));
|
|
map["bar"] = 2;
|
|
expect(set, hasLength(2));
|
|
});
|
|
|
|
test("is unmodifiable", () {
|
|
expect(() => set.add("baz"), throwsUnsupportedError);
|
|
expect(() => set.addAll(["baz", "bang"]), throwsUnsupportedError);
|
|
expect(() => set.remove("foo"), throwsUnsupportedError);
|
|
expect(() => set.removeAll(["baz", "bang"]), throwsUnsupportedError);
|
|
expect(() => set.retainAll(["foo"]), throwsUnsupportedError);
|
|
expect(() => set.removeWhere((_) => true), throwsUnsupportedError);
|
|
expect(() => set.retainWhere((_) => true), throwsUnsupportedError);
|
|
expect(() => set.clear(), throwsUnsupportedError);
|
|
});
|
|
});
|
|
|
|
group("MapValueSet", () {
|
|
var map;
|
|
var set;
|
|
|
|
setUp(() {
|
|
map = new Map<String, String>();
|
|
set = new MapValueSet<String, String>(map,
|
|
(string) => string.substring(0, 1));
|
|
});
|
|
|
|
testTwoElementSet(() {
|
|
map["f"] = "foo";
|
|
map["b"] = "bar";
|
|
return set;
|
|
});
|
|
|
|
test(".single", () {
|
|
expect(() => set.single, throwsStateError);
|
|
map["f"] = "foo";
|
|
expect(set.single, equals("foo"));
|
|
map["b"] = "bar";
|
|
expect(() => set.single, throwsStateError);
|
|
});
|
|
|
|
test(".toString", () {
|
|
expect(set.toString(), equals("{}"));
|
|
map["f"] = "foo";
|
|
map["b"] = "bar";
|
|
expect(set.toString(), equals("{foo, bar}"));
|
|
});
|
|
|
|
test(".contains", () {
|
|
expect(set.contains("foo"), isFalse);
|
|
map["f"] = "foo";
|
|
expect(set.contains("foo"), isTrue);
|
|
expect(set.contains("fblthp"), isTrue);
|
|
});
|
|
|
|
test(".isEmpty", () {
|
|
expect(set.isEmpty, isTrue);
|
|
map["f"] = "foo";
|
|
expect(set.isEmpty, isFalse);
|
|
});
|
|
|
|
test(".isNotEmpty", () {
|
|
expect(set.isNotEmpty, isFalse);
|
|
map["f"] = "foo";
|
|
expect(set.isNotEmpty, isTrue);
|
|
});
|
|
|
|
test(".length", () {
|
|
expect(set, hasLength(0));
|
|
map["f"] = "foo";
|
|
expect(set, hasLength(1));
|
|
map["b"] = "bar";
|
|
expect(set, hasLength(2));
|
|
});
|
|
|
|
test(".lookup", () {
|
|
map["f"] = "foo";
|
|
expect(set.lookup("fblthp"), equals("foo"));
|
|
expect(set.lookup("bar"), isNull);
|
|
});
|
|
|
|
test(".add", () {
|
|
set.add("foo");
|
|
set.add("bar");
|
|
expect(map, equals({"f": "foo", "b": "bar"}));
|
|
});
|
|
|
|
test(".addAll", () {
|
|
set.addAll(["foo", "bar"]);
|
|
expect(map, equals({"f": "foo", "b": "bar"}));
|
|
});
|
|
|
|
test(".clear", () {
|
|
map["f"] = "foo";
|
|
map["b"] = "bar";
|
|
set.clear();
|
|
expect(map, isEmpty);
|
|
});
|
|
|
|
test(".remove", () {
|
|
map["f"] = "foo";
|
|
map["b"] = "bar";
|
|
set.remove("fblthp");
|
|
expect(map, equals({"b": "bar"}));
|
|
});
|
|
|
|
test(".removeAll", () {
|
|
map["f"] = "foo";
|
|
map["b"] = "bar";
|
|
map["q"] = "qux";
|
|
set.removeAll(["fblthp", "qux"]);
|
|
expect(map, equals({"b": "bar"}));
|
|
});
|
|
|
|
test(".removeWhere", () {
|
|
map["f"] = "foo";
|
|
map["b"] = "bar";
|
|
map["q"] = "qoo";
|
|
set.removeWhere((element) => element.endsWith("o"));
|
|
expect(map, equals({"b": "bar"}));
|
|
});
|
|
|
|
test(".retainAll", () {
|
|
map["f"] = "foo";
|
|
map["b"] = "bar";
|
|
map["q"] = "qux";
|
|
set.retainAll(["fblthp", "qux"]);
|
|
expect(map, equals({"f": "foo", "q": "qux"}));
|
|
});
|
|
|
|
test(".retainAll respects an unusual notion of equality", () {
|
|
map = new HashMap<String, String>(
|
|
equals: (value1, value2) =>
|
|
value1.toLowerCase() == value2.toLowerCase(),
|
|
hashCode: (value) => value.toLowerCase().hashCode);
|
|
set = new MapValueSet<String, String>(map,
|
|
(string) => string.substring(0, 1));
|
|
|
|
map["f"] = "foo";
|
|
map["B"] = "bar";
|
|
map["Q"] = "qux";
|
|
set.retainAll(["fblthp", "qux"]);
|
|
expect(map, equals({"f": "foo", "Q": "qux"}));
|
|
});
|
|
|
|
test(".retainWhere", () {
|
|
map["f"] = "foo";
|
|
map["b"] = "bar";
|
|
map["q"] = "qoo";
|
|
set.retainWhere((element) => element.endsWith("o"));
|
|
expect(map, equals({"f": "foo", "q": "qoo"}));
|
|
});
|
|
});
|
|
}
|