Enhance the tests for ComputeLibraryCycleTask

pkg/analyzer/test/src/task/dart_test.dart

 // Copyright (c) 2015, 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.task.dart_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 1555 matching lines @@
 ''');
     Source lib3Source = newSource(
         '/my_lib3.dart',
         '''
 library my_lib3;
 import 'my_lib2.dart';
 ''');
     AnalysisTarget lib1Target = new LibrarySpecificUnit(lib1Source, lib1Source);
     AnalysisTarget lib2Target = new LibrarySpecificUnit(lib2Source, lib2Source);
     AnalysisTarget lib3Target = new LibrarySpecificUnit(lib3Source, lib3Source);
+
     computeResult(lib1Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(1));
     computeResult(lib2Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(1));
     computeResult(lib3Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(1));
 
-    // complete the cycle
+    // create a cycle
     context.setContents(
         lib1Source,
         '''
 library my_lib1;
 import 'my_lib3.dart';
 ''');
+    _expectInvalid(lib1Target);
+    _expectInvalid(lib2Target);
+    _expectInvalid(lib3Target);
+
     computeResult(lib1Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(3));
     computeResult(lib2Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(3));
     computeResult(lib3Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(3));
 
     // break the cycle again
     context.setContents(
         lib1Source,
         '''
 library my_lib1;
 ''');
+    _expectInvalid(lib1Target);
+    _expectInvalid(lib2Target);
+    _expectInvalid(lib3Target);
+
     computeResult(lib1Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(1));
     computeResult(lib2Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(1));
     computeResult(lib3Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(1));
   }
 
   void test_library_cycle_incremental_partial() {
     enableStrongMode();
@@ skipping 10 matching lines @@
 ''');
     Source lib3Source = newSource(
         '/my_lib3.dart',
         '''
 library my_lib3;
 import 'my_lib2.dart';
 ''');
     AnalysisTarget lib1Target = new LibrarySpecificUnit(lib1Source, lib1Source);
     AnalysisTarget lib2Target = new LibrarySpecificUnit(lib2Source, lib2Source);
     AnalysisTarget lib3Target = new LibrarySpecificUnit(lib3Source, lib3Source);
+
     computeResult(lib1Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(1));
     computeResult(lib2Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(1));
     // lib3 is not reachable, so we have not yet computed its library
     // cycles
 
     // complete the cycle, via lib3
     context.setContents(
         lib1Source,
         '''
 library my_lib1;
 import 'my_lib3.dart';
 ''');
+    _expectInvalid(lib1Target);
+    _expectInvalid(lib2Target);
+    _expectInvalid(lib3Target);
+
     // Ensure that invalidation correctly invalidated everything reachable
     // through lib3
     computeResult(lib1Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(3));
     computeResult(lib2Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(3));
     computeResult(lib3Target, LIBRARY_CYCLE);
     expect(outputs[LIBRARY_CYCLE], hasLength(3));
   }
 
@@ skipping 99 matching lines @@
     expect(b.getMethod('foo').returnType.toString(), 'int');
 
     // add a dummy edit.
     context.setContents(
         lib1Source,
         '''
 library my_lib1;
 import 'my_lib3.dart';
 var foo = 123;
 ''');
+    _expectInvalid(lib1Target);
+    _expectInvalid(lib2Target);
+    _expectInvalid(lib3Target);
 
     computeResult(lib1Target, RESOLVED_UNIT);
     computeResult(lib2Target, RESOLVED_UNIT);
     computeResult(lib3Target, RESOLVED_UNIT);
     unit = outputs[RESOLVED_UNIT];
     b = unit.declarations[1].element;
     expect(b.getMethod('foo').returnType.toString(), 'int',
         reason: 'edit should not affect member inference');
   }
 
@@ skipping 216 matching lines @@
     List<CompilationUnitElement> dep7 = getLibraryCycleDependencies(results7);
     expect(dep0, hasLength(1)); // dart:core
     expect(dep1, hasLength(1)); // dart:core
     expect(dep2, hasLength(1)); // dart:core
     expect(dep3, hasLength(1)); // dart:core
     expect(dep4, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
     expect(dep5, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
     expect(dep6, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
     expect(dep7, hasLength(5)); // dart:core, a.dart, aa.dart, ab.dart, b.dart
   }
+
+  void _expectInvalid(LibrarySpecificUnit target) {
+    CacheEntry entry = context.getCacheEntry(target);
+    expect(entry.getState(LIBRARY_CYCLE), CacheState.INVALID);
+  }
 }
 
 @reflectiveTest
 class ComputePropagableVariableDependenciesTaskTest
     extends _AbstractDartTaskTest {
   List<VariableElement> getPropagableVariableDependencies(
       Map<ResultDescriptor, dynamic> outputs) {
     return outputs[PROPAGABLE_VARIABLE_DEPENDENCIES] as List<VariableElement>;
   }
 
@@ skipping 3342 matching lines @@
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result] as List<AnalysisError>;
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }