sdk/pkg/_macros/test/executor/cast_test.dart

// Copyright (c) 2023, 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 'package:_macros/src/executor/cast.dart';

void main() {
  test("dynamic casts", () {
    expect(Cast<dynamic>().cast(3), 3);
    expect(Cast<dynamic>().cast("hello"), "hello");
  });

  test("int casts", () {
    expect(Cast<int>().cast(3), 3);
    expect(
        () => Cast<int>().cast("hello"),
        throwsA(isA<FailedCast>().having((e) => e.toString(), 'toString()',
            'Failed cast: expected type int but got type String for: hello')));
  });

  test("double casts", () {
    expect(Cast<double>().cast(3.1), 3.1);
    expect(
        () => Cast<double>().cast("hello"),
        throwsA(isA<FailedCast>().having(
            (e) => e.toString(),
            'toString()',
            'Failed cast: '
                'expected type double but got type String for: hello')));
  });

  test("String casts", () {
    expect(Cast<String>().cast("hello"), "hello");
    expect(
        () => Cast<String>().cast(3),
        throwsA(isA<FailedCast>().having((e) => e.toString(), 'toString()',
            'Failed cast: expected type String but got type int for: 3')));
  });

  test("bool casts", () {
    expect(Cast<bool>().cast(true), true);
    expect(
        () => Cast<bool>().cast(3),
        throwsA(isA<FailedCast>().having((e) => e.toString(), 'toString()',
            'Failed cast: expected type bool but got type int for: 3')));
  });

  test("Casting empty lists", () {
    var listOfInt = ListCast.from(Cast<int>());
    var listOfString = ListCast.from(Cast<String>());

    expect(listOfInt.cast(<dynamic>[]) is List<int>, isTrue);
    expect(listOfInt.cast(<dynamic>[]), <int>[]);

    expect(
        () => listOfString.cast({}),
        throwsA(isA<FailedCast>().having(
            (e) => e.toString(),
            'toString()',
            'Failed cast: expected type List<String> but got '
                'type _Map<dynamic, dynamic> for: {}')));
  });

  test("Casting non-empty lists", () {
    var listOfInt = ListCast.from(Cast<int>());
    var listOfString = ListCast.from(Cast<String>());

    expect(listOfInt.cast(<num>[3]) is List<int>, isTrue);
    expect(listOfInt.cast(<num>[3]), <int>[3]);
    expect(
        () => listOfString.cast(<num>[3]),
        throwsA(isA<FailedCast>().having((e) => e.toString(), 'toString()',
            'Failed cast: expected type String but got type int for: 3')));
  });

  test("Casting nested lists", () {
    var listOfInt = ListCast.from(Cast<int>());
    var listOfString = ListCast.from(Cast<String>());
    var listOfListOfInt = ListCast.from(listOfInt);
    var listOfListOfString = ListCast.from(listOfString);

    expect(
        listOfListOfInt.cast(<dynamic>[
          <dynamic>[3]
        ]) is List<List<int>>,
        isTrue);
    expect(
        listOfListOfInt.cast(<dynamic>[
          <dynamic>[3]
        ]),
        <List<int>>[
          <int>[3]
        ]);
    expect(
        () => listOfListOfString.cast(<dynamic>[
              <dynamic>[3]
            ]),
        throwsA(isA<FailedCast>().having((e) => e.toString(), 'toString()',
            'Failed cast: expected type String but got type int for: 3')));
  });

  test("Casting non-empty sets", () {
    var setOfInt = SetCast.from(Cast<int>());
    var setOfString = SetCast.from(Cast<String>());

    expect(setOfInt.cast(<num>{3}) is Set<int>, isTrue);
    expect(setOfInt.cast(<num>{3}), <int>{3});
    expect(
        () => setOfString.cast(<num>{3}),
        throwsA(isA<FailedCast>().having((e) => e.toString(), 'toString()',
            'Failed cast: expected type String but got type int for: 3')));
  });

  test("Casting nested sets", () {
    var setOfInt = SetCast.from(Cast<int>());
    var setOfString = SetCast.from(Cast<String>());
    var setOfSetOfInt = SetCast.from(setOfInt);
    var setOfSetOfString = SetCast.from(setOfString);

    expect(
        setOfSetOfInt.cast(<dynamic>{
          <dynamic>{3}
        }) is Set<Set<int>>,
        isTrue);
    expect(
        setOfSetOfInt.cast(<dynamic>{
          <dynamic>{3}
        }),
        <Set<int>>{
          <int>{3}
        });
    expect(
        () => setOfSetOfString.cast(<dynamic>{
              <dynamic>{3}
            }),
        throwsA(isA<FailedCast>().having((e) => e.toString(), 'toString()',
            'Failed cast: expected type String but got type int for: 3')));
  });

  test("Casting empty maps", () {
    var mapOfStringToInt = MapCast.from(Cast<String>(), Cast<int>());
    var mapOfStringToString = MapCast.from(Cast<String>(), Cast<String>());

    expect(mapOfStringToInt.cast(<dynamic, dynamic>{}) is Map<String, int>,
        isTrue);
    expect(mapOfStringToInt.cast(<dynamic, dynamic>{}), <String, int>{});

    expect(
        () => mapOfStringToString.cast(<dynamic>[]),
        throwsA(isA<FailedCast>().having(
            (e) => e.toString(),
            'toString()',
            'Failed cast: expected type Map<String, String> but got type '
                'List<dynamic> for: []')));
  });

  test("Casting non-empty maps", () {
    var mapOfStringToInt = MapCast.from(Cast<String>(), Cast<int>());
    var mapOfStringToString = MapCast.from(Cast<String>(), Cast<String>());

    expect(
        mapOfStringToInt.cast(<dynamic, dynamic>{"hello": 3})
            is Map<String, int>,
        isTrue);
    expect(mapOfStringToInt.cast(<dynamic, dynamic>{"hello": 3}),
        <String, int>{"hello": 3});

    expect(() => mapOfStringToString.cast(<dynamic, dynamic>{"hello": 3}),
        throwsA(isA<FailedCast>()));
    expect(
        () => mapOfStringToString.cast(<dynamic, dynamic>{3: "world"}),
        throwsA(isA<FailedCast>().having((e) => e.toString(), 'toString()',
            'Failed cast: expected type String but got type int for: 3')));
  });

  test("Casting nested maps", () {
    var schema =
        MapCast.from(Cast<String>(), MapCast.from(Cast<String>(), Cast<int>()));

    expect(
        schema.cast(<dynamic, dynamic>{
          "hello": <dynamic, dynamic>{"hello": 3}
        }) is Map<String, Map<String, int>>,
        isTrue);
    expect(
        schema.cast(<dynamic, dynamic>{
          "hello": <dynamic, dynamic>{"hello": 3}
        }),
        <String, Map<String, int>>{
          "hello": <String, int>{"hello": 3}
        });

    expect(
        () => schema.cast(<dynamic, dynamic>{
              "hello": <dynamic, dynamic>{3: "hello"}
            }),
        throwsA(isA<FailedCast>().having((e) => e.toString(), 'toString()',
            'Failed cast: expected type String but got type int for: 3')));
  });

  test("Casting nested list/maps/sets", () {
    var schema =
        MapCast.from(Cast<String>(), ListCast.from(SetCast.from(Cast<int>())));

    expect(
        schema.cast(<dynamic, dynamic>{
          "hello": <dynamic>[
            {3}
          ]
        }) is Map<String, List<Set<int>>>,
        isTrue);
    expect(
        schema.cast(<dynamic, dynamic>{
          "hello": <dynamic>[
            {3}
          ]
        }),
        <String, List<Set<int>>>{
          "hello": <Set<int>>[
            {3}
          ]
        });
  });

  test("nullable cast", () {
    expect(Cast<int>().nullable.cast(null), null);
    expect(Cast<int>().nullable.cast(3), 3);
    expect(ListCast.from(Cast<int>()).nullable.cast(<num>[3]), <int>[3]);
    expect(ListCast.from(Cast<int>().nullable).cast(<num?>[3, null]),
        <int?>[3, null]);
    expect(
        () => Cast<int>().nullable.cast(2.0),
        throwsA(isA<FailedCast>().having((e) => e.toString(), 'toString()',
            'Failed cast: expected type int but got type double for: 2.0')));
    expect(
        () => ListCast.from(Cast<int>()).nullable.cast([2.0]),
        throwsA(isA<FailedCast>().having((e) => e.toString(), 'toString()',
            'Failed cast: expected type int but got type double for: 2.0')));
  });
}