pkgs/code_builder/test/specs/class_test.dart

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

import '../common.dart';

void main() {
  useDartfmt();

  test('should create a class', () {
    expect(
      Class((b) => b..name = 'Foo'),
      equalsDart(r'''
        class Foo {}
      '''),
    );
  });

  test('should create an abstract class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..abstract = true),
      equalsDart(r'''
        abstract class Foo {}
      '''),
    );
  });

  test('should create an abstract base class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..abstract = true
        ..modifier = ClassModifier.base),
      equalsDart(r'''
        abstract base class Foo {}
      '''),
    );
  });

  test('should create a final class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..modifier = ClassModifier.final$),
      equalsDart(r'''
        final class Foo {}
      '''),
    );
  });

  test('should create a sealed class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..sealed = true),
      equalsDart(r'''
        sealed class Foo {}
      '''),
    );
  });

  test('should create an abstract interface class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..abstract = true
        ..modifier = ClassModifier.interface),
      equalsDart(r'''
        abstract interface class Foo {}
      '''),
    );
  });

  test('should create a mixin class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..mixin = true),
      equalsDart(r'''
        mixin class Foo {}
      '''),
    );
  });

  test('should create an abstract mixin class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..abstract = true
        ..mixin = true),
      equalsDart(r'''
        abstract mixin class Foo {}
      '''),
    );
  });

  test('should create a base mixin class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..mixin = true
        ..modifier = ClassModifier.base),
      equalsDart(r'''
        base mixin class Foo {}
      '''),
    );
  });

  test('should create an abstract base mixin class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..abstract = true
        ..mixin = true
        ..modifier = ClassModifier.base),
      equalsDart(r'''
        abstract base mixin class Foo {}
      '''),
    );
  });

  test('should create a class with documentations', () {
    expect(
      Class(
        (b) => b
          ..name = 'Foo'
          ..docs.addAll(
            const [
              '/// My favorite class.',
            ],
          ),
      ),
      equalsDart(r'''
        /// My favorite class.
        class Foo {}
      '''),
    );
  });

  test('should create a class with annotations', () {
    expect(
      Class(
        (b) => b
          ..name = 'Foo'
          ..annotations.addAll([
            refer('deprecated'),
            refer('Deprecated').call([literalString('This is an old class')])
          ]),
      ),
      equalsDart(r'''
        @deprecated
        @Deprecated('This is an old class')
        class Foo {}
      '''),
    );
  });

  test('should create a class with a generic type', () {
    expect(
      Class((b) => b
        ..name = 'List'
        ..types.add(refer('T'))),
      equalsDart(r'''
        class List<T> {}
      '''),
    );
  });

  test('should create a class with multiple generic types', () {
    expect(
      Class(
        (b) => b
          ..name = 'Map'
          ..types.addAll([
            refer('K'),
            refer('V'),
          ]),
      ),
      equalsDart(r'''
        class Map<K, V> {}
      '''),
    );
  });

  test('should create a class with a bound generic type', () {
    expect(
      Class((b) => b
        ..name = 'Comparable'
        ..types.add(TypeReference((b) => b
          ..symbol = 'T'
          ..bound = TypeReference((b) => b
            ..symbol = 'Comparable'
            ..types.add(refer('T').type))))),
      equalsDart(r'''
        class Comparable<T extends Comparable<T>> {}
      '''),
    );
  });

  test('should create a class extending another class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..extend = TypeReference((b) => b.symbol = 'Bar')),
      equalsDart(r'''
        class Foo extends Bar {}
      '''),
    );
  });

  test('should create a class mixing in another class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..extend = TypeReference((b) => b.symbol = 'Bar')
        ..mixins.add(TypeReference((b) => b.symbol = 'Foo'))),
      equalsDart(r'''
        class Foo extends Bar with Foo {}
      '''),
    );
  });

  test('should create a class implementing another class', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..extend = TypeReference((b) => b.symbol = 'Bar')
        ..implements.add(TypeReference((b) => b.symbol = 'Foo'))),
      equalsDart(r'''
        class Foo extends Bar implements Foo {}
      '''),
    );
  });

  test('should create a class with a constructor', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor())),
      equalsDart(r'''
        class Foo {
          Foo();
        }
      '''),
    );
  });

  test('should create a class with a constructor with initializers', () {
    expect(
      Class(
        (b) => b
          ..name = 'Foo'
          ..constructors.add(
            Constructor(
              (b) => b
                ..initializers.addAll([
                  const Code('a = 5'),
                  const Code('super()'),
                ]),
            ),
          ),
      ),
      equalsDart(r'''
        class Foo {
          Foo() : a = 5, super();
        }
      '''),
    );
  });

  test('should create a class with a annotated constructor', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors
            .add(Constructor((b) => b..annotations.add(refer('deprecated'))))),
      equalsDart(r'''
        class Foo {
          @deprecated
          Foo();
        }
      '''),
    );
  });

  test('should create a class with a named constructor', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor((b) => b..name = 'named'))),
      equalsDart(r'''
        class Foo {
          Foo.named();
        }
      '''),
    );
  });

  test('should create a class with a const constructor', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor((b) => b..constant = true))),
      equalsDart(r'''
        class Foo {
          const Foo();
        }
      '''),
    );
  });

  test('should create a class with an external constructor', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor((b) => b..external = true))),
      equalsDart(r'''
        class Foo {
          external Foo();
        }
      '''),
    );
  });

  test('should create a class with a factory constructor', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor((b) => b
          ..factory = true
          ..redirect = refer('_Foo')))),
      equalsDart(r'''
        class Foo {
          factory Foo() = _Foo;
        }
      '''),
    );
  });

  test('should create a class with a const factory constructor', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor((b) => b
          ..factory = true
          ..constant = true
          ..redirect = refer('_Foo')))),
      equalsDart(r'''
        class Foo {
          const factory Foo() = _Foo;
        }
      '''),
    );
  });

  test('should create a class with a factory lambda constructor', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor((b) => b
          ..factory = true
          ..lambda = true
          ..body = const Code('_Foo()')))),
      equalsDart(r'''
        class Foo {
          factory Foo() => _Foo();
        }
      '''),
    );
  });

  test('should create a class with an implicit factory lambda constructor', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor((b) => b
          ..factory = true
          ..body = refer('_Foo').newInstance([]).code))),
      equalsDart(r'''
        class Foo {
          factory Foo() => _Foo();
        }
      '''),
    );
  });

  test('should create a class with a constructor with a body', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor((b) => b
          ..factory = true
          ..body = const Code('return _Foo();')))),
      equalsDart(r'''
        class Foo {
          factory Foo() {
            return _Foo();
          }
        }
      '''),
    );
  });

  test('should create a class with a constructor with parameters', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor((b) => b
          ..requiredParameters.addAll([
            Parameter((b) => b..name = 'a'),
            Parameter((b) => b..name = 'b'),
          ])
          ..optionalParameters.addAll([
            Parameter((b) => b
              ..name = 'c'
              ..named = true),
          ])))),
      equalsDart(r'''
        class Foo {
          Foo(a, b, {c, });
        }
      '''),
    );
  });

  test('should create a class with a constructor+field-formal parameters', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor((b) => b
          ..requiredParameters.addAll([
            Parameter((b) => b
              ..name = 'a'
              ..toThis = true),
            Parameter((b) => b
              ..name = 'b'
              ..toThis = true),
          ])
          ..optionalParameters.addAll([
            Parameter((b) => b
              ..name = 'c'
              ..named = true
              ..toThis = true),
          ])))),
      equalsDart(r'''
        class Foo {
          Foo(this.a, this.b, {this.c, });
        }
      '''),
    );
  });

  test('should create a class with a constructor+super-formal parameters', () {
    expect(
      Class((b) => b
        ..name = 'Foo'
        ..constructors.add(Constructor((b) => b
          ..requiredParameters.addAll([
            Parameter((b) => b
              ..name = 'a'
              ..toSuper = true),
            Parameter((b) => b
              ..name = 'b'
              ..toSuper = true),
          ])
          ..optionalParameters.addAll([
            Parameter((b) => b
              ..name = 'c'
              ..named = true
              ..toSuper = true),
          ])))),
      equalsDart(r'''
        class Foo {
          Foo(super.a, super.b, {super.c, });
        }
      '''),
    );
  });
}