Merge "Use default network template in billing cycle settings."

    static final String KEY_SET_DATA_LIMIT = "set_data_limit";

    private static final String KEY_DATA_LIMIT = "data_limit";

    private NetworkTemplate mNetworkTemplate;

    @VisibleForTesting

    NetworkTemplate mNetworkTemplate;

    private Preference mBillingCycle;

    private Preference mDataWarning;

    private SwitchPreference mEnableDataWarning;

    public void onCreate(Bundle icicle) {

        super.onCreate(icicle);

        mDataUsageController = new DataUsageController(getContext());

        final Context context = getContext();

        mDataUsageController = new DataUsageController(context);

        Bundle args = getArguments();

        mNetworkTemplate = args.getParcelable(DataUsageList.EXTRA_NETWORK_TEMPLATE);

        if (mNetworkTemplate == null) {

            mNetworkTemplate = DataUsageUtils.getDefaultTemplate(context,

                DataUsageUtils.getDefaultSubscriptionId(context));

        }

        mBillingCycle = findPreference(KEY_BILLING_CYCLE);

        mEnableDataWarning = (SwitchPreference) findPreference(KEY_SET_DATA_WARNING);

            return SystemProperties.get(TEST_RADIOS_PROP).contains("wifi");

        }

        ConnectivityManager connectivityManager =

                context.getSystemService(ConnectivityManager.class);

        final ConnectivityManager connectivityManager = ConnectivityManager.from(context);

        return connectivityManager != null && connectivityManager.isNetworkSupported(TYPE_WIFI);

    }

package com.android.settings.datausage;

import static android.net.NetworkPolicy.CYCLE_NONE;

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

import static junit.framework.Assert.assertFalse;

import static junit.framework.Assert.assertTrue;

import static org.mockito.Matchers.any;

import static org.mockito.Matchers.anyInt;

import static org.mockito.Matchers.anyLong;

import static org.mockito.Matchers.anyObject;

import static org.mockito.Matchers.anyString;

import static org.mockito.Matchers.nullable;

import static org.mockito.Mockito.doNothing;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.verify;

import android.content.Context;

import android.content.DialogInterface;

import android.content.SharedPreferences;

import android.content.res.Resources;

import android.net.ConnectivityManager;

import android.net.NetworkPolicyManager;

import android.os.Bundle;

import androidx.fragment.app.FragmentActivity;

import androidx.preference.Preference;

import androidx.preference.PreferenceManager;

import androidx.preference.SwitchPreference;

import com.android.settings.testutils.SettingsRobolectricTestRunner;

import com.android.settingslib.NetworkPolicyEditor;

import com.android.settingslib.widget.FooterPreference;

import com.android.settingslib.widget.FooterPreferenceMixinCompat;

import org.junit.Before;

import org.junit.Test;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.robolectric.RuntimeEnvironment;

import org.robolectric.util.ReflectionHelpers;

@RunWith(SettingsRobolectricTestRunner.class)

public class BillingCycleSettingsTest {

    PreferenceManager mMockPreferenceManager;

    @Mock

    private NetworkPolicyEditor mNetworkPolicyEditor;

    @Mock

    private ConnectivityManager mConnectivityManager;

    @Mock

    private NetworkPolicyManager mNetworkPolicyManager;

    private Context mContext;

    @Mock

    public void testDataUsageLimit_shouldNotBeSetOnCancel() {

        mConfirmLimitFragment.onClick(null, DialogInterface.BUTTON_NEGATIVE);

        assertFalse(mSharedPreferences.getBoolean(BillingCycleSettings.KEY_SET_DATA_LIMIT, true));

        assertThat(mSharedPreferences.getBoolean(BillingCycleSettings.KEY_SET_DATA_LIMIT, true))

            .isFalse();

        verify(mMockBillingCycleSettings, never()).setPolicyLimitBytes(anyLong());

    }

    public void testDataUsageLimit_shouldBeSetOnConfirmation() {

        mConfirmLimitFragment.onClick(null, DialogInterface.BUTTON_POSITIVE);

        assertTrue(mSharedPreferences.getBoolean(BillingCycleSettings.KEY_SET_DATA_LIMIT, false));

        assertThat(mSharedPreferences.getBoolean(BillingCycleSettings.KEY_SET_DATA_LIMIT, false))

            .isTrue();

        verify(mMockBillingCycleSettings).setPolicyLimitBytes(LIMIT_BYTES);

    }

        verify(mBillingCycle).setSummary(null);

    }

    @Test

    public void onCreate_emptyArguments_shouldSetDefaultNetworkTemplate() {

        final BillingCycleSettings billingCycleSettings = spy(new BillingCycleSettings());

        when(billingCycleSettings.getContext()).thenReturn(mContext);

        when(billingCycleSettings.getArguments()).thenReturn(Bundle.EMPTY);

        final FragmentActivity activity = mock(FragmentActivity.class);

        when(billingCycleSettings.getActivity()).thenReturn(activity);

        final Resources.Theme theme = mContext.getTheme();

        when(activity.getTheme()).thenReturn(theme);

        doNothing().when(billingCycleSettings)

            .onCreatePreferences(any(Bundle.class), nullable(String.class));

        when(mContext.getSystemService(Context.NETWORK_POLICY_SERVICE))

            .thenReturn(mNetworkPolicyManager);

        when(mContext.getSystemService(Context.CONNECTIVITY_SERVICE))

            .thenReturn(mConnectivityManager);

        when(mConnectivityManager.isNetworkSupported(anyInt())).thenReturn(true);

        final SwitchPreference preference = mock(SwitchPreference.class);

        when(billingCycleSettings.findPreference(anyString())).thenReturn(preference);

        final FooterPreferenceMixinCompat footer = mock(FooterPreferenceMixinCompat.class);

        ReflectionHelpers.setField(billingCycleSettings, "mFooterPreferenceMixin", footer);

        when(footer.createFooterPreference()).thenReturn(mock(FooterPreference.class));

        billingCycleSettings.onCreate(Bundle.EMPTY);

        assertThat(billingCycleSettings.mNetworkTemplate).isNotNull();

    }

}

 No newline at end of file

        mActivity = spy(Robolectric.buildActivity(FragmentActivity.class).get());

        when(mActivity.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager);

        when(mActivity.getSystemService(ConnectivityManager.class))

        when(mActivity.getSystemService(Context.CONNECTIVITY_SERVICE))

                .thenReturn(mConnectivityManager);

        when(mTelephonyManager.getSimState()).thenReturn(TelephonyManager.SIM_STATE_READY);

        when(mConnectivityManager.isNetworkSupported(TYPE_WIFI)).thenReturn(false);