diff --git a/res/xml/terms_of_address.xml b/res/xml/terms_of_address.xml new file mode 100644 index 00000000000..a29a55c31a3 --- /dev/null +++ b/res/xml/terms_of_address.xml @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + + diff --git a/src/com/android/settings/localepicker/TermsOfAddressBaseController.java b/src/com/android/settings/localepicker/TermsOfAddressBaseController.java new file mode 100644 index 00000000000..34c502fe0dc --- /dev/null +++ b/src/com/android/settings/localepicker/TermsOfAddressBaseController.java @@ -0,0 +1,82 @@ +/** + * Copyright (C) 2023 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.settings.localepicker; + +import android.app.GrammaticalInflectionManager; +import android.content.Context; + +import androidx.preference.PreferenceScreen; + +import com.android.settings.core.BasePreferenceController; +import com.android.settings.overlay.FeatureFactory; +import com.android.settings.widget.TickButtonPreference; +import com.android.settingslib.core.instrumentation.MetricsFeatureProvider; + +public abstract class TermsOfAddressBaseController extends BasePreferenceController { + + private PreferenceScreen mPreferenceScreen; + private MetricsFeatureProvider mMetricsFeatureProvider; + private TickButtonPreference mPreference; + private GrammaticalInflectionManager mGrammaticalInflectionManager; + + public TermsOfAddressBaseController(Context context, String preferenceKey) { + super(context, preferenceKey); + mMetricsFeatureProvider = FeatureFactory.getFeatureFactory().getMetricsFeatureProvider(); + mGrammaticalInflectionManager = context.getSystemService( + GrammaticalInflectionManager.class); + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + mPreferenceScreen = screen; + mPreference = screen.findPreference(getPreferenceKey()); + mPreference.setOnPreferenceClickListener(clickedPref -> { + mGrammaticalInflectionManager.setSystemWideGrammaticalGender( + getGrammaticalGenderType()); + setSelected(mPreference); + mMetricsFeatureProvider.action(mContext, getMetricsActionKey()); + return true; + }); + updatePreferences(); + } + + private void setSelected(TickButtonPreference preference) { + for (int i = 1; i < mPreferenceScreen.getPreferenceCount(); i++) { + TickButtonPreference pref = (TickButtonPreference) mPreferenceScreen.getPreference(i); + pref.setSelected(pref.getKey().equals(preference.getKey())); + } + } + + private void updatePreferences() { + if (mPreference == null) { + return; + } + mPreference.setSelected( + mGrammaticalInflectionManager.getSystemGrammaticalGender() + == getGrammaticalGenderType()); + } + + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + + protected abstract int getMetricsActionKey(); + + protected abstract int getGrammaticalGenderType(); +} diff --git a/src/com/android/settings/localepicker/TermsOfAddressFeminineController.java b/src/com/android/settings/localepicker/TermsOfAddressFeminineController.java new file mode 100644 index 00000000000..9a46872641b --- /dev/null +++ b/src/com/android/settings/localepicker/TermsOfAddressFeminineController.java @@ -0,0 +1,45 @@ +/** + * Copyright (C) 2023 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.settings.localepicker; + +import android.app.settings.SettingsEnums; +import android.content.Context; +import android.content.res.Configuration; + +public class TermsOfAddressFeminineController extends TermsOfAddressBaseController { + + private static final String KEY_FEMININE = "key_terms_of_address_feminine"; + + public TermsOfAddressFeminineController(Context context, String preferenceKey) { + super(context, preferenceKey); + } + + @Override + public String getPreferenceKey() { + return KEY_FEMININE; + } + + @Override + protected int getMetricsActionKey() { + return SettingsEnums.ACTION_TERMS_OF_ADDRESS_FEMININE; + } + + @Override + protected int getGrammaticalGenderType() { + return Configuration.GRAMMATICAL_GENDER_FEMININE; + } +} diff --git a/src/com/android/settings/localepicker/TermsOfAddressMasculineController.java b/src/com/android/settings/localepicker/TermsOfAddressMasculineController.java new file mode 100644 index 00000000000..cb39df0c8f8 --- /dev/null +++ b/src/com/android/settings/localepicker/TermsOfAddressMasculineController.java @@ -0,0 +1,45 @@ +/** + * Copyright (C) 2023 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.settings.localepicker; + +import android.app.settings.SettingsEnums; +import android.content.Context; +import android.content.res.Configuration; + +public class TermsOfAddressMasculineController extends TermsOfAddressBaseController { + + private static final String KEY_MASCULINE = "key_terms_of_address_masculine"; + + public TermsOfAddressMasculineController(Context context, String preferenceKey) { + super(context, preferenceKey); + } + + @Override + public String getPreferenceKey() { + return KEY_MASCULINE; + } + + @Override + protected int getMetricsActionKey() { + return SettingsEnums.ACTION_TERMS_OF_ADDRESS_MASCULINE; + } + + @Override + protected int getGrammaticalGenderType() { + return Configuration.GRAMMATICAL_GENDER_MASCULINE; + } +} diff --git a/src/com/android/settings/localepicker/TermsOfAddressNeutralController.java b/src/com/android/settings/localepicker/TermsOfAddressNeutralController.java new file mode 100644 index 00000000000..e0693b5e74f --- /dev/null +++ b/src/com/android/settings/localepicker/TermsOfAddressNeutralController.java @@ -0,0 +1,45 @@ +/** + * Copyright (C) 2023 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.settings.localepicker; + +import android.app.settings.SettingsEnums; +import android.content.Context; +import android.content.res.Configuration; + +public class TermsOfAddressNeutralController extends TermsOfAddressBaseController { + + private static final String KEY_NEUTRAL = "key_terms_of_address_neutral"; + + public TermsOfAddressNeutralController(Context context, String preferenceKey) { + super(context, preferenceKey); + } + + @Override + public String getPreferenceKey() { + return KEY_NEUTRAL; + } + + @Override + protected int getMetricsActionKey() { + return SettingsEnums.ACTION_TERMS_OF_ADDRESS_NEUTRAL; + } + + @Override + protected int getGrammaticalGenderType() { + return Configuration.GRAMMATICAL_GENDER_NEUTRAL; + } +} diff --git a/src/com/android/settings/localepicker/TermsOfAddressNotSpecifiedController.java b/src/com/android/settings/localepicker/TermsOfAddressNotSpecifiedController.java new file mode 100644 index 00000000000..4e2e450d9e7 --- /dev/null +++ b/src/com/android/settings/localepicker/TermsOfAddressNotSpecifiedController.java @@ -0,0 +1,45 @@ +/** + * Copyright (C) 2023 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.settings.localepicker; + +import android.app.settings.SettingsEnums; +import android.content.Context; +import android.content.res.Configuration; + +public class TermsOfAddressNotSpecifiedController extends TermsOfAddressBaseController { + + private static final String KEY_NOT_SPECIFIED = "key_terms_of_address_not_specified"; + + public TermsOfAddressNotSpecifiedController(Context context, String preferenceKey) { + super(context, preferenceKey); + } + + @Override + public String getPreferenceKey() { + return KEY_NOT_SPECIFIED; + } + + @Override + protected int getMetricsActionKey() { + return SettingsEnums.ACTION_TERMS_OF_ADDRESS_NOT_SPECIFIED; + } + + @Override + protected int getGrammaticalGenderType() { + return Configuration.GRAMMATICAL_GENDER_NOT_SPECIFIED; + } +} diff --git a/tests/unit/src/com/android/settings/localepicker/TermsOfAddressFeminineControllerTest.java b/tests/unit/src/com/android/settings/localepicker/TermsOfAddressFeminineControllerTest.java new file mode 100644 index 00000000000..c04e5f92a63 --- /dev/null +++ b/tests/unit/src/com/android/settings/localepicker/TermsOfAddressFeminineControllerTest.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2023 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.settings.localepicker; + +import static com.google.common.truth.Truth.assertThat; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.spy; + +import android.content.Context; +import android.os.Looper; + +import com.android.settings.widget.TickButtonPreference; + +import androidx.preference.PreferenceManager; +import androidx.preference.Preference; +import androidx.preference.PreferenceCategory; +import androidx.preference.PreferenceScreen; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.MockitoAnnotations; + +@RunWith(AndroidJUnit4.class) +public class TermsOfAddressFeminineControllerTest { + + private static final String KEY_CATEGORY_TERMS_OF_ADDRESS = "key_category_terms_of_address"; + private static final String KEY_FEMININE = "key_terms_of_address_feminine"; + private static final String KEY_MASCULINE = "key_terms_of_address_masculine"; + private static final String KEY_NEUTRAL = "key_terms_of_address_neutral"; + private static final String KEY_NOT_SPECIFIED = "key_terms_of_address_not_specified"; + + private Context mContext; + private PreferenceManager mPreferenceManager; + private PreferenceCategory mPreferenceCategory; + private PreferenceScreen mPreferenceScreen; + private TermsOfAddressFeminineController mController; + private TickButtonPreference mFemininePreference; + private TickButtonPreference mMasculinePreference; + private TickButtonPreference mNotSpecifiedPreference; + private TickButtonPreference mNeutralPreference; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + mContext = spy(ApplicationProvider.getApplicationContext()); + + if (Looper.myLooper() == null) { + Looper.prepare(); + } + + mPreferenceManager = new PreferenceManager(mContext); + mPreferenceScreen = mPreferenceManager.createPreferenceScreen(mContext); + mPreferenceCategory = new PreferenceCategory(mContext); + mPreferenceCategory.setKey(KEY_CATEGORY_TERMS_OF_ADDRESS); + mNotSpecifiedPreference = new TickButtonPreference(mContext); + mNotSpecifiedPreference.setKey(KEY_NOT_SPECIFIED); + mFemininePreference = new TickButtonPreference(mContext); + mFemininePreference.setKey(KEY_FEMININE); + mMasculinePreference = new TickButtonPreference(mContext); + mMasculinePreference.setKey(KEY_MASCULINE); + mNeutralPreference = new TickButtonPreference(mContext); + mNeutralPreference.setKey(KEY_NEUTRAL); + mPreferenceScreen.addPreference(mPreferenceCategory); + mPreferenceScreen.addPreference(mNotSpecifiedPreference); + mPreferenceScreen.addPreference(mFemininePreference); + mPreferenceScreen.addPreference(mMasculinePreference); + mPreferenceScreen.addPreference(mNeutralPreference); + mController = new TermsOfAddressFeminineController(mContext, KEY_FEMININE); + mController.displayPreference(mPreferenceScreen); + } + + @Test + public void displayPreference_setGrammaticalGenderIsFeminine_FeminineIsSelected() { + TickButtonPreference selectedPreference = + (TickButtonPreference) mPreferenceScreen.getPreference(2); + TickButtonPreference pref = (TickButtonPreference) mPreferenceScreen.getPreference(1); + + selectedPreference.performClick(); + + assertThat(selectedPreference.getKey()).isEqualTo(KEY_FEMININE); + assertThat(selectedPreference.isSelected()).isTrue(); + assertThat(pref.isSelected()).isFalse(); + } +} diff --git a/tests/unit/src/com/android/settings/localepicker/TermsOfAddressMasculineControllerTest.java b/tests/unit/src/com/android/settings/localepicker/TermsOfAddressMasculineControllerTest.java new file mode 100644 index 00000000000..c2298be6faf --- /dev/null +++ b/tests/unit/src/com/android/settings/localepicker/TermsOfAddressMasculineControllerTest.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2023 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.settings.localepicker; + +import static com.google.common.truth.Truth.assertThat; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.spy; + +import android.content.Context; +import android.os.Looper; + +import com.android.settings.widget.TickButtonPreference; + +import androidx.preference.PreferenceManager; +import androidx.preference.Preference; +import androidx.preference.PreferenceCategory; +import androidx.preference.PreferenceScreen; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.MockitoAnnotations; + +@RunWith(AndroidJUnit4.class) +public class TermsOfAddressMasculineControllerTest { + + private static final String KEY_CATEGORY_TERMS_OF_ADDRESS = "key_category_terms_of_address"; + private static final String KEY_FEMININE = "key_terms_of_address_feminine"; + private static final String KEY_MASCULINE = "key_terms_of_address_masculine"; + private static final String KEY_NEUTRAL = "key_terms_of_address_neutral"; + private static final String KEY_NOT_SPECIFIED = "key_terms_of_address_not_specified"; + + private Context mContext; + private PreferenceManager mPreferenceManager; + private PreferenceCategory mPreferenceCategory; + private PreferenceScreen mPreferenceScreen; + private TermsOfAddressMasculineController mController; + private TickButtonPreference mFemininePreference; + private TickButtonPreference mMasculinePreference; + private TickButtonPreference mNotSpecifiedPreference; + private TickButtonPreference mNeutralPreference; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + mContext = spy(ApplicationProvider.getApplicationContext()); + + if (Looper.myLooper() == null) { + Looper.prepare(); + } + + mPreferenceManager = new PreferenceManager(mContext); + mPreferenceScreen = mPreferenceManager.createPreferenceScreen(mContext); + mPreferenceCategory = new PreferenceCategory(mContext); + mPreferenceCategory.setKey(KEY_CATEGORY_TERMS_OF_ADDRESS); + mNotSpecifiedPreference = new TickButtonPreference(mContext); + mNotSpecifiedPreference.setKey(KEY_NOT_SPECIFIED); + mFemininePreference = new TickButtonPreference(mContext); + mFemininePreference.setKey(KEY_FEMININE); + mMasculinePreference = new TickButtonPreference(mContext); + mMasculinePreference.setKey(KEY_MASCULINE); + mNeutralPreference = new TickButtonPreference(mContext); + mNeutralPreference.setKey(KEY_NEUTRAL); + mPreferenceScreen.addPreference(mPreferenceCategory); + mPreferenceScreen.addPreference(mNotSpecifiedPreference); + mPreferenceScreen.addPreference(mFemininePreference); + mPreferenceScreen.addPreference(mMasculinePreference); + mPreferenceScreen.addPreference(mNeutralPreference); + mController = new TermsOfAddressMasculineController(mContext, KEY_MASCULINE); + mController.displayPreference(mPreferenceScreen); + } + + @Test + public void displayPreference_setGrammaticalGenderIsMasculine_MasculineIsSelected() { + TickButtonPreference selectedPreference = + (TickButtonPreference) mPreferenceScreen.getPreference(3); + TickButtonPreference pref = (TickButtonPreference) mPreferenceScreen.getPreference(1); + + selectedPreference.performClick(); + + assertThat(selectedPreference.getKey()).isEqualTo(KEY_MASCULINE); + assertThat(selectedPreference.isSelected()).isTrue(); + assertThat(pref.isSelected()).isFalse(); + } +} diff --git a/tests/unit/src/com/android/settings/localepicker/TermsOfAddressNeutralControllerTest.java b/tests/unit/src/com/android/settings/localepicker/TermsOfAddressNeutralControllerTest.java new file mode 100644 index 00000000000..fb207fc8cfe --- /dev/null +++ b/tests/unit/src/com/android/settings/localepicker/TermsOfAddressNeutralControllerTest.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2023 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.settings.localepicker; + +import static com.google.common.truth.Truth.assertThat; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.spy; + +import android.content.Context; +import android.os.Looper; + +import com.android.settings.widget.TickButtonPreference; + +import androidx.preference.PreferenceManager; +import androidx.preference.Preference; +import androidx.preference.PreferenceCategory; +import androidx.preference.PreferenceScreen; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.MockitoAnnotations; + +@RunWith(AndroidJUnit4.class) +public class TermsOfAddressNeutralControllerTest { + + private static final String KEY_CATEGORY_TERMS_OF_ADDRESS = "key_category_terms_of_address"; + private static final String KEY_FEMININE = "key_terms_of_address_feminine"; + private static final String KEY_MASCULINE = "key_terms_of_address_masculine"; + private static final String KEY_NEUTRAL = "key_terms_of_address_neutral"; + private static final String KEY_NOT_SPECIFIED = "key_terms_of_address_not_specified"; + + private Context mContext; + private PreferenceManager mPreferenceManager; + private PreferenceCategory mPreferenceCategory; + private PreferenceScreen mPreferenceScreen; + private TermsOfAddressNeutralController mController; + private TickButtonPreference mFemininePreference; + private TickButtonPreference mMasculinePreference; + private TickButtonPreference mNotSpecifiedPreference; + private TickButtonPreference mNeutralPreference; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + mContext = spy(ApplicationProvider.getApplicationContext()); + + if (Looper.myLooper() == null) { + Looper.prepare(); + } + + mPreferenceManager = new PreferenceManager(mContext); + mPreferenceScreen = mPreferenceManager.createPreferenceScreen(mContext); + mPreferenceCategory = new PreferenceCategory(mContext); + mPreferenceCategory.setKey(KEY_CATEGORY_TERMS_OF_ADDRESS); + mNotSpecifiedPreference = new TickButtonPreference(mContext); + mNotSpecifiedPreference.setKey(KEY_NOT_SPECIFIED); + mFemininePreference = new TickButtonPreference(mContext); + mFemininePreference.setKey(KEY_FEMININE); + mMasculinePreference = new TickButtonPreference(mContext); + mMasculinePreference.setKey(KEY_MASCULINE); + mNeutralPreference = new TickButtonPreference(mContext); + mNeutralPreference.setKey(KEY_NEUTRAL); + mPreferenceScreen.addPreference(mPreferenceCategory); + mPreferenceScreen.addPreference(mNotSpecifiedPreference); + mPreferenceScreen.addPreference(mFemininePreference); + mPreferenceScreen.addPreference(mMasculinePreference); + mPreferenceScreen.addPreference(mNeutralPreference); + mController = new TermsOfAddressNeutralController(mContext, KEY_NEUTRAL); + mController.displayPreference(mPreferenceScreen); + } + + @Test + public void displayPreference_setGrammaticalGenderIsNotSpecified_NotSpecifiedIsSelected() { + TickButtonPreference selectedPreference = + (TickButtonPreference) mPreferenceScreen.getPreference(4); + TickButtonPreference pref = (TickButtonPreference) mPreferenceScreen.getPreference(1); + + selectedPreference.performClick(); + + assertThat(selectedPreference.getKey()).isEqualTo(KEY_NEUTRAL); + assertThat(selectedPreference.isSelected()).isTrue(); + assertThat(pref.isSelected()).isFalse(); + } +} diff --git a/tests/unit/src/com/android/settings/localepicker/TermsOfAddressNotSpecifiedControllerTest.java b/tests/unit/src/com/android/settings/localepicker/TermsOfAddressNotSpecifiedControllerTest.java new file mode 100644 index 00000000000..8492c3b37d3 --- /dev/null +++ b/tests/unit/src/com/android/settings/localepicker/TermsOfAddressNotSpecifiedControllerTest.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2023 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.settings.localepicker; + +import static com.google.common.truth.Truth.assertThat; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.spy; + +import android.content.Context; +import android.os.Looper; + +import com.android.settings.widget.TickButtonPreference; + +import androidx.preference.PreferenceManager; +import androidx.preference.Preference; +import androidx.preference.PreferenceCategory; +import androidx.preference.PreferenceScreen; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.MockitoAnnotations; + +@RunWith(AndroidJUnit4.class) +public class TermsOfAddressNotSpecifiedControllerTest { + + private static final String KEY_CATEGORY_TERMS_OF_ADDRESS = "key_category_terms_of_address"; + private static final String KEY_FEMININE = "key_terms_of_address_feminine"; + private static final String KEY_MASCULINE = "key_terms_of_address_masculine"; + private static final String KEY_NEUTRAL = "key_terms_of_address_neutral"; + private static final String KEY_NOT_SPECIFIED = "key_terms_of_address_not_specified"; + + private Context mContext; + private PreferenceManager mPreferenceManager; + private PreferenceCategory mPreferenceCategory; + private PreferenceScreen mPreferenceScreen; + private TermsOfAddressNotSpecifiedController mController; + private TickButtonPreference mFemininePreference; + private TickButtonPreference mMasculinePreference; + private TickButtonPreference mNotSpecifiedPreference; + private TickButtonPreference mNeutralPreference; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + mContext = spy(ApplicationProvider.getApplicationContext()); + + if (Looper.myLooper() == null) { + Looper.prepare(); + } + + mPreferenceManager = new PreferenceManager(mContext); + mPreferenceScreen = mPreferenceManager.createPreferenceScreen(mContext); + mPreferenceCategory = new PreferenceCategory(mContext); + mPreferenceCategory.setKey(KEY_CATEGORY_TERMS_OF_ADDRESS); + mNotSpecifiedPreference = new TickButtonPreference(mContext); + mNotSpecifiedPreference.setKey(KEY_NOT_SPECIFIED); + mFemininePreference = new TickButtonPreference(mContext); + mFemininePreference.setKey(KEY_FEMININE); + mMasculinePreference = new TickButtonPreference(mContext); + mMasculinePreference.setKey(KEY_MASCULINE); + mNeutralPreference = new TickButtonPreference(mContext); + mNeutralPreference.setKey(KEY_NEUTRAL); + mPreferenceScreen.addPreference(mPreferenceCategory); + mPreferenceScreen.addPreference(mNotSpecifiedPreference); + mPreferenceScreen.addPreference(mFemininePreference); + mPreferenceScreen.addPreference(mMasculinePreference); + mPreferenceScreen.addPreference(mNeutralPreference); + mController = new TermsOfAddressNotSpecifiedController(mContext, KEY_NOT_SPECIFIED); + mController.displayPreference(mPreferenceScreen); + } + + @Test + public void displayPreference_setGrammaticalGenderIsNotSpecified_NotSpecifiedIsSelected() { + TickButtonPreference selectedPreference = + (TickButtonPreference) mPreferenceScreen.getPreference(1); + TickButtonPreference pref = (TickButtonPreference) mPreferenceScreen.getPreference(2); + + selectedPreference.performClick(); + + assertThat(selectedPreference.getKey()).isEqualTo(KEY_NOT_SPECIFIED); + assertThat(selectedPreference.isSelected()).isTrue(); + assertThat(pref.isSelected()).isFalse(); + } +}