/*
 * Copyright (C) 2017 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 com.android.settingslib;

import static com.android.settingslib.Utils.STORAGE_MANAGER_ENABLED_PROPERTY;
import static com.android.settingslib.Utils.WIRELESS_CHARGING_DEFAULT_TIMESTAMP;
import static com.android.settingslib.Utils.shouldShowWirelessChargingWarningTip;
import static com.android.settingslib.Utils.updateWirelessChargingNotificationTimestamp;

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

import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;

import android.app.ActivityManager;
import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.hardware.usb.UsbManager;
import android.hardware.usb.UsbPort;
import android.hardware.usb.UsbPortStatus;
import android.hardware.usb.flags.Flags;
import android.location.LocationManager;
import android.media.AudioManager;
import android.os.BatteryManager;
import android.os.SystemProperties;
import android.os.UserHandle;
import android.platform.test.flag.junit.SetFlagsRule;
import android.provider.Settings;
import android.telephony.AccessNetworkConstants;
import android.telephony.NetworkRegistrationInfo;
import android.telephony.ServiceState;
import android.text.TextUtils;

import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatcher;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
import org.robolectric.shadows.ShadowSettings;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

@RunWith(RobolectricTestRunner.class)
@Config(shadows = {UtilsTest.ShadowLocationManager.class})
public class UtilsTest {
    private static final double[] TEST_PERCENTAGES = {0, 0.4, 0.5, 0.6, 49, 49.3, 49.8, 50, 100};
    private static final String TAG = "UtilsTest";
    private static final String PERCENTAGE_0 = "0%";
    private static final String PERCENTAGE_1 = "1%";
    private static final String PERCENTAGE_49 = "49%";
    private static final String PERCENTAGE_50 = "50%";
    private static final String PERCENTAGE_100 = "100%";
    private static final long CURRENT_TIMESTAMP = System.currentTimeMillis();

    private AudioManager mAudioManager;
    private Context mContext;
    @Mock private LocationManager mLocationManager;
    @Mock private ServiceState mServiceState;
    @Mock private NetworkRegistrationInfo mNetworkRegistrationInfo;
    @Mock private UsbPort mUsbPort;
    @Mock private UsbManager mUsbManager;
    @Mock private UsbPortStatus mUsbPortStatus;

    @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        mContext = spy(RuntimeEnvironment.application);
        when(mContext.getSystemService(Context.LOCATION_SERVICE)).thenReturn(mLocationManager);
        when(mContext.getSystemService(UsbManager.class)).thenReturn(mUsbManager);
        ShadowSettings.ShadowSecure.reset();
        mAudioManager = mContext.getSystemService(AudioManager.class);
    }

    @After
    public void reset() {
        Settings.Secure.putInt(
                mContext.getContentResolver(), Utils.INCOMPATIBLE_CHARGER_WARNING_DISABLED, 0);
    }

    @Test
    public void testUpdateLocationEnabled() {
        int currentUserId = ActivityManager.getCurrentUser();
        Utils.updateLocationEnabled(
                mContext, true, currentUserId, Settings.Secure.LOCATION_CHANGER_QUICK_SETTINGS);

        assertThat(
                        Settings.Secure.getInt(
                                mContext.getContentResolver(),
                                Settings.Secure.LOCATION_CHANGER,
                                Settings.Secure.LOCATION_CHANGER_UNKNOWN))
                .isEqualTo(Settings.Secure.LOCATION_CHANGER_QUICK_SETTINGS);
    }

    @Test
    public void testFormatPercentage_RoundTrue_RoundUpIfPossible() {
        final String[] expectedPercentages = {
            PERCENTAGE_0,
            PERCENTAGE_0,
            PERCENTAGE_1,
            PERCENTAGE_1,
            PERCENTAGE_49,
            PERCENTAGE_49,
            PERCENTAGE_50,
            PERCENTAGE_50,
            PERCENTAGE_100
        };

        for (int i = 0, size = TEST_PERCENTAGES.length; i < size; i++) {
            final String percentage = Utils.formatPercentage(TEST_PERCENTAGES[i], true);
            assertThat(percentage).isEqualTo(expectedPercentages[i]);
        }
    }

    @Test
    public void testFormatPercentage_RoundFalse_NoRound() {
        final String[] expectedPercentages = {
            PERCENTAGE_0,
            PERCENTAGE_0,
            PERCENTAGE_0,
            PERCENTAGE_0,
            PERCENTAGE_49,
            PERCENTAGE_49,
            PERCENTAGE_49,
            PERCENTAGE_50,
            PERCENTAGE_100
        };

        for (int i = 0, size = TEST_PERCENTAGES.length; i < size; i++) {
            final String percentage = Utils.formatPercentage(TEST_PERCENTAGES[i], false);
            assertThat(percentage).isEqualTo(expectedPercentages[i]);
        }
    }

    @Test
    public void testGetDefaultStorageManagerDaysToRetain_storageManagerDaysToRetainUsesResources() {
        Resources resources = mock(Resources.class);
        when(resources.getInteger(
                        eq(
                                com.android.internal.R.integer
                                        .config_storageManagerDaystoRetainDefault)))
                .thenReturn(60);
        assertThat(Utils.getDefaultStorageManagerDaysToRetain(resources)).isEqualTo(60);
    }

    @Test
    public void testIsStorageManagerEnabled_UsesSystemProperties() {
        SystemProperties.set(STORAGE_MANAGER_ENABLED_PROPERTY, "true");
        assertThat(Utils.isStorageManagerEnabled(mContext)).isTrue();
    }

    private static ArgumentMatcher<Intent> actionMatches(String expected) {
        return intent -> TextUtils.equals(expected, intent.getAction());
    }

    @Implements(value = LocationManager.class)
    public static class ShadowLocationManager {

        @Implementation
        public void setLocationEnabledForUser(boolean enabled, UserHandle userHandle) {
            // Do nothing
        }
    }

    @Test
    public void isAudioModeOngoingCall_modeInCommunication_returnTrue() {
        mAudioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);

        assertThat(Utils.isAudioModeOngoingCall(mContext)).isTrue();
    }

    @Test
    public void isAudioModeOngoingCall_modeInCall_returnTrue() {
        mAudioManager.setMode(AudioManager.MODE_IN_CALL);

        assertThat(Utils.isAudioModeOngoingCall(mContext)).isTrue();
    }

    @Test
    public void isAudioModeOngoingCall_modeRingtone_returnTrue() {
        mAudioManager.setMode(AudioManager.MODE_RINGTONE);

        assertThat(Utils.isAudioModeOngoingCall(mContext)).isTrue();
    }

    @Test
    public void isAudioModeOngoingCall_modeNormal_returnFalse() {
        mAudioManager.setMode(AudioManager.MODE_NORMAL);

        assertThat(Utils.isAudioModeOngoingCall(mContext)).isFalse();
    }

    @Test
    public void isInService_servicestateNull_returnFalse() {
        assertThat(Utils.isInService(null)).isFalse();
    }

    @Test
    public void isInService_voiceInService_returnTrue() {
        when(mServiceState.getVoiceRegState()).thenReturn(ServiceState.STATE_IN_SERVICE);

        assertThat(Utils.isInService(mServiceState)).isTrue();
    }

    @Test
    public void isInService_voiceOutOfServiceDataInService_returnTrue() {
        when(mServiceState.getVoiceRegState()).thenReturn(ServiceState.STATE_OUT_OF_SERVICE);
        when(mServiceState.getDataRegistrationState()).thenReturn(ServiceState.STATE_IN_SERVICE);
        when(mServiceState.getNetworkRegistrationInfo(
                        NetworkRegistrationInfo.DOMAIN_PS,
                        AccessNetworkConstants.TRANSPORT_TYPE_WWAN))
                .thenReturn(mNetworkRegistrationInfo);
        when(mNetworkRegistrationInfo.isInService()).thenReturn(true);

        assertThat(Utils.isInService(mServiceState)).isTrue();
    }

    @Test
    public void isInService_voiceOutOfServiceDataInServiceOnIwLan_returnFalse() {
        when(mServiceState.getVoiceRegState()).thenReturn(ServiceState.STATE_OUT_OF_SERVICE);
        when(mServiceState.getNetworkRegistrationInfo(
                        NetworkRegistrationInfo.DOMAIN_PS,
                        AccessNetworkConstants.TRANSPORT_TYPE_WLAN))
                .thenReturn(mNetworkRegistrationInfo);
        when(mServiceState.getDataRegistrationState()).thenReturn(ServiceState.STATE_IN_SERVICE);
        when(mNetworkRegistrationInfo.isInService()).thenReturn(true);

        assertThat(Utils.isInService(mServiceState)).isFalse();
    }

    @Test
    public void isInService_voiceOutOfServiceDataNull_returnFalse() {
        when(mServiceState.getVoiceRegState()).thenReturn(ServiceState.STATE_OUT_OF_SERVICE);
        when(mServiceState.getNetworkRegistrationInfo(
                        NetworkRegistrationInfo.DOMAIN_PS,
                        AccessNetworkConstants.TRANSPORT_TYPE_WWAN))
                .thenReturn(null);

        assertThat(Utils.isInService(mServiceState)).isFalse();
    }

    @Test
    public void isInService_voiceOutOfServiceDataOutOfService_returnFalse() {
        when(mServiceState.getVoiceRegState()).thenReturn(ServiceState.STATE_OUT_OF_SERVICE);
        when(mServiceState.getNetworkRegistrationInfo(
                        NetworkRegistrationInfo.DOMAIN_PS,
                        AccessNetworkConstants.TRANSPORT_TYPE_WWAN))
                .thenReturn(mNetworkRegistrationInfo);
        when(mNetworkRegistrationInfo.isInService()).thenReturn(false);

        assertThat(Utils.isInService(mServiceState)).isFalse();
    }

    @Test
    public void isInService_ServiceStatePowerOff_returnFalse() {
        when(mServiceState.getVoiceRegState()).thenReturn(ServiceState.STATE_POWER_OFF);

        assertThat(Utils.isInService(mServiceState)).isFalse();
    }

    @Test
    public void getCombinedServiceState_servicestateNull_returnOutOfService() {
        assertThat(Utils.getCombinedServiceState(null))
                .isEqualTo(ServiceState.STATE_OUT_OF_SERVICE);
    }

    @Test
    public void getCombinedServiceState_ServiceStatePowerOff_returnPowerOff() {
        when(mServiceState.getVoiceRegState()).thenReturn(ServiceState.STATE_POWER_OFF);

        assertThat(Utils.getCombinedServiceState(mServiceState))
                .isEqualTo(ServiceState.STATE_POWER_OFF);
    }

    @Test
    public void getCombinedServiceState_voiceInService_returnInService() {
        when(mServiceState.getVoiceRegState()).thenReturn(ServiceState.STATE_IN_SERVICE);

        assertThat(Utils.getCombinedServiceState(mServiceState))
                .isEqualTo(ServiceState.STATE_IN_SERVICE);
    }

    @Test
    public void getCombinedServiceState_voiceOutOfServiceDataInService_returnInService() {
        when(mServiceState.getVoiceRegState()).thenReturn(ServiceState.STATE_OUT_OF_SERVICE);
        when(mServiceState.getNetworkRegistrationInfo(
                        NetworkRegistrationInfo.DOMAIN_PS,
                        AccessNetworkConstants.TRANSPORT_TYPE_WWAN))
                .thenReturn(mNetworkRegistrationInfo);
        when(mNetworkRegistrationInfo.isInService()).thenReturn(true);

        assertThat(Utils.getCombinedServiceState(mServiceState))
                .isEqualTo(ServiceState.STATE_IN_SERVICE);
    }

    @Test
    public void getCombinedServiceState_voiceOutOfServiceDataInServiceOnIwLan_returnOutOfService() {
        when(mServiceState.getVoiceRegState()).thenReturn(ServiceState.STATE_OUT_OF_SERVICE);
        when(mServiceState.getNetworkRegistrationInfo(
                        NetworkRegistrationInfo.DOMAIN_PS,
                        AccessNetworkConstants.TRANSPORT_TYPE_WLAN))
                .thenReturn(mNetworkRegistrationInfo);
        when(mNetworkRegistrationInfo.isInService()).thenReturn(true);

        assertThat(Utils.getCombinedServiceState(mServiceState))
                .isEqualTo(ServiceState.STATE_OUT_OF_SERVICE);
    }

    @Test
    public void getCombinedServiceState_voiceOutOfServiceDataOutOfService_returnOutOfService() {
        when(mServiceState.getVoiceRegState()).thenReturn(ServiceState.STATE_OUT_OF_SERVICE);
        when(mServiceState.getDataRegistrationState())
                .thenReturn(ServiceState.STATE_OUT_OF_SERVICE);

        assertThat(Utils.getCombinedServiceState(mServiceState))
                .isEqualTo(ServiceState.STATE_OUT_OF_SERVICE);
    }

    @Test
    public void getBatteryStatus_statusIsFull_returnFullString() {
        final Intent intent =
                new Intent()
                        .putExtra(BatteryManager.EXTRA_LEVEL, 100)
                        .putExtra(BatteryManager.EXTRA_SCALE, 100);
        final Resources resources = mContext.getResources();

        assertThat(Utils.getBatteryStatus(mContext, intent, /* compactStatus= */ false))
                .isEqualTo(resources.getString(R.string.battery_info_status_full));
    }

    @Test
    public void getBatteryStatus_statusIsFullAndUseCompactStatus_returnFullyChargedString() {
        final Intent intent =
                new Intent()
                        .putExtra(BatteryManager.EXTRA_LEVEL, 100)
                        .putExtra(BatteryManager.EXTRA_SCALE, 100);
        final Resources resources = mContext.getResources();

        assertThat(Utils.getBatteryStatus(mContext, intent, /* compactStatus= */ true))
                .isEqualTo(resources.getString(R.string.battery_info_status_full_charged));
    }

    @Test
    public void getBatteryStatus_batteryLevelIs100_returnFullString() {
        final Intent intent =
                new Intent()
                        .putExtra(BatteryManager.EXTRA_STATUS, BatteryManager.BATTERY_STATUS_FULL);
        final Resources resources = mContext.getResources();

        assertThat(Utils.getBatteryStatus(mContext, intent, /* compactStatus= */ false))
                .isEqualTo(resources.getString(R.string.battery_info_status_full));
    }

    @Test
    public void getBatteryStatus_batteryLevelIs100AndUseCompactStatus_returnFullyString() {
        final Intent intent =
                new Intent()
                        .putExtra(BatteryManager.EXTRA_STATUS, BatteryManager.BATTERY_STATUS_FULL);
        final Resources resources = mContext.getResources();

        assertThat(Utils.getBatteryStatus(mContext, intent, /* compactStatus= */ true))
                .isEqualTo(resources.getString(R.string.battery_info_status_full_charged));
    }

    @Test
    public void getBatteryStatus_batteryLevel99_returnChargingString() {
        final Intent intent = new Intent();
        intent.putExtra(BatteryManager.EXTRA_STATUS, BatteryManager.BATTERY_STATUS_CHARGING);
        intent.putExtra(BatteryManager.EXTRA_PLUGGED, BatteryManager.BATTERY_PLUGGED_USB);
        final Resources resources = mContext.getResources();

        assertThat(Utils.getBatteryStatus(mContext, intent, /* compactStatus= */ false))
                .isEqualTo(resources.getString(R.string.battery_info_status_charging));
    }

    @Test
    public void getBatteryStatus_chargingDock_returnDockChargingString() {
        final Intent intent = new Intent();
        intent.putExtra(BatteryManager.EXTRA_STATUS, BatteryManager.BATTERY_STATUS_CHARGING);
        intent.putExtra(BatteryManager.EXTRA_PLUGGED, BatteryManager.BATTERY_PLUGGED_DOCK);
        final Resources resources = mContext.getResources();

        assertThat(Utils.getBatteryStatus(mContext, intent, /* compactStatus= */ false))
                .isEqualTo(resources.getString(R.string.battery_info_status_charging_dock));
    }

    @Test
    public void getBatteryStatus_chargingWireless_returnWirelessChargingString() {
        final Intent intent = new Intent();
        intent.putExtra(BatteryManager.EXTRA_STATUS, BatteryManager.BATTERY_STATUS_CHARGING);
        intent.putExtra(BatteryManager.EXTRA_PLUGGED, BatteryManager.BATTERY_PLUGGED_WIRELESS);
        final Resources resources = mContext.getResources();

        assertThat(Utils.getBatteryStatus(mContext, intent, /* compactStatus= */ false))
                .isEqualTo(resources.getString(R.string.battery_info_status_charging_wireless));
    }

    @Test
    public void getBatteryStatus_chargingAndUseCompactStatus_returnCompactString() {
        final Intent intent = new Intent();
        intent.putExtra(BatteryManager.EXTRA_STATUS, BatteryManager.BATTERY_STATUS_CHARGING);
        intent.putExtra(BatteryManager.EXTRA_PLUGGED, BatteryManager.BATTERY_PLUGGED_USB);
        final Resources resources = mContext.getResources();

        assertThat(Utils.getBatteryStatus(mContext, intent, /* compactStatus= */ true))
                .isEqualTo(resources.getString(R.string.battery_info_status_charging));
    }

    @Test
    public void getBatteryStatus_chargingWirelessAndUseCompactStatus_returnCompactString() {
        final Intent intent = new Intent();
        intent.putExtra(BatteryManager.EXTRA_STATUS, BatteryManager.BATTERY_STATUS_CHARGING);
        intent.putExtra(BatteryManager.EXTRA_PLUGGED, BatteryManager.BATTERY_PLUGGED_WIRELESS);
        final Resources resources = mContext.getResources();

        assertThat(Utils.getBatteryStatus(mContext, intent, /* compactStatus= */ true))
                .isEqualTo(resources.getString(R.string.battery_info_status_charging));
    }

    @Test
    public void containsIncompatibleChargers_nullPorts_returnFalse() {
        when(mUsbManager.getPorts()).thenReturn(null);
        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isFalse();
    }

    @Test
    public void containsIncompatibleChargers_emptyPorts_returnFalse() {
        when(mUsbManager.getPorts()).thenReturn(new ArrayList<>());
        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isFalse();
    }

    @Test
    public void containsIncompatibleChargers_nullPortStatus_returnFalse() {
        final List<UsbPort> usbPorts = new ArrayList<>();
        usbPorts.add(mUsbPort);
        when(mUsbManager.getPorts()).thenReturn(usbPorts);
        when(mUsbPort.getStatus()).thenReturn(null);

        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isFalse();
    }

    @Test
    public void containsIncompatibleChargers_complianeWarningOther_returnTrue_flagDisabled() {
        mSetFlagsRule.disableFlags(Flags.FLAG_ENABLE_USB_DATA_COMPLIANCE_WARNING);
        mSetFlagsRule.disableFlags(Flags.FLAG_ENABLE_INPUT_POWER_LIMITED_WARNING);
        setupIncompatibleCharging(UsbPortStatus.COMPLIANCE_WARNING_OTHER);

        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isTrue();
    }

    @Test
    public void containsIncompatibleChargers_complianeWarningPower_returnFalse_flagDisabled() {
        mSetFlagsRule.disableFlags(Flags.FLAG_ENABLE_USB_DATA_COMPLIANCE_WARNING);
        mSetFlagsRule.disableFlags(Flags.FLAG_ENABLE_INPUT_POWER_LIMITED_WARNING);
        setupIncompatibleCharging(UsbPortStatus.COMPLIANCE_WARNING_INPUT_POWER_LIMITED);

        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isFalse();
    }

    @Test
    public void containsIncompatibleChargers_complianeWarningOther_returnFalse_flagEnabled() {
        mSetFlagsRule.enableFlags(Flags.FLAG_ENABLE_USB_DATA_COMPLIANCE_WARNING);
        mSetFlagsRule.enableFlags(Flags.FLAG_ENABLE_INPUT_POWER_LIMITED_WARNING);
        setupIncompatibleCharging(UsbPortStatus.COMPLIANCE_WARNING_OTHER);

        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isFalse();
    }

    @Test
    public void containsIncompatibleChargers_complianeWarningPower_returnTrue_flagEnabled() {
        mSetFlagsRule.enableFlags(Flags.FLAG_ENABLE_USB_DATA_COMPLIANCE_WARNING);
        mSetFlagsRule.enableFlags(Flags.FLAG_ENABLE_INPUT_POWER_LIMITED_WARNING);
        setupIncompatibleCharging(UsbPortStatus.COMPLIANCE_WARNING_INPUT_POWER_LIMITED);

        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isTrue();
    }

    @Test
    public void containsIncompatibleChargers_complianeWarningDebug_returnTrue() {
        setupIncompatibleCharging(UsbPortStatus.COMPLIANCE_WARNING_DEBUG_ACCESSORY);
        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isTrue();
    }

    @Test
    public void containsIncompatibleChargers_unexpectedWarningType_returnFalse() {
        setupIncompatibleCharging(UsbPortStatus.COMPLIANCE_WARNING_BC_1_2);
        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isFalse();
    }

    @Test
    public void containsIncompatibleChargers_emptyComplianceWarnings_returnFalse() {
        setupIncompatibleCharging();
        when(mUsbPortStatus.getComplianceWarnings()).thenReturn(new int[1]);
        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isFalse();
    }

    @Test
    public void containsIncompatibleChargers_notSupportComplianceWarnings_returnFalse() {
        setupIncompatibleCharging();
        when(mUsbPort.supportsComplianceWarnings()).thenReturn(false);

        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isFalse();
    }

    @Test
    public void containsIncompatibleChargers_usbNotConnected_returnFalse() {
        setupIncompatibleCharging();
        when(mUsbPortStatus.isConnected()).thenReturn(false);

        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isFalse();
    }

    @Test
    public void containsIncompatibleChargers_disableWarning_returnFalse() {
        setupIncompatibleCharging();
        Settings.Secure.putInt(
                mContext.getContentResolver(), Utils.INCOMPATIBLE_CHARGER_WARNING_DISABLED, 1);

        assertThat(Utils.containsIncompatibleChargers(mContext, TAG)).isFalse();
    }

    @Test
    public void shouldShowWirelessChargingNotification_neverSendNotification_returnTrue() {
        updateWirelessChargingNotificationTimestamp(
                mContext, WIRELESS_CHARGING_DEFAULT_TIMESTAMP, TAG);

        assertThat(Utils.shouldShowWirelessChargingNotification(mContext, TAG)).isTrue();
    }

    @Test
    public void shouldShowNotification_neverSendNotification_updateTimestampAndEnabledState() {
        updateWirelessChargingNotificationTimestamp(
                mContext, WIRELESS_CHARGING_DEFAULT_TIMESTAMP, TAG);

        Utils.shouldShowWirelessChargingNotification(mContext, TAG);

        assertThat(getWirelessChargingNotificationTimestamp())
                .isNotEqualTo(WIRELESS_CHARGING_DEFAULT_TIMESTAMP);
        assertThat(shouldShowWirelessChargingWarningTip(mContext, TAG)).isTrue();
    }

    @Test
    public void shouldShowWirelessChargingNotification_notificationDisabled_returnFalse() {
        updateWirelessChargingNotificationTimestamp(mContext, CURRENT_TIMESTAMP, TAG);

        assertThat(Utils.shouldShowWirelessChargingNotification(mContext, TAG)).isFalse();
    }

    @Test
    public void shouldShowWirelessChargingNotification_withinTimeThreshold_returnFalse() {
        updateWirelessChargingNotificationTimestamp(mContext, CURRENT_TIMESTAMP, TAG);

        assertThat(Utils.shouldShowWirelessChargingNotification(mContext, TAG)).isFalse();
    }

    @Test
    public void shouldShowWirelessChargingNotification_exceedTimeThreshold_returnTrue() {
        final long monthAgo = Duration.ofDays(31).toMillis();
        final long timestamp = CURRENT_TIMESTAMP - monthAgo;
        updateWirelessChargingNotificationTimestamp(mContext, timestamp, TAG);

        assertThat(Utils.shouldShowWirelessChargingNotification(mContext, TAG)).isTrue();
    }

    @Test
    public void shouldShowNotification_exceedTimeThreshold_updateTimestampAndEnabledState() {
        final long monthAgo = Duration.ofDays(31).toMillis();
        final long timestamp = CURRENT_TIMESTAMP - monthAgo;
        updateWirelessChargingNotificationTimestamp(mContext, timestamp, TAG);

        Utils.shouldShowWirelessChargingNotification(mContext, TAG);

        assertThat(getWirelessChargingNotificationTimestamp()).isNotEqualTo(timestamp);
        assertThat(shouldShowWirelessChargingWarningTip(mContext, TAG)).isTrue();
    }

    @Test
    public void updateWirelessChargingNotificationTimestamp_dismissForever_setMinValue() {
        updateWirelessChargingNotificationTimestamp(mContext, Long.MIN_VALUE, TAG);

        assertThat(getWirelessChargingNotificationTimestamp()).isEqualTo(Long.MIN_VALUE);
    }

    @Test
    public void updateWirelessChargingNotificationTimestamp_notDismissForever_setTimestamp() {
        updateWirelessChargingNotificationTimestamp(mContext, CURRENT_TIMESTAMP, TAG);

        assertThat(getWirelessChargingNotificationTimestamp())
                .isNotEqualTo(WIRELESS_CHARGING_DEFAULT_TIMESTAMP);
        assertThat(getWirelessChargingNotificationTimestamp()).isNotEqualTo(Long.MIN_VALUE);
    }

    @Test
    public void shouldShowWirelessChargingWarningTip_enabled_returnTrue() {
        Utils.updateWirelessChargingWarningEnabled(mContext, true, TAG);

        assertThat(shouldShowWirelessChargingWarningTip(mContext, TAG)).isTrue();
    }

    @Test
    public void shouldShowWirelessChargingWarningTip_disabled_returnFalse() {
        Utils.updateWirelessChargingWarningEnabled(mContext, false, TAG);

        assertThat(shouldShowWirelessChargingWarningTip(mContext, TAG)).isFalse();
    }

    private void setupIncompatibleCharging() {
        setupIncompatibleCharging(UsbPortStatus.COMPLIANCE_WARNING_DEBUG_ACCESSORY);
    }

    private void setupIncompatibleCharging(int complianceWarningType) {
        final List<UsbPort> usbPorts = new ArrayList<>();
        usbPorts.add(mUsbPort);
        when(mUsbManager.getPorts()).thenReturn(usbPorts);
        when(mUsbPort.getStatus()).thenReturn(mUsbPortStatus);
        when(mUsbPort.supportsComplianceWarnings()).thenReturn(true);
        when(mUsbPortStatus.isConnected()).thenReturn(true);
        when(mUsbPortStatus.getComplianceWarnings()).thenReturn(new int[] {complianceWarningType});
    }

    private long getWirelessChargingNotificationTimestamp() {
        return Settings.Secure.getLong(
                mContext.getContentResolver(),
                Utils.WIRELESS_CHARGING_NOTIFICATION_TIMESTAMP,
                WIRELESS_CHARGING_DEFAULT_TIMESTAMP);
    }
}