Merge "Consolidate a11y unit tests and get them working" into oc-dev (101b1515) · Commits · e / os / android_frameworks_base

core/java/android/view/accessibility/AccessibilityManager.java

+22 −12

Original line number	Original line	Diff line number	Diff line
	@@ -41,6 +41,7 @@ import android.util.Log;
	import android.view.IWindow;		import android.view.IWindow;
	import android.view.View;		import android.view.View;

			import com.android.internal.annotations.VisibleForTesting;
	import com.android.internal.util.IntPair;		import com.android.internal.util.IntPair;

	import java.util.ArrayList;		import java.util.ArrayList;
	@@ -126,6 +127,8 @@ public final class AccessibilityManager {

	final Handler mHandler;		final Handler mHandler;

			final Handler.Callback mCallback;

	boolean mIsEnabled;		boolean mIsEnabled;

	int mRelevantEventTypes = AccessibilityEvent.TYPES_ALL_MASK;		int mRelevantEventTypes = AccessibilityEvent.TYPES_ALL_MASK;
	@@ -217,12 +220,12 @@ public final class AccessibilityManager {
	// is now off an exception will be thrown. We want to have the exception		// is now off an exception will be thrown. We want to have the exception
	// enforcement to guard against apps that fire unnecessary accessibility		// enforcement to guard against apps that fire unnecessary accessibility
	// events when accessibility is off.		// events when accessibility is off.
	mHandler.obtainMessage(MyHandler.MSG_SET_STATE, state, 0).sendToTarget();		mHandler.obtainMessage(MyCallback.MSG_SET_STATE, state, 0).sendToTarget();
	}		}

	@Override		@Override
	public void notifyServicesStateChanged() {		public void notifyServicesStateChanged() {
	mHandler.obtainMessage(MyHandler.MSG_NOTIFY_SERVICES_STATE_CHANGED).sendToTarget();		mHandler.obtainMessage(MyCallback.MSG_NOTIFY_SERVICES_STATE_CHANGED).sendToTarget();
	}		}

	@Override		@Override
	@@ -271,7 +274,8 @@ public final class AccessibilityManager {
	public AccessibilityManager(Context context, IAccessibilityManager service, int userId) {		public AccessibilityManager(Context context, IAccessibilityManager service, int userId) {
	// Constructor can't be chained because we can't create an instance of an inner class		// Constructor can't be chained because we can't create an instance of an inner class
	// before calling another constructor.		// before calling another constructor.
	mHandler = new MyHandler(context.getMainLooper());		mCallback = new MyCallback();
			mHandler = new Handler(context.getMainLooper(), mCallback);
	mUserId = userId;		mUserId = userId;
	synchronized (mLock) {		synchronized (mLock) {
	tryConnectToServiceLocked(service);		tryConnectToServiceLocked(service);
	@@ -288,6 +292,7 @@ public final class AccessibilityManager {
	* @hide		* @hide
	*/		*/
	public AccessibilityManager(Handler handler, IAccessibilityManager service, int userId) {		public AccessibilityManager(Handler handler, IAccessibilityManager service, int userId) {
			mCallback = new MyCallback();
	mHandler = handler;		mHandler = handler;
	mUserId = userId;		mUserId = userId;
	synchronized (mLock) {		synchronized (mLock) {
	@@ -302,6 +307,14 @@ public final class AccessibilityManager {
	return mClient;		return mClient;
	}		}

			/**
			* @hide
			*/
			@VisibleForTesting
			public Handler.Callback getCallback() {
			return mCallback;
			}

	/**		/**
	* Returns if the accessibility in the system is enabled.		* Returns if the accessibility in the system is enabled.
	*		*
	@@ -711,15 +724,15 @@ public final class AccessibilityManager {
	mIsHighTextContrastEnabled = highTextContrastEnabled;		mIsHighTextContrastEnabled = highTextContrastEnabled;

	if (wasEnabled != enabled) {		if (wasEnabled != enabled) {
	mHandler.sendEmptyMessage(MyHandler.MSG_NOTIFY_ACCESSIBILITY_STATE_CHANGED);		mHandler.sendEmptyMessage(MyCallback.MSG_NOTIFY_ACCESSIBILITY_STATE_CHANGED);
	}		}

	if (wasTouchExplorationEnabled != touchExplorationEnabled) {		if (wasTouchExplorationEnabled != touchExplorationEnabled) {
	mHandler.sendEmptyMessage(MyHandler.MSG_NOTIFY_EXPLORATION_STATE_CHANGED);		mHandler.sendEmptyMessage(MyCallback.MSG_NOTIFY_EXPLORATION_STATE_CHANGED);
	}		}

	if (wasHighTextContrastEnabled != highTextContrastEnabled) {		if (wasHighTextContrastEnabled != highTextContrastEnabled) {
	mHandler.sendEmptyMessage(MyHandler.MSG_NOTIFY_HIGH_TEXT_CONTRAST_STATE_CHANGED);		mHandler.sendEmptyMessage(MyCallback.MSG_NOTIFY_HIGH_TEXT_CONTRAST_STATE_CHANGED);
	}		}
	}		}

	@@ -960,19 +973,15 @@ public final class AccessibilityManager {
	}		}
	}		}

	private final class MyHandler extends Handler {		private final class MyCallback implements Handler.Callback {
	public static final int MSG_NOTIFY_ACCESSIBILITY_STATE_CHANGED = 1;		public static final int MSG_NOTIFY_ACCESSIBILITY_STATE_CHANGED = 1;
	public static final int MSG_NOTIFY_EXPLORATION_STATE_CHANGED = 2;		public static final int MSG_NOTIFY_EXPLORATION_STATE_CHANGED = 2;
	public static final int MSG_NOTIFY_HIGH_TEXT_CONTRAST_STATE_CHANGED = 3;		public static final int MSG_NOTIFY_HIGH_TEXT_CONTRAST_STATE_CHANGED = 3;
	public static final int MSG_SET_STATE = 4;		public static final int MSG_SET_STATE = 4;
	public static final int MSG_NOTIFY_SERVICES_STATE_CHANGED = 5;		public static final int MSG_NOTIFY_SERVICES_STATE_CHANGED = 5;

	public MyHandler(Looper looper) {
	super(looper, null, false);
	}

	@Override		@Override
	public void handleMessage(Message message) {		public boolean handleMessage(Message message) {
	switch (message.what) {		switch (message.what) {
	case MSG_NOTIFY_ACCESSIBILITY_STATE_CHANGED: {		case MSG_NOTIFY_ACCESSIBILITY_STATE_CHANGED: {
	handleNotifyAccessibilityStateChanged();		handleNotifyAccessibilityStateChanged();
	@@ -998,6 +1007,7 @@ public final class AccessibilityManager {
	}		}
	} break;		} break;
	}		}
			return true;
	}		}
	}		}
	}		}

services/tests/servicestests/AndroidManifest.xml

+0 −14

Original line number	Original line	Diff line number	Diff line
	@@ -52,20 +52,6 @@
	<application>		<application>
	<uses-library android:name="android.test.runner" />		<uses-library android:name="android.test.runner" />

	<service android:name="com.android.server.AccessibilityManagerServiceTest$MyFirstMockAccessibilityService"
	android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
	<intent-filter>
	<action android:name="android.accessibilityservice.AccessibilityService"/>
	</intent-filter>
	</service>

	<service android:name="com.android.server.AccessibilityManagerServiceTest$MySecondMockAccessibilityService"
	android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
	<intent-filter>
	<action android:name="android.accessibilityservice.AccessibilityService"/>
	</intent-filter>
	</service>

	<service android:name="com.android.server.accounts.TestAccountType1AuthenticatorService"		<service android:name="com.android.server.accounts.TestAccountType1AuthenticatorService"
	android:exported="false">		android:exported="false">
	<intent-filter>		<intent-filter>

services/tests/servicestests/src/com/android/server/AccessibilityManagerServiceTest.java

deleted100644 → 0

+0 −762

File deleted.

Preview size limit exceeded, changes collapsed.

services/tests/servicestests/src/com/android/server/MockAccessibilityService.java

deleted100644 → 0

+0 −256

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2010 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.server;

	import android.accessibilityservice.AccessibilityService;
	import android.accessibilityservice.AccessibilityServiceInfo;
	import android.content.Intent;
	import android.os.Message;
	import android.view.accessibility.AccessibilityEvent;

	import java.util.Iterator;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Queue;

	import junit.framework.TestCase;

	/**
	* This is the base class for mock {@link AccessibilityService}s.
	*/
	public abstract class MockAccessibilityService extends AccessibilityService {

	/**
	* The event this service expects to receive.
	*/
	private final Queue<AccessibilityEvent> mExpectedEvents = new LinkedList<AccessibilityEvent>();

	/**
	* Interruption call this service expects to receive.
	*/
	private boolean mExpectedInterrupt;

	/**
	* Flag if the mock is currently replaying.
	*/
	private boolean mReplaying;

	/**
	* Flag if the system is bound as a client to this service.
	*/
	private boolean mIsSystemBoundAsClient;

	/**
	* Creates an {@link AccessibilityServiceInfo} populated with default
	* values.
	*
	* @return The default info.
	*/
	public static AccessibilityServiceInfo createDefaultInfo() {
	AccessibilityServiceInfo defaultInfo = new AccessibilityServiceInfo();
	defaultInfo.eventTypes = AccessibilityEvent.TYPE_ANNOUNCEMENT;
	defaultInfo.feedbackType = AccessibilityServiceInfo.FEEDBACK_AUDIBLE;
	defaultInfo.flags = 0;
	defaultInfo.notificationTimeout = 0;
	defaultInfo.packageNames = new String[] {
	"foo.bar.baz"
	};

	return defaultInfo;
	}

	/**
	* Starts replaying the mock.
	*/
	public void replay() {
	mReplaying = true;
	}

	/**
	* Verifies if all expected service methods have been called.
	*/
	public void verify() {
	if (!mReplaying) {
	throw new IllegalStateException("Did you forget to call replay()");
	}

	if (mExpectedInterrupt) {
	throw new IllegalStateException("Expected call to #interrupt() not received");
	}
	if (!mExpectedEvents.isEmpty()) {
	throw new IllegalStateException("Expected a call to onAccessibilityEvent() for "
	+ "events \"" + mExpectedEvents + "\" not received");
	}
	}

	/**
	* Resets this instance so it can be reused.
	*/
	public void reset() {
	mExpectedEvents.clear();
	mExpectedInterrupt = false;
	mReplaying = false;
	}

	/**
	* Sets an expected call to
	* {@link #onAccessibilityEvent(AccessibilityEvent)} with given event as
	* argument.
	*
	* @param expectedEvent The expected event argument.
	*/
	public void expectEvent(AccessibilityEvent expectedEvent) {
	mExpectedEvents.add(expectedEvent);
	}

	/**
	* Sets an expected call of {@link #onInterrupt()}.
	*/
	public void expectInterrupt() {
	mExpectedInterrupt = true;
	}

	@Override
	public void onAccessibilityEvent(AccessibilityEvent receivedEvent) {
	if (!mReplaying) {
	return;
	}

	if (mExpectedEvents.isEmpty()) {
	throw new IllegalStateException("Unexpected event: " + receivedEvent);
	}

	AccessibilityEvent expectedEvent = mExpectedEvents.poll();
	assertEqualsAccessiblityEvent(expectedEvent, receivedEvent);
	}

	@Override
	public void onInterrupt() {
	if (!mReplaying) {
	return;
	}

	if (!mExpectedInterrupt) {
	throw new IllegalStateException("Unexpected call to onInterrupt()");
	}

	mExpectedInterrupt = false;
	}

	@Override
	protected void onServiceConnected() {
	mIsSystemBoundAsClient = true;
	}

	@Override
	public boolean onUnbind(Intent intent) {
	mIsSystemBoundAsClient = false;
	return false;
	}

	/**
	* Returns if the system is bound as client to this service.
	*
	* @return True if the system is bound, false otherwise.
	*/
	public boolean isSystemBoundAsClient() {
	return mIsSystemBoundAsClient;
	}

	/**
	* Compares all properties of the <code>expectedEvent</code> and the
	* <code>receviedEvent</code> to verify that the received event is the one
	* that is expected.
	*/
	private void assertEqualsAccessiblityEvent(AccessibilityEvent expectedEvent,
	AccessibilityEvent receivedEvent) {
	TestCase.assertEquals("addedCount has incorrect value", expectedEvent.getAddedCount(),
	receivedEvent.getAddedCount());
	TestCase.assertEquals("beforeText has incorrect value", expectedEvent.getBeforeText(),
	receivedEvent.getBeforeText());
	TestCase.assertEquals("checked has incorrect value", expectedEvent.isChecked(),
	receivedEvent.isChecked());
	TestCase.assertEquals("className has incorrect value", expectedEvent.getClassName(),
	receivedEvent.getClassName());
	TestCase.assertEquals("contentDescription has incorrect value", expectedEvent
	.getContentDescription(), receivedEvent.getContentDescription());
	TestCase.assertEquals("currentItemIndex has incorrect value", expectedEvent
	.getCurrentItemIndex(), receivedEvent.getCurrentItemIndex());
	TestCase.assertEquals("enabled has incorrect value", expectedEvent.isEnabled(),
	receivedEvent.isEnabled());
	TestCase.assertEquals("eventType has incorrect value", expectedEvent.getEventType(),
	receivedEvent.getEventType());
	TestCase.assertEquals("fromIndex has incorrect value", expectedEvent.getFromIndex(),
	receivedEvent.getFromIndex());
	TestCase.assertEquals("fullScreen has incorrect value", expectedEvent.isFullScreen(),
	receivedEvent.isFullScreen());
	TestCase.assertEquals("itemCount has incorrect value", expectedEvent.getItemCount(),
	receivedEvent.getItemCount());
	assertEqualsNotificationAsParcelableData(expectedEvent, receivedEvent);
	TestCase.assertEquals("password has incorrect value", expectedEvent.isPassword(),
	receivedEvent.isPassword());
	TestCase.assertEquals("removedCount has incorrect value", expectedEvent.getRemovedCount(),
	receivedEvent.getRemovedCount());
	assertEqualsText(expectedEvent, receivedEvent);
	}

	/**
	* Compares the {@link android.os.Parcelable} data of the
	* <code>expectedEvent</code> and <code>receivedEvent</code> to verify that
	* the received event is the one that is expected.
	*/
	private void assertEqualsNotificationAsParcelableData(AccessibilityEvent expectedEvent,
	AccessibilityEvent receivedEvent) {
	String message = "parcelableData has incorrect value";
	Message expectedMessage = (Message) expectedEvent.getParcelableData();
	Message receivedMessage = (Message) receivedEvent.getParcelableData();

	if (expectedMessage == null) {
	if (receivedMessage == null) {
	return;
	}
	}

	TestCase.assertNotNull(message, receivedMessage);

	// we do a very simple sanity check since we do not test Message
	TestCase.assertEquals(message, expectedMessage.what, receivedMessage.what);
	}

	/**
	* Compares the text of the <code>expectedEvent</code> and
	* <code>receivedEvent</code> by comparing the string representation of the
	* corresponding {@link CharSequence}s.
	*/
	private void assertEqualsText(AccessibilityEvent expectedEvent,
	AccessibilityEvent receivedEvent) {
	String message = "text has incorrect value";
	List<CharSequence> expectedText = expectedEvent.getText();
	List<CharSequence> receivedText = receivedEvent.getText();

	TestCase.assertEquals(message, expectedText.size(), receivedText.size());

	Iterator<CharSequence> expectedTextIterator = expectedText.iterator();
	Iterator<CharSequence> receivedTextIterator = receivedText.iterator();

	for (int i = 0; i < expectedText.size(); i++) {
	// compare the string representation
	TestCase.assertEquals(message, expectedTextIterator.next().toString(),
	receivedTextIterator.next().toString());
	}
	}
	}

services/tests/servicestests/src/com/android/server/AccessibilityManagerTest.java→services/tests/servicestests/src/com/android/server/accessibility/AccessibilityManagerTest.java

+66 −61

Original line number	Original line	Diff line number	Diff line
	@@ -14,18 +14,24 @@
	* limitations under the License.		* limitations under the License.
	*/		*/

	package com.android.server;		package com.android.server.accessibility;

			import static junit.framework.TestCase.assertFalse;
			import static junit.framework.TestCase.assertSame;
			import static org.junit.Assert.assertEquals;
			import static org.junit.Assert.assertTrue;
			import static org.junit.Assert.fail;
	import static org.mockito.Matchers.any;		import static org.mockito.Matchers.any;
	import static org.mockito.Matchers.anyInt;		import static org.mockito.Matchers.anyInt;
	import static org.mockito.Mockito.verify;		import static org.mockito.Mockito.verify;
	import static org.mockito.Mockito.when;		import static org.mockito.Mockito.when;

	import android.accessibilityservice.AccessibilityServiceInfo;		import android.accessibilityservice.AccessibilityServiceInfo;
			import android.app.Instrumentation;
			import android.os.Looper;
	import android.os.UserHandle;		import android.os.UserHandle;
	import android.test.AndroidTestCase;		import android.support.test.InstrumentationRegistry;
	import android.test.suitebuilder.annotation.LargeTest;		import android.support.test.runner.AndroidJUnit4;
	import android.test.suitebuilder.annotation.MediumTest;
	import android.view.accessibility.AccessibilityEvent;		import android.view.accessibility.AccessibilityEvent;
	import android.view.accessibility.AccessibilityManager;		import android.view.accessibility.AccessibilityManager;
	import android.view.accessibility.IAccessibilityManager;		import android.view.accessibility.IAccessibilityManager;
	@@ -33,6 +39,10 @@ import android.view.accessibility.IAccessibilityManagerClient;

	import com.android.internal.util.IntPair;		import com.android.internal.util.IntPair;

			import org.junit.Before;
			import org.junit.BeforeClass;
			import org.junit.Test;
			import org.junit.runner.RunWith;
	import org.mockito.Mock;		import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;		import org.mockito.MockitoAnnotations;

	@@ -40,44 +50,48 @@ import java.util.ArrayList;
	import java.util.List;		import java.util.List;

	/**		/**
	* Tests for the AccessibilityManager which mocking the backing service.		* Tests for the AccessibilityManager by mocking the backing service.
	*/		*/
	public class AccessibilityManagerTest extends AndroidTestCase {		@RunWith(AndroidJUnit4.class)
			public class AccessibilityManagerTest {
	/**		private static final boolean WITH_A11Y_ENABLED = true;
	* Timeout required for pending Binder calls or event processing to		private static final boolean WITH_A11Y_DISABLED = false;
	* complete.
	*/		@Mock private IAccessibilityManager mMockService;
	public static final long TIMEOUT_BINDER_CALL = 50;		private MessageCapturingHandler mHandler;
			private Instrumentation mInstrumentation;
	@Mock
	private IAccessibilityManager mMockService;		@BeforeClass
			public static void oneTimeInitialization() {
			if (Looper.myLooper() == null) {
			Looper.prepare();
			}
			}

	@Override		@Before
	public void setUp() throws Exception {		public void setUp() throws Exception {
	MockitoAnnotations.initMocks(this);		MockitoAnnotations.initMocks(this);
			mHandler = new MessageCapturingHandler(null);
			mInstrumentation = InstrumentationRegistry.getInstrumentation();
	}		}

	private AccessibilityManager createManager(boolean enabled) throws Exception {		private AccessibilityManager createManager(boolean enabled) throws Exception {
	if (enabled) {		long serviceReturnValue = IntPair.of(
			(enabled) ? AccessibilityManager.STATE_FLAG_ACCESSIBILITY_ENABLED : 0,
			AccessibilityEvent.TYPES_ALL_MASK);
	when(mMockService.addClient(any(IAccessibilityManagerClient.class), anyInt()))		when(mMockService.addClient(any(IAccessibilityManagerClient.class), anyInt()))
	.thenReturn(		.thenReturn(serviceReturnValue);
	IntPair.of(AccessibilityManager.STATE_FLAG_ACCESSIBILITY_ENABLED,
	AccessibilityEvent.TYPES_ALL_MASK));
	} else {
	when(mMockService.addClient(any(IAccessibilityManagerClient.class), anyInt()))
	.thenReturn(IntPair.of(0, AccessibilityEvent.TYPES_ALL_MASK));
	}

	AccessibilityManager manager =		AccessibilityManager manager =
	new AccessibilityManager(mContext, mMockService, UserHandle.USER_CURRENT);		new AccessibilityManager(mHandler, mMockService, UserHandle.USER_CURRENT);

	verify(mMockService).addClient(any(IAccessibilityManagerClient.class), anyInt());		verify(mMockService).addClient(any(IAccessibilityManagerClient.class), anyInt());
			mHandler.setCallback(manager.getCallback());
			mHandler.sendAllMessages();
	return manager;		return manager;
	}		}

	@MediumTest		@Test
	public void testGetAccessibilityServiceList() throws Exception {		public void testGetAccessibilityServiceList() throws Exception {
	// create a list of installed accessibility services the mock service returns		// create a list of installed accessibility services the mock service returns
	List<AccessibilityServiceInfo> expectedServices = new ArrayList<>();		List<AccessibilityServiceInfo> expectedServices = new ArrayList<>();
	@@ -99,53 +113,43 @@ public class AccessibilityManagerTest extends AndroidTestCase {
	assertEquals("All expected services must be returned", expectedServices, receivedServices);		assertEquals("All expected services must be returned", expectedServices, receivedServices);
	}		}

	@MediumTest		@Test
	public void testInterrupt() throws Exception {		public void testInterrupt() throws Exception {
	AccessibilityManager manager = createManager(true);		AccessibilityManager manager = createManager(WITH_A11Y_ENABLED);
	manager.interrupt();		manager.interrupt();

	verify(mMockService).interrupt(UserHandle.USER_CURRENT);		verify(mMockService).interrupt(UserHandle.USER_CURRENT);
	}		}

	@LargeTest		@Test
	public void testIsEnabled() throws Exception {		public void testIsEnabled() throws Exception {
	// invoke the method under test		// Create manager with a11y enabled
	AccessibilityManager manager = createManager(true);		AccessibilityManager manager = createManager(WITH_A11Y_ENABLED);
	boolean isEnabledServiceEnabled = manager.isEnabled();		assertTrue("Must be enabled since the mock service is enabled", manager.isEnabled());

	// check expected result
	assertTrue("Must be enabled since the mock service is enabled", isEnabledServiceEnabled);

	// disable accessibility		// Disable accessibility
	manager.getClient().setState(0);		manager.getClient().setState(0);
			mHandler.sendAllMessages();
	// wait for the asynchronous IBinder call to complete		assertFalse("Must be disabled since the mock service is disabled", manager.isEnabled());
	Thread.sleep(TIMEOUT_BINDER_CALL);

	// invoke the method under test
	boolean isEnabledServcieDisabled = manager.isEnabled();

	// check expected result
	assertFalse("Must be disabled since the mock service is disabled",
	isEnabledServcieDisabled);
	}		}

	@MediumTest		@Test
	public void testSendAccessibilityEvent_AccessibilityEnabled() throws Exception {		public void testSendAccessibilityEvent_AccessibilityEnabled() throws Exception {
	AccessibilityEvent sentEvent = AccessibilityEvent.obtain();		AccessibilityEvent sentEvent = AccessibilityEvent.obtain(
			AccessibilityEvent.TYPE_ANNOUNCEMENT);

	AccessibilityManager manager = createManager(true);		AccessibilityManager manager = createManager(WITH_A11Y_ENABLED);
	manager.sendAccessibilityEvent(sentEvent);		manager.sendAccessibilityEvent(sentEvent);

	assertSame("The event should be recycled.", sentEvent, AccessibilityEvent.obtain());		assertSame("The event should be recycled.", sentEvent, AccessibilityEvent.obtain());
	}		}

	@MediumTest		@Test
	public void testSendAccessibilityEvent_AccessibilityDisabled() throws Exception {		public void testSendAccessibilityEvent_AccessibilityDisabled() throws Exception {
	AccessibilityEvent sentEvent = AccessibilityEvent.obtain();		AccessibilityEvent sentEvent = AccessibilityEvent.obtain();

	AccessibilityManager manager = createManager(false /* disabled */);		AccessibilityManager manager = createManager(WITH_A11Y_DISABLED);
			mInstrumentation.runOnMainSync(() -> {
	try {		try {
	manager.sendAccessibilityEvent(sentEvent);		manager.sendAccessibilityEvent(sentEvent);
	fail("No accessibility events are sent if accessibility is disabled");		fail("No accessibility events are sent if accessibility is disabled");
	@@ -153,5 +157,6 @@ public class AccessibilityManagerTest extends AndroidTestCase {
	// check expected result		// check expected result
	assertEquals("Accessibility off. Did you forget to check that?", ise.getMessage());		assertEquals("Accessibility off. Did you forget to check that?", ise.getMessage());
	}		}
			});
	}		}
	}		}