Bertrand SIMONNET | 52e5b99 | 2015-08-10 15:18:00 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 16 | |
Daniel Erat | b9b05e6 | 2010-11-09 12:18:51 -0800 | [diff] [blame] | 17 | #include <vector> |
| 18 | |
Luigi Semenzato | 859b3f0 | 2014-02-05 15:33:19 -0800 | [diff] [blame] | 19 | #include <base/at_exit.h> |
Ben Chan | 51bf92a | 2014-09-05 08:21:06 -0700 | [diff] [blame] | 20 | #include <base/files/file_util.h> |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 21 | #include <base/files/scoped_temp_dir.h> |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 22 | #include <base/strings/string_number_conversions.h> |
Alex Vakulenko | 74dc624 | 2015-10-13 09:23:34 -0700 | [diff] [blame] | 23 | #include <brillo/flag_helper.h> |
Darin Petkov | f1e85e4 | 2010-06-10 15:59:53 -0700 | [diff] [blame] | 24 | #include <gtest/gtest.h> |
| 25 | |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 26 | #include "constants.h" |
Bertrand SIMONNET | 608e428 | 2015-11-12 17:52:17 -0800 | [diff] [blame] | 27 | #include "metrics_collector.h" |
Samuel Tan | 28a78b7 | 2015-09-23 14:39:35 -0700 | [diff] [blame] | 28 | #include "metrics/metrics_library_mock.h" |
Bertrand SIMONNET | 4b915ae | 2015-07-28 15:38:14 -0700 | [diff] [blame] | 29 | #include "persistent_integer_mock.h" |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 30 | |
Ben Chan | 2e6543d | 2014-02-05 23:26:25 -0800 | [diff] [blame] | 31 | using base::FilePath; |
Daniel Erat | c83975a | 2014-04-04 08:53:44 -0700 | [diff] [blame] | 32 | using base::TimeDelta; |
Daniel Erat | b9b05e6 | 2010-11-09 12:18:51 -0800 | [diff] [blame] | 33 | using std::string; |
| 34 | using std::vector; |
Darin Petkov | f1e85e4 | 2010-06-10 15:59:53 -0700 | [diff] [blame] | 35 | using ::testing::_; |
Steve Fung | e86591e | 2014-12-01 13:38:21 -0800 | [diff] [blame] | 36 | using ::testing::AnyNumber; |
Daniel Erat | c83975a | 2014-04-04 08:53:44 -0700 | [diff] [blame] | 37 | using ::testing::AtLeast; |
Darin Petkov | fc91b42 | 2010-05-12 13:05:45 -0700 | [diff] [blame] | 38 | using ::testing::Return; |
| 39 | using ::testing::StrictMock; |
Luigi Semenzato | 2fd51cc | 2014-02-26 11:53:16 -0800 | [diff] [blame] | 40 | using chromeos_metrics::PersistentIntegerMock; |
Darin Petkov | fc91b42 | 2010-05-12 13:05:45 -0700 | [diff] [blame] | 41 | |
Luigi Semenzato | 5bd764f | 2011-10-14 12:03:35 -0700 | [diff] [blame] | 42 | |
Bertrand SIMONNET | 608e428 | 2015-11-12 17:52:17 -0800 | [diff] [blame] | 43 | class MetricsCollectorTest : public testing::Test { |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 44 | protected: |
| 45 | virtual void SetUp() { |
Alex Vakulenko | 74dc624 | 2015-10-13 09:23:34 -0700 | [diff] [blame] | 46 | brillo::FlagHelper::Init(0, nullptr, ""); |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 47 | EXPECT_TRUE(temp_dir_.CreateUniqueTempDir()); |
Bertrand SIMONNET | 9d3a4ae | 2015-11-25 13:49:12 -0800 | [diff] [blame] | 48 | |
| 49 | base::FilePath private_dir = temp_dir_.path().Append("private"); |
| 50 | base::FilePath shared_dir = temp_dir_.path().Append("shared"); |
| 51 | |
| 52 | EXPECT_TRUE(base::CreateDirectory(private_dir)); |
| 53 | EXPECT_TRUE(base::CreateDirectory(shared_dir)); |
| 54 | |
| 55 | daemon_.Init(true, &metrics_lib_, "", private_dir, shared_dir); |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 56 | } |
| 57 | |
Darin Petkov | fc91b42 | 2010-05-12 13:05:45 -0700 | [diff] [blame] | 58 | // Adds a metrics library mock expectation that the specified metric |
| 59 | // will be generated. |
Daniel Erat | c83975a | 2014-04-04 08:53:44 -0700 | [diff] [blame] | 60 | void ExpectSample(const std::string& name, int sample) { |
| 61 | EXPECT_CALL(metrics_lib_, SendToUMA(name, sample, _, _, _)) |
Darin Petkov | fc91b42 | 2010-05-12 13:05:45 -0700 | [diff] [blame] | 62 | .Times(1) |
| 63 | .WillOnce(Return(true)) |
| 64 | .RetiresOnSaturation(); |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 65 | } |
| 66 | |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 67 | // Creates or overwrites the file in |path| so that it contains the printable |
| 68 | // representation of |value|. |
Ben Chan | f05ab40 | 2014-08-07 00:54:59 -0700 | [diff] [blame] | 69 | void CreateUint64ValueFile(const base::FilePath& path, uint64_t value) { |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 70 | std::string value_string = base::Uint64ToString(value); |
| 71 | ASSERT_EQ(value_string.length(), |
| 72 | base::WriteFile(path, value_string.c_str(), |
| 73 | value_string.length())); |
Luigi Semenzato | fb3a821 | 2013-05-07 16:55:00 -0700 | [diff] [blame] | 74 | } |
| 75 | |
Bertrand SIMONNET | 608e428 | 2015-11-12 17:52:17 -0800 | [diff] [blame] | 76 | // The MetricsCollector under test. |
| 77 | MetricsCollector daemon_; |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 78 | |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 79 | // Temporary directory used for tests. |
| 80 | base::ScopedTempDir temp_dir_; |
| 81 | |
Luigi Semenzato | 2fd51cc | 2014-02-26 11:53:16 -0800 | [diff] [blame] | 82 | // Mocks. They are strict mock so that all unexpected |
| 83 | // calls are marked as failures. |
Darin Petkov | fc91b42 | 2010-05-12 13:05:45 -0700 | [diff] [blame] | 84 | StrictMock<MetricsLibraryMock> metrics_lib_; |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 85 | }; |
| 86 | |
Bertrand SIMONNET | 608e428 | 2015-11-12 17:52:17 -0800 | [diff] [blame] | 87 | TEST_F(MetricsCollectorTest, SendSample) { |
Daniel Erat | c83975a | 2014-04-04 08:53:44 -0700 | [diff] [blame] | 88 | ExpectSample("Dummy.Metric", 3); |
Luigi Semenzato | 2fd51cc | 2014-02-26 11:53:16 -0800 | [diff] [blame] | 89 | daemon_.SendSample("Dummy.Metric", /* sample */ 3, |
Darin Petkov | 11b8eb3 | 2010-05-18 11:00:59 -0700 | [diff] [blame] | 90 | /* min */ 1, /* max */ 100, /* buckets */ 50); |
| 91 | } |
| 92 | |
Bertrand SIMONNET | 608e428 | 2015-11-12 17:52:17 -0800 | [diff] [blame] | 93 | TEST_F(MetricsCollectorTest, ProcessMeminfo) { |
Bertrand SIMONNET | e6cfd64 | 2014-07-09 16:35:23 -0700 | [diff] [blame] | 94 | string meminfo = |
| 95 | "MemTotal: 2000000 kB\nMemFree: 500000 kB\n" |
| 96 | "Buffers: 1000000 kB\nCached: 213652 kB\n" |
| 97 | "SwapCached: 0 kB\nActive: 133400 kB\n" |
| 98 | "Inactive: 183396 kB\nActive(anon): 92984 kB\n" |
| 99 | "Inactive(anon): 58860 kB\nActive(file): 40416 kB\n" |
| 100 | "Inactive(file): 124536 kB\nUnevictable: 0 kB\n" |
| 101 | "Mlocked: 0 kB\nSwapTotal: 0 kB\n" |
| 102 | "SwapFree: 0 kB\nDirty: 40 kB\n" |
| 103 | "Writeback: 0 kB\nAnonPages: 92652 kB\n" |
| 104 | "Mapped: 59716 kB\nShmem: 59196 kB\n" |
| 105 | "Slab: 16656 kB\nSReclaimable: 6132 kB\n" |
| 106 | "SUnreclaim: 10524 kB\nKernelStack: 1648 kB\n" |
| 107 | "PageTables: 2780 kB\nNFS_Unstable: 0 kB\n" |
| 108 | "Bounce: 0 kB\nWritebackTmp: 0 kB\n" |
| 109 | "CommitLimit: 970656 kB\nCommitted_AS: 1260528 kB\n" |
| 110 | "VmallocTotal: 122880 kB\nVmallocUsed: 12144 kB\n" |
| 111 | "VmallocChunk: 103824 kB\nDirectMap4k: 9636 kB\n" |
| 112 | "DirectMap2M: 1955840 kB\n"; |
| 113 | |
Luigi Semenzato | 8accd33 | 2011-05-17 16:37:18 -0700 | [diff] [blame] | 114 | // All enum calls must report percents. |
Bertrand SIMONNET | e6cfd64 | 2014-07-09 16:35:23 -0700 | [diff] [blame] | 115 | EXPECT_CALL(metrics_lib_, SendEnumToUMA(_, _, 100)).Times(AtLeast(1)); |
Luigi Semenzato | 8accd33 | 2011-05-17 16:37:18 -0700 | [diff] [blame] | 116 | // Check that MemFree is correctly computed at 25%. |
| 117 | EXPECT_CALL(metrics_lib_, SendEnumToUMA("Platform.MeminfoMemFree", 25, 100)) |
| 118 | .Times(AtLeast(1)); |
| 119 | // Check that we call SendToUma at least once (log histogram). |
Luigi Semenzato | 29c7ef9 | 2011-04-12 14:12:35 -0700 | [diff] [blame] | 120 | EXPECT_CALL(metrics_lib_, SendToUMA(_, _, _, _, _)) |
| 121 | .Times(AtLeast(1)); |
Luigi Semenzato | 8accd33 | 2011-05-17 16:37:18 -0700 | [diff] [blame] | 122 | // Make sure we don't report fields not in the list. |
| 123 | EXPECT_CALL(metrics_lib_, SendToUMA("Platform.MeminfoMlocked", _, _, _, _)) |
Luigi Semenzato | 29c7ef9 | 2011-04-12 14:12:35 -0700 | [diff] [blame] | 124 | .Times(0); |
Luigi Semenzato | 8accd33 | 2011-05-17 16:37:18 -0700 | [diff] [blame] | 125 | EXPECT_CALL(metrics_lib_, SendEnumToUMA("Platform.MeminfoMlocked", _, _)) |
Luigi Semenzato | 29c7ef9 | 2011-04-12 14:12:35 -0700 | [diff] [blame] | 126 | .Times(0); |
| 127 | EXPECT_TRUE(daemon_.ProcessMeminfo(meminfo)); |
| 128 | } |
| 129 | |
Bertrand SIMONNET | 608e428 | 2015-11-12 17:52:17 -0800 | [diff] [blame] | 130 | TEST_F(MetricsCollectorTest, ProcessMeminfo2) { |
Bertrand SIMONNET | e6cfd64 | 2014-07-09 16:35:23 -0700 | [diff] [blame] | 131 | string meminfo = "MemTotal: 2000000 kB\nMemFree: 1000000 kB\n"; |
Luigi Semenzato | fb3a821 | 2013-05-07 16:55:00 -0700 | [diff] [blame] | 132 | // Not enough fields. |
Luigi Semenzato | 29c7ef9 | 2011-04-12 14:12:35 -0700 | [diff] [blame] | 133 | EXPECT_FALSE(daemon_.ProcessMeminfo(meminfo)); |
| 134 | } |
| 135 | |
Bertrand SIMONNET | 608e428 | 2015-11-12 17:52:17 -0800 | [diff] [blame] | 136 | TEST_F(MetricsCollectorTest, SendZramMetrics) { |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 137 | EXPECT_TRUE(daemon_.testing_); |
| 138 | |
| 139 | // |compr_data_size| is the size in bytes of compressed data. |
Ben Chan | f05ab40 | 2014-08-07 00:54:59 -0700 | [diff] [blame] | 140 | const uint64_t compr_data_size = 50 * 1000 * 1000; |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 141 | // The constant '3' is a realistic but random choice. |
| 142 | // |orig_data_size| does not include zero pages. |
Ben Chan | f05ab40 | 2014-08-07 00:54:59 -0700 | [diff] [blame] | 143 | const uint64_t orig_data_size = compr_data_size * 3; |
| 144 | const uint64_t page_size = 4096; |
| 145 | const uint64_t zero_pages = 10 * 1000 * 1000 / page_size; |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 146 | |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 147 | CreateUint64ValueFile( |
Bertrand SIMONNET | 608e428 | 2015-11-12 17:52:17 -0800 | [diff] [blame] | 148 | temp_dir_.path().Append(MetricsCollector::kComprDataSizeName), |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 149 | compr_data_size); |
| 150 | CreateUint64ValueFile( |
Bertrand SIMONNET | 608e428 | 2015-11-12 17:52:17 -0800 | [diff] [blame] | 151 | temp_dir_.path().Append(MetricsCollector::kOrigDataSizeName), |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 152 | orig_data_size); |
| 153 | CreateUint64ValueFile( |
Bertrand SIMONNET | 608e428 | 2015-11-12 17:52:17 -0800 | [diff] [blame] | 154 | temp_dir_.path().Append(MetricsCollector::kZeroPagesName), zero_pages); |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 155 | |
Ben Chan | f05ab40 | 2014-08-07 00:54:59 -0700 | [diff] [blame] | 156 | const uint64_t real_orig_size = orig_data_size + zero_pages * page_size; |
| 157 | const uint64_t zero_ratio_percent = |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 158 | zero_pages * page_size * 100 / real_orig_size; |
| 159 | // Ratio samples are in percents. |
Ben Chan | f05ab40 | 2014-08-07 00:54:59 -0700 | [diff] [blame] | 160 | const uint64_t actual_ratio_sample = real_orig_size * 100 / compr_data_size; |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 161 | |
| 162 | EXPECT_CALL(metrics_lib_, SendToUMA(_, compr_data_size >> 20, _, _, _)); |
| 163 | EXPECT_CALL(metrics_lib_, |
| 164 | SendToUMA(_, (real_orig_size - compr_data_size) >> 20, _, _, _)); |
| 165 | EXPECT_CALL(metrics_lib_, SendToUMA(_, actual_ratio_sample, _, _, _)); |
| 166 | EXPECT_CALL(metrics_lib_, SendToUMA(_, zero_pages, _, _, _)); |
| 167 | EXPECT_CALL(metrics_lib_, SendToUMA(_, zero_ratio_percent, _, _, _)); |
| 168 | |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 169 | EXPECT_TRUE(daemon_.ReportZram(temp_dir_.path())); |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 170 | } |