packages/quiver/test/check_test.dart

// 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');
      });
    });
  });
}