Fix caching paging during read.

pkg/analysis_server/test/index/page_node_manager_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.index.page_node_manager;
 
 import 'dart:math';
 import 'dart:typed_data';
 
 import 'package:analysis_server/src/index/b_plus_tree.dart';
@@ skipping 80 matching lines @@
     when(delegate.writeIndex).thenReturn((key, value) {
       delegate.writeIndex(key, value);
     });
     when(delegate.writeLeaf).thenReturn((key, value) {
       delegate.writeLeaf(key, value);
     });
     manager = new CachingNodeManager<int, String, int>(delegate, 4, 4);
     resetInteractions(delegate);
   }
 
-  void test_maxIndexKeys() {
-    when(delegate.maxIndexKeys).thenReturn(42);
-    expect(manager.maxIndexKeys, 42);
-  }
-
-  void test_maxLeafKeys() {
-    when(delegate.maxLeafKeys).thenReturn(42);
-    expect(manager.maxLeafKeys, 42);
-  }
-
   void test_createIndex() {
     when(delegate.createIndex()).thenReturn(77);
     expect(manager.createIndex(), 77);
   }
 
   void test_createLeaf() {
     when(delegate.createLeaf()).thenReturn(99);
     expect(manager.createLeaf(), 99);
   }
 
   void test_delete() {
     manager.delete(42);
     verify(delegate.delete(42)).once();
   }
 
   void test_isIndex() {
     when(delegate.isIndex(1)).thenReturn(true);
     when(delegate.isIndex(2)).thenReturn(false);
     expect(manager.isIndex(1), isTrue);
     expect(manager.isIndex(2), isFalse);
   }
 
-  void test_readIndex_cached() {
+  void test_maxIndexKeys() {
+    when(delegate.maxIndexKeys).thenReturn(42);
+    expect(manager.maxIndexKeys, 42);
+  }
+
+  void test_maxLeafKeys() {
+    when(delegate.maxLeafKeys).thenReturn(42);
+    expect(manager.maxLeafKeys, 42);
+  }
+
+  void test_readIndex_cache_whenRead() {
+    var data = new IndexNodeData<int, int>([1, 2], [10, 20, 30]);
+    when(delegate.readIndex(2)).thenReturn(data);
+    expect(manager.readIndex(2), data);
+    verify(delegate.readIndex(2)).once();
+    resetInteractions(delegate);
+    // we just read "2", so it should be cached
+    manager.readIndex(2);
+    verify(delegate.readIndex(2)).never();
+  }
+
+  void test_readIndex_cache_whenWrite() {
     var data = new IndexNodeData<int, int>([1, 2], [10, 20, 30]);
     manager.writeIndex(2, data);
     expect(manager.readIndex(2), data);
+    verify(delegate.readLeaf(2)).never();
     // delete, forces request to the delegate
     manager.delete(2);
     manager.readIndex(2);
     verify(delegate.readIndex(2)).once();
   }
 
   void test_readIndex_delegate() {
     var data = new IndexNodeData<int, int>([1, 2], [10, 20, 30]);
     when(delegate.readIndex(2)).thenReturn(data);
     expect(manager.readIndex(2), data);
   }
 
-  void test_readLeaf_cached() {
+  void test_readLeaf_cache_whenRead() {
+    var data = new LeafNodeData<int, String>([1, 2, 3], ['A', 'B', 'C']);
+    when(delegate.readLeaf(2)).thenReturn(data);
+    expect(manager.readLeaf(2), data);
+    verify(delegate.readLeaf(2)).once();
+    resetInteractions(delegate);
+    // we just read "2", so it should be cached
+    manager.readLeaf(2);
+    verify(delegate.readLeaf(2)).never();
+  }
+
+  void test_readLeaf_cache_whenWrite() {
     var data = new LeafNodeData<int, String>([1, 2, 3], ['A', 'B', 'C']);
     manager.writeLeaf(2, data);
     expect(manager.readLeaf(2), data);
+    verify(delegate.readLeaf(2)).never();
     // delete, forces request to the delegate
     manager.delete(2);
     manager.readLeaf(2);
     verify(delegate.readLeaf(2)).once();
   }
 
   void test_readLeaf_delegate() {
     var data = new LeafNodeData<int, String>([1, 2, 3], ['A', 'B', 'C']);
     when(delegate.readLeaf(2)).thenReturn(data);
     expect(manager.readLeaf(2), data);
@@ skipping 46 matching lines @@
   }
 
   test_fourChars() {
     // encode
     codec.encode(buffer, 'ABCD');
     expect(bytes, [0, 4, 0, 65, 0, 66, 0, 67, 0, 68]);
     // decode
     expect(codec.decode(buffer), 'ABCD');
   }
 
+  test_russian() {
+    // encode
+    codec.encode(buffer, 'ЩУКА');
+    expect(bytes, [0, 4, 4, 41, 4, 35, 4, 26, 4, 16]);
+    // decode
+    expect(codec.decode(buffer), 'ЩУКА');
+  }
+
   test_tooManyChars() {
     expect(() {
       codec.encode(buffer, 'ABCDE');
     }, throws);
   }
 
   test_twoChars() {
     // encode
     codec.encode(buffer, 'AB');
     expect(bytes, [0, 2, 0, 65, 0, 66, 0, 0, 0, 0]);
     // decode
     expect(codec.decode(buffer), 'AB');
   }
-
-  test_russian() {
-    // encode
-    codec.encode(buffer, 'ЩУКА');
-    expect(bytes, [0, 4, 4, 41, 4, 35, 4, 26, 4, 16]);
-    // decode
-    expect(codec.decode(buffer), 'ЩУКА');
-  }
 }
 
 
 @ReflectiveTestCase()
 class _MemoryPageManagerTest {
   static const PAGE_SIZE = 8;
   MemoryPageManager manager = new MemoryPageManager(PAGE_SIZE);
 
   test_alloc() {
     int idA = manager.alloc();
@@ skipping 151 matching lines @@
   }
 
   test_all() {
     // encode
     codec.encode(buffer, 42);
     expect(bytes, [0, 0, 0, 42]);
     // decode
     expect(codec.decode(buffer), 42);
   }
 }