pkgs/checks/lib/src/extensions/iterable.dart - test - Git at Google

 // Copyright (c) 2022, 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 '../../context.dart';

 import '../collection_equality.dart';
 import 'core.dart';

 extension IterableChecks<T> on Subject<Iterable<T>> {
   Subject<int> get length => has((l) => l.length, 'length');

   Subject<T> get first => context.nest(() => ['has first element'], (actual) {
     final iterator = actual.iterator;
     if (!iterator.moveNext()) {
       return Extracted.rejection(which: ['has no elements']);
     }
     return Extracted.value(iterator.current);
   });

   Subject<T> get last => context.nest(() => ['has last element'], (actual) {
     final iterator = actual.iterator;
     if (!iterator.moveNext()) {
       return Extracted.rejection(which: ['has no elements']);
     }
     var current = iterator.current;
     while (iterator.moveNext()) {
       current = iterator.current;
     }
     return Extracted.value(current);
   });

   Subject<T> get single => context.nest(() => ['has single element'], (actual) {
     final iterator = actual.iterator;
     if (!iterator.moveNext()) {
       return Extracted.rejection(which: ['has no elements']);
     }
     final value = iterator.current;
     if (iterator.moveNext()) {
       return Extracted.rejection(which: ['has more than one element']);
     }
     return Extracted.value(value);
   });

   void isEmpty() {
     context.expect(() => const ['is empty'], (actual) {
       if (actual.isEmpty) return null;
       return Rejection(which: ['is not empty']);
     });
   }

   void isNotEmpty() {
     context.expect(() => const ['is not empty'], (actual) {
       if (actual.isNotEmpty) return null;
       return Rejection(which: ['is empty']);
     });
   }

   /// Expects that the iterable contains [element] according to
   /// [Iterable.contains].
   void contains(T element) {
     context.expect(
       () {
         return prefixFirst('contains ', literal(element));
       },
       (actual) {
         if (actual.isEmpty) return Rejection(actual: ['an empty iterable']);
         if (actual.contains(element)) return null;
         return Rejection(
           which: prefixFirst('does not contain ', literal(element)),
         );
       },
     );
   }

   /// Expects that the iterable contains a value matching each expected value
   /// from [elements] in the given order, with any extra elements between
   /// them.
   ///
   /// For example, the following will succeed:
   ///
   /// ```dart
   /// check([1, 0, 2, 0, 3]).containsInOrder([1, 2, 3]);
   /// ```
   ///
   /// Values in [elements] may be a `T`, a `Condition<T>`, or a
   /// `Condition<Object?>`. If an expectation is a condition callback it will be
   /// checked against the actual values, and any other expectations, including
   /// those that are not a `T` or a condition callback, will be compared with
   /// the equality operator.
   ///
   /// ```dart
   /// check([1, 0, 2, 0, 3])
   ///   .containsInOrder([1, (Subject<int> v) => v.isGreaterThan(1), 3]);
   /// ```
   @Deprecated(
     'Use `containsEqualInOrder` for expectations with values compared'
     ' with `==` or `containsMatchingInOrder` for other expectations',
   )
   void containsInOrder(Iterable<Object?> elements) {
     context.expect(
       () => prefixFirst('contains, in order: ', literal(elements)),
       (actual) {
         final expected = elements.toList();
         if (expected.isEmpty) {
           throw ArgumentError('expected may not be empty');
         }
         var expectedIndex = 0;
         for (final element in actual) {
           final currentExpected = expected[expectedIndex];
           final matches =
               currentExpected is Condition<T>
                   ? softCheck(element, currentExpected) == null
                   : currentExpected is Condition<dynamic>
                   ? softCheck(element, currentExpected) == null
                   : currentExpected == element;
           if (matches && ++expectedIndex >= expected.length) return null;
         }
         return Rejection(
           which: [
             ...prefixFirst(
               'did not have an element matching the expectation at index '
               '$expectedIndex ',
               literal(expected[expectedIndex]),
             ),
           ],
         );
       },
     );
   }

   /// Expects that the iterable contains a value matching each condition in
   /// [conditions] in the given order, with any extra elements between them.
   ///
   /// For example, the following will succeed:
   ///
   /// ```dart
   /// check([1, 10, 2, 10, 3]).containsMatchingInOrder([
   ///   (it) => it.isLessThan(2),
   ///   (it) => it.isLessThan(3),
   ///   (it) => it.isLessThan(4),
   /// ]);
   /// ```
   void containsMatchingInOrder(Iterable<Condition<T>> conditions) {
     context.expect(
       () => prefixFirst('contains, in order: ', literal(conditions)),
       (actual) {
         final expected = conditions.toList();
         if (expected.isEmpty) {
           throw ArgumentError('expected may not be empty');
         }
         var expectedIndex = 0;
         for (final element in actual) {
           final currentExpected = expected[expectedIndex];
           final matches = softCheck(element, currentExpected) == null;
           if (matches && ++expectedIndex >= expected.length) return null;
         }
         return Rejection(
           which: [
             ...prefixFirst(
               'did not have an element matching the expectation at index '
               '$expectedIndex ',
               literal(expected[expectedIndex]),
             ),
           ],
         );
       },
     );
   }

   /// Expects that the iterable contains a value equals to each expected value
   /// from [elements] in the given order, with any extra elements between
   /// them.
   ///
   /// For example, the following will succeed:
   ///
   /// ```dart
   /// check([1, 0, 2, 0, 3]).containsInOrder([1, 2, 3]);
   /// ```
   ///
   /// Values, will be compared with the equality operator.
   void containsEqualInOrder(Iterable<T> elements) {
     context.expect(
       () => prefixFirst('contains, in order: ', literal(elements)),
       (actual) {
         final expected = elements.toList();
         if (expected.isEmpty) {
           throw ArgumentError('expected may not be empty');
         }
         var expectedIndex = 0;
         for (final element in actual) {
           final currentExpected = expected[expectedIndex];
           final matches = currentExpected == element;
           if (matches && ++expectedIndex >= expected.length) return null;
         }
         return Rejection(
           which: [
             ...prefixFirst(
               'did not have an element equal to the expectation at index '
               '$expectedIndex ',
               literal(expected[expectedIndex]),
             ),
           ],
         );
       },
     );
   }

   /// Expects that the iterable contains at least on element such that
   /// [elementCondition] is satisfied.
   void any(Condition<T> elementCondition) {
     context.expect(
       () {
         final conditionDescription = describe(elementCondition);
         assert(conditionDescription.isNotEmpty);
         return ['contains a value that:', ...conditionDescription];
       },
       (actual) {
         if (actual.isEmpty) return Rejection(actual: ['an empty iterable']);
         for (var e in actual) {
           if (softCheck(e, elementCondition) == null) return null;
         }
         return Rejection(which: ['Contains no matching element']);
       },
     );
   }

   /// Expects there are no elements in the iterable which fail to satisfy
   /// [elementCondition].
   ///
   /// Empty iterables will pass always pass this expectation.
   void every(Condition<T> elementCondition) {
     context.expect(
       () {
         final conditionDescription = describe(elementCondition);
         assert(conditionDescription.isNotEmpty);
         return ['only has values that:', ...conditionDescription];
       },
       (actual) {
         final iterator = actual.iterator;
         for (var i = 0; iterator.moveNext(); i++) {
           final element = iterator.current;
           final failure = softCheck(element, elementCondition);
           if (failure == null) continue;
           final which = failure.rejection.which;
           return Rejection(
             which: [
               'has an element at index $i that:',
               ...indent(failure.detail.actual.skip(1)),
               ...indent(
                 prefixFirst('Actual: ', failure.rejection.actual),
                 failure.detail.depth + 1,
               ),
               if (which != null && which.isNotEmpty)
                 ...indent(
                   prefixFirst('Which: ', which),
                   failure.detail.depth + 1,
                 ),
             ],
           );
         }
         return null;
       },
     );
   }

   /// Expects that the iterable contains elements that are deeply equal to the
   /// elements of [expected].
   ///
   /// {@macro deep_collection_equals}
   void deepEquals(Iterable<Object?> expected) => context.expect(
     () => prefixFirst('is deeply equal to ', literal(expected)),
     (actual) {
       final which = deepCollectionEquals(actual, expected);
       if (which == null) return null;
       return Rejection(which: which);
     },
   );

   /// Expects that the iterable contains elements which equal those of
   /// [expected] in any order.
   ///
   /// Should not be used for very large collections, runtime is O(n^2.5) in the
   /// worst case where the iterables contain many equal elements, and O(n^2) in
   /// more typical cases.
   void unorderedEquals(Iterable<T> expected) {
     context.expect(() => prefixFirst('unordered equals ', literal(expected)), (
       actual,
     ) {
       final which = unorderedCompare(
         actual,
         expected,
         (actual, expected) => expected == actual,
         (expected, index, count) => [
           ...prefixFirst(
             'has no element equal to the expected element at index '
             '$index: ',
             literal(expected),
           ),
           if (count > 1) 'or ${count - 1} other elements',
         ],
         (actual, index, count) => [
           ...prefixFirst(
             'has an unexpected element at index $index: ',
             literal(actual),
           ),
           if (count > 1) 'and ${count - 1} other unexpected elements',
         ],
       );
       if (which == null) return null;
       return Rejection(which: which);
     });
   }

   /// Expects that the iterable contains elements which match all conditions of
   /// [expected] in any order.
   ///
   /// Should not be used for very large collections, runtime is O(n^2.5) in the
   /// worst case where conditions match many elements, and O(n^2) in more
   /// typical cases.
   void unorderedMatches(Iterable<Condition<T>> expected) {
     context.expect(() => prefixFirst('unordered matches ', literal(expected)), (
       actual,
     ) {
       final which = unorderedCompare(
         actual,
         expected,
         (actual, expected) => softCheck(actual, expected) == null,
         (expected, index, count) => [
           'has no element matching the condition at index $index:',
           ...describe(expected),
           if (count > 1) 'or ${count - 1} other conditions',
         ],
         (actual, index, count) => [
           ...prefixFirst(
             'has an unmatched element at index $index: ',
             literal(actual),
           ),
           if (count > 1) 'and ${count - 1} other unmatched elements',
         ],
       );
       if (which == null) return null;
       return Rejection(which: which);
     });
   }

   /// Expects that the iterable contains elements that correspond by the
   /// [elementCondition] exactly to each element in [expected].
   ///
   /// Fails if the iterable has a different length than [expected].
   ///
   /// For each element in the iterable, calls [elementCondition] with the
   /// corresponding element from [expected] to get the specific condition for
   /// that index.
   ///
   /// [description] is used in the Expected clause. It should be a predicate
   /// without the object, for example with the description 'is less than' the
   /// full expectation will be: "pairwise is less than $expected"
   @Deprecated('Use `pairwiseMatches`')
   void pairwiseComparesTo<S>(
     List<S> expected,
     Condition<T> Function(S) elementCondition,
     String description,
   ) => pairwiseMatches(expected, elementCondition, description);

   /// Expects that the iterable contains elements that correspond by the
   /// [elementCondition] exactly to each element in [expected].
   ///
   /// Fails if the iterable has a different length than [expected].
   ///
   /// For each element in the iterable, calls [elementCondition] with the
   /// corresponding element from [expected] to get the specific condition for
   /// that index.
   ///
   /// [description] is used in the Expected clause. It should be a predicate
   /// without the object, for example with the description 'is less than' the
   /// full expectation will be: "pairwise is less than $expected"
   void pairwiseMatches<S>(
     List<S> expected,
     Condition<T> Function(S) elementCondition,
     String description,
   ) {
     context.expect(
       () {
         return prefixFirst('pairwise $description ', literal(expected));
       },
       (actual) {
         final iterator = actual.iterator;
         for (var i = 0; i < expected.length; i++) {
           final expectedValue = expected[i];
           if (!iterator.moveNext()) {
             return Rejection(
               which: [
                 'has too few elements, there is no element to match at index $i',
               ],
             );
           }
           final actualValue = iterator.current;
           final failure = softCheck(
             actualValue,
             elementCondition(expectedValue),
           );
           if (failure == null) continue;
           final innerDescription = describe<T>(elementCondition(expectedValue));
           final which = failure.rejection.which;
           return Rejection(
             which: [
               'does not have an element at index $i that:',
               ...innerDescription,
               ...prefixFirst(
                 'Actual element at index $i: ',
                 failure.rejection.actual,
               ),
               if (which != null) ...prefixFirst('Which: ', which),
             ],
           );
         }
         if (!iterator.moveNext()) return null;
         return Rejection(
           which: ['has too many elements, expected exactly ${expected.length}'],
         );
       },
     );
   }
 }
	// Copyright (c) 2022, 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 '../../context.dart';

	import '../collection_equality.dart';
	import 'core.dart';

	extension IterableChecks<T> on Subject<Iterable<T>> {
	Subject<int> get length => has((l) => l.length, 'length');

	Subject<T> get first => context.nest(() => ['has first element'], (actual) {
	final iterator = actual.iterator;
	if (!iterator.moveNext()) {
	return Extracted.rejection(which: ['has no elements']);
	}
	return Extracted.value(iterator.current);
	});

	Subject<T> get last => context.nest(() => ['has last element'], (actual) {
	final iterator = actual.iterator;
	if (!iterator.moveNext()) {
	return Extracted.rejection(which: ['has no elements']);
	}
	var current = iterator.current;
	while (iterator.moveNext()) {
	current = iterator.current;
	}
	return Extracted.value(current);
	});

	Subject<T> get single => context.nest(() => ['has single element'], (actual) {
	final iterator = actual.iterator;
	if (!iterator.moveNext()) {
	return Extracted.rejection(which: ['has no elements']);
	}
	final value = iterator.current;
	if (iterator.moveNext()) {
	return Extracted.rejection(which: ['has more than one element']);
	}
	return Extracted.value(value);
	});

	void isEmpty() {
	context.expect(() => const ['is empty'], (actual) {
	if (actual.isEmpty) return null;
	return Rejection(which: ['is not empty']);
	});
	}

	void isNotEmpty() {
	context.expect(() => const ['is not empty'], (actual) {
	if (actual.isNotEmpty) return null;
	return Rejection(which: ['is empty']);
	});
	}

	/// Expects that the iterable contains [element] according to
	/// [Iterable.contains].
	void contains(T element) {
	context.expect(
	() {
	return prefixFirst('contains ', literal(element));
	},
	(actual) {
	if (actual.isEmpty) return Rejection(actual: ['an empty iterable']);
	if (actual.contains(element)) return null;
	return Rejection(
	which: prefixFirst('does not contain ', literal(element)),
	);
	},
	);
	}

	/// Expects that the iterable contains a value matching each expected value
	/// from [elements] in the given order, with any extra elements between
	/// them.
	///
	/// For example, the following will succeed:
	///
	/// ```dart
	/// check([1, 0, 2, 0, 3]).containsInOrder([1, 2, 3]);
	/// ```
	///
	/// Values in [elements] may be a `T`, a `Condition<T>`, or a
	/// `Condition<Object?>`. If an expectation is a condition callback it will be
	/// checked against the actual values, and any other expectations, including
	/// those that are not a `T` or a condition callback, will be compared with
	/// the equality operator.
	///
	/// ```dart
	/// check([1, 0, 2, 0, 3])
	/// .containsInOrder([1, (Subject<int> v) => v.isGreaterThan(1), 3]);
	/// ```
	@Deprecated(
	'Use `containsEqualInOrder` for expectations with values compared'
	' with `==` or `containsMatchingInOrder` for other expectations',
	)
	void containsInOrder(Iterable<Object?> elements) {
	context.expect(
	() => prefixFirst('contains, in order: ', literal(elements)),
	(actual) {
	final expected = elements.toList();
	if (expected.isEmpty) {
	throw ArgumentError('expected may not be empty');
	}
	var expectedIndex = 0;
	for (final element in actual) {
	final currentExpected = expected[expectedIndex];
	final matches =
	currentExpected is Condition<T>
	? softCheck(element, currentExpected) == null
	: currentExpected is Condition<dynamic>
	? softCheck(element, currentExpected) == null
	: currentExpected == element;
	if (matches && ++expectedIndex >= expected.length) return null;
	}
	return Rejection(
	which: [
	...prefixFirst(
	'did not have an element matching the expectation at index '
	'$expectedIndex ',
	literal(expected[expectedIndex]),
	),
	],
	);
	},
	);
	}

	/// Expects that the iterable contains a value matching each condition in
	/// [conditions] in the given order, with any extra elements between them.
	///
	/// For example, the following will succeed:
	///
	/// ```dart
	/// check([1, 10, 2, 10, 3]).containsMatchingInOrder([
	/// (it) => it.isLessThan(2),
	/// (it) => it.isLessThan(3),
	/// (it) => it.isLessThan(4),
	/// ]);
	/// ```
	void containsMatchingInOrder(Iterable<Condition<T>> conditions) {
	context.expect(
	() => prefixFirst('contains, in order: ', literal(conditions)),
	(actual) {
	final expected = conditions.toList();
	if (expected.isEmpty) {
	throw ArgumentError('expected may not be empty');
	}
	var expectedIndex = 0;
	for (final element in actual) {
	final currentExpected = expected[expectedIndex];
	final matches = softCheck(element, currentExpected) == null;
	if (matches && ++expectedIndex >= expected.length) return null;
	}
	return Rejection(
	which: [
	...prefixFirst(
	'did not have an element matching the expectation at index '
	'$expectedIndex ',
	literal(expected[expectedIndex]),
	),
	],
	);
	},
	);
	}

	/// Expects that the iterable contains a value equals to each expected value
	/// from [elements] in the given order, with any extra elements between
	/// them.
	///
	/// For example, the following will succeed:
	///
	/// ```dart
	/// check([1, 0, 2, 0, 3]).containsInOrder([1, 2, 3]);
	/// ```
	///
	/// Values, will be compared with the equality operator.
	void containsEqualInOrder(Iterable<T> elements) {
	context.expect(
	() => prefixFirst('contains, in order: ', literal(elements)),
	(actual) {
	final expected = elements.toList();
	if (expected.isEmpty) {
	throw ArgumentError('expected may not be empty');
	}
	var expectedIndex = 0;
	for (final element in actual) {
	final currentExpected = expected[expectedIndex];
	final matches = currentExpected == element;
	if (matches && ++expectedIndex >= expected.length) return null;
	}
	return Rejection(
	which: [
	...prefixFirst(
	'did not have an element equal to the expectation at index '
	'$expectedIndex ',
	literal(expected[expectedIndex]),
	),
	],
	);
	},
	);
	}

	/// Expects that the iterable contains at least on element such that
	/// [elementCondition] is satisfied.
	void any(Condition<T> elementCondition) {
	context.expect(
	() {
	final conditionDescription = describe(elementCondition);
	assert(conditionDescription.isNotEmpty);
	return ['contains a value that:', ...conditionDescription];
	},
	(actual) {
	if (actual.isEmpty) return Rejection(actual: ['an empty iterable']);
	for (var e in actual) {
	if (softCheck(e, elementCondition) == null) return null;
	}
	return Rejection(which: ['Contains no matching element']);
	},
	);
	}

	/// Expects there are no elements in the iterable which fail to satisfy
	/// [elementCondition].
	///
	/// Empty iterables will pass always pass this expectation.
	void every(Condition<T> elementCondition) {
	context.expect(
	() {
	final conditionDescription = describe(elementCondition);
	assert(conditionDescription.isNotEmpty);
	return ['only has values that:', ...conditionDescription];
	},
	(actual) {
	final iterator = actual.iterator;
	for (var i = 0; iterator.moveNext(); i++) {
	final element = iterator.current;
	final failure = softCheck(element, elementCondition);
	if (failure == null) continue;
	final which = failure.rejection.which;
	return Rejection(
	which: [
	'has an element at index $i that:',
	...indent(failure.detail.actual.skip(1)),
	...indent(
	prefixFirst('Actual: ', failure.rejection.actual),
	failure.detail.depth + 1,
	),
	if (which != null && which.isNotEmpty)
	...indent(
	prefixFirst('Which: ', which),
	failure.detail.depth + 1,
	),
	],
	);
	}
	return null;
	},
	);
	}

	/// Expects that the iterable contains elements that are deeply equal to the
	/// elements of [expected].
	///
	/// {@macro deep_collection_equals}
	void deepEquals(Iterable<Object?> expected) => context.expect(
	() => prefixFirst('is deeply equal to ', literal(expected)),
	(actual) {
	final which = deepCollectionEquals(actual, expected);
	if (which == null) return null;
	return Rejection(which: which);
	},
	);

	/// Expects that the iterable contains elements which equal those of
	/// [expected] in any order.
	///
	/// Should not be used for very large collections, runtime is O(n^2.5) in the
	/// worst case where the iterables contain many equal elements, and O(n^2) in
	/// more typical cases.
	void unorderedEquals(Iterable<T> expected) {
	context.expect(() => prefixFirst('unordered equals ', literal(expected)), (
	actual,
	) {
	final which = unorderedCompare(
	actual,
	expected,
	(actual, expected) => expected == actual,
	(expected, index, count) => [
	...prefixFirst(
	'has no element equal to the expected element at index '
	'$index: ',
	literal(expected),
	),
	if (count > 1) 'or ${count - 1} other elements',
	],
	(actual, index, count) => [
	...prefixFirst(
	'has an unexpected element at index $index: ',
	literal(actual),
	),
	if (count > 1) 'and ${count - 1} other unexpected elements',
	],
	);
	if (which == null) return null;
	return Rejection(which: which);
	});
	}

	/// Expects that the iterable contains elements which match all conditions of
	/// [expected] in any order.
	///
	/// Should not be used for very large collections, runtime is O(n^2.5) in the
	/// worst case where conditions match many elements, and O(n^2) in more
	/// typical cases.
	void unorderedMatches(Iterable<Condition<T>> expected) {
	context.expect(() => prefixFirst('unordered matches ', literal(expected)), (
	actual,
	) {
	final which = unorderedCompare(
	actual,
	expected,
	(actual, expected) => softCheck(actual, expected) == null,
	(expected, index, count) => [
	'has no element matching the condition at index $index:',
	...describe(expected),
	if (count > 1) 'or ${count - 1} other conditions',
	],
	(actual, index, count) => [
	...prefixFirst(
	'has an unmatched element at index $index: ',
	literal(actual),
	),
	if (count > 1) 'and ${count - 1} other unmatched elements',
	],
	);
	if (which == null) return null;
	return Rejection(which: which);
	});
	}

	/// Expects that the iterable contains elements that correspond by the
	/// [elementCondition] exactly to each element in [expected].
	///
	/// Fails if the iterable has a different length than [expected].
	///
	/// For each element in the iterable, calls [elementCondition] with the
	/// corresponding element from [expected] to get the specific condition for
	/// that index.
	///
	/// [description] is used in the Expected clause. It should be a predicate
	/// without the object, for example with the description 'is less than' the
	/// full expectation will be: "pairwise is less than $expected"
	@Deprecated('Use `pairwiseMatches`')
	void pairwiseComparesTo<S>(
	List<S> expected,
	Condition<T> Function(S) elementCondition,
	String description,
	) => pairwiseMatches(expected, elementCondition, description);

	/// Expects that the iterable contains elements that correspond by the
	/// [elementCondition] exactly to each element in [expected].
	///
	/// Fails if the iterable has a different length than [expected].
	///
	/// For each element in the iterable, calls [elementCondition] with the
	/// corresponding element from [expected] to get the specific condition for
	/// that index.
	///
	/// [description] is used in the Expected clause. It should be a predicate
	/// without the object, for example with the description 'is less than' the
	/// full expectation will be: "pairwise is less than $expected"
	void pairwiseMatches<S>(
	List<S> expected,
	Condition<T> Function(S) elementCondition,
	String description,
	) {
	context.expect(
	() {
	return prefixFirst('pairwise $description ', literal(expected));
	},
	(actual) {
	final iterator = actual.iterator;
	for (var i = 0; i < expected.length; i++) {
	final expectedValue = expected[i];
	if (!iterator.moveNext()) {
	return Rejection(
	which: [
	'has too few elements, there is no element to match at index $i',
	],
	);
	}
	final actualValue = iterator.current;
	final failure = softCheck(
	actualValue,
	elementCondition(expectedValue),
	);
	if (failure == null) continue;
	final innerDescription = describe<T>(elementCondition(expectedValue));
	final which = failure.rejection.which;
	return Rejection(
	which: [
	'does not have an element at index $i that:',
	...innerDescription,
	...prefixFirst(
	'Actual element at index $i: ',
	failure.rejection.actual,
	),
	if (which != null) ...prefixFirst('Which: ', which),
	],
	);
	}
	if (!iterator.moveNext()) return null;
	return Rejection(
	which: ['has too many elements, expected exactly ${expected.length}'],
	);
	},
	);
	}
	}