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 <errno.h>
18 #include <sys/wait.h>
19 #include <unistd.h>
20
21 #include <chrono>
22 #include <sstream>
23 #include <string>
24
25 #include <gtest/gtest.h>
26
27 #include "utils.h"
28
29 #if defined(__BIONIC__)
30 #include <sys/system_properties.h>
NanoTime()31 int64_t NanoTime() {
32 auto t = std::chrono::time_point_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now());
33 return t.time_since_epoch().count();
34 }
35 #endif
36
37 // Note that this test affects global state of the system
38 // this tests tries to mitigate this by using utime+pid
39 // prefix for the property name. It is still results in
40 // pollution of property service since properties cannot
41 // be removed.
42 //
43 // Note that there is also possibility to run into "out-of-memory"
44 // if this test if it is executed often enough without reboot.
TEST(properties,smoke)45 TEST(properties, smoke) {
46 #if defined(__BIONIC__)
47 char propvalue[PROP_VALUE_MAX];
48
49 std::stringstream ss;
50 ss << "debug.test." << getpid() << "." << NanoTime() << ".";
51 const std::string property_prefix = ss.str();
52 const std::string property_name = property_prefix + "property1";
53
54 // Set brand new property
55 ASSERT_EQ(0, __system_property_set(property_name.c_str(), "value1"));
56 ASSERT_EQ(6, __system_property_get(property_name.c_str(), propvalue));
57 ASSERT_STREQ("value1", propvalue);
58
59 std::string long_value = "property-";
60 for (size_t i = 0; i < PROP_VALUE_MAX; i++) {
61 long_value += "y";
62 }
63
64 // Make sure that attempts to set invalid property value fails and preserves
65 // previous value.
66 propvalue[0] = '\0';
67 ASSERT_EQ(-1, __system_property_set(property_name.c_str(), long_value.c_str()));
68 ASSERT_EQ(6, __system_property_get(property_name.c_str(), propvalue));
69 ASSERT_STREQ("value1", propvalue);
70
71 // Update property
72 ASSERT_EQ(0, __system_property_set(property_name.c_str(), "value1-1"));
73 ASSERT_EQ(8, __system_property_get(property_name.c_str(), propvalue));
74 ASSERT_STREQ("value1-1", propvalue);
75
76
77 // check that there is no limit on property name length
78 char suffix[1024];
79 for (size_t i = 0; i < sizeof(suffix); i++) {
80 suffix[i] = 'x';
81 }
82
83 suffix[sizeof(suffix)-1] = '\0';
84 const std::string long_property_name = property_prefix + suffix;
85
86 ASSERT_EQ(0, __system_property_set(long_property_name.c_str(), "value2"));
87 ASSERT_EQ(6, __system_property_get(long_property_name.c_str(), propvalue));
88 ASSERT_STREQ("value2", propvalue);
89
90 // test find and read_callback
91 const prop_info* pi = __system_property_find(property_name.c_str());
92 ASSERT_TRUE(pi != nullptr);
93
94 std::string expected_name = property_name;
95 __system_property_read_callback(pi,
96 [](void* cookie, const char* name, const char* value, unsigned /*serial*/) {
97 const std::string* expected_name = static_cast<const std::string*>(cookie);
98 ASSERT_EQ(*expected_name, name);
99 ASSERT_STREQ("value1-1", value);
100 }, &expected_name);
101
102 pi = __system_property_find(long_property_name.c_str());
103 ASSERT_TRUE(pi != nullptr);
104
105 expected_name = long_property_name;
106 __system_property_read_callback(pi,
107 [](void* cookie, const char* name, const char* value, unsigned /*serial*/) {
108 const std::string* expected_name = static_cast<const std::string*>(cookie);
109 ASSERT_EQ(*expected_name, name);
110 ASSERT_STREQ("value2", value);
111 }, &expected_name);
112
113 // Check that read() for long names still works but returns truncated version of the name
114 pi = __system_property_find(property_name.c_str());
115 ASSERT_TRUE(pi != nullptr);
116 char legacy_name[PROP_NAME_MAX];
117 expected_name = std::string(property_name.c_str(), PROP_NAME_MAX-1);
118 ASSERT_EQ(8, __system_property_read(pi, &legacy_name[0], propvalue));
119 ASSERT_EQ(expected_name, legacy_name);
120 ASSERT_STREQ("value1-1", propvalue);
121
122 const prop_info* pi_long = __system_property_find(long_property_name.c_str());
123 ASSERT_TRUE(pi != nullptr);
124 expected_name = std::string(long_property_name.c_str(), PROP_NAME_MAX-1);
125 ASSERT_EQ(6, __system_property_read(pi_long, &legacy_name[0], propvalue));
126 ASSERT_EQ(expected_name, legacy_name);
127 ASSERT_STREQ("value2", propvalue);
128 #else // __BIONIC__
129 GTEST_SKIP() << "bionic-only test";
130 #endif // __BIONIC__
131 }
132
TEST(properties,no_fd_leaks)133 TEST(properties, no_fd_leaks) {
134 #if defined(__BIONIC__)
135 FdLeakChecker leak_checker;
136 std::stringstream ss;
137 ss << "debug.test." << getpid() << "." << NanoTime() << ".";
138 const std::string property_prefix = ss.str();
139 const std::string property_name = property_prefix + "property1";
140
141 for (size_t i = 0; i < 100; ++i) {
142 char propvalue[PROP_VALUE_MAX];
143 ASSERT_EQ(0, __system_property_set(property_name.c_str(), "value1"));
144 ASSERT_EQ(6, __system_property_get(property_name.c_str(), propvalue));
145 ASSERT_STREQ("value1", propvalue);
146
147 ASSERT_EQ(0, __system_property_set(property_name.c_str(), "value2"));
148 ASSERT_EQ(6, __system_property_get(property_name.c_str(), propvalue));
149 ASSERT_STREQ("value2", propvalue);
150 }
151 #else // __BIONIC__
152 GTEST_SKIP() << "bionic-only test";
153 #endif // __BIONIC__
154 }
155
TEST(properties,empty_value)156 TEST(properties, empty_value) {
157 #if defined(__BIONIC__)
158 char propvalue[PROP_VALUE_MAX];
159
160 std::stringstream ss;
161 ss << "debug.test." << getpid() << "." << NanoTime() << "." << "property_empty";
162 const std::string property_name = ss.str();
163
164 for (size_t i = 0; i < 1000; ++i) {
165 ASSERT_EQ(0, __system_property_set(property_name.c_str(), ""));
166 ASSERT_EQ(0, __system_property_get(property_name.c_str(), propvalue));
167 ASSERT_STREQ("", propvalue);
168 }
169
170 #else // __BIONIC__
171 GTEST_SKIP() << "bionic-only test";
172 #endif // __BIONIC__
173 }
174