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 // 16 17 #include "update_engine/metrics_utils.h" 18 19 #include <gtest/gtest.h> 20 21 #include "update_engine/common/fake_clock.h" 22 #include "update_engine/common/fake_prefs.h" 23 #include "update_engine/fake_system_state.h" 24 25 namespace chromeos_update_engine { 26 namespace metrics_utils { 27 28 class MetricsUtilsTest : public ::testing::Test {}; 29 30 TEST(MetricsUtilsTest, GetConnectionType) { 31 // Check that expected combinations map to the right value. 32 EXPECT_EQ(metrics::ConnectionType::kUnknown, 33 GetConnectionType(ConnectionType::kUnknown, 34 ConnectionTethering::kUnknown)); 35 EXPECT_EQ(metrics::ConnectionType::kEthernet, 36 GetConnectionType(ConnectionType::kEthernet, 37 ConnectionTethering::kUnknown)); 38 EXPECT_EQ(metrics::ConnectionType::kWifi, 39 GetConnectionType(ConnectionType::kWifi, 40 ConnectionTethering::kUnknown)); 41 EXPECT_EQ(metrics::ConnectionType::kWimax, 42 GetConnectionType(ConnectionType::kWimax, 43 ConnectionTethering::kUnknown)); 44 EXPECT_EQ(metrics::ConnectionType::kBluetooth, 45 GetConnectionType(ConnectionType::kBluetooth, 46 ConnectionTethering::kUnknown)); 47 EXPECT_EQ(metrics::ConnectionType::kCellular, 48 GetConnectionType(ConnectionType::kCellular, 49 ConnectionTethering::kUnknown)); 50 EXPECT_EQ(metrics::ConnectionType::kTetheredEthernet, 51 GetConnectionType(ConnectionType::kEthernet, 52 ConnectionTethering::kConfirmed)); 53 EXPECT_EQ(metrics::ConnectionType::kTetheredWifi, 54 GetConnectionType(ConnectionType::kWifi, 55 ConnectionTethering::kConfirmed)); 56 57 // Ensure that we don't report tethered ethernet unless it's confirmed. 58 EXPECT_EQ(metrics::ConnectionType::kEthernet, 59 GetConnectionType(ConnectionType::kEthernet, 60 ConnectionTethering::kNotDetected)); 61 EXPECT_EQ(metrics::ConnectionType::kEthernet, 62 GetConnectionType(ConnectionType::kEthernet, 63 ConnectionTethering::kSuspected)); 64 EXPECT_EQ(metrics::ConnectionType::kEthernet, 65 GetConnectionType(ConnectionType::kEthernet, 66 ConnectionTethering::kUnknown)); 67 68 // Ditto for tethered wifi. 69 EXPECT_EQ(metrics::ConnectionType::kWifi, 70 GetConnectionType(ConnectionType::kWifi, 71 ConnectionTethering::kNotDetected)); 72 EXPECT_EQ(metrics::ConnectionType::kWifi, 73 GetConnectionType(ConnectionType::kWifi, 74 ConnectionTethering::kSuspected)); 75 EXPECT_EQ(metrics::ConnectionType::kWifi, 76 GetConnectionType(ConnectionType::kWifi, 77 ConnectionTethering::kUnknown)); 78 } 79 80 TEST(MetricsUtilsTest, WallclockDurationHelper) { 81 FakeSystemState fake_system_state; 82 FakeClock fake_clock; 83 base::TimeDelta duration; 84 const std::string state_variable_key = "test-prefs"; 85 FakePrefs fake_prefs; 86 87 fake_system_state.set_clock(&fake_clock); 88 fake_system_state.set_prefs(&fake_prefs); 89 90 // Initialize wallclock to 1 sec. 91 fake_clock.SetWallclockTime(base::Time::FromInternalValue(1000000)); 92 93 // First time called so no previous measurement available. 94 EXPECT_FALSE(metrics_utils::WallclockDurationHelper(&fake_system_state, 95 state_variable_key, 96 &duration)); 97 98 // Next time, we should get zero since the clock didn't advance. 99 EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, 100 state_variable_key, 101 &duration)); 102 EXPECT_EQ(duration.InSeconds(), 0); 103 104 // We can also call it as many times as we want with it being 105 // considered a failure. 106 EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, 107 state_variable_key, 108 &duration)); 109 EXPECT_EQ(duration.InSeconds(), 0); 110 EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, 111 state_variable_key, 112 &duration)); 113 EXPECT_EQ(duration.InSeconds(), 0); 114 115 // Advance the clock one second, then we should get 1 sec on the 116 // next call and 0 sec on the subsequent call. 117 fake_clock.SetWallclockTime(base::Time::FromInternalValue(2000000)); 118 EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, 119 state_variable_key, 120 &duration)); 121 EXPECT_EQ(duration.InSeconds(), 1); 122 EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, 123 state_variable_key, 124 &duration)); 125 EXPECT_EQ(duration.InSeconds(), 0); 126 127 // Advance clock two seconds and we should get 2 sec and then 0 sec. 128 fake_clock.SetWallclockTime(base::Time::FromInternalValue(4000000)); 129 EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, 130 state_variable_key, 131 &duration)); 132 EXPECT_EQ(duration.InSeconds(), 2); 133 EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, 134 state_variable_key, 135 &duration)); 136 EXPECT_EQ(duration.InSeconds(), 0); 137 138 // There's a possibility that the wallclock can go backwards (NTP 139 // adjustments, for example) so check that we properly handle this 140 // case. 141 fake_clock.SetWallclockTime(base::Time::FromInternalValue(3000000)); 142 EXPECT_FALSE(metrics_utils::WallclockDurationHelper(&fake_system_state, 143 state_variable_key, 144 &duration)); 145 fake_clock.SetWallclockTime(base::Time::FromInternalValue(4000000)); 146 EXPECT_TRUE(metrics_utils::WallclockDurationHelper(&fake_system_state, 147 state_variable_key, 148 &duration)); 149 EXPECT_EQ(duration.InSeconds(), 1); 150 } 151 152 TEST(MetricsUtilsTest, MonotonicDurationHelper) { 153 int64_t storage = 0; 154 FakeSystemState fake_system_state; 155 FakeClock fake_clock; 156 base::TimeDelta duration; 157 158 fake_system_state.set_clock(&fake_clock); 159 160 // Initialize monotonic clock to 1 sec. 161 fake_clock.SetMonotonicTime(base::Time::FromInternalValue(1000000)); 162 163 // First time called so no previous measurement available. 164 EXPECT_FALSE(metrics_utils::MonotonicDurationHelper(&fake_system_state, 165 &storage, 166 &duration)); 167 168 // Next time, we should get zero since the clock didn't advance. 169 EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, 170 &storage, 171 &duration)); 172 EXPECT_EQ(duration.InSeconds(), 0); 173 174 // We can also call it as many times as we want with it being 175 // considered a failure. 176 EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, 177 &storage, 178 &duration)); 179 EXPECT_EQ(duration.InSeconds(), 0); 180 EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, 181 &storage, 182 &duration)); 183 EXPECT_EQ(duration.InSeconds(), 0); 184 185 // Advance the clock one second, then we should get 1 sec on the 186 // next call and 0 sec on the subsequent call. 187 fake_clock.SetMonotonicTime(base::Time::FromInternalValue(2000000)); 188 EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, 189 &storage, 190 &duration)); 191 EXPECT_EQ(duration.InSeconds(), 1); 192 EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, 193 &storage, 194 &duration)); 195 EXPECT_EQ(duration.InSeconds(), 0); 196 197 // Advance clock two seconds and we should get 2 sec and then 0 sec. 198 fake_clock.SetMonotonicTime(base::Time::FromInternalValue(4000000)); 199 EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, 200 &storage, 201 &duration)); 202 EXPECT_EQ(duration.InSeconds(), 2); 203 EXPECT_TRUE(metrics_utils::MonotonicDurationHelper(&fake_system_state, 204 &storage, 205 &duration)); 206 EXPECT_EQ(duration.InSeconds(), 0); 207 } 208 209 } // namespace metrics_utils 210 } // namespace chromeos_update_engine 211
