// Copyright (c) 2019, 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:analyzer/dart/analysis/analysis_context.dart';
import 'package:analyzer/dart/analysis/analysis_context_collection.dart';
import 'package:analyzer/file_system/file_system.dart';
import 'package:analyzer/src/dart/analysis/analysis_context_collection.dart';
import 'package:analyzer/src/dart/analysis/byte_store.dart';
import 'package:analyzer/src/dart/analysis/driver_based_analysis_context.dart';
import 'package:analyzer/src/dart/analysis/experiments.dart';
import 'package:analyzer/src/services/available_declarations.dart';
import 'package:analyzer/src/test_utilities/mock_sdk.dart';
import 'package:analyzer/src/test_utilities/resource_provider_mixin.dart';
import 'package:meta/meta.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';

main() {
  defineReflectiveSuite(() {
    defineReflectiveTests(AvailableDeclarationsTest);
    defineReflectiveTests(ChangeFileTest);
    defineReflectiveTests(DartdocInfoTest);
    defineReflectiveTests(DeclarationTest);
    defineReflectiveTests(ExportTest);
    defineReflectiveTests(GetLibrariesTest);
  });
}

class AbstractContextTest with ResourceProviderMixin {
  final byteStore = MemoryByteStore();

  AnalysisContextCollection analysisContextCollection;

  AnalysisContext testAnalysisContext;

  /// The file system specific `/home/test/analysis_options.yaml` path.
  String get analysisOptionsPath =>
      convertPath('/home/test/analysis_options.yaml');

  void addDotPackagesDependency(String path, String name, String rootPath) {
    var packagesFile = getFile(path);

    String packagesContent;
    try {
      packagesContent = packagesFile.readAsStringSync();
    } catch (_) {
      packagesContent = '';
    }

    // Ignore if there is already the same package dependency.
    if (packagesContent.contains('$name:file://')) {
      return;
    }

    rootPath = convertPath(rootPath);
    packagesContent += '$name:${toUri('$rootPath/lib')}\n';

    packagesFile.writeAsStringSync(packagesContent);

    createAnalysisContexts();
  }

  void addTestPackageDependency(String name, String rootPath) {
    addDotPackagesDependency('/home/test/.packages', name, rootPath);
  }

  /// Create all analysis contexts in `/home`.
  void createAnalysisContexts() {
    analysisContextCollection = AnalysisContextCollectionImpl(
      includedPaths: [convertPath('/home')],
      resourceProvider: resourceProvider,
      sdkPath: convertPath('/sdk'),
    );

    var testPath = convertPath('/home/test');
    testAnalysisContext = getContext(testPath);
  }

  /// Create an analysis options file based on the given arguments.
  void createAnalysisOptionsFile({List<String> experiments}) {
    var buffer = StringBuffer();
    if (experiments != null) {
      buffer.writeln('analyzer:');
      buffer.writeln('  enable-experiment:');
      for (var experiment in experiments) {
        buffer.writeln('    - $experiment');
      }
    }
    newFile(analysisOptionsPath, content: buffer.toString());

    if (analysisContextCollection != null) {
      createAnalysisContexts();
    }
  }

  /// Return the existing analysis context that should be used to analyze the
  /// given [path], or throw [StateError] if the [path] is not analyzed in any
  /// of the created analysis contexts.
  AnalysisContext getContext(String path) {
    path = convertPath(path);
    return analysisContextCollection.contextFor(path);
  }

  setUp() {
    new MockSdk(resourceProvider: resourceProvider);

    newFolder('/home/test');
    newFile('/home/test/.packages', content: '''
test:${toUri('/home/test/lib')}
''');

    createAnalysisContexts();
  }
}

@reflectiveTest
class AvailableDeclarationsTest extends _Base {
  test_changesStream_noDuplicates() async {
    newFile('/home/aaa/lib/a.dart', content: 'class A {}');

    newFile('/home/bbb/pubspec.yaml', content: r'''
dependencies:
  aaa: any
''');
    addDotPackagesDependency('/home/bbb/.packages', 'aaa', '/home/aaa');
    newFile('/home/bbb/lib/b.dart', content: 'class B {}');

    newFile('/home/ccc/pubspec.yaml', content: r'''
dependencies:
  aaa: any
''');
    addDotPackagesDependency('/home/ccc/.packages', 'aaa', '/home/aaa');
    newFile('/home/ccc/lib/c.dart', content: 'class C {}');

    createAnalysisContexts();

    var bPath = convertPath('/home/bbb');
    var cPath = convertPath('/home/ccc');

    var bAnalysisContext = analysisContextCollection.contextFor(bPath);
    var cAnalysisContext = analysisContextCollection.contextFor(cPath);

    tracker.addContext(bAnalysisContext);
    tracker.addContext(cAnalysisContext);
    await _doAllTrackerWork();

    var uniquePathSet = Set<String>();
    for (var change in changes) {
      for (var library in change.changed) {
        if (!uniquePathSet.add(library.path)) {
          fail('Not unique path: ${library.path}');
        }
      }
    }
  }

  test_discardContexts() async {
    newFile('/home/test/lib/test.dart', content: r'''
class A {}
''');

    // No libraries initially.
    expect(uriToLibrary, isEmpty);

    // Add the context, and discard everything immediately.
    tracker.addContext(testAnalysisContext);
    tracker.discardContexts();

    // There is no context.
    expect(tracker.getContext(testAnalysisContext), isNull);

    // There is no work to do.
    expect(tracker.hasWork, isFalse);
    await _doAllTrackerWork();

    // So, there are no new libraries.
    expect(uriToLibrary, isEmpty);
  }

  test_getContext() async {
    newFile('/home/test/lib/a.dart', content: r'''
class A {}
class B {}
''');
    var addContext = tracker.addContext(testAnalysisContext);
    expect(tracker.getContext(testAnalysisContext), same(addContext));
  }

  test_getLibrary() async {
    newFile('/home/test/lib/test.dart', content: r'''
class C {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();

    var id = uriToLibrary['package:test/test.dart'].id;
    var library = tracker.getLibrary(id);
    expect(library.id, id);
    expect(library.uriStr, 'package:test/test.dart');
  }

  test_readByteStore() async {
    newFile('/home/test/lib/a.dart', content: r'''
class A {}
''');
    newFile('/home/test/lib/b.dart', content: r'''
class B {}
''');
    newFile('/home/test/lib/test.dart', content: r'''
export 'a.dart' show A;
part 'b.dart';
class C {}
enum E {v}
''');

    // The byte store is empty, fill it.
    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    // Re-create tracker, will read from byte store.
    _createTracker();
    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.enum_('E', [
        _ExpectedDeclaration.enumConstant('v'),
      ]),
    ]);
  }

  static Future pumpEventQueue([int times = 5000]) {
    if (times == 0) return new Future.value();
    return new Future.delayed(Duration.zero, () => pumpEventQueue(times - 1));
  }
}

@reflectiveTest
class ChangeFileTest extends _Base {
  disabled_test_updated_library_parted() async {
    // TODO(scheglov) Figure out why this fails on Windows.
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');

    newFile(a, content: r'''
class A {}
''');
    newFile(b, content: r'''
part 'a.dart';
class B {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasNoLibrary('package:test/a.dart');
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    newFile(a, content: r'''
class A2 {}
''');
    tracker.changeFile(a);
    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A2', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('A2', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_added_exported() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');
    var c = convertPath('/home/test/lib/c.dart');
    var d = convertPath('/home/test/lib/d.dart');

    newFile(a, content: r'''
export 'b.dart';
class A {}
''');
    newFile(b, content: r'''
export 'c.dart';
class B {}
''');
    newFile(d, content: r'''
class D {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary('package:test/c.dart');
    _assertHasLibrary('package:test/d.dart', declarations: [
      _ExpectedDeclaration.class_('D', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    newFile(c, content: r'''
class C {}
''');
    tracker.changeFile(c);
    await _doAllTrackerWork();

    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/c.dart', declarations: [
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/d.dart', declarations: [
      _ExpectedDeclaration.class_('D', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_added_library() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');

    newFile(a, content: r'''
class A {}
''');
    var declarationsContext = tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary('package:test/b.dart');

    newFile(b, content: r'''
class B {}
''');
    tracker.changeFile(b);
    await _doAllTrackerWork();

    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    var librariesObject = declarationsContext.getLibraries(
      '/home/test/lib/test.dart',
    );
    expect(
      librariesObject.context.map((library) => library.uriStr).toSet(),
      containsAll(['package:test/a.dart', 'package:test/b.dart']),
    );
  }

  test_added_part() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');
    var c = convertPath('/home/test/lib/c.dart');

    newFile(a, content: r'''
part 'b.dart';
class A {}
''');
    newFile(c, content: r'''
class C {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary('package:test/b.dart');
    _assertHasLibrary('package:test/c.dart', declarations: [
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    newFile(b, content: r'''
part of 'a.dart';
class B {}
''');
    tracker.changeFile(b);
    await _doAllTrackerWork();

    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary('package:test/b.dart');
    _assertHasLibrary('package:test/c.dart', declarations: [
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_added_part_withoutLibrary() async {
    var b = convertPath('/home/test/lib/b.dart');

    newFile(b, content: r'''
part of 'a.dart';
''');
    tracker.changeFile(b);
    await _doAllTrackerWork();

    _assertHasNoLibrary('package:test/a.dart');
    _assertHasNoLibrary('package:test/b.dart');
  }

  test_chooseContext_inAnalysisRoot() async {
    var homePath = convertPath('/home');
    var testPath = convertPath('/home/test');
    var filePath = convertPath('/home/test/lib/test.dart');

    var homeContext = analysisContextCollection.contextFor(homePath);
    var testContext = analysisContextCollection.contextFor(testPath);

    tracker.addContext(homeContext);
    tracker.addContext(testContext);
    await _doAllTrackerWork();

    newFile(filePath, content: 'class A {}');
    uriToLibrary.clear();
    tracker.changeFile(filePath);
    await _doAllTrackerWork();

    _assertDeclaration(
      _getDeclaration(
        _getLibrary('package:test/test.dart').declarations,
        'A',
      ),
      'A',
      DeclarationKind.CLASS,
      relevanceTags: ['package:test/test.dart::A'],
    );

    newFile(filePath, content: 'class B {}');
    uriToLibrary.clear();
    tracker.changeFile(filePath);
    await _doAllTrackerWork();

    _assertDeclaration(
      _getDeclaration(
        _getLibrary('package:test/test.dart').declarations,
        'B',
      ),
      'B',
      DeclarationKind.CLASS,
      relevanceTags: ['package:test/test.dart::B'],
    );
  }

  test_chooseContext_inPackage() async {
    var homePath = convertPath('/home');
    var testPath = convertPath('/home/test');
    var filePath = convertPath('/packages/aaa/lib/a.dart');

    newFile('/home/test/pubspec.yaml', content: r'''
name: test
dependencies:
  aaa: any
''');
    addTestPackageDependency('aaa', '/packages/aaa');

    var homeContext = analysisContextCollection.contextFor(homePath);
    var testContext = analysisContextCollection.contextFor(testPath);

    tracker.addContext(homeContext);
    tracker.addContext(testContext);
    await _doAllTrackerWork();

    newFile(filePath, content: 'class A {}');
    uriToLibrary.clear();
    tracker.changeFile(filePath);
    await _doAllTrackerWork();

    _assertDeclaration(
      _getDeclaration(
        _getLibrary('package:aaa/a.dart').declarations,
        'A',
      ),
      'A',
      DeclarationKind.CLASS,
      relevanceTags: ['package:aaa/a.dart::A'],
    );

    newFile(filePath, content: 'class B {}');
    uriToLibrary.clear();
    tracker.changeFile(filePath);
    await _doAllTrackerWork();

    _assertDeclaration(
      _getDeclaration(
        _getLibrary('package:aaa/a.dart').declarations,
        'B',
      ),
      'B',
      DeclarationKind.CLASS,
      relevanceTags: ['package:aaa/a.dart::B'],
    );
  }

  test_chooseContext_inSdk() async {
    var filePath = convertPath('/sdk/lib/math/math.dart');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    newFile(filePath, content: 'class A {}');
    uriToLibrary.clear();
    tracker.changeFile(filePath);
    await _doAllTrackerWork();

    _assertDeclaration(
      _getDeclaration(
        _getLibrary('dart:math').declarations,
        'A',
      ),
      'A',
      DeclarationKind.CLASS,
      relevanceTags: ['dart:math::A'],
    );

    newFile(filePath, content: 'class B {}');
    uriToLibrary.clear();
    tracker.changeFile(filePath);
    await _doAllTrackerWork();

    _assertDeclaration(
      _getDeclaration(
        _getLibrary('dart:math').declarations,
        'B',
      ),
      'B',
      DeclarationKind.CLASS,
      relevanceTags: ['dart:math::B'],
    );
  }

  test_deleted_exported() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');
    var c = convertPath('/home/test/lib/c.dart');
    var d = convertPath('/home/test/lib/d.dart');

    newFile(a, content: r'''
export 'b.dart';
class A {}
''');
    newFile(b, content: r'''
export 'c.dart';
class B {}
''');
    newFile(c, content: r'''
class C {}
''');
    newFile(d, content: r'''
class D {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/c.dart', declarations: [
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/d.dart', declarations: [
      _ExpectedDeclaration.class_('D', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    deleteFile(c);
    tracker.changeFile(c);
    await _doAllTrackerWork();

    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary('package:test/c.dart');
    _assertHasLibrary('package:test/d.dart', declarations: [
      _ExpectedDeclaration.class_('D', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_deleted_library() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');

    newFile(a, content: '');
    newFile(b, content: '');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart');
    _assertHasLibrary('package:test/b.dart');

    deleteFile(a);
    tracker.changeFile(a);
    await _doAllTrackerWork();

    _assertHasNoLibrary('package:test/a.dart');
    _assertHasLibrary('package:test/b.dart');
  }

  test_deleted_library_ofPart() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');

    newFile(a, content: r'''
part 'b.dart';
''');
    newFile(b, content: r'''
part of 'a.dart';
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart');
    _assertHasNoLibrary('package:test/b.dart');

    deleteFile(a);
    tracker.changeFile(a);
    await _doAllTrackerWork();

    _assertHasNoLibrary('package:test/a.dart');
    _assertHasNoLibrary('package:test/b.dart');
  }

  test_deleted_part() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');
    var c = convertPath('/home/test/lib/c.dart');

    newFile(a, content: r'''
part 'b.dart';
class A {}
''');
    newFile(b, content: r'''
part of 'a.dart';
class B {}
''');
    newFile(c, content: r'''
class C {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/c.dart', declarations: [
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    deleteFile(b);
    tracker.changeFile(b);
    await _doAllTrackerWork();

    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/c.dart', declarations: [
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_deleted_part_withoutLibrary() async {
    var b = convertPath('/home/test/lib/b.dart');

    newFile(b, content: r'''
part of 'a.dart';
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasNoLibrary('package:test/a.dart');
    _assertHasNoLibrary('package:test/b.dart');
  }

  test_updated_exported() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');
    var c = convertPath('/home/test/lib/c.dart');
    var d = convertPath('/home/test/lib/d.dart');

    newFile(a, content: r'''
export 'b.dart';
class A {}
''');
    newFile(b, content: r'''
export 'c.dart';
class B {}
''');
    newFile(c, content: r'''
class C {}
''');
    newFile(d, content: r'''
class D {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/c.dart', declarations: [
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/d.dart', declarations: [
      _ExpectedDeclaration.class_('D', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    newFile(c, content: r'''
class C2 {}
''');
    tracker.changeFile(c);
    await _doAllTrackerWork();

    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C2', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C2', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/c.dart', declarations: [
      _ExpectedDeclaration.class_('C2', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/d.dart', declarations: [
      _ExpectedDeclaration.class_('D', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_updated_library() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');

    newFile(a, content: r'''
class A {}
''');
    newFile(b, content: r'''
class B {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    newFile(a, content: r'''
class A2 {}
''');
    tracker.changeFile(a);
    await _doAllTrackerWork();

    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A2', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_updated_library_to_part() async {
    var a = convertPath('/home/test/lib/a.dart');

    newFile(a, content: r'''
class A {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    newFile(a, content: r'''
part of nothing;
class A {}
''');
    tracker.changeFile(a);
    await _doAllTrackerWork();
    _assertHasNoLibrary('package:test/a.dart');

    newFile(a, content: r'''
class A2 {}
''');
    tracker.changeFile(a);
    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A2', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_updated_part() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');
    var c = convertPath('/home/test/lib/c.dart');

    newFile(a, content: r'''
part 'b.dart';
class A {}
''');
    newFile(b, content: r'''
part of 'a.dart';
class B {}
''');
    newFile(c, content: r'''
class C {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/c.dart', declarations: [
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    newFile(b, content: r'''
part of 'a.dart';
class B2 {}
''');
    tracker.changeFile(b);
    await _doAllTrackerWork();

    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B2', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/c.dart', declarations: [
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_updated_part_exported() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');

    newFile(a, content: r'''
part of unknown;
class A {}
''');
    newFile(b, content: r'''
export 'a.dart';
class B {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasNoLibrary('package:test/a.dart');
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    newFile(a, content: r'''
part of unknown;
class A2 {}
''');
    tracker.changeFile(a);
    await _doAllTrackerWork();
    _assertHasNoLibrary('package:test/a.dart');
    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_updated_part_withoutLibrary() async {
    var b = convertPath('/home/test/lib/b.dart');

    newFile(b, content: r'''
part of 'a.dart';
class B {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasNoLibrary('package:test/a.dart');
    _assertHasNoLibrary('package:test/b.dart');

    newFile(b, content: r'''
part of 'a.dart';
class B2 {}
''');
    tracker.changeFile(b);

    await _doAllTrackerWork();
    _assertHasNoLibrary('package:test/a.dart');
    _assertHasNoLibrary('package:test/b.dart');
  }
}

@reflectiveTest
class DartdocInfoTest extends _Base {
  test_samePackage() async {
    File file = newFile('/home/aaa/lib/definition.dart', content: '''
/// {@template foo}
/// Body of the template.
/// {@endtemplate}
class A {}
''');

    createAnalysisContexts();

    DriverBasedAnalysisContext context =
        analysisContextCollection.contextFor(file.path);

    tracker.addContext(context);
    await _doAllTrackerWork();

    String result =
        tracker.getContext(context).dartdocDirectiveInfo.processDartdoc('''
/// Before macro.
/// {@macro foo}
/// After macro.''');
    expect(result, '''
Before macro.
Body of the template.
After macro.''');
  }
}

@reflectiveTest
class DeclarationTest extends _Base {
  test_CLASS() async {
    newFile('/home/test/lib/test.dart', content: r'''
class A {}

abstract class B {}

@deprecated
class C {}

/// aaa
///
/// bbb bbb
/// ccc ccc
class D {}
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'A'),
      'A',
      DeclarationKind.CLASS,
      relevanceTags: ['package:test/test.dart::A'],
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'B'),
      'B',
      DeclarationKind.CLASS,
      isAbstract: true,
      relevanceTags: ['package:test/test.dart::B'],
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'C'),
      'C',
      DeclarationKind.CLASS,
      isDeprecated: true,
      relevanceTags: ['package:test/test.dart::C'],
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'D'),
      'D',
      DeclarationKind.CLASS,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb\nccc ccc',
      relevanceTags: ['package:test/test.dart::D'],
    );
  }

  test_CLASS_TYPE_ALIAS() async {
    newFile('/home/test/lib/test.dart', content: r'''
mixin M {}

class A = Object with M;

@deprecated
class B = Object with M;

/// aaa
///
/// bbb bbb
class C = Object with M;
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'A'),
      'A',
      DeclarationKind.CLASS_TYPE_ALIAS,
      relevanceTags: ['package:test/test.dart::A'],
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'B'),
      'B',
      DeclarationKind.CLASS_TYPE_ALIAS,
      isDeprecated: true,
      relevanceTags: ['package:test/test.dart::B'],
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'C'),
      'C',
      DeclarationKind.CLASS_TYPE_ALIAS,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb',
      relevanceTags: ['package:test/test.dart::C'],
    );
  }

  test_CONSTRUCTOR() async {
    newFile('/home/test/lib/test.dart', content: r'''
class C {
  int f1;
  int f2;

  C() {}

  C.a() {}

  @deprecated
  C.b() {}

  /// aaa
  ///
  /// bbb bbb
  C.c() {}

  C.d(Map<String, int> p1, int p2, {double p3}) {}

  C.e(this.f1, this.f2) {}
}
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    var classDeclaration = _getDeclaration(library.declarations, 'C');

    _assertDeclaration(
      _getDeclaration(classDeclaration.children, ''),
      '',
      DeclarationKind.CONSTRUCTOR,
      parameterNames: [],
      parameters: '()',
      parameterTypes: [],
      relevanceTags: ['package:test/test.dart::C'],
      requiredParameterCount: 0,
      returnType: 'C',
    );
    _assertDeclaration(
      _getDeclaration(classDeclaration.children, 'a'),
      'a',
      DeclarationKind.CONSTRUCTOR,
      parameterNames: [],
      parameters: '()',
      parameterTypes: [],
      relevanceTags: ['package:test/test.dart::C'],
      requiredParameterCount: 0,
      returnType: 'C',
    );
    _assertDeclaration(
      _getDeclaration(classDeclaration.children, 'b'),
      'b',
      DeclarationKind.CONSTRUCTOR,
      isDeprecated: true,
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      relevanceTags: ['package:test/test.dart::C'],
      requiredParameterCount: 0,
      returnType: 'C',
    );
    _assertDeclaration(
      _getDeclaration(classDeclaration.children, 'c'),
      'c',
      DeclarationKind.CONSTRUCTOR,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb',
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      relevanceTags: ['package:test/test.dart::C'],
      requiredParameterCount: 0,
      returnType: 'C',
    );
    _assertDeclaration(
      _getDeclaration(classDeclaration.children, 'd'),
      'd',
      DeclarationKind.CONSTRUCTOR,
      defaultArgumentListString: 'p1, p2',
      defaultArgumentListTextRanges: [0, 2, 4, 2],
      parameters: '(Map<String, int> p1, int p2, {double p3})',
      parameterNames: ['p1', 'p2', 'p3'],
      parameterTypes: ['Map<String, int>', 'int', 'double'],
      relevanceTags: ['package:test/test.dart::C'],
      requiredParameterCount: 2,
      returnType: 'C',
    );
    _assertDeclaration(
      _getDeclaration(classDeclaration.children, 'e'),
      'e',
      DeclarationKind.CONSTRUCTOR,
      defaultArgumentListString: 'f1, f2',
      defaultArgumentListTextRanges: [0, 2, 4, 2],
      parameters: '(this.f1, this.f2)',
      parameterNames: ['f1', 'f2'],
      parameterTypes: ['', ''],
      relevanceTags: ['package:test/test.dart::C'],
      requiredParameterCount: 2,
      returnType: 'C',
    );
  }

  test_ENUM() async {
    newFile('/home/test/lib/test.dart', content: r'''
enum A {v}

@deprecated
enum B {v}

/// aaa
///
/// bbb bbb
enum C {v}
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'A'),
      'A',
      DeclarationKind.ENUM,
      relevanceTags: ['package:test/test.dart::A'],
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'B'),
      'B',
      DeclarationKind.ENUM,
      isDeprecated: true,
      relevanceTags: ['package:test/test.dart::B'],
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'C'),
      'C',
      DeclarationKind.ENUM,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb',
      relevanceTags: ['package:test/test.dart::C'],
    );
  }

  test_ENUM_CONSTANT() async {
    newFile('/home/test/lib/test.dart', content: r'''
enum MyEnum {
  a,

  @deprecated
  b,

  /// aaa
  ///
  /// bbb bbb
  c
}
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    var enumDeclaration = _getDeclaration(library.declarations, 'MyEnum');

    _assertDeclaration(
      _getDeclaration(enumDeclaration.children, 'a'),
      'a',
      DeclarationKind.ENUM_CONSTANT,
      relevanceTags: ['package:test/test.dart::MyEnum'],
    );
    _assertDeclaration(
      _getDeclaration(enumDeclaration.children, 'b'),
      'b',
      DeclarationKind.ENUM_CONSTANT,
      isDeprecated: true,
      relevanceTags: ['package:test/test.dart::MyEnum'],
    );
    _assertDeclaration(
      _getDeclaration(enumDeclaration.children, 'c'),
      'c',
      DeclarationKind.ENUM_CONSTANT,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb',
      relevanceTags: ['package:test/test.dart::MyEnum'],
    );
  }

  test_EXTENSION() async {
    createAnalysisOptionsFile(experiments: [EnableString.extension_methods]);
    newFile('/home/test/lib/test.dart', content: r'''
extension A on String {}

extension on String {}

@deprecated
extension B on String {}

/// aaa
///
/// bbb bbb
/// ccc ccc
extension C on String {}
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'A'),
      'A',
      DeclarationKind.EXTENSION,
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'B'),
      'B',
      DeclarationKind.EXTENSION,
      isDeprecated: true,
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'C'),
      'C',
      DeclarationKind.EXTENSION,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb\nccc ccc',
    );
  }

  test_FUNCTION() async {
    newFile('/home/test/lib/test.dart', content: r'''
void a() {}

@deprecated
void b() {}

/// aaa
///
/// bbb bbb
void c() {}

List<String> d(Map<String, int> p1, int p2, {double p3}) {}

void e<T extends num, U>() {}
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'a'),
      'a',
      DeclarationKind.FUNCTION,
      parameterNames: [],
      parameters: '()',
      parameterTypes: [],
      requiredParameterCount: 0,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'b'),
      'b',
      DeclarationKind.FUNCTION,
      isDeprecated: true,
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      requiredParameterCount: 0,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'c'),
      'c',
      DeclarationKind.FUNCTION,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb',
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      requiredParameterCount: 0,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'd'),
      'd',
      DeclarationKind.FUNCTION,
      defaultArgumentListString: 'p1, p2',
      defaultArgumentListTextRanges: [0, 2, 4, 2],
      parameters: '(Map<String, int> p1, int p2, {double p3})',
      parameterNames: ['p1', 'p2', 'p3'],
      parameterTypes: ['Map<String, int>', 'int', 'double'],
      requiredParameterCount: 2,
      returnType: 'List<String>',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'e'),
      'e',
      DeclarationKind.FUNCTION,
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      requiredParameterCount: 0,
      returnType: 'void',
      typeParameters: '<T extends num, U>',
    );
  }

  test_FUNCTION_defaultArgumentList() async {
    newFile('/home/test/lib/test.dart', content: r'''
void a() {}

void b(int a, double bb, String ccc) {}

void c(int a, [double b, String c]) {}

void d(int a, {int b, @required int c, @required int d, int e}) {}
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'a'),
      'a',
      DeclarationKind.FUNCTION,
      parameterNames: [],
      parameters: '()',
      parameterTypes: [],
      requiredParameterCount: 0,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'b'),
      'b',
      DeclarationKind.FUNCTION,
      defaultArgumentListString: 'a, bb, ccc',
      defaultArgumentListTextRanges: [0, 1, 3, 2, 7, 3],
      parameters: '(int a, double bb, String ccc)',
      parameterNames: ['a', 'bb', 'ccc'],
      parameterTypes: ['int', 'double', 'String'],
      requiredParameterCount: 3,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'c'),
      'c',
      DeclarationKind.FUNCTION,
      defaultArgumentListString: 'a',
      defaultArgumentListTextRanges: [0, 1],
      parameters: '(int a, [double b, String c])',
      parameterNames: ['a', 'b', 'c'],
      parameterTypes: ['int', 'double', 'String'],
      requiredParameterCount: 1,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'd'),
      'd',
      DeclarationKind.FUNCTION,
      defaultArgumentListString: 'a, c: null, d: null',
      defaultArgumentListTextRanges: [0, 1, 6, 4, 15, 4],
      parameters: '(int a, {int b, @required int c, @required int d, int e})',
      parameterNames: ['a', 'b', 'c', 'd', 'e'],
      parameterTypes: ['int', 'int', 'int', 'int', 'int'],
      requiredParameterCount: 1,
      returnType: 'void',
    );
  }

  test_FUNCTION_TYPE_ALIAS() async {
    newFile('/home/test/lib/test.dart', content: r'''
typedef A = void Function();

@deprecated
typedef B = void Function();

/// aaa
///
/// bbb bbb
typedef C = void Function();

typedef D = int Function(int p1, [double p2, String p3]);

typedef E = void Function(int, double, {String p3});

typedef F = void Function<T extends num, U>();
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'A'),
      'A',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      relevanceTags: ['package:test/test.dart::A'],
      requiredParameterCount: 0,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'B'),
      'B',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      isDeprecated: true,
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      relevanceTags: ['package:test/test.dart::B'],
      requiredParameterCount: 0,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'C'),
      'C',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb',
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      relevanceTags: ['package:test/test.dart::C'],
      requiredParameterCount: 0,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'D'),
      'D',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      parameters: '(int p1, [double p2, String p3])',
      parameterNames: ['p1', 'p2', 'p3'],
      parameterTypes: ['int', 'double', 'String'],
      relevanceTags: ['package:test/test.dart::D'],
      requiredParameterCount: 1,
      returnType: 'int',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'E'),
      'E',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      parameters: '(int, double, {String p3})',
      parameterNames: ['', '', 'p3'],
      parameterTypes: ['int', 'double', 'String'],
      relevanceTags: ['package:test/test.dart::E'],
      requiredParameterCount: 2,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'F'),
      'F',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      requiredParameterCount: 0,
      relevanceTags: ['package:test/test.dart::F'],
      returnType: 'void',
      typeParameters: '<T extends num, U>',
    );
  }

  test_FUNCTION_TYPE_ALIAS_noFunction() async {
    newFile('/home/test/lib/test.dart', content: r'''
typedef A = ;
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertNoDeclaration(library, 'A');
  }

  test_FUNCTION_TYPE_ALIAS_old() async {
    newFile('/home/test/lib/test.dart', content: r'''
typedef void A();

@deprecated
typedef void B();

/// aaa
///
/// bbb bbb
typedef void C();

typedef int D(int p1, [double p2, String p3]);

typedef void E(int p1, double p2, {String p3});

typedef void F<T extends num, U>();
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'A'),
      'A',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      relevanceTags: ['package:test/test.dart::A'],
      requiredParameterCount: 0,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'B'),
      'B',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      isDeprecated: true,
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      relevanceTags: ['package:test/test.dart::B'],
      requiredParameterCount: 0,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'C'),
      'C',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb',
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      relevanceTags: ['package:test/test.dart::C'],
      requiredParameterCount: 0,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'D'),
      'D',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      parameters: '(int p1, [double p2, String p3])',
      parameterNames: ['p1', 'p2', 'p3'],
      parameterTypes: ['int', 'double', 'String'],
      relevanceTags: ['package:test/test.dart::D'],
      requiredParameterCount: 1,
      returnType: 'int',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'E'),
      'E',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      parameters: '(int p1, double p2, {String p3})',
      parameterNames: ['p1', 'p2', 'p3'],
      parameterTypes: ['int', 'double', 'String'],
      relevanceTags: ['package:test/test.dart::E'],
      requiredParameterCount: 2,
      returnType: 'void',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'F'),
      'F',
      DeclarationKind.FUNCTION_TYPE_ALIAS,
      parameters: '()',
      parameterNames: [],
      parameterTypes: [],
      requiredParameterCount: 0,
      relevanceTags: ['package:test/test.dart::F'],
      returnType: 'void',
      typeParameters: '<T extends num, U>',
    );
  }

  test_GETTER() async {
    newFile('/home/test/lib/test.dart', content: r'''
int get a => 0;

@deprecated
int get b => 0;

/// aaa
///
/// bbb bbb
int get c => 0;
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'a'),
      'a',
      DeclarationKind.GETTER,
      returnType: 'int',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'b'),
      'b',
      DeclarationKind.GETTER,
      isDeprecated: true,
      returnType: 'int',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'c'),
      'c',
      DeclarationKind.GETTER,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb',
      returnType: 'int',
    );
  }

  test_library_isDeprecated() async {
    newFile('/home/test/lib/a.dart', content: '');
    newFile('/home/test/lib/b.dart', content: r'''
@deprecated
library my.lib;
''');
    newFile('/home/test/lib/c.dart', content: r'''
@Deprecated('description')
library my.lib;
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();

    expect(uriToLibrary['package:test/a.dart'].isDeprecated, isFalse);
    expect(uriToLibrary['package:test/b.dart'].isDeprecated, isTrue);
    expect(uriToLibrary['package:test/c.dart'].isDeprecated, isTrue);
  }

  test_library_partDirective_empty() async {
    newFile('/home/test/lib/test.dart', content: r'''
part ' ';

class A {}
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'A'),
      'A',
      DeclarationKind.CLASS,
      relevanceTags: ['package:test/test.dart::A'],
    );
  }

  test_library_partDirective_incomplete() async {
    newFile('/home/test/lib/test.dart', content: r'''
part

class A {}
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'A'),
      'A',
      DeclarationKind.CLASS,
      relevanceTags: ['package:test/test.dart::A'],
    );
  }

  test_library_parts() async {
    newFile('/home/test/lib/a.dart', content: r'''
part of 'test.dart';
class A {}
''');
    newFile('/home/test/lib/b.dart', content: r'''
part of 'test.dart';
class B {}
''');
    newFile('/home/test/lib/test.dart', content: r'''
part 'a.dart';
part 'b.dart';
class C {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_library_publicOnly() async {
    newFile('/home/test/lib/a.dart', content: r'''
part of 'test.dart';
class A {}
class _A {}
''');
    newFile('/home/test/lib/test.dart', content: r'''
part 'a.dart';
class B {}
class _B {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_library_publicOnly_enum() async {
    newFile('/home/test/lib/a.dart', content: r'''
part of 'test.dart';
enum A {a, _a}
enum _A {a, _a}
''');
    newFile('/home/test/lib/test.dart', content: r'''
part 'a.dart';
enum B {b, _b}
enum _B {b, _b}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.enum_('A', [
        _ExpectedDeclaration.enumConstant('a'),
      ]),
      _ExpectedDeclaration.enum_('B', [
        _ExpectedDeclaration.enumConstant('b'),
      ]),
    ]);
  }

  test_location() async {
    var code = r'''
class A {}

class B {}
''';
    var testPath = newFile('/home/test/lib/test.dart', content: code).path;

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'A'),
      'A',
      DeclarationKind.CLASS,
      locationOffset: code.indexOf('A {}'),
      locationPath: testPath,
      locationStartColumn: 7,
      locationStartLine: 1,
      relevanceTags: ['package:test/test.dart::A'],
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'B'),
      'B',
      DeclarationKind.CLASS,
      locationOffset: code.indexOf('B {}'),
      locationPath: testPath,
      locationStartColumn: 7,
      locationStartLine: 3,
      relevanceTags: ['package:test/test.dart::B'],
    );
  }

  test_MIXIN() async {
    newFile('/home/test/lib/test.dart', content: r'''
mixin A {}

@deprecated
mixin B {}

/// aaa
///
/// bbb bbb
/// ccc ccc
mixin C {}
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'A'),
      'A',
      DeclarationKind.MIXIN,
      relevanceTags: ['package:test/test.dart::A'],
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'B'),
      'B',
      DeclarationKind.MIXIN,
      isDeprecated: true,
      relevanceTags: ['package:test/test.dart::B'],
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'C'),
      'C',
      DeclarationKind.MIXIN,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb\nccc ccc',
      relevanceTags: ['package:test/test.dart::C'],
    );
  }

  test_SETTER() async {
    newFile('/home/test/lib/test.dart', content: r'''
set a(int value) {}

@deprecated
set b(int value) {}

/// aaa
///
/// bbb bbb
set c(int value) {}
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'a'),
      'a',
      DeclarationKind.SETTER,
      parameters: '(int value)',
      parameterNames: ['value'],
      parameterTypes: ['int'],
      requiredParameterCount: 1,
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'b'),
      'b',
      DeclarationKind.SETTER,
      isDeprecated: true,
      parameters: '(int value)',
      parameterNames: ['value'],
      parameterTypes: ['int'],
      requiredParameterCount: 1,
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'c'),
      'c',
      DeclarationKind.SETTER,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb',
      parameters: '(int value)',
      parameterNames: ['value'],
      parameterTypes: ['int'],
      requiredParameterCount: 1,
    );
  }

  test_VARIABLE() async {
    newFile('/home/test/lib/test.dart', content: r'''
int a;

@deprecated
int b;

/// aaa
///
/// bbb bbb
int c;

const d = 0;

final double e = 2.7;
''');

    tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var library = _getLibrary('package:test/test.dart');
    _assertDeclaration(
      _getDeclaration(library.declarations, 'a'),
      'a',
      DeclarationKind.VARIABLE,
      returnType: 'int',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'b'),
      'b',
      DeclarationKind.VARIABLE,
      isDeprecated: true,
      returnType: 'int',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'c'),
      'c',
      DeclarationKind.VARIABLE,
      docSummary: 'aaa',
      docComplete: 'aaa\n\nbbb bbb',
      returnType: 'int',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'd'),
      'd',
      DeclarationKind.VARIABLE,
      isConst: true,
      relevanceTags: ['dart:core::int'],
      returnType: '',
    );
    _assertDeclaration(
      _getDeclaration(library.declarations, 'e'),
      'e',
      DeclarationKind.VARIABLE,
      isFinal: true,
      relevanceTags: ['dart:core::double'],
      returnType: 'double',
    );
  }
}

@reflectiveTest
class ExportTest extends _Base {
  test_combinators_hide() async {
    newFile('/home/test/lib/a.dart', content: r'''
class A {}
class B {}
class C {}
''');
    newFile('/home/test/lib/test.dart', content: r'''
export 'a.dart' hide B;
class D {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('D', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_combinators_show() async {
    newFile('/home/test/lib/a.dart', content: r'''
class A {}
class B {}
class C {}
''');
    newFile('/home/test/lib/test.dart', content: r'''
export 'a.dart' show B;
class D {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('D', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_combinators_show_enum() async {
    newFile('/home/test/lib/a.dart', content: r'''
enum E1 {a}
enum E2 {b}
''');
    newFile('/home/test/lib/test.dart', content: r'''
export 'a.dart' show E1;
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.enum_('E1', [
        _ExpectedDeclaration.enumConstant('a'),
      ]),
    ]);
  }

  test_cycle() async {
    newFile('/home/test/lib/a.dart', content: r'''
export 'b.dart';
class A {}
''');
    newFile('/home/test/lib/b.dart', content: r'''
export 'a.dart';
class B {}
''');
    newFile('/home/test/lib/test.dart', content: r'''
export 'b.dart';
class C {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();

    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_enum() async {
    newFile('/home/test/lib/test.dart', content: r'''
enum E1 {a, b}
enum E2 {a, b}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.enum_('E1', [
        _ExpectedDeclaration.enumConstant('a'),
        _ExpectedDeclaration.enumConstant('b'),
      ]),
      _ExpectedDeclaration.enum_('E2', [
        _ExpectedDeclaration.enumConstant('a'),
        _ExpectedDeclaration.enumConstant('b'),
      ]),
    ]);
  }

  test_missing() async {
    newFile('/home/test/lib/test.dart', content: r'''
export 'a.dart';
class C {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_sequence() async {
    newFile('/home/test/lib/a.dart', content: r'''
class A {}
''');
    newFile('/home/test/lib/b.dart', content: r'''
export 'a.dart';
class B {}
''');
    newFile('/home/test/lib/test.dart', content: r'''
export 'b.dart';
class C {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();

    _assertHasLibrary('package:test/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    _assertHasLibrary('package:test/b.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }

  test_shadowedByLocal() async {
    newFile('/home/test/lib/a.dart', content: r'''
class A {}
class B {}
''');
    newFile('/home/test/lib/test.dart', content: r'''
export 'a.dart';

mixin B {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.mixin('B'),
    ]);
  }

  test_simple() async {
    newFile('/home/test/lib/a.dart', content: r'''
class A {}
class B {}
''');
    newFile('/home/test/lib/test.dart', content: r'''
export 'a.dart';
class C {}
''');
    tracker.addContext(testAnalysisContext);

    await _doAllTrackerWork();
    _assertHasLibrary('package:test/test.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
  }
}

@reflectiveTest
class GetLibrariesTest extends _Base {
  test_bazel() async {
    newFile('/home/aaa/lib/a.dart', content: 'class A {}');
    newFile('/home/aaa/lib/src/a2.dart', content: 'class A2 {}');

    newFile('/home/bbb/lib/b.dart', content: 'class B {}');
    newFile('/home/bbb/lib/src/b2.dart', content: 'class B2 {}');

    newFile('/home/material_button/BUILD', content: '');
    newFile(
      '/home/material_button/lib/button.dart',
      content: 'class MaterialButton {}',
    );
    newFile(
      '/home/material_button/test/button_test.dart',
      content: 'class MaterialButtonTest {}',
    );

    newFile('/home/material_button/testing/BUILD', content: '');
    newFile(
      '/home/material_button/testing/lib/material_button_po.dart',
      content: 'class MaterialButtonPO {}',
    );

    var packagesFilePath = '/home/material_button/.packages';
    addDotPackagesDependency(packagesFilePath, 'aaa', '/home/aaa');
    addDotPackagesDependency(packagesFilePath, 'bbb', '/home/bbb');
    addDotPackagesDependency(
      packagesFilePath,
      'material_button',
      '/home/material_button',
    );
    addDotPackagesDependency(
      packagesFilePath,
      'material_button_testing',
      '/home/material_button/testing',
    );

    var analysisContext = analysisContextCollection.contextFor(
      convertPath('/home/material_button'),
    );
    var context = tracker.addContext(analysisContext);
    context.setDependencies({
      convertPath('/home/material_button'): [convertPath('/home/aaa/lib')],
      convertPath('/home/material_button/testing'): [
        convertPath('/home/bbb/lib'),
        convertPath('/home/material_button/lib'),
      ],
    });
    await _doAllTrackerWork();

    _assertHasLibrary('package:aaa/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary('package:aaa/src/a2.dart');

    _assertHasLibrary('package:bbb/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary('package:bbb/src/b2.dart');

    _assertHasLibrary('package:material_button/button.dart', declarations: [
      _ExpectedDeclaration.class_('MaterialButton', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary(
      toUriStr('/home/material_button/test/button_test.dart'),
      declarations: [
        _ExpectedDeclaration.class_('MaterialButtonTest', [
          _ExpectedDeclaration.constructor(''),
        ]),
      ],
    );
    _assertHasLibrary(
      'package:material_button_testing/material_button_po.dart',
      declarations: [
        _ExpectedDeclaration.class_('MaterialButtonPO', [
          _ExpectedDeclaration.constructor(''),
        ]),
      ],
    );

    {
      var path = convertPath('/home/material_button/lib/_.dart');
      var libraries = context.getLibraries(path);
      _assertHasLibraries(
        libraries.sdk,
        uriList: ['dart:core', 'dart:async'],
      );
      _assertHasLibraries(
        libraries.dependencies,
        uriList: ['package:aaa/a.dart'],
        only: true,
      );
      _assertHasLibraries(
        libraries.context,
        uriList: [
          'package:material_button/button.dart',
        ],
        only: true,
      );
    }

    {
      var path = convertPath('/home/material_button/test/_.dart');
      var libraries = context.getLibraries(path);
      _assertHasLibraries(
        libraries.sdk,
        uriList: ['dart:core', 'dart:async'],
      );
      _assertHasLibraries(
        libraries.dependencies,
        uriList: ['package:aaa/a.dart'],
        only: true,
      );
      _assertHasLibraries(
        libraries.context,
        uriList: [
          'package:material_button/button.dart',
          toUriStr('/home/material_button/test/button_test.dart'),
        ],
        only: true,
      );
    }

    {
      var path = convertPath('/home/material_button/testing/lib/_.dart');
      var libraries = context.getLibraries(path);
      _assertHasLibraries(
        libraries.sdk,
        uriList: ['dart:core', 'dart:async'],
      );
      _assertHasLibraries(
        libraries.dependencies,
        uriList: [
          'package:bbb/b.dart',
          'package:material_button/button.dart',
        ],
        only: true,
      );
      _assertHasLibraries(
        libraries.context,
        uriList: [
          'package:material_button_testing/material_button_po.dart',
        ],
        only: true,
      );
    }
  }

  test_excludeSelf() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');
    var c = convertPath('/home/test/lib/c.dart');

    newFile(a);
    newFile(b);
    newFile(c);

    var context = tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var aList = _uriListOfContextLibraries(context, a);
    expect(
      aList,
      unorderedEquals([
        'package:test/b.dart',
        'package:test/c.dart',
      ]),
    );

    var bList = _uriListOfContextLibraries(context, b);
    expect(
      bList,
      unorderedEquals([
        'package:test/a.dart',
        'package:test/c.dart',
      ]),
    );
  }

  test_excludeSelf_part() async {
    var a = convertPath('/home/test/lib/a.dart');
    var b = convertPath('/home/test/lib/b.dart');
    var c = convertPath('/home/test/lib/c.dart');

    newFile(a, content: r'''
part 'b.dart';
''');
    newFile(b, content: r'''
part of 'a.dart';
''');
    newFile(c);

    var context = tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var aList = _uriListOfContextLibraries(context, a);
    expect(aList, unorderedEquals(['package:test/c.dart']));

    var bList = _uriListOfContextLibraries(context, b);
    expect(bList, unorderedEquals(['package:test/c.dart']));

    var cList = _uriListOfContextLibraries(context, c);
    expect(cList, unorderedEquals(['package:test/a.dart']));
  }

  test_pub() async {
    newFile('/home/aaa/lib/a.dart', content: 'class A {}');
    newFile('/home/aaa/lib/src/a2.dart', content: 'class A2 {}');

    newFile('/home/bbb/lib/b.dart', content: 'class B {}');
    newFile('/home/bbb/lib/src/b2.dart', content: 'class B2 {}');

    newFile('/home/ccc/lib/c.dart', content: 'class C {}');
    newFile('/home/ccc/lib/src/c2.dart', content: 'class C2 {}');

    newFile('/home/test/pubspec.yaml', content: r'''
name: test
dependencies:
  aaa: any
dev_dependencies:
  bbb: any
''');
    newFile('/home/test/lib/t.dart', content: 'class T {}');
    newFile('/home/test/lib/src/t2.dart', content: 'class T2 {}');
    newFile('/home/test/bin/t3.dart', content: 'class T3 {}');
    newFile('/home/test/test/t4.dart', content: 'class T4 {}');

    newFile('/home/test/samples/basic/pubspec.yaml', content: r'''
name: test
dependencies:
  ccc: any
  test: any
''');
    newFile('/home/test/samples/basic/lib/s.dart', content: 'class S {}');

    addTestPackageDependency('aaa', '/home/aaa');
    addTestPackageDependency('bbb', '/home/bbb');
    addTestPackageDependency('ccc', '/home/ccc');
    addTestPackageDependency('basic', '/home/test/samples/basic');

    var context = tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    _assertHasLibrary('package:aaa/a.dart', declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary('package:aaa/src/a2.dart');

    _assertHasLibrary('package:bbb/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary('package:bbb/src/b2.dart');

    _assertHasLibrary('package:ccc/c.dart', declarations: [
      _ExpectedDeclaration.class_('C', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary('package:ccc/src/c2.dart');

    _assertHasLibrary('package:test/t.dart', declarations: [
      _ExpectedDeclaration.class_('T', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/src/t2.dart', declarations: [
      _ExpectedDeclaration.class_('T2', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    _assertHasLibrary('package:basic/s.dart', declarations: [
      _ExpectedDeclaration.class_('S', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    {
      var path = convertPath('/home/test/lib/_.dart');
      var libraries = context.getLibraries(path);
      _assertHasLibraries(
        libraries.sdk,
        uriList: ['dart:core', 'dart:async'],
      );
      _assertHasLibraries(
        libraries.dependencies,
        uriList: ['package:aaa/a.dart'],
        only: true,
      );
      // Note, no `bin/` or `test/` libraries.
      // Note, has `lib/src` library.
      _assertHasLibraries(
        libraries.context,
        uriList: [
          'package:test/t.dart',
          'package:test/src/t2.dart',
        ],
        only: true,
      );
    }

    {
      var path = convertPath('/home/test/bin/_.dart');
      var libraries = context.getLibraries(path);
      _assertHasLibraries(
        libraries.sdk,
        uriList: ['dart:core', 'dart:async'],
      );
      _assertHasLibraries(
        libraries.dependencies,
        uriList: [
          'package:aaa/a.dart',
          'package:bbb/b.dart',
        ],
        only: true,
      );
      // Note, no `test/` libraries.
      _assertHasLibraries(
        libraries.context,
        uriList: [
          'package:test/t.dart',
          'package:test/src/t2.dart',
          toUriStr('/home/test/bin/t3.dart'),
        ],
        only: true,
      );
    }

    {
      var path = convertPath('/home/test/test/_.dart');
      var libraries = context.getLibraries(path);
      _assertHasLibraries(
        libraries.sdk,
        uriList: ['dart:core', 'dart:async'],
      );
      _assertHasLibraries(
        libraries.dependencies,
        uriList: [
          'package:aaa/a.dart',
          'package:bbb/b.dart',
        ],
        only: true,
      );
      // Note, no `bin/` libraries.
      _assertHasLibraries(
        libraries.context,
        uriList: [
          'package:test/t.dart',
          'package:test/src/t2.dart',
          toUriStr('/home/test/test/t4.dart'),
        ],
        only: true,
      );
    }

    {
      var path = convertPath('/home/test/samples/basic/lib/_.dart');
      var libraries = context.getLibraries(path);
      _assertHasLibraries(
        libraries.sdk,
        uriList: ['dart:core', 'dart:async'],
      );
      _assertHasLibraries(
        libraries.dependencies,
        uriList: [
          'package:ccc/c.dart',
          'package:test/t.dart',
        ],
        only: true,
      );
      // Note, no `package:test` libraries.
      _assertHasLibraries(
        libraries.context,
        uriList: [
          'package:basic/s.dart',
        ],
        only: true,
      );
    }
  }

  test_sdk_excludesPrivate() async {
    newFile('/home/test/lib/test.dart', content: '');

    var context = tracker.addContext(testAnalysisContext);
    await _doAllTrackerWork();

    var path = convertPath('/home/test/lib/_.dart');
    var libraries = context.getLibraries(path);
    expect(
      libraries.sdk.where((library) => library.uriStr.startsWith('dart:_')),
      isEmpty,
    );
  }

  test_setDependencies() async {
    newFile('/home/aaa/lib/a.dart', content: r'''
export 'src/a2.dart' show A2;
class A1 {}
''');
    newFile('/home/aaa/lib/src/a2.dart', content: r'''
class A2 {}
class A3 {}
''');
    newFile('/home/bbb/lib/b.dart', content: r'''
class B {}
''');

    addTestPackageDependency('aaa', '/home/aaa');
    addTestPackageDependency('bbb', '/home/bbb');

    newFile('/home/test/lib/t.dart', content: 'class T {}');
    newFile('/home/test/lib/src/t2.dart', content: 'class T2 {}');
    newFile('/home/test/test/t3.dart', content: 'class T3 {}');

    var context = tracker.addContext(testAnalysisContext);
    context.setDependencies({
      convertPath('/home/test'): [
        convertPath('/home/aaa/lib'),
        convertPath('/home/bbb/lib'),
      ],
      convertPath('/home/test/lib'): [convertPath('/home/aaa/lib')],
    });

    await _doAllTrackerWork();

    _assertHasLibrary('package:aaa/a.dart', declarations: [
      _ExpectedDeclaration.class_('A1', [
        _ExpectedDeclaration.constructor(''),
      ]),
      _ExpectedDeclaration.class_('A2', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary('package:aaa/src/a2.dart');
    _assertHasLibrary('package:bbb/b.dart', declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/t.dart', declarations: [
      _ExpectedDeclaration.class_('T', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary('package:test/src/t2.dart', declarations: [
      _ExpectedDeclaration.class_('T2', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary(
      toUriStr('/home/test/test/t3.dart'),
      declarations: [
        _ExpectedDeclaration.class_('T3', [
          _ExpectedDeclaration.constructor(''),
        ]),
      ],
    );

    // `lib/` is configured to see `package:aaa`.
    {
      var path = convertPath('/home/test/lib/_.dart');
      var libraries = context.getLibraries(path);
      _assertHasLibraries(
        libraries.dependencies,
        uriList: ['package:aaa/a.dart'],
        only: true,
      );
      // Not in a package, so all context files are visible.
      _assertHasLibraries(
        libraries.context,
        uriList: [
          'package:test/t.dart',
          'package:test/src/t2.dart',
          toUriStr('/home/test/test/t3.dart'),
        ],
        only: true,
      );
    }

    // `test/` is configured to see `package:aaa` and `package:bbb`.
    {
      var path = convertPath('/home/test/bin/_.dart');
      var libraries = context.getLibraries(path);
      _assertHasLibraries(
        libraries.dependencies,
        uriList: [
          'package:aaa/a.dart',
          'package:bbb/b.dart',
        ],
        only: true,
      );
      // Not in a package, so all context files are visible.
      _assertHasLibraries(
        libraries.context,
        uriList: [
          'package:test/t.dart',
          'package:test/src/t2.dart',
          toUriStr('/home/test/test/t3.dart'),
        ],
        only: true,
      );
    }
  }

  test_setDependencies_twice() async {
    newFile('/home/aaa/lib/a.dart', content: r'''
class A {}
''');
    newFile('/home/bbb/lib/b.dart', content: r'''
class B {}
''');

    addTestPackageDependency('aaa', '/home/aaa');
    addTestPackageDependency('bbb', '/home/bbb');

    newFile('/home/test/lib/test.dart', content: r'''
class C {}
''');

    var context = tracker.addContext(testAnalysisContext);

    var aUri = 'package:aaa/a.dart';
    var bUri = 'package:bbb/b.dart';

    context.setDependencies({
      convertPath('/home/test'): [convertPath('/home/aaa/lib')],
    });
    await _doAllTrackerWork();

    _assertHasLibrary(aUri, declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasNoLibrary(bUri);

    // The package can see package:aaa, but not package:bbb
    {
      var path = convertPath('/home/test/lib/a.dart');
      var libraries = context.getLibraries(path);
      _assertHasLibraries(
        libraries.dependencies,
        uriList: ['package:aaa/a.dart'],
        only: true,
      );
    }

    context.setDependencies({
      convertPath('/home/test'): [convertPath('/home/bbb/lib')],
    });
    await _doAllTrackerWork();

    _assertHasLibrary(aUri, declarations: [
      _ExpectedDeclaration.class_('A', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);
    _assertHasLibrary(bUri, declarations: [
      _ExpectedDeclaration.class_('B', [
        _ExpectedDeclaration.constructor(''),
      ]),
    ]);

    // The package can see package:bbb, but not package:aaa
    {
      var path = convertPath('/home/test/lib/a.dart');
      var libraries = context.getLibraries(path);
      _assertHasLibraries(
        libraries.dependencies,
        uriList: ['package:bbb/b.dart'],
        only: true,
      );
    }
  }

  static void _assertHasLibraries(List<Library> libraries,
      {@required List<String> uriList, bool only = false}) {
    var actualUriList = libraries.map((lib) => lib.uriStr).toList();
    if (only) {
      expect(actualUriList, unorderedEquals(uriList));
    } else {
      expect(actualUriList, containsAll(uriList));
    }
  }

  static List<String> _uriListOfContextLibraries(
    DeclarationsContext context,
    String path,
  ) {
    return context.getLibraries(path).context.map((l) => l.uriStr).toList();
  }
}

class _Base extends AbstractContextTest {
  DeclarationsTracker tracker;

  final List<LibraryChange> changes = [];

  final Map<int, Library> idToLibrary = {};
  final Map<String, Library> uriToLibrary = {};

  @override
  setUp() {
    super.setUp();
    _createTracker();
  }

  void _assertDeclaration(
    Declaration declaration,
    String name,
    DeclarationKind kind, {
    String defaultArgumentListString,
    List<int> defaultArgumentListTextRanges,
    String docComplete,
    String docSummary,
    bool isAbstract = false,
    bool isConst = false,
    bool isDeprecated = false,
    bool isFinal = false,
    int locationOffset,
    String locationPath,
    int locationStartColumn,
    int locationStartLine,
    String parameters,
    List<String> parameterNames,
    List<String> parameterTypes,
    List<String> relevanceTags,
    int requiredParameterCount,
    String returnType,
    String typeParameters,
  }) {
    expect(declaration.defaultArgumentListString, defaultArgumentListString);
    expect(
      declaration.defaultArgumentListTextRanges,
      defaultArgumentListTextRanges,
    );
    expect(declaration.docComplete, docComplete);
    expect(declaration.docSummary, docSummary);
    expect(declaration.name, name);
    expect(declaration.kind, kind);
    expect(declaration.isAbstract, isAbstract);
    expect(declaration.isConst, isConst);
    expect(declaration.isDeprecated, isDeprecated);
    expect(declaration.isFinal, isFinal);
    expect(declaration.parameters, parameters);
    expect(declaration.parameterNames, parameterNames);
    expect(declaration.parameterTypes, parameterTypes);
    expect(declaration.relevanceTags, relevanceTags);
    expect(declaration.requiredParameterCount, requiredParameterCount);
    expect(declaration.returnType, returnType);
    expect(declaration.typeParameters, typeParameters);
    if (locationOffset != null) {
      expect(declaration.locationOffset, locationOffset);
      expect(declaration.locationPath, locationPath);
      expect(declaration.locationStartColumn, locationStartColumn);
      expect(declaration.locationStartLine, locationStartLine);
    }
  }

  void _assertHasDeclaration(
      List<Declaration> declarations, _ExpectedDeclaration expected) {
    var matching = declarations.where((d) {
      return d.name == expected.name && d.kind == expected.kind;
    }).toList();
    if (matching.length != 1) {
      fail('Expected $expected in\n${declarations.join('\n')}');
    }

    var actual = matching.single;
    expect(actual.children, hasLength(expected.children.length));
    for (var expectedChild in expected.children) {
      _assertHasDeclaration(actual.children, expectedChild);
    }
  }

  /// Assert that the current state has the library with the given [uri].
  ///
  /// If [declarations] provided, also checks that the library has exactly
  /// these declarations.
  void _assertHasLibrary(String uri,
      {List<_ExpectedDeclaration> declarations}) {
    var library = uriToLibrary[uri];
    expect(library, isNotNull);
    if (declarations != null) {
      expect(library.declarations, hasLength(declarations.length));
      for (var expected in declarations) {
        _assertHasDeclaration(library.declarations, expected);
      }
    }
  }

  void _assertHasNoLibrary(String uri) {
    expect(uriToLibrary, isNot(contains(uri)));
  }

  void _assertNoDeclaration(Library library, String name) {
    expect(
      library.declarations.where((declaration) => declaration.name == name),
      isEmpty,
    );
  }

  void _createTracker() {
    uriToLibrary.clear();

    tracker = DeclarationsTracker(byteStore, resourceProvider);
    tracker.changes.listen((change) {
      changes.add(change);
      for (var library in change.changed) {
        expect(library.declarations, isNotNull);
        idToLibrary[library.id] = library;
        uriToLibrary[library.uriStr] = library;
      }
      idToLibrary.removeWhere((uriStr, library) {
        return change.removed.contains(library.id);
      });
      uriToLibrary.removeWhere((uriStr, library) {
        return change.removed.contains(library.id);
      });
    });
  }

  Future<void> _doAllTrackerWork() async {
    while (tracker.hasWork) {
      tracker.doWork();
    }
    await pumpEventQueue();
  }

  Declaration _getDeclaration(List<Declaration> declarations, String name) {
    return declarations.singleWhere((declaration) => declaration.name == name);
  }

  Library _getLibrary(String uriStr) {
    var library = uriToLibrary[uriStr];
    expect(library, isNotNull);
    return library;
  }
}

class _ExpectedDeclaration {
  final DeclarationKind kind;
  final String name;
  final List<_ExpectedDeclaration> children;

  _ExpectedDeclaration(this.kind, this.name, {this.children: const []});

  _ExpectedDeclaration.class_(String name, List<_ExpectedDeclaration> children)
      : this(DeclarationKind.CLASS, name, children: children);

  _ExpectedDeclaration.classTypeAlias(String name)
      : this(DeclarationKind.CLASS_TYPE_ALIAS, name);

  _ExpectedDeclaration.constructor(String name)
      : this(DeclarationKind.CONSTRUCTOR, name);

  _ExpectedDeclaration.enum_(String name, List<_ExpectedDeclaration> children)
      : this(DeclarationKind.ENUM, name, children: children);

  _ExpectedDeclaration.enumConstant(String name)
      : this(DeclarationKind.ENUM_CONSTANT, name);

  _ExpectedDeclaration.function(String name)
      : this(DeclarationKind.FUNCTION, name);

  _ExpectedDeclaration.functionTypeAlias(String name)
      : this(DeclarationKind.FUNCTION_TYPE_ALIAS, name);

  _ExpectedDeclaration.mixin(String name) : this(DeclarationKind.MIXIN, name);

  _ExpectedDeclaration.variable(String name)
      : this(DeclarationKind.VARIABLE, name);

  @override
  String toString() {
    return '($kind, $name)';
  }
}