PicasaAlbumTableReader for Media Galleries API

webkit/fileapi/media/picasa/pmp_column_reader_unittest.cc

 // Copyright 2013 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 <algorithm>
 #include <vector>
 
 #include "base/file_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/media/picasa/pmp_column_reader.h"
@@ skipping 21 matching lines @@
 bool DoRead(const PmpColumnReader* reader, uint32 row, uint8* target) {
   return reader->ReadUInt8(row, target);
 }
 
 bool DoRead(const PmpColumnReader* reader, uint32 row, uint64* target) {
   return reader->ReadUInt64(row, target);
 }
 
 // TestValid
 template<class T>
-void TestValid(const uint16 field_type, const std::vector<T>& elems) {
+void TestValid(const picasaimport::PmpFieldType field_type,
+               const std::vector<T>& elems) {
   PmpTestHelper test_helper;
   ASSERT_TRUE(test_helper.Init());
 
-  PmpColumnReader reader;
+  PmpColumnReader reader("");
 
   uint32 rows_read = 0xFF;
 
   std::vector<uint8> data =
       PmpTestHelper::MakeHeaderAndBody(field_type, elems.size(), elems);
-  ASSERT_TRUE(test_helper.InitColumnReaderFromBytes(&reader, data, &rows_read));
+  ASSERT_TRUE(test_helper.InitColumnReaderFromBytes(
+      &reader, data, field_type, &rows_read));
   EXPECT_EQ(elems.size(), rows_read);
 
   for(uint32 i = 0; i < elems.size() && i < rows_read; i++) {
     T target;
     EXPECT_TRUE(DoRead(&reader, i, &target));
     EXPECT_EQ(elems[i], target);
   }
 }
 
 template<class T>
-void TestMalformed(const uint16 field_type, const std::vector<T>& elems) {
+void TestMalformed(const picasaimport::PmpFieldType field_type,
+                   const std::vector<T>& elems) {
   PmpTestHelper test_helper;
   ASSERT_TRUE(test_helper.Init());
 
-  PmpColumnReader reader1, reader2, reader3, reader4;
+  PmpColumnReader reader1(""), reader2(""), reader3(""), reader4("");

[vandebo (ex-Chrome), 2013/04/09 19:16:56]

probably should put these on multiple lines now... actually each one should be
declared just before it is used.  Wouldn't hurt to give them a name too.

[tommycli, 2013/04/11 18:24:05]

Done.

 
   std::vector<uint8> data_too_few_declared_rows =
       PmpTestHelper::MakeHeaderAndBody(field_type, elems.size()-1, elems);
   EXPECT_FALSE(test_helper.InitColumnReaderFromBytes(
-      &reader1, data_too_few_declared_rows, NULL));
+      &reader1, data_too_few_declared_rows, field_type, NULL));
 
   std::vector<uint8> data_too_many_declared_rows =
       PmpTestHelper::MakeHeaderAndBody(field_type, elems.size()+1, elems);
   EXPECT_FALSE(test_helper.InitColumnReaderFromBytes(
-      &reader2, data_too_many_declared_rows, NULL));
+      &reader2, data_too_many_declared_rows, field_type, NULL));
 
   std::vector<uint8> data_truncated =
       PmpTestHelper::MakeHeaderAndBody(field_type, elems.size(), elems);
   data_truncated.resize(data_truncated.size()-10);
   EXPECT_FALSE(test_helper.InitColumnReaderFromBytes(
-      &reader3, data_truncated, NULL));
+      &reader3, data_truncated, field_type, NULL));
 
   std::vector<uint8> data_padded =
       PmpTestHelper::MakeHeaderAndBody(field_type, elems.size(), elems);
   data_padded.resize(data_padded.size()+10);
   EXPECT_FALSE(test_helper.InitColumnReaderFromBytes(
-      &reader4, data_padded, NULL));
+      &reader4, data_padded, field_type, NULL));
 }
 
 template<class T>
-void TestPrimitive(const uint16 field_type) {
+void TestPrimitive(const picasaimport::PmpFieldType field_type) {
   // Make an ascending vector of the primitive.
   uint32 n = 100;
   std::vector<T> data(n, 0);
   for(uint32 i = 0; i < n; i++) {
     data[i] = i*3;
   }
 
   TestValid<T>(field_type, data);
   TestMalformed<T>(field_type, data);
 }
 
 
 TEST(PmpColumnReaderTest, HeaderParsingAndValidation) {
   PmpTestHelper test_helper;
   ASSERT_TRUE(test_helper.Init());
 
-  PmpColumnReader reader1, reader2, reader3, reader4, reader5;
+  PmpColumnReader reader1(""), reader2(""), reader3(""), reader4(""),

[vandebo (ex-Chrome), 2013/04/09 19:16:56]

same here

[tommycli, 2013/04/11 18:24:05]

Done.

+                  reader5("");
 
   // Good header.
   uint32 rows_read = 0xFF;
-  std::vector<uint8> good_header = PmpTestHelper::MakeHeader(0x00, 0);
+  std::vector<uint8> good_header =
+      PmpTestHelper::MakeHeader(picasaimport::PMP_STRING_TYPE, 0);
   ASSERT_TRUE(test_helper.InitColumnReaderFromBytes(
-      &reader1, good_header, &rows_read));
+      &reader1, good_header, picasaimport::PMP_STRING_TYPE, &rows_read));
   EXPECT_EQ(0U, rows_read) << "Read non-zero rows from header-only data.";
 
   // Botch up elements of the header.
-  std::vector<uint8> bad_magic_byte = PmpTestHelper::MakeHeader(0x00, 0);
+  std::vector<uint8> bad_magic_byte =
+      PmpTestHelper::MakeHeader(picasaimport::PMP_STRING_TYPE, 0);
   bad_magic_byte[0] = 0xff;
   EXPECT_FALSE(test_helper.InitColumnReaderFromBytes(
-      &reader2, bad_magic_byte, NULL));
+      &reader2, bad_magic_byte, picasaimport::PMP_STRING_TYPE, NULL));
 
   // Corrupt means the type fields don't agree.
-  std::vector<uint8> corrupt_type = PmpTestHelper::MakeHeader(0x00, 0);
+  std::vector<uint8> corrupt_type =
+      PmpTestHelper::MakeHeader(picasaimport::PMP_STRING_TYPE, 0);
   corrupt_type[picasaimport::kPmpFieldType1Offset] = 0xff;
   EXPECT_FALSE(test_helper.InitColumnReaderFromBytes(
-      &reader3, corrupt_type, NULL));
+      &reader3, corrupt_type, picasaimport::PMP_STRING_TYPE, NULL));
 
-  std::vector<uint8> invalid_type = PmpTestHelper::MakeHeader(0x00, 0);
+  std::vector<uint8> invalid_type =
+      PmpTestHelper::MakeHeader(picasaimport::PMP_STRING_TYPE, 0);
   invalid_type[picasaimport::kPmpFieldType1Offset] = 0xff;
   invalid_type[picasaimport::kPmpFieldType2Offset] = 0xff;
   EXPECT_FALSE(test_helper.InitColumnReaderFromBytes(
-      &reader4, invalid_type, NULL));
+      &reader4, invalid_type, picasaimport::PMP_STRING_TYPE, NULL));
 
-  std::vector<uint8> incomplete_header = PmpTestHelper::MakeHeader(0x00, 0);
+  std::vector<uint8> incomplete_header =
+      PmpTestHelper::MakeHeader(picasaimport::PMP_STRING_TYPE, 0);
   incomplete_header.resize(10);
   EXPECT_FALSE(test_helper.InitColumnReaderFromBytes(
-      &reader5, incomplete_header, NULL));
+      &reader5, incomplete_header, picasaimport::PMP_STRING_TYPE, NULL));
 }
 
 TEST(PmpColumnReaderTest, StringParsing) {
   std::vector<std::string> empty_strings(100, "");
 
   // Test empty strings read okay.
   TestValid(picasaimport::PMP_STRING_TYPE, empty_strings);
 
   std::vector<std::string> mixed_strings;
   mixed_strings.push_back("");
@@ skipping 12 matching lines @@
 }
 
 TEST(PmpColumnReaderTest, PrimitiveParsing) {
   TestPrimitive<uint32>(picasaimport::PMP_UINT32_TYPE);
   TestPrimitive<double>(picasaimport::PMP_DOUBLE64_TYPE);
   TestPrimitive<uint8>(picasaimport::PMP_UINT8_TYPE);
   TestPrimitive<uint64>(picasaimport::PMP_UINT64_TYPE);
 }
 
 }  // namespace