Test unitaire d'un fragment Android

Question

Je veux tester à l'unité une classe de fragments Android.

Puis-je configurer un test avec AndroidTestCase ou dois-je utiliser ApplicationTestCase?

Existe-t-il des exemples utiles d'utilisation de ces deux cas de test? Les exemples de test sur le site du développeur sont minimes et semblent juste se concentrer sur les activités de test.

Tout ce que j'ai trouvé ailleurs, ce sont des exemples où la classe AndroidTestCase est étendue, mais il ne reste plus qu'à additionner deux nombres ou, si le contexte est utilisé, un simple get et teste que quelque chose n'est pas nul!

Si je comprends bien, un fragment doit vivre dans une activité. Donc, pourrais-je créer une activité fictive ou demander à l'application ou au contexte de fournir une activité dans laquelle je peux tester mon fragment?

Dois-je créer ma propre activité, puis utiliser ActivityUnitTestCase?

Merci pour votre aide.

Trev

Answer 1

Je me débattais avec la même question. En particulier, comme la plupart des exemples de code sont déjà obsolètes +, Android Studio/SDK s'améliorant, les anciennes réponses ne sont parfois plus pertinentes.

Commençons par commencer: vous devez déterminer si vous souhaitez utiliser les tests Instrumental ou JUnit simples.

La différence entre eux magnifiquement décrite par S.D. ici ; En bref: les tests JUnit sont plus légers et ne nécessitent pas d'émulateur, mais ils nécessitent un émulateur, ce qui vous permet de vous familiariser avec l'expérience réelle du périphérique (capteurs, GPS, interaction avec d'autres applications, etc.). ). Lisez aussi plus à propos de test sous Android .

1. JUnit test de fragments

Disons que vous n'avez pas besoin de tests instrumentaux lourds et que de simples tests junit suffisent . J'utilise Nice framework Robolectric à cette fin.

Ajouter graduellement:

dependencies {
    .....
    testCompile 'junit:junit:4.12'
    testCompile 'org.robolectric:robolectric:3.0'
    testCompile "org.mockito:mockito-core:1.10.8"
    testCompile ('com.squareup.assertj:assertj-Android:1.0.0') {
        exclude module: 'support-annotations'
    }
    .....
}

Mockito, AsserJ sont optionnels, mais je les ai trouvés très utiles, donc je recommande fortement de les inclure aussi.

Ensuite, dans Variantes de construction, spécifiez Tests unitaires en tant que Test Artifact:

Il est maintenant temps d'écrire de vrais tests: -) À titre d'exemple, prenons l'exemple du projet standard "Activité vide avec fragment".

J'ai ajouté quelques lignes de code, pour avoir réellement quelque chose à tester:

import Android.os.Bundle;
import Android.support.v4.app.Fragment;
import Android.view.LayoutInflater;
import Android.view.View;
import Android.view.ViewGroup;
import Java.util.ArrayList;
import Java.util.List;

public class MainActivityFragment extends Fragment {

    private List<Cow> cows;
    public MainActivityFragment() {}

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {   
        cows = new ArrayList<>();
        cows.add(new Cow("Burka", 10));
        cows.add(new Cow("Zorka", 9));
        cows.add(new Cow("Kruzenshtern", 15));

        return inflater.inflate(R.layout.fragment_main, container, false);
    }

    int calculateYoungCows(int maxAge) {
        if (cows == null) {
            throw new IllegalStateException("onCreateView hasn't been called");
        }

        if (getActivity() == null) {
            throw new IllegalStateException("Activity is null");
        }

        if (getView() == null) {
            throw new IllegalStateException("View is null");
        }

        int result = 0;
        for (Cow cow : cows) {
            if (cow.age <= maxAge) {
                result++;
            }
        }

        return result;
    }
}

Et classe vache:

public class Cow {
    public String name;
    public int age;

    public Cow(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

L'ensemble de test du Robolectic ressemblerait à quelque chose comme:

import Android.app.Application;
import Android.support.v4.app.Fragment;
import Android.support.v4.app.FragmentManager;
import Android.support.v4.app.FragmentTransaction;
import Android.test.ApplicationTestCase;

import junit.framework.Assert;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.Robolectric;
import org.robolectric.RobolectricGradleTestRunner;
import org.robolectric.annotation.Config;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

@RunWith(RobolectricGradleTestRunner.class)
@Config(constants = BuildConfig.class, sdk=21)
public class MainActivityFragmentTest extends ApplicationTestCase<Application> {

    public MainActivityFragmentTest() {
        super(Application.class);
    }

    MainActivity mainActivity;
    MainActivityFragment mainActivityFragment;

    @Before
    public void setUp() {
        mainActivity = Robolectric.setupActivity(MainActivity.class);
        mainActivityFragment = new MainActivityFragment();
        startFragment(mainActivityFragment);
    }

    @Test
    public void testMainActivity() {
        Assert.assertNotNull(mainActivity);
    }

    @Test
    public void testCowsCounter() {
        assertThat(mainActivityFragment.calculateYoungCows(10)).isEqualTo(2);
        assertThat(mainActivityFragment.calculateYoungCows(99)).isEqualTo(3);
    }

    private void startFragment( Fragment fragment ) {
        FragmentManager fragmentManager = mainActivity.getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        fragmentTransaction.add(fragment, null );
        fragmentTransaction.commit();
    }
}

C'est à dire. nous créons une activité via Robolectric.setupActivity, nouveau fragment de la classe setUp () des classes de test. Vous pouvez éventuellement démarrer le fragment immédiatement à partir de setUp () ou directement à partir du test. 

NB! Je n'ai pas passé trop beaucoup de temps dessus, mais on dirait qu'il est presque impossible de le lier avec Dagger (je ne sais pas si c'est plus facile avec Dagger2), car vous ne pouvez pas définir de personnalisation test Application avec injections simulées.

2. Test instrumental de fragments

La complexité de cette approche dépend fortement de l’utilisation de l’injection de poignard/dépendance dans l’application à tester.

Dans Build Variants, spécifiez Tests instrumentaux Android en tant que Test Artifact:

Dans Gradle, j'ajoute ces dépendances:

dependencies {
    .....
    androidTestCompile "com.google.dexmaker:dexmaker:1.1"
    androidTestCompile "com.google.dexmaker:dexmaker-mockito:1.1"
    androidTestCompile 'com.squareup.assertj:assertj-Android:1.0.0'
    androidTestCompile "org.mockito:mockito-core:1.10.8"
    }
    .....
}

(encore une fois, ils sont tous facultatifs, mais ils peuvent vous faciliter la vie)

- Si vous n'avez pas de poignard

C'est un chemin heureux. La différence avec Robolectric de ce qui précède ne serait que dans les petits détails.

Pré-étape 1: Si vous voulez utiliser Mockito, vous devez l'activer pour qu'il puisse fonctionner sur les périphériques et les émulateurs avec ce hack:

public class TestUtils {
    private static final String CACHE_DIRECTORY = "/data/data/" + BuildConfig.APPLICATION_ID + "/cache";
    public static final String DEXMAKER_CACHE_PROPERTY = "dexmaker.dexcache";

    public static void enableMockitoOnDevicesAndEmulators() {
        if (System.getProperty(DEXMAKER_CACHE_PROPERTY) == null || System.getProperty(DEXMAKER_CACHE_PROPERTY).isEmpty()) {
            File file = new File(CACHE_DIRECTORY);
            if (!file.exists()) {
                final boolean success = file.mkdirs();
                if (!success) {
                    fail("Unable to create cache directory required for Mockito");
                }
            }

            System.setProperty(DEXMAKER_CACHE_PROPERTY, file.getPath());
        }
    }
}

Le fragment MainActivityFragment reste le même, comme ci-dessus. Ainsi, l'ensemble de tests ressemblerait à ceci:

package com.klogi.myapplication;

import Android.support.v4.app.Fragment;
import Android.support.v4.app.FragmentManager;
import Android.support.v4.app.FragmentTransaction;
import Android.test.ActivityInstrumentationTestCase2;

import junit.framework.Assert;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

public class MainActivityFragmentTest extends ActivityInstrumentationTestCase2<MainActivity> {

    public MainActivityFragmentTest() {
        super(MainActivity.class);
    }

    MainActivity mainActivity;
    MainActivityFragment mainActivityFragment;

    @Override
    protected void setUp() throws Exception {
        TestUtils.enableMockitoOnDevicesAndEmulators();
        mainActivity = getActivity();
        mainActivityFragment = new MainActivityFragment();
    }

    public void testMainActivity() {
        Assert.assertNotNull(mainActivity);
    }

    public void testCowsCounter() {
        startFragment(mainActivityFragment);
        assertThat(mainActivityFragment.calculateYoungCows(10)).isEqualTo(2);
        assertThat(mainActivityFragment.calculateYoungCows(99)).isEqualTo(3);
    }

    private void startFragment( Fragment fragment ) {
        FragmentManager fragmentManager = mainActivity.getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        fragmentTransaction.add(fragment, null);
        fragmentTransaction.commit();

        getActivity().runOnUiThread(new Runnable() {
            @Override
            public void run() {
                getActivity().getSupportFragmentManager().executePendingTransactions();
            }
        });

        getInstrumentation().waitForIdleSync();
    }

}

Comme vous pouvez le constater, la classe Test est une extension de la classe ActivityInstrumentationTestCase2. De plus, il est très important de faire attention à la méthode startFragment, qui a été modifiée par rapport à l'exemple JUnit: par défaut, les tests ne s'exécutent pas sur le thread d'interface utilisateur et nous devons explicitement appeler pour l'exécution les transactions en attente de FragmentManager.

- Si vous avez une dague

Les choses deviennent sérieuses ici :-)

Premièrement, nous nous débarrassons de ActivityInstrumentationTestCase2 au profit de ActivityUnitTestCase class, en tant que classe de base pour toutes les classes de test de fragment.

Comme d'habitude, ce n'est pas si simple et il y a plusieurs pièges ( this en est un exemple). Nous devons donc pimp notre AcitivityUnitTestCase à ActivityUnitTestCaseOverride

C'est un peu trop long de le publier complètement ici, alors j'en télécharge la version complète vers github ;

public abstract class ActivityUnitTestCaseOverride<T extends Activity>
        extends ActivityUnitTestCase<T> {

    ........
    private Class<T> mActivityClass;

    private Context mActivityContext;
    private Application mApplication;
    private MockParent mMockParent;

    private boolean mAttached = false;
    private boolean mCreated = false;

    public ActivityUnitTestCaseOverride(Class<T> activityClass) {
        super(activityClass);
        mActivityClass = activityClass;
    }

    @Override
    public T getActivity() {
        return (T) super.getActivity();
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();

        // default value for target context, as a default
        mActivityContext = getInstrumentation().getTargetContext();
    }

    /**
     * Start the activity under test, in the same way as if it was started by
     * {@link Android.content.Context#startActivity Context.startActivity()}, providing the
     * arguments it supplied.  When you use this method to start the activity, it will automatically
     * be stopped by {@link #tearDown}.
     * <p/>
     * <p>This method will call onCreate(), but if you wish to further exercise Activity life
     * cycle methods, you must call them yourself from your test case.
     * <p/>
     * <p><i>Do not call from your setUp() method.  You must call this method from each of your
     * test methods.</i>
     *
     * @param intent                       The Intent as if supplied to {@link Android.content.Context#startActivity}.
     * @param savedInstanceState           The instance state, if you are simulating this part of the life
     *                                     cycle.  Typically null.
     * @param lastNonConfigurationInstance This Object will be available to the
     *                                     Activity if it calls {@link Android.app.Activity#getLastNonConfigurationInstance()}.
     *                                     Typically null.
     * @return Returns the Activity that was created
     */
    protected T startActivity(Intent intent, Bundle savedInstanceState,
                              Object lastNonConfigurationInstance) {
        assertFalse("Activity already created", mCreated);

        if (!mAttached) {
            assertNotNull(mActivityClass);
            setActivity(null);
            T newActivity = null;
            try {
                IBinder token = null;
                if (mApplication == null) {
                    setApplication(new MockApplication());
                }
                ComponentName cn = new ComponentName(getInstrumentation().getTargetContext(), mActivityClass.getName());
                intent.setComponent(cn);
                ActivityInfo info = new ActivityInfo();
                CharSequence title = mActivityClass.getName();
                mMockParent = new MockParent();
                String id = null;

                newActivity = (T) getInstrumentation().newActivity(mActivityClass, mActivityContext,
                        token, mApplication, intent, info, title, mMockParent, id,
                        lastNonConfigurationInstance);
            } catch (Exception e) {
                assertNotNull(newActivity);
            }

            assertNotNull(newActivity);
            setActivity(newActivity);

            mAttached = true;
        }

        T result = getActivity();
        if (result != null) {
            getInstrumentation().callActivityOnCreate(getActivity(), savedInstanceState);
            mCreated = true;
        }
        return result;
    }

    protected Class<T> getActivityClass() {
        return mActivityClass;
    }

    @Override
    protected void tearDown() throws Exception {

        setActivity(null);

        // Scrub out members - protects against memory leaks in the case where someone
        // creates a non-static inner class (thus referencing the test case) and gives it to
        // someone else to hold onto
        scrubClass(ActivityInstrumentationTestCase.class);

        super.tearDown();
    }

    /**
     * Set the application for use during the test.  You must call this function before calling
     * {@link #startActivity}.  If your test does not call this method,
     *
     * @param application The Application object that will be injected into the Activity under test.
     */
    public void setApplication(Application application) {
        mApplication = application;
    }
    .......
}

Créez un AbstractFragmentTest abstrait pour tous vos tests de fragments:

import Android.app.Activity;
import Android.content.Intent;
import Android.content.pm.ActivityInfo;
import Android.content.res.Configuration;
import Android.support.v4.app.Fragment;
import Android.support.v4.app.FragmentManager;
import Android.support.v4.app.FragmentTransaction;

/**
 * Common base class for {@link Fragment} tests.
 */
public abstract class AbstractFragmentTest<TFragment extends Fragment, TActivity extends FragmentActivity> extends ActivityUnitTestCaseOverride<TActivity> {

    private TFragment fragment;
    protected MockInjectionRegistration mocks;

    protected AbstractFragmentTest(TFragment fragment, Class<TActivity> activityType) {
        super(activityType);
        this.fragment = parameterIsNotNull(fragment);
    }

    @Override
    protected void setActivity(Activity testActivity) {
        if (testActivity != null) {
            testActivity.setTheme(R.style.AppCompatTheme);
        }

        super.setActivity(testActivity);
    }

    /**
     * Get the {@link Fragment} under test.
     */
    protected TFragment getFragment() {
        return fragment;
    }

    protected void setUpActivityAndFragment() {
        createMockApplication();

        final Intent intent = new Intent(getInstrumentation().getTargetContext(),
                getActivityClass());
        startActivity(intent, null, null);
        startFragment(getFragment());

        getInstrumentation().callActivityOnStart(getActivity());
        getInstrumentation().callActivityOnResume(getActivity());
    }

    private void createMockApplication() {
        TestUtils.enableMockitoOnDevicesAndEmulators();

        mocks = new MockInjectionRegistration();
        TestApplication testApplication = new TestApplication(getInstrumentation().getTargetContext());
        testApplication.setModules(mocks);
        testApplication.onCreate();
        setApplication(testApplication);
    }

    private void startFragment(Fragment fragment) {
        FragmentManager fragmentManager = getActivity().getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        fragmentTransaction.add(fragment, null);
        fragmentTransaction.commit();
    }
}

Il y a plusieurs choses importantes ici.

1) Nous substituons la méthode setActivity () pour définir le thème AppCompact sur l'activité. Sans cela, le test va tomber.

2) Méthode setUpActivityAndFragment ():

I. crée une activité (=> getActivity () commence à renvoyer une valeur non nulle, dans les tests et dans l'application testée) 1) onCreate () de l'activité appelée;

2) onStart () de l'activité appelée;

3) onResume () de l'activité appelée;

II. attache et commence fragment à l'activité

1) onAttach () du fragment appelé;

2) onCreateView () du fragment appelé;

3) onStart () du fragment appelé;

4) onResume () du fragment appelé;

3) Méthode createMockApplication (): Comme dans la version sans poignard, dans la pré-étape 1, nous activons le mocking sur les périphériques et les émulateurs.

Ensuite, nous remplaçons l'application normale par ses injections par notre application personnalisée, TestApplication!

MockInjectionRegistration ressemble à ceci:

....
import javax.inject.Singleton;

import dagger.Module;
import dagger.Provides;
import de.greenrobot.event.EventBus;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

@Module(
        injects = {

                ....
                MainActivity.class,
                MyWorkFragment.class,
                HomeFragment.class,
                ProfileFragment.class,
                ....
        },
        addsTo = DelveMobileInjectionRegistration.class,
        overrides = true
)
public final class MockInjectionRegistration {

    .....
    public DataSource dataSource;
    public EventBus eventBus;
    public MixpanelAPI mixpanel;
    .....

    public MockInjectionRegistration() {
        .....
        dataSource = mock(DataSource.class);
        eventBus = mock(EventBus.class);
        mixpanel = mock(MixpanelAPI.class);
        MixpanelAPI.People mixpanelPeople = mock(MixpanelAPI.People.class);
        when(mixpanel.getPeople()).thenReturn(mixpanelPeople);
        .....
    }
...........
    @Provides
    @Singleton
    @SuppressWarnings("unused")
        // invoked by Dagger
    DataSource provideDataSource() {
        Guard.valueIsNotNull(dataSource);
        return dataSource;
    }

    @Provides
    @Singleton
    @SuppressWarnings("unused")
        // invoked by Dagger
    EventBus provideEventBus() {
        Guard.valueIsNotNull(eventBus);
        return eventBus;
    }

    @Provides
    @Singleton
    @SuppressWarnings("unused")
        // invoked by Dagger
    MixpanelAPI provideMixpanelAPI() {
        Guard.valueIsNotNull(mixpanel);
        return mixpanel;
    }
.........
}

C'est à dire. au lieu de vraies classes, nous fournissons aux fragments leurs versions simulées. (Qui sont facilement traçables, permet de configurer les résultats des appels de méthode, etc.).

Et TestApplication est simplement votre extension personnalisée d’Application, qui devrait prendre en charge le paramétrage des modules et initialiser ObjectGraph.

C'étaient des pré-étapes pour commencer à écrire les tests :) Maintenant la partie simple, les vrais tests:

public class SearchFragmentTest extends AbstractFragmentTest<SearchFragment, MainActivity> {

    public SearchFragmentTest() {
        super(new SearchFragment(), MainActivity.class);
    }

    @UiThreadTest
    public void testOnCreateView() throws Exception {
        setUpActivityAndFragment();

        SearchFragment searchFragment = getFragment();
        assertNotNull(searchFragment.adapter);
        assertNotNull(SearchFragment.getSearchAdapter());
        assertNotNull(SearchFragment.getSearchSignalLogger());
    }

    @UiThreadTest
    public void testOnPause() throws Exception {
        setUpActivityAndFragment();

        SearchFragment searchFragment = getFragment();
        assertTrue(Strings.isNullOrEmpty(SharedPreferencesTools.getString(getActivity(), SearchFragment.SEARCH_STATE_BUNDLE_ARGUMENT)));

        searchFragment.searchBoxRef.setCurrentConstraint("abs");
        searchFragment.onPause();

        assertEquals(searchFragment.searchBoxRef.getCurrentConstraint(), SharedPreferencesTools.getString(getActivity(), SearchFragment.SEARCH_STATE_BUNDLE_ARGUMENT));
    }

    @UiThreadTest
    public void testOnQueryTextChange() throws Exception {
        setUpActivityAndFragment();
        reset(mocks.eventBus);

        getFragment().onQueryTextChange("Donald");
        Thread.sleep(300);

        // Should be one cached, one uncached event
        verify(mocks.eventBus, times(2)).post(isA(SearchRequest.class));
        verify(mocks.eventBus).post(isA(SearchLoadingIndicatorEvent.class));
    }

    @UiThreadTest
    public void testOnQueryUpdateEventWithDifferentConstraint() throws Exception {
        setUpActivityAndFragment();

        reset(mocks.eventBus);

        getFragment().onEventMainThread(new SearchResponse(new ArrayList<>(), "Donald", false));

        verifyNoMoreInteractions(mocks.eventBus);
    }
    ....
}

C'est tout! Vous avez maintenant activé les tests Instrumental/JUnit pour vos fragments.

J'espère sincèrement que ce message aidera quelqu'un.

Answer 2

Supposons que vous ayez une classe FragmentActivity appelée 'MyFragmentActivity' dans laquelle une classe de fragments publique appelée 'MyFragment' est ajoutée à l'aide de FragmentTransaction. Créez simplement une classe 'JUnit Test Case' qui étend ActivityInstrumentationTestCase2 dans votre projet de test. Ensuite, appelez simplement getActivity () et accédez à l'objet MyFragment et à ses membres publics pour écrire des scénarios de test.

Référez-vous l'extrait de code ci-dessous:

// TARGET CLASS
public class MyFragmentActivity extends FragmentActivity {
    public MyFragment myFragment;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
        myFragment = new MyFragment();
        fragmentTransaction.add(R.id.mainFragmentContainer, myFragment);
        fragmentTransaction.commit();
    }
}

// TEST CLASS
public class MyFragmentActivityTest extends Android.test.ActivityInstrumentationTestCase2<MyFragmentActivity> {
    MyFragmentActivity myFragmentActivity;
    MyFragment myFragment;

    public MyFragmentActivityTest() {
        super(MyFragmentActivity.class);
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        myFragmentActivity = (MyFragmentActivity) getActivity();
        myFragment = myFragmentActivity.myFragment;
    }

    public void testPreConditions() {
        assertNotNull(myFragmentActivity);
        assertNotNull(myFragment);
    }

    public void testAnythingFromMyFragment() {
        // access any public members of myFragment to test
    }
}

J'espère que ça aide. Acceptez ma réponse si vous trouvez cela utile. Merci.

Answer 3

Je suis sûr que vous pouvez faire ce que vous dites, créer une activité fictive et tester le fragment à partir de là. Vous devez simplement exporter la bibliothèque de compatibilité dans le projet principal et vous pourrez accéder aux fragments du projet test. Je vais créer un exemple de projet, tester le code ici et mettre à jour ma réponse en fonction de mes connaissances.

Pour plus de détails sur l’exportation de la bibliothèque de compatibilité, consultez ici .

Answer 4

Ajout à la réponse de @ abhijit.mitkar.

Dans un scénario où votre fragment n'est pas un membre public de l'activité testée.

protected void setUp() {
   mActivity = getActivity();
   mFragment = new TheTargetFragment();

   FragmentTransaction transaction = mActivity.getSupportFragmentManager().beginTransaction();
   transaction.add(R.id.fragment_container, mFragment, "FRAGMENT_TAG");
   transaction.commit();
}

Le but du code ci-dessus est de remplacer le fragment par un nouvel objet fragment auquel nous avons accès.

Le code ci-dessous vous permettra d'accéder aux fragments membres de l'interface utilisateur.

TextView randomTextView= (TextView) mFragment.getView().findViewById(R.id.textViewRandom);

Obtenir l'interface utilisateur de l'activité ne sera pas vous donnera le résultat attendu.

TextView randomTextView= (TextView) mActivity.findViewById(R.id.textViewRandom);

Enfin, si vous souhaitez apporter des modifications à l'interface utilisateur. Comme un bon développeur Android, faites-le dans le fil principal.

mActivity.runOnUiThread(new Runnable() {
    @Override
    public void run() {
        // set text view's value
    }
});

Remarque: Vous voudrez peut-être lui attribuer un Thread.sleep () à la fin d'un test. Pour éviter le verrouillage, getInstrumentation (). WaitForIdleSync (); ne semble pas fonctionner toujours.

J'ai utilisé ActivityInstrumentationTestCase2 depuis que je faisais des tests fonctionnels.