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