Utils/expect_common.dart - co19 - Git at Google

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

 part of 'expect.dart';

 class Expect {
   /// Checks whether the expected and actual values are equal using `==`.
   static void equals(var expected, var actual, [String reason = '']) {
     if ((expected != actual) &&
         !((expected is double) &&
             (actual is double) &&
             (expected.isNaN) &&
             (actual.isNaN))) {
       _fail('Expect.equals(expected: <$expected>, actual: <$actual>$reason) '
           'fails.');
     }
   }

   /// Checks whether the actual value is [bool] and its value is [true].
   static void isTrue(var actual, [String reason = '']) {
     if (!_identical(actual, true)) {
       _fail('Expect.isTrue($actual$reason) fails.');
     }
   }

   /// Checks whether the actual value is [bool] and its value is [false].
   static void isFalse(var actual, [String reason = '']) {
     if (!_identical(actual, false)) {
       _fail('Expect.isFalse($actual$reason) fails.');
     }
   }

   /// Checks whether [actual] is [null].
   static void isNull(actual, [String reason = '']) {
     if (null != actual) {
       _fail('Expect.isNull(actual: <$actual>$reason) fails.');
     }
   }

   /// Checks whether [actual] is not [null].
   static void isNotNull(actual, [String reason = '']) {
     if (null == actual) {
       _fail('Expect.isNotNull(actual: <$actual>$reason) fails.');
     }
   }

   /// Checks whether the expected and actual values are identical (using
   /// `identical`).
   static void identical(var expected, var actual, [String reason = '']) {
     if (!_identical(expected, actual)) {
       _fail('Expect.identical(expected: <$expected>, '
           'actual: <$actual>$reason) fails.');
     }
   }

   /// Unconditional failure.
   static void fail(String reason) {
     _fail('Expect.fail($reason)');
   }

   /// Checks whether the difference between expected and actual is greater than
   /// the given tolerance. If no tolerance is given, tolerance is assumed to be
   /// a value of the 4 significant digits smaller than the value given for
   /// [expected].
   static void approxEquals(num expected, num actual,
       [num? tolerance, String reason = '']) {
     tolerance ??= (expected / 1e4).abs();

     // Note: use !( <= ) rather than > so we fail on NaNs
     if (!((expected - actual).abs() <= tolerance)) {
       _fail('Expect.approxEquals(expected:<$expected>, actual:<$actual>, '
           'tolerance:<$tolerance>$reason) fails');
     }
   }

   /// Checks whether the expected and actual values are not equal.
   static void notEquals(unexpected, actual, [String reason = '']) {
     if (unexpected == actual) {
       _fail('Expect.notEquals(unexpected: <$unexpected>, '
           'actual:<$actual>$reason) fails.');
     }
   }

   /// Specialized equality test for strings. When the strings don't match,
   /// this method shows where the mismatch starts and ends.
   static void stringEquals(String? expected, String? actual,
       [String reason = '']) {
     String defaultMessage =
         'Expect.stringEquals(expected: <$expected>, <$actual>$reason) fails';
     if (expected == actual) return;

     if (expected == null || actual == null) {
       _fail('$defaultMessage');
     } else {
       // Scan from the left until we find a mismatch
       int left = 0;
       int expLength = expected.length;
       int actLength = actual.length;
       while (true) {
         if (left == expLength) {
           assert(left < actLength);
           String snippet = actual.substring(left, actLength);
           _fail('$defaultMessage\nDiff:\n...[  ]\n...[ $snippet ]');
         } else if (left == actLength) {
           assert(left < expLength);
           String snippet = expected.substring(left, expLength);
           _fail('$defaultMessage\nDiff:\n...[  ]\n...[ $snippet ]');
         } else if (expected[left] != actual[left]) {
           break;
         }
         left++;
       }

       // scan from the right until we find a mismatch
       int right = 0;
       while (true) {
         if (right == expLength) {
           assert(right < actLength);
           String snippet = actual.substring(0, actLength - right);
           _fail('$defaultMessage\nDiff:\n[  ]...\n[ $snippet ]...');
         } else if (right == actLength) {
           assert(right < expLength);
           String snippet = expected.substring(0, expLength - right);
           _fail('$defaultMessage\nDiff:\n[  ]...\n[ $snippet ]...');
         } else if ((expLength - right <= left || actLength - right <= left) ||
             ((expected[expLength - right - 1] !=
                 actual[actLength - right - 1]))) {
           // Stop scanning if we've reached the end of the left-to-right match
           break;
         }
         right++;
       }

       String eSnippet = expected.substring(left, expLength - right);
       String aSnippet = actual.substring(left, actLength - right);
       String diff = '\nDiff:\n...[ $eSnippet ]...\n...[ $aSnippet ]...';
       _fail('$defaultMessage$diff');
     }
   }

   /// Checks that every element of [expected] is also in [actual], and that
   /// every element of [actual] is also in [expected].
   static void setEquals(Iterable<Object?> expected, Iterable<Object?> actual,
       [String reason = '']) {
     final missingSet = new Set.from(expected);
     missingSet.removeAll(actual);
     final extraSet = new Set.from(actual);
     extraSet.removeAll(expected);

     if (!extraSet.isEmpty || !missingSet.isEmpty) {
       StringBuffer buffer = StringBuffer('Expect.setEquals($reason) fails');
       // Report any missing items.
       if (!missingSet.isEmpty) {
         buffer.write('\nExpected collection does not contain: ');
       }

       for (final val in missingSet) {
         buffer.write('$val ');
       }

       // Report any extra items.
       if (!extraSet.isEmpty) {
         buffer.write('\nExpected collection should not contain: ');
       }

       for (final val in extraSet) {
         buffer.write('$val ');
       }

       _fail(buffer.toString());
     }
   }

   /// Calls the function [func] and verifies that it throws an exception.
   ///
   /// The optional [check] function can provide additional validation that
   /// correct exception is being thrown. For example, to check the type of the
   /// exception you could write this:
   ///
   ///    Expect.throws(myThrowingFunction, (e) => e is MyException);
   static void throws(void func(),
       [_CheckExceptionFn? check, String reason = '']) {
     try {
       func();
     } catch (exception, str) {
       if (check != null && !check(exception)) {
         _fail('Expect.throws($reason): '
             'Unexpected ${exception.runtimeType}($exception)\n$str');
       }
       return;
     }
     _fail('Expect.throws($reason) fails');
   }

   /// Calls the async function [func] and verifies that it throws an exception.
   ///
   /// The optional [check] function can provide additional validation that
   /// correct exception is being thrown. For example, to check the type of the
   /// exception you could write this:
   ///
   ///    Expect.asyncThrows(myThrowingAsyncFunction, (e) => e is MyException);
   static Future<void> asyncThrows(Future<void> func(),
       [_CheckExceptionFn? check, String reason = '']) async {
     try {
       await func();
     } catch (exception, str) {
       if (check != null && !check(exception)) {
         _fail('Expect.throws($reason): '
             'Unexpected ${exception.runtimeType}($exception)\n$str');
       }
       return;
     }
     _fail('Expect.throws($reason) fails');
   }

   /// Checks that given lists are equal.
   static void listEquals(var expected, var actual, [String reason = '']) {
     if (expected is! List) {
       Expect.fail('expected is not a List:$expected');
     } else if (actual is! List) {
       Expect.fail('actual is not a List:$expected');
     } else {
       deepEquals(expected, actual, reason);
     }
   }

   /// Checks that given maps are equal.
   static void mapEquals(var expected, var actual, [String reason = '']) {
     if ((expected is! Map) || (actual is! Map)) {
       Expect.fail('not a Map');
     } else {
       deepEquals(expected, actual, reason);
     }
   }

   /// Checks that both collections have identical topology and equal primitive
   /// elements. Useful to check cyclic collections passed through ports and
   /// streams.
   static void deepEquals(var expected, var actual, [String reason = '']) {
     Map planned = Map();
     Map processed = Map();

     void plan2check(var expected, var actual) {
       if (expected == null) {
         Expect.isNull(actual);
       }

       if ((expected is Map) || (expected is List)) {
         var savedActual = planned[expected];
         if (savedActual != null) {
           // this pair is planned to investigate
           Expect.equals(savedActual, actual);
         } else if ((savedActual = processed[expected]) != null) {
           // this pair is checked already
           Expect.equals(savedActual, actual);
         } else {
           // this pair is not yet investigated
           Expect.equals(
               expected.length,
               actual.length,
               'Collection lengths are not equal: '
               'expected length=${expected.length}, '
               'actual length=${actual.length}');
           planned[expected] = actual;
         }
       } else {
         Expect.equals(expected, actual, reason);
       }
     }

     void runPlanned(var expected, var actual) {
       if (expected is Map) {
         for (var key in expected.keys) {
 //        TODO check that key sets are equivalent.
 //        The following method does not work:
 //          Expect.isTrue(actual.keys.toSet().remove(key)");
           plan2check(expected[key], actual[key]);
         }
       } else if (expected is List) {
         for (int i = 0; i != expected.length; i++) {
           plan2check(expected[i], actual[i]);
         }
       } else {
         Expect.fail("only Lists and Maps expected in the plan");
       }
       // Move pair from planned to processed
       planned.remove(expected);
       processed[expected] = actual;
     }

     try {
       plan2check(expected, actual);
       for (;;) {
         Iterable keys = planned.keys;
         if (keys.isEmpty) {
           return;
         }
         var key = keys.first;
         runPlanned(key, planned[key]);
       }
     } catch (error) {
       _fail(
           'deepEquals($expected, $actual, $reason) fails\n   [cause: $error]');
     }
   }

   // Checks that given шеукфидуы are equal.
   static void iterableEquals(Iterable expected, Iterable actual) {
     Iterator expIterator = expected.iterator;
     Iterator actIterator = actual.iterator;
     while (expIterator.moveNext()) {
       Expect.isTrue(actIterator.moveNext());
       Expect.equals(expIterator.current, actIterator.current);
     }
     Expect.isFalse(actIterator.moveNext());
   }

   /// Checks that [obj] object is of the type [T] or not.
   static void _checkIs<T>(bool expected, Object? obj) {
     Expect.equals(expected, obj is T);
   }

   /// Call this function with `checkIs` as the first parameter to check the type
   /// to prevent the compiler reducing the code to the answer. Otherwise, dart2js
   /// compiler may optimize `Expect.isTrue(c is C)` to `Expect_isTrue(true)`
   @pragma('dart2js:noInline')
   static void _checkType(
       void Function(bool, Object?) checker, bool expected, Object? o) {
     checker(expected, o);
   }

   /// Call this function to perform runtime type check. Sometimes compiler (for
   /// example dart2js or AOT) optimizes
   /// `Expect.isTrue(c is C)` to `Expect_isTrue(true)`
   /// If you want to test not only compiler optimization but runtime as well the
   /// use
   /// ```dart
   /// Expect.isTrue(c is C);  // to test optimization
   /// Expect.runtimeIsType<C>(c); // to test runtime
   /// ```
   static void runtimeIsType<T>(Object? o) {
     _checkType(_checkIs<T>, true, o);
   }

   /// Call this function to perform runtime type check. Sometimes compiler (for
   /// example dart2js or AOT) optimizes
   /// `Expect.isFalse(c is C)` to `Expect_isFalse(false)`
   /// If you want to test not only compiler optimization but runtime as well the
   /// use
   /// ```dart
   /// Expect.isFalse(c is C); // to test optimization
   /// Expect.runtimeIsNotType<C>(c); // to test runtime
   /// ```
   static void runtimeIsNotType<T>(Object? o) {
     _checkType(_checkIs<T>, false, o);
   }

   /// Checks that the run-time type of [o] implements `Iterable<T>`, otherwise
   /// throws. For example,
   /// `isRuntimeTypeImplementsIterable<num>(<int>[1, 2, 3])` will throw
   /// `ExpectException`, but
   /// `isRuntimeTypeImplementsIterable<num>(<num>[1, 2, 3])` succeeds.
   static void isRuntimeTypeImplementsIterable<T>(Object? o) {
     if (o is! Iterable<T>) {
       throw ExpectException("Not Iterable<$T>: ${o.runtimeType}");
     }
     List<T> list = o.toList(growable: true);
     try {
       list.addAll(<T>[]);
     } on TypeError catch (_) {
       throw ExpectException("Expected Iterable<$T> but found $o");
     }
   }
 }

 bool _identical(a, b) => identical(a, b);

 typedef bool _CheckExceptionFn(exception);

 class ExpectException implements Exception {
   String? message;
   ExpectException([this.message]);
   String toString() => message ?? "";
 }

 /// Is true iff `assert` statements are enabled.
 final bool assertStatementsEnabled = (() {
   bool result = false;
   assert(result = true);
   return result;
 })();

 /// Is true iff js compiler is used
 final bool isJS = identical(1.0, 1);

 /// Checks that objects are identical at the compile time
 class CheckIdentical {
   const CheckIdentical(Object? o1, Object? o2) : assert(identical(o1, o2));
 }

 /// Checks that objects are not identical at the compile time
 class CheckNotIdentical {
   const CheckNotIdentical(Object? o1, Object? o2) : assert(!identical(o1, o2));
 }
	// Copyright (c) 2012, 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.

	part of 'expect.dart';

	class Expect {
	/// Checks whether the expected and actual values are equal using `==`.
	static void equals(var expected, var actual, [String reason = '']) {
	if ((expected != actual) &&
	!((expected is double) &&
	(actual is double) &&
	(expected.isNaN) &&
	(actual.isNaN))) {
	_fail('Expect.equals(expected: <$expected>, actual: <$actual>$reason) '
	'fails.');
	}
	}

	/// Checks whether the actual value is [bool] and its value is [true].
	static void isTrue(var actual, [String reason = '']) {
	if (!_identical(actual, true)) {
	_fail('Expect.isTrue($actual$reason) fails.');
	}
	}

	/// Checks whether the actual value is [bool] and its value is [false].
	static void isFalse(var actual, [String reason = '']) {
	if (!_identical(actual, false)) {
	_fail('Expect.isFalse($actual$reason) fails.');
	}
	}

	/// Checks whether [actual] is [null].
	static void isNull(actual, [String reason = '']) {
	if (null != actual) {
	_fail('Expect.isNull(actual: <$actual>$reason) fails.');
	}
	}

	/// Checks whether [actual] is not [null].
	static void isNotNull(actual, [String reason = '']) {
	if (null == actual) {
	_fail('Expect.isNotNull(actual: <$actual>$reason) fails.');
	}
	}

	/// Checks whether the expected and actual values are identical (using
	/// `identical`).
	static void identical(var expected, var actual, [String reason = '']) {
	if (!_identical(expected, actual)) {
	_fail('Expect.identical(expected: <$expected>, '
	'actual: <$actual>$reason) fails.');
	}
	}

	/// Unconditional failure.
	static void fail(String reason) {
	_fail('Expect.fail($reason)');
	}

	/// Checks whether the difference between expected and actual is greater than
	/// the given tolerance. If no tolerance is given, tolerance is assumed to be
	/// a value of the 4 significant digits smaller than the value given for
	/// [expected].
	static void approxEquals(num expected, num actual,
	[num? tolerance, String reason = '']) {
	tolerance ??= (expected / 1e4).abs();

	// Note: use !( <= ) rather than > so we fail on NaNs
	if (!((expected - actual).abs() <= tolerance)) {
	_fail('Expect.approxEquals(expected:<$expected>, actual:<$actual>, '
	'tolerance:<$tolerance>$reason) fails');
	}
	}

	/// Checks whether the expected and actual values are not equal.
	static void notEquals(unexpected, actual, [String reason = '']) {
	if (unexpected == actual) {
	_fail('Expect.notEquals(unexpected: <$unexpected>, '
	'actual:<$actual>$reason) fails.');
	}
	}

	/// Specialized equality test for strings. When the strings don't match,
	/// this method shows where the mismatch starts and ends.
	static void stringEquals(String? expected, String? actual,
	[String reason = '']) {
	String defaultMessage =
	'Expect.stringEquals(expected: <$expected>, <$actual>$reason) fails';
	if (expected == actual) return;

	if (expected == null \|\| actual == null) {
	_fail('$defaultMessage');
	} else {
	// Scan from the left until we find a mismatch
	int left = 0;
	int expLength = expected.length;
	int actLength = actual.length;
	while (true) {
	if (left == expLength) {
	assert(left < actLength);
	String snippet = actual.substring(left, actLength);
	_fail('$defaultMessage\nDiff:\n...[ ]\n...[ $snippet ]');
	} else if (left == actLength) {
	assert(left < expLength);
	String snippet = expected.substring(left, expLength);
	_fail('$defaultMessage\nDiff:\n...[ ]\n...[ $snippet ]');
	} else if (expected[left] != actual[left]) {
	break;
	}
	left++;
	}

	// scan from the right until we find a mismatch
	int right = 0;
	while (true) {
	if (right == expLength) {
	assert(right < actLength);
	String snippet = actual.substring(0, actLength - right);
	_fail('$defaultMessage\nDiff:\n[ ]...\n[ $snippet ]...');
	} else if (right == actLength) {
	assert(right < expLength);
	String snippet = expected.substring(0, expLength - right);
	_fail('$defaultMessage\nDiff:\n[ ]...\n[ $snippet ]...');
	} else if ((expLength - right <= left \|\| actLength - right <= left) \|\|
	((expected[expLength - right - 1] !=
	actual[actLength - right - 1]))) {
	// Stop scanning if we've reached the end of the left-to-right match
	break;
	}
	right++;
	}

	String eSnippet = expected.substring(left, expLength - right);
	String aSnippet = actual.substring(left, actLength - right);
	String diff = '\nDiff:\n...[ $eSnippet ]...\n...[ $aSnippet ]...';
	_fail('$defaultMessage$diff');
	}
	}

	/// Checks that every element of [expected] is also in [actual], and that
	/// every element of [actual] is also in [expected].
	static void setEquals(Iterable<Object?> expected, Iterable<Object?> actual,
	[String reason = '']) {
	final missingSet = new Set.from(expected);
	missingSet.removeAll(actual);
	final extraSet = new Set.from(actual);
	extraSet.removeAll(expected);

	if (!extraSet.isEmpty \|\| !missingSet.isEmpty) {
	StringBuffer buffer = StringBuffer('Expect.setEquals($reason) fails');
	// Report any missing items.
	if (!missingSet.isEmpty) {
	buffer.write('\nExpected collection does not contain: ');
	}

	for (final val in missingSet) {
	buffer.write('$val ');
	}

	// Report any extra items.
	if (!extraSet.isEmpty) {
	buffer.write('\nExpected collection should not contain: ');
	}

	for (final val in extraSet) {
	buffer.write('$val ');
	}

	_fail(buffer.toString());
	}
	}

	/// Calls the function [func] and verifies that it throws an exception.
	///
	/// The optional [check] function can provide additional validation that
	/// correct exception is being thrown. For example, to check the type of the
	/// exception you could write this:
	///
	/// Expect.throws(myThrowingFunction, (e) => e is MyException);
	static void throws(void func(),
	[_CheckExceptionFn? check, String reason = '']) {
	try {
	func();
	} catch (exception, str) {
	if (check != null && !check(exception)) {
	_fail('Expect.throws($reason): '
	'Unexpected ${exception.runtimeType}($exception)\n$str');
	}
	return;
	}
	_fail('Expect.throws($reason) fails');
	}

	/// Calls the async function [func] and verifies that it throws an exception.
	///
	/// The optional [check] function can provide additional validation that
	/// correct exception is being thrown. For example, to check the type of the
	/// exception you could write this:
	///
	/// Expect.asyncThrows(myThrowingAsyncFunction, (e) => e is MyException);
	static Future<void> asyncThrows(Future<void> func(),
	[_CheckExceptionFn? check, String reason = '']) async {
	try {
	await func();
	} catch (exception, str) {
	if (check != null && !check(exception)) {
	_fail('Expect.throws($reason): '
	'Unexpected ${exception.runtimeType}($exception)\n$str');
	}
	return;
	}
	_fail('Expect.throws($reason) fails');
	}

	/// Checks that given lists are equal.
	static void listEquals(var expected, var actual, [String reason = '']) {
	if (expected is! List) {
	Expect.fail('expected is not a List:$expected');
	} else if (actual is! List) {
	Expect.fail('actual is not a List:$expected');
	} else {
	deepEquals(expected, actual, reason);
	}
	}

	/// Checks that given maps are equal.
	static void mapEquals(var expected, var actual, [String reason = '']) {
	if ((expected is! Map) \|\| (actual is! Map)) {
	Expect.fail('not a Map');
	} else {
	deepEquals(expected, actual, reason);
	}
	}

	/// Checks that both collections have identical topology and equal primitive
	/// elements. Useful to check cyclic collections passed through ports and
	/// streams.
	static void deepEquals(var expected, var actual, [String reason = '']) {
	Map planned = Map();
	Map processed = Map();

	void plan2check(var expected, var actual) {
	if (expected == null) {
	Expect.isNull(actual);
	}

	if ((expected is Map) \|\| (expected is List)) {
	var savedActual = planned[expected];
	if (savedActual != null) {
	// this pair is planned to investigate
	Expect.equals(savedActual, actual);
	} else if ((savedActual = processed[expected]) != null) {
	// this pair is checked already
	Expect.equals(savedActual, actual);
	} else {
	// this pair is not yet investigated
	Expect.equals(
	expected.length,
	actual.length,
	'Collection lengths are not equal: '
	'expected length=${expected.length}, '
	'actual length=${actual.length}');
	planned[expected] = actual;
	}
	} else {
	Expect.equals(expected, actual, reason);
	}
	}

	void runPlanned(var expected, var actual) {
	if (expected is Map) {
	for (var key in expected.keys) {
	// TODO check that key sets are equivalent.
	// The following method does not work:
	// Expect.isTrue(actual.keys.toSet().remove(key)");
	plan2check(expected[key], actual[key]);
	}
	} else if (expected is List) {
	for (int i = 0; i != expected.length; i++) {
	plan2check(expected[i], actual[i]);
	}
	} else {
	Expect.fail("only Lists and Maps expected in the plan");
	}
	// Move pair from planned to processed
	planned.remove(expected);
	processed[expected] = actual;
	}

	try {
	plan2check(expected, actual);
	for (;;) {
	Iterable keys = planned.keys;
	if (keys.isEmpty) {
	return;
	}
	var key = keys.first;
	runPlanned(key, planned[key]);
	}
	} catch (error) {
	_fail(
	'deepEquals($expected, $actual, $reason) fails\n [cause: $error]');
	}
	}

	// Checks that given шеукфидуы are equal.
	static void iterableEquals(Iterable expected, Iterable actual) {
	Iterator expIterator = expected.iterator;
	Iterator actIterator = actual.iterator;
	while (expIterator.moveNext()) {
	Expect.isTrue(actIterator.moveNext());
	Expect.equals(expIterator.current, actIterator.current);
	}
	Expect.isFalse(actIterator.moveNext());
	}

	/// Checks that [obj] object is of the type [T] or not.
	static void _checkIs<T>(bool expected, Object? obj) {
	Expect.equals(expected, obj is T);
	}

	/// Call this function with `checkIs` as the first parameter to check the type
	/// to prevent the compiler reducing the code to the answer. Otherwise, dart2js
	/// compiler may optimize `Expect.isTrue(c is C)` to `Expect_isTrue(true)`
	@pragma('dart2js:noInline')
	static void _checkType(
	void Function(bool, Object?) checker, bool expected, Object? o) {
	checker(expected, o);
	}

	/// Call this function to perform runtime type check. Sometimes compiler (for
	/// example dart2js or AOT) optimizes
	/// `Expect.isTrue(c is C)` to `Expect_isTrue(true)`
	/// If you want to test not only compiler optimization but runtime as well the
	/// use
	/// ```dart
	/// Expect.isTrue(c is C); // to test optimization
	/// Expect.runtimeIsType<C>(c); // to test runtime
	/// ```
	static void runtimeIsType<T>(Object? o) {
	_checkType(_checkIs<T>, true, o);
	}

	/// Call this function to perform runtime type check. Sometimes compiler (for
	/// example dart2js or AOT) optimizes
	/// `Expect.isFalse(c is C)` to `Expect_isFalse(false)`
	/// If you want to test not only compiler optimization but runtime as well the
	/// use
	/// ```dart
	/// Expect.isFalse(c is C); // to test optimization
	/// Expect.runtimeIsNotType<C>(c); // to test runtime
	/// ```
	static void runtimeIsNotType<T>(Object? o) {
	_checkType(_checkIs<T>, false, o);
	}

	/// Checks that the run-time type of [o] implements `Iterable<T>`, otherwise
	/// throws. For example,
	/// `isRuntimeTypeImplementsIterable<num>(<int>[1, 2, 3])` will throw
	/// `ExpectException`, but
	/// `isRuntimeTypeImplementsIterable<num>(<num>[1, 2, 3])` succeeds.
	static void isRuntimeTypeImplementsIterable<T>(Object? o) {
	if (o is! Iterable<T>) {
	throw ExpectException("Not Iterable<$T>: ${o.runtimeType}");
	}
	List<T> list = o.toList(growable: true);
	try {
	list.addAll(<T>[]);
	} on TypeError catch (_) {
	throw ExpectException("Expected Iterable<$T> but found $o");
	}
	}
	}

	bool _identical(a, b) => identical(a, b);

	typedef bool _CheckExceptionFn(exception);

	class ExpectException implements Exception {
	String? message;
	ExpectException([this.message]);
	String toString() => message ?? "";
	}

	/// Is true iff `assert` statements are enabled.
	final bool assertStatementsEnabled = (() {
	bool result = false;
	assert(result = true);
	return result;
	})();

	/// Is true iff js compiler is used
	final bool isJS = identical(1.0, 1);

	/// Checks that objects are identical at the compile time
	class CheckIdentical {
	const CheckIdentical(Object? o1, Object? o2) : assert(identical(o1, o2));
	}

	/// Checks that objects are not identical at the compile time
	class CheckNotIdentical {
	const CheckNotIdentical(Object? o1, Object? o2) : assert(!identical(o1, o2));
	}