forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
wifi_polling_policy_unittest.cc
145 lines (119 loc) · 5.48 KB
/
wifi_polling_policy_unittest.cc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
// Copyright 2018 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 "device/geolocation/wifi_polling_policy.h"
#include <memory>
#include "testing/gtest/include/gtest/gtest.h"
namespace device {
namespace {
const int kDefaultIntervalMillis = 200;
const int kNoChangeIntervalMillis = 300;
const int kTwoNoChangeIntervalMillis = 400;
const int kNoWifiIntervalMillis = 100;
} // namespace
// Main test fixture
class GeolocationWifiPollingPolicyTest : public testing::Test {
public:
void SetUp() override {
WifiPollingPolicy::Initialize(
std::make_unique<GenericWifiPollingPolicy<
kDefaultIntervalMillis, kNoChangeIntervalMillis,
kTwoNoChangeIntervalMillis, kNoWifiIntervalMillis>>());
polling_policy_ = WifiPollingPolicy::Get();
}
void TearDown() override {
polling_policy_ = nullptr;
WifiPollingPolicy::Shutdown();
}
protected:
WifiPollingPolicy* polling_policy_ = nullptr;
};
TEST_F(GeolocationWifiPollingPolicyTest, CreateDestroy) {
// Test fixture members were SetUp correctly.
EXPECT_TRUE(polling_policy_);
}
// Tests that the InitialInterval is zero when the policy is first created.
TEST_F(GeolocationWifiPollingPolicyTest, InitialIntervalZero) {
// The first call should return zero, indicating we may scan immediately.
// Internally, the policy starts a new interval at the current time.
EXPECT_EQ(0, polling_policy_->InitialInterval());
// The second call should return the non-zero remainder of the interval
// created by the first call.
int interval = polling_policy_->InitialInterval();
EXPECT_GT(interval, 0);
EXPECT_LE(interval, kDefaultIntervalMillis);
}
// Tests that the PollingInterval is equal to the default polling interval when
// the policy is first created.
TEST_F(GeolocationWifiPollingPolicyTest, PollingIntervalNonZero) {
// PollingInterval assumes it is only called immediately following a wifi
// scan. The first call should start a new interval at the current time and
// return the full duration of the new interval.
EXPECT_EQ(kDefaultIntervalMillis, polling_policy_->PollingInterval());
// The second call should return the non-zero remainder of the interval
// created by the first call.
int interval = polling_policy_->PollingInterval();
EXPECT_GT(interval, 0);
EXPECT_LE(interval, kDefaultIntervalMillis);
}
// Tests that the NoWifiInterval is equal to the default no-wifi interval when
// the policy is first created.
TEST_F(GeolocationWifiPollingPolicyTest, NoWifiIntervalNonZero) {
// NoWifiInterval assumes it is only called immediately following a failed
// attempt at a wifi scan. The first call should start a new interval at the
// current time and return the full duration of the new interval.
EXPECT_EQ(kNoWifiIntervalMillis, polling_policy_->NoWifiInterval());
// The second call should return the non-zero remainder of the interval
// created by the first call.
int interval = polling_policy_->NoWifiInterval();
EXPECT_GT(interval, 0);
EXPECT_LE(interval, kNoWifiIntervalMillis);
}
// Calls UpdatePollingInterval once with unchanged scan results. Verifies that
// the no-change interval is used.
TEST_F(GeolocationWifiPollingPolicyTest, UpdatePollingIntervalOnce) {
polling_policy_->UpdatePollingInterval(false);
EXPECT_EQ(kNoChangeIntervalMillis, polling_policy_->PollingInterval());
}
// Calls UpdatePollingInterval twice with unchanged scan results. Verifies that
// the two-no-change interval is used.
TEST_F(GeolocationWifiPollingPolicyTest, UpdatePollingIntervalTwice) {
polling_policy_->UpdatePollingInterval(false);
polling_policy_->UpdatePollingInterval(false);
EXPECT_EQ(kTwoNoChangeIntervalMillis, polling_policy_->PollingInterval());
}
// Calls UpdatePollingInterval three times with unchanged scan results. This
// should have the same effect as calling it twice.
TEST_F(GeolocationWifiPollingPolicyTest, UpdatePollingIntervalThrice) {
polling_policy_->UpdatePollingInterval(false);
polling_policy_->UpdatePollingInterval(false);
polling_policy_->UpdatePollingInterval(false);
EXPECT_EQ(kTwoNoChangeIntervalMillis, polling_policy_->PollingInterval());
}
// Calls UpdatePollingInterval twice with unchanged scan results and then once
// with differing results. Verifies that the default interval is used.
TEST_F(GeolocationWifiPollingPolicyTest, UpdatePollingIntervalResultsDiffer) {
polling_policy_->UpdatePollingInterval(false);
polling_policy_->UpdatePollingInterval(false);
polling_policy_->UpdatePollingInterval(true);
EXPECT_EQ(kDefaultIntervalMillis, polling_policy_->PollingInterval());
}
TEST_F(GeolocationWifiPollingPolicyTest, ShorterInterval) {
// Ask for a polling interval.
EXPECT_EQ(kDefaultIntervalMillis, polling_policy_->PollingInterval());
// Now ask for a no-wifi interval, which is shorter. The returned interval
// must be no longer than the shorter of the two intervals.
int interval = polling_policy_->NoWifiInterval();
EXPECT_GT(interval, 0);
EXPECT_LE(interval, kNoWifiIntervalMillis);
}
TEST_F(GeolocationWifiPollingPolicyTest, LongerInterval) {
// Ask for a no-wifi interval.
EXPECT_EQ(kNoWifiIntervalMillis, polling_policy_->NoWifiInterval());
// Now ask for a polling interval, which is longer. The returned interval
// must be no longer than the shorter of the two intervals.
int interval = polling_policy_->PollingInterval();
EXPECT_GT(interval, 0);
EXPECT_LE(interval, kNoWifiIntervalMillis);
}
} // namespace device