Add CacheEntry.setErrorState().

pkg/analyzer/test/src/context/cache_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 test.src.task.driver_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, CacheState, RetentionPriority;
@@ skipping 141 matching lines @@
     CacheEntry entry = new CacheEntry();
     expect(entry.explicitlyAdded, false);
     entry.explicitlyAdded = true;
     expect(entry.explicitlyAdded, true);
   }
 
   test_fixExceptionState_error_exception() {
     ResultDescriptor result = new ResultDescriptor('test', null);
     CaughtException exception = new CaughtException(null, null);
     CacheEntry entry = new CacheEntry();
-    entry.setState(result, CacheState.ERROR);
-    entry.exception = exception;
+    entry.setErrorState(<ResultDescriptor>[result], exception);
     entry.fixExceptionState();
     expect(entry.getState(result), CacheState.ERROR);
     expect(entry.exception, exception);
   }
 
-  test_fixExceptionState_error_noException() {
-    ResultDescriptor result = new ResultDescriptor('test', null);
-    CacheEntry entry = new CacheEntry();
-    entry.setState(result, CacheState.ERROR);
-    entry.fixExceptionState();
-    expect(entry.getState(result), CacheState.ERROR);
-    expect(entry.exception, isNotNull);
-  }
-
   test_fixExceptionState_noError_exception() {
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry();
-    entry.exception = new CaughtException(null, null);
+    // set one result to ERROR
+    CaughtException exception = new CaughtException(null, null);
+    entry.setErrorState(<ResultDescriptor>[result], exception);
+    // set the same result to VALID
+    entry.setValue(result, 1);
+    // fix the exception state
     entry.fixExceptionState();
-    expect(entry.getState(result), CacheState.INVALID);
     expect(entry.exception, isNull);
   }
 
   test_fixExceptionState_noError_noException() {
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry();
     entry.fixExceptionState();
     expect(entry.getState(result), CacheState.INVALID);
     expect(entry.exception, isNull);
   }
@@ skipping 32 matching lines @@
     expect(entry.hasAstStructure, true);
   }
 
   test_hasErrorState_false() {
     CacheEntry entry = new CacheEntry();
     expect(entry.hasErrorState(), false);
   }
 
   test_hasErrorState_true() {
     ResultDescriptor result = new ResultDescriptor('test', null);
+    CaughtException exception = new CaughtException(null, null);
     CacheEntry entry = new CacheEntry();
-    entry.setState(result, CacheState.ERROR);
+    entry.setErrorState(<ResultDescriptor>[result], exception);
     expect(entry.hasErrorState(), true);
   }
 
   test_invalidateAllInformation() {
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry();
     entry.setValue(result, 'value');
     entry.invalidateAllInformation();
     expect(entry.getState(result), CacheState.INVALID);
     expect(entry.getValue(result), isNull);
   }
 
+  test_setErrorState() {
+    ResultDescriptor result1 = new ResultDescriptor('res1', 1);
+    ResultDescriptor result2 = new ResultDescriptor('res2', 2);
+    ResultDescriptor result3 = new ResultDescriptor('res3', 3);
+    // prepare some good state
+    CacheEntry entry = new CacheEntry();
+    entry.setValue(result1, 10);
+    entry.setValue(result2, 20);
+    entry.setValue(result3, 30);
+    // set error state
+    CaughtException exception = new CaughtException(null, null);
+    entry.setErrorState(<ResultDescriptor>[result1, result2], exception);
+    // verify
+    expect(entry.exception, exception);
+    expect(entry.getState(result1), CacheState.ERROR);
+    expect(entry.getState(result2), CacheState.ERROR);
+    expect(entry.getState(result3), CacheState.VALID);
+    expect(entry.getValue(result1), 1);
+    expect(entry.getValue(result2), 2);
+    expect(entry.getValue(result3), 30);
+  }
+
+  test_setErrorState_noDescriptors() {
+    CaughtException exception = new CaughtException(null, null);
+    CacheEntry entry = new CacheEntry();
+    expect(() {
+      entry.setErrorState(<ResultDescriptor>[], exception);
+    }, throwsArgumentError);
+  }
+
+  test_setErrorState_noException() {
+    ResultDescriptor result = new ResultDescriptor('test', null);
+    CacheEntry entry = new CacheEntry();
+    expect(() {
+      entry.setErrorState(<ResultDescriptor>[result], null);
+    }, throwsArgumentError);
+  }
+
   test_setState_error() {
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry();
-    entry.setState(result, CacheState.ERROR);
-    expect(entry.getState(result), CacheState.ERROR);
-    expect(entry.getValue(result), isNull);
+    entry.setValue(result, 42);
+    // an invalid state change
+    expect(() {
+      entry.setState(result, CacheState.ERROR);
+    }, throwsArgumentError);
+    // no changes
+    expect(entry.getState(result), CacheState.VALID);
+    expect(entry.getValue(result), 42);
+  }
+
+  test_setState_flushed() {
+    ResultDescriptor result = new ResultDescriptor('test', 1);
+    CacheEntry entry = new CacheEntry();
+    // set VALID
+    entry.setValue(result, 10);
+    expect(entry.getState(result), CacheState.VALID);
+    expect(entry.getValue(result), 10);
+    // set FLUSHED
+    entry.setState(result, CacheState.FLUSHED);
+    expect(entry.getState(result), CacheState.FLUSHED);
+    expect(entry.getValue(result), 1);
+  }
+
+  test_setState_inProcess() {
+    ResultDescriptor result = new ResultDescriptor('test', 1);
+    CacheEntry entry = new CacheEntry();
+    // set VALID
+    entry.setValue(result, 10);
+    expect(entry.getState(result), CacheState.VALID);
+    expect(entry.getValue(result), 10);
+    // set IN_PROCESS
+    entry.setState(result, CacheState.IN_PROCESS);
+    expect(entry.getState(result), CacheState.IN_PROCESS);
+    expect(entry.getValue(result), 10);
   }
 
   test_setState_invalid() {
-    ResultDescriptor result = new ResultDescriptor('test', null);
+    ResultDescriptor result = new ResultDescriptor('test', 1);
     CacheEntry entry = new CacheEntry();
+    // set VALID
+    entry.setValue(result, 10);
+    expect(entry.getState(result), CacheState.VALID);
+    expect(entry.getValue(result), 10);
+    // set INVALID
     entry.setState(result, CacheState.INVALID);
     expect(entry.getState(result), CacheState.INVALID);
-    expect(entry.getValue(result), isNull);
+    expect(entry.getValue(result), 1);
   }
 
   test_setState_valid() {
     ResultDescriptor result = new ResultDescriptor('test', null);
     CacheEntry entry = new CacheEntry();
     expect(() => entry.setState(result, CacheState.VALID), throwsArgumentError);
   }
 
   test_setValue() {
     String value = 'value';
@@ skipping 153 matching lines @@
     return new UniversalCachePartition(null, 8, policy);
   }
 
   void test_contains() {
     UniversalCachePartition partition =
         new UniversalCachePartition(null, 8, null);
     TestSource source = new TestSource();
     expect(partition.contains(source), isTrue);
   }
 }