chrome/utility/media_galleries/pmp_column_reader_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <algorithm>
   6 #include <vector>
   7
   8 #include "base/files/file.h"
   9 #include "base/files/file_util.h"
  10 #include "base/files/scoped_temp_dir.h"
  11 #include "chrome/common/media_galleries/pmp_constants.h"
  12 #include "chrome/common/media_galleries/pmp_test_util.h"
  13 #include "chrome/utility/media_galleries/pmp_column_reader.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace picasa {
  17
  18 namespace {
  19
  20 bool InitColumnReaderFromBytes(
  21     PmpColumnReader* const reader,
  22     const std::vector<char>& data,
  23     const PmpFieldType expected_type) {
  24   base::ScopedTempDir temp_dir;
  25   if (!temp_dir.CreateUniqueTempDir())
  26     return false;
  27
  28   base::FilePath temp_path;
  29   if (!base::CreateTemporaryFileInDir(temp_dir.path(), &temp_path))
  30     return false;
  31
  32   // Explicit conversion from signed to unsigned.
  33   size_t bytes_written = base::WriteFile(temp_path, &data[0], data.size());
  34   if (bytes_written != data.size())
  35     return false;
  36
  37   base::File file(temp_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
  38   if (!file.IsValid())
  39     return false;
  40
  41   return reader->ReadFile(&file, expected_type);
  42 }
  43
  44 // Overridden version of Read method to make test code templatable.
  45 bool DoRead(const PmpColumnReader* reader, uint32 row, std::string* target) {
  46   return reader->ReadString(row, target);
  47 }
  48
  49 bool DoRead(const PmpColumnReader* reader, uint32 row, uint32* target) {
  50   return reader->ReadUInt32(row, target);
  51 }
  52
  53 bool DoRead(const PmpColumnReader* reader, uint32 row, double* target) {
  54   return reader->ReadDouble64(row, target);
  55 }
  56
  57 bool DoRead(const PmpColumnReader* reader, uint32 row, uint8* target) {
  58   return reader->ReadUInt8(row, target);
  59 }
  60
  61 bool DoRead(const PmpColumnReader* reader, uint32 row, uint64* target) {
  62   return reader->ReadUInt64(row, target);
  63 }
  64
  65 // TestValid
  66 template<class T>
  67 void TestValid(const PmpFieldType field_type,
  68                const std::vector<T>& elems) {
  69   PmpColumnReader reader;
  70   std::vector<char> data =
  71       PmpTestUtil::MakeHeaderAndBody(field_type, elems.size(), elems);
  72   ASSERT_TRUE(InitColumnReaderFromBytes(&reader, data, field_type));
  73   EXPECT_EQ(elems.size(), reader.rows_read());
  74
  75   for (uint32 i = 0; i < elems.size() && i < reader.rows_read(); i++) {
  76     T target;
  77     EXPECT_TRUE(DoRead(&reader, i, &target));
  78     EXPECT_EQ(elems[i], target);
  79   }
  80 }
  81
  82 template<class T>
  83 void TestMalformed(const PmpFieldType field_type,
  84                    const std::vector<T>& elems) {
  85   PmpColumnReader reader_too_few_declared_rows;
  86   std::vector<char> data_too_few_declared_rows =
  87       PmpTestUtil::MakeHeaderAndBody(field_type, elems.size()-1, elems);
  88   EXPECT_FALSE(InitColumnReaderFromBytes(&reader_too_few_declared_rows,
  89                                          data_too_few_declared_rows,
  90                                          field_type));
  91
  92   PmpColumnReader reader_too_many_declared_rows;
  93   std::vector<char> data_too_many_declared_rows =
  94       PmpTestUtil::MakeHeaderAndBody(field_type, elems.size()+1, elems);
  95   EXPECT_FALSE(InitColumnReaderFromBytes(&reader_too_many_declared_rows,
  96                                          data_too_many_declared_rows,
  97                                          field_type));
  98
  99   PmpColumnReader reader_truncated;
 100   std::vector<char> data_truncated =
 101       PmpTestUtil::MakeHeaderAndBody(field_type, elems.size(), elems);
 102   data_truncated.resize(data_truncated.size()-10);
 103   EXPECT_FALSE(InitColumnReaderFromBytes(&reader_truncated,
 104                                          data_truncated,
 105                                          field_type));
 106
 107   PmpColumnReader reader_padded;
 108   std::vector<char> data_padded =
 109       PmpTestUtil::MakeHeaderAndBody(field_type, elems.size(), elems);
 110   data_padded.resize(data_padded.size()+10);
 111   EXPECT_FALSE(InitColumnReaderFromBytes(&reader_padded,
 112                                          data_padded,
 113                                          field_type));
 114 }
 115
 116 template<class T>
 117 void TestPrimitive(const PmpFieldType field_type) {
 118   // Make an ascending vector of the primitive.
 119   uint32 n = 100;
 120   std::vector<T> data(n, 0);
 121   for (uint32 i = 0; i < n; i++) {
 122     data[i] = i*3;
 123   }
 124
 125   TestValid<T>(field_type, data);
 126   TestMalformed<T>(field_type, data);
 127 }
 128
 129
 130 TEST(PmpColumnReaderTest, HeaderParsingAndValidation) {
 131   PmpColumnReader reader_good_header;
 132   std::vector<char> good_header =
 133       PmpTestUtil::MakeHeader(PMP_TYPE_STRING, 0);
 134   EXPECT_TRUE(InitColumnReaderFromBytes(&reader_good_header,
 135                                         good_header,
 136                                         PMP_TYPE_STRING));
 137   EXPECT_EQ(0U, reader_good_header.rows_read()) <<
 138       "Read non-zero rows from header-only data.";
 139
 140   PmpColumnReader reader_bad_magic_bytes;
 141   std::vector<char> bad_magic_bytes =
 142       PmpTestUtil::MakeHeader(PMP_TYPE_STRING, 0);
 143   bad_magic_bytes[0] = static_cast<char>(-128);
 144   EXPECT_FALSE(InitColumnReaderFromBytes(&reader_bad_magic_bytes,
 145                                          bad_magic_bytes,
 146                                          PMP_TYPE_STRING));
 147
 148   PmpColumnReader reader_inconsistent_types;
 149   std::vector<char> inconsistent_type =
 150       PmpTestUtil::MakeHeader(PMP_TYPE_STRING, 0);
 151   inconsistent_type[kPmpFieldType1Offset] = static_cast<char>(-128);
 152   EXPECT_FALSE(InitColumnReaderFromBytes(&reader_inconsistent_types,
 153                                          inconsistent_type,
 154                                          PMP_TYPE_STRING));
 155
 156   PmpColumnReader reader_invalid_type;
 157   std::vector<char> invalid_type =
 158       PmpTestUtil::MakeHeader(PMP_TYPE_STRING, 0);
 159   invalid_type[kPmpFieldType1Offset] = static_cast<char>(-128);
 160   invalid_type[kPmpFieldType2Offset] = static_cast<char>(-128);
 161   EXPECT_FALSE(InitColumnReaderFromBytes(&reader_invalid_type,
 162                                          invalid_type,
 163                                          PMP_TYPE_STRING));
 164
 165   PmpColumnReader reader_incomplete_header;
 166   std::vector<char> incomplete_header =
 167       PmpTestUtil::MakeHeader(PMP_TYPE_STRING, 0);
 168   incomplete_header.resize(10);
 169   EXPECT_FALSE(InitColumnReaderFromBytes(&reader_incomplete_header,
 170                                          incomplete_header,
 171                                          PMP_TYPE_STRING));
 172 }
 173
 174 TEST(PmpColumnReaderTest, StringParsing) {
 175   std::vector<std::string> empty_strings(100, "");
 176
 177   // Test empty strings read okay.
 178   TestValid(PMP_TYPE_STRING, empty_strings);
 179
 180   std::vector<std::string> mixed_strings;
 181   mixed_strings.push_back("");
 182   mixed_strings.push_back("Hello");
 183   mixed_strings.push_back("World");
 184   mixed_strings.push_back("");
 185   mixed_strings.push_back("123123");
 186   mixed_strings.push_back("Q");
 187   mixed_strings.push_back("");
 188
 189   // Test that a mixed set of strings read correctly.
 190   TestValid(PMP_TYPE_STRING, mixed_strings);
 191
 192   // Test with the data messed up in a variety of ways.
 193   TestMalformed(PMP_TYPE_STRING, mixed_strings);
 194 }
 195
 196 TEST(PmpColumnReaderTest, PrimitiveParsing) {
 197   TestPrimitive<uint32>(PMP_TYPE_UINT32);
 198   TestPrimitive<double>(PMP_TYPE_DOUBLE64);
 199   TestPrimitive<uint8>(PMP_TYPE_UINT8);
 200   TestPrimitive<uint64>(PMP_TYPE_UINT64);
 201 }
 202
 203 }  // namespace
 204
 205 }  // namespace picasa