Roll Observatory packages and add a roll script

packages/quiver/test/check_test.dart

Index: packages/quiver/test/check_test.dart
diff --git a/packages/quiver/test/check_test.dart b/packages/quiver/test/check_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..8257cbdd46173a55b076d56396abd27e64856a7c
--- /dev/null
+++ b/packages/quiver/test/check_test.dart
@@ -0,0 +1,182 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+library quiver.check_test;
+
+import 'package:quiver/check.dart';
+import 'package:test/test.dart';
+
+main() {
+  group('checkArgument', () {
+    group('success', () {
+      test('simple', () => checkArgument(true));
+      test('null message', () => checkArgument(true, message: null));
+      test('string message', () => checkArgument(true, message: 'foo'));
+      test('function message', () =>
+          checkArgument(true, message: () => fail("Shouldn't be called")));
+    });
+
+    group('failure', () {
+      checkArgumentShouldFail(Function f, [String expectedMessage]) {
+        try {
+          f();
+          fail('Should have thrown an ArgumentError');
+        } catch (e) {
+          expect(e, isArgumentError);
+          expect(e.message, expectedMessage);
+        }
+      }
+
+      test('no message',
+          () => checkArgumentShouldFail(() => checkArgument(false)));
+
+      test('failure and simple string message', () => checkArgumentShouldFail(
+          () => checkArgument(false, message: 'message'), 'message'));
+
+      test('failure and null message', () =>
+          checkArgumentShouldFail(() => checkArgument(false, message: null)));
+      test('failure and object as message', () =>
+          checkArgumentShouldFail(() => checkArgument(false, message: 5), '5'));
+      test('failure and message closure returns object',
+          () => checkArgumentShouldFail(
+              () => checkArgument(false, message: () => 5), '5'));
+
+      test('failure and message function', () {
+        int five = 5;
+        checkArgumentShouldFail(
+            () => checkArgument(false, message: () => 'I ate $five pies'),
+            'I ate 5 pies');
+      });
+    });
+  });
+
+  group('checkState', () {
+    group('success', () {
+      test('simple', () => checkState(true));
+      test('null message', () => checkState(true, message: null));
+      test('string message', () => checkState(true, message: 'foo'));
+      test('function message',
+          () => checkState(true, message: () => fail("Shouldn't be called")));
+    });
+
+    group('failure', () {
+      checkStateShouldFail(Function f, [String expectedMessage]) {
+        if (expectedMessage == null) expectedMessage = 'failed precondition';
+        try {
+          f();
+          fail('Should have thrown a StateError');
+        } catch (e) {
+          expect(e, isStateError);
+          expect(e.message, expectedMessage);
+        }
+      }
+
+      test('no message', () => checkStateShouldFail(() => checkState(false)));
+
+      test('failure and simple string message', () => checkStateShouldFail(
+          () => checkState(false, message: 'message'), 'message'));
+
+      test('failure and null message',
+          () => checkStateShouldFail(() => checkState(false, message: null)));
+      test('message closure returns null', () =>
+          checkStateShouldFail(() => checkState(false, message: () => null)));
+
+      test('failure and message function', () {
+        int five = 5;
+        checkStateShouldFail(
+            () => checkState(false, message: () => 'I ate $five pies'),
+            'I ate 5 pies');
+      });
+    });
+  });
+
+  group('checkNotNull', () {
+    group('success', () {
+      test('simple', () => expect(checkNotNull(''), ''));
+      test('string message', () => expect(checkNotNull(5, message: 'foo'), 5));
+      test('function message', () => expect(checkNotNull(true,
+          message: () => fail("Shouldn't be called")), true));
+    });
+
+    group('failure', () {
+      checkNotNullShouldFail(Function f, [String expectedMessage]) {
+        if (expectedMessage == null) expectedMessage = 'null pointer';
+        try {
+          f();
+          fail('Should have thrown an ArgumentError');
+        } catch (e) {
+          expect(e, isArgumentError);
+          expect(e.message, expectedMessage);
+        }
+      }
+
+      test(
+          'no message', () => checkNotNullShouldFail(() => checkNotNull(null)));
+
+      test('simple failure message', () => checkNotNullShouldFail(
+          () => checkNotNull(null, message: 'message'), 'message'));
+
+      test('null message', () =>
+          checkNotNullShouldFail(() => checkNotNull(null, message: null)));
+
+      test('message closure returns null', () => checkNotNullShouldFail(
+          () => checkNotNull(null, message: () => null)));
+
+      test('failure and message function', () {
+        int five = 5;
+        checkNotNullShouldFail(
+            () => checkNotNull(null, message: () => 'I ate $five pies'),
+            'I ate 5 pies');
+      });
+    });
+  });
+
+  group('checkListIndex', () {
+    test('success', () {
+      checkListIndex(0, 1);
+      checkListIndex(0, 1, message: () => fail("shouldn't be called"));
+      checkListIndex(0, 2);
+      checkListIndex(0, 2, message: () => fail("shouldn't be called"));
+      checkListIndex(1, 2);
+      checkListIndex(1, 2, message: () => fail("shouldn't be called"));
+    });
+
+    group('failure', () {
+      checkListIndexShouldFail(int index, int size,
+          [message, String expectedMessage]) {
+        try {
+          checkListIndex(index, size, message: message);
+          fail('Should have thrown a RangeError');
+        } catch (e) {
+          expect(e, isRangeError);
+          expect(e.message, expectedMessage == null
+              ? 'index $index not valid for list of size $size'
+              : expectedMessage);
+        }
+      }
+      test('negative size', () => checkListIndexShouldFail(0, -1));
+      test('negative index', () => checkListIndexShouldFail(-1, 1));
+      test('index too high', () => checkListIndexShouldFail(1, 1));
+      test('zero size', () => checkListIndexShouldFail(0, 0));
+
+      test('with failure message',
+          () => checkListIndexShouldFail(1, 1, 'foo', 'foo'));
+      test('with failure message function', () {
+        int five = 5;
+        checkListIndexShouldFail(
+            1, 1, () => 'I ate $five pies', 'I ate 5 pies');
+      });
+    });
+  });
+}