// Copyright (c) 2015, 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 'package:test/test.dart';

import '../../utils.dart';

void main() {
  group('[throwsArgumentError]', () {
    test('passes when a ArgumentError is thrown', () {
      expect(() => throw ArgumentError(''), throwsArgumentError);
    });

    test('fails when a non-ArgumentError is thrown', () async {
      var liveTest = await runTestBody(() {
        expect(() => throw Exception(), throwsArgumentError);
      });

      expectTestFailed(liveTest,
          startsWith("Expected: throws <Instance of 'ArgumentError'>"));
    });
  });

  group('[throwsConcurrentModificationError]', () {
    test('passes when a ConcurrentModificationError is thrown', () {
      expect(() => throw ConcurrentModificationError(''),
          throwsConcurrentModificationError);
    });

    test('fails when a non-ConcurrentModificationError is thrown', () async {
      var liveTest = await runTestBody(() {
        expect(() => throw Exception(), throwsConcurrentModificationError);
      });

      expectTestFailed(
          liveTest,
          startsWith(
              "Expected: throws <Instance of 'ConcurrentModificationError'>"));
    });
  });

  group('[throwsCyclicInitializationError]', () {
    test('passes when a CyclicInitializationError is thrown', () {
      expect(() => throw CyclicInitializationError(''),
          throwsCyclicInitializationError);
    });

    test('fails when a non-CyclicInitializationError is thrown', () async {
      var liveTest = await runTestBody(() {
        expect(() => throw Exception(), throwsCyclicInitializationError);
      });

      expectTestFailed(
          liveTest,
          startsWith(
              "Expected: throws <Instance of 'CyclicInitializationError'>"));
    });
  });

  group('[throwsException]', () {
    test('passes when a Exception is thrown', () {
      expect(() => throw Exception(''), throwsException);
    });

    test('fails when a non-Exception is thrown', () async {
      var liveTest = await runTestBody(() {
        expect(() => throw 'oh no', throwsException);
      });

      expectTestFailed(
          liveTest, startsWith("Expected: throws <Instance of 'Exception'>"));
    });
  });

  group('[throwsFormatException]', () {
    test('passes when a FormatException is thrown', () {
      expect(() => throw FormatException(''), throwsFormatException);
    });

    test('fails when a non-FormatException is thrown', () async {
      var liveTest = await runTestBody(() {
        expect(() => throw Exception(), throwsFormatException);
      });

      expectTestFailed(liveTest,
          startsWith("Expected: throws <Instance of 'FormatException'>"));
    });
  });

  group('[throwsNoSuchMethodError]', () {
    test('passes when a NoSuchMethodError is thrown', () {
      expect(() {
        (1 as dynamic).notAMethodOnInt();
      }, throwsNoSuchMethodError);
    });

    test('fails when a non-NoSuchMethodError is thrown', () async {
      var liveTest = await runTestBody(() {
        expect(() => throw Exception(), throwsNoSuchMethodError);
      });

      expectTestFailed(liveTest,
          startsWith("Expected: throws <Instance of 'NoSuchMethodError'>"));
    });
  });

  group('[throwsNullThrownError]', () {
    test('passes when a NullThrownError is thrown', () {
      // Throwing null is no longer allowed with NNBD, but we do want to allow
      // it from legacy code and should be able to catch those errors.
      expect(() => throw NullThrownError(), throwsNullThrownError);
    });

    test('fails when a non-NullThrownError is thrown', () async {
      var liveTest = await runTestBody(() {
        expect(() => throw Exception(), throwsNullThrownError);
      });

      expectTestFailed(liveTest,
          startsWith("Expected: throws <Instance of '$NullThrownError'>"));
    });
  });

  group('[throwsRangeError]', () {
    test('passes when a RangeError is thrown', () {
      expect(() => throw RangeError(''), throwsRangeError);
    });

    test('fails when a non-RangeError is thrown', () async {
      var liveTest = await runTestBody(() {
        expect(() => throw Exception(), throwsRangeError);
      });

      expectTestFailed(
          liveTest, startsWith("Expected: throws <Instance of 'RangeError'>"));
    });
  });

  group('[throwsStateError]', () {
    test('passes when a StateError is thrown', () {
      expect(() => throw StateError(''), throwsStateError);
    });

    test('fails when a non-StateError is thrown', () async {
      var liveTest = await runTestBody(() {
        expect(() => throw Exception(), throwsStateError);
      });

      expectTestFailed(
          liveTest, startsWith("Expected: throws <Instance of 'StateError'>"));
    });
  });

  group('[throwsUnimplementedError]', () {
    test('passes when a UnimplementedError is thrown', () {
      expect(() => throw UnimplementedError(''), throwsUnimplementedError);
    });

    test('fails when a non-UnimplementedError is thrown', () async {
      var liveTest = await runTestBody(() {
        expect(() => throw Exception(), throwsUnimplementedError);
      });

      expectTestFailed(liveTest,
          startsWith("Expected: throws <Instance of 'UnimplementedError'>"));
    });
  });

  group('[throwsUnsupportedError]', () {
    test('passes when a UnsupportedError is thrown', () {
      expect(() => throw UnsupportedError(''), throwsUnsupportedError);
    });

    test('fails when a non-UnsupportedError is thrown', () async {
      var liveTest = await runTestBody(() {
        expect(() => throw Exception(), throwsUnsupportedError);
      });

      expectTestFailed(liveTest,
          startsWith("Expected: throws <Instance of 'UnsupportedError'>"));
    });
  });
}