tests/system_properties_test.cpp

   1 /*
   2  * Copyright (C) 2013 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 <gtest/gtest.h>
  18 #include "BionicDeathTest.h"
  19
  20 #include <errno.h>
  21 #include <sys/wait.h>
  22 #include <unistd.h>
  23 #include <string>
  24
  25 #if defined(__BIONIC__)
  26
  27 #define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
  28 #include <sys/_system_properties.h>
  29
  30 extern void *__system_property_area__;
  31
  32 struct LocalPropertyTestState {
  33     LocalPropertyTestState() : valid(false) {
  34         const char* ANDROID_DATA = getenv("ANDROID_DATA");
  35         char dir_template[PATH_MAX];
  36         snprintf(dir_template, sizeof(dir_template), "%s/local/tmp/prop-XXXXXX", ANDROID_DATA);
  37         char* dirname = mkdtemp(dir_template);
  38         if (!dirname) {
  39             fprintf(stderr, "making temp file for test state failed (is %s writable?): %s",
  40                     dir_template, strerror(errno));
  41             return;
  42         }
  43
  44         old_pa = __system_property_area__;
  45         __system_property_area__ = NULL;
  46
  47         pa_dirname = dirname;
  48         pa_filename = pa_dirname + "/__properties__";
  49
  50         __system_property_set_filename(pa_filename.c_str());
  51         __system_property_area_init();
  52         valid = true;
  53     }
  54
  55     ~LocalPropertyTestState() {
  56         if (!valid) {
  57             return;
  58         }
  59
  60         __system_property_area__ = old_pa;
  61
  62         __system_property_set_filename(PROP_FILENAME);
  63         unlink(pa_filename.c_str());
  64         rmdir(pa_dirname.c_str());
  65     }
  66 public:
  67     bool valid;
  68 private:
  69     std::string pa_dirname;
  70     std::string pa_filename;
  71     void *old_pa;
  72 };
  73
  74 static void foreach_test_callback(const prop_info *pi, void* cookie) {
  75     size_t *count = static_cast<size_t *>(cookie);
  76
  77     ASSERT_NE((prop_info *)NULL, pi);
  78     (*count)++;
  79 }
  80
  81 static void hierarchical_test_callback(const prop_info *pi, void *cookie) {
  82     bool (*ok)[8][8] = static_cast<bool (*)[8][8]>(cookie);
  83
  84     char name[PROP_NAME_MAX];
  85     char value[PROP_VALUE_MAX];
  86
  87     __system_property_read(pi, name, value);
  88
  89     int name_i, name_j, name_k;
  90     int value_i, value_j, value_k;
  91     ASSERT_EQ(3, sscanf(name, "property_%d.%d.%d", &name_i, &name_j, &name_k));
  92     ASSERT_EQ(3, sscanf(value, "value_%d.%d.%d", &value_i, &value_j, &value_k));
  93     ASSERT_EQ(name_i, value_i);
  94     ASSERT_GE(name_i, 0);
  95     ASSERT_LT(name_i, 8);
  96     ASSERT_EQ(name_j, value_j);
  97     ASSERT_GE(name_j, 0);
  98     ASSERT_LT(name_j, 8);
  99     ASSERT_EQ(name_k, value_k);
 100     ASSERT_GE(name_k, 0);
 101     ASSERT_LT(name_k, 8);
 102
 103     ok[name_i][name_j][name_k] = true;
 104 }
 105
 106 static void *PropertyWaitHelperFn(void *arg) {
 107     int *flag = (int *)arg;
 108     prop_info *pi;
 109     pi = (prop_info *)__system_property_find("property");
 110     usleep(100000);
 111
 112     *flag = 1;
 113     __system_property_update(pi, "value3", 6);
 114
 115     return NULL;
 116 }
 117
 118 #endif // __BIONIC__
 119
 120 TEST(properties, add) {
 121 #if defined(__BIONIC__)
 122     LocalPropertyTestState pa;
 123     ASSERT_TRUE(pa.valid);
 124
 125     char propvalue[PROP_VALUE_MAX];
 126
 127     ASSERT_EQ(0, __system_property_add("property", 8, "value1", 6));
 128     ASSERT_EQ(0, __system_property_add("other_property", 14, "value2", 6));
 129     ASSERT_EQ(0, __system_property_add("property_other", 14, "value3", 6));
 130
 131     ASSERT_EQ(6, __system_property_get("property", propvalue));
 132     ASSERT_STREQ(propvalue, "value1");
 133
 134     ASSERT_EQ(6, __system_property_get("other_property", propvalue));
 135     ASSERT_STREQ(propvalue, "value2");
 136
 137     ASSERT_EQ(6, __system_property_get("property_other", propvalue));
 138     ASSERT_STREQ(propvalue, "value3");
 139 #else // __BIONIC__
 140     GTEST_LOG_(INFO) << "This test does nothing.\n";
 141 #endif // __BIONIC__
 142 }
 143
 144 TEST(properties, update) {
 145 #if defined(__BIONIC__)
 146     LocalPropertyTestState pa;
 147     ASSERT_TRUE(pa.valid);
 148
 149     char propvalue[PROP_VALUE_MAX];
 150     prop_info *pi;
 151
 152     ASSERT_EQ(0, __system_property_add("property", 8, "oldvalue1", 9));
 153     ASSERT_EQ(0, __system_property_add("other_property", 14, "value2", 6));
 154     ASSERT_EQ(0, __system_property_add("property_other", 14, "value3", 6));
 155
 156     pi = (prop_info *)__system_property_find("property");
 157     ASSERT_NE((prop_info *)NULL, pi);
 158     __system_property_update(pi, "value4", 6);
 159
 160     pi = (prop_info *)__system_property_find("other_property");
 161     ASSERT_NE((prop_info *)NULL, pi);
 162     __system_property_update(pi, "newvalue5", 9);
 163
 164     pi = (prop_info *)__system_property_find("property_other");
 165     ASSERT_NE((prop_info *)NULL, pi);
 166     __system_property_update(pi, "value6", 6);
 167
 168     ASSERT_EQ(6, __system_property_get("property", propvalue));
 169     ASSERT_STREQ(propvalue, "value4");
 170
 171     ASSERT_EQ(9, __system_property_get("other_property", propvalue));
 172     ASSERT_STREQ(propvalue, "newvalue5");
 173
 174     ASSERT_EQ(6, __system_property_get("property_other", propvalue));
 175     ASSERT_STREQ(propvalue, "value6");
 176 #else // __BIONIC__
 177     GTEST_LOG_(INFO) << "This test does nothing.\n";
 178 #endif // __BIONIC__
 179 }
 180
 181 TEST(properties, fill) {
 182 #if defined(__BIONIC__)
 183     LocalPropertyTestState pa;
 184     ASSERT_TRUE(pa.valid);
 185     char prop_name[PROP_NAME_MAX];
 186     char prop_value[PROP_VALUE_MAX];
 187     char prop_value_ret[PROP_VALUE_MAX];
 188     int count = 0;
 189     int ret;
 190
 191     while (true) {
 192         ret = snprintf(prop_name, PROP_NAME_MAX - 1, "property_%d", count);
 193         memset(prop_name + ret, 'a', PROP_NAME_MAX - 1 - ret);
 194         ret = snprintf(prop_value, PROP_VALUE_MAX - 1, "value_%d", count);
 195         memset(prop_value + ret, 'b', PROP_VALUE_MAX - 1 - ret);
 196         prop_name[PROP_NAME_MAX - 1] = 0;
 197         prop_value[PROP_VALUE_MAX - 1] = 0;
 198
 199         ret = __system_property_add(prop_name, PROP_NAME_MAX - 1, prop_value, PROP_VALUE_MAX - 1);
 200         if (ret < 0)
 201             break;
 202
 203         count++;
 204     }
 205
 206     // For historical reasons at least 247 properties must be supported
 207     ASSERT_GE(count, 247);
 208
 209     for (int i = 0; i < count; i++) {
 210         ret = snprintf(prop_name, PROP_NAME_MAX - 1, "property_%d", i);
 211         memset(prop_name + ret, 'a', PROP_NAME_MAX - 1 - ret);
 212         ret = snprintf(prop_value, PROP_VALUE_MAX - 1, "value_%d", i);
 213         memset(prop_value + ret, 'b', PROP_VALUE_MAX - 1 - ret);
 214         prop_name[PROP_NAME_MAX - 1] = 0;
 215         prop_value[PROP_VALUE_MAX - 1] = 0;
 216         memset(prop_value_ret, '\0', PROP_VALUE_MAX);
 217
 218         ASSERT_EQ(PROP_VALUE_MAX - 1, __system_property_get(prop_name, prop_value_ret));
 219         ASSERT_EQ(0, memcmp(prop_value, prop_value_ret, PROP_VALUE_MAX));
 220     }
 221 #else // __BIONIC__
 222     GTEST_LOG_(INFO) << "This test does nothing.\n";
 223 #endif // __BIONIC__
 224 }
 225
 226 TEST(properties, foreach) {
 227 #if defined(__BIONIC__)
 228     LocalPropertyTestState pa;
 229     ASSERT_TRUE(pa.valid);
 230     size_t count = 0;
 231
 232     ASSERT_EQ(0, __system_property_add("property", 8, "value1", 6));
 233     ASSERT_EQ(0, __system_property_add("other_property", 14, "value2", 6));
 234     ASSERT_EQ(0, __system_property_add("property_other", 14, "value3", 6));
 235
 236     ASSERT_EQ(0, __system_property_foreach(foreach_test_callback, &count));
 237     ASSERT_EQ(3U, count);
 238 #else // __BIONIC__
 239     GTEST_LOG_(INFO) << "This test does nothing.\n";
 240 #endif // __BIONIC__
 241 }
 242
 243 TEST(properties, find_nth) {
 244 #if defined(__BIONIC__)
 245     LocalPropertyTestState pa;
 246     ASSERT_TRUE(pa.valid);
 247
 248     ASSERT_EQ(0, __system_property_add("property", 8, "value1", 6));
 249     ASSERT_EQ(0, __system_property_add("other_property", 14, "value2", 6));
 250     ASSERT_EQ(0, __system_property_add("property_other", 14, "value3", 6));
 251
 252     ASSERT_NE((const prop_info *)NULL, __system_property_find_nth(0));
 253     ASSERT_NE((const prop_info *)NULL, __system_property_find_nth(1));
 254     ASSERT_NE((const prop_info *)NULL, __system_property_find_nth(2));
 255
 256     ASSERT_EQ((const prop_info *)NULL, __system_property_find_nth(3));
 257     ASSERT_EQ((const prop_info *)NULL, __system_property_find_nth(4));
 258     ASSERT_EQ((const prop_info *)NULL, __system_property_find_nth(5));
 259     ASSERT_EQ((const prop_info *)NULL, __system_property_find_nth(100));
 260     ASSERT_EQ((const prop_info *)NULL, __system_property_find_nth(200));
 261     ASSERT_EQ((const prop_info *)NULL, __system_property_find_nth(247));
 262 #else // __BIONIC__
 263     GTEST_LOG_(INFO) << "This test does nothing.\n";
 264 #endif // __BIONIC__
 265 }
 266
 267 TEST(properties, fill_hierarchical) {
 268 #if defined(__BIONIC__)
 269     LocalPropertyTestState pa;
 270     ASSERT_TRUE(pa.valid);
 271     char prop_name[PROP_NAME_MAX];
 272     char prop_value[PROP_VALUE_MAX];
 273     char prop_value_ret[PROP_VALUE_MAX];
 274     int ret;
 275
 276     for (int i = 0; i < 8; i++) {
 277         for (int j = 0; j < 8; j++) {
 278             for (int k = 0; k < 8; k++) {
 279                 ret = snprintf(prop_name, PROP_NAME_MAX - 1, "property_%d.%d.%d", i, j, k);
 280                 memset(prop_name + ret, 'a', PROP_NAME_MAX - 1 - ret);
 281                 ret = snprintf(prop_value, PROP_VALUE_MAX - 1, "value_%d.%d.%d", i, j, k);
 282                 memset(prop_value + ret, 'b', PROP_VALUE_MAX - 1 - ret);
 283                 prop_name[PROP_NAME_MAX - 1] = 0;
 284                 prop_value[PROP_VALUE_MAX - 1] = 0;
 285
 286                 ASSERT_EQ(0, __system_property_add(prop_name, PROP_NAME_MAX - 1, prop_value, PROP_VALUE_MAX - 1));
 287             }
 288         }
 289     }
 290
 291     for (int i = 0; i < 8; i++) {
 292         for (int j = 0; j < 8; j++) {
 293             for (int k = 0; k < 8; k++) {
 294                 ret = snprintf(prop_name, PROP_NAME_MAX - 1, "property_%d.%d.%d", i, j, k);
 295                 memset(prop_name + ret, 'a', PROP_NAME_MAX - 1 - ret);
 296                 ret = snprintf(prop_value, PROP_VALUE_MAX - 1, "value_%d.%d.%d", i, j, k);
 297                 memset(prop_value + ret, 'b', PROP_VALUE_MAX - 1 - ret);
 298                 prop_name[PROP_NAME_MAX - 1] = 0;
 299                 prop_value[PROP_VALUE_MAX - 1] = 0;
 300                 memset(prop_value_ret, '\0', PROP_VALUE_MAX);
 301
 302                 ASSERT_EQ(PROP_VALUE_MAX - 1, __system_property_get(prop_name, prop_value_ret));
 303                 ASSERT_EQ(0, memcmp(prop_value, prop_value_ret, PROP_VALUE_MAX));
 304             }
 305         }
 306     }
 307
 308     bool ok[8][8][8];
 309     memset(ok, 0, sizeof(ok));
 310     __system_property_foreach(hierarchical_test_callback, ok);
 311
 312     for (int i = 0; i < 8; i++) {
 313         for (int j = 0; j < 8; j++) {
 314             for (int k = 0; k < 8; k++) {
 315                 ASSERT_TRUE(ok[i][j][k]);
 316             }
 317         }
 318     }
 319 #else // __BIONIC__
 320     GTEST_LOG_(INFO) << "This test does nothing.\n";
 321 #endif // __BIONIC__
 322 }
 323
 324 TEST(properties, errors) {
 325 #if defined(__BIONIC__)
 326     LocalPropertyTestState pa;
 327     ASSERT_TRUE(pa.valid);
 328     char prop_value[PROP_NAME_MAX];
 329
 330     ASSERT_EQ(0, __system_property_add("property", 8, "value1", 6));
 331     ASSERT_EQ(0, __system_property_add("other_property", 14, "value2", 6));
 332     ASSERT_EQ(0, __system_property_add("property_other", 14, "value3", 6));
 333
 334     ASSERT_EQ(0, __system_property_find("property1"));
 335     ASSERT_EQ(0, __system_property_get("property1", prop_value));
 336
 337     ASSERT_EQ(-1, __system_property_add("name", PROP_NAME_MAX, "value", 5));
 338     ASSERT_EQ(-1, __system_property_add("name", 4, "value", PROP_VALUE_MAX));
 339     ASSERT_EQ(-1, __system_property_update(NULL, "value", PROP_VALUE_MAX));
 340 #else // __BIONIC__
 341     GTEST_LOG_(INFO) << "This test does nothing.\n";
 342 #endif // __BIONIC__
 343 }
 344
 345 TEST(properties, serial) {
 346 #if defined(__BIONIC__)
 347     LocalPropertyTestState pa;
 348     ASSERT_TRUE(pa.valid);
 349     const prop_info *pi;
 350     unsigned int serial;
 351
 352     ASSERT_EQ(0, __system_property_add("property", 8, "value1", 6));
 353     ASSERT_NE((const prop_info *)NULL, pi = __system_property_find("property"));
 354     serial = __system_property_serial(pi);
 355     ASSERT_EQ(0, __system_property_update((prop_info *)pi, "value2", 6));
 356     ASSERT_NE(serial, __system_property_serial(pi));
 357 #else // __BIONIC__
 358     GTEST_LOG_(INFO) << "This test does nothing.\n";
 359 #endif // __BIONIC__
 360 }
 361
 362 TEST(properties, wait) {
 363 #if defined(__BIONIC__)
 364     LocalPropertyTestState pa;
 365     ASSERT_TRUE(pa.valid);
 366     unsigned int serial;
 367     prop_info *pi;
 368     pthread_t t;
 369     int flag = 0;
 370
 371     ASSERT_EQ(0, __system_property_add("property", 8, "value1", 6));
 372     serial = __system_property_wait_any(0);
 373     pi = (prop_info *)__system_property_find("property");
 374     ASSERT_NE((prop_info *)NULL, pi);
 375     __system_property_update(pi, "value2", 6);
 376     serial = __system_property_wait_any(serial);
 377
 378     ASSERT_EQ(0, pthread_create(&t, NULL, PropertyWaitHelperFn, &flag));
 379     ASSERT_EQ(flag, 0);
 380     serial = __system_property_wait_any(serial);
 381     ASSERT_EQ(flag, 1);
 382
 383     void* result;
 384     ASSERT_EQ(0, pthread_join(t, &result));
 385 #else // __BIONIC__
 386     GTEST_LOG_(INFO) << "This test does nothing.\n";
 387 #endif // __BIONIC__
 388 }
 389
 390 class KilledByFault {
 391     public:
 392         explicit KilledByFault() {};
 393         bool operator()(int exit_status) const;
 394 };
 395
 396 bool KilledByFault::operator()(int exit_status) const {
 397     return WIFSIGNALED(exit_status) &&
 398         (WTERMSIG(exit_status) == SIGSEGV ||
 399          WTERMSIG(exit_status) == SIGBUS ||
 400          WTERMSIG(exit_status) == SIGABRT);
 401 }
 402
 403 class properties_DeathTest : public BionicDeathTest {};
 404
 405 TEST_F(properties_DeathTest, read_only) {
 406 #if defined(__BIONIC__)
 407
 408   // This test only makes sense if we're talking to the real system property service.
 409   struct stat sb;
 410   if (stat(PROP_FILENAME, &sb) == -1 && errno == ENOENT) {
 411     return;
 412   }
 413
 414   ASSERT_EXIT(__system_property_add("property", 8, "value", 5), KilledByFault(), "");
 415 #else // __BIONIC__
 416   GTEST_LOG_(INFO) << "This test does nothing.\n";
 417 #endif // __BIONIC__
 418 }