Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8247153b authored by Neil Fuller's avatar Neil Fuller
Browse files

Change TimeDetectorStrategy.Environment API 

Switch TimeDetectorStrategy.Environment to returning
ConfigurationInternal in place of an individual property.

This is in preparation for implementing the methods to update
time detector configuration and support listeners. More properties will
be added to ConfigurationInternal / removed from Environment in later
commits.

This mirrors the situation in com.android.server.timezonedetector and is
part of a sequence of changes to make com.android.server.timedetector
follow the patterns for configuration used there.

Bug: 172891783
Bug: 229740080
Test: atest com.android.server.timedetector android.app.time
Change-Id: I0ffe467ede4b6b0279b284108a368c5265a323a0
parent a5db2b6c

core/java/android/app/time/TimeCapabilities.java

+61 −38
Original line number Diff line number Diff line
@@ -16,7 +16,10 @@ 


package android.app.time;



import static android.app.time.Capabilities.CAPABILITY_NOT_APPLICABLE;



import android.annotation.NonNull;

import android.annotation.Nullable;

import android.app.time.Capabilities.CapabilityState;

import android.os.Parcel;

import android.os.Parcelable;
@@ -54,40 +57,40 @@ public final class TimeCapabilities implements Parcelable { 
     */

    @NonNull

    private final UserHandle mUserHandle;

    private final @CapabilityState int mConfigureAutoTimeDetectionEnabledCapability;

    private final @CapabilityState int mSuggestTimeManuallyCapability;

    private final @CapabilityState int mConfigureAutoDetectionEnabledCapability;

    private final @CapabilityState int mSuggestManualTimeCapability;



    private TimeCapabilities(@NonNull Builder builder) {

        this.mUserHandle = Objects.requireNonNull(builder.mUserHandle);

        this.mConfigureAutoTimeDetectionEnabledCapability =

        this.mConfigureAutoDetectionEnabledCapability =

                builder.mConfigureAutoDetectionEnabledCapability;

        this.mSuggestTimeManuallyCapability =

                builder.mSuggestTimeManuallyCapability;

        this.mSuggestManualTimeCapability = builder.mSuggestManualTimeCapability;

    }



    @NonNull

    private static TimeCapabilities createFromParcel(Parcel in) {

        UserHandle userHandle = UserHandle.readFromParcel(in);

        return new TimeCapabilities.Builder(userHandle)

                .setConfigureAutoTimeDetectionEnabledCapability(in.readInt())

                .setSuggestTimeManuallyCapability(in.readInt())

                .setConfigureAutoDetectionEnabledCapability(in.readInt())

                .setSuggestManualTimeCapability(in.readInt())

                .build();

    }



    @Override

    public void writeToParcel(@NonNull Parcel dest, int flags) {

        UserHandle.writeToParcel(mUserHandle, dest);

        dest.writeInt(mConfigureAutoTimeDetectionEnabledCapability);

        dest.writeInt(mSuggestTimeManuallyCapability);

        dest.writeInt(mConfigureAutoDetectionEnabledCapability);

        dest.writeInt(mSuggestManualTimeCapability);

    }



    /**

     * Returns the capability state associated with the user's ability to modify the automatic time

     * detection setting.

     * detection setting. The setting can be updated via {@link

     * TimeManager#updateTimeConfiguration(TimeConfiguration)}.

     */

    @CapabilityState

    public int getConfigureAutoTimeDetectionEnabledCapability() {

        return mConfigureAutoTimeDetectionEnabledCapability;

    public int getConfigureAutoDetectionEnabledCapability() {

        return mConfigureAutoDetectionEnabledCapability;

    }



    /**
@@ -95,8 +98,31 @@ public final class TimeCapabilities implements Parcelable { 
     * device.

     */

    @CapabilityState

    public int getSuggestTimeManuallyCapability() {

        return mSuggestTimeManuallyCapability;

    public int getSuggestManualTimeCapability() {

        return mSuggestManualTimeCapability;

    }



    /**

     * Tries to create a new {@link TimeConfiguration} from the {@code config} and the set of

     * {@code requestedChanges}, if {@code this} capabilities allow. The new configuration is

     * returned. If the capabilities do not permit one or more of the requested changes then {@code

     * null} is returned.

     *

     * @hide

     */

    @Nullable

    public TimeConfiguration tryApplyConfigChanges(

            @NonNull TimeConfiguration config,

            @NonNull TimeConfiguration requestedChanges) {

        TimeConfiguration.Builder newConfigBuilder = new TimeConfiguration.Builder(config);

        if (requestedChanges.hasIsAutoDetectionEnabled()) {

            if (this.getConfigureAutoDetectionEnabledCapability() < CAPABILITY_NOT_APPLICABLE) {

                return null;

            }

            newConfigBuilder.setAutoDetectionEnabled(requestedChanges.isAutoDetectionEnabled());

        }



        return newConfigBuilder.build();

    }



    @Override
@@ -109,25 +135,25 @@ public final class TimeCapabilities implements Parcelable { 
        if (this == o) return true;

        if (o == null || getClass() != o.getClass()) return false;

        TimeCapabilities that = (TimeCapabilities) o;

        return mConfigureAutoTimeDetectionEnabledCapability

                == that.mConfigureAutoTimeDetectionEnabledCapability

                && mSuggestTimeManuallyCapability == that.mSuggestTimeManuallyCapability

        return mConfigureAutoDetectionEnabledCapability

                == that.mConfigureAutoDetectionEnabledCapability

                && mSuggestManualTimeCapability == that.mSuggestManualTimeCapability

                && mUserHandle.equals(that.mUserHandle);

    }



    @Override

    public int hashCode() {

        return Objects.hash(mUserHandle, mConfigureAutoTimeDetectionEnabledCapability,

                mSuggestTimeManuallyCapability);

        return Objects.hash(mUserHandle, mConfigureAutoDetectionEnabledCapability,

                mSuggestManualTimeCapability);

    }



    @Override

    public String toString() {

        return "TimeCapabilities{"

                + "mUserHandle=" + mUserHandle

                + ", mConfigureAutoTimeDetectionEnabledCapability="

                + mConfigureAutoTimeDetectionEnabledCapability

                + ", mSuggestTimeManuallyCapability=" + mSuggestTimeManuallyCapability

                + ", mConfigureAutoDetectionEnabledCapability="

                + mConfigureAutoDetectionEnabledCapability

                + ", mSuggestManualTimeCapability=" + mSuggestManualTimeCapability

                + '}';

    }
@@ -137,35 +163,32 @@ public final class TimeCapabilities implements Parcelable { 
     * @hide

     */

    public static class Builder {



        @NonNull private final UserHandle mUserHandle;

        private @CapabilityState int mConfigureAutoDetectionEnabledCapability;

        private @CapabilityState int mSuggestTimeManuallyCapability;

        private @CapabilityState int mSuggestManualTimeCapability;



        public Builder(@NonNull UserHandle userHandle) {

            this.mUserHandle = Objects.requireNonNull(userHandle);

        }



        public Builder(@NonNull TimeCapabilities timeCapabilities) {

            Objects.requireNonNull(timeCapabilities);

            this.mUserHandle = timeCapabilities.mUserHandle;

            this.mConfigureAutoDetectionEnabledCapability =

                    timeCapabilities.mConfigureAutoTimeDetectionEnabledCapability;

            this.mSuggestTimeManuallyCapability =

                    timeCapabilities.mSuggestTimeManuallyCapability;

        }



        public Builder(@NonNull UserHandle userHandle) {

            this.mUserHandle = Objects.requireNonNull(userHandle);

                    timeCapabilities.mConfigureAutoDetectionEnabledCapability;

            this.mSuggestManualTimeCapability = timeCapabilities.mSuggestManualTimeCapability;

        }



        /** Sets the state for automatic time detection config. */

        public Builder setConfigureAutoTimeDetectionEnabledCapability(

                @CapabilityState int setConfigureAutoTimeDetectionEnabledCapability) {

            this.mConfigureAutoDetectionEnabledCapability =

                    setConfigureAutoTimeDetectionEnabledCapability;

        public Builder setConfigureAutoDetectionEnabledCapability(@CapabilityState int value) {

            this.mConfigureAutoDetectionEnabledCapability = value;

            return this;

        }



        /** Sets the state for manual time change. */

        public Builder setSuggestTimeManuallyCapability(

                @CapabilityState int suggestTimeManuallyCapability) {

            this.mSuggestTimeManuallyCapability = suggestTimeManuallyCapability;

        public Builder setSuggestManualTimeCapability(@CapabilityState int value) {

            this.mSuggestManualTimeCapability = value;

            return this;

        }
@@ -173,7 +196,7 @@ public final class TimeCapabilities implements Parcelable { 
        public TimeCapabilities build() {

            verifyCapabilitySet(mConfigureAutoDetectionEnabledCapability,

                    "configureAutoDetectionEnabledCapability");

            verifyCapabilitySet(mSuggestTimeManuallyCapability, "suggestTimeManuallyCapability");

            verifyCapabilitySet(mSuggestManualTimeCapability, "mSuggestManualTimeCapability");

            return new TimeCapabilities(this);

        }

core/java/android/app/time/TimeConfiguration.java

+79 −21
Original line number Diff line number Diff line
@@ -27,8 +27,16 @@ import java.lang.annotation.RetentionPolicy; 
import java.util.Objects;



/**

 * User visible settings that control the behavior of the time zone detector / manual time zone

 * entry.

 * User visible settings that control the behavior of the time detector / manual time entry.

 *

 * <p>When reading the configuration, values for all settings will be provided. In some cases, such

 * as when the device behavior relies on optional hardware / OEM configuration, or the value of

 * several settings, the device behavior may not be directly affected by the setting value.

 *

 * <p>Settings can be left absent when updating configuration via {@link

 * TimeManager#updateTimeConfiguration(TimeConfiguration)} and those settings will not be

 * changed. Not all configuration settings can be modified by all users: see {@link

 * TimeManager#getTimeCapabilitiesAndConfig()} and {@link TimeCapabilities} for details.

 *

 * @hide

 */
@@ -61,29 +69,53 @@ public final class TimeConfiguration implements Parcelable { 
        this.mBundle = builder.mBundle;

    }



    private static TimeConfiguration readFromParcel(Parcel in) {

        return new TimeConfiguration.Builder()

                .setPropertyBundleInternal(in.readBundle())

                .build();

    }



    @Override

    public void writeToParcel(@NonNull Parcel dest, int flags) {

        dest.writeBundle(mBundle);

    }



    /**

     * Returns {@code true} if all known settings are present.

     *

     * @hide

     */

    public boolean isComplete() {

        return hasIsAutoDetectionEnabled();

    }



    /**

     * Returns the value of the {@link #SETTING_AUTO_DETECTION_ENABLED} setting. This

     * controls whether a device will attempt to determine the time automatically using

     * contextual information if the device supports auto detection.

     *

     * <p>See {@link TimeCapabilities#getConfigureAutoDetectionEnabledCapability()} for how to

     * tell if the setting is meaningful for the current user at this time.

     *

     * @throws IllegalStateException if the setting is not present

     */

    public boolean isAutoDetectionEnabled() {

        enforceSettingPresent(SETTING_AUTO_DETECTION_ENABLED);

        return mBundle.getBoolean(SETTING_AUTO_DETECTION_ENABLED);

    }



    @Override

    public int describeContents() {

        return 0;

    /**

     * Returns {@code true} if the {@link #isAutoDetectionEnabled()} setting is present.

     *

     * @hide

     */

    public boolean hasIsAutoDetectionEnabled() {

        return mBundle.containsKey(SETTING_AUTO_DETECTION_ENABLED);

    }



    @Override

    public void writeToParcel(@NonNull Parcel dest, int flags) {

        dest.writeBundle(mBundle);

    }



    private static TimeConfiguration readFromParcel(Parcel in) {

        return new TimeConfiguration.Builder()

                .merge(in.readBundle())

                .build();

    public int describeContents() {

        return 0;

    }



    @Override
@@ -106,33 +138,59 @@ public final class TimeConfiguration implements Parcelable { 
                + '}';

    }



    private void enforceSettingPresent(@TimeZoneConfiguration.Setting String setting) {

        if (!mBundle.containsKey(setting)) {

            throw new IllegalStateException(setting + " is not set");

        }

    }



    /**

     * A builder for {@link TimeConfiguration} objects.

     *

     * @hide

     */

    public static final class Builder {



        private final Bundle mBundle = new Bundle();



        /**

         * Creates a new Builder with no settings held.

         */

        public Builder() {}



        public Builder(@NonNull TimeConfiguration configuration) {

            mBundle.putAll(configuration.mBundle);

        /**

         * Creates a new Builder by copying the settings from an existing instance.

         */

        public Builder(@NonNull TimeConfiguration toCopy) {

            mergeProperties(toCopy);

        }



        /** Sets whether auto detection is enabled or not. */

        /**

         * Merges {@code other} settings into this instances, replacing existing values in this

         * where the settings appear in both.

         *

         * @hide

         */

        @NonNull

        public Builder setAutoDetectionEnabled(boolean enabled) {

            mBundle.putBoolean(SETTING_AUTO_DETECTION_ENABLED, enabled);

        public Builder mergeProperties(@NonNull TimeConfiguration toCopy) {

            mBundle.putAll(toCopy.mBundle);

            return this;

        }



        @NonNull

        Builder setPropertyBundleInternal(@NonNull Bundle bundle) {

            this.mBundle.putAll(bundle);

            return this;

        }



        Builder merge(@NonNull Bundle bundle) {

            mBundle.putAll(bundle);

        /** Sets whether auto detection is enabled or not. */

        @NonNull

        public Builder setAutoDetectionEnabled(boolean enabled) {

            mBundle.putBoolean(SETTING_AUTO_DETECTION_ENABLED, enabled);

            return this;

        }



        /** Returns {@link TimeConfiguration} object. */

        /** Returns the {@link TimeConfiguration}. */

        @NonNull

        public TimeConfiguration build() {

            return new TimeConfiguration(this);

core/tests/coretests/src/android/app/time/TimeCapabilitiesTest.java

+151 −29
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
package android.app.time;





import static android.app.time.Capabilities.CAPABILITY_NOT_ALLOWED;

import static android.app.time.Capabilities.CAPABILITY_NOT_APPLICABLE;

import static android.app.time.Capabilities.CAPABILITY_NOT_SUPPORTED;

import static android.app.time.Capabilities.CAPABILITY_POSSESSED;
@@ -24,6 +25,9 @@ import static android.app.timezonedetector.ParcelableTestSupport.assertRoundTrip 


import static com.google.common.truth.Truth.assertThat;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotEquals;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.fail;



import android.os.UserHandle;
@@ -38,22 +42,80 @@ import org.junit.runner.RunWith; 
@SmallTest

public class TimeCapabilitiesTest {



    private static final UserHandle USER_HANDLE = UserHandle.of(332211);

    private static final UserHandle TEST_USER_HANDLE = UserHandle.of(332211);



    @Test

    public void testEquals() {

        TimeCapabilities.Builder builder1 = new TimeCapabilities.Builder(TEST_USER_HANDLE)

                .setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)

                .setSuggestManualTimeCapability(CAPABILITY_POSSESSED);

        TimeCapabilities.Builder builder2 = new TimeCapabilities.Builder(TEST_USER_HANDLE)

                .setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)

                .setSuggestManualTimeCapability(CAPABILITY_POSSESSED);

        {

            TimeCapabilities one = builder1.build();

            TimeCapabilities two = builder2.build();

            assertEquals(one, two);

        }



        builder2.setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_ALLOWED);

        {

            TimeCapabilities one = builder1.build();

            TimeCapabilities two = builder2.build();

            assertNotEquals(one, two);

        }



        builder1.setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_ALLOWED);

        {

            TimeCapabilities one = builder1.build();

            TimeCapabilities two = builder2.build();

            assertEquals(one, two);

        }



        builder2.setSuggestManualTimeCapability(CAPABILITY_NOT_ALLOWED);

        {

            TimeCapabilities one = builder1.build();

            TimeCapabilities two = builder2.build();

            assertNotEquals(one, two);

        }



        builder1.setSuggestManualTimeCapability(CAPABILITY_NOT_ALLOWED);

        {

            TimeCapabilities one = builder1.build();

            TimeCapabilities two = builder2.build();

            assertEquals(one, two);

        }

    }



    @Test

    public void userHandle_notIgnoredInEquals() {

        TimeCapabilities firstUserCapabilities = new TimeCapabilities.Builder(UserHandle.of(1))

                .setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)

                .setSuggestManualTimeCapability(CAPABILITY_POSSESSED)

                .build();



        TimeCapabilities secondUserCapabilities = new TimeCapabilities.Builder(UserHandle.of(2))

                .setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)

                .setSuggestManualTimeCapability(CAPABILITY_POSSESSED)

                .build();



        assertThat(firstUserCapabilities).isNotEqualTo(secondUserCapabilities);

    }



    @Test

    public void testBuilder() {

        TimeCapabilities capabilities = new TimeCapabilities.Builder(USER_HANDLE)

                .setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_NOT_APPLICABLE)

                .setSuggestTimeManuallyCapability(CAPABILITY_NOT_SUPPORTED)

        TimeCapabilities capabilities = new TimeCapabilities.Builder(TEST_USER_HANDLE)

                .setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_APPLICABLE)

                .setSuggestManualTimeCapability(CAPABILITY_NOT_SUPPORTED)

                .build();



        assertThat(capabilities.getConfigureAutoTimeDetectionEnabledCapability())

        assertThat(capabilities.getConfigureAutoDetectionEnabledCapability())

                .isEqualTo(CAPABILITY_NOT_APPLICABLE);

        assertThat(capabilities.getSuggestTimeManuallyCapability())

        assertThat(capabilities.getSuggestManualTimeCapability())

                .isEqualTo(CAPABILITY_NOT_SUPPORTED);



        try {

            new TimeCapabilities.Builder(USER_HANDLE)

            new TimeCapabilities.Builder(TEST_USER_HANDLE)

                    .build();

            fail("Should throw IllegalStateException");

        } catch (IllegalStateException ignored) {
@@ -61,8 +123,8 @@ public class TimeCapabilitiesTest { 
        }



        try {

            new TimeCapabilities.Builder(USER_HANDLE)

                    .setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_NOT_APPLICABLE)

            new TimeCapabilities.Builder(TEST_USER_HANDLE)

                    .setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_APPLICABLE)

                    .build();

            fail("Should throw IllegalStateException");

        } catch (IllegalStateException ignored) {
@@ -70,8 +132,8 @@ public class TimeCapabilitiesTest { 
        }



        try {

            new TimeCapabilities.Builder(USER_HANDLE)

                    .setSuggestTimeManuallyCapability(CAPABILITY_NOT_APPLICABLE)

            new TimeCapabilities.Builder(TEST_USER_HANDLE)

                    .setSuggestManualTimeCapability(CAPABILITY_NOT_APPLICABLE)

                    .build();

            fail("Should throw IllegalStateException");

        } catch (IllegalStateException ignored) {
@@ -80,33 +142,93 @@ public class TimeCapabilitiesTest { 
    }



    @Test

    public void userHandle_notIgnoredInEquals() {

        TimeCapabilities firstUserCapabilities = new TimeCapabilities.Builder(UserHandle.of(1))

                .setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_POSSESSED)

                .setSuggestTimeManuallyCapability(CAPABILITY_POSSESSED)

    public void testParcelable() {

        TimeCapabilities.Builder builder = new TimeCapabilities.Builder(TEST_USER_HANDLE)

                .setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_SUPPORTED)

                .setSuggestManualTimeCapability(CAPABILITY_NOT_SUPPORTED);



        assertRoundTripParcelable(builder.build());



        builder.setSuggestManualTimeCapability(CAPABILITY_POSSESSED);

        assertRoundTripParcelable(builder.build());



        builder.setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED);

        assertRoundTripParcelable(builder.build());

    }



    @Test

    public void testTryApplyConfigChanges_permitted() {

        TimeConfiguration oldConfiguration =

                new TimeConfiguration.Builder()

                        .setAutoDetectionEnabled(true)

                        .build();

        TimeCapabilities capabilities = new TimeCapabilities.Builder(TEST_USER_HANDLE)

                .setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)

                .setSuggestManualTimeCapability(CAPABILITY_POSSESSED)

                .build();



        TimeCapabilities secondUserCapabilities = new TimeCapabilities.Builder(UserHandle.of(2))

                .setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_POSSESSED)

                .setSuggestTimeManuallyCapability(CAPABILITY_POSSESSED)

        TimeConfiguration configChange = new TimeConfiguration.Builder()

                .setAutoDetectionEnabled(false)

                .build();



        assertThat(firstUserCapabilities).isNotEqualTo(secondUserCapabilities);

        TimeConfiguration expected = new TimeConfiguration.Builder(oldConfiguration)

                .setAutoDetectionEnabled(false)

                .build();

        assertEquals(expected, capabilities.tryApplyConfigChanges(oldConfiguration, configChange));

    }



    @Test

    public void testParcelable() {

        TimeCapabilities.Builder builder = new TimeCapabilities.Builder(USER_HANDLE)

                .setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_NOT_SUPPORTED)

                .setSuggestTimeManuallyCapability(CAPABILITY_NOT_SUPPORTED);

    public void testTryApplyConfigChanges_notPermitted() {

        TimeConfiguration oldConfiguration =

                new TimeConfiguration.Builder()

                        .setAutoDetectionEnabled(true)

                        .build();

        TimeCapabilities capabilities = new TimeCapabilities.Builder(TEST_USER_HANDLE)

                .setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_ALLOWED)

                .setSuggestManualTimeCapability(CAPABILITY_NOT_ALLOWED)

                .build();



        assertRoundTripParcelable(builder.build());

        TimeConfiguration configChange = new TimeConfiguration.Builder()

                .setAutoDetectionEnabled(false)

                .build();



        builder.setSuggestTimeManuallyCapability(CAPABILITY_POSSESSED);

        assertRoundTripParcelable(builder.build());

        assertNull(capabilities.tryApplyConfigChanges(oldConfiguration, configChange));

    }



        builder.setConfigureAutoTimeDetectionEnabledCapability(CAPABILITY_POSSESSED);

        assertRoundTripParcelable(builder.build());

    @Test

    public void copyBuilder_copiesAllFields() {

        TimeCapabilities capabilities = new TimeCapabilities.Builder(TEST_USER_HANDLE)

                .setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_ALLOWED)

                .setSuggestManualTimeCapability(CAPABILITY_NOT_ALLOWED)

                .build();



        {

            TimeCapabilities updatedCapabilities =

                    new TimeCapabilities.Builder(capabilities)

                            .setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)

                            .build();

            TimeCapabilities expectedCapabilities =

                    new TimeCapabilities.Builder(TEST_USER_HANDLE)

                            .setConfigureAutoDetectionEnabledCapability(CAPABILITY_POSSESSED)

                            .setSuggestManualTimeCapability(CAPABILITY_NOT_ALLOWED)

                            .build();



            assertThat(updatedCapabilities).isEqualTo(expectedCapabilities);

        }



        {

            TimeCapabilities updatedCapabilities =

                    new TimeCapabilities.Builder(capabilities)

                            .setSuggestManualTimeCapability(CAPABILITY_POSSESSED)

                            .build();



            TimeCapabilities expectedCapabilities =

                    new TimeCapabilities.Builder(TEST_USER_HANDLE)

                            .setConfigureAutoDetectionEnabledCapability(CAPABILITY_NOT_ALLOWED)

                            .setSuggestManualTimeCapability(CAPABILITY_POSSESSED)

                            .build();



            assertThat(updatedCapabilities).isEqualTo(expectedCapabilities);

        }

    }

}