tests/tests/view/src/android/view/cts/View_UsingViewsTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2009 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.view.cts;

 import static com.android.compatibility.common.util.CtsMockitoUtils.within;

 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;

 import android.app.Activity;
 import android.app.Instrumentation;
 import android.graphics.Bitmap;
 import android.graphics.Color;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.widget.Button;
 import android.widget.EditText;
 import android.widget.RelativeLayout;
 import android.widget.TextView;

 import androidx.test.InstrumentationRegistry;
 import androidx.test.annotation.UiThreadTest;
 import androidx.test.filters.MediumTest;
 import androidx.test.rule.ActivityTestRule;
 import androidx.test.runner.AndroidJUnit4;

 import com.android.compatibility.common.util.CtsTouchUtils;

 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.invocation.InvocationOnMock;

 @MediumTest
 @RunWith(AndroidJUnit4.class)
 public class View_UsingViewsTest {
     /**
      * country of Argentina
      */
     private static final String ARGENTINA = "Argentina";

     /**
      * country of America
      */
     private static final String AMERICA = "America";

     /**
      * country of China
      */
     private static final String CHINA = "China";

     /**
      * the symbol of Argentina is football
      */
     private static final String ARGENTINA_SYMBOL = "football";

     /**
      * the symbol of America is basketball
      */
     private static final String AMERICA_SYMBOL = "basketball";

     /**
      * the symbol of China is table tennis
      */
     private static final String CHINA_SYMBOL = "table tennis";

     private Instrumentation mInstrumentation;
     private Activity mActivity;

     private EditText mEditText;
     private Button mButtonOk;
     private Button mButtonCancel;
     private TextView mSymbolTextView;
     private TextView mWarningTextView;

     @Rule
     public ActivityTestRule<UsingViewsCtsActivity> mActivityRule =
             new ActivityTestRule<>(UsingViewsCtsActivity.class);

     @Before
     public void setup() {
         mInstrumentation = InstrumentationRegistry.getInstrumentation();
         mActivity = mActivityRule.getActivity();

         mEditText = (EditText) mActivity.findViewById(R.id.entry);
         mButtonOk = (Button) mActivity.findViewById(R.id.ok);
         mButtonCancel = (Button) mActivity.findViewById(R.id.cancel);
         mSymbolTextView = (TextView) mActivity.findViewById(R.id.symbolball);
         mWarningTextView = (TextView) mActivity.findViewById(R.id.warning);
     }

     @UiThreadTest
     @Test
     public void testSetProperties() {
         // setClickable, setOnClickListener
         mButtonOk.setClickable(true);
         assertTrue(mButtonOk.isClickable());

         View.OnClickListener okButtonListener = spy(new MockOnClickOkListener());
         mButtonOk.setOnClickListener(okButtonListener);

         mButtonOk.performClick();
         verify(okButtonListener, times(1)).onClick(mButtonOk);

         mButtonCancel.setClickable(false);
         assertFalse(mButtonCancel.isClickable());

         View.OnClickListener cancelButtonListener = mock(View.OnClickListener.class);
         doAnswer((InvocationOnMock invocation) -> {
             mEditText.setText(null);
             return null;
         }).when(cancelButtonListener).onClick(any(View.class));
         mButtonCancel.setOnClickListener(cancelButtonListener);
         assertTrue(mButtonCancel.isClickable());

         mButtonCancel.performClick();
         verify(cancelButtonListener, times(1)).onClick(mButtonCancel);

         // setDrawingCacheEnabled, setDrawingCacheQuality, setDrawingCacheBackgroundColor,
         mEditText.setDrawingCacheEnabled(true);
         assertTrue(mEditText.isDrawingCacheEnabled());

         // the default quality is auto
         assertEquals(View.DRAWING_CACHE_QUALITY_AUTO, mEditText.getDrawingCacheQuality());
         mEditText.setDrawingCacheQuality(View.DRAWING_CACHE_QUALITY_LOW);
         assertEquals(View.DRAWING_CACHE_QUALITY_LOW, mEditText.getDrawingCacheQuality());
         mEditText.setDrawingCacheQuality(View.DRAWING_CACHE_QUALITY_HIGH);
         assertEquals(View.DRAWING_CACHE_QUALITY_HIGH, mEditText.getDrawingCacheQuality());

         mEditText.setDrawingCacheBackgroundColor(Color.GREEN);
         assertEquals(Color.GREEN, mEditText.getDrawingCacheBackgroundColor());

         // create the cache
         Bitmap b = mEditText.getDrawingCache();
         assertNotNull(b);
         assertEquals(mEditText.getHeight(), b.getHeight());
         assertEquals(mEditText.getWidth(), b.getWidth());
         assertEquals(Color.GREEN, b.getPixel(0, 0));

         // setDrawingCacheEnabled to false
         mEditText.setDrawingCacheEnabled(false);
         assertFalse(mEditText.isDrawingCacheEnabled());

         mEditText.setDrawingCacheBackgroundColor(Color.YELLOW);
         assertEquals(Color.YELLOW, mEditText.getDrawingCacheBackgroundColor());

         // build drawable cache
         mEditText.buildDrawingCache();
         b = mEditText.getDrawingCache();
         assertNotNull(b);
         assertEquals(mEditText.getHeight(), b.getHeight());
         assertEquals(mEditText.getWidth(), b.getWidth());
         assertEquals(Color.YELLOW, b.getPixel(0, 0));
         mEditText.destroyDrawingCache();

         // setDuplicateParentStateEnabled
         TextView v = new TextView(mActivity);
         v.setSingleLine(); // otherwise the multiline state interferes with theses tests
         v.setEnabled(false);
         v.setText("Test setDuplicateParentStateEnabled");

         v.setDuplicateParentStateEnabled(false);
         assertFalse(v.isDuplicateParentStateEnabled());

         RelativeLayout parent = (RelativeLayout) mEditText.getParent();
         parent.addView(v);

         assertFalse(parent.getDrawableState().length == v.getDrawableState().length);
         parent.removeView(v);

         v.setDuplicateParentStateEnabled(true);
         assertTrue(v.isDuplicateParentStateEnabled());

         parent.addView(v);
         v.refreshDrawableState();

         assertArrayEquals(parent.getDrawableState(), v.getDrawableState());
         parent.removeView(v);

         // setEnabled
         mWarningTextView.setEnabled(false);
         assertFalse(mWarningTextView.isEnabled());

         mWarningTextView.setEnabled(true);
         assertTrue(mWarningTextView.isEnabled());

         // setFadingEdgeLength, setVerticalFadingEdgeEnabled and
         // setHorizontalFadingEdgeEnabled(boolean)
         mWarningTextView.setVerticalFadingEdgeEnabled(true);
         assertTrue(mWarningTextView.isVerticalFadingEdgeEnabled());
         mWarningTextView.setFadingEdgeLength(10);

         mSymbolTextView.setHorizontalFadingEdgeEnabled(true);
         assertTrue(mSymbolTextView.isHorizontalFadingEdgeEnabled());
         mSymbolTextView.setFadingEdgeLength(100);

         // setFocusable and setFocusableInTouchMode
         mButtonCancel.setFocusable(false);
         assertFalse(mButtonCancel.isFocusable());
         assertFalse(mButtonCancel.isFocusableInTouchMode());

         mButtonCancel.setFocusable(true);
         assertTrue(mButtonCancel.isFocusable());
         assertFalse(mButtonCancel.isFocusableInTouchMode());

         mButtonCancel.setFocusableInTouchMode(true);
         assertTrue(mButtonCancel.isFocusable());
         assertTrue(mButtonCancel.isFocusableInTouchMode());

         mButtonOk.setFocusable(false);
         assertFalse(mButtonOk.isFocusable());
         assertFalse(mButtonOk.isFocusableInTouchMode());

         mButtonOk.setFocusableInTouchMode(true);
         assertTrue(mButtonOk.isFocusable());
         assertTrue(mButtonOk.isFocusableInTouchMode());

         // setHorizontalScrollBarEnabled and setVerticalScrollBarEnabled
         // both two bar is not drawn by default
         assertFalse(parent.isHorizontalScrollBarEnabled());
         assertFalse(parent.isVerticalScrollBarEnabled());

         parent.setHorizontalScrollBarEnabled(true);
         assertTrue(parent.isHorizontalScrollBarEnabled());

         parent.setVerticalScrollBarEnabled(true);
         assertTrue(parent.isVerticalScrollBarEnabled());

         // setId
         assertEquals(View.NO_ID, parent.getId());
         assertEquals(R.id.entry, mEditText.getId());
         assertEquals(R.id.symbolball, mSymbolTextView.getId());

         mSymbolTextView.setId(0x5555);
         assertEquals(0x5555, mSymbolTextView.getId());
         TextView t = (TextView) parent.findViewById(0x5555);
         assertSame(mSymbolTextView, t);

         mSymbolTextView.setId(R.id.symbolball);
         assertEquals(R.id.symbolball, mSymbolTextView.getId());
     }

     @UiThreadTest
     @Test
     public void testSetFocus() {
         boolean focusWasOnEditText = mEditText.hasFocus();

         View.OnFocusChangeListener editListener = mock(View.OnFocusChangeListener.class);
         View.OnFocusChangeListener okListener = mock(View.OnFocusChangeListener.class);
         View.OnFocusChangeListener cancelListener = mock(View.OnFocusChangeListener.class);
         View.OnFocusChangeListener symbolListener = mock(View.OnFocusChangeListener.class);
         View.OnFocusChangeListener warningListener = mock(View.OnFocusChangeListener.class);

         mEditText.setOnFocusChangeListener(editListener);
         mButtonOk.setOnFocusChangeListener(okListener);
         mButtonCancel.setOnFocusChangeListener(cancelListener);
         mSymbolTextView.setOnFocusChangeListener(symbolListener);
         mWarningTextView.setOnFocusChangeListener(warningListener);

         mSymbolTextView.setText(ARGENTINA_SYMBOL);
         mWarningTextView.setVisibility(View.VISIBLE);

         assertTrue(mEditText.requestFocus());
         assertTrue(mEditText.hasFocus());
         assertFalse(mButtonOk.hasFocus());
         assertFalse(mButtonCancel.hasFocus());
         assertFalse(mSymbolTextView.hasFocus());
         assertFalse(mWarningTextView.hasFocus());

         if (!focusWasOnEditText) {
             verify(editListener, times(1)).onFocusChange(mEditText, true);
         }
         verifyZeroInteractions(okListener);
         verifyZeroInteractions(cancelListener);
         verifyZeroInteractions(symbolListener);
         verifyZeroInteractions(warningListener);

         // set ok button to focus
         reset(editListener);
         assertTrue(mButtonOk.requestFocus());
         assertTrue(mButtonOk.hasFocus());
         verify(okListener, times(1)).onFocusChange(mButtonOk, true);
         assertFalse(mEditText.hasFocus());
         verify(editListener, times(1)).onFocusChange(mEditText, false);
         verifyZeroInteractions(cancelListener);
         verifyZeroInteractions(symbolListener);
         verifyZeroInteractions(warningListener);

         // set cancel button to focus
         reset(okListener);
         reset(editListener);
         assertTrue(mButtonCancel.requestFocus());
         assertTrue(mButtonCancel.hasFocus());
         verify(cancelListener, times(1)).onFocusChange(mButtonCancel, true);
         assertFalse(mButtonOk.hasFocus());
         verify(okListener, times(1)).onFocusChange(mButtonOk, false);
         verifyZeroInteractions(editListener);
         verifyZeroInteractions(symbolListener);
         verifyZeroInteractions(warningListener);

         // set symbol text to focus
         mSymbolTextView.setFocusable(true);
         assertTrue(mSymbolTextView.requestFocus());
         assertTrue(mSymbolTextView.hasFocus());
         verify(symbolListener, times(1)).onFocusChange(mSymbolTextView, true);
         assertFalse(mButtonCancel.hasFocus());
         verify(cancelListener, times(1)).onFocusChange(mButtonCancel, false);
         verifyZeroInteractions(okListener);
         verifyZeroInteractions(editListener);
         verifyZeroInteractions(warningListener);

         // set warning text to focus
         mWarningTextView.setFocusable(true);
         assertTrue(mWarningTextView.requestFocus());
         assertTrue(mWarningTextView.hasFocus());
         verify(warningListener, times(1)).onFocusChange(mWarningTextView, true);
         assertFalse(mSymbolTextView.hasFocus());
         verify(symbolListener, times(1)).onFocusChange(mSymbolTextView, false);
         verifyZeroInteractions(editListener);
         verifyZeroInteractions(okListener);
         verifyZeroInteractions(cancelListener);

         // set edit text to focus
         assertTrue(mEditText.requestFocus());
         assertTrue(mEditText.hasFocus());
         verify(editListener, times(1)).onFocusChange(mEditText, true);
         assertFalse(mWarningTextView.hasFocus());
         verify(warningListener, times(1)).onFocusChange(mWarningTextView, false);
         verifyZeroInteractions(cancelListener);
         verifyZeroInteractions(symbolListener);
         verifyZeroInteractions(okListener);
     }

     @Test
     public void testSetupListeners() throws Throwable {
         // set ok button OnClick listener
         mButtonOk.setClickable(true);
         assertTrue(mButtonOk.isClickable());

         View.OnClickListener okButtonListener = spy(new MockOnClickOkListener());
         mButtonOk.setOnClickListener(okButtonListener);

         // set cancel button OnClick listener
         mButtonCancel.setClickable(true);
         assertTrue(mButtonCancel.isClickable());

         View.OnClickListener cancelButtonListener = mock(View.OnClickListener.class);
         doAnswer((InvocationOnMock invocation) -> {
             mEditText.setText(null);
             return null;
         }).when(cancelButtonListener).onClick(any(View.class));
         mButtonCancel.setOnClickListener(cancelButtonListener);

         // set edit text OnLongClick listener
         mEditText.setLongClickable(true);
         assertTrue(mEditText.isLongClickable());

         final View.OnLongClickListener onLongClickListener =
                 mock(View.OnLongClickListener.class);
         mEditText.setOnLongClickListener(onLongClickListener);

         // long click the edit text
         mInstrumentation.waitForIdleSync();
         CtsTouchUtils.emulateLongPressOnViewCenter(mInstrumentation, mEditText);
         verify(onLongClickListener, within(1000)).onLongClick(mEditText);

         // click the Cancel button
         mActivityRule.runOnUiThread(() -> mEditText.setText("Germany"));
         mInstrumentation.waitForIdleSync();

         CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mButtonCancel);
         assertEquals("", mEditText.getText().toString());

         // click the OK button
         mActivityRule.runOnUiThread(() -> mEditText.setText(ARGENTINA));
         mInstrumentation.waitForIdleSync();

         CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mButtonOk);
         assertEquals(ARGENTINA_SYMBOL, mSymbolTextView.getText().toString());

         mActivityRule.runOnUiThread(() -> mEditText.setText(AMERICA));
         mInstrumentation.waitForIdleSync();

         CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mButtonOk);
         assertEquals(AMERICA_SYMBOL, mSymbolTextView.getText().toString());

         mActivityRule.runOnUiThread(() -> mEditText.setText(CHINA));
         mInstrumentation.waitForIdleSync();

         CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mButtonOk);
         assertEquals(CHINA_SYMBOL, mSymbolTextView.getText().toString());

         mActivityRule.runOnUiThread(() -> mEditText.setText("Unknown"));
         mInstrumentation.waitForIdleSync();

         CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mButtonOk);
         assertEquals(View.VISIBLE, mWarningTextView.getVisibility());
     }

     @UiThreadTest
     @Test
     public void testSetVisibility() {
         mActivity.setContentView(R.layout.view_visibility_layout);

         View v1 = mActivity.findViewById(R.id.textview1);
         View v2 = mActivity.findViewById(R.id.textview2);
         View v3 = mActivity.findViewById(R.id.textview3);

         assertNotNull(v1);
         assertNotNull(v2);
         assertNotNull(v3);

         assertEquals(View.VISIBLE, v1.getVisibility());
         assertEquals(View.INVISIBLE, v2.getVisibility());
         assertEquals(View.GONE, v3.getVisibility());

         v1.setVisibility(View.GONE);
         assertEquals(View.GONE, v1.getVisibility());

         v2.setVisibility(View.VISIBLE);
         assertEquals(View.VISIBLE, v2.getVisibility());

         v3.setVisibility(View.INVISIBLE);
         assertEquals(View.INVISIBLE, v3.getVisibility());
     }

     protected class MockOnClickOkListener implements OnClickListener {
         private boolean showPicture(String country) {
             if (ARGENTINA.equals(country)) {
                 mSymbolTextView.setText(ARGENTINA_SYMBOL);
                 return true;
             } else if (AMERICA.equals(country)) {
                 mSymbolTextView.setText(AMERICA_SYMBOL);
                 return true;
             } else if (CHINA.equals(country)) {
                 mSymbolTextView.setText(CHINA_SYMBOL);
                 return true;
             }

             return false;
         }

         public void onClick(View v) {
             String country = mEditText.getText().toString();
             if (!showPicture(country)) {
                 mWarningTextView.setVisibility(View.VISIBLE);
             } else if (View.VISIBLE == mWarningTextView.getVisibility()) {
                 mWarningTextView.setVisibility(View.INVISIBLE);
             }
         }
     }
 }
	/*
	* Copyright (C) 2009 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.view.cts;

	import static com.android.compatibility.common.util.CtsMockitoUtils.within;

	import static org.junit.Assert.assertArrayEquals;
	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertSame;
	import static org.junit.Assert.assertTrue;
	import static org.mockito.Matchers.any;
	import static org.mockito.Mockito.doAnswer;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.reset;
	import static org.mockito.Mockito.spy;
	import static org.mockito.Mockito.times;
	import static org.mockito.Mockito.verify;
	import static org.mockito.Mockito.verifyZeroInteractions;

	import android.app.Activity;
	import android.app.Instrumentation;
	import android.graphics.Bitmap;
	import android.graphics.Color;
	import android.view.View;
	import android.view.View.OnClickListener;
	import android.widget.Button;
	import android.widget.EditText;
	import android.widget.RelativeLayout;
	import android.widget.TextView;

	import androidx.test.InstrumentationRegistry;
	import androidx.test.annotation.UiThreadTest;
	import androidx.test.filters.MediumTest;
	import androidx.test.rule.ActivityTestRule;
	import androidx.test.runner.AndroidJUnit4;

	import com.android.compatibility.common.util.CtsTouchUtils;

	import org.junit.Before;
	import org.junit.Rule;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.mockito.invocation.InvocationOnMock;

	@MediumTest
	@RunWith(AndroidJUnit4.class)
	public class View_UsingViewsTest {
	/**
	* country of Argentina
	*/
	private static final String ARGENTINA = "Argentina";

	/**
	* country of America
	*/
	private static final String AMERICA = "America";

	/**
	* country of China
	*/
	private static final String CHINA = "China";

	/**
	* the symbol of Argentina is football
	*/
	private static final String ARGENTINA_SYMBOL = "football";

	/**
	* the symbol of America is basketball
	*/
	private static final String AMERICA_SYMBOL = "basketball";

	/**
	* the symbol of China is table tennis
	*/
	private static final String CHINA_SYMBOL = "table tennis";

	private Instrumentation mInstrumentation;
	private Activity mActivity;

	private EditText mEditText;
	private Button mButtonOk;
	private Button mButtonCancel;
	private TextView mSymbolTextView;
	private TextView mWarningTextView;

	@Rule
	public ActivityTestRule<UsingViewsCtsActivity> mActivityRule =
	new ActivityTestRule<>(UsingViewsCtsActivity.class);

	@Before
	public void setup() {
	mInstrumentation = InstrumentationRegistry.getInstrumentation();
	mActivity = mActivityRule.getActivity();

	mEditText = (EditText) mActivity.findViewById(R.id.entry);
	mButtonOk = (Button) mActivity.findViewById(R.id.ok);
	mButtonCancel = (Button) mActivity.findViewById(R.id.cancel);
	mSymbolTextView = (TextView) mActivity.findViewById(R.id.symbolball);
	mWarningTextView = (TextView) mActivity.findViewById(R.id.warning);
	}

	@UiThreadTest
	@Test
	public void testSetProperties() {
	// setClickable, setOnClickListener
	mButtonOk.setClickable(true);
	assertTrue(mButtonOk.isClickable());

	View.OnClickListener okButtonListener = spy(new MockOnClickOkListener());
	mButtonOk.setOnClickListener(okButtonListener);

	mButtonOk.performClick();
	verify(okButtonListener, times(1)).onClick(mButtonOk);

	mButtonCancel.setClickable(false);
	assertFalse(mButtonCancel.isClickable());

	View.OnClickListener cancelButtonListener = mock(View.OnClickListener.class);
	doAnswer((InvocationOnMock invocation) -> {
	mEditText.setText(null);
	return null;
	}).when(cancelButtonListener).onClick(any(View.class));
	mButtonCancel.setOnClickListener(cancelButtonListener);
	assertTrue(mButtonCancel.isClickable());

	mButtonCancel.performClick();
	verify(cancelButtonListener, times(1)).onClick(mButtonCancel);

	// setDrawingCacheEnabled, setDrawingCacheQuality, setDrawingCacheBackgroundColor,
	mEditText.setDrawingCacheEnabled(true);
	assertTrue(mEditText.isDrawingCacheEnabled());

	// the default quality is auto
	assertEquals(View.DRAWING_CACHE_QUALITY_AUTO, mEditText.getDrawingCacheQuality());
	mEditText.setDrawingCacheQuality(View.DRAWING_CACHE_QUALITY_LOW);
	assertEquals(View.DRAWING_CACHE_QUALITY_LOW, mEditText.getDrawingCacheQuality());
	mEditText.setDrawingCacheQuality(View.DRAWING_CACHE_QUALITY_HIGH);
	assertEquals(View.DRAWING_CACHE_QUALITY_HIGH, mEditText.getDrawingCacheQuality());

	mEditText.setDrawingCacheBackgroundColor(Color.GREEN);
	assertEquals(Color.GREEN, mEditText.getDrawingCacheBackgroundColor());

	// create the cache
	Bitmap b = mEditText.getDrawingCache();
	assertNotNull(b);
	assertEquals(mEditText.getHeight(), b.getHeight());
	assertEquals(mEditText.getWidth(), b.getWidth());
	assertEquals(Color.GREEN, b.getPixel(0, 0));

	// setDrawingCacheEnabled to false
	mEditText.setDrawingCacheEnabled(false);
	assertFalse(mEditText.isDrawingCacheEnabled());

	mEditText.setDrawingCacheBackgroundColor(Color.YELLOW);
	assertEquals(Color.YELLOW, mEditText.getDrawingCacheBackgroundColor());

	// build drawable cache
	mEditText.buildDrawingCache();
	b = mEditText.getDrawingCache();
	assertNotNull(b);
	assertEquals(mEditText.getHeight(), b.getHeight());
	assertEquals(mEditText.getWidth(), b.getWidth());
	assertEquals(Color.YELLOW, b.getPixel(0, 0));
	mEditText.destroyDrawingCache();

	// setDuplicateParentStateEnabled
	TextView v = new TextView(mActivity);
	v.setSingleLine(); // otherwise the multiline state interferes with theses tests
	v.setEnabled(false);
	v.setText("Test setDuplicateParentStateEnabled");

	v.setDuplicateParentStateEnabled(false);
	assertFalse(v.isDuplicateParentStateEnabled());

	RelativeLayout parent = (RelativeLayout) mEditText.getParent();
	parent.addView(v);

	assertFalse(parent.getDrawableState().length == v.getDrawableState().length);
	parent.removeView(v);

	v.setDuplicateParentStateEnabled(true);
	assertTrue(v.isDuplicateParentStateEnabled());

	parent.addView(v);
	v.refreshDrawableState();

	assertArrayEquals(parent.getDrawableState(), v.getDrawableState());
	parent.removeView(v);

	// setEnabled
	mWarningTextView.setEnabled(false);
	assertFalse(mWarningTextView.isEnabled());

	mWarningTextView.setEnabled(true);
	assertTrue(mWarningTextView.isEnabled());

	// setFadingEdgeLength, setVerticalFadingEdgeEnabled and
	// setHorizontalFadingEdgeEnabled(boolean)
	mWarningTextView.setVerticalFadingEdgeEnabled(true);
	assertTrue(mWarningTextView.isVerticalFadingEdgeEnabled());
	mWarningTextView.setFadingEdgeLength(10);

	mSymbolTextView.setHorizontalFadingEdgeEnabled(true);
	assertTrue(mSymbolTextView.isHorizontalFadingEdgeEnabled());
	mSymbolTextView.setFadingEdgeLength(100);

	// setFocusable and setFocusableInTouchMode
	mButtonCancel.setFocusable(false);
	assertFalse(mButtonCancel.isFocusable());
	assertFalse(mButtonCancel.isFocusableInTouchMode());

	mButtonCancel.setFocusable(true);
	assertTrue(mButtonCancel.isFocusable());
	assertFalse(mButtonCancel.isFocusableInTouchMode());

	mButtonCancel.setFocusableInTouchMode(true);
	assertTrue(mButtonCancel.isFocusable());
	assertTrue(mButtonCancel.isFocusableInTouchMode());

	mButtonOk.setFocusable(false);
	assertFalse(mButtonOk.isFocusable());
	assertFalse(mButtonOk.isFocusableInTouchMode());

	mButtonOk.setFocusableInTouchMode(true);
	assertTrue(mButtonOk.isFocusable());
	assertTrue(mButtonOk.isFocusableInTouchMode());

	// setHorizontalScrollBarEnabled and setVerticalScrollBarEnabled
	// both two bar is not drawn by default
	assertFalse(parent.isHorizontalScrollBarEnabled());
	assertFalse(parent.isVerticalScrollBarEnabled());

	parent.setHorizontalScrollBarEnabled(true);
	assertTrue(parent.isHorizontalScrollBarEnabled());

	parent.setVerticalScrollBarEnabled(true);
	assertTrue(parent.isVerticalScrollBarEnabled());

	// setId
	assertEquals(View.NO_ID, parent.getId());
	assertEquals(R.id.entry, mEditText.getId());
	assertEquals(R.id.symbolball, mSymbolTextView.getId());

	mSymbolTextView.setId(0x5555);
	assertEquals(0x5555, mSymbolTextView.getId());
	TextView t = (TextView) parent.findViewById(0x5555);
	assertSame(mSymbolTextView, t);

	mSymbolTextView.setId(R.id.symbolball);
	assertEquals(R.id.symbolball, mSymbolTextView.getId());
	}

	@UiThreadTest
	@Test
	public void testSetFocus() {
	boolean focusWasOnEditText = mEditText.hasFocus();

	View.OnFocusChangeListener editListener = mock(View.OnFocusChangeListener.class);
	View.OnFocusChangeListener okListener = mock(View.OnFocusChangeListener.class);
	View.OnFocusChangeListener cancelListener = mock(View.OnFocusChangeListener.class);
	View.OnFocusChangeListener symbolListener = mock(View.OnFocusChangeListener.class);
	View.OnFocusChangeListener warningListener = mock(View.OnFocusChangeListener.class);

	mEditText.setOnFocusChangeListener(editListener);
	mButtonOk.setOnFocusChangeListener(okListener);
	mButtonCancel.setOnFocusChangeListener(cancelListener);
	mSymbolTextView.setOnFocusChangeListener(symbolListener);
	mWarningTextView.setOnFocusChangeListener(warningListener);

	mSymbolTextView.setText(ARGENTINA_SYMBOL);
	mWarningTextView.setVisibility(View.VISIBLE);

	assertTrue(mEditText.requestFocus());
	assertTrue(mEditText.hasFocus());
	assertFalse(mButtonOk.hasFocus());
	assertFalse(mButtonCancel.hasFocus());
	assertFalse(mSymbolTextView.hasFocus());
	assertFalse(mWarningTextView.hasFocus());

	if (!focusWasOnEditText) {
	verify(editListener, times(1)).onFocusChange(mEditText, true);
	}
	verifyZeroInteractions(okListener);
	verifyZeroInteractions(cancelListener);
	verifyZeroInteractions(symbolListener);
	verifyZeroInteractions(warningListener);

	// set ok button to focus
	reset(editListener);
	assertTrue(mButtonOk.requestFocus());
	assertTrue(mButtonOk.hasFocus());
	verify(okListener, times(1)).onFocusChange(mButtonOk, true);
	assertFalse(mEditText.hasFocus());
	verify(editListener, times(1)).onFocusChange(mEditText, false);
	verifyZeroInteractions(cancelListener);
	verifyZeroInteractions(symbolListener);
	verifyZeroInteractions(warningListener);

	// set cancel button to focus
	reset(okListener);
	reset(editListener);
	assertTrue(mButtonCancel.requestFocus());
	assertTrue(mButtonCancel.hasFocus());
	verify(cancelListener, times(1)).onFocusChange(mButtonCancel, true);
	assertFalse(mButtonOk.hasFocus());
	verify(okListener, times(1)).onFocusChange(mButtonOk, false);
	verifyZeroInteractions(editListener);
	verifyZeroInteractions(symbolListener);
	verifyZeroInteractions(warningListener);

	// set symbol text to focus
	mSymbolTextView.setFocusable(true);
	assertTrue(mSymbolTextView.requestFocus());
	assertTrue(mSymbolTextView.hasFocus());
	verify(symbolListener, times(1)).onFocusChange(mSymbolTextView, true);
	assertFalse(mButtonCancel.hasFocus());
	verify(cancelListener, times(1)).onFocusChange(mButtonCancel, false);
	verifyZeroInteractions(okListener);
	verifyZeroInteractions(editListener);
	verifyZeroInteractions(warningListener);

	// set warning text to focus
	mWarningTextView.setFocusable(true);
	assertTrue(mWarningTextView.requestFocus());
	assertTrue(mWarningTextView.hasFocus());
	verify(warningListener, times(1)).onFocusChange(mWarningTextView, true);
	assertFalse(mSymbolTextView.hasFocus());
	verify(symbolListener, times(1)).onFocusChange(mSymbolTextView, false);
	verifyZeroInteractions(editListener);
	verifyZeroInteractions(okListener);
	verifyZeroInteractions(cancelListener);

	// set edit text to focus
	assertTrue(mEditText.requestFocus());
	assertTrue(mEditText.hasFocus());
	verify(editListener, times(1)).onFocusChange(mEditText, true);
	assertFalse(mWarningTextView.hasFocus());
	verify(warningListener, times(1)).onFocusChange(mWarningTextView, false);
	verifyZeroInteractions(cancelListener);
	verifyZeroInteractions(symbolListener);
	verifyZeroInteractions(okListener);
	}

	@Test
	public void testSetupListeners() throws Throwable {
	// set ok button OnClick listener
	mButtonOk.setClickable(true);
	assertTrue(mButtonOk.isClickable());

	View.OnClickListener okButtonListener = spy(new MockOnClickOkListener());
	mButtonOk.setOnClickListener(okButtonListener);

	// set cancel button OnClick listener
	mButtonCancel.setClickable(true);
	assertTrue(mButtonCancel.isClickable());

	View.OnClickListener cancelButtonListener = mock(View.OnClickListener.class);
	doAnswer((InvocationOnMock invocation) -> {
	mEditText.setText(null);
	return null;
	}).when(cancelButtonListener).onClick(any(View.class));
	mButtonCancel.setOnClickListener(cancelButtonListener);

	// set edit text OnLongClick listener
	mEditText.setLongClickable(true);
	assertTrue(mEditText.isLongClickable());

	final View.OnLongClickListener onLongClickListener =
	mock(View.OnLongClickListener.class);
	mEditText.setOnLongClickListener(onLongClickListener);

	// long click the edit text
	mInstrumentation.waitForIdleSync();
	CtsTouchUtils.emulateLongPressOnViewCenter(mInstrumentation, mEditText);
	verify(onLongClickListener, within(1000)).onLongClick(mEditText);

	// click the Cancel button
	mActivityRule.runOnUiThread(() -> mEditText.setText("Germany"));
	mInstrumentation.waitForIdleSync();

	CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mButtonCancel);
	assertEquals("", mEditText.getText().toString());

	// click the OK button
	mActivityRule.runOnUiThread(() -> mEditText.setText(ARGENTINA));
	mInstrumentation.waitForIdleSync();

	CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mButtonOk);
	assertEquals(ARGENTINA_SYMBOL, mSymbolTextView.getText().toString());

	mActivityRule.runOnUiThread(() -> mEditText.setText(AMERICA));
	mInstrumentation.waitForIdleSync();

	CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mButtonOk);
	assertEquals(AMERICA_SYMBOL, mSymbolTextView.getText().toString());

	mActivityRule.runOnUiThread(() -> mEditText.setText(CHINA));
	mInstrumentation.waitForIdleSync();

	CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mButtonOk);
	assertEquals(CHINA_SYMBOL, mSymbolTextView.getText().toString());

	mActivityRule.runOnUiThread(() -> mEditText.setText("Unknown"));
	mInstrumentation.waitForIdleSync();

	CtsTouchUtils.emulateTapOnViewCenter(mInstrumentation, mButtonOk);
	assertEquals(View.VISIBLE, mWarningTextView.getVisibility());
	}

	@UiThreadTest
	@Test
	public void testSetVisibility() {
	mActivity.setContentView(R.layout.view_visibility_layout);

	View v1 = mActivity.findViewById(R.id.textview1);
	View v2 = mActivity.findViewById(R.id.textview2);
	View v3 = mActivity.findViewById(R.id.textview3);

	assertNotNull(v1);
	assertNotNull(v2);
	assertNotNull(v3);

	assertEquals(View.VISIBLE, v1.getVisibility());
	assertEquals(View.INVISIBLE, v2.getVisibility());
	assertEquals(View.GONE, v3.getVisibility());

	v1.setVisibility(View.GONE);
	assertEquals(View.GONE, v1.getVisibility());

	v2.setVisibility(View.VISIBLE);
	assertEquals(View.VISIBLE, v2.getVisibility());

	v3.setVisibility(View.INVISIBLE);
	assertEquals(View.INVISIBLE, v3.getVisibility());
	}

	protected class MockOnClickOkListener implements OnClickListener {
	private boolean showPicture(String country) {
	if (ARGENTINA.equals(country)) {
	mSymbolTextView.setText(ARGENTINA_SYMBOL);
	return true;
	} else if (AMERICA.equals(country)) {
	mSymbolTextView.setText(AMERICA_SYMBOL);
	return true;
	} else if (CHINA.equals(country)) {
	mSymbolTextView.setText(CHINA_SYMBOL);
	return true;
	}

	return false;
	}

	public void onClick(View v) {
	String country = mEditText.getText().toString();
	if (!showPicture(country)) {
	mWarningTextView.setVisibility(View.VISIBLE);
	} else if (View.VISIBLE == mWarningTextView.getVisibility()) {
	mWarningTextView.setVisibility(View.INVISIBLE);
	}
	}
	}
	}