Simplify handling of pathnames in integration tests.

pkg/analysis_server/test/integration/analysis_domain_int_test.dart

 // Copyright (c) 2014, 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 test.integration.analysis.domain;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_testing/reflective_tests.dart';
 import 'package:path/path.dart';
 import 'package:unittest/unittest.dart';
 
 import 'integration_tests.dart';
 import 'protocol_matchers.dart';
 
 @ReflectiveTestCase()
 class AnalysisDomainIntegrationTest extends
     AbstractAnalysisServerIntegrationTest {
   test_getHover() {
-    String filename = 'test.dart';
-    String pathname = normalizePath(filename);
+    String pathname = sourcePath('test.dart');
     String text =
         r'''
 library lib.test;
 
 List topLevelVar;
 
 /**
  * Documentation for func
  */
 void func(int param) {
   num localVar = topLevelVar.length;
   topLevelVar.length = param;
   topLevelVar.add(localVar);
 }
 
 main() {
   func(35);
 }
 ''';
-    writeFile(filename, text);
-    setAnalysisRoots(['']);
+    writeFile(pathname, text);
+    standardAnalysisRoot();
 
     testHover(String target, int length, List<String> descriptionRegexps, String
         kind, List<String> staticTypeRegexps, {bool isCore: false, String docRegexp:
         null, bool isLiteral: false, List<String> parameterRegexps:
         null, propagatedType: null}) {
       int offset = text.indexOf(target);
       return server.send(ANALYSIS_GET_HOVER, {
         'file': pathname,
         'offset': offset
       }).then((result) {
@@ skipping 77 matching lines @@
           ['num'], parameterRegexps: ['.*'], propagatedType: 'int'));
       tests.add(testHover('func(35', 4, ['func', 'int', 'param'], 'function',
           null, docRegexp: 'Documentation for func'));
       tests.add(testHover('35', 2, null, null, ['int'], isLiteral: true,
           parameterRegexps: ['int', 'param']));
       return Future.wait(tests);
     });
   }
 
   test_getHover_noInfo() {
-    String filename = 'test.dart';
-    String pathname = normalizePath(filename);
+    String pathname = sourcePath('test.dart');
     String text = r'''
 main() {
   // no code
 }
 ''';
-    writeFile(filename, text);
-    setAnalysisRoots(['']);
+    writeFile(pathname, text);
+    standardAnalysisRoot();
 
     // Note: analysis.getHover doesn't wait for analysis to complete--it simply
     // returns the latest results that are available at the time that the
     // request is made.  So wait for analysis to finish before testing anything.
     return analysisFinished.then((_) {
       return server.send(ANALYSIS_GET_HOVER, {
         'file': pathname,
         'offset': text.indexOf('no code')
       }).then((result) {
         expect(result, isAnalysisGetHoverResult);
         expect(result['hovers'], hasLength(0));
       });
     });
   }
 
   test_getErrors_before_analysis() {
     return getErrorsTest(false);
   }
 
   test_getErrors_after_analysis() {
     return getErrorsTest(true);
   }
 
   Future getErrorsTest(bool afterAnalysis) {
-    String filename = 'test.dart';
-    String pathname = normalizePath(filename);
+    String pathname = sourcePath('test.dart');
     String text = r'''
 main() {
   var x // parse error: missing ';'
 }''';
-    writeFile(filename, text);
-    setAnalysisRoots(['']);
+    writeFile(pathname, text);
+    standardAnalysisRoot();
     Future finishTest() {
       return server.send(ANALYSIS_GET_ERRORS, {
         'file': pathname
       }).then((result) {
         expect(result, isAnalysisGetErrorsResult);
         expect(result['errors'], equals(currentAnalysisErrors[pathname]));
       });
     }
     if (afterAnalysis) {
       return analysisFinished.then((_) => finishTest());
     } else {
       return finishTest();
     }
   }
 
   test_updateContent_content_only() {
     return updateContentTest(false);
   }
 
   test_updateContent_including_offset_and_lengths() {
     return updateContentTest(true);
   }
 
   Future updateContentTest(bool includeOffsetAndLengths) {
-    String filename = 'test.dart';
-    String pathname = normalizePath(filename);
+    String pathname = sourcePath('test.dart');
     String goodText = r'''
 main() {
   print("Hello, world!");
 }''';
     String badText = goodText.replaceAll(';', '');
-    writeFile(filename, badText);
-    setAnalysisRoots(['']);
+    writeFile(pathname, badText);
+    standardAnalysisRoot();
     return analysisFinished.then((_) {
       // The contents on disk (badText) are missing a semicolon.
       expect(currentAnalysisErrors[pathname], isNot(isEmpty));
       var contentChange = {
         'content': goodText
       };
       if (includeOffsetAndLengths) {
         contentChange['offset'] = goodText.indexOf(';');
         contentChange['oldLength'] = 0;
         contentChange['newLength'] = 1;
@@ skipping 24 matching lines @@
       // Now there should be errors again, because the contents on disk are no
       // longer overridden.
       expect(currentAnalysisErrors[pathname], isNot(isEmpty));
     });
   }
 }
 
 main() {
   runReflectiveTests(AnalysisDomainIntegrationTest);
 }