// Copyright (c) 2015, the tuple 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.

// ignore_for_file: prefer_const_constructors

import 'package:test/test.dart';
import 'package:tuple/tuple.dart';

void main() {
  group(Tuple2, () {
    final t = Tuple2<int, String>(1, 'a');

    test('has the correct items', () {
      expect(t.item1, 1);
      expect(t.item2, 'a');
    });

    group('\'s fromList', () {
      test('throws when items is empty', () {
        expect(() => Tuple2<int, String>.fromList([]), throwsArgumentError);
      });

      test('throws when items has one value', () {
        expect(() => Tuple2<int, String>.fromList([1]), throwsArgumentError);
      });

      test('throws when items has three values', () {
        expect(() => Tuple2<int, String>.fromList([1, 'a', 3]),
            throwsArgumentError);
      });

      test('throws when first value is not an int', () {
        expect(
            () => Tuple2<int, String>.fromList(['a', 'b']), throwsA(anything));
      });

      test('throws when second value is not a string', () {
        expect(() => Tuple2<int, String>.fromList([1, 2.0]), throwsA(anything));
      });
    });

    test('returns correct tuple from withItem1', () {
      expect(t.withItem1(2), Tuple2<int, String>(2, 'a'));
    });

    test('returns correct tuple from withItem2', () {
      expect(t.withItem2('b'), Tuple2<int, String>(1, 'b'));
    });

    group('\'s toList', () {
      test('returns fixed list by default', () {
        final list = t.toList();
        expect(list, orderedEquals([1, 'a']));
        expect(() => list.add(1), throwsA(isA<UnsupportedError>()));
      });

      test('returns growable list when told so', () {
        expect(
            t.toList(growable: true)..add('b'), orderedEquals([1, 'a', 'b']));
      });
    });

    test('converts to proper string', () {
      expect('$t', '[1, a]');
    });

    test('does not equal when first value is different', () {
      expect(t == t.withItem1(2), isFalse);
    });

    test('does not equal when second value is different', () {
      expect(t == t.withItem2('b'), isFalse);
    });

    test('does not equal when both values are different', () {
      expect(t == Tuple2<int, String>(2, 'b'), isFalse);
    });

    test('equals itself', () {
      expect(t == t, isTrue);
    });

    test('equals another object with same values', () {
      expect(t == Tuple2<int, String>(1, 'a'), isTrue);
    });

    test('can be used as a map key', () {
      final map = <Tuple2<int, String>, int>{};
      map[t] = 101;
      expect(map[Tuple2<int, String>(1, 'a')], 101);
    });
  });

  group(Tuple3, () {
    final t = Tuple3<int, String, int>(1, 'a', 10);

    test('has the correct items', () {
      expect(t.item1, 1);
      expect(t.item2, 'a');
      expect(t.item3, 10);
    });

    group('\'s fromList', () {
      test('throws when items is empty', () {
        expect(
            () => Tuple3<int, String, int>.fromList([]), throwsArgumentError);
      });

      test('throws when items has one value', () {
        expect(
            () => Tuple3<int, String, int>.fromList([1]), throwsArgumentError);
      });

      test('throws when items has two values', () {
        expect(() => Tuple3<int, String, int>.fromList([1, 'a']),
            throwsArgumentError);
      });

      test('throws when items has four values', () {
        expect(() => Tuple3<int, String, int>.fromList([1, 'a', 2, 3]),
            throwsArgumentError);
      });

      test('throws when first value is not an int', () {
        expect(() => Tuple3<int, String, int>.fromList(['', 'a', 10]),
            throwsA(anything));
      });

      test('throws when second value is not a string', () {
        expect(() => Tuple3<int, String, int>.fromList([1, 2, 10]),
            throwsA(anything));
      });

      test('throws when third value is not an int', () {
        expect(() => Tuple3<int, String, int>.fromList([1, 'a', 'b']),
            throwsA(anything));
      });
    });

    test('returns correct tuple from withItem1', () {
      expect(t.withItem1(2), Tuple3<int, String, int>(2, 'a', 10));
    });

    test('returns correct tuple from withItem2', () {
      expect(t.withItem2('b'), Tuple3<int, String, int>(1, 'b', 10));
    });

    test('returns correct tuple from withItem3', () {
      expect(t.withItem3(100), Tuple3<int, String, int>(1, 'a', 100));
    });

    group('\'s toList', () {
      test('returns fixed list by default', () {
        final list = t.toList();
        expect(list, orderedEquals([1, 'a', 10]));
        expect(() => list.add(1), throwsA(isA<UnsupportedError>()));
      });

      test('returns growable list when told so', () {
        expect(t.toList(growable: true)..add('b'),
            orderedEquals([1, 'a', 10, 'b']));
      });
    });

    test('converts to proper string', () {
      expect('$t', '[1, a, 10]');
    });

    test('does not equal when first value is different', () {
      expect(t == t.withItem1(2), isFalse);
    });

    test('does not equal when second value is different', () {
      expect(t == t.withItem2('b'), isFalse);
    });

    test('does not equal when third value is different', () {
      expect(t == t.withItem3(100), isFalse);
    });

    test('equals itself', () {
      expect(t == t, isTrue);
    });

    test('equals another object with same values', () {
      expect(t == Tuple3<int, String, int>(1, 'a', 10), isTrue);
    });

    test('can be used as a map key', () {
      final map = <Tuple3<int, String, int>, int>{};
      map[t] = 101;
      expect(map[Tuple3<int, String, int>(1, 'a', 10)], 101);
    });
  });

  group(Tuple4, () {
    final t = Tuple4<int, String, int, String>(1, 'a', 10, 'b');

    test('has the correct items', () {
      expect(t.item1, 1);
      expect(t.item2, 'a');
      expect(t.item3, 10);
      expect(t.item4, 'b');
    });

    group('\'s fromList', () {
      test('throws when items is empty', () {
        expect(() => Tuple4<int, String, int, String>.fromList([]),
            throwsArgumentError);
      });

      test('throws when items has one value', () {
        expect(() => Tuple4<int, String, int, String>.fromList([1]),
            throwsArgumentError);
      });

      test('throws when items has two values', () {
        expect(() => Tuple4<int, String, int, String>.fromList([1, 'a']),
            throwsArgumentError);
      });

      test('throws when items has three values', () {
        expect(() => Tuple4<int, String, int, String>.fromList([1, 'a', 2]),
            throwsArgumentError);
      });

      test('throws when items has five values', () {
        expect(
            () =>
                Tuple4<int, String, int, String>.fromList([1, 'a', 2, 'b', 3]),
            throwsArgumentError);
      });

      test('throws when first value is not an int', () {
        expect(
            () => Tuple4<int, String, int, String>.fromList(['', 'a', 2, 'b']),
            throwsA(anything));
      });

      test('throws when second value is not a string', () {
        expect(() => Tuple4<int, String, int, String>.fromList([1, 2, 3, 'b']),
            throwsA(anything));
      });

      test('throws when third value is not an int', () {
        expect(
            () => Tuple4<int, String, int, String>.fromList([1, 'a', 'b', 2]),
            throwsA(anything));
      });

      test('throws when fourth value is not a string', () {
        expect(() => Tuple4<int, String, int, String>.fromList([1, 'a', 2, 3]),
            throwsA(anything));
      });
    });

    test('returns correct tuple from withItem1', () {
      expect(t.withItem1(2), Tuple4<int, String, int, String>(2, 'a', 10, 'b'));
    });

    test('returns correct tuple from withItem2', () {
      expect(
          t.withItem2('b'), Tuple4<int, String, int, String>(1, 'b', 10, 'b'));
    });

    test('returns correct tuple from withItem3', () {
      expect(
          t.withItem3(100), Tuple4<int, String, int, String>(1, 'a', 100, 'b'));
    });

    test('returns correct tuple from withItem4', () {
      expect(
          t.withItem4('c'), Tuple4<int, String, int, String>(1, 'a', 10, 'c'));
    });

    group('\'s toList', () {
      test('returns fixed list by default', () {
        final list = t.toList();
        expect(list, orderedEquals([1, 'a', 10, 'b']));
        expect(() => list.add(1), throwsA(isA<UnsupportedError>()));
      });

      test('returns growable list when told so', () {
        expect(t.toList(growable: true)..add('c'),
            orderedEquals([1, 'a', 10, 'b', 'c']));
      });
    });

    test('converts to proper string', () {
      expect('$t', '[1, a, 10, b]');
    });

    test('does not equal when first value is different', () {
      expect(t == t.withItem1(2), isFalse);
    });

    test('does not equal when second value is different', () {
      expect(t == t.withItem2('b'), isFalse);
    });

    test('does not equal when third value is different', () {
      expect(t == t.withItem3(100), isFalse);
    });

    test('does not equal when fourth value is different', () {
      expect(t == t.withItem4('c'), isFalse);
    });

    test('equals itself', () {
      expect(t == t, isTrue);
    });

    test('equals another object with same values', () {
      expect(t == Tuple4<int, String, int, String>(1, 'a', 10, 'b'), isTrue);
    });

    test('can be used as a map key', () {
      final map = <Tuple4<int, String, int, String>, int>{};
      map[t] = 101;
      expect(map[Tuple4<int, String, int, String>(1, 'a', 10, 'b')], 101);
    });
  });

  group(Tuple5, () {
    final t = Tuple5<int, String, int, String, int>(1, 'a', 10, 'b', 100);

    test('has the correct items', () {
      expect(t.item1, 1);
      expect(t.item2, 'a');
      expect(t.item3, 10);
      expect(t.item4, 'b');
      expect(t.item5, 100);
    });

    group('\'s fromList', () {
      test('throws when items is empty', () {
        expect(() => Tuple5<int, String, int, String, int>.fromList([]),
            throwsArgumentError);
      });

      test('throws when items has one value', () {
        expect(() => Tuple5<int, String, int, String, int>.fromList([1]),
            throwsArgumentError);
      });

      test('throws when items has two values', () {
        expect(() => Tuple5<int, String, int, String, int>.fromList([1, 'a']),
            throwsArgumentError);
      });

      test('throws when items has three values', () {
        expect(
            () => Tuple5<int, String, int, String, int>.fromList([1, 'a', 2]),
            throwsArgumentError);
      });

      test('throws when items has four values', () {
        expect(
            () => Tuple5<int, String, int, String, int>.fromList(
                [1, 'a', 2, 'b']),
            throwsArgumentError);
      });

      test('throws when items has six values', () {
        expect(
            () => Tuple5<int, String, int, String, int>.fromList(
                [1, 'a', 2, 'b', 3, 'c']),
            throwsArgumentError);
      });

      test('throws when first value is not an int', () {
        expect(
            () => Tuple5<int, String, int, String, int>.fromList(
                ['z', 'a', 2, 'b', 3]),
            throwsA(anything));
      });

      test('throws when second value is not a string', () {
        expect(
            () => Tuple5<int, String, int, String, int>.fromList(
                [1, 0, 2, 'b', 3]),
            throwsA(anything));
      });

      test('throws when third value is not an int', () {
        expect(
            () => Tuple5<int, String, int, String, int>.fromList(
                [1, 'a', 'z', 'b', 3]),
            throwsA(anything));
      });

      test('throws when fourth value is not a string', () {
        expect(
            () => Tuple5<int, String, int, String, int>.fromList(
                [1, 'a', 2, 0, 3]),
            throwsA(anything));
      });

      test('throws when fifth value is not an int', () {
        expect(
            () => Tuple5<int, String, int, String, int>.fromList(
                [1, 'a', 2, 'b', 'z']),
            throwsA(anything));
      });
    });

    test('returns correct tuple from withItem1', () {
      expect(t.withItem1(2),
          Tuple5<int, String, int, String, int>(2, 'a', 10, 'b', 100));
    });

    test('returns correct tuple from withItem2', () {
      expect(t.withItem2('b'),
          Tuple5<int, String, int, String, int>(1, 'b', 10, 'b', 100));
    });

    test('returns correct tuple from withItem3', () {
      expect(t.withItem3(100),
          Tuple5<int, String, int, String, int>(1, 'a', 100, 'b', 100));
    });

    test('returns correct tuple from withItem4', () {
      expect(t.withItem4('c'),
          Tuple5<int, String, int, String, int>(1, 'a', 10, 'c', 100));
    });

    test('returns correct tuple from withItem5', () {
      expect(t.withItem5(4),
          Tuple5<int, String, int, String, int>(1, 'a', 10, 'b', 4));
    });

    group('\'s toList', () {
      test('returns fixed list by default', () {
        final list = t.toList();
        expect(list, orderedEquals([1, 'a', 10, 'b', 100]));
        expect(() => list.add(1), throwsA(isA<UnsupportedError>()));
      });

      test('returns growable list when told so', () {
        expect(t.toList(growable: true)..add('c'),
            orderedEquals([1, 'a', 10, 'b', 100, 'c']));
      });
    });

    test('converts to proper string', () {
      expect('$t', '[1, a, 10, b, 100]');
    });

    test('does not equal when first value is different', () {
      expect(t == t.withItem1(2), isFalse);
    });

    test('does not equal when second value is different', () {
      expect(t == t.withItem2('b'), isFalse);
    });

    test('does not equal when third value is different', () {
      expect(t == t.withItem3(100), isFalse);
    });

    test('does not equal when fourth value is different', () {
      expect(t == t.withItem4('c'), isFalse);
    });

    test('does not equal when fifth value is different', () {
      expect(t == t.withItem5(0), isFalse);
    });

    test('equals itself', () {
      expect(t == t, isTrue);
    });

    test('equals another object with same values', () {
      expect(t == Tuple5<int, String, int, String, int>(1, 'a', 10, 'b', 100),
          isTrue);
    });

    test('can be used as a map key', () {
      final map = <Tuple5<int, String, int, String, int>, int>{};
      map[t] = 101;
      expect(map[Tuple5<int, String, int, String, int>(1, 'a', 10, 'b', 100)],
          101);
    });
  });

  group(Tuple6, () {
    final t = Tuple6<int, String, int, String, int, String>(
        1, 'a', 10, 'b', 100, 'c');

    test('has the correct items', () {
      expect(t.item1, 1);
      expect(t.item2, 'a');
      expect(t.item3, 10);
      expect(t.item4, 'b');
      expect(t.item5, 100);
      expect(t.item6, 'c');
    });

    group('\'s fromList', () {
      test('throws when items is empty', () {
        expect(() => Tuple6<int, String, int, String, int, String>.fromList([]),
            throwsArgumentError);
      });

      test('throws when items has one value', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList([1]),
            throwsArgumentError);
      });

      test('throws when items has two values', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList(
                [1, 'a']),
            throwsArgumentError);
      });

      test('throws when items has three values', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList(
                [1, 'a', 2]),
            throwsArgumentError);
      });

      test('throws when items has four values', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList(
                [1, 'a', 2, 'b']),
            throwsArgumentError);
      });

      test('throws when items has five values', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList(
                [1, 'a', 2, 'b', 3]),
            throwsArgumentError);
      });

      test('throws when items has seven values', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList(
                [1, 'a', 2, 'b', 3, 'c', 4]),
            throwsArgumentError);
      });

      test('throws when first value is not an int', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList(
                ['z', 'a', 2, 'b', 3, 'c']),
            throwsA(anything));
      });

      test('throws when second value is not a string', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList(
                [1, 0, 2, 'b', 3, 'c']),
            throwsA(anything));
      });

      test('throws when third value is not an int', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList(
                [1, 'a', 'z', 'b', 3, 'c']),
            throwsA(anything));
      });

      test('throws when fourth value is not a string', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList(
                [1, 'a', 2, 0, 3, 'c']),
            throwsA(anything));
      });

      test('throws when fifth value is not an int', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList(
                [1, 'a', 2, 'b', 'z', 'c']),
            throwsA(anything));
      });

      test('throws when sixth value is not a string', () {
        expect(
            () => Tuple6<int, String, int, String, int, String>.fromList(
                [1, 'a', 2, 'b', 3, 4]),
            throwsA(anything));
      });
    });

    test('returns correct tuple from withItem1', () {
      expect(
          t.withItem1(2),
          Tuple6<int, String, int, String, int, String>(
              2, 'a', 10, 'b', 100, 'c'));
    });

    test('returns correct tuple from withItem2', () {
      expect(
          t.withItem2('b'),
          Tuple6<int, String, int, String, int, String>(
              1, 'b', 10, 'b', 100, 'c'));
    });

    test('returns correct tuple from withItem3', () {
      expect(
          t.withItem3(100),
          Tuple6<int, String, int, String, int, String>(
              1, 'a', 100, 'b', 100, 'c'));
    });

    test('returns correct tuple from withItem4', () {
      expect(
          t.withItem4('c'),
          Tuple6<int, String, int, String, int, String>(
              1, 'a', 10, 'c', 100, 'c'));
    });

    test('returns correct tuple from withItem5', () {
      expect(
          t.withItem5(4),
          Tuple6<int, String, int, String, int, String>(
              1, 'a', 10, 'b', 4, 'c'));
    });

    test('returns correct tuple from withItem6', () {
      expect(
          t.withItem6('z'),
          Tuple6<int, String, int, String, int, String>(
              1, 'a', 10, 'b', 100, 'z'));
    });

    group('\'s toList', () {
      test('returns fixed list by default', () {
        final list = t.toList();
        expect(list, orderedEquals([1, 'a', 10, 'b', 100, 'c']));
        expect(() => list.add(1), throwsA(isA<UnsupportedError>()));
      });

      test('returns growable list when told so', () {
        expect(t.toList(growable: true)..add(1),
            orderedEquals([1, 'a', 10, 'b', 100, 'c', 1]));
      });
    });

    test('converts to proper string', () {
      expect('$t', '[1, a, 10, b, 100, c]');
    });

    test('does not equal when first value is different', () {
      expect(t == t.withItem1(2), isFalse);
    });

    test('does not equal when second value is different', () {
      expect(t == t.withItem2('b'), isFalse);
    });

    test('does not equal when third value is different', () {
      expect(t == t.withItem3(100), isFalse);
    });

    test('does not equal when fourth value is different', () {
      expect(t == t.withItem4('c'), isFalse);
    });

    test('does not equal when fifth value is different', () {
      expect(t == t.withItem5(0), isFalse);
    });

    test('does not equal when sixth value is different', () {
      expect(t == t.withItem6('z'), isFalse);
    });

    test('equals itself', () {
      expect(t == t, isTrue);
    });

    test('equals another object with same values', () {
      expect(
          t ==
              Tuple6<int, String, int, String, int, String>(
                  1, 'a', 10, 'b', 100, 'c'),
          isTrue);
    });

    test('can be used as a map key', () {
      final map = <Tuple6<int, String, int, String, int, String>, int>{};
      map[t] = 101;
      expect(
          map[Tuple6<int, String, int, String, int, String>(
              1, 'a', 10, 'b', 100, 'c')],
          101);
    });
  });

  group(Tuple7, () {
    final t = Tuple7<int, String, int, String, int, String, int>(
        1, 'a', 10, 'b', 100, 'c', 1000);

    test('has the correct items', () {
      expect(t.item1, 1);
      expect(t.item2, 'a');
      expect(t.item3, 10);
      expect(t.item4, 'b');
      expect(t.item5, 100);
      expect(t.item6, 'c');
      expect(t.item7, 1000);
    });

    group('\'s fromList', () {
      test('throws when items is empty', () {
        expect(
            () =>
                Tuple7<int, String, int, String, int, String, int>.fromList([]),
            throwsArgumentError);
      });

      test('throws when items has one value', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1]),
            throwsArgumentError);
      });

      test('throws when items has two values', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 'a']),
            throwsArgumentError);
      });

      test('throws when items has three values', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 'a', 2]),
            throwsArgumentError);
      });

      test('throws when items has four values', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 'a', 2, 'b']),
            throwsArgumentError);
      });

      test('throws when items has five values', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 'a', 2, 'b', 3]),
            throwsArgumentError);
      });

      test('throws when items has six values', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 'a', 2, 'b', 3, 'c']),
            throwsArgumentError);
      });

      test('throws when items has eight values', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 'a', 2, 'b', 3, 'c', 4, 'd']),
            throwsArgumentError);
      });

      test('throws when first value is not an int', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                ['z', 'a', 2, 'b', 3, 'c', 4]),
            throwsA(anything));
      });

      test('throws when second value is not a string', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 0, 2, 'b', 3, 'c', 4]),
            throwsA(anything));
      });

      test('throws when third value is not an int', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 'a', 'z', 'b', 3, 'c', 4]),
            throwsA(anything));
      });

      test('throws when fourth value is not a string', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 'a', 2, 0, 3, 'c', 4]),
            throwsA(anything));
      });

      test('throws when fifth value is not an int', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 'a', 2, 'b', 'z', 'c', 4]),
            throwsA(anything));
      });

      test('throws when sixth value is not a string', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 'a', 2, 'b', 3, 4, 5]),
            throwsA(anything));
      });

      test('throws when seventh value is not an int', () {
        expect(
            () => Tuple7<int, String, int, String, int, String, int>.fromList(
                [1, 'a', 2, 'b', 3, 'c', 'd']),
            throwsA(anything));
      });
    });

    test('returns correct tuple from withItem1', () {
      expect(
          t.withItem1(2),
          Tuple7<int, String, int, String, int, String, int>(
              2, 'a', 10, 'b', 100, 'c', 1000));
    });

    test('returns correct tuple from withItem2', () {
      expect(
          t.withItem2('b'),
          Tuple7<int, String, int, String, int, String, int>(
              1, 'b', 10, 'b', 100, 'c', 1000));
    });

    test('returns correct tuple from withItem3', () {
      expect(
          t.withItem3(100),
          Tuple7<int, String, int, String, int, String, int>(
              1, 'a', 100, 'b', 100, 'c', 1000));
    });

    test('returns correct tuple from withItem4', () {
      expect(
          t.withItem4('c'),
          Tuple7<int, String, int, String, int, String, int>(
              1, 'a', 10, 'c', 100, 'c', 1000));
    });

    test('returns correct tuple from withItem5', () {
      expect(
          t.withItem5(4),
          Tuple7<int, String, int, String, int, String, int>(
              1, 'a', 10, 'b', 4, 'c', 1000));
    });

    test('returns correct tuple from withItem6', () {
      expect(
          t.withItem6('z'),
          Tuple7<int, String, int, String, int, String, int>(
              1, 'a', 10, 'b', 100, 'z', 1000));
    });

    test('returns correct tuple from withItem7', () {
      expect(
          t.withItem7(0),
          Tuple7<int, String, int, String, int, String, int>(
              1, 'a', 10, 'b', 100, 'c', 0));
    });

    group('\'s toList', () {
      test('returns fixed list by default', () {
        final list = t.toList();
        expect(list, orderedEquals([1, 'a', 10, 'b', 100, 'c', 1000]));
        expect(() => list.add(1), throwsA(isA<UnsupportedError>()));
      });

      test('returns growable list when told so', () {
        expect(t.toList(growable: true)..add(1),
            orderedEquals([1, 'a', 10, 'b', 100, 'c', 1000, 1]));
      });
    });

    test('converts to proper string', () {
      expect('$t', '[1, a, 10, b, 100, c, 1000]');
    });

    test('does not equal when first value is different', () {
      expect(t == t.withItem1(2), isFalse);
    });

    test('does not equal when second value is different', () {
      expect(t == t.withItem2('b'), isFalse);
    });

    test('does not equal when third value is different', () {
      expect(t == t.withItem3(100), isFalse);
    });

    test('does not equal when fourth value is different', () {
      expect(t == t.withItem4('c'), isFalse);
    });

    test('does not equal when fifth value is different', () {
      expect(t == t.withItem5(0), isFalse);
    });

    test('does not equal when sixth value is different', () {
      expect(t == t.withItem6('z'), isFalse);
    });

    test('does not equal when seventh value is different', () {
      expect(t == t.withItem7(0), isFalse);
    });

    test('equals itself', () {
      expect(t == t, isTrue);
    });

    test('equals another object with same values', () {
      expect(
          t ==
              Tuple7<int, String, int, String, int, String, int>(
                  1, 'a', 10, 'b', 100, 'c', 1000),
          isTrue);
    });

    test('can be used as a map key', () {
      final map = <Tuple7<int, String, int, String, int, String, int>, int>{};
      map[t] = 101;
      expect(
          map[Tuple7<int, String, int, String, int, String, int>(
              1, 'a', 10, 'b', 100, 'c', 1000)],
          101);
    });
  });
}