0.5.0 added shouldContainAllInOrder

Author: klisiewicz

lib/src/iterable/iterable_assertions.dart

@@ -27,6 +27,13 @@ extension IterableAssertions<T> on Iterable<T> {
   void shouldContainAll(Iterable<T> expected) {
     expect(this, containsAll(expected));
   }
+
+  /// Asserts that [Iterable] contains an element matching every value in
+  /// [expected] in the same order, but may contain additional values
+  /// interleaved throughout.
+  void shouldContainAllInOrder(Iterable<T> expected) {
+    expect(this, containsAllInOrder(expected));
+  }
 }
 
 extension IterableStringAssertions on Iterable<String> {

test/src/iterable/iterable_assertions_test.dart

@@ -188,6 +188,37 @@ void main() {
         );
       });
     });
+
+    group('should contain all in order', () {
+      test('should return normally when contains all in order', () {
+        expect(
+          () => capitals.shouldContainAllInOrder(['Berlin']),
+          returnsNormally,
+        );
+        expect(
+          () => capitals.shouldContainAllInOrder(['Berlin', 'Warsaw']),
+          returnsNormally,
+        );
+      });
+
+      test('should fail when contains all not in order', () {
+        expect(
+          () => capitals.shouldContainAllInOrder(['Warsaw', 'Berlin']),
+          failsTest,
+        );
+      });
+
+      test('should fail when not contain all', () {
+        expect(
+          () => capitals.shouldContainAllInOrder(['Barcelona']),
+          failsTest,
+        );
+        expect(
+          () => capitals.shouldContainAllInOrder(['Berlin, Barcelona']),
+          failsTest,
+        );
+      });
+    });
   });
 
   group('numbers', () {
@@ -279,6 +310,37 @@ void main() {
         );
       });
     });
+
+    group('should contain all in order', () {
+      test('should return normally when contains all in order', () {
+        expect(
+          () => primes.shouldContainAllInOrder([2]),
+          returnsNormally,
+        );
+        expect(
+          () => primes.shouldContainAllInOrder([2, 3]),
+          returnsNormally,
+        );
+      });
+
+      test('should fail when contains all not in order', () {
+        expect(
+          () => primes.shouldContainAllInOrder([5, 2, 7]),
+          failsTest,
+        );
+      });
+
+      test('should fail when not contain all', () {
+        expect(
+          () => primes.shouldContainAllInOrder([1]),
+          failsTest,
+        );
+        expect(
+          () => primes.shouldContainAllInOrder([3, 2, 1]),
+          failsTest,
+        );
+      });
+    });
   });
 
   group('objects', () {
@@ -386,5 +448,36 @@ void main() {
         );
       });
     });
+
+    group('should contain all', () {
+      test('should return normally when contains all in order', () {
+        expect(
+          () => [alice, bob].shouldContainAllInOrder([alice]),
+          returnsNormally,
+        );
+        expect(
+          () => [alice, bob].shouldContainAllInOrder([alice, bob]),
+          returnsNormally,
+        );
+      });
+
+      test('should fail when contains all not in order', () {
+        expect(
+          () => [alice, bob].shouldContainAllInOrder([bob, alice]),
+          failsTest,
+        );
+      });
+
+      test('should fail when not contain all', () {
+        expect(
+          () => [alice, bob].shouldContainAllInOrder([jimmy]),
+          failsTest,
+        );
+        expect(
+          () => [alice, bob].shouldContainAllInOrder([alice, bob, jimmy]),
+          failsTest,
+        );
+      });
+    });
   });
 }