| // Copyright 2014 The Chromium OS 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 <sys/stat.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| |
| #include "metrics/serialization/serialization_utils.h" |
| |
| #include <base/files/file_util.h> |
| #include <base/files/scoped_temp_dir.h> |
| #include <base/logging.h> |
| #include <base/strings/stringprintf.h> |
| #include <gtest/gtest.h> |
| |
| #include "metrics/serialization/metric_sample.h" |
| |
| namespace metrics { |
| namespace { |
| |
| class SerializationUtilsTest : public testing::Test { |
| protected: |
| SerializationUtilsTest() { |
| bool success = temporary_dir_.CreateUniqueTempDir(); |
| if (success) { |
| base::FilePath dir_path = temporary_dir_.path(); |
| filepath_ = dir_path.Append("chromeossampletest"); |
| filename_ = filepath_.value(); |
| } |
| } |
| |
| void SetUp() override { base::DeleteFile(filepath_, false); } |
| |
| void TestSerialization(MetricSample* sample) { |
| std::string serialized(sample->ToString()); |
| ASSERT_EQ('\0', serialized[serialized.length() - 1]); |
| std::unique_ptr<MetricSample> deserialized = |
| SerializationUtils::ParseSample(serialized); |
| ASSERT_TRUE(deserialized.get()); |
| EXPECT_TRUE(sample->IsEqual(*deserialized.get())); |
| } |
| |
| std::string filename_; |
| base::ScopedTempDir temporary_dir_; |
| base::FilePath filepath_; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(SerializationUtilsTest); |
| }; |
| |
| TEST_F(SerializationUtilsTest, CrashSerializeTest) { |
| TestSerialization(MetricSample::CrashSample("test").get()); |
| } |
| |
| TEST_F(SerializationUtilsTest, HistogramSerializeTest) { |
| TestSerialization( |
| MetricSample::HistogramSample("myhist", 13, 1, 100, 10).get()); |
| } |
| |
| TEST_F(SerializationUtilsTest, RepeatedSerializeTest) { |
| TestSerialization(MetricSample::HistogramSample( |
| "myrepeatedhist", 26, 1, 100, 10, 1000).get()); |
| } |
| |
| TEST_F(SerializationUtilsTest, LinearSerializeTest) { |
| TestSerialization( |
| MetricSample::LinearHistogramSample("linearhist", 12, 30).get()); |
| } |
| |
| TEST_F(SerializationUtilsTest, SparseSerializeTest) { |
| TestSerialization(MetricSample::SparseHistogramSample("mysparse", 30).get()); |
| } |
| |
| TEST_F(SerializationUtilsTest, UserActionSerializeTest) { |
| TestSerialization(MetricSample::UserActionSample("myaction").get()); |
| } |
| |
| TEST_F(SerializationUtilsTest, IllegalNameAreFilteredTest) { |
| std::unique_ptr<MetricSample> sample1 = |
| MetricSample::SparseHistogramSample("no space", 10); |
| std::unique_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_t size = 0; |
| |
| ASSERT_TRUE(!PathExists(filepath_) || base::GetFileSize(filepath_, &size)); |
| |
| EXPECT_EQ(0, size); |
| } |
| |
| TEST_F(SerializationUtilsTest, BadInputIsCaughtTest) { |
| std::string input( |
| base::StringPrintf("sparsehistogram%cname foo%c", '\0', '\0')); |
| EXPECT_EQ(NULL, MetricSample::ParseSparseHistogram(input).get()); |
| } |
| |
| TEST_F(SerializationUtilsTest, MessageSeparatedByZero) { |
| std::unique_ptr<MetricSample> crash = MetricSample::CrashSample("mycrash"); |
| |
| SerializationUtils::WriteMetricToFile(*crash.get(), filename_); |
| int64_t 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(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'); |
| |
| std::unique_ptr<MetricSample> crash = MetricSample::CrashSample(name); |
| EXPECT_FALSE(SerializationUtils::WriteMetricToFile(*crash.get(), filename_)); |
| int64_t size = 0; |
| ASSERT_TRUE(base::GetFileSize(filepath_, &size)); |
| EXPECT_EQ(0, size); |
| } |
| |
| 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_t message_size = message.length() + sizeof(int32_t); |
| test_file.WriteAtCurrentPos(reinterpret_cast<const char*>(&message_size), |
| sizeof(message_size)); |
| test_file.WriteAtCurrentPos(message.c_str(), message.length()); |
| test_file.Close(); |
| |
| std::unique_ptr<MetricSample> crash = MetricSample::CrashSample("test"); |
| SerializationUtils::WriteMetricToFile(*crash.get(), filename_); |
| |
| std::vector<std::unique_ptr<MetricSample>> samples; |
| SerializationUtils::ReadAndTruncateMetricsFromFile( |
| filename_, |
| &samples, |
| SerializationUtils::kSampleBatchMaxLength); |
| ASSERT_EQ(1u, samples.size()); |
| ASSERT_NE(nullptr, samples[0]); |
| EXPECT_TRUE(crash->IsEqual(*samples[0])); |
| } |
| |
| TEST_F(SerializationUtilsTest, WriteReadTest) { |
| std::unique_ptr<MetricSample> hist = |
| MetricSample::HistogramSample("myhist", 1, 2, 3, 4); |
| std::unique_ptr<MetricSample> crash = MetricSample::CrashSample("mycrash"); |
| std::unique_ptr<MetricSample> lhist = |
| MetricSample::LinearHistogramSample("linear", 1, 10); |
| std::unique_ptr<MetricSample> shist = |
| MetricSample::SparseHistogramSample("mysparse", 30); |
| std::unique_ptr<MetricSample> action = |
| MetricSample::UserActionSample("myaction"); |
| std::unique_ptr<MetricSample> repeatedhist = |
| MetricSample::HistogramSample("myrepeatedhist", 1, 2, 3, 4, 10); |
| |
| SerializationUtils::WriteMetricToFile(*hist.get(), filename_); |
| SerializationUtils::WriteMetricToFile(*crash.get(), filename_); |
| SerializationUtils::WriteMetricToFile(*lhist.get(), filename_); |
| SerializationUtils::WriteMetricToFile(*shist.get(), filename_); |
| SerializationUtils::WriteMetricToFile(*action.get(), filename_); |
| SerializationUtils::WriteMetricToFile(*repeatedhist.get(), filename_); |
| std::vector<std::unique_ptr<MetricSample>> samples; |
| SerializationUtils::ReadAndTruncateMetricsFromFile( |
| filename_, |
| &samples, |
| SerializationUtils::kSampleBatchMaxLength); |
| ASSERT_EQ(6, samples.size()); |
| for (const auto& sample : samples) { |
| ASSERT_NE(nullptr, sample); |
| } |
| EXPECT_TRUE(hist->IsEqual(*samples[0])); |
| EXPECT_TRUE(crash->IsEqual(*samples[1])); |
| EXPECT_TRUE(lhist->IsEqual(*samples[2])); |
| EXPECT_TRUE(shist->IsEqual(*samples[3])); |
| EXPECT_TRUE(action->IsEqual(*samples[4])); |
| EXPECT_TRUE(repeatedhist->IsEqual(*samples[5])); |
| |
| int64_t size = 0; |
| ASSERT_TRUE(base::GetFileSize(filepath_, &size)); |
| ASSERT_EQ(0, size); |
| } |
| |
| // Test of batched upload. Creates a metrics log with enough samples to |
| // trigger two uploads. |
| TEST_F(SerializationUtilsTest, BatchedUploadTest) { |
| std::unique_ptr<MetricSample> hist = |
| MetricSample::HistogramSample("Boring.Histogram", 1, 2, 3, 4); |
| // The serialized MetricSample does not contain the header size (4 bytes for |
| // the total sample length). |
| size_t serialized_sample_length = hist->ToString().length() + 4; |
| // Make the max batch size a multiple of the filesystem block size so we can |
| // test the hole-punching optimization (maybe overkill, but fun). |
| const size_t sample_batch_max_length = 10 * 4096; |
| // Write enough samples for two passes. |
| const int sample_count = |
| 1.5 * sample_batch_max_length / serialized_sample_length; |
| |
| for (int i = 0; i < sample_count; i++) { |
| SerializationUtils::WriteMetricToFile(*hist.get(), filename_); |
| } |
| |
| std::vector<std::unique_ptr<MetricSample>> samples; |
| bool first_pass_status = |
| SerializationUtils::ReadAndTruncateMetricsFromFile( |
| filename_, |
| &samples, |
| sample_batch_max_length); |
| |
| ASSERT_FALSE(first_pass_status); // means: more samples remain |
| int first_pass_count = samples.size(); |
| ASSERT_LT(first_pass_count, sample_count); |
| |
| // There is nothing in the base library which returns the actual file |
| // allocation (size - holes). |
| struct stat stat_buf; |
| // Check that stat() is successful. |
| ASSERT_EQ(::stat(filename_.c_str(), &stat_buf), 0); |
| // Check that the file is not truncated to zero. |
| ASSERT_GT(stat_buf.st_size, 0); |
| // Check that the file has holes. |
| ASSERT_LT(stat_buf.st_blocks * 512, stat_buf.st_size); |
| |
| bool second_pass_status = |
| SerializationUtils::ReadAndTruncateMetricsFromFile( |
| filename_, |
| &samples, |
| sample_batch_max_length); |
| |
| ASSERT_TRUE(second_pass_status); // no more samples. |
| // Check that stat() is successful. |
| ASSERT_EQ(::stat(filename_.c_str(), &stat_buf), 0); |
| // Check that the file is empty. |
| ASSERT_EQ(stat_buf.st_size, 0); |
| // Check that we read all samples. |
| ASSERT_EQ(samples.size(), sample_count); |
| } |
| |
| |
| } // namespace |
| } // namespace metrics |