Split out options from ContextBuilder

pkg/analyzer/test/src/context/builder_test.dart

 // Copyright (c) 2016, 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.
 
 library analyzer.test.src.context.context_builder_test;
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/plugin/options.dart';
 import 'package:analyzer/src/context/builder.dart';
@@ skipping 37 matching lines @@
    * The SDK manager used by the tests;
    */
   DartSdkManager sdkManager;
 
   /**
    * The content cache used by the tests.
    */
   ContentCache contentCache;
 
   /**
+   * The options passed to the context builder.
+   */
+  ContextBuilderOptions builderOptions = new ContextBuilderOptions();
+
+  /**
    * The context builder to be used in the test.
    */
   ContextBuilder builder;
 
   /**
    * The path to the default SDK, or `null` if the test has not explicitly
    * invoked [createDefaultSdk].
    */
   String defaultSdkPath = null;
 
   Uri convertedDirectoryUri(String directoryPath) {
     return new Uri.directory(resourceProvider.convertPath(directoryPath),
         windows: pathContext.style == path.windows.style);
   }
 
   void createDefaultSdk(Folder sdkDir) {
     defaultSdkPath = pathContext.join(sdkDir.path, 'default', 'sdk');
     String librariesFilePath = pathContext.join(defaultSdkPath, 'lib',
         '_internal', 'sdk_library_metadata', 'lib', 'libraries.dart');
     resourceProvider.newFile(
         librariesFilePath,
         r'''
 const Map<String, LibraryInfo> libraries = const {
   "async": const LibraryInfo("async/async.dart"),
   "core": const LibraryInfo("core/core.dart"),
 };
 ''');
     sdkManager = new DartSdkManager(defaultSdkPath, false);
-    builder = new ContextBuilder(resourceProvider, sdkManager, contentCache);
+    builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
+        options: builderOptions);
   }
 
   void createFile(String path, String content) {
     resourceProvider.newFile(path, content);
   }
 
   @override
   void setUp() {
     resourceProvider = new MemoryResourceProvider();
     pathContext = resourceProvider.pathContext;
     new MockSdk(resourceProvider: resourceProvider);
     sdkManager =
         new DartSdkManager(resourceProvider.convertPath('/sdk'), false);
     contentCache = new ContentCache();
-    builder = new ContextBuilder(resourceProvider, sdkManager, contentCache);
+    builder = new ContextBuilder(resourceProvider, sdkManager, contentCache,
+        options: builderOptions);
   }
 
   @failingTest
   void test_buildContext() {
     fail('Incomplete test');
   }
 
   void test_convertPackagesToMap_noPackages() {
     expect(builder.convertPackagesToMap(Packages.noPackages), isEmpty);
   }
@@ skipping 23 matching lines @@
   void test_createDefaultOptions_default() {
     // Invert a subset of the options to ensure that the default options are
     // being returned.
     AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
     defaultOptions.dart2jsHint = !defaultOptions.dart2jsHint;
     defaultOptions.enableAssertMessage = !defaultOptions.enableAssertMessage;
     defaultOptions.enableGenericMethods = !defaultOptions.enableGenericMethods;
     defaultOptions.enableStrictCallChecks =
         !defaultOptions.enableStrictCallChecks;
     defaultOptions.enableSuperMixins = !defaultOptions.enableSuperMixins;
-    builder.defaultOptions = defaultOptions;
+    builderOptions.defaultOptions = defaultOptions;
     AnalysisOptions options = builder.createDefaultOptions();
     _expectEqualOptions(options, defaultOptions);
   }
 
   void test_createDefaultOptions_noDefault() {
     AnalysisOptions options = builder.createDefaultOptions();
     _expectEqualOptions(options, new AnalysisOptionsImpl());
   }
 
   void test_createPackageMap_fromPackageDirectory_explicit() {
     // Use a package directory that is outside the project directory.
     String rootPath = resourceProvider.convertPath('/root');
     String projectPath = pathContext.join(rootPath, 'project');
     String packageDirPath = pathContext.join(rootPath, 'packages');
     String fooName = 'foo';
     String fooPath = pathContext.join(packageDirPath, fooName);
     String barName = 'bar';
     String barPath = pathContext.join(packageDirPath, barName);
     resourceProvider.newFolder(projectPath);
     resourceProvider.newFolder(fooPath);
     resourceProvider.newFolder(barPath);
 
-    builder.defaultPackagesDirectoryPath = packageDirPath;
+    builderOptions.defaultPackagesDirectoryPath = packageDirPath;
 
     Packages packages = builder.createPackageMap(projectPath);
     expect(packages, isNotNull);
     Map<String, Uri> map = packages.asMap();
     expect(map, hasLength(2));
     expect(map[fooName], convertedDirectoryUri(fooPath));
     expect(map[barName], convertedDirectoryUri(barPath));
   }
 
   void test_createPackageMap_fromPackageDirectory_inRoot() {
@@ skipping 23 matching lines @@
     resourceProvider.newFolder(projectPath);
     Uri fooUri = convertedDirectoryUri('/pkg/foo');
     Uri barUri = convertedDirectoryUri('/pkg/bar');
     createFile(
         packageFilePath,
         '''
 foo:$fooUri
 bar:$barUri
 ''');
 
-    builder.defaultPackageFilePath = packageFilePath;
+    builderOptions.defaultPackageFilePath = packageFilePath;
     Packages packages = builder.createPackageMap(projectPath);
     expect(packages, isNotNull);
     Map<String, Uri> map = packages.asMap();
     expect(map, hasLength(2));
     expect(map['foo'], fooUri);
     expect(map['bar'], barUri);
   }
 
   void test_createPackageMap_fromPackageFile_inParentOfRoot() {
     // Use a package file that is inside the parent of the project directory.
@@ skipping 180 matching lines @@
         pathContext.join(defaultSdkPath, 'lib', 'core', 'core.dart'));
 
     Source packageSource = factory.forUri('package:a/a.dart');
     expect(packageSource, isNotNull);
     expect(packageSource.fullName, pathContext.join(packageA, 'a.dart'));
   }
 
   void test_declareVariables_emptyMap() {
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     Iterable<String> expected = context.declaredVariables.variableNames;
-    builder.declaredVariables = <String, String>{};
+    builderOptions.declaredVariables = <String, String>{};
 
     builder.declareVariables(context);
     expect(context.declaredVariables.variableNames, unorderedEquals(expected));
   }
 
   void test_declareVariables_nonEmptyMap() {
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     List<String> expected = context.declaredVariables.variableNames.toList();
     expect(expected, isNot(contains('a')));
     expect(expected, isNot(contains('b')));
     expected.addAll(['a', 'b']);
-    builder.declaredVariables = <String, String>{'a': 'a', 'b': 'b'};
+    builderOptions.declaredVariables = <String, String>{'a': 'a', 'b': 'b'};
 
     builder.declareVariables(context);
     expect(context.declaredVariables.variableNames, unorderedEquals(expected));
   }
 
   void test_declareVariables_null() {
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     Iterable<String> expected = context.declaredVariables.variableNames;
 
     builder.declareVariables(context);
@@ skipping 48 matching lines @@
     expect(
         htmlSource.fullName,
         resourceProvider
             .convertPath('/sdk/lib/html/dart2js/html_dart2js.dart'));
     expect(htmlSource.exists(), isTrue);
   }
 
   void test_getAnalysisOptions_default_noOverrides() {
     AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
     defaultOptions.enableGenericMethods = true;
-    builder.defaultOptions = defaultOptions;
+    builderOptions.defaultOptions = defaultOptions;
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.enableGenericMethods = true;
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 linter:
   rules:
     - empty_constructor_bodies
 ''');
 
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     AnalysisOptions options = builder.getAnalysisOptions(context, path);
     _expectEqualOptions(options, expected);
   }
 
   void test_getAnalysisOptions_default_overrides() {
     AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
     defaultOptions.enableGenericMethods = true;
-    builder.defaultOptions = defaultOptions;
+    builderOptions.defaultOptions = defaultOptions;
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.enableSuperMixins = true;
     expected.enableGenericMethods = true;
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath =
         pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 analyzer:
@@ skipping 77 matching lines @@
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     AnalysisOptions options = builder.getAnalysisOptions(context, path);
     _expectEqualOptions(options, expected);
   }
 
   void test_getOptionsFile_explicit() {
     String path = resourceProvider.convertPath('/some/directory/path');
     String filePath = resourceProvider.convertPath('/options/analysis.yaml');
     resourceProvider.newFile(filePath, '');
 
-    builder.defaultAnalysisOptionsFilePath = filePath;
+    builderOptions.defaultAnalysisOptionsFilePath = filePath;
     File result = builder.getOptionsFile(path);
     expect(result, isNotNull);
     expect(result.path, filePath);
   }
 
   void test_getOptionsFile_inParentOfRoot_new() {
     String parentPath = resourceProvider.convertPath('/some/directory');
     String path = pathContext.join(parentPath, 'path');
     String filePath =
         pathContext.join(parentPath, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
@@ skipping 111 matching lines @@
       fail('Unexpected invocation of optionsProcessed');
     }
     expect(options, hasLength(expectedOptions.length));
     for (String key in expectedOptions.keys) {
       expect(options.containsKey(key), isTrue, reason: 'missing key $key');
       expect(options[key], expectedOptions[key],
           reason: 'values for key $key do not match');
     }
   }
 }