Move memory management code into separate class for future reuse.

base/metrics/persistent_memory_allocator_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/metrics/persistent_memory_allocator.h"
 
 #include <memory>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 103 matching lines @@
   EXPECT_LE(sizeof(TestObject1), allocator_->GetAllocSize(block1));
   EXPECT_GT(sizeof(TestObject1) + kAllocAlignment,
             allocator_->GetAllocSize(block1));
   PersistentMemoryAllocator::MemoryInfo meminfo1;
   allocator_->GetMemoryInfo(&meminfo1);
   EXPECT_EQ(meminfo0.total, meminfo1.total);
   EXPECT_GT(meminfo0.free, meminfo1.free);
 
   // Ensure that the test-object can be made iterable.
   PersistentMemoryAllocator::Iterator iter1a(allocator_.get());
+  EXPECT_EQ(0U, iter1a.GetLast());
   uint32_t type;
   EXPECT_EQ(0U, iter1a.GetNext(&type));
   allocator_->MakeIterable(block1);
   EXPECT_EQ(block1, iter1a.GetNext(&type));
   EXPECT_EQ(1U, type);
+  EXPECT_EQ(block1, iter1a.GetLast());
   EXPECT_EQ(0U, iter1a.GetNext(&type));
+  EXPECT_EQ(block1, iter1a.GetLast());
 
   // Create second test-object and ensure everything is good and it cannot
   // be confused with test-object of another type.
   Reference block2 = allocator_->Allocate(sizeof(TestObject2), 2);
   EXPECT_NE(0U, block2);
   EXPECT_NE(nullptr, allocator_->GetAsObject<TestObject2>(block2, 2));
   EXPECT_EQ(nullptr, allocator_->GetAsObject<TestObject2>(block2, 1));
   EXPECT_LE(sizeof(TestObject2), allocator_->GetAllocSize(block2));
   EXPECT_GT(sizeof(TestObject2) + kAllocAlignment,
             allocator_->GetAllocSize(block2));
   PersistentMemoryAllocator::MemoryInfo meminfo2;
   allocator_->GetMemoryInfo(&meminfo2);
   EXPECT_EQ(meminfo1.total, meminfo2.total);
   EXPECT_GT(meminfo1.free, meminfo2.free);
 
   // Ensure that second test-object can also be made iterable.
   allocator_->MakeIterable(block2);
   EXPECT_EQ(block2, iter1a.GetNext(&type));
   EXPECT_EQ(2U, type);
+  EXPECT_EQ(block2, iter1a.GetLast());
+  EXPECT_EQ(0U, iter1a.GetNext(&type));
+  EXPECT_EQ(block2, iter1a.GetLast());
+
+  // Check that the iterator can be reset to the beginning.
+  iter1a.Reset();
+  EXPECT_EQ(0U, iter1a.GetLast());
+  EXPECT_EQ(block1, iter1a.GetNext(&type));
+  EXPECT_EQ(block1, iter1a.GetLast());
+  EXPECT_EQ(block2, iter1a.GetNext(&type));
+  EXPECT_EQ(block2, iter1a.GetLast());
+  EXPECT_EQ(0U, iter1a.GetNext(&type));
+
+  // Check that the iterator can be reset to an arbitrary location.
+  iter1a.Reset(block1);
+  EXPECT_EQ(block1, iter1a.GetLast());
+  EXPECT_EQ(block2, iter1a.GetNext(&type));
+  EXPECT_EQ(block2, iter1a.GetLast());
   EXPECT_EQ(0U, iter1a.GetNext(&type));
 
   // Check that iteration can begin after an arbitrary location.
   PersistentMemoryAllocator::Iterator iter1b(allocator_.get(), block1);
   EXPECT_EQ(block2, iter1b.GetNext(&type));
   EXPECT_EQ(0U, iter1b.GetNext(&type));
 
   // Ensure nothing has gone noticably wrong.
   EXPECT_FALSE(allocator_->IsFull());
   EXPECT_FALSE(allocator_->IsCorrupt());
@@ skipping 647 matching lines @@
       // For filesize >= minsize, the file must be acceptable. This
       // else clause (file-not-acceptable) should be reached only if
       // filesize < minsize.
       EXPECT_GT(minsize, filesize);
     }
   }
 }
 #endif  // !defined(OS_NACL)
 
 }  // namespace base