1 /*
2  * Copyright (C) 2017 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 <android-base/file.h>
18 #include <android-base/stringprintf.h>
19 #include <gtest/gtest.h>
20 
21 #include <algorithm>
22 #include <thread>
23 
24 #include "perfmgr/FileNode.h"
25 
26 namespace android {
27 namespace perfmgr {
28 
29 using std::literals::chrono_literals::operator""ms;
30 
31 constexpr double kTIMING_TOLERANCE_MS = std::chrono::milliseconds(25).count();
32 constexpr auto kSLEEP_TOLERANCE_MS = 2ms;
33 
_VerifyPathValue(const std::string & path,const std::string & value)34 static inline void _VerifyPathValue(const std::string& path,
35                                     const std::string& value) {
36     std::string s;
37     EXPECT_TRUE(android::base::ReadFileToString(path, &s)) << strerror(errno);
38     EXPECT_EQ(value, s);
39 }
40 
41 // Test init with no default value
TEST(FileNodeTest,NoInitDefaultTest)42 TEST(FileNodeTest, NoInitDefaultTest) {
43     TemporaryFile tf;
44     FileNode t("t", tf.path, {{"value0"}, {"value1"}, {"value2"}}, 1, false, false);
45     t.Update(false);
46     _VerifyPathValue(tf.path, "");
47 }
48 
49 // Test init with default value
TEST(FileNodeTest,InitDefaultTest)50 TEST(FileNodeTest, InitDefaultTest) {
51     TemporaryFile tf;
52     FileNode t("t", tf.path, {{"value0"}, {"value1"}, {"value2"}}, 1, true, true);
53     t.Update(false);
54     _VerifyPathValue(tf.path, "value1");
55     TemporaryFile tf2;
56     FileNode t2("t2", tf2.path, {{"value0"}, {"value1"}, {"value2"}}, 0, true, true);
57     t2.Update(false);
58     _VerifyPathValue(tf2.path, "value0");
59 }
60 
61 // Test DumpToFd
TEST(FileNodeTest,DumpToFdTest)62 TEST(FileNodeTest, DumpToFdTest) {
63     TemporaryFile tf;
64     FileNode t("test_dump", tf.path, {{"value0"}, {"value1"}, {"value2"}}, 1,
65                true, true);
66     t.Update(false);
67     TemporaryFile dumptf;
68     t.DumpToFd(dumptf.fd);
69     fsync(dumptf.fd);
70     std::string buf(android::base::StringPrintf(
71             "Node Name\t"
72             "Node Path\t"
73             "Current Index\t"
74             "Current Value\t"
75             "Hold FD\t"
76             "Truncate\n"
77             "%s\t%s\t%zu\t%s\t%d\t%d\n",
78             "test_dump", tf.path, static_cast<size_t>(1), "value1", 0, 1));
79     _VerifyPathValue(dumptf.path, buf);
80 }
81 
82 // Test GetValueIndex
TEST(FileNodeTest,GetValueIndexTest)83 TEST(FileNodeTest, GetValueIndexTest) {
84     TemporaryFile tf;
85     FileNode t("t", tf.path, {{"value0"}, {"value1"}, {"value2"}}, 1, false, false);
86     std::size_t index = 0;
87     EXPECT_TRUE(t.GetValueIndex("value2", &index));
88     EXPECT_EQ(2u, index);
89     index = 1234;
90     EXPECT_FALSE(t.GetValueIndex("NON_EXIST", &index));
91     EXPECT_EQ(1234u, index);
92 }
93 
94 // Test GetValues
TEST(FileNodeTest,GetValuesTest)95 TEST(FileNodeTest, GetValuesTest) {
96     TemporaryFile tf;
97     FileNode t("t", tf.path, {{"value0"}, {"value1"}, {"value2"}}, 1, false, false);
98     std::vector values = t.GetValues();
99     EXPECT_EQ(3u, values.size());
100     EXPECT_EQ("value0", values[0]);
101     EXPECT_EQ("value1", values[1]);
102     EXPECT_EQ("value2", values[2]);
103 }
104 
105 // Test get more properties
TEST(FileNodeTest,GetPropertiesTest)106 TEST(FileNodeTest, GetPropertiesTest) {
107     std::string test_name = "TESTREQ_1";
108     std::string test_path = "TEST_PATH";
109     FileNode t(test_name, test_path, {}, 0, false, false, true);
110     EXPECT_EQ(test_name, t.GetName());
111     EXPECT_EQ(test_path, t.GetPath());
112     EXPECT_EQ(0u, t.GetValues().size());
113     EXPECT_EQ(0u, t.GetDefaultIndex());
114     EXPECT_FALSE(t.GetResetOnInit());
115     EXPECT_TRUE(t.GetHoldFd());
116 }
117 
118 // Test add request fail and retry
TEST(FileNodeTest,AddRequestTestFail)119 TEST(FileNodeTest, AddRequestTestFail) {
120     FileNode t("t", "/sys/android/nonexist_node_test",
121                {{"value0"}, {"value1"}, {"value2"}}, 2, true, true);
122     auto start = std::chrono::steady_clock::now();
123     EXPECT_TRUE(t.AddRequest(1, "INTERACTION", start + 200ms));
124     std::chrono::milliseconds expire_time = t.Update(true);
125     // Add request @ value1
126     EXPECT_NEAR(std::chrono::milliseconds(200).count(), expire_time.count(),
127                 kTIMING_TOLERANCE_MS);
128     // Add request @ value0 higher prio than value1
129     EXPECT_TRUE(t.AddRequest(0, "LAUNCH", start + 2000ms));
130     expire_time = t.Update(true);
131     // Retry in 500 ms
132     EXPECT_NEAR(std::chrono::milliseconds(500).count(), expire_time.count(),
133                 kTIMING_TOLERANCE_MS);
134 }
135 
136 // Test add request
TEST(FileNodeTest,AddRequestTest)137 TEST(FileNodeTest, AddRequestTest) {
138     TemporaryFile tf;
139     FileNode t("t", tf.path, {{"value0"}, {"value1"}, {"value2"}}, 2, true, true);
140     auto start = std::chrono::steady_clock::now();
141     EXPECT_TRUE(t.AddRequest(1, "INTERACTION", start + 500ms));
142     std::chrono::milliseconds expire_time = t.Update(true);
143     // Add request @ value1
144     _VerifyPathValue(tf.path, "value1");
145     EXPECT_NEAR(std::chrono::milliseconds(500).count(), expire_time.count(),
146                 kTIMING_TOLERANCE_MS);
147     // Add request @ value0 higher prio than value1
148     EXPECT_TRUE(t.AddRequest(0, "LAUNCH", start + 200ms));
149     expire_time = t.Update(true);
150     _VerifyPathValue(tf.path, "value0");
151     EXPECT_NEAR(std::chrono::milliseconds(200).count(), expire_time.count(),
152                 kTIMING_TOLERANCE_MS);
153     // Let high prio request timeout, now only request @ value1 active
154     std::this_thread::sleep_for(expire_time + kSLEEP_TOLERANCE_MS);
155     expire_time = t.Update(true);
156     _VerifyPathValue(tf.path, "value1");
157     EXPECT_NEAR(std::chrono::milliseconds(300).count(), expire_time.count(),
158                 kTIMING_TOLERANCE_MS);
159     // Let all requests timeout, now default value2
160     std::this_thread::sleep_for(expire_time + kSLEEP_TOLERANCE_MS);
161     expire_time = t.Update(true);
162     _VerifyPathValue(tf.path, "value2");
163     EXPECT_EQ(std::chrono::milliseconds::max(), expire_time);
164 }
165 
166 // Test remove request
TEST(FileNodeTest,RemoveRequestTest)167 TEST(FileNodeTest, RemoveRequestTest) {
168     TemporaryFile tf;
169     FileNode t("t", tf.path, {{"value0"}, {"value1"}, {"value2"}}, 2, true, true);
170     auto start = std::chrono::steady_clock::now();
171     EXPECT_TRUE(t.AddRequest(1, "INTERACTION", start + 500ms));
172     std::chrono::milliseconds expire_time = t.Update(true);
173     // Add request @ value1
174     _VerifyPathValue(tf.path, "value1");
175     EXPECT_NEAR(std::chrono::milliseconds(500).count(), expire_time.count(),
176                 kTIMING_TOLERANCE_MS);
177     // Add request @ value0 higher prio than value1
178     EXPECT_TRUE(t.AddRequest(0, "LAUNCH", start + 200ms));
179     expire_time = t.Update(true);
180     _VerifyPathValue(tf.path, "value0");
181     EXPECT_NEAR(std::chrono::milliseconds(200).count(), expire_time.count(),
182                 kTIMING_TOLERANCE_MS);
183     // Remove high prio request, now only request @ value1 active
184     t.RemoveRequest("LAUNCH");
185     expire_time = t.Update(true);
186     _VerifyPathValue(tf.path, "value1");
187     EXPECT_NEAR(std::chrono::milliseconds(500).count(), expire_time.count(),
188                 kTIMING_TOLERANCE_MS);
189     // Remove request, now default value2
190     t.RemoveRequest("INTERACTION");
191     expire_time = t.Update(true);
192     _VerifyPathValue(tf.path, "value2");
193     EXPECT_EQ(std::chrono::milliseconds::max(), expire_time);
194 }
195 
196 // Test add request with holding fd
TEST(FileNodeTest,AddRequestTestHoldFdOverride)197 TEST(FileNodeTest, AddRequestTestHoldFdOverride) {
198     TemporaryFile tf;
199     FileNode t("t", tf.path, {{"value0"}, {"value1"}, {"value2"}}, 2, true,
200                true, true);
201     EXPECT_TRUE(t.GetHoldFd());
202     auto start = std::chrono::steady_clock::now();
203     EXPECT_TRUE(t.AddRequest(1, "INTERACTION", start + 500ms));
204     std::chrono::milliseconds expire_time = t.Update(true);
205     // Add request @ value1
206     _VerifyPathValue(tf.path, "value1");
207     EXPECT_NEAR(std::chrono::milliseconds(500).count(), expire_time.count(),
208                 kTIMING_TOLERANCE_MS);
209     // Add request @ value0 higher prio than value1
210     EXPECT_TRUE(t.AddRequest(0, "LAUNCH", start + 200ms));
211     expire_time = t.Update(true);
212     _VerifyPathValue(tf.path, "value0");
213     EXPECT_NEAR(std::chrono::milliseconds(200).count(), expire_time.count(),
214                 kTIMING_TOLERANCE_MS);
215     // Add request @ value0 shorter
216     EXPECT_TRUE(t.AddRequest(0, "LAUNCH", start + 100ms));
217     expire_time = t.Update(true);
218     _VerifyPathValue(tf.path, "value0");
219     EXPECT_NEAR(std::chrono::milliseconds(200).count(), expire_time.count(),
220                 kTIMING_TOLERANCE_MS);
221     // Add request @ value0 longer
222     EXPECT_TRUE(t.AddRequest(0, "LAUNCH", start + 300ms));
223     expire_time = t.Update(true);
224     _VerifyPathValue(tf.path, "value0");
225     EXPECT_NEAR(std::chrono::milliseconds(300).count(), expire_time.count(),
226                 kTIMING_TOLERANCE_MS);
227     // Remove high prio request, now only request @ value1 active
228     t.RemoveRequest("LAUNCH");
229     expire_time = t.Update(true);
230     _VerifyPathValue(tf.path, "value1");
231     EXPECT_NEAR(std::chrono::milliseconds(500).count(), expire_time.count(),
232                 kTIMING_TOLERANCE_MS);
233     // Remove request, now default value2
234     t.RemoveRequest("INTERACTION");
235     expire_time = t.Update(true);
236     _VerifyPathValue(tf.path, "value2");
237     EXPECT_EQ(std::chrono::milliseconds::max(), expire_time);
238 }
239 
240 }  // namespace perfmgr
241 }  // namespace android
242