Index: test/functions_test.dart |
diff --git a/test/functions_test.dart b/test/functions_test.dart |
new file mode 100644 |
index 0000000000000000000000000000000000000000..4d928bf29de56c60a003753378c179ef964435ef |
--- /dev/null |
+++ b/test/functions_test.dart |
@@ -0,0 +1,184 @@ |
+// Copyright (c) 2016, 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. |
+ |
+import "package:test/test.dart"; |
+ |
+import "package:collection/collection.dart"; |
+ |
+void main() { |
+ group("mapMap()", () { |
+ test("with an empty map returns an empty map", () { |
+ expect( |
+ mapMap({}, |
+ key: expectAsync((_, __) {}, count: 0), |
+ value: expectAsync((_, __) {}, count: 0)), |
+ isEmpty); |
+ }); |
+ |
+ test("with no callbacks, returns a copy of the map", () { |
+ var map = {"foo": 1, "bar": 2}; |
+ var result = mapMap(map); |
+ expect(result, equals({"foo": 1, "bar": 2})); |
+ |
+ // The resulting map should be a copy. |
+ result["foo"] = 3; |
+ expect(map, equals({"foo": 1, "bar": 2})); |
+ }); |
+ |
+ test("maps the map's keys", () { |
+ expect(mapMap({"foo": 1, "bar": 2}, key: (key, value) => key[value]), |
+ equals({"o": 1, "r": 2})); |
+ }); |
+ |
+ test("maps the map's values", () { |
+ expect(mapMap({"foo": 1, "bar": 2}, value: (key, value) => key[value]), |
+ equals({"foo": "o", "bar": "r"})); |
+ }); |
+ |
+ test("maps both the map's keys and values", () { |
+ expect( |
+ mapMap({"foo": 1, "bar": 2}, |
+ key: (key, value) => "$key$value", |
+ value: (key, value) => key[value]), |
+ equals({"foo1": "o", "bar2": "r"})); |
+ }); |
+ }); |
+ |
+ group("mergeMaps()", () { |
+ test("with empty maps returns an empty map", () { |
+ expect(mergeMaps({}, {}, value: expectAsync((_, __) {}, count: 0)), |
+ isEmpty); |
+ }); |
+ |
+ test("returns a map with all values in both input maps", () { |
+ expect(mergeMaps({"foo": 1, "bar": 2}, {"baz": 3, "qux": 4}), |
+ equals({"foo": 1, "bar": 2, "baz": 3, "qux": 4})); |
+ }); |
+ |
+ test("the second map's values win by default", () { |
+ expect(mergeMaps({"foo": 1, "bar": 2}, {"bar": 3, "baz": 4}), |
+ equals({"foo": 1, "bar": 3, "baz": 4})); |
+ }); |
+ |
+ test("uses the callback to merge values", () { |
+ expect(mergeMaps({"foo": 1, "bar": 2}, {"bar": 3, "baz": 4}, |
+ value: (value1, value2) => value1 + value2), |
+ equals({"foo": 1, "bar": 5, "baz": 4})); |
+ }); |
+ }); |
+ |
+ group("groupBy()", () { |
+ test("returns an empty map for an empty iterable", () { |
+ expect(groupBy([], expectAsync((_) {}, count: 0)), isEmpty); |
+ }); |
+ |
+ test("groups elements by the function's return value", () { |
+ expect( |
+ groupBy(["foo", "bar", "baz", "bop", "qux"], (string) => string[1]), |
+ equals({"o": ["foo", "bop"], "a": ["bar", "baz"], "u": ["qux"]})); |
+ }); |
+ }); |
+ |
+ group("minBy()", () { |
+ test("returns null for an empty iterable", () { |
+ expect( |
+ minBy([], expectAsync((_) {}, count: 0), |
+ compare: expectAsync((_, __) {}, count: 0)), |
+ isNull); |
+ }); |
+ |
+ test("returns the element for which the ordering function returns the " |
+ "smallest value", () { |
+ expect( |
+ minBy( |
+ [{"foo": 3}, {"foo": 5}, {"foo": 4}, {"foo": 1}, {"foo": 2}], |
+ (map) => map["foo"]), |
+ equals({"foo": 1})); |
+ }); |
+ |
+ test("uses a custom comparator if provided", () { |
+ expect( |
+ minBy( |
+ [{"foo": 3}, {"foo": 5}, {"foo": 4}, {"foo": 1}, {"foo": 2}], |
+ (map) => map, |
+ compare: (map1, map2) => map1["foo"].compareTo(map2["foo"])), |
+ equals({"foo": 1})); |
+ }); |
+ }); |
+ |
+ group("maxBy()", () { |
+ test("returns null for an empty iterable", () { |
+ expect( |
+ maxBy([], expectAsync((_) {}, count: 0), |
+ compare: expectAsync((_, __) {}, count: 0)), |
+ isNull); |
+ }); |
+ |
+ test("returns the element for which the ordering function returns the " |
+ "largest value", () { |
+ expect( |
+ maxBy( |
+ [{"foo": 3}, {"foo": 5}, {"foo": 4}, {"foo": 1}, {"foo": 2}], |
+ (map) => map["foo"]), |
+ equals({"foo": 5})); |
+ }); |
+ |
+ test("uses a custom comparator if provided", () { |
+ expect( |
+ maxBy( |
+ [{"foo": 3}, {"foo": 5}, {"foo": 4}, {"foo": 1}, {"foo": 2}], |
+ (map) => map, |
+ compare: (map1, map2) => map1["foo"].compareTo(map2["foo"])), |
+ equals({"foo": 5})); |
+ }); |
+ }); |
+ |
+ group("transitiveClosure()", () { |
+ test("returns an empty map for an empty graph", () { |
+ expect(transitiveClosure({}), isEmpty); |
+ }); |
+ |
+ test("returns the input when there are no transitive connections", () { |
+ expect(transitiveClosure({ |
+ "foo": ["bar"], |
+ "bar": [], |
+ "bang": ["qux", "zap"], |
+ "qux": [], |
+ "zap": [] |
+ }), equals({ |
+ "foo": ["bar"], |
+ "bar": [], |
+ "bang": ["qux", "zap"], |
+ "qux": [], |
+ "zap": [] |
+ })); |
+ }); |
+ |
+ test("flattens transitive connections", () { |
+ expect(transitiveClosure({ |
+ "qux": [], |
+ "bar": ["baz"], |
+ "baz": ["qux"], |
+ "foo": ["bar"] |
+ }), equals({ |
+ "foo": ["bar", "baz", "qux"], |
+ "bar": ["baz", "qux"], |
+ "baz": ["qux"], |
+ "qux": [] |
+ })); |
+ }); |
+ |
+ test("handles loops", () { |
+ expect(transitiveClosure({ |
+ "foo": ["bar"], |
+ "bar": ["baz"], |
+ "baz": ["foo"] |
+ }), equals({ |
+ "foo": ["bar", "baz", "foo"], |
+ "bar": ["baz", "foo", "bar"], |
+ "baz": ["foo", "bar", "baz"] |
+ })); |
+ }); |
+ }); |
+} |