xref: /cts/tests/tests/deviceconfig/src/android/deviceconfig/cts/DeviceConfigApiTests.java

/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License
 */

package android.deviceconfig.cts;

import static android.provider.Settings.RESET_MODE_PACKAGE_DEFAULTS;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;

import android.os.SystemClock;
import android.provider.DeviceConfig;
import android.provider.DeviceConfig.OnPropertiesChangedListener;
import android.provider.DeviceConfig.Properties;

import androidx.test.InstrumentationRegistry;
import androidx.test.runner.AndroidJUnit4;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executor;

@RunWith(AndroidJUnit4.class)
public final class DeviceConfigApiTests {
    private static final String NAMESPACE1 = "namespace1";
    private static final String NAMESPACE2 = "namespace2";
    private static final String EMPTY_NAMESPACE = "empty_namespace";
    private static final String KEY1 = "key1";
    private static final String KEY2 = "key2";
    private static final String VALUE1 = "value1";
    private static final String VALUE2 = "value2";
    private static final String DEFAULT_VALUE = "default_value";

    private static final boolean DEFAULT_BOOLEAN_TRUE = true;
    private static final boolean DEFAULT_BOOLEAN_FALSE = false;
    private static final boolean BOOLEAN_TRUE = true;
    private static final boolean BOOLEAN_FALSE = false;
    private static final String INVALID_BOOLEAN = "TR_UE";

    private static final int DEFAULT_INT = 999;
    private static final int VALID_INT = 123;
    private static final String INVALID_INT = "12E";

    private static final long DEFAULT_LONG = 123456;
    private static final long VALID_LONG = 278724287;
    private static final String INVALID_LONG = "23232R42";

    private static final float DEFAULT_FLOAT = 123.456f;
    private static final float VALID_FLOAT = 456.789f;
    private static final String INVALID_FLOAT = "34343et";

    private static final Executor EXECUTOR = InstrumentationRegistry.getContext().getMainExecutor();


    private static final long WAIT_FOR_PROPERTY_CHANGE_TIMEOUT_MILLIS = 2000; // 2 sec
    private final Object mLock = new Object();


    private static final String WRITE_DEVICE_CONFIG_PERMISSION =
            "android.permission.WRITE_DEVICE_CONFIG";

    private static final String READ_DEVICE_CONFIG_PERMISSION =
            "android.permission.READ_DEVICE_CONFIG";

    /**
     * Get necessary permissions to access and modify properties through DeviceConfig API.
     */
    @BeforeClass
    public static void setUp() throws Exception {
        InstrumentationRegistry.getInstrumentation().getUiAutomation().adoptShellPermissionIdentity(
                WRITE_DEVICE_CONFIG_PERMISSION, READ_DEVICE_CONFIG_PERMISSION);
    }

    /**
     * Nullify properties in DeviceConfig API after completion of every test.
     */
    @After
    public void cleanUp() {
        nullifyProperty(NAMESPACE1, KEY1);
        nullifyProperty(NAMESPACE2, KEY1);
        nullifyProperty(NAMESPACE1, KEY2);
        nullifyProperty(NAMESPACE2, KEY2);
    }

    /**
     * Delete properties in DeviceConfig API after completion of all tests and drop shell
     * permissions.
     */
    @AfterClass
    public static void cleanUpAfterAllTests() {
        deletePropertyThrowShell(NAMESPACE1, KEY1);
        deletePropertyThrowShell(NAMESPACE2, KEY1);
        deletePropertyThrowShell(NAMESPACE1, KEY2);
        deletePropertyThrowShell(NAMESPACE2, KEY2);
        InstrumentationRegistry.getInstrumentation().getUiAutomation()
                .dropShellPermissionIdentity();
    }

    /**
     * Checks that getting property which does not exist returns null.
     */
    @Test
    public void getProperty_empty() {
        String result = DeviceConfig.getProperty(EMPTY_NAMESPACE, KEY1);
        assertNull("Request for non existant flag name in DeviceConfig API should return null "
                + "while " + result + " was returned", result);
    }

    /**
     * Checks that setting and getting property from the same namespace return correct value.
     */
    @Test
    public void setAndGetProperty_sameNamespace() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE1, /*makeDefault=*/false);
        String result = DeviceConfig.getProperty(NAMESPACE1, KEY1);
        assertEquals("Value read from DeviceConfig API does not match written value.", VALUE1,
                result);
    }

    /**
     * Checks that setting a property in one namespace does not set the same property in a different
     * namespace.
     */
    @Test
    public void setAndGetProperty_differentNamespace() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE1, /*makeDefault=*/false);
        String result = DeviceConfig.getProperty(NAMESPACE2, KEY1);
        assertNull("Value for same keys written to different namespaces must not clash", result);
    }

    /**
     * Checks that different namespaces can keep different values for the same key.
     */
    @Test
    public void setAndGetProperty_multipleNamespaces() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE1, /*makeDefault=*/false);
        DeviceConfig.setProperty(NAMESPACE2, KEY1, VALUE2, /*makeDefault=*/false);
        String result = DeviceConfig.getProperty(NAMESPACE1, KEY1);
        assertEquals("Value read from DeviceConfig API does not match written value.", VALUE1,
                result);
        result = DeviceConfig.getProperty(NAMESPACE2, KEY1);
        assertEquals("Value read from DeviceConfig API does not match written value.", VALUE2,
                result);
    }

    /**
     * Checks that saving value twice keeps the last value.
     */
    @Test
    public void setAndGetProperty_overrideValue() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE1, /*makeDefault=*/false);
        DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE2, /*makeDefault=*/false);
        String result = DeviceConfig.getProperty(NAMESPACE1, KEY1);
        assertEquals("New value written to the same namespace/key did not override previous"
                + " value.", VALUE2, result);
    }

    /**
     * Checks that getString() for null property returns default value.
     */
    @Test
    public void getString_empty() {
        final String result = DeviceConfig.getString(NAMESPACE1, KEY1, DEFAULT_VALUE);
        assertEquals("DeviceConfig.getString() must return default value if property is null",
                DEFAULT_VALUE, result);
    }

    /**
     * Checks that getString() for null property returns default value even if it is null.
     */
    @Test
    public void getString_nullDefault() {
        final String result = DeviceConfig.getString(NAMESPACE1, KEY1, null);
        assertEquals("DeviceConfig.getString() must return default value if property is null",
                null, result);
    }

    /**
     * Checks that getString() returns string saved in property.
     */
    @Test
    public void getString_nonEmpty() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE1, /*makeDefault=*/false);

        final String result = DeviceConfig.getString(NAMESPACE1, KEY1, DEFAULT_VALUE);
        assertEquals("DeviceConfig.getString() must return same value as getProperty() when " +
                "property is not null", VALUE1, result);
    }

    /**
     * Checks that getString() fails with NullPointerException when called with null namespace.
     */
    @Test
    public void getString_nullNamespace() {
        try {
            DeviceConfig.getString(null, KEY1, DEFAULT_VALUE);
            fail("DeviceConfig.getString() with null namespace must result in "
                    + "NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that getString() fails with NullPointerException when called with null key.
     */
    @Test
    public void getString_nullName() {
        try {
            DeviceConfig.getString(NAMESPACE1, null, DEFAULT_VALUE);
            fail("DeviceConfig.getString() with null name must result in NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that getBoolean() for null property returns default value.
     */
    @Test
    public void getBoolean_empty() {
        final boolean result = DeviceConfig.getBoolean(NAMESPACE1, KEY1, DEFAULT_BOOLEAN_TRUE);
        assertEquals("DeviceConfig.getBoolean() must return default value if property is null",
                DEFAULT_BOOLEAN_TRUE, result);
    }

    /**
     * Checks that getBoolean() returns boolean representation of string saved in property.
     */
    @Test
    public void getBoolean_valid() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, String.valueOf(BOOLEAN_TRUE),
                /*makeDefault=*/false);

        final boolean result = DeviceConfig.getBoolean(NAMESPACE1, KEY1, DEFAULT_BOOLEAN_FALSE);
        assertEquals("DeviceConfig.getString() must return boolean equivalent value of"
                + " getProperty() when property is not null", BOOLEAN_TRUE, result);
    }

    /**
     * Checks that getBoolean() returns false for any invalid property value.
     */
    @Test
    public void getBoolean_invalid() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, INVALID_BOOLEAN, /*makeDefault=*/false);

        final boolean result = DeviceConfig.getBoolean(NAMESPACE1, KEY1, DEFAULT_BOOLEAN_TRUE);
        // Anything non-null other than case insensitive "true" parses to false.
        assertEquals("DeviceConfig.getBoolean() must return boolean equivalent value of"
                + " getProperty() when property is not null", BOOLEAN_FALSE, result);
    }

    /**
     * Checks that getBoolean() fails with NullPointerException when called with null namespace.
     */
    @Test
    public void getBoolean_nullNamespace() {
        try {
            DeviceConfig.getBoolean(null, KEY1, DEFAULT_BOOLEAN_TRUE);
            fail("DeviceConfig.getBoolean() with null namespace must result in "
                    + "NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that getBoolean() fails with NullPointerException when called with null name.
     */
    @Test
    public void getBoolean_nullName() {
        try {
            DeviceConfig.getBoolean(NAMESPACE1, null, DEFAULT_BOOLEAN_TRUE);
            fail("DeviceConfig.getBoolean() with null name must result in NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that getInt() for null property returns default value.
     */
    @Test
    public void getInt_empty() {
        final int result = DeviceConfig.getInt(NAMESPACE1, KEY1, DEFAULT_INT);
        assertEquals("DeviceConfig.getInt() must return default value if property is null",
                DEFAULT_INT, result);
    }

    /**
     * Checks that getInt() returns integer representation of string saved in property.
     */
    @Test
    public void getInt_valid() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, String.valueOf(VALID_INT),
                /*makeDefault=*/false);

        final int result = DeviceConfig.getInt(NAMESPACE1, KEY1, DEFAULT_INT);
        assertEquals("DeviceConfig.getInt() must return integer equivalent value of"
                + " getProperty() when property is not null", VALID_INT, result);
    }

    /**
     * Checks that getInt() returns default value if property is not well-formed integer value.
     */
    @Test
    public void getInt_invalid() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, INVALID_INT, /*makeDefault=*/false);

        final int result = DeviceConfig.getInt(NAMESPACE1, KEY1, DEFAULT_INT);
        // Failure to parse results in using the default value
        assertEquals("DeviceConfig.getInt() must return integer equivalent value of"
                + " getProperty() when property is not null", DEFAULT_INT, result);
    }

    /**
     * Checks that getInt() fails with NullPointerException when called with null namespace.
     */
    @Test
    public void getInt_nullNamespace() {
        try {
            DeviceConfig.getInt(null, KEY1, VALID_INT);
            fail("DeviceConfig.getInt() with null namespace must result in NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that getInt() fails with NullPointerException when called with null name.
     */
    @Test
    public void getInt_nullName() {
        try {
            DeviceConfig.getInt(NAMESPACE1, null, VALID_INT);
            fail("DeviceConfig.getInt() with null name must result in NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that getLong() for null property returns default value.
     */
    @Test
    public void getLong_empty() {
        final long result = DeviceConfig.getLong(NAMESPACE1, KEY1, DEFAULT_LONG);
        assertEquals("DeviceConfig.getLong() must return default value if property is null",
                DEFAULT_LONG, result);
    }

    /**
     * Checks that getLong() returns long representation of string saved in property.
     */
    @Test
    public void getLong_valid() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, String.valueOf(VALID_LONG),
                /*makeDefault=*/false);

        final long result = DeviceConfig.getLong(NAMESPACE1, KEY1, DEFAULT_LONG);
        assertEquals("DeviceConfig.getLong() must return long equivalent value of"
                + " getProperty() when property is not null", VALID_LONG, result);
    }

    /**
     * Checks that getLong() returns default value if property is not well-formed long value.
     */
    @Test
    public void getLong_invalid() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, INVALID_LONG, /*makeDefault=*/false);

        final long result = DeviceConfig.getLong(NAMESPACE1, KEY1, DEFAULT_LONG);
        // Failure to parse results in using the default value
        assertEquals("DeviceConfig.getLong() must return long equivalent value of"
                + " getProperty() when property is not null", DEFAULT_LONG, result);
    }

    /**
     * Checks that getLong() fails with NullPointerException when called with null namespace.
     */
    @Test
    public void getLong_nullNamespace() {
        try {
            DeviceConfig.getLong(null, KEY1, DEFAULT_LONG);
            fail("DeviceConfig.getLong() with null namespace must result in "
                    + "NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that getLong() fails with NullPointerException when called with null name.
     */
    @Test
    public void getLong_nullName() {
        try {
            DeviceConfig.getLong(NAMESPACE1, null, 0);
            fail("DeviceConfig.getLong() with null name must result in NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that getFloat() for null property returns default value.
     */
    @Test
    public void getFloat_empty() {
        final float result = DeviceConfig.getFloat(NAMESPACE1, KEY1, DEFAULT_FLOAT);
        assertEquals("DeviceConfig.getFloat() must return default value if property is null",
                DEFAULT_FLOAT, result, 0.0);
    }

    /**
     * Checks that getFloat() returns float representation of string saved in property.
     */
    @Test
    public void getFloat_valid() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, String.valueOf(VALID_FLOAT),
                /*makeDefault=*/false);

        final float result = DeviceConfig.getFloat(NAMESPACE1, KEY1, DEFAULT_FLOAT);
        assertEquals("DeviceConfig.getFloat() must return float equivalent value of"
                + " getProperty() when property is not null", VALID_FLOAT, result, 0.0);
    }

    /**
     * Checks that getFloat() returns default value if property is not well-formed float value.
     */
    @Test
    public void getFloat_invalid() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, INVALID_FLOAT, /*makeDefault=*/false);

        final float result = DeviceConfig.getFloat(NAMESPACE1, KEY1, DEFAULT_FLOAT);
        // Failure to parse results in using the default value
        assertEquals("DeviceConfig.getFloat() must return float equivalent value of"
                + " getProperty() when property is not null", DEFAULT_FLOAT, result, 0.0f);
    }

    /**
     * Checks that getFloat() fails with NullPointerException when called with null namespace.
     */
    @Test
    public void getFloat_nullNamespace() {
        try {
            DeviceConfig.getFloat(null, KEY1, DEFAULT_FLOAT);
            fail("DeviceConfig.getFloat() with null namespace must result in "
                    + "NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that getFloat() fails with NullPointerException when called with null name.
     */
    @Test
    public void getFloat_nullName() {
        try {
            DeviceConfig.getFloat(NAMESPACE1, null, DEFAULT_FLOAT);
            fail("DeviceConfig.getFloat() with null name must result in NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that setProperty() fails with NullPointerException when called with null namespace.
     */
    @Test
    public void setProperty_nullNamespace() {
        try {
            DeviceConfig.setProperty(null, KEY1, DEFAULT_VALUE, /*makeDefault=*/false);
            fail("DeviceConfig.setProperty() with null namespace must result in "
                    + "NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that setProperty() fails with NullPointerException when called with null name.
     */
    @Test
    public void setProperty_nullName() {
        try {
            DeviceConfig.setProperty(NAMESPACE1, null, DEFAULT_VALUE, /*makeDefault=*/false);
            fail("DeviceConfig.setProperty() with null name must result in NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Checks that Properties.getString() for null property returns default value.
     */
    @Test
    public void getPropertiesString_empty() {
        setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, VALUE1);
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, null);
        final String result = properties.getString(KEY1, DEFAULT_VALUE);
        assertEquals("DeviceConfig.Properties.getString() must return default value if property "
                        + "is null", DEFAULT_VALUE, result);
    }

    /**
     * Checks that Properties.getString() for null property returns default value even if it is
     * null.
     */
    @Test
    public void getPropertiesString_nullDefault() {
        setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, DEFAULT_VALUE);
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, null);
        final String result = properties.getString(KEY1, null);
        assertEquals("DeviceConfig.Properties.getString() must return default value if property is "
                        + "null", null, result);
    }

    /**
     * Checks that Properties.getString() returns string saved in property.
     */
    @Test
    public void getPropertiesString_nonEmpty() {
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, VALUE1);

        final String result = properties.getString(KEY1, DEFAULT_VALUE);
        assertEquals("DeviceConfig.Properties.getString() must return same value as getProperty() "
                + "when property is not null", VALUE1, result);
    }

    /**
     * Checks that Properties.getBoolean() for null property returns default value.
     */
    @Test
    public void getPropertiesBoolean_empty() {
        setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, String.valueOf(BOOLEAN_TRUE));
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, null);
        final boolean result = properties.getBoolean(KEY1, DEFAULT_BOOLEAN_TRUE);
        assertEquals("DeviceConfig.Properties.getBoolean() must return default value if property "
                        + "is null", DEFAULT_BOOLEAN_TRUE, result);
    }

    /**
     * Checks that Properties.getBoolean() returns boolean representation of string saved in
     * property.
     */
    @Test
    public void getPropertiesBoolean_valid() {
        final Properties properties = setPropertiesAndAssertSuccessfulChange(
                NAMESPACE1, KEY1, String.valueOf(BOOLEAN_TRUE));
        final boolean result = properties.getBoolean(KEY1, DEFAULT_BOOLEAN_FALSE);
        assertEquals("DeviceConfig.Properties.getString() must return boolean equivalent value of"
                + " getProperty() when property is not null", BOOLEAN_TRUE, result);
    }

    /**
     * Checks that Properties.getBoolean() returns false for any invalid (non parselable) property
     * value.
     */
    @Test
    public void getPropertiesBoolean_invalid() {
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, INVALID_BOOLEAN);

        final boolean result = properties.getBoolean(KEY1, DEFAULT_BOOLEAN_TRUE);
        // Anything non-null other than case insensitive "true" parses to false.
        assertEquals("DeviceConfig.Properties.getBoolean() must return boolean equivalent value of"
                + " getProperty() when property is not null", BOOLEAN_FALSE, result);
    }

    /**
     * Checks that Properties.getInt() for null property returns default value.
     */
    @Test
    public void getPropertiesInt_empty() {
        setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, String.valueOf(VALID_INT));
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, null);

        final int result = properties.getInt(KEY1, DEFAULT_INT);
        assertEquals("DeviceConfig.Properties.getInt() must return default value if property is "
                        + "null", DEFAULT_INT, result);
    }

    /**
     * Checks that Properties.getInt() returns integer representation of string saved in property.
     */
    @Test
    public void getPropertiesInt_valid() {
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, String.valueOf(VALID_INT));

        final int result = properties.getInt(KEY1, DEFAULT_INT);
        assertEquals("DeviceConfig.Properties.getInt() must return integer equivalent value of"
                + " getProperty() when property is not null", VALID_INT, result);
    }

    /**
     * Checks that Properties.getInt() returns default value if property is not well-formed integer
     * value.
     */
    @Test
    public void getPropertiesInt_invalid() {
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, INVALID_INT);

        final int result = properties.getInt(KEY1, DEFAULT_INT);
        // Failure to parse results in using the default value
        assertEquals("DeviceConfig.Properties.getInt() must return integer equivalent value of"
                + " getProperty() when property is not null", DEFAULT_INT, result);
    }

    /**
     * Checks that Properties.getLong() for null property returns default value.
     */
    @Test
    public void getPropertiesLong_empty() {
        setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, String.valueOf(VALID_LONG));
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, null);

        final long result = properties.getLong(KEY1, DEFAULT_LONG);
        assertEquals("DeviceConfig.Properties.getLong() must return default value if property is "
                        + "null", DEFAULT_LONG, result);
    }

    /**
     * Checks that Properties.getLong() returns long representation of string saved in property.
     */
    @Test
    public void getPropertiesLong_valid() {
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, String.valueOf(VALID_LONG));

        final long result = properties.getLong(KEY1, DEFAULT_LONG);
        assertEquals("DeviceConfig.Properties.getLong() must return long equivalent value of"
                + " getProperty() when property is not null", VALID_LONG, result);
    }

    /**
     * Checks that Properties.getLong() returns default value if property is not well-formed long
     * value.
     */
    @Test
    public void getPropertiesLong_invalid() {
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, INVALID_LONG);

        final long result = properties.getLong(KEY1, DEFAULT_LONG);
        // Failure to parse results in using the default value
        assertEquals("DeviceConfig.Properties.getLong() must return long equivalent value of"
                + " getProperty() when property is not null", DEFAULT_LONG, result);
    }

    /**
     * Checks that Properties.getFloat() for null property returns default value.
     */
    @Test
    public void getPropertiesFloat_empty() {
        setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, String.valueOf(VALID_FLOAT));
        final Properties properties =
                setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, null);
        final float result = properties.getFloat(KEY1, DEFAULT_FLOAT);
        assertEquals("DeviceConfig.Properties.getFloat() must return default value if property is "
                        + "null", DEFAULT_FLOAT, result, 0.0f);
    }

    /**
     * Checks that Properties.getFloat() returns float representation of string saved in property.
     */
    @Test
    public void getPropertiesFloat_valid() {
        final Properties properties = setPropertiesAndAssertSuccessfulChange(
                NAMESPACE1, KEY1, String.valueOf(VALID_FLOAT));

        final float result = properties.getFloat(KEY1, DEFAULT_FLOAT);
        assertEquals("DeviceConfig.Properties.getFloat() must return float equivalent value of"
                + " getProperty() when property is not null", VALID_FLOAT, result, 0.0f);
    }

    /**
     * Checks that Properties.getFloat() returns default value if property is not well-formed float
     * value.
     */
    @Test
    public void getPropertiesFloat_invalid() {
        final Properties properties = setPropertiesAndAssertSuccessfulChange(
                NAMESPACE1, KEY1, INVALID_FLOAT);

        final float result = properties.getFloat(KEY1, DEFAULT_FLOAT);
        // Failure to parse results in using the default value
        assertEquals("DeviceConfig.Properties.getFloat() must return float equivalent value of"
                + " getProperty() when property is not null", DEFAULT_FLOAT, result, 0.0f);
    }

    /**
     * Test that properties listener is successfully registered and provides callbacks on value
     * change.
     */
    @Test
    public void testPropertiesListener() {
        setPropertiesAndAssertSuccessfulChange(NAMESPACE1, KEY1, VALUE1);
    }

    /**
     * Test that two properties listeners subscribed to the same namespace are successfully
     * registered and unregistered while receiving correct updates in all states.
     */
    @Test
    public void testTwoPropertiesListenersSameNamespace() {
        final List<PropertyUpdate> receivedUpdates1 = new ArrayList<>();
        final List<PropertyUpdate> receivedUpdates2 = new ArrayList<>();

        OnPropertiesChangedListener listener1 = createOnPropertiesChangedListener(receivedUpdates1);
        OnPropertiesChangedListener listener2 = createOnPropertiesChangedListener(receivedUpdates2);

        try {
            DeviceConfig.addOnPropertiesChangedListener(NAMESPACE1, EXECUTOR, listener1);
            DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE1, /*makeDefault=*/false);

            waitForListenerUpdateOrTimeout(receivedUpdates1, /*expectedTotalUpdatesCount=*/1);
            waitForListenerUpdateOrTimeout(receivedUpdates2, /*expectedTotalUpdatesCount=*/0);

            assertEquals("OnPropertiesListener did not receive expected update",
                    receivedUpdates1.size(), /*expectedTotalUpdatesCount=*/1);
            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates2.size(), /*expectedTotalUpdatesCount=*/0);
            receivedUpdates1.get(0).assertEqual(NAMESPACE1, KEY1, VALUE1);

            DeviceConfig.addOnPropertiesChangedListener(NAMESPACE1, EXECUTOR, listener2);
            DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE2, /*makeDefault=*/false);

            waitForListenerUpdateOrTimeout(receivedUpdates1, /*expectedTotalUpdatesCount=*/2);
            waitForListenerUpdateOrTimeout(receivedUpdates2, /*expectedTotalUpdatesCount=*/1);

            assertEquals("OnPropertiesListener did not receive expected update",
                    receivedUpdates1.size(), 2);
            assertEquals("OnPropertiesListener did not receive expected update",
                    receivedUpdates2.size(), 1);
            receivedUpdates1.get(1).assertEqual(NAMESPACE1, KEY1, VALUE2);
            receivedUpdates2.get(0).assertEqual(NAMESPACE1, KEY1, VALUE2);

            DeviceConfig.removeOnPropertiesChangedListener(listener1);
            DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE1, /*makeDefault=*/false);

            waitForListenerUpdateOrTimeout(receivedUpdates2, /*expectedTotalUpdatesCount=*/2);
            waitForListenerUpdateOrTimeout(receivedUpdates1, /*expectedTotalUpdatesCount=*/2);

            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates1.size(), 2);
            assertEquals("OnPropertiesListener did not receive expected update",
                    receivedUpdates2.size(), 2);

            receivedUpdates2.get(1).assertEqual(NAMESPACE1, KEY1, VALUE1);

            DeviceConfig.removeOnPropertiesChangedListener(listener2);
            DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE2, /*makeDefault=*/false);

            waitForListenerUpdateOrTimeout(receivedUpdates2, /*expectedTotalUpdatesCount=*/2);
            waitForListenerUpdateOrTimeout(receivedUpdates1, /*expectedTotalUpdatesCount=*/2);

            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates1.size(), 2);
            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates2.size(), 2);
        } finally {
            DeviceConfig.removeOnPropertiesChangedListener(listener1);
            DeviceConfig.removeOnPropertiesChangedListener(listener2);
        }
    }

    /**
     * Test that two properties listeners subscribed to different namespaces are successfully
     * registered and unregistered while receiving correct updates in all states.
     */
    @Test
    public void testTwoPropertiesListenersDifferentNamespace() {
        final List<PropertyUpdate> receivedUpdates1 = new ArrayList<>();
        final List<PropertyUpdate> receivedUpdates2 = new ArrayList<>();

        OnPropertiesChangedListener listener1 = createOnPropertiesChangedListener(receivedUpdates1);
        OnPropertiesChangedListener listener2 = createOnPropertiesChangedListener(receivedUpdates2);

        try {
            DeviceConfig.addOnPropertiesChangedListener(NAMESPACE1, EXECUTOR, listener1);
            DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE1, /*makeDefault=*/false);

            waitForListenerUpdateOrTimeout(receivedUpdates1, /*expectedTotalUpdatesCount=*/1);
            waitForListenerUpdateOrTimeout(receivedUpdates2, /*expectedTotalUpdatesCount=*/0);

            assertEquals("OnPropertiesListener did not receive expected update",
                    receivedUpdates1.size(), 1);
            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates2.size(), 0);
            receivedUpdates1.get(0).assertEqual(NAMESPACE1, KEY1, VALUE1);

            DeviceConfig.addOnPropertiesChangedListener(NAMESPACE2, EXECUTOR, listener2);
            DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE2, /*makeDefault=*/false);

            waitForListenerUpdateOrTimeout(receivedUpdates1, /*expectedTotalUpdatesCount=*/2);
            waitForListenerUpdateOrTimeout(receivedUpdates2, /*expectedTotalUpdatesCount=*/0);

            assertEquals("OnPropertiesListener did not receive expected update",
                    receivedUpdates1.size(), 2);
            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates2.size(), 0);
            receivedUpdates1.get(1).assertEqual(NAMESPACE1, KEY1, VALUE2);

            DeviceConfig.setProperty(NAMESPACE2, KEY1, VALUE1, /*makeDefault=*/false);
            waitForListenerUpdateOrTimeout(receivedUpdates2, /*expectedTotalUpdatesCount=*/1);
            waitForListenerUpdateOrTimeout(receivedUpdates1, /*expectedTotalUpdatesCount=*/2);

            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates1.size(), 2);
            assertEquals("OnPropertiesListener did not receive expected update",
                    receivedUpdates2.size(), 1);

            receivedUpdates2.get(0).assertEqual(NAMESPACE2, KEY1, VALUE1);

            DeviceConfig.removeOnPropertiesChangedListener(listener1);
            DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE1, /*makeDefault=*/false);

            waitForListenerUpdateOrTimeout(receivedUpdates2, /*expectedTotalUpdatesCount=*/1);
            waitForListenerUpdateOrTimeout(receivedUpdates1, /*expectedTotalUpdatesCount=*/2);

            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates1.size(), 2);
            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates2.size(), 1);

            DeviceConfig.setProperty(NAMESPACE2, KEY1, VALUE2, /*makeDefault=*/false);
            waitForListenerUpdateOrTimeout(receivedUpdates2, /*expectedTotalUpdatesCount=*/2);
            waitForListenerUpdateOrTimeout(receivedUpdates1, /*expectedTotalUpdatesCount=*/2);

            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates1.size(), 2);
            assertEquals("OnPropertiesListener did not receive expected update",
                    receivedUpdates2.size(), 2);

            receivedUpdates2.get(1).assertEqual(NAMESPACE2, KEY1, VALUE2);
            DeviceConfig.removeOnPropertiesChangedListener(listener2);

            waitForListenerUpdateOrTimeout(receivedUpdates2, /*expectedTotalUpdatesCount=*/2);
            waitForListenerUpdateOrTimeout(receivedUpdates1, /*expectedTotalUpdatesCount=*/2);

            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates1.size(), 2);
            assertEquals("OnPropertiesListener received unexpected update",
                    receivedUpdates2.size(), 2);

        } catch(Exception e) {
            throw e;
        } finally {
            DeviceConfig.removeOnPropertiesChangedListener(listener1);
            DeviceConfig.removeOnPropertiesChangedListener(listener2);
        }
    }

    /**
     * Test that reset to package default successfully resets values.
     */
    @Test
    public void testResetToPackageDefaults() {
        DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE1, /*makeDefault=*/true);
        DeviceConfig.setProperty(NAMESPACE1, KEY1, VALUE2, /*makeDefault=*/false);

        assertEquals(DeviceConfig.getProperty(NAMESPACE1, KEY1), VALUE2);

        DeviceConfig.resetToDefaults(RESET_MODE_PACKAGE_DEFAULTS, NAMESPACE1);

        assertEquals(DeviceConfig.getProperty(NAMESPACE1, KEY1), VALUE1);
    }

    private OnPropertiesChangedListener createOnPropertiesChangedListener(
            List<PropertyUpdate> receivedUpdates) {
        OnPropertiesChangedListener changeListener = new OnPropertiesChangedListener() {
            @Override
            public void onPropertiesChanged(Properties properties) {
                synchronized (mLock) {
                    receivedUpdates.add(new PropertyUpdate(properties));
                    mLock.notifyAll();
                }
            }
        };
        return changeListener;
    }

    private void waitForListenerUpdateOrTimeout(
            List<PropertyUpdate> receivedUpdates, int expectedTotalUpdatesCount) {

        final long startTimeMillis = SystemClock.uptimeMillis();
        synchronized (mLock) {
            while (true) {
                if (receivedUpdates.size() >= expectedTotalUpdatesCount) {
                    return;
                }
                final long elapsedTimeMillis = SystemClock.uptimeMillis() - startTimeMillis;
                if (elapsedTimeMillis >= WAIT_FOR_PROPERTY_CHANGE_TIMEOUT_MILLIS) {
                    return;
                }
                final long remainingTimeMillis = WAIT_FOR_PROPERTY_CHANGE_TIMEOUT_MILLIS
                        - elapsedTimeMillis;
                try {
                    mLock.wait(remainingTimeMillis);
                } catch (InterruptedException ie) {
                    /* ignore */
                }
            }
        }
    }

    private Properties setPropertiesAndAssertSuccessfulChange(String setNamespace, String setName,
            String setValue) {
        final List<PropertyUpdate> receivedUpdates = new ArrayList<>();
        OnPropertiesChangedListener changeListener = createOnPropertiesChangedListener(receivedUpdates);

        DeviceConfig.addOnPropertiesChangedListener(setNamespace, EXECUTOR, changeListener);

        DeviceConfig.setProperty(setNamespace, setName, setValue, /*makeDefault=*/false);
        waitForListenerUpdateOrTimeout(receivedUpdates, 1);
        DeviceConfig.removeOnPropertiesChangedListener(changeListener);

        assertEquals("Failed to receive update to OnPropertiesChangedListener",
                receivedUpdates.size(), 1);
        PropertyUpdate propertiesUpdate = receivedUpdates.get(0);
        propertiesUpdate.assertEqual(setNamespace, setName, setValue);

        return propertiesUpdate.properties;
    }

    private void nullifyProperty(String namespace, String key) {
        if (DeviceConfig.getString(namespace, key, null) != null) {
            setPropertiesAndAssertSuccessfulChange(namespace, key, null);
        }
    }

    private static void deletePropertyThrowShell(String namespace, String key) {
        InstrumentationRegistry.getInstrumentation().getUiAutomation().executeShellCommand(
                "device_config delete " + namespace + " " + key);
    }

    private static class PropertyUpdate {
        String namespace;
        String name;
        String value;
        Properties properties;

        PropertyUpdate(String namespace, String name, String value) {
            this.name = name;
            this.namespace = namespace;
            this.value = value;
            this.properties = null;
        }

        PropertyUpdate(Properties properties) {
            if (properties.getKeyset().size() != 1) {
                fail("Unexpected properties size.");
            }
            this.namespace = properties.getNamespace();
            this.name = properties.getKeyset().iterator().next();
            this.value = properties.getString(this.name, null);
            this.properties = properties;
        }

        void assertEqual(String namespace, String name, String value) {
            assertEquals("Listener received update for unexpected namespace",
                    namespace, this.namespace);
            assertEquals("Listener received update for unexpected property",
                    this.name, name);
            assertEquals("Listener received update with unexpected value",
                    this.value, value);
        }

    }
}