Moves components/metrics/chromeos to c/m/serialization/.

components/metrics/serialization/serialization_utils_unittest.cc

 // Copyright 2014 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 "components/metrics/chromeos/serialization_utils.h"
+#include "components/metrics/serialization/serialization_utils.h"
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
-#include "components/metrics/chromeos/metric_sample.h"
+#include "components/metrics/serialization/metric_sample.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace metrics {
 namespace {
 
-class SerializationUtilsChromeOSTest : public testing::Test {
+class SerializationUtilsTest : public testing::Test {
  protected:
-  SerializationUtilsChromeOSTest() {
+  SerializationUtilsTest() {
     bool success = temporary_dir.CreateUniqueTempDir();
     if (success) {
       base::FilePath dir_path = temporary_dir.path();
       filename = dir_path.value() + "chromeossampletest";
       filepath = base::FilePath(filename);
     }
   }
 
   virtual void SetUp() OVERRIDE {
     base::DeleteFile(filepath, false);
   }
 
   void TestSerialization(MetricSample* sample) {
     std::string serialized(sample->ToString());
     ASSERT_EQ('\0', serialized[serialized.length() - 1]);
     scoped_ptr<MetricSample> deserialized =
         SerializationUtils::ParseSample(serialized);
     ASSERT_TRUE(deserialized);
     EXPECT_TRUE(sample->IsEqual(*deserialized.get()));
   }
 
   std::string filename;
   base::ScopedTempDir temporary_dir;
   base::FilePath filepath;
 };
 
-TEST_F(SerializationUtilsChromeOSTest, CrashSerializeTest) {
+TEST_F(SerializationUtilsTest, CrashSerializeTest) {
   TestSerialization(MetricSample::CrashSample("test").get());
 }
 
-TEST_F(SerializationUtilsChromeOSTest, HistogramSerializeTest) {
+TEST_F(SerializationUtilsTest, HistogramSerializeTest) {
   TestSerialization(
       MetricSample::HistogramSample("myhist", 13, 1, 100, 10).get());
 }
 
-TEST_F(SerializationUtilsChromeOSTest, LinearSerializeTest) {
+TEST_F(SerializationUtilsTest, LinearSerializeTest) {
   TestSerialization(
       MetricSample::LinearHistogramSample("linearhist", 12, 30).get());
 }
 
-TEST_F(SerializationUtilsChromeOSTest, SparseSerializeTest) {
+TEST_F(SerializationUtilsTest, SparseSerializeTest) {
   TestSerialization(MetricSample::SparseHistogramSample("mysparse", 30).get());
 }
 
-TEST_F(SerializationUtilsChromeOSTest, UserActionSerializeTest) {
+TEST_F(SerializationUtilsTest, UserActionSerializeTest) {
   TestSerialization(MetricSample::UserActionSample("myaction").get());
 }
 
-TEST_F(SerializationUtilsChromeOSTest, IllegalNameAreFilteredTest) {
+TEST_F(SerializationUtilsTest, IllegalNameAreFilteredTest) {
   scoped_ptr<MetricSample> sample1 =
       MetricSample::SparseHistogramSample("no space", 10);
   scoped_ptr<MetricSample> sample2 = MetricSample::LinearHistogramSample(
       base::StringPrintf("here%cbhe", '\0'), 1, 3);
 
   EXPECT_FALSE(SerializationUtils::WriteMetricToFile(*sample1.get(), filename));
   EXPECT_FALSE(SerializationUtils::WriteMetricToFile(*sample2.get(), filename));
   int64 size = 0;
 
   ASSERT_TRUE(!PathExists(filepath) || base::GetFileSize(filepath, &size));
 
   EXPECT_EQ(0, size);
 }
 
-TEST_F(SerializationUtilsChromeOSTest, BadInputIsCaughtTest) {
+TEST_F(SerializationUtilsTest, BadInputIsCaughtTest) {
   std::string input(
       base::StringPrintf("sparsehistogram%cname foo%c", '\0', '\0'));
   EXPECT_EQ(NULL, MetricSample::ParseSparseHistogram(input).get());
 }
 
-TEST_F(SerializationUtilsChromeOSTest, MessageSeparatedByZero) {
+TEST_F(SerializationUtilsTest, MessageSeparatedByZero) {
   scoped_ptr<MetricSample> crash = MetricSample::CrashSample("mycrash");
 
   SerializationUtils::WriteMetricToFile(*crash.get(), filename);
   int64 size = 0;
   ASSERT_TRUE(base::GetFileSize(filepath, &size));
   // 4 bytes for the size
   // 5 bytes for crash
   // 7 bytes for mycrash
   // 2 bytes for the \0
   // -> total of 18
   EXPECT_EQ(size, 18);
 }
 
-TEST_F(SerializationUtilsChromeOSTest, MessagesTooLongAreDiscardedTest) {
+TEST_F(SerializationUtilsTest, MessagesTooLongAreDiscardedTest) {
   // Creates a message that is bigger than the maximum allowed size.
   // As we are adding extra character (crash, \0s, etc), if the name is
   // kMessageMaxLength long, it will be too long.
   std::string name(SerializationUtils::kMessageMaxLength, 'c');
 
   scoped_ptr<MetricSample> crash = MetricSample::CrashSample(name);
   EXPECT_FALSE(SerializationUtils::WriteMetricToFile(*crash.get(), filename));
   int64 size = 0;
   ASSERT_TRUE(base::GetFileSize(filepath, &size));
   EXPECT_EQ(0, size);
 }
 
-TEST_F(SerializationUtilsChromeOSTest, ReadLongMessageTest) {
+TEST_F(SerializationUtilsTest, ReadLongMessageTest) {
   base::File test_file(filepath,
                        base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_APPEND);
   std::string message(SerializationUtils::kMessageMaxLength + 1, 'c');
 
   int32 message_size = message.length() + sizeof(int32);
   test_file.WriteAtCurrentPos(reinterpret_cast<const char*>(&message_size),
                               sizeof(message_size));
   test_file.WriteAtCurrentPos(message.c_str(), message.length());
   test_file.Close();
 
   scoped_ptr<MetricSample> crash = MetricSample::CrashSample("test");
   SerializationUtils::WriteMetricToFile(*crash.get(), filename);
 
   ScopedVector<MetricSample> samples;
   SerializationUtils::ReadAndTruncateMetricsFromFile(filename, &samples);
   ASSERT_EQ(size_t(1), samples.size());
   ASSERT_TRUE(samples[0] != NULL);
   EXPECT_TRUE(crash->IsEqual(*samples[0]));
 }
 
-TEST_F(SerializationUtilsChromeOSTest, WriteReadTest) {
+TEST_F(SerializationUtilsTest, WriteReadTest) {
   scoped_ptr<MetricSample> hist =
       MetricSample::HistogramSample("myhist", 1, 2, 3, 4);
   scoped_ptr<MetricSample> crash = MetricSample::CrashSample("mycrash");
   scoped_ptr<MetricSample> lhist =
       MetricSample::LinearHistogramSample("linear", 1, 10);
   scoped_ptr<MetricSample> shist =
       MetricSample::SparseHistogramSample("mysparse", 30);
   scoped_ptr<MetricSample> action = MetricSample::UserActionSample("myaction");
 
   SerializationUtils::WriteMetricToFile(*hist.get(), filename);
@@ skipping 13 matching lines @@
   EXPECT_TRUE(shist->IsEqual(*vect[3]));
   EXPECT_TRUE(action->IsEqual(*vect[4]));
 
   int64 size = 0;
   ASSERT_TRUE(base::GetFileSize(filepath, &size));
   ASSERT_EQ(0, size);
 }
 
 }  // namespace
 }  // namespace metrics