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 | 4b915ae | 2015-07-28 15:38:14 -0700 | [diff] [blame] | 27 | #include "metrics_daemon.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 | |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 43 | class MetricsDaemonTest : public testing::Test { |
| 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()); |
| 48 | scaling_max_freq_path_ = temp_dir_.path().Append("scaling_max"); |
| 49 | cpu_max_freq_path_ = temp_dir_.path().Append("cpu_freq_max"); |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 50 | |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 51 | CreateUint64ValueFile(cpu_max_freq_path_, 10000000); |
| 52 | CreateUint64ValueFile(scaling_max_freq_path_, 10000000); |
| 53 | |
| 54 | chromeos_metrics::PersistentInteger::SetMetricsDirectory( |
| 55 | temp_dir_.path().value()); |
Bertrand SIMONNET | 46b49da | 2014-06-25 14:38:07 -0700 | [diff] [blame] | 56 | daemon_.Init(true, |
| 57 | false, |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 58 | true, |
Bertrand SIMONNET | 46b49da | 2014-06-25 14:38:07 -0700 | [diff] [blame] | 59 | &metrics_lib_, |
Bertrand SIMONNET | 7a96405 | 2015-09-29 11:07:24 -0700 | [diff] [blame] | 60 | "", |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 61 | scaling_max_freq_path_.value(), |
| 62 | cpu_max_freq_path_.value(), |
Bertrand SIMONNET | cac74e1 | 2014-10-09 10:14:13 -0700 | [diff] [blame] | 63 | base::TimeDelta::FromMinutes(30), |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 64 | metrics::kMetricsServer, |
Bertrand SIMONNET | 2765d0a | 2015-09-09 10:38:20 -0700 | [diff] [blame] | 65 | temp_dir_.path()); |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 66 | } |
| 67 | |
Darin Petkov | fc91b42 | 2010-05-12 13:05:45 -0700 | [diff] [blame] | 68 | // Adds a metrics library mock expectation that the specified metric |
| 69 | // will be generated. |
Daniel Erat | c83975a | 2014-04-04 08:53:44 -0700 | [diff] [blame] | 70 | void ExpectSample(const std::string& name, int sample) { |
| 71 | EXPECT_CALL(metrics_lib_, SendToUMA(name, sample, _, _, _)) |
Darin Petkov | fc91b42 | 2010-05-12 13:05:45 -0700 | [diff] [blame] | 72 | .Times(1) |
| 73 | .WillOnce(Return(true)) |
| 74 | .RetiresOnSaturation(); |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 75 | } |
| 76 | |
Daniel Erat | b9b05e6 | 2010-11-09 12:18:51 -0800 | [diff] [blame] | 77 | // Creates a new DBus signal message with zero or more string arguments. |
| 78 | // The message can be deallocated through DeleteDBusMessage. |
Darin Petkov | e579d66 | 2010-05-05 16:19:39 -0700 | [diff] [blame] | 79 | // |
| 80 | // |path| is the object emitting the signal. |
| 81 | // |interface| is the interface the signal is emitted from. |
| 82 | // |name| is the name of the signal. |
Daniel Erat | b9b05e6 | 2010-11-09 12:18:51 -0800 | [diff] [blame] | 83 | // |arg_values| contains the values of the string arguments. |
| 84 | DBusMessage* NewDBusSignalString(const string& path, |
| 85 | const string& interface, |
| 86 | const string& name, |
| 87 | const vector<string>& arg_values) { |
Darin Petkov | e579d66 | 2010-05-05 16:19:39 -0700 | [diff] [blame] | 88 | DBusMessage* msg = dbus_message_new_signal(path.c_str(), |
| 89 | interface.c_str(), |
| 90 | name.c_str()); |
| 91 | DBusMessageIter iter; |
| 92 | dbus_message_iter_init_append(msg, &iter); |
Daniel Erat | b9b05e6 | 2010-11-09 12:18:51 -0800 | [diff] [blame] | 93 | for (vector<string>::const_iterator it = arg_values.begin(); |
| 94 | it != arg_values.end(); ++it) { |
| 95 | const char* str_value = it->c_str(); |
| 96 | dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &str_value); |
| 97 | } |
Darin Petkov | e579d66 | 2010-05-05 16:19:39 -0700 | [diff] [blame] | 98 | return msg; |
| 99 | } |
| 100 | |
| 101 | // Deallocates the DBus message |msg| previously allocated through |
| 102 | // dbus_message_new*. |
| 103 | void DeleteDBusMessage(DBusMessage* msg) { |
| 104 | dbus_message_unref(msg); |
| 105 | } |
| 106 | |
Luigi Semenzato | c88e42d | 2011-02-17 10:21:16 -0800 | [diff] [blame] | 107 | |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 108 | // Creates or overwrites the file in |path| so that it contains the printable |
| 109 | // representation of |value|. |
Ben Chan | f05ab40 | 2014-08-07 00:54:59 -0700 | [diff] [blame] | 110 | void CreateUint64ValueFile(const base::FilePath& path, uint64_t value) { |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 111 | std::string value_string = base::Uint64ToString(value); |
| 112 | ASSERT_EQ(value_string.length(), |
| 113 | base::WriteFile(path, value_string.c_str(), |
| 114 | value_string.length())); |
Luigi Semenzato | fb3a821 | 2013-05-07 16:55:00 -0700 | [diff] [blame] | 115 | } |
| 116 | |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 117 | // The MetricsDaemon under test. |
| 118 | MetricsDaemon daemon_; |
| 119 | |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 120 | // Temporary directory used for tests. |
| 121 | base::ScopedTempDir temp_dir_; |
| 122 | |
| 123 | // Path for the fake files. |
| 124 | base::FilePath scaling_max_freq_path_; |
| 125 | base::FilePath cpu_max_freq_path_; |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 126 | |
Luigi Semenzato | 2fd51cc | 2014-02-26 11:53:16 -0800 | [diff] [blame] | 127 | // Mocks. They are strict mock so that all unexpected |
| 128 | // calls are marked as failures. |
Darin Petkov | fc91b42 | 2010-05-12 13:05:45 -0700 | [diff] [blame] | 129 | StrictMock<MetricsLibraryMock> metrics_lib_; |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 130 | }; |
| 131 | |
Darin Petkov | e579d66 | 2010-05-05 16:19:39 -0700 | [diff] [blame] | 132 | TEST_F(MetricsDaemonTest, MessageFilter) { |
Luigi Semenzato | 2fd51cc | 2014-02-26 11:53:16 -0800 | [diff] [blame] | 133 | // Ignore calls to SendToUMA. |
Steve Fung | e86591e | 2014-12-01 13:38:21 -0800 | [diff] [blame] | 134 | EXPECT_CALL(metrics_lib_, SendToUMA(_, _, _, _, _)).Times(AnyNumber()); |
Luigi Semenzato | 2fd51cc | 2014-02-26 11:53:16 -0800 | [diff] [blame] | 135 | |
Darin Petkov | e579d66 | 2010-05-05 16:19:39 -0700 | [diff] [blame] | 136 | DBusMessage* msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL); |
| 137 | DBusHandlerResult res = |
Alex Vakulenko | 1459503 | 2014-08-28 14:59:56 -0700 | [diff] [blame] | 138 | MetricsDaemon::MessageFilter(/* connection */ nullptr, msg, &daemon_); |
Darin Petkov | e579d66 | 2010-05-05 16:19:39 -0700 | [diff] [blame] | 139 | EXPECT_EQ(DBUS_HANDLER_RESULT_NOT_YET_HANDLED, res); |
| 140 | DeleteDBusMessage(msg); |
| 141 | |
Daniel Erat | b9b05e6 | 2010-11-09 12:18:51 -0800 | [diff] [blame] | 142 | vector<string> signal_args; |
Darin Petkov | 1bb904e | 2010-06-16 15:58:06 -0700 | [diff] [blame] | 143 | msg = NewDBusSignalString("/", |
| 144 | "org.chromium.CrashReporter", |
| 145 | "UserCrash", |
Daniel Erat | b9b05e6 | 2010-11-09 12:18:51 -0800 | [diff] [blame] | 146 | signal_args); |
Alex Vakulenko | 1459503 | 2014-08-28 14:59:56 -0700 | [diff] [blame] | 147 | res = MetricsDaemon::MessageFilter(/* connection */ nullptr, msg, &daemon_); |
Darin Petkov | 1bb904e | 2010-06-16 15:58:06 -0700 | [diff] [blame] | 148 | EXPECT_EQ(DBUS_HANDLER_RESULT_HANDLED, res); |
| 149 | DeleteDBusMessage(msg); |
| 150 | |
Daniel Erat | b9b05e6 | 2010-11-09 12:18:51 -0800 | [diff] [blame] | 151 | signal_args.clear(); |
Daniel Erat | b9b05e6 | 2010-11-09 12:18:51 -0800 | [diff] [blame] | 152 | signal_args.push_back("randomstate"); |
| 153 | signal_args.push_back("bob"); // arbitrary username |
Darin Petkov | e579d66 | 2010-05-05 16:19:39 -0700 | [diff] [blame] | 154 | msg = NewDBusSignalString("/", |
| 155 | "org.chromium.UnknownService.Manager", |
| 156 | "StateChanged", |
Daniel Erat | b9b05e6 | 2010-11-09 12:18:51 -0800 | [diff] [blame] | 157 | signal_args); |
Alex Vakulenko | 1459503 | 2014-08-28 14:59:56 -0700 | [diff] [blame] | 158 | res = MetricsDaemon::MessageFilter(/* connection */ nullptr, msg, &daemon_); |
Darin Petkov | e579d66 | 2010-05-05 16:19:39 -0700 | [diff] [blame] | 159 | EXPECT_EQ(DBUS_HANDLER_RESULT_NOT_YET_HANDLED, res); |
| 160 | DeleteDBusMessage(msg); |
| 161 | } |
| 162 | |
Luigi Semenzato | 2fd51cc | 2014-02-26 11:53:16 -0800 | [diff] [blame] | 163 | TEST_F(MetricsDaemonTest, SendSample) { |
Daniel Erat | c83975a | 2014-04-04 08:53:44 -0700 | [diff] [blame] | 164 | ExpectSample("Dummy.Metric", 3); |
Luigi Semenzato | 2fd51cc | 2014-02-26 11:53:16 -0800 | [diff] [blame] | 165 | daemon_.SendSample("Dummy.Metric", /* sample */ 3, |
Darin Petkov | 11b8eb3 | 2010-05-18 11:00:59 -0700 | [diff] [blame] | 166 | /* min */ 1, /* max */ 100, /* buckets */ 50); |
| 167 | } |
| 168 | |
Luigi Semenzato | 29c7ef9 | 2011-04-12 14:12:35 -0700 | [diff] [blame] | 169 | TEST_F(MetricsDaemonTest, ProcessMeminfo) { |
Bertrand SIMONNET | e6cfd64 | 2014-07-09 16:35:23 -0700 | [diff] [blame] | 170 | string meminfo = |
| 171 | "MemTotal: 2000000 kB\nMemFree: 500000 kB\n" |
| 172 | "Buffers: 1000000 kB\nCached: 213652 kB\n" |
| 173 | "SwapCached: 0 kB\nActive: 133400 kB\n" |
| 174 | "Inactive: 183396 kB\nActive(anon): 92984 kB\n" |
| 175 | "Inactive(anon): 58860 kB\nActive(file): 40416 kB\n" |
| 176 | "Inactive(file): 124536 kB\nUnevictable: 0 kB\n" |
| 177 | "Mlocked: 0 kB\nSwapTotal: 0 kB\n" |
| 178 | "SwapFree: 0 kB\nDirty: 40 kB\n" |
| 179 | "Writeback: 0 kB\nAnonPages: 92652 kB\n" |
| 180 | "Mapped: 59716 kB\nShmem: 59196 kB\n" |
| 181 | "Slab: 16656 kB\nSReclaimable: 6132 kB\n" |
| 182 | "SUnreclaim: 10524 kB\nKernelStack: 1648 kB\n" |
| 183 | "PageTables: 2780 kB\nNFS_Unstable: 0 kB\n" |
| 184 | "Bounce: 0 kB\nWritebackTmp: 0 kB\n" |
| 185 | "CommitLimit: 970656 kB\nCommitted_AS: 1260528 kB\n" |
| 186 | "VmallocTotal: 122880 kB\nVmallocUsed: 12144 kB\n" |
| 187 | "VmallocChunk: 103824 kB\nDirectMap4k: 9636 kB\n" |
| 188 | "DirectMap2M: 1955840 kB\n"; |
| 189 | |
Luigi Semenzato | 8accd33 | 2011-05-17 16:37:18 -0700 | [diff] [blame] | 190 | // All enum calls must report percents. |
Bertrand SIMONNET | e6cfd64 | 2014-07-09 16:35:23 -0700 | [diff] [blame] | 191 | EXPECT_CALL(metrics_lib_, SendEnumToUMA(_, _, 100)).Times(AtLeast(1)); |
Luigi Semenzato | 8accd33 | 2011-05-17 16:37:18 -0700 | [diff] [blame] | 192 | // Check that MemFree is correctly computed at 25%. |
| 193 | EXPECT_CALL(metrics_lib_, SendEnumToUMA("Platform.MeminfoMemFree", 25, 100)) |
| 194 | .Times(AtLeast(1)); |
| 195 | // Check that we call SendToUma at least once (log histogram). |
Luigi Semenzato | 29c7ef9 | 2011-04-12 14:12:35 -0700 | [diff] [blame] | 196 | EXPECT_CALL(metrics_lib_, SendToUMA(_, _, _, _, _)) |
| 197 | .Times(AtLeast(1)); |
Luigi Semenzato | 8accd33 | 2011-05-17 16:37:18 -0700 | [diff] [blame] | 198 | // Make sure we don't report fields not in the list. |
| 199 | EXPECT_CALL(metrics_lib_, SendToUMA("Platform.MeminfoMlocked", _, _, _, _)) |
Luigi Semenzato | 29c7ef9 | 2011-04-12 14:12:35 -0700 | [diff] [blame] | 200 | .Times(0); |
Luigi Semenzato | 8accd33 | 2011-05-17 16:37:18 -0700 | [diff] [blame] | 201 | EXPECT_CALL(metrics_lib_, SendEnumToUMA("Platform.MeminfoMlocked", _, _)) |
Luigi Semenzato | 29c7ef9 | 2011-04-12 14:12:35 -0700 | [diff] [blame] | 202 | .Times(0); |
| 203 | EXPECT_TRUE(daemon_.ProcessMeminfo(meminfo)); |
| 204 | } |
| 205 | |
| 206 | TEST_F(MetricsDaemonTest, ProcessMeminfo2) { |
Bertrand SIMONNET | e6cfd64 | 2014-07-09 16:35:23 -0700 | [diff] [blame] | 207 | string meminfo = "MemTotal: 2000000 kB\nMemFree: 1000000 kB\n"; |
Luigi Semenzato | fb3a821 | 2013-05-07 16:55:00 -0700 | [diff] [blame] | 208 | // Not enough fields. |
Luigi Semenzato | 29c7ef9 | 2011-04-12 14:12:35 -0700 | [diff] [blame] | 209 | EXPECT_FALSE(daemon_.ProcessMeminfo(meminfo)); |
| 210 | } |
| 211 | |
Luigi Semenzato | fb3a821 | 2013-05-07 16:55:00 -0700 | [diff] [blame] | 212 | TEST_F(MetricsDaemonTest, ReadFreqToInt) { |
| 213 | const int fake_scaled_freq = 1666999; |
| 214 | const int fake_max_freq = 2000000; |
| 215 | int scaled_freq = 0; |
| 216 | int max_freq = 0; |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 217 | CreateUint64ValueFile(scaling_max_freq_path_, fake_scaled_freq); |
| 218 | CreateUint64ValueFile(cpu_max_freq_path_, fake_max_freq); |
Luigi Semenzato | fb3a821 | 2013-05-07 16:55:00 -0700 | [diff] [blame] | 219 | EXPECT_TRUE(daemon_.testing_); |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 220 | EXPECT_TRUE(daemon_.ReadFreqToInt(scaling_max_freq_path_.value(), |
| 221 | &scaled_freq)); |
| 222 | EXPECT_TRUE(daemon_.ReadFreqToInt(cpu_max_freq_path_.value(), &max_freq)); |
Luigi Semenzato | fb3a821 | 2013-05-07 16:55:00 -0700 | [diff] [blame] | 223 | EXPECT_EQ(fake_scaled_freq, scaled_freq); |
| 224 | EXPECT_EQ(fake_max_freq, max_freq); |
| 225 | } |
| 226 | |
| 227 | TEST_F(MetricsDaemonTest, SendCpuThrottleMetrics) { |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 228 | CreateUint64ValueFile(cpu_max_freq_path_, 2001000); |
Luigi Semenzato | fb3a821 | 2013-05-07 16:55:00 -0700 | [diff] [blame] | 229 | // Test the 101% and 100% cases. |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 230 | CreateUint64ValueFile(scaling_max_freq_path_, 2001000); |
Luigi Semenzato | fb3a821 | 2013-05-07 16:55:00 -0700 | [diff] [blame] | 231 | EXPECT_TRUE(daemon_.testing_); |
| 232 | EXPECT_CALL(metrics_lib_, SendEnumToUMA(_, 101, 101)); |
| 233 | daemon_.SendCpuThrottleMetrics(); |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 234 | CreateUint64ValueFile(scaling_max_freq_path_, 2000000); |
Luigi Semenzato | fb3a821 | 2013-05-07 16:55:00 -0700 | [diff] [blame] | 235 | EXPECT_CALL(metrics_lib_, SendEnumToUMA(_, 100, 101)); |
| 236 | daemon_.SendCpuThrottleMetrics(); |
| 237 | } |
| 238 | |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 239 | TEST_F(MetricsDaemonTest, SendZramMetrics) { |
| 240 | EXPECT_TRUE(daemon_.testing_); |
| 241 | |
| 242 | // |compr_data_size| is the size in bytes of compressed data. |
Ben Chan | f05ab40 | 2014-08-07 00:54:59 -0700 | [diff] [blame] | 243 | const uint64_t compr_data_size = 50 * 1000 * 1000; |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 244 | // The constant '3' is a realistic but random choice. |
| 245 | // |orig_data_size| does not include zero pages. |
Ben Chan | f05ab40 | 2014-08-07 00:54:59 -0700 | [diff] [blame] | 246 | const uint64_t orig_data_size = compr_data_size * 3; |
| 247 | const uint64_t page_size = 4096; |
| 248 | const uint64_t zero_pages = 10 * 1000 * 1000 / page_size; |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 249 | |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 250 | CreateUint64ValueFile( |
| 251 | temp_dir_.path().Append(MetricsDaemon::kComprDataSizeName), |
| 252 | compr_data_size); |
| 253 | CreateUint64ValueFile( |
| 254 | temp_dir_.path().Append(MetricsDaemon::kOrigDataSizeName), |
| 255 | orig_data_size); |
| 256 | CreateUint64ValueFile( |
| 257 | temp_dir_.path().Append(MetricsDaemon::kZeroPagesName), zero_pages); |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 258 | |
Ben Chan | f05ab40 | 2014-08-07 00:54:59 -0700 | [diff] [blame] | 259 | const uint64_t real_orig_size = orig_data_size + zero_pages * page_size; |
| 260 | const uint64_t zero_ratio_percent = |
Luigi Semenzato | 9636019 | 2014-06-04 10:53:35 -0700 | [diff] [blame] | 261 | zero_pages * page_size * 100 / real_orig_size; |
| 262 | // Ratio samples are in percents. |
Ben Chan | f05ab40 | 2014-08-07 00:54:59 -0700 | [diff] [blame] | 263 | 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] | 264 | |
| 265 | EXPECT_CALL(metrics_lib_, SendToUMA(_, compr_data_size >> 20, _, _, _)); |
| 266 | EXPECT_CALL(metrics_lib_, |
| 267 | SendToUMA(_, (real_orig_size - compr_data_size) >> 20, _, _, _)); |
| 268 | EXPECT_CALL(metrics_lib_, SendToUMA(_, actual_ratio_sample, _, _, _)); |
| 269 | EXPECT_CALL(metrics_lib_, SendToUMA(_, zero_pages, _, _, _)); |
| 270 | EXPECT_CALL(metrics_lib_, SendToUMA(_, zero_ratio_percent, _, _, _)); |
| 271 | |
Bertrand SIMONNET | 1253186 | 2015-08-31 11:11:57 -0700 | [diff] [blame] | 272 | EXPECT_TRUE(daemon_.ReportZram(temp_dir_.path())); |
Darin Petkov | 2ccef01 | 2010-05-05 16:06:37 -0700 | [diff] [blame] | 273 | } |