Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7a6cc9b5 authored by Phil Weaver's avatar Phil Weaver
Browse files

Consolidate a11y unit tests and get them working 

Moving tests for accessibility manager into the a11y
directory and getting them to use some of the newer
test infrastructure. Minor tweaks to
AccessibilityManager to make it testable.

Deleting the AccessibilityManagerService tests entirely.
This class is difficult to unit test with the current
infrastructure, but is covered in CTS tests to a large
degree. I wasn't able to get these working quickly, and
they rely on timeouts that make them run much slower than
the other tests. They also throw exceptions when their
mock accessibility services receive accessibility events,
which causes the system to blacklist those services, causing
the tests to fail differently until the system is reset.
I think it's better to focus on writing new, more robust
tests than on rewriting these tests to pass.

Bug: 36614219
Test: A11y unit tests now work.
Change-Id: I8effe44f22110d55ebb700dc46f59b7e7a1aa946
(cherry picked from commit 9213d231)
parent c01dd791

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

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

import android.view.View;



import com.android.internal.annotations.VisibleForTesting;

import com.android.internal.util.IntPair;



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


    final Handler mHandler;



    final Handler.Callback mCallback;



    boolean mIsEnabled;



    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

            // enforcement to guard against apps that fire unnecessary accessibility

            // events when accessibility is off.

            mHandler.obtainMessage(MyHandler.MSG_SET_STATE, state, 0).sendToTarget();

            mHandler.obtainMessage(MyCallback.MSG_SET_STATE, state, 0).sendToTarget();

        }



        @Override

        public void notifyServicesStateChanged() {

            mHandler.obtainMessage(MyHandler.MSG_NOTIFY_SERVICES_STATE_CHANGED).sendToTarget();

            mHandler.obtainMessage(MyCallback.MSG_NOTIFY_SERVICES_STATE_CHANGED).sendToTarget();

        }



        @Override
@@ -271,7 +274,8 @@ public final class AccessibilityManager { 
    public AccessibilityManager(Context context, IAccessibilityManager service, int userId) {

        // Constructor can't be chained because we can't create an instance of an inner class

        // before calling another constructor.

        mHandler = new MyHandler(context.getMainLooper());

        mCallback = new MyCallback();

        mHandler = new Handler(context.getMainLooper(), mCallback);

        mUserId = userId;

        synchronized (mLock) {

            tryConnectToServiceLocked(service);
@@ -288,6 +292,7 @@ public final class AccessibilityManager { 
     * @hide

     */

    public AccessibilityManager(Handler handler, IAccessibilityManager service, int userId) {

        mCallback = new MyCallback();

        mHandler = handler;

        mUserId = userId;

        synchronized (mLock) {
@@ -302,6 +307,14 @@ public final class AccessibilityManager { 
        return mClient;

    }



    /**

     * @hide

     */

    @VisibleForTesting

    public Handler.Callback getCallback() {

        return mCallback;

    }



    /**

     * Returns if the accessibility in the system is enabled.

     *
@@ -711,15 +724,15 @@ public final class AccessibilityManager { 
        mIsHighTextContrastEnabled = highTextContrastEnabled;



        if (wasEnabled != enabled) {

            mHandler.sendEmptyMessage(MyHandler.MSG_NOTIFY_ACCESSIBILITY_STATE_CHANGED);

            mHandler.sendEmptyMessage(MyCallback.MSG_NOTIFY_ACCESSIBILITY_STATE_CHANGED);

        }



        if (wasTouchExplorationEnabled != touchExplorationEnabled) {

            mHandler.sendEmptyMessage(MyHandler.MSG_NOTIFY_EXPLORATION_STATE_CHANGED);

            mHandler.sendEmptyMessage(MyCallback.MSG_NOTIFY_EXPLORATION_STATE_CHANGED);

        }



        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_EXPLORATION_STATE_CHANGED = 2;

        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_NOTIFY_SERVICES_STATE_CHANGED = 5;



        public MyHandler(Looper looper) {

            super(looper, null, false);

        }



        @Override

        public void handleMessage(Message message) {

        public boolean handleMessage(Message message) {

            switch (message.what) {

                case MSG_NOTIFY_ACCESSIBILITY_STATE_CHANGED: {

                    handleNotifyAccessibilityStateChanged();
@@ -998,6 +1007,7 @@ public final class AccessibilityManager { 
                    }

                } break;

            }

            return true;

        }

    }

}

services/tests/servicestests/AndroidManifest.xml

+0 −14
Original line number Diff line number Diff line
@@ -52,20 +52,6 @@ 
    <application>

        <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"

            android:exported="false">

          <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 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 Diff line number Diff line
@@ -14,18 +14,24 @@ 
 * 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.anyInt;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.accessibilityservice.AccessibilityServiceInfo;

import android.app.Instrumentation;

import android.os.Looper;

import android.os.UserHandle;

import android.test.AndroidTestCase;

import android.test.suitebuilder.annotation.LargeTest;

import android.test.suitebuilder.annotation.MediumTest;

import android.support.test.InstrumentationRegistry;

import android.support.test.runner.AndroidJUnit4;

import android.view.accessibility.AccessibilityEvent;

import android.view.accessibility.AccessibilityManager;

import android.view.accessibility.IAccessibilityManager;
@@ -33,6 +39,10 @@ import android.view.accessibility.IAccessibilityManagerClient; 


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.MockitoAnnotations;
@@ -40,44 +50,48 @@ import java.util.ArrayList; 
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 {



    /**

     * Timeout required for pending Binder calls or event processing to

     * complete.

     */

    public static final long TIMEOUT_BINDER_CALL = 50;



    @Mock

    private IAccessibilityManager mMockService;

@RunWith(AndroidJUnit4.class)

public class AccessibilityManagerTest {

    private static final boolean WITH_A11Y_ENABLED = true;

    private static final boolean WITH_A11Y_DISABLED = false;



    @Mock private IAccessibilityManager mMockService;

    private MessageCapturingHandler mHandler;

    private Instrumentation mInstrumentation;



    @BeforeClass

    public static void oneTimeInitialization() {

        if (Looper.myLooper() == null) {

            Looper.prepare();

        }

    }



    @Override

    @Before

    public void setUp() throws Exception {

        MockitoAnnotations.initMocks(this);

        mHandler = new MessageCapturingHandler(null);

        mInstrumentation = InstrumentationRegistry.getInstrumentation();

    }



    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()))

                    .thenReturn(

                            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));

        }

                .thenReturn(serviceReturnValue);



        AccessibilityManager manager =

                new AccessibilityManager(mContext, mMockService, UserHandle.USER_CURRENT);

                new AccessibilityManager(mHandler, mMockService, UserHandle.USER_CURRENT);



        verify(mMockService).addClient(any(IAccessibilityManagerClient.class), anyInt());



        mHandler.setCallback(manager.getCallback());

        mHandler.sendAllMessages();

        return manager;

    }



    @MediumTest

    @Test

    public void testGetAccessibilityServiceList() throws Exception {

        // create a list of installed accessibility services the mock service returns

        List<AccessibilityServiceInfo> expectedServices = new ArrayList<>();
@@ -99,53 +113,43 @@ public class AccessibilityManagerTest extends AndroidTestCase { 
        assertEquals("All expected services must be returned", expectedServices, receivedServices);

    }



    @MediumTest

    @Test

    public void testInterrupt() throws Exception {

        AccessibilityManager manager = createManager(true);

        AccessibilityManager manager = createManager(WITH_A11Y_ENABLED);

        manager.interrupt();



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

    }



    @LargeTest

    @Test

    public void testIsEnabled() throws Exception {

        // invoke the method under test

        AccessibilityManager manager = createManager(true);

        boolean isEnabledServiceEnabled = manager.isEnabled();



        // check expected result

        assertTrue("Must be enabled since the mock service is enabled", isEnabledServiceEnabled);

        // Create manager with a11y enabled

        AccessibilityManager manager = createManager(WITH_A11Y_ENABLED);

        assertTrue("Must be enabled since the mock service is enabled", manager.isEnabled());



        // disable accessibility

        // Disable accessibility

        manager.getClient().setState(0);



        // wait for the asynchronous IBinder call to complete

        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);

        mHandler.sendAllMessages();

        assertFalse("Must be disabled since the mock service is disabled", manager.isEnabled());

    }



    @MediumTest

    @Test

    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);



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

    }



    @MediumTest

    @Test

    public void testSendAccessibilityEvent_AccessibilityDisabled() throws Exception {

        AccessibilityEvent sentEvent = AccessibilityEvent.obtain();



        AccessibilityManager manager = createManager(false  /* disabled */);



        AccessibilityManager manager = createManager(WITH_A11Y_DISABLED);

        mInstrumentation.runOnMainSync(() -> {

            try {

                manager.sendAccessibilityEvent(sentEvent);

                fail("No accessibility events are sent if accessibility is disabled");
@@ -153,5 +157,6 @@ public class AccessibilityManagerTest extends AndroidTestCase { 
                // check expected result

                assertEquals("Accessibility off. Did you forget to check that?", ise.getMessage());

            }

        });

    }

}