tests/corelib_2/set_unmodifiable_view_test.dart

// Copyright (c) 2020, 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.

// @dart = 2.9

import "package:expect/expect.dart";
import "dart:collection";

main() {
  testIterableApi();
  testUnmodifiableSetApi();
  testMutatingApisThrow();
  testChangesInOriginalSetAreObservedInUnmodifiableView();
}

void testIterableApi() {
  Set<int> original = {1, 2, 3};
  Set<int> copy = {...original};
  UnmodifiableSetView<int> wrapped = new UnmodifiableSetView(original);

  Expect.equals(wrapped.any((_) => true), original.any((_) => true));
  Expect.equals(wrapped.any((_) => false), original.any((_) => false));

  Expect.equals(wrapped.contains(0), original.contains(0));
  Expect.equals(wrapped.elementAt(0), original.elementAt(0));

  Expect.equals(wrapped.every((_) => true), original.every((_) => true));
  Expect.equals(wrapped.every((_) => false), original.every((_) => false));

  Expect.setEquals(
      wrapped.expand((x) => [x, x]), original.expand((x) => [x, x]));

  Expect.equals(wrapped.first, original.first);

  Expect.equals(
      wrapped.firstWhere((_) => true), original.firstWhere((_) => true));
  Expect.throwsStateError(() {
    wrapped.firstWhere((_) => false);
  }, "firstWhere");

  Expect.equals(wrapped.fold<int>(0, (x, y) => x + y),
      original.fold<int>(0, (x, y) => x + y));

  testForeach(wrapped, original);

  Expect.equals(wrapped.isEmpty, original.isEmpty);

  Expect.equals(wrapped.isNotEmpty, original.isNotEmpty);

  testIterator(wrapped, original);

  Expect.equals(wrapped.join(""), original.join(""));
  Expect.equals(wrapped.join("-"), original.join("-"));

  Expect.equals(wrapped.last, original.last);

  Expect.equals(
      wrapped.lastWhere((_) => true), original.lastWhere((_) => true));
  Expect.throwsStateError(() {
    wrapped.lastWhere((_) => false);
  }, "lastWhere");

  Expect.equals(wrapped.length, original.length);

  Expect.setEquals(wrapped.map((x) => "[$x]"), original.map((x) => "[$x]"));

  Expect.equals(
      wrapped.reduce((x, y) => x + y), original.reduce((x, y) => x + y));

  Expect.throwsStateError(() {
    wrapped.single;
  }, "single");

  Expect.throwsStateError(() {
    wrapped.singleWhere((_) => true);
  }, "singleWhere true");
  Expect.throwsStateError(() {
    wrapped.singleWhere((_) => false);
  }, "singleWhere false");

  Expect.setEquals(wrapped.skip(0), original.skip(0));
  Expect.setEquals(wrapped.skip(1), original.skip(1));

  Expect.setEquals(
      wrapped.skipWhile((_) => true), original.skipWhile((_) => true));
  Expect.setEquals(
      wrapped.skipWhile((_) => false), original.skipWhile((_) => false));

  Expect.setEquals(wrapped.take(0), original.take(0));
  Expect.setEquals(wrapped.take(1), original.take(1));

  Expect.setEquals(
      wrapped.takeWhile((_) => true), original.takeWhile((_) => true));
  Expect.setEquals(
      wrapped.takeWhile((_) => false), original.takeWhile((_) => false));

  var toListResult = wrapped.toList();
  Expect.listEquals(original.toList(), toListResult);
  toListResult.add(4);
  Expect.listEquals([1, 2, 3, 4], toListResult);
  toListResult[3] = 5;
  Expect.listEquals([1, 2, 3, 5], toListResult);
  // wrapped and original are intact
  Expect.setEquals(copy, wrapped);
  Expect.setEquals(copy, original);

  var toSetResult = wrapped.toSet();
  Expect.setEquals(original.toSet(), toSetResult);
  toSetResult.add(4);
  Expect.setEquals({1, 2, 3, 4}, toSetResult);
  // wrapped and original are intact
  Expect.setEquals(copy, wrapped);
  Expect.setEquals(copy, original);

  Expect.setEquals(wrapped.where((_) => true), original.where((_) => true));
  Expect.setEquals(wrapped.where((_) => false), original.where((_) => false));
}

void testUnmodifiableSetApi() {
  Set<int> original = {1, 2, 3};
  Set<int> copy = {...original};
  UnmodifiableSetView<int> wrapped = new UnmodifiableSetView(original);

  Expect.isTrue(wrapped.containsAll(copy));
  Expect.isTrue(wrapped.containsAll(copy.toList()));
  Expect.isTrue(wrapped.containsAll([]));

  Expect.isTrue(wrapped.intersection({}).isEmpty);
  Expect.setEquals(wrapped.intersection(copy), original);

  Expect.setEquals(wrapped.union({}), original);
  Expect.setEquals(wrapped.union(copy), original);

  Expect.setEquals(wrapped.difference({}), original);
  Expect.isTrue(wrapped.difference(copy).isEmpty);
}

void testMutatingApisThrow() {
  UnmodifiableSetView<int> s = new UnmodifiableSetView({1, 2, 3});

  Expect.throwsUnsupportedError(() {
    s.add(3);
  }, "add");

  Expect.throwsUnsupportedError(() {
    s.addAll({1, 2, 3});
  }, "addAll");

  Expect.throwsUnsupportedError(() {
    s.addAll(<int>{});
  }, "addAll empty");

  Expect.throwsUnsupportedError(() {
    s.remove(3);
  }, "remove");

  Expect.throwsUnsupportedError(() {
    s.removeAll({1, 2, 3});
  }, "removeAll");

  Expect.throwsUnsupportedError(() {
    s.removeAll(<int>{});
  }, "removeAll empty");

  Expect.throwsUnsupportedError(() {
    s.retainAll({1, 2, 3});
  }, "retainAll");

  Expect.throwsUnsupportedError(() {
    s.retainAll(<int>{});
  }, "retainAll empty");

  Expect.throwsUnsupportedError(() {
    s.removeWhere((_) => true);
  }, "removeWhere");

  Expect.throwsUnsupportedError(() {
    s.retainWhere((_) => false);
  }, "retainWhere");

  Expect.throwsUnsupportedError(() {
    s.clear();
  }, "clear");
}

void testChangesInOriginalSetAreObservedInUnmodifiableView() {
  Set<int> original = {1, 2, 3};
  Set<int> copy = {...original};
  UnmodifiableSetView<int> wrapped = new UnmodifiableSetView(original);

  original.add(4);
  Expect.setEquals(original, wrapped);
  Expect.setEquals({4}, wrapped.difference(copy));
}

void testForeach(Set<int> wrapped, Set<int> original) {
  var wrapCtr = 0;
  var origCtr = 0;

  wrapped.forEach((x) {
    wrapCtr += x;
  });

  original.forEach((x) {
    origCtr += x;
  });

  Expect.equals(wrapCtr, origCtr);
}

void testIterator(Set<int> wrapped, Set<int> original) {
  Iterator wrapIter = wrapped.iterator;
  Iterator origIter = original.iterator;

  while (origIter.moveNext()) {
    Expect.isTrue(wrapIter.moveNext());
    Expect.equals(wrapIter.current, origIter.current);
  }

  Expect.isFalse(wrapIter.moveNext());
}