Removed fixed dependencies

packages/analyzer/test/src/context/cache_test.dart

Index: packages/analyzer/test/src/context/cache_test.dart
diff --git a/packages/analyzer/test/src/context/cache_test.dart b/packages/analyzer/test/src/context/cache_test.dart
index b012ffdbe1e47cd675958b634923c6795204ff26..44f609549cec0f8de3d3077888ef000049dd635a 100644
--- a/packages/analyzer/test/src/context/cache_test.dart
+++ b/packages/analyzer/test/src/context/cache_test.dart
@@ -2,41 +2,38 @@
 // 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.src.task.driver_test;
+library analyzer.test.src.context.cache_test;
 
+import 'package:analyzer/exception/exception.dart';
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/file_system/memory_file_system.dart';
+import 'package:analyzer/file_system/physical_file_system.dart';
+import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/context/cache.dart';
-import 'package:analyzer/src/generated/engine.dart'
-    show
-        AnalysisContext,
-        CacheState,
-        InternalAnalysisContext,
-        RetentionPriority;
-import 'package:analyzer/src/generated/java_engine.dart';
-import 'package:analyzer/src/generated/sdk_io.dart';
+import 'package:analyzer/src/dart/sdk/sdk.dart';
+import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/task/model.dart';
 import 'package:analyzer/task/model.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:typed_mock/typed_mock.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../generated/test_support.dart';
-import '../../reflective_tests.dart';
 import '../../utils.dart';
 
 main() {
   initializeTestEnvironment();
-  runReflectiveTests(AnalysisCacheTest);
-  runReflectiveTests(CacheEntryTest);
-  runReflectiveTests(CacheFlushManagerTest);
-  runReflectiveTests(SdkCachePartitionTest);
-  runReflectiveTests(UniversalCachePartitionTest);
-  runReflectiveTests(ResultDataTest);
+  defineReflectiveTests(AnalysisCacheTest);
+  defineReflectiveTests(CacheEntryTest);
+  defineReflectiveTests(CacheFlushManagerTest);
+  defineReflectiveTests(SdkCachePartitionTest);
+  defineReflectiveTests(UniversalCachePartitionTest);
+  defineReflectiveTests(ResultDataTest);
 }
 
-AnalysisCache createCache(
-    {AnalysisContext context,
-    RetentionPriority policy: RetentionPriority.LOW}) {
+AnalysisCache createCache({AnalysisContext context}) {
   CachePartition partition = new UniversalCachePartition(context);
   return new AnalysisCache(<CachePartition>[partition]);
 }
@@ -47,7 +44,7 @@ class AbstractCacheTest {
 
   void setUp() {
     context = new _InternalAnalysisContextMock();
-    when(context.priorityTargets).thenReturn([]);
+    when(context.prioritySources).thenReturn([]);
     cache = createCache(context: context);
     when(context.analysisCache).thenReturn(cache);
   }
@@ -59,6 +56,27 @@ class AnalysisCacheTest extends AbstractCacheTest {
     expect(cache, isNotNull);
   }
 
+  test_flush() {
+    AnalysisTarget target = new TestSource();
+    ResultDescriptor<String> resultA = new ResultDescriptor<String>('A', null);
+    ResultDescriptor<String> resultB = new ResultDescriptor<String>('B', null);
+    CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
+    // put values
+    entry.setValue(resultA, 'a', TargetedResult.EMPTY_LIST);
+    entry.setValue(resultB, 'b', TargetedResult.EMPTY_LIST);
+    expect(cache.getState(target, resultA), CacheState.VALID);
+    expect(cache.getState(target, resultB), CacheState.VALID);
+    expect(cache.getValue(target, resultA), 'a');
+    expect(cache.getValue(target, resultB), 'b');
+    // flush A
+    cache.flush((target, result) => result == resultA);
+    expect(cache.getState(target, resultA), CacheState.FLUSHED);
+    expect(cache.getState(target, resultB), CacheState.VALID);
+    expect(cache.getValue(target, resultA), isNull);
+    expect(cache.getValue(target, resultB), 'b');
+  }
+
   void test_get() {
     AnalysisTarget target = new TestSource();
     expect(cache.get(target), isNull);
@@ -106,7 +124,8 @@ class AnalysisCacheTest extends AbstractCacheTest {
   }
 
   void test_getState_hasEntry_valid() {
-    ResultDescriptor result = new ResultDescriptor('result', -1);
+    ResultDescriptor<String> result =
+        new ResultDescriptor<String>('result', null);
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
@@ -121,7 +140,7 @@ class AnalysisCacheTest extends AbstractCacheTest {
   }
 
   void test_getValue_hasEntry_valid() {
-    ResultDescriptor result = new ResultDescriptor('result', -1);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('result', -1);
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
@@ -164,9 +183,9 @@ class AnalysisCacheTest extends AbstractCacheTest {
     cache.put(entry1);
     cache.put(entry2);
     cache.put(entry3);
-    ResultDescriptor result1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor result2 = new ResultDescriptor('result2', -2);
-    ResultDescriptor result3 = new ResultDescriptor('result3', -3);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
     // set results, all of them are VALID
     entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry2.setValue(result2, 222, [new TargetedResult(target1, result1)]);
@@ -189,8 +208,8 @@ class AnalysisCacheTest extends AbstractCacheTest {
     AnalysisTarget target = new TestSource('/a.dart');
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
-    ResultDescriptor result1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor result2 = new ResultDescriptor('result2', -2);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
     // set results, all of them are VALID
     entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
@@ -240,8 +259,10 @@ class AnalysisCacheTest extends AbstractCacheTest {
 @reflectiveTest
 class CacheEntryTest extends AbstractCacheTest {
   test_dispose() {
-    ResultDescriptor descriptor1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor descriptor2 = new ResultDescriptor('result2', -2);
+    ResultDescriptor<int> descriptor1 =
+        new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> descriptor2 =
+        new ResultDescriptor<int>('result2', -2);
     AnalysisTarget target1 = new TestSource('1.dart');
     AnalysisTarget target2 = new TestSource('2.dart');
     TargetedResult result1 = new TargetedResult(target1, descriptor1);
@@ -273,6 +294,7 @@ class CacheEntryTest extends AbstractCacheTest {
     ResultDescriptor result = new ResultDescriptor('test', null);
     CaughtException exception = new CaughtException(null, null);
     CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     entry.setErrorState(exception, <ResultDescriptor>[result]);
     entry.fixExceptionState();
     expect(entry.getState(result), CacheState.ERROR);
@@ -281,7 +303,7 @@ class CacheEntryTest extends AbstractCacheTest {
 
   test_fixExceptionState_noError_exception() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('test', null);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', null);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     // set one result to ERROR
@@ -303,6 +325,27 @@ class CacheEntryTest extends AbstractCacheTest {
     expect(entry.exception, isNull);
   }
 
+  test_flush() {
+    AnalysisTarget target = new TestSource();
+    ResultDescriptor<String> resultA = new ResultDescriptor<String>('A', null);
+    ResultDescriptor<String> resultB = new ResultDescriptor<String>('B', null);
+    CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
+    // put values
+    entry.setValue(resultA, 'a', TargetedResult.EMPTY_LIST);
+    entry.setValue(resultB, 'b', TargetedResult.EMPTY_LIST);
+    expect(entry.getState(resultA), CacheState.VALID);
+    expect(entry.getState(resultB), CacheState.VALID);
+    expect(entry.getValue(resultA), 'a');
+    expect(entry.getValue(resultB), 'b');
+    // flush A
+    entry.flush((target, result) => result == resultA);
+    expect(entry.getState(resultA), CacheState.FLUSHED);
+    expect(entry.getState(resultB), CacheState.VALID);
+    expect(entry.getValue(resultA), isNull);
+    expect(entry.getValue(resultB), 'b');
+  }
+
   test_getState() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', null);
@@ -319,13 +362,17 @@ class CacheEntryTest extends AbstractCacheTest {
   }
 
   test_getValue_flushResults() {
-    ResultCachingPolicy cachingPolicy = new SimpleResultCachingPolicy(2, 2);
-    ResultDescriptor descriptor1 =
-        new ResultDescriptor('result1', null, cachingPolicy: cachingPolicy);
-    ResultDescriptor descriptor2 =
-        new ResultDescriptor('result2', null, cachingPolicy: cachingPolicy);
-    ResultDescriptor descriptor3 =
-        new ResultDescriptor('result3', null, cachingPolicy: cachingPolicy);
+    ResultCachingPolicy<int> cachingPolicy =
+        new SimpleResultCachingPolicy<int>(2, 2);
+    ResultDescriptor<int> descriptor1 = new ResultDescriptor<int>(
+        'result1', null,
+        cachingPolicy: cachingPolicy);
+    ResultDescriptor<int> descriptor2 = new ResultDescriptor<int>(
+        'result2', null,
+        cachingPolicy: cachingPolicy);
+    ResultDescriptor<int> descriptor3 = new ResultDescriptor<int>(
+        'result3', null,
+        cachingPolicy: cachingPolicy);
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
@@ -359,14 +406,17 @@ class CacheEntryTest extends AbstractCacheTest {
     ResultDescriptor result = new ResultDescriptor('test', null);
     CaughtException exception = new CaughtException(null, null);
     CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     entry.setErrorState(exception, <ResultDescriptor>[result]);
     expect(entry.hasErrorState(), true);
   }
 
   test_invalidateAllInformation() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('test', null);
+    ResultDescriptor<String> result =
+        new ResultDescriptor<String>('test', null);
     CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     entry.setValue(result, 'value', TargetedResult.EMPTY_LIST);
     entry.invalidateAllInformation();
     expect(entry.getState(result), CacheState.INVALID);
@@ -375,11 +425,12 @@ class CacheEntryTest extends AbstractCacheTest {
 
   test_setErrorState() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result1 = new ResultDescriptor('res1', 1);
-    ResultDescriptor result2 = new ResultDescriptor('res2', 2);
-    ResultDescriptor result3 = new ResultDescriptor('res3', 3);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('res1', 1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('res2', 2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('res3', 3);
     // prepare some good state
     CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     entry.setValue(result1, 10, TargetedResult.EMPTY_LIST);
     entry.setValue(result2, 20, TargetedResult.EMPTY_LIST);
     entry.setValue(result3, 30, TargetedResult.EMPTY_LIST);
@@ -403,10 +454,10 @@ class CacheEntryTest extends AbstractCacheTest {
     CacheEntry entry2 = new CacheEntry(target2);
     cache.put(entry1);
     cache.put(entry2);
-    ResultDescriptor result1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor result2 = new ResultDescriptor('result2', -2);
-    ResultDescriptor result3 = new ResultDescriptor('result3', -3);
-    ResultDescriptor result4 = new ResultDescriptor('result4', -4);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
+    ResultDescriptor<int> result4 = new ResultDescriptor<int>('result4', -4);
     // set results, all of them are VALID
     entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry2.setValue(result2, 222, [new TargetedResult(target1, result1)]);
@@ -465,8 +516,9 @@ class CacheEntryTest extends AbstractCacheTest {
 
   test_setState_error() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('test', null);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', null);
     CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     entry.setValue(result, 42, TargetedResult.EMPTY_LIST);
     // an invalid state change
     expect(() {
@@ -479,8 +531,9 @@ class CacheEntryTest extends AbstractCacheTest {
 
   test_setState_flushed() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('test', 1);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', 1);
     CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     // set VALID
     entry.setValue(result, 10, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result), CacheState.VALID);
@@ -493,8 +546,9 @@ class CacheEntryTest extends AbstractCacheTest {
 
   test_setState_inProcess() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('test', 1);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', 1);
     CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     // set VALID
     entry.setValue(result, 10, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result), CacheState.VALID);
@@ -507,7 +561,7 @@ class CacheEntryTest extends AbstractCacheTest {
 
   test_setState_invalid() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('test', 1);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', 1);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     // set VALID
@@ -535,7 +589,7 @@ class CacheEntryTest extends AbstractCacheTest {
     CacheEntry entry2 = new CacheEntry(target2);
     cache.put(entry1);
     cache.put(entry2);
-    ResultDescriptor result = new ResultDescriptor('result', -1);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('result', -1);
     // Set each result as VALID with a dependency on on the other.
     entry1.setValue(result, 100, [new TargetedResult(target2, result)]);
     entry2.setValue(result, 200, [new TargetedResult(target1, result)]);
@@ -565,10 +619,10 @@ class CacheEntryTest extends AbstractCacheTest {
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
-    ResultDescriptor result1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor result2 = new ResultDescriptor('result2', -2);
-    ResultDescriptor result3 = new ResultDescriptor('result3', -3);
-    ResultDescriptor result4 = new ResultDescriptor('result4', -4);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
+    ResultDescriptor<int> result4 = new ResultDescriptor<int>('result4', -4);
     // set results, all of them are VALID
     entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
@@ -596,6 +650,21 @@ class CacheEntryTest extends AbstractCacheTest {
     expect(cache.get(target), entry);
   }
 
+  test_setState_invalid_keepEmpty_ifExplicitlyAdded() {
+    AnalysisTarget target = new TestSource('/a.dart');
+    CacheEntry entry = new CacheEntry(target);
+    entry.explicitlyAdded = true;
+    cache.put(entry);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('result1', -1);
+    // set results, all of them are VALID
+    entry.setValue(result, 111, TargetedResult.EMPTY_LIST);
+    expect(entry.getState(result), CacheState.VALID);
+    expect(entry.getValue(result), 111);
+    // invalidate result, keep entry
+    entry.setState(result, CacheState.INVALID);
+    expect(cache.get(target), isNotNull);
+  }
+
   test_setState_invalid_removeEmptyEntry() {
     AnalysisTarget target1 = new TestSource('/a.dart');
     AnalysisTarget target2 = new TestSource('/b.dart');
@@ -603,9 +672,9 @@ class CacheEntryTest extends AbstractCacheTest {
     CacheEntry entry2 = new CacheEntry(target2);
     cache.put(entry1);
     cache.put(entry2);
-    ResultDescriptor result1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor result2 = new ResultDescriptor('result2', -2);
-    ResultDescriptor result3 = new ResultDescriptor('result3', -3);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
     // set results, all of them are VALID
     entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry2.setValue(result2, 222, [new TargetedResult(target1, result1)]);
@@ -626,9 +695,9 @@ class CacheEntryTest extends AbstractCacheTest {
     Source target = new TestSource('/test.dart');
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
-    ResultDescriptor result1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor result2 = new ResultDescriptor('result2', -2);
-    ResultDescriptor result3 = new ResultDescriptor('result3', -3);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
     // set results, all of them are VALID
     entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
@@ -641,6 +710,12 @@ class CacheEntryTest extends AbstractCacheTest {
         unorderedEquals([new TargetedResult(target, result2)]));
     expect(entry.getResultData(result2).dependedOnResults,
         unorderedEquals([new TargetedResult(target, result1)]));
+    // record invalidated results
+    Set<TargetedResult> reportedInvalidatedResults = new Set<TargetedResult>();
+    cache.onResultInvalidated.listen((InvalidatedResult invalidatedResult) {
+      reportedInvalidatedResults.add(new TargetedResult(
+          invalidatedResult.entry.target, invalidatedResult.descriptor));
+    });
     // invalidate result2 with Delta: keep result2, invalidate result3
     entry.setState(result2, CacheState.INVALID,
         delta: new _KeepContinueDelta(target, result2));
@@ -652,6 +727,10 @@ class CacheEntryTest extends AbstractCacheTest {
         unorderedEquals([new TargetedResult(target, result2)]));
     expect(entry.getResultData(result2).dependedOnResults,
         unorderedEquals([new TargetedResult(target, result1)]));
+    // (target, result3) was reported as invalidated
+    // (target, result2) was NOT reported
+    expect(reportedInvalidatedResults,
+        unorderedEquals([new TargetedResult(target, result3)]));
   }
 
   test_setState_valid() {
@@ -663,22 +742,28 @@ class CacheEntryTest extends AbstractCacheTest {
 
   test_setValue() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('test', null);
+    ResultDescriptor<String> result =
+        new ResultDescriptor<String>('test', null);
     String value = 'value';
     CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     entry.setValue(result, value, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result), CacheState.VALID);
     expect(entry.getValue(result), value);
   }
 
   test_setValue_flushResults() {
-    ResultCachingPolicy cachingPolicy = new SimpleResultCachingPolicy(2, 2);
-    ResultDescriptor descriptor1 =
-        new ResultDescriptor('result1', null, cachingPolicy: cachingPolicy);
-    ResultDescriptor descriptor2 =
-        new ResultDescriptor('result2', null, cachingPolicy: cachingPolicy);
-    ResultDescriptor descriptor3 =
-        new ResultDescriptor('result3', null, cachingPolicy: cachingPolicy);
+    ResultCachingPolicy<int> cachingPolicy =
+        new SimpleResultCachingPolicy<int>(2, 2);
+    ResultDescriptor<int> descriptor1 = new ResultDescriptor<int>(
+        'result1', null,
+        cachingPolicy: cachingPolicy);
+    ResultDescriptor<int> descriptor2 = new ResultDescriptor<int>(
+        'result2', null,
+        cachingPolicy: cachingPolicy);
+    ResultDescriptor<int> descriptor3 = new ResultDescriptor<int>(
+        'result3', null,
+        cachingPolicy: cachingPolicy);
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
@@ -699,12 +784,50 @@ class CacheEntryTest extends AbstractCacheTest {
     }
   }
 
+  test_setValue_flushResults_keepForPrioritySources() {
+    ResultCachingPolicy<int> cachingPolicy =
+        new SimpleResultCachingPolicy<int>(2, 2);
+    ResultDescriptor<int> newResult(String name) =>
+        new ResultDescriptor<int>(name, null, cachingPolicy: cachingPolicy);
+    ResultDescriptor<int> descriptor1 = newResult('result1');
+    ResultDescriptor<int> descriptor2 = newResult('result2');
+    ResultDescriptor<int> descriptor3 = newResult('result3');
+    TestSource source1 = new TestSource('/a.dart');
+    TestSource source2 = new TestSource('/b.dart');
+    TestSource source3 = new TestSource('/c.dart');
+    AnalysisTarget target1 =
+        new _TestAnalysisTarget(librarySource: source1, source: source1);
+    AnalysisTarget target2 =
+        new _TestAnalysisTarget(librarySource: source2, source: source2);
+    AnalysisTarget target3 =
+        new _TestAnalysisTarget(librarySource: source3, source: source3);
+    CacheEntry entry1 = new CacheEntry(target1);
+    CacheEntry entry2 = new CacheEntry(target2);
+    CacheEntry entry3 = new CacheEntry(target3);
+    cache.put(entry1);
+    cache.put(entry2);
+    cache.put(entry3);
+
+    // Set two results.
+    entry1.setValue(descriptor1, 1, TargetedResult.EMPTY_LIST);
+    entry2.setValue(descriptor2, 2, TargetedResult.EMPTY_LIST);
+    expect(entry1.getState(descriptor1), CacheState.VALID);
+    expect(entry2.getState(descriptor2), CacheState.VALID);
+
+    // Make source1 priority, so result2 is flushed instead.
+    when(context.prioritySources).thenReturn([source1]);
+    entry3.setValue(descriptor3, 3, TargetedResult.EMPTY_LIST);
+    expect(entry1.getState(descriptor1), CacheState.VALID);
+    expect(entry2.getState(descriptor2), CacheState.FLUSHED);
+    expect(entry3.getState(descriptor3), CacheState.VALID);
+  }
+
   test_setValue_keepDependent() {
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
-    ResultDescriptor result1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor result2 = new ResultDescriptor('result2', -2);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
     // set results, all of them are VALID
     entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
@@ -720,13 +843,35 @@ class CacheEntryTest extends AbstractCacheTest {
     expect(entry.getValue(result2), 222);
   }
 
+  test_setValue_userBeforeProvider_invalidateProvider_alsoUser() {
+    AnalysisTarget target1 = new TestSource('/a.dart');
+    AnalysisTarget target2 = new TestSource('/b.dart');
+    CacheEntry entry1 = new CacheEntry(target1);
+    CacheEntry entry2 = new CacheEntry(target2);
+    cache.put(entry1);
+    cache.put(entry2);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    // set results, all of them are VALID
+    entry2.setValue(result2, 222, [new TargetedResult(target1, result1)]);
+    entry1.setValue(result1, 111, TargetedResult.EMPTY_LIST);
+    expect(entry1.getState(result1), CacheState.VALID);
+    expect(entry2.getState(result2), CacheState.VALID);
+    expect(entry1.getValue(result1), 111);
+    expect(entry2.getValue(result2), 222);
+    // invalidate result1, should invalidate also result2
+    entry1.setState(result1, CacheState.INVALID);
+    expect(entry1.getState(result1), CacheState.INVALID);
+    expect(entry2.getState(result2), CacheState.INVALID);
+  }
+
   test_setValueIncremental() {
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
-    ResultDescriptor result1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor result2 = new ResultDescriptor('result2', -2);
-    ResultDescriptor result3 = new ResultDescriptor('result3', -3);
+    ResultDescriptor<int> result1 = new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> result2 = new ResultDescriptor<int>('result2', -2);
+    ResultDescriptor<int> result3 = new ResultDescriptor<int>('result3', -3);
     // set results, all of them are VALID
     entry.setValue(result1, 111, TargetedResult.EMPTY_LIST);
     entry.setValue(result2, 222, [new TargetedResult(target, result1)]);
@@ -759,8 +904,9 @@ class CacheEntryTest extends AbstractCacheTest {
 
   test_toString_nonEmpty() {
     AnalysisTarget target = new TestSource();
-    ResultDescriptor result = new ResultDescriptor('test', null);
+    ResultDescriptor<int> result = new ResultDescriptor<int>('test', null);
     CacheEntry entry = new CacheEntry(target);
+    cache.put(entry);
     entry.setValue(result, 42, TargetedResult.EMPTY_LIST);
     expect(entry.toString(), isNotNull);
   }
@@ -801,7 +947,7 @@ class CacheFlushManagerTest {
   test_new() {
     expect(manager.maxActiveSize, 15);
     expect(manager.maxIdleSize, 3);
-    expect(manager.maxSize, 3);
+    expect(manager.maxSize, 15);
     expect(manager.currentSize, 0);
     expect(manager.recentlyUsed, isEmpty);
   }
@@ -862,6 +1008,8 @@ class CacheFlushManagerTest {
   }
 
   test_resultStored() {
+    CacheFlushManager manager = new CacheFlushManager(
+        new SimpleResultCachingPolicy(3, 3), (AnalysisTarget target) => false);
     ResultDescriptor descriptor1 = new ResultDescriptor('result1', null);
     ResultDescriptor descriptor2 = new ResultDescriptor('result2', null);
     ResultDescriptor descriptor3 = new ResultDescriptor('result3', null);
@@ -946,12 +1094,31 @@ abstract class CachePartitionTest extends EngineTestCase {
     expect(createPartition(), isNotNull);
   }
 
+  void test_dispose() {
+    CachePartition partition = createPartition();
+    Source source1 = new TestSource('/1.dart');
+    Source source2 = new TestSource('/2.dart');
+    CacheEntry entry1 = new CacheEntry(source1);
+    CacheEntry entry2 = new CacheEntry(source2);
+    // add two sources
+    partition.put(entry1);
+    partition.put(entry2);
+    expect(partition.entryMap, hasLength(2));
+    expect(partition.pathToSource, hasLength(2));
+    expect(partition.sources, unorderedEquals([source1, source2]));
+    // dispose, no sources
+    partition.dispose();
+    expect(partition.entryMap, isEmpty);
+    expect(partition.pathToSource, isEmpty);
+    expect(partition.sources, isEmpty);
+  }
+
   void test_entrySet() {
     CachePartition partition = createPartition();
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     partition.put(entry);
-    Map<AnalysisTarget, CacheEntry> entryMap = partition.map;
+    Map<AnalysisTarget, CacheEntry> entryMap = partition.entryMap;
     expect(entryMap, hasLength(1));
     AnalysisTarget entryKey = entryMap.keys.first;
     expect(entryKey, target);
@@ -1000,6 +1167,35 @@ abstract class CachePartitionTest extends EngineTestCase {
   }
 }
 
+@reflectiveTest
+class PackageCachePartitionTest extends CachePartitionTest {
+  MemoryResourceProvider resourceProvider;
+  Folder rootFolder;
+
+  CachePartition createPartition() {
+    resourceProvider = new MemoryResourceProvider();
+    rootFolder = resourceProvider.newFolder('/package/root');
+    return new PackageCachePartition(null, rootFolder);
+  }
+
+  void test_contains_false() {
+    CachePartition partition = createPartition();
+    AnalysisTarget target = new TestSource();
+    expect(partition.isResponsibleFor(target), isFalse);
+  }
+
+  void test_contains_true() {
+    SdkCachePartition partition = new SdkCachePartition(null);
+    SourceFactory factory = new SourceFactory([
+      new PackageMapUriResolver(resourceProvider, <String, List<Folder>>{
+        'root': <Folder>[rootFolder]
+      })
+    ]);
+    AnalysisTarget target = factory.forUri("package:root/root.dart");
+    expect(partition.isResponsibleFor(target), isTrue);
+  }
+}
+
 @reflectiveTest
 class ResultDataTest extends EngineTestCase {
   test_creation() {
@@ -1035,8 +1231,10 @@ class SdkCachePartitionTest extends CachePartitionTest {
 
   void test_contains_true() {
     SdkCachePartition partition = new SdkCachePartition(null);
-    SourceFactory factory = new SourceFactory(
-        [new DartUriResolver(DirectoryBasedDartSdk.defaultSdk)]);
+    ResourceProvider resourceProvider = PhysicalResourceProvider.INSTANCE;
+    FolderBasedDartSdk sdk = new FolderBasedDartSdk(resourceProvider,
+        FolderBasedDartSdk.defaultSdkDirectory(resourceProvider));
+    SourceFactory factory = new SourceFactory([new DartUriResolver(sdk)]);
     AnalysisTarget target = factory.forUri("dart:core");
     expect(partition.isResponsibleFor(target), isTrue);
   }
@@ -1062,8 +1260,10 @@ class UniversalCachePartitionTest extends CachePartitionTest {
     when(context.analysisCache).thenReturn(cache);
     // configure
     // prepare entries
-    ResultDescriptor descriptor1 = new ResultDescriptor('result1', -1);
-    ResultDescriptor descriptor2 = new ResultDescriptor('result2', -2);
+    ResultDescriptor<int> descriptor1 =
+        new ResultDescriptor<int>('result1', -1);
+    ResultDescriptor<int> descriptor2 =
+        new ResultDescriptor<int>('result2', -2);
     AnalysisTarget target1 = new TestSource('1.dart');
     AnalysisTarget target2 = new TestSource('2.dart');
     TargetedResult result1 = new TargetedResult(target1, descriptor1);
@@ -1088,7 +1288,8 @@ class UniversalCachePartitionTest extends CachePartitionTest {
 
 class _InternalAnalysisContextMock extends TypedMock
     implements InternalAnalysisContext {
-  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+  @override
+  final AnalysisOptions analysisOptions = new AnalysisOptionsImpl();
 }
 
 /**
@@ -1100,9 +1301,21 @@ class _KeepContinueDelta implements Delta {
 
   _KeepContinueDelta(this.source, this.keepDescriptor);
 
+  @override
+  bool get shouldGatherChanges => false;
+
+  @override
+  bool gatherChanges(InternalAnalysisContext context, AnalysisTarget target,
+      ResultDescriptor descriptor, Object value) {
+    return false;
+  }
+
+  @override
+  void gatherEnd() {}
+
   @override
   DeltaResult validate(InternalAnalysisContext context, AnalysisTarget target,
-      ResultDescriptor descriptor) {
+      ResultDescriptor descriptor, Object value) {
     if (descriptor == keepDescriptor) {
       return DeltaResult.KEEP_CONTINUE;
     }
@@ -1111,6 +1324,7 @@ class _KeepContinueDelta implements Delta {
 }
 
 class _TestAnalysisTarget implements AnalysisTarget {
-  @override
-  Source get source => null;
+  final Source librarySource;
+  final Source source;
+  _TestAnalysisTarget({this.librarySource, this.source});
 }