unify test_data_layer tests

diff --git a/src/caffe/test/test_data_layer.cpp b/src/caffe/test/test_data_layer.cpp
index 1eae1a4..98ac60d 100644 (file)
--- a/src/caffe/test/test_data_layer.cpp
+++ b/src/caffe/test/test_data_layer.cpp
@@ -63,6 +63,187 @@ class DataLayerTest : public ::testing::Test {
     delete db;
   }
 
+  void TestRead() {
+    const Dtype scale = 3;
+    LayerParameter param;
+    DataParameter* data_param = param.mutable_data_param();
+    data_param->set_batch_size(5);
+    data_param->set_scale(scale);
+    data_param->set_source(filename_->c_str());
+    DataLayer<Dtype> layer(param);
+    layer.SetUp(blob_bottom_vec_, &blob_top_vec_);
+    EXPECT_EQ(blob_top_data_->num(), 5);
+    EXPECT_EQ(blob_top_data_->channels(), 2);
+    EXPECT_EQ(blob_top_data_->height(), 3);
+    EXPECT_EQ(blob_top_data_->width(), 4);
+    EXPECT_EQ(blob_top_label_->num(), 5);
+    EXPECT_EQ(blob_top_label_->channels(), 1);
+    EXPECT_EQ(blob_top_label_->height(), 1);
+    EXPECT_EQ(blob_top_label_->width(), 1);
+
+    for (int iter = 0; iter < 100; ++iter) {
+      layer.Forward(blob_bottom_vec_, &blob_top_vec_);
+      for (int i = 0; i < 5; ++i) {
+        EXPECT_EQ(i, blob_top_label_->cpu_data()[i]);
+      }
+      for (int i = 0; i < 5; ++i) {
+        for (int j = 0; j < 24; ++j) {
+          EXPECT_EQ(scale * i, blob_top_data_->cpu_data()[i * 24 + j])
+              << "debug: iter " << iter << " i " << i << " j " << j;
+        }
+      }
+    }
+  }
+
+  void TestReadCrop() {
+    const Dtype scale = 3;
+    LayerParameter param;
+    Caffe::set_random_seed(1701);
+    DataParameter* data_param = param.mutable_data_param();
+    data_param->set_batch_size(5);
+    data_param->set_scale(scale);
+    data_param->set_crop_size(1);
+    data_param->set_source(filename_->c_str());
+    DataLayer<Dtype> layer(param);
+    layer.SetUp(blob_bottom_vec_, &blob_top_vec_);
+    EXPECT_EQ(blob_top_data_->num(), 5);
+    EXPECT_EQ(blob_top_data_->channels(), 2);
+    EXPECT_EQ(blob_top_data_->height(), 1);
+    EXPECT_EQ(blob_top_data_->width(), 1);
+    EXPECT_EQ(blob_top_label_->num(), 5);
+    EXPECT_EQ(blob_top_label_->channels(), 1);
+    EXPECT_EQ(blob_top_label_->height(), 1);
+    EXPECT_EQ(blob_top_label_->width(), 1);
+
+    for (int iter = 0; iter < 2; ++iter) {
+      layer.Forward(blob_bottom_vec_, &blob_top_vec_);
+      for (int i = 0; i < 5; ++i) {
+        EXPECT_EQ(i, blob_top_label_->cpu_data()[i]);
+      }
+      int num_with_center_value = 0;
+      for (int i = 0; i < 5; ++i) {
+        for (int j = 0; j < 2; ++j) {
+          const Dtype center_value = scale * (j ? 17 : 5);
+          num_with_center_value +=
+              (center_value == blob_top_data_->cpu_data()[i * 2 + j]);
+          // At TEST time, check that we always get center value.
+          if (Caffe::phase() == Caffe::TEST) {
+            EXPECT_EQ(center_value, this->blob_top_data_->cpu_data()[i * 2 + j])
+                << "debug: iter " << iter << " i " << i << " j " << j;
+          }
+        }
+      }
+      // At TRAIN time, check that we did not get the center crop all 10 times.
+      // (This check fails with probability 1-1/12^10 in a correct 
+      // implementation, so we call set_random_seed.)
+      if (Caffe::phase() == Caffe::TRAIN) {
+        EXPECT_LT(num_with_center_value, 10);
+      }
+    }
+  }
+
+  void TestReadCropTrainSequenceSeeded() {
+    LayerParameter param;
+    DataParameter* data_param = param.mutable_data_param();
+    data_param->set_batch_size(5);
+    data_param->set_crop_size(1);
+    data_param->set_mirror(true);
+    data_param->set_source(filename_->c_str());
+
+    // Get crop sequence with Caffe seed 1701.
+    Caffe::set_random_seed(seed_);
+    vector<vector<Dtype> > crop_sequence;
+    {
+      DataLayer<Dtype> layer1(param);
+      layer1.SetUp(blob_bottom_vec_, &blob_top_vec_);
+      for (int iter = 0; iter < 2; ++iter) {
+        layer1.Forward(blob_bottom_vec_, &blob_top_vec_);
+        for (int i = 0; i < 5; ++i) {
+          EXPECT_EQ(i, blob_top_label_->cpu_data()[i]);
+        }
+        vector<Dtype> iter_crop_sequence;
+        for (int i = 0; i < 5; ++i) {
+          for (int j = 0; j < 2; ++j) {
+            iter_crop_sequence.push_back(
+                blob_top_data_->cpu_data()[i * 2 + j]);
+          }
+        }
+        crop_sequence.push_back(iter_crop_sequence);
+      }
+    }  // destroy 1st data layer and unlock the leveldb
+
+    // Get crop sequence after reseeding Caffe with 1701.
+    // Check that the sequence is the same as the original.
+    Caffe::set_random_seed(seed_);
+    DataLayer<Dtype> layer2(param);
+    layer2.SetUp(blob_bottom_vec_, &blob_top_vec_);
+    for (int iter = 0; iter < 2; ++iter) {
+      layer2.Forward(blob_bottom_vec_, &blob_top_vec_);
+      for (int i = 0; i < 5; ++i) {
+        EXPECT_EQ(i, blob_top_label_->cpu_data()[i]);
+      }
+      for (int i = 0; i < 5; ++i) {
+        for (int j = 0; j < 2; ++j) {
+          EXPECT_EQ(crop_sequence[iter][i * 2 + j],
+                    blob_top_data_->cpu_data()[i * 2 + j])
+              << "debug: iter " << iter << " i " << i << " j " << j;
+        }
+      }
+    }
+  }
+
+  void TestReadCropTrainSequenceUnseeded() {
+    LayerParameter param;
+    DataParameter* data_param = param.mutable_data_param();
+    data_param->set_batch_size(5);
+    data_param->set_crop_size(1);
+    data_param->set_mirror(true);
+    data_param->set_source(filename_->c_str());
+
+    // Get crop sequence with Caffe seed 1701, srand seed 1701.
+    Caffe::set_random_seed(seed_);
+    srand(seed_);
+    vector<vector<Dtype> > crop_sequence;
+    {
+      DataLayer<Dtype> layer1(param);
+      layer1.SetUp(blob_bottom_vec_, &blob_top_vec_);
+      for (int iter = 0; iter < 2; ++iter) {
+        layer1.Forward(blob_bottom_vec_, &blob_top_vec_);
+        for (int i = 0; i < 5; ++i) {
+          EXPECT_EQ(i, blob_top_label_->cpu_data()[i]);
+        }
+        vector<Dtype> iter_crop_sequence;
+        for (int i = 0; i < 5; ++i) {
+          for (int j = 0; j < 2; ++j) {
+            iter_crop_sequence.push_back(
+                blob_top_data_->cpu_data()[i * 2 + j]);
+          }
+        }
+        crop_sequence.push_back(iter_crop_sequence);
+      }
+    }  // destroy 1st data layer and unlock the leveldb
+
+    // Get crop sequence continuing from previous Caffe RNG state;
+    // reseed srand with 1701. Check that the sequence differs from the original.
+    srand(seed_);
+    DataLayer<Dtype> layer2(param);
+    layer2.SetUp(blob_bottom_vec_, &blob_top_vec_);
+    for (int iter = 0; iter < 2; ++iter) {
+      layer2.Forward(blob_bottom_vec_, &blob_top_vec_);
+      for (int i = 0; i < 5; ++i) {
+        EXPECT_EQ(i, blob_top_label_->cpu_data()[i]);
+      }
+      int num_sequence_matches = 0;
+      for (int i = 0; i < 5; ++i) {
+        for (int j = 0; j < 2; ++j) {
+          num_sequence_matches += (crop_sequence[iter][i * 2 + j] ==
+                                   blob_top_data_->cpu_data()[i * 2 + j]);
+        }
+      }
+      EXPECT_LT(num_sequence_matches, 10);
+    }
+  }
+
   virtual ~DataLayerTest() { delete blob_top_data_; delete blob_top_label_; }
 
   shared_ptr<string> filename_;
@@ -80,70 +261,14 @@ TYPED_TEST(DataLayerTest, TestReadCPU) {
   Caffe::set_mode(Caffe::CPU);
   const bool unique_pixels = false;  // all pixels the same; images different
   this->FillLevelDB(unique_pixels);
-  const TypeParam scale = 3;
-  LayerParameter param;
-  DataParameter* data_param = param.mutable_data_param();
-  data_param->set_batch_size(5);
-  data_param->set_scale(scale);
-  data_param->set_source(this->filename_->c_str());
-  DataLayer<TypeParam> layer(param);
-  layer.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-  EXPECT_EQ(this->blob_top_data_->num(), 5);
-  EXPECT_EQ(this->blob_top_data_->channels(), 2);
-  EXPECT_EQ(this->blob_top_data_->height(), 3);
-  EXPECT_EQ(this->blob_top_data_->width(), 4);
-  EXPECT_EQ(this->blob_top_label_->num(), 5);
-  EXPECT_EQ(this->blob_top_label_->channels(), 1);
-  EXPECT_EQ(this->blob_top_label_->height(), 1);
-  EXPECT_EQ(this->blob_top_label_->width(), 1);
-
-  for (int iter = 0; iter < 100; ++iter) {
-    layer.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int i = 0; i < 5; ++i) {
-      EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-    }
-    for (int i = 0; i < 5; ++i) {
-      for (int j = 0; j < 24; ++j) {
-        EXPECT_EQ(scale * i, this->blob_top_data_->cpu_data()[i * 24 + j])
-            << "debug: iter " << iter << " i " << i << " j " << j;
-      }
-    }
-  }
+  this->TestRead();
 }
 
 TYPED_TEST(DataLayerTest, TestReadGPU) {
   Caffe::set_mode(Caffe::GPU);
   const bool unique_pixels = false;  // all pixels the same; images different
   this->FillLevelDB(unique_pixels);
-  const TypeParam scale = 3;
-  LayerParameter param;
-  DataParameter* data_param = param.mutable_data_param();
-  data_param->set_batch_size(5);
-  data_param->set_scale(scale);
-  data_param->set_source(this->filename_->c_str());
-  DataLayer<TypeParam> layer(param);
-  layer.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-  EXPECT_EQ(this->blob_top_data_->num(), 5);
-  EXPECT_EQ(this->blob_top_data_->channels(), 2);
-  EXPECT_EQ(this->blob_top_data_->height(), 3);
-  EXPECT_EQ(this->blob_top_data_->width(), 4);
-  EXPECT_EQ(this->blob_top_label_->num(), 5);
-  EXPECT_EQ(this->blob_top_label_->channels(), 1);
-  EXPECT_EQ(this->blob_top_label_->height(), 1);
-  EXPECT_EQ(this->blob_top_label_->width(), 1);
-
-  for (int iter = 0; iter < 100; ++iter) {
-    layer.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int i = 0; i < 5; ++i) {
-      EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-    }
-    for (int i = 0; i < 5; ++i) {
-      for (int j = 0; j < 24; ++j) {
-        EXPECT_EQ(scale * i, this->blob_top_data_->cpu_data()[i * 24 + j])
-            << "debug: iter " << iter << " i " << i << " j " << j;
-      }
-    }
-  }
+  this->TestRead();
 }
 
 TYPED_TEST(DataLayerTest, TestReadCropTrainCPU) {
@@ -151,41 +276,7 @@ TYPED_TEST(DataLayerTest, TestReadCropTrainCPU) {
   Caffe::set_mode(Caffe::CPU);
   const bool unique_pixels = true;  // all images the same; pixels different
   this->FillLevelDB(unique_pixels);
-  const TypeParam scale = 3;
-  LayerParameter param;
-  DataParameter* data_param = param.mutable_data_param();
-  data_param->set_batch_size(5);
-  data_param->set_scale(scale);
-  data_param->set_crop_size(1);
-  data_param->set_source(this->filename_->c_str());
-  DataLayer<TypeParam> layer(param);
-  layer.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-  EXPECT_EQ(this->blob_top_data_->num(), 5);
-  EXPECT_EQ(this->blob_top_data_->channels(), 2);
-  EXPECT_EQ(this->blob_top_data_->height(), 1);
-  EXPECT_EQ(this->blob_top_data_->width(), 1);
-  EXPECT_EQ(this->blob_top_label_->num(), 5);
-  EXPECT_EQ(this->blob_top_label_->channels(), 1);
-  EXPECT_EQ(this->blob_top_label_->height(), 1);
-  EXPECT_EQ(this->blob_top_label_->width(), 1);
-
-  for (int iter = 0; iter < 2; ++iter) {
-    layer.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int i = 0; i < 5; ++i) {
-      EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-    }
-    int num_with_center_value = 0;
-    for (int i = 0; i < 5; ++i) {
-      for (int j = 0; j < 2; ++j) {
-        const TypeParam center_value = scale * (j ? 17 : 5);
-        num_with_center_value +=
-            (center_value == this->blob_top_data_->cpu_data()[i * 2 + j]);
-      }
-    }
-    // Check we did not get the center crop all 10 times (occurs with
-    // probability 1-1/12^10 in working implementation).
-    EXPECT_LT(num_with_center_value, 10);
-  }
+  this->TestReadCrop();
 }
 
 TYPED_TEST(DataLayerTest, TestReadCropTrainGPU) {
@@ -193,41 +284,7 @@ TYPED_TEST(DataLayerTest, TestReadCropTrainGPU) {
   Caffe::set_mode(Caffe::GPU);
   const bool unique_pixels = true;  // all images the same; pixels different
   this->FillLevelDB(unique_pixels);
-  const TypeParam scale = 3;
-  LayerParameter param;
-  DataParameter* data_param = param.mutable_data_param();
-  data_param->set_batch_size(5);
-  data_param->set_scale(scale);
-  data_param->set_crop_size(1);
-  data_param->set_source(this->filename_->c_str());
-  DataLayer<TypeParam> layer(param);
-  layer.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-  EXPECT_EQ(this->blob_top_data_->num(), 5);
-  EXPECT_EQ(this->blob_top_data_->channels(), 2);
-  EXPECT_EQ(this->blob_top_data_->height(), 1);
-  EXPECT_EQ(this->blob_top_data_->width(), 1);
-  EXPECT_EQ(this->blob_top_label_->num(), 5);
-  EXPECT_EQ(this->blob_top_label_->channels(), 1);
-  EXPECT_EQ(this->blob_top_label_->height(), 1);
-  EXPECT_EQ(this->blob_top_label_->width(), 1);
-
-  for (int iter = 0; iter < 2; ++iter) {
-    layer.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int i = 0; i < 5; ++i) {
-      EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-    }
-    int num_with_center_value = 0;
-    for (int i = 0; i < 5; ++i) {
-      for (int j = 0; j < 2; ++j) {
-        const TypeParam center_value = scale * (j ? 17 : 5);
-        num_with_center_value +=
-            (center_value == this->blob_top_data_->cpu_data()[i * 2 + j]);
-      }
-    }
-    // Check we did not get the center crop all 10 times (occurs with
-    // probability 1-1/12^10 in working implementation).
-    EXPECT_LT(num_with_center_value, 10);
-  }
+  this->TestReadCrop();
 }
 
 // Test that the sequence of random crops is consistent when using
@@ -237,53 +294,7 @@ TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceSeededCPU) {
   Caffe::set_mode(Caffe::CPU);
   const bool unique_pixels = true;  // all images the same; pixels different
   this->FillLevelDB(unique_pixels);
-  LayerParameter param;
-  DataParameter* data_param = param.mutable_data_param();
-  data_param->set_batch_size(5);
-  data_param->set_crop_size(1);
-  data_param->set_mirror(true);
-  data_param->set_source(this->filename_->c_str());
-
-  // Get crop sequence with Caffe seed 1701.
-  Caffe::set_random_seed(this->seed_);
-  vector<vector<TypeParam> > crop_sequence;
-  {
-    DataLayer<TypeParam> layer1(param);
-    layer1.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int iter = 0; iter < 2; ++iter) {
-      layer1.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-      for (int i = 0; i < 5; ++i) {
-        EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-      }
-      vector<TypeParam> iter_crop_sequence;
-      for (int i = 0; i < 5; ++i) {
-        for (int j = 0; j < 2; ++j) {
-          iter_crop_sequence.push_back(
-              this->blob_top_data_->cpu_data()[i * 2 + j]);
-        }
-      }
-      crop_sequence.push_back(iter_crop_sequence);
-    }
-  }  // destroy 1st data layer and unlock the leveldb
-
-  // Get crop sequence after reseeding Caffe with 1701.
-  // Check that the sequence is the same as the original.
-  Caffe::set_random_seed(this->seed_);
-  DataLayer<TypeParam> layer2(param);
-  layer2.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-  for (int iter = 0; iter < 2; ++iter) {
-    layer2.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int i = 0; i < 5; ++i) {
-      EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-    }
-    for (int i = 0; i < 5; ++i) {
-      for (int j = 0; j < 2; ++j) {
-        EXPECT_EQ(crop_sequence[iter][i * 2 + j],
-                  this->blob_top_data_->cpu_data()[i * 2 + j])
-            << "debug: iter " << iter << " i " << i << " j " << j;
-      }
-    }
-  }
+  this->TestReadCropTrainSequenceSeeded();
 }
 
 // Test that the sequence of random crops is consistent when using
@@ -293,53 +304,7 @@ TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceSeededGPU) {
   Caffe::set_mode(Caffe::GPU);
   const bool unique_pixels = true;  // all images the same; pixels different
   this->FillLevelDB(unique_pixels);
-  LayerParameter param;
-  DataParameter* data_param = param.mutable_data_param();
-  data_param->set_batch_size(5);
-  data_param->set_crop_size(1);
-  data_param->set_mirror(true);
-  data_param->set_source(this->filename_->c_str());
-
-  // Get crop sequence with Caffe seed 1701.
-  Caffe::set_random_seed(this->seed_);
-  vector<vector<TypeParam> > crop_sequence;
-  {
-    DataLayer<TypeParam> layer1(param);
-    layer1.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int iter = 0; iter < 2; ++iter) {
-      layer1.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-      for (int i = 0; i < 5; ++i) {
-        EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-      }
-      vector<TypeParam> iter_crop_sequence;
-      for (int i = 0; i < 5; ++i) {
-        for (int j = 0; j < 2; ++j) {
-          iter_crop_sequence.push_back(
-              this->blob_top_data_->cpu_data()[i * 2 + j]);
-        }
-      }
-      crop_sequence.push_back(iter_crop_sequence);
-    }
-  }  // destroy 1st data layer and unlock the leveldb
-
-  // Get crop sequence after reseeding Caffe with 1701.
-  // Check that the sequence is the same as the original.
-  Caffe::set_random_seed(this->seed_);
-  DataLayer<TypeParam> layer2(param);
-  layer2.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-  for (int iter = 0; iter < 2; ++iter) {
-    layer2.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int i = 0; i < 5; ++i) {
-      EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-    }
-    for (int i = 0; i < 5; ++i) {
-      for (int j = 0; j < 2; ++j) {
-        EXPECT_EQ(crop_sequence[iter][i * 2 + j],
-                  this->blob_top_data_->cpu_data()[i * 2 + j])
-            << "debug: iter " << iter << " i " << i << " j " << j;
-      }
-    }
-  }
+  this->TestReadCropTrainSequenceSeeded();
 }
 
 // Test that the sequence of random crops differs across iterations when
@@ -349,55 +314,7 @@ TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceUnseededCPU) {
   Caffe::set_mode(Caffe::CPU);
   const bool unique_pixels = true;  // all images the same; pixels different
   this->FillLevelDB(unique_pixels);
-  LayerParameter param;
-  DataParameter* data_param = param.mutable_data_param();
-  data_param->set_batch_size(5);
-  data_param->set_crop_size(1);
-  data_param->set_mirror(true);
-  data_param->set_source(this->filename_->c_str());
-
-  // Get crop sequence with Caffe seed 1701, srand seed 1701.
-  Caffe::set_random_seed(this->seed_);
-  srand(this->seed_);
-  vector<vector<TypeParam> > crop_sequence;
-  {
-    DataLayer<TypeParam> layer1(param);
-    layer1.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int iter = 0; iter < 2; ++iter) {
-      layer1.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-      for (int i = 0; i < 5; ++i) {
-        EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-      }
-      vector<TypeParam> iter_crop_sequence;
-      for (int i = 0; i < 5; ++i) {
-        for (int j = 0; j < 2; ++j) {
-          iter_crop_sequence.push_back(
-              this->blob_top_data_->cpu_data()[i * 2 + j]);
-        }
-      }
-      crop_sequence.push_back(iter_crop_sequence);
-    }
-  }  // destroy 1st data layer and unlock the leveldb
-
-  // Get crop sequence continuing from previous Caffe RNG state;
-  // reseed srand with 1701. Check that the sequence differs from the original.
-  srand(this->seed_);
-  DataLayer<TypeParam> layer2(param);
-  layer2.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-  for (int iter = 0; iter < 2; ++iter) {
-    layer2.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int i = 0; i < 5; ++i) {
-      EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-    }
-    int num_sequence_matches = 0;
-    for (int i = 0; i < 5; ++i) {
-      for (int j = 0; j < 2; ++j) {
-        num_sequence_matches += (crop_sequence[iter][i * 2 + j] ==
-                                 this->blob_top_data_->cpu_data()[i * 2 + j]);
-      }
-    }
-    EXPECT_LT(num_sequence_matches, 10);
-  }
+  this->TestReadCropTrainSequenceUnseeded();
 }
 
 // Test that the sequence of random crops differs across iterations when
@@ -407,55 +324,7 @@ TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceUnseededGPU) {
   Caffe::set_mode(Caffe::GPU);
   const bool unique_pixels = true;  // all images the same; pixels different
   this->FillLevelDB(unique_pixels);
-  LayerParameter param;
-  DataParameter* data_param = param.mutable_data_param();
-  data_param->set_batch_size(5);
-  data_param->set_crop_size(1);
-  data_param->set_mirror(true);
-  data_param->set_source(this->filename_->c_str());
-
-  // Get crop sequence with Caffe seed 1701, srand seed 1701.
-  Caffe::set_random_seed(this->seed_);
-  srand(this->seed_);
-  vector<vector<TypeParam> > crop_sequence;
-  {
-    DataLayer<TypeParam> layer1(param);
-    layer1.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int iter = 0; iter < 2; ++iter) {
-      layer1.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-      for (int i = 0; i < 5; ++i) {
-        EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-      }
-      vector<TypeParam> iter_crop_sequence;
-      for (int i = 0; i < 5; ++i) {
-        for (int j = 0; j < 2; ++j) {
-          iter_crop_sequence.push_back(
-              this->blob_top_data_->cpu_data()[i * 2 + j]);
-        }
-      }
-      crop_sequence.push_back(iter_crop_sequence);
-    }
-  }  // destroy 1st data layer and unlock the leveldb
-
-  // Get crop sequence continuing from previous Caffe RNG state;
-  // reseed srand with 1701. Check that the sequence differs from the original.
-  srand(this->seed_);
-  DataLayer<TypeParam> layer2(param);
-  layer2.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-  for (int iter = 0; iter < 2; ++iter) {
-    layer2.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int i = 0; i < 5; ++i) {
-      EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-    }
-    int num_sequence_matches = 0;
-    for (int i = 0; i < 5; ++i) {
-      for (int j = 0; j < 2; ++j) {
-        num_sequence_matches += (crop_sequence[iter][i * 2 + j] ==
-                                 this->blob_top_data_->cpu_data()[i * 2 + j]);
-      }
-    }
-    EXPECT_LT(num_sequence_matches, 10);
-  }
+  this->TestReadCropTrainSequenceUnseeded();
 }
 
 TYPED_TEST(DataLayerTest, TestReadCropTestCPU) {
@@ -463,37 +332,7 @@ TYPED_TEST(DataLayerTest, TestReadCropTestCPU) {
   Caffe::set_mode(Caffe::CPU);
   const bool unique_pixels = true;  // all images the same; pixels different
   this->FillLevelDB(unique_pixels);
-  const TypeParam scale = 3;
-  LayerParameter param;
-  DataParameter* data_param = param.mutable_data_param();
-  data_param->set_batch_size(5);
-  data_param->set_scale(scale);
-  data_param->set_crop_size(1);
-  data_param->set_source(this->filename_->c_str());
-  DataLayer<TypeParam> layer(param);
-  layer.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-  EXPECT_EQ(this->blob_top_data_->num(), 5);
-  EXPECT_EQ(this->blob_top_data_->channels(), 2);
-  EXPECT_EQ(this->blob_top_data_->height(), 1);
-  EXPECT_EQ(this->blob_top_data_->width(), 1);
-  EXPECT_EQ(this->blob_top_label_->num(), 5);
-  EXPECT_EQ(this->blob_top_label_->channels(), 1);
-  EXPECT_EQ(this->blob_top_label_->height(), 1);
-  EXPECT_EQ(this->blob_top_label_->width(), 1);
-
-  for (int iter = 0; iter < 2; ++iter) {
-    layer.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int i = 0; i < 5; ++i) {
-      EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-    }
-    for (int i = 0; i < 5; ++i) {
-      for (int j = 0; j < 2; ++j) {
-        const TypeParam center_value = scale * (j ? 17 : 5);
-        EXPECT_EQ(center_value, this->blob_top_data_->cpu_data()[i * 2 + j])
-            << "debug: iter " << iter << " i " << i << " j " << j;
-      }
-    }
-  }
+  this->TestReadCrop();
 }
 
 TYPED_TEST(DataLayerTest, TestReadCropTestGPU) {
@@ -501,37 +340,7 @@ TYPED_TEST(DataLayerTest, TestReadCropTestGPU) {
   Caffe::set_mode(Caffe::GPU);
   const bool unique_pixels = true;  // all images the same; pixels different
   this->FillLevelDB(unique_pixels);
-  const TypeParam scale = 3;
-  LayerParameter param;
-  DataParameter* data_param = param.mutable_data_param();
-  data_param->set_batch_size(5);
-  data_param->set_scale(scale);
-  data_param->set_crop_size(1);
-  data_param->set_source(this->filename_->c_str());
-  DataLayer<TypeParam> layer(param);
-  layer.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_);
-  EXPECT_EQ(this->blob_top_data_->num(), 5);
-  EXPECT_EQ(this->blob_top_data_->channels(), 2);
-  EXPECT_EQ(this->blob_top_data_->height(), 1);
-  EXPECT_EQ(this->blob_top_data_->width(), 1);
-  EXPECT_EQ(this->blob_top_label_->num(), 5);
-  EXPECT_EQ(this->blob_top_label_->channels(), 1);
-  EXPECT_EQ(this->blob_top_label_->height(), 1);
-  EXPECT_EQ(this->blob_top_label_->width(), 1);
-
-  for (int iter = 0; iter < 2; ++iter) {
-    layer.Forward(this->blob_bottom_vec_, &this->blob_top_vec_);
-    for (int i = 0; i < 5; ++i) {
-      EXPECT_EQ(i, this->blob_top_label_->cpu_data()[i]);
-    }
-    for (int i = 0; i < 5; ++i) {
-      for (int j = 0; j < 2; ++j) {
-        const TypeParam center_value = scale * (j ? 17 : 5);
-        EXPECT_EQ(center_value, this->blob_top_data_->cpu_data()[i * 2 + j])
-            << "debug: iter " << iter << " i " << i << " j " << j;
-      }
-    }
-  }
+  this->TestReadCrop();
 }
 
 }  // namespace caffe