path: root/tests/fragment/src/android/fragment/cts/FragmentTransitionTest.java

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

import static junit.framework.Assert.assertNull;
import static junit.framework.Assert.fail;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;

import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.app.SharedElementCallback;
import android.graphics.Rect;
import android.os.Bundle;
import android.support.test.filters.MediumTest;
import android.support.test.rule.ActivityTestRule;
import android.transition.TransitionSet;
import android.view.View;

import com.android.compatibility.common.util.transition.TargetTracking;
import com.android.compatibility.common.util.transition.TrackingTransition;

import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.mockito.ArgumentCaptor;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@MediumTest
@RunWith(Parameterized.class)
public class FragmentTransitionTest {
    private final boolean mReordered;
    private int mOnBackStackChangedTimes;
    private FragmentManager.OnBackStackChangedListener mOnBackStackChangedListener;

    @Parameterized.Parameters
    public static Object[] data() {
        return new Boolean[] {
                false, true
        };
    }

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

    private FragmentManager mFragmentManager;

    public FragmentTransitionTest(final boolean reordered) {
        mReordered = reordered;
    }

    @Before
    public void setup() throws Throwable {
        mFragmentManager = mActivityRule.getActivity().getFragmentManager();
        FragmentTestUtil.setContentView(mActivityRule, R.layout.simple_container);
        mOnBackStackChangedTimes = 0;
        mOnBackStackChangedListener = new FragmentManager.OnBackStackChangedListener() {
            @Override
            public void onBackStackChanged() {
                mOnBackStackChangedTimes++;
            }
        };
        mFragmentManager.addOnBackStackChangedListener(mOnBackStackChangedListener);
    }

    @After
    public void teardown() throws Throwable {
        mFragmentManager.removeOnBackStackChangedListener(mOnBackStackChangedListener);
        mOnBackStackChangedListener = null;
    }

    // Test that normal view transitions (enter, exit, reenter, return) run with
    // a single fragment.
    @Test
    public void enterExitTransitions() throws Throwable {
        // enter transition
        TransitionFragment fragment = setupInitialFragment();
        final View blue = findBlue();
        final View green = findBlue();

        // exit transition
        mFragmentManager.beginTransaction()
                .setReorderingAllowed(mReordered)
                .remove(fragment)
                .addToBackStack(null)
                .commit();

        fragment.waitForTransition();
        verifyAndClearTransition(fragment.exitTransition, null, green, blue);
        verifyNoOtherTransitions(fragment);
        assertEquals(2, mOnBackStackChangedTimes);

        // reenter transition
        FragmentTestUtil.popBackStackImmediate(mActivityRule);
        fragment.waitForTransition();
        final View green2 = findGreen();
        final View blue2 = findBlue();
        verifyAndClearTransition(fragment.reenterTransition, null, green2, blue2);
        verifyNoOtherTransitions(fragment);
        assertEquals(3, mOnBackStackChangedTimes);

        // return transition
        FragmentTestUtil.popBackStackImmediate(mActivityRule);
        fragment.waitForTransition();
        verifyAndClearTransition(fragment.returnTransition, null, green2, blue2);
        verifyNoOtherTransitions(fragment);
        assertEquals(4, mOnBackStackChangedTimes);
    }

    // Test that shared elements transition from one fragment to the next
    // and back during pop.
    @Test
    public void sharedElement() throws Throwable {
        TransitionFragment fragment1 = setupInitialFragment();

        // Now do a transition to scene2
        TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene2);

        verifyTransition(fragment1, fragment2, "blueSquare");
        assertEquals(2, mOnBackStackChangedTimes);

        // Now pop the back stack
        verifyPopTransition(1, fragment2, fragment1);
        assertEquals(3, mOnBackStackChangedTimes);
    }

    // Test that shared element transitions through multiple fragments work together
    @Test
    public void intermediateFragment() throws Throwable {
        TransitionFragment fragment1 = setupInitialFragment();

        final TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene3);

        verifyTransition(fragment1, fragment2, "shared");

        final TransitionFragment fragment3 = new TransitionFragment();
        fragment3.setLayoutId(R.layout.scene2);

        verifyTransition(fragment2, fragment3, "blueSquare");

        // Should transfer backwards when popping multiple:
        verifyPopTransition(2, fragment3, fragment1, fragment2);
    }

    // Adding/removing the same fragment multiple times shouldn't mess anything up
    @Test
    public void removeAdded() throws Throwable {
        final TransitionFragment fragment1 = setupInitialFragment();

        final View startBlue = findBlue();
        final View startGreen = findGreen();

        final TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene2);

        mActivityRule.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mFragmentManager.beginTransaction()
                        .setReorderingAllowed(mReordered)
                        .replace(R.id.fragmentContainer, fragment2)
                        .replace(R.id.fragmentContainer, fragment1)
                        .replace(R.id.fragmentContainer, fragment2)
                        .addToBackStack(null)
                        .commit();
            }
        });
        FragmentTestUtil.waitForExecution(mActivityRule);
        assertEquals(2, mOnBackStackChangedTimes);

        // should be a normal transition from fragment1 to fragment2
        fragment1.waitForTransition();
        fragment2.waitForTransition();
        FragmentTestUtil.waitForExecution(mActivityRule);

        final View endBlue = findBlue();
        final View endGreen = findGreen();
        verifyAndClearTransition(fragment1.exitTransition, null, startBlue, startGreen);
        verifyAndClearTransition(fragment2.enterTransition, null, endBlue, endGreen);
        verifyNoOtherTransitions(fragment1);
        verifyNoOtherTransitions(fragment2);

        // Pop should also do the same thing
        FragmentTestUtil.popBackStackImmediate(mActivityRule);
        assertEquals(3, mOnBackStackChangedTimes);

        fragment1.waitForTransition();
        fragment2.waitForTransition();
        FragmentTestUtil.waitForExecution(mActivityRule);

        final View popBlue = findBlue();
        final View popGreen = findGreen();
        verifyAndClearTransition(fragment1.reenterTransition, null, popBlue, popGreen);
        verifyAndClearTransition(fragment2.returnTransition, null, endBlue, endGreen);
        verifyNoOtherTransitions(fragment1);
        verifyNoOtherTransitions(fragment2);
    }

    // Make sure that shared elements on two different fragment containers don't interact
    @Test
    public void crossContainer() throws Throwable {
        FragmentTestUtil.setContentView(mActivityRule, R.layout.double_container);
        TransitionFragment fragment1 = new TransitionFragment();
        fragment1.setLayoutId(R.layout.scene1);
        TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene1);
        mFragmentManager.beginTransaction()
                .setReorderingAllowed(mReordered)
                .add(R.id.fragmentContainer1, fragment1)
                .add(R.id.fragmentContainer2, fragment2)
                .addToBackStack(null)
                .commit();
        FragmentTestUtil.waitForExecution(mActivityRule);
        assertEquals(1, mOnBackStackChangedTimes);

        fragment1.waitForTransition();
        final View greenSquare1 = findViewById(fragment1, R.id.greenSquare);
        final View blueSquare1 = findViewById(fragment1, R.id.blueSquare);
        verifyAndClearTransition(fragment1.enterTransition, null, greenSquare1, blueSquare1);
        verifyNoOtherTransitions(fragment1);
        fragment2.waitForTransition();
        final View greenSquare2 = findViewById(fragment2, R.id.greenSquare);
        final View blueSquare2 = findViewById(fragment2, R.id.blueSquare);
        verifyAndClearTransition(fragment2.enterTransition, null, greenSquare2, blueSquare2);
        verifyNoOtherTransitions(fragment2);

        // Make sure the correct transitions are run when the target names
        // are different in both shared elements. We may fool the system.
        verifyCrossTransition(false, fragment1, fragment2);

        // Make sure the correct transitions are run when the source names
        // are different in both shared elements. We may fool the system.
        verifyCrossTransition(true, fragment1, fragment2);
    }

    // Make sure that onSharedElementStart and onSharedElementEnd are called
    @Test
    public void callStartEndWithSharedElements() throws Throwable {
        TransitionFragment fragment1 = setupInitialFragment();

        // Now do a transition to scene2
        TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene2);

        SharedElementCallback enterCallback = mock(SharedElementCallback.class);
        fragment2.setEnterSharedElementCallback(enterCallback);

        final View startBlue = findBlue();

        verifyTransition(fragment1, fragment2, "blueSquare");

        ArgumentCaptor<List> names = ArgumentCaptor.forClass(List.class);
        ArgumentCaptor<List> views = ArgumentCaptor.forClass(List.class);
        ArgumentCaptor<List> snapshots = ArgumentCaptor.forClass(List.class);
        verify(enterCallback).onSharedElementStart(names.capture(), views.capture(),
                snapshots.capture());
        assertEquals(1, names.getValue().size());
        assertEquals(1, views.getValue().size());
        assertNull(snapshots.getValue());
        assertEquals("blueSquare", names.getValue().get(0));
        assertEquals(startBlue, views.getValue().get(0));

        final View endBlue = findBlue();

        verify(enterCallback).onSharedElementEnd(names.capture(), views.capture(),
                snapshots.capture());
        assertEquals(1, names.getValue().size());
        assertEquals(1, views.getValue().size());
        assertNull(snapshots.getValue());
        assertEquals("blueSquare", names.getValue().get(0));
        assertEquals(endBlue, views.getValue().get(0));

        // Now pop the back stack
        reset(enterCallback);
        verifyPopTransition(1, fragment2, fragment1);

        verify(enterCallback).onSharedElementStart(names.capture(), views.capture(),
                snapshots.capture());
        assertEquals(1, names.getValue().size());
        assertEquals(1, views.getValue().size());
        assertNull(snapshots.getValue());
        assertEquals("blueSquare", names.getValue().get(0));
        assertEquals(endBlue, views.getValue().get(0));

        final View reenterBlue = findBlue();

        verify(enterCallback).onSharedElementEnd(names.capture(), views.capture(),
                snapshots.capture());
        assertEquals(1, names.getValue().size());
        assertEquals(1, views.getValue().size());
        assertNull(snapshots.getValue());
        assertEquals("blueSquare", names.getValue().get(0));
        assertEquals(reenterBlue, views.getValue().get(0));
    }

    // Make sure that onMapSharedElement works to change the shared element going out
    @Test
    public void onMapSharedElementOut() throws Throwable {
        TransitionFragment fragment1 = setupInitialFragment();

        // Now do a transition to scene2
        TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene2);

        final View startBlue = findBlue();
        final View startGreen = findGreen();

        final Rect startGreenBounds = getBoundsOnScreen(startGreen);

        SharedElementCallback mapOut = new SharedElementCallback() {
            @Override
            public void onMapSharedElements(List<String> names, Map<String, View> sharedElements) {
                assertEquals(1, names.size());
                assertEquals("blueSquare", names.get(0));
                assertEquals(1, sharedElements.size());
                assertEquals(startBlue, sharedElements.get("blueSquare"));
                sharedElements.put("blueSquare", startGreen);
            }
        };
        fragment1.setExitSharedElementCallback(mapOut);

        mFragmentManager.beginTransaction()
                .addSharedElement(startBlue, "blueSquare")
                .replace(R.id.fragmentContainer, fragment2)
                .setReorderingAllowed(mReordered)
                .addToBackStack(null)
                .commit();
        FragmentTestUtil.waitForExecution(mActivityRule);

        fragment1.waitForTransition();
        fragment2.waitForTransition();

        final View endBlue = findBlue();
        final Rect endBlueBounds = getBoundsOnScreen(endBlue);

        verifyAndClearTransition(fragment2.sharedElementEnter, startGreenBounds, startGreen,
                endBlue);

        SharedElementCallback mapBack = new SharedElementCallback() {
            @Override
            public void onMapSharedElements(List<String> names, Map<String, View> sharedElements) {
                assertEquals(1, names.size());
                assertEquals("blueSquare", names.get(0));
                assertEquals(1, sharedElements.size());
                final View expectedBlue = findViewById(fragment1, R.id.blueSquare);
                assertEquals(expectedBlue, sharedElements.get("blueSquare"));
                final View greenSquare = findViewById(fragment1, R.id.greenSquare);
                sharedElements.put("blueSquare", greenSquare);
            }
        };
        fragment1.setExitSharedElementCallback(mapBack);

        FragmentTestUtil.popBackStackImmediate(mActivityRule);

        fragment1.waitForTransition();
        fragment2.waitForTransition();

        final View reenterGreen = findGreen();
        verifyAndClearTransition(fragment2.sharedElementReturn, endBlueBounds, endBlue,
                reenterGreen);
    }

    // Make sure that onMapSharedElement works to change the shared element target
    @Test
    public void onMapSharedElementIn() throws Throwable {
        TransitionFragment fragment1 = setupInitialFragment();

        // Now do a transition to scene2
        TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene2);

        final View startBlue = findBlue();
        final Rect startBlueBounds = getBoundsOnScreen(startBlue);

        SharedElementCallback mapIn = new SharedElementCallback() {
            @Override
            public void onMapSharedElements(List<String> names, Map<String, View> sharedElements) {
                assertEquals(1, names.size());
                assertEquals("blueSquare", names.get(0));
                assertEquals(1, sharedElements.size());
                final View blueSquare = findViewById(fragment2, R.id.blueSquare);
                assertEquals(blueSquare, sharedElements.get("blueSquare"));
                final View greenSquare = findViewById(fragment2, R.id.greenSquare);
                sharedElements.put("blueSquare", greenSquare);
            }
        };
        fragment2.setEnterSharedElementCallback(mapIn);

        mFragmentManager.beginTransaction()
                .addSharedElement(startBlue, "blueSquare")
                .replace(R.id.fragmentContainer, fragment2)
                .setReorderingAllowed(mReordered)
                .addToBackStack(null)
                .commit();
        FragmentTestUtil.waitForExecution(mActivityRule);

        fragment1.waitForTransition();
        fragment2.waitForTransition();

        final View endGreen = findGreen();
        final View endBlue = findBlue();
        final Rect endGreenBounds = getBoundsOnScreen(endGreen);

        verifyAndClearTransition(fragment2.sharedElementEnter, startBlueBounds, startBlue,
                endGreen);

        SharedElementCallback mapBack = new SharedElementCallback() {
            @Override
            public void onMapSharedElements(List<String> names, Map<String, View> sharedElements) {
                assertEquals(1, names.size());
                assertEquals("blueSquare", names.get(0));
                assertEquals(1, sharedElements.size());
                assertEquals(endBlue, sharedElements.get("blueSquare"));
                sharedElements.put("blueSquare", endGreen);
            }
        };
        fragment2.setEnterSharedElementCallback(mapBack);

        FragmentTestUtil.popBackStackImmediate(mActivityRule);

        fragment1.waitForTransition();
        fragment2.waitForTransition();

        final View reenterBlue = findBlue();
        verifyAndClearTransition(fragment2.sharedElementReturn, endGreenBounds, endGreen,
                reenterBlue);
    }

    // Ensure that shared element transitions that have targets properly target the views
    @Test
    public void complexSharedElementTransition() throws Throwable {
        TransitionFragment fragment1 = setupInitialFragment();

        // Now do a transition to scene2
        ComplexTransitionFragment fragment2 = new ComplexTransitionFragment();
        fragment2.setLayoutId(R.layout.scene2);

        final View startBlue = findBlue();
        final View startGreen = findGreen();
        final Rect startBlueBounds = getBoundsOnScreen(startBlue);

        mFragmentManager.beginTransaction()
                .addSharedElement(startBlue, "blueSquare")
                .addSharedElement(startGreen, "greenSquare")
                .replace(R.id.fragmentContainer, fragment2)
                .addToBackStack(null)
                .commit();
        FragmentTestUtil.waitForExecution(mActivityRule);
        assertEquals(2, mOnBackStackChangedTimes);

        fragment1.waitForTransition();
        fragment2.waitForTransition();

        final View endBlue = findBlue();
        final View endGreen = findGreen();
        final Rect endBlueBounds = getBoundsOnScreen(endBlue);

        verifyAndClearTransition(fragment2.sharedElementEnterTransition1, startBlueBounds,
                startBlue, endBlue);
        verifyAndClearTransition(fragment2.sharedElementEnterTransition2, startBlueBounds,
                startGreen, endGreen);

        // Now see if it works when popped
        FragmentTestUtil.popBackStackImmediate(mActivityRule);
        assertEquals(3, mOnBackStackChangedTimes);

        fragment1.waitForTransition();
        fragment2.waitForTransition();

        final View reenterBlue = findBlue();
        final View reenterGreen = findGreen();

        verifyAndClearTransition(fragment2.sharedElementReturnTransition1, endBlueBounds,
                endBlue, reenterBlue);
        verifyAndClearTransition(fragment2.sharedElementReturnTransition2, endBlueBounds,
                endGreen, reenterGreen);
    }

    // Ensure that after transitions have executed that they don't have any targets or other
    // unfortunate modifications.
    @Test
    public void transitionsEndUnchanged() throws Throwable {
        TransitionFragment fragment1 = setupInitialFragment();

        // Now do a transition to scene2
        TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene2);

        verifyTransition(fragment1, fragment2, "blueSquare");
        assertEquals(0, fragment1.exitTransition.getTargets().size());
        assertEquals(0, fragment2.sharedElementEnter.getTargets().size());
        assertEquals(0, fragment2.enterTransition.getTargets().size());
        assertNull(fragment1.exitTransition.getEpicenterCallback());
        assertNull(fragment2.enterTransition.getEpicenterCallback());
        assertNull(fragment2.sharedElementEnter.getEpicenterCallback());

        // Now pop the back stack
        verifyPopTransition(1, fragment2, fragment1);

        assertEquals(0, fragment2.returnTransition.getTargets().size());
        assertEquals(0, fragment2.sharedElementReturn.getTargets().size());
        assertEquals(0, fragment1.reenterTransition.getTargets().size());
        assertNull(fragment2.returnTransition.getEpicenterCallback());
        assertNull(fragment2.sharedElementReturn.getEpicenterCallback());
        assertNull(fragment2.reenterTransition.getEpicenterCallback());
    }

    // Ensure that transitions are done when a fragment is shown and hidden
    @Test
    public void showHideTransition() throws Throwable {
        TransitionFragment fragment1 = setupInitialFragment();
        TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene2);

        final View startBlue = findBlue();
        final View startGreen = findGreen();

        mFragmentManager.beginTransaction()
                .setReorderingAllowed(mReordered)
                .add(R.id.fragmentContainer, fragment2)
                .hide(fragment1)
                .addToBackStack(null)
                .commit();

        FragmentTestUtil.waitForExecution(mActivityRule);
        fragment1.waitForTransition();
        fragment2.waitForTransition();

        final View endGreen = findViewById(fragment2, R.id.greenSquare);
        final View endBlue = findViewById(fragment2, R.id.blueSquare);

        assertEquals(View.GONE, fragment1.getView().getVisibility());
        assertEquals(View.VISIBLE, startGreen.getVisibility());
        assertEquals(View.VISIBLE, startBlue.getVisibility());

        verifyAndClearTransition(fragment1.exitTransition, null, startGreen, startBlue);
        verifyNoOtherTransitions(fragment1);

        verifyAndClearTransition(fragment2.enterTransition, null, endGreen, endBlue);
        verifyNoOtherTransitions(fragment2);

        FragmentTestUtil.popBackStackImmediate(mActivityRule);

        FragmentTestUtil.waitForExecution(mActivityRule);
        fragment1.waitForTransition();
        fragment2.waitForTransition();

        verifyAndClearTransition(fragment1.reenterTransition, null, startGreen, startBlue);
        verifyNoOtherTransitions(fragment1);

        assertEquals(View.VISIBLE, fragment1.getView().getVisibility());
        assertEquals(View.VISIBLE, startGreen.getVisibility());
        assertEquals(View.VISIBLE, startBlue.getVisibility());

        verifyAndClearTransition(fragment2.returnTransition, null, endGreen, endBlue);
        verifyNoOtherTransitions(fragment2);
    }

    // Ensure that transitions are done when a fragment is attached and detached
    @Test
    public void attachDetachTransition() throws Throwable {
        TransitionFragment fragment1 = setupInitialFragment();
        TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene2);

        final View startBlue = findBlue();
        final View startGreen = findGreen();

        mFragmentManager.beginTransaction()
                .setReorderingAllowed(mReordered)
                .add(R.id.fragmentContainer, fragment2)
                .detach(fragment1)
                .addToBackStack(null)
                .commit();

        FragmentTestUtil.waitForExecution(mActivityRule);

        final View endGreen = findViewById(fragment2, R.id.greenSquare);
        final View endBlue = findViewById(fragment2, R.id.blueSquare);

        verifyAndClearTransition(fragment1.exitTransition, null, startGreen, startBlue);
        verifyNoOtherTransitions(fragment1);

        verifyAndClearTransition(fragment2.enterTransition, null, endGreen, endBlue);
        verifyNoOtherTransitions(fragment2);

        FragmentTestUtil.popBackStackImmediate(mActivityRule);

        FragmentTestUtil.waitForExecution(mActivityRule);

        final View reenterBlue = findBlue();
        final View reenterGreen = findGreen();

        verifyAndClearTransition(fragment1.reenterTransition, null, reenterGreen, reenterBlue);
        verifyNoOtherTransitions(fragment1);

        verifyAndClearTransition(fragment2.returnTransition, null, endGreen, endBlue);
        verifyNoOtherTransitions(fragment2);
    }

    // Ensure that shared element without matching transition name doesn't error out
    @Test
    public void sharedElementMismatch() throws Throwable {
        final TransitionFragment fragment1 = setupInitialFragment();

        // Now do a transition to scene2
        TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene2);

        final View startBlue = findBlue();
        final View startGreen = findGreen();
        final Rect startBlueBounds = getBoundsOnScreen(startBlue);

        mFragmentManager.beginTransaction()
                .addSharedElement(startBlue, "fooSquare")
                .replace(R.id.fragmentContainer, fragment2)
                .setReorderingAllowed(mReordered)
                .addToBackStack(null)
                .commit();
        FragmentTestUtil.waitForExecution(mActivityRule);

        fragment1.waitForTransition();
        fragment2.waitForTransition();

        final View endBlue = findBlue();
        final View endGreen = findGreen();

        if (mReordered) {
            verifyAndClearTransition(fragment1.exitTransition, null, startGreen, startBlue);
        } else {
            verifyAndClearTransition(fragment1.exitTransition, startBlueBounds, startGreen);
            verifyAndClearTransition(fragment2.sharedElementEnter, startBlueBounds, startBlue);
        }
        verifyNoOtherTransitions(fragment1);

        verifyAndClearTransition(fragment2.enterTransition, null, endGreen, endBlue);
        verifyNoOtherTransitions(fragment2);
    }

    // Ensure that using the same source or target shared element results in an exception.
    @Test
    public void sharedDuplicateTargetNames() throws Throwable {
        setupInitialFragment();

        final View startBlue = findBlue();
        final View startGreen = findGreen();

        FragmentTransaction ft = mFragmentManager.beginTransaction();
        ft.addSharedElement(startBlue, "blueSquare");
        try {
            ft.addSharedElement(startGreen, "blueSquare");
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }

        try {
            ft.addSharedElement(startBlue, "greenSquare");
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }
    }

    // Test that invisible fragment views don't participate in transitions
    @Test
    public void invisibleNoTransitions() throws Throwable {
        if (!mReordered) {
            return; // only reordered transitions can avoid interaction
        }
        // enter transition
        TransitionFragment fragment = new InvisibleFragment();
        fragment.setLayoutId(R.layout.scene1);
        mFragmentManager.beginTransaction()
                .setReorderingAllowed(mReordered)
                .add(R.id.fragmentContainer, fragment)
                .addToBackStack(null)
                .commit();
        FragmentTestUtil.waitForExecution(mActivityRule);
        fragment.waitForNoTransition();
        verifyNoOtherTransitions(fragment);

        // exit transition
        mFragmentManager.beginTransaction()
                .setReorderingAllowed(mReordered)
                .remove(fragment)
                .addToBackStack(null)
                .commit();

        fragment.waitForNoTransition();
        verifyNoOtherTransitions(fragment);

        // reenter transition
        FragmentTestUtil.popBackStackImmediate(mActivityRule);
        fragment.waitForNoTransition();
        verifyNoOtherTransitions(fragment);

        // return transition
        FragmentTestUtil.popBackStackImmediate(mActivityRule);
        fragment.waitForNoTransition();
        verifyNoOtherTransitions(fragment);
    }

    // No crash when transitioning a shared element and there is no shared element transition.
    @Test
    public void noSharedElementTransition() throws Throwable {
        TransitionFragment fragment1 = setupInitialFragment();

        final View startBlue = findBlue();
        final View startGreen = findGreen();
        final Rect startBlueBounds = getBoundsOnScreen(startBlue);

        TransitionFragment fragment2 = new TransitionFragment();
        fragment2.setLayoutId(R.layout.scene2);

        mFragmentManager.beginTransaction()
                .setReorderingAllowed(mReordered)
                .addSharedElement(startBlue, "blueSquare")
                .replace(R.id.fragmentContainer, fragment2)
                .addToBackStack(null)
                .commit();

        fragment1.waitForTransition();
        fragment2.waitForTransition();
        final View midGreen = findGreen();
        final View midBlue = findBlue();
        final Rect midBlueBounds = getBoundsOnScreen(midBlue);
        verifyAndClearTransition(fragment1.exitTransition, startBlueBounds, startGreen);
        verifyAndClearTransition(fragment2.sharedElementEnter, startBlueBounds, startBlue, midBlue);
        verifyAndClearTransition(fragment2.enterTransition, midBlueBounds, midGreen);
        verifyNoOtherTransitions(fragment1);
        verifyNoOtherTransitions(fragment2);

        final TransitionFragment fragment3 = new TransitionFragment();
        fragment3.setLayoutId(R.layout.scene3);

        mActivityRule.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mFragmentManager.popBackStack();
                mFragmentManager.beginTransaction()
                        .setReorderingAllowed(mReordered)
                        .replace(R.id.fragmentContainer, fragment3)
                        .addToBackStack(null)
                        .commit();
            }
        });

        // This shouldn't give an error.
        FragmentTestUtil.executePendingTransactions(mActivityRule);

        fragment2.waitForTransition();
        // It does not transition properly for ordered transactions, though.
        if (mReordered) {
            verifyAndClearTransition(fragment2.returnTransition, null, midGreen, midBlue);
            final View endGreen = findGreen();
            final View endBlue = findBlue();
            final View endRed = findRed();
            verifyAndClearTransition(fragment3.enterTransition, null, endGreen, endBlue, endRed);
            verifyNoOtherTransitions(fragment2);
            verifyNoOtherTransitions(fragment3);
        } else {
            // fragment3 doesn't get a transition since it conflicts with the pop transition
            verifyNoOtherTransitions(fragment3);
            // Everything else is just doing its best. Reordered transactions can't handle
            // multiple transitions acting together except for popping multiple together.
        }
    }

    private TransitionFragment setupInitialFragment() throws Throwable {
        TransitionFragment fragment1 = new TransitionFragment();
        fragment1.setLayoutId(R.layout.scene1);
        mFragmentManager.beginTransaction()
                .setReorderingAllowed(mReordered)
                .add(R.id.fragmentContainer, fragment1)
                .addToBackStack(null)
                .commit();
        FragmentTestUtil.waitForExecution(mActivityRule);
        assertEquals(1, mOnBackStackChangedTimes);
        fragment1.waitForTransition();
        final View blueSquare1 = findBlue();
        final View greenSquare1 = findGreen();
        verifyAndClearTransition(fragment1.enterTransition, null, blueSquare1, greenSquare1);
        verifyNoOtherTransitions(fragment1);
        return fragment1;
    }

    private View findViewById(Fragment fragment, int id) {
        return fragment.getView().findViewById(id);
    }

    private View findGreen() {
        return mActivityRule.getActivity().findViewById(R.id.greenSquare);
    }

    private View findBlue() {
        return mActivityRule.getActivity().findViewById(R.id.blueSquare);
    }

    private View findRed() {
        return mActivityRule.getActivity().findViewById(R.id.redSquare);
    }

    private void verifyAndClearTransition(TargetTracking transition, Rect epicenter,
            View... expected) {
        if (epicenter == null) {
            assertNull(transition.getCapturedEpicenter());
        } else {
            assertEquals(epicenter, transition.getCapturedEpicenter());
        }
        ArrayList<View> targets = transition.getTrackedTargets();
        String errorMessage = "Expected: [" + expected.length + "] {" +
                Arrays.stream(expected).map(v -> v.toString()).collect(Collectors.joining(", ")) +
                "}, but got: [" + targets.size() + "] {" +
                targets.stream().map(v -> v.toString()).collect(Collectors.joining(", ")) +
                "}";
        assertEquals(errorMessage, expected.length, targets.size());
        for (View view : expected) {
            assertTrue(errorMessage, targets.contains(view));
        }
        transition.clearTargets();
    }

    private void verifyNoOtherTransitions(TransitionFragment fragment) {
        assertEquals(0, fragment.enterTransition.targets.size());
        assertEquals(0, fragment.exitTransition.targets.size());
        assertEquals(0, fragment.reenterTransition.targets.size());
        assertEquals(0, fragment.returnTransition.targets.size());
        assertEquals(0, fragment.sharedElementEnter.targets.size());
        assertEquals(0, fragment.sharedElementReturn.targets.size());
    }

    private void verifyTransition(TransitionFragment from, TransitionFragment to,
            String sharedElementName) throws Throwable {
        final int startOnBackStackChanged = mOnBackStackChangedTimes;
        final View startBlue = findBlue();
        final View startGreen = findGreen();
        final View startRed = findRed();

        final Rect startBlueRect = getBoundsOnScreen(startBlue);

        mFragmentManager.beginTransaction()
                .setReorderingAllowed(mReordered)
                .addSharedElement(startBlue, sharedElementName)
                .replace(R.id.fragmentContainer, to)
                .addToBackStack(null)
                .commit();

        FragmentTestUtil.waitForExecution(mActivityRule);
        assertEquals(startOnBackStackChanged + 1, mOnBackStackChangedTimes);

        to.waitForTransition();
        final View endGreen = findGreen();
        final View endBlue = findBlue();
        final View endRed = findRed();
        final Rect endBlueRect = getBoundsOnScreen(endBlue);

        if (startRed != null) {
            verifyAndClearTransition(from.exitTransition, startBlueRect, startGreen, startRed);
        } else {
            verifyAndClearTransition(from.exitTransition, startBlueRect, startGreen);
        }
        verifyNoOtherTransitions(from);

        if (endRed != null) {
            verifyAndClearTransition(to.enterTransition, endBlueRect, endGreen, endRed);
        } else {
            verifyAndClearTransition(to.enterTransition, endBlueRect, endGreen);
        }
        verifyAndClearTransition(to.sharedElementEnter, startBlueRect, startBlue, endBlue);
        verifyNoOtherTransitions(to);
    }

    private void verifyCrossTransition(boolean swapSource,
            TransitionFragment from1, TransitionFragment from2) throws Throwable {
        final int startNumOnBackStackChanged = mOnBackStackChangedTimes;
        final int changesPerOperation = mReordered ? 1 : 2;
        final TransitionFragment to1 = new TransitionFragment();
        to1.setLayoutId(R.layout.scene2);
        final TransitionFragment to2 = new TransitionFragment();
        to2.setLayoutId(R.layout.scene2);

        final View fromExit1 = findViewById(from1, R.id.greenSquare);
        final View fromShared1 = findViewById(from1, R.id.blueSquare);
        final Rect fromSharedRect1 = getBoundsOnScreen(fromShared1);

        final int fromExitId2 = swapSource ? R.id.blueSquare : R.id.greenSquare;
        final int fromSharedId2 = swapSource ? R.id.greenSquare : R.id.blueSquare;
        final View fromExit2 = findViewById(from2, fromExitId2);
        final View fromShared2 = findViewById(from2, fromSharedId2);
        final Rect fromSharedRect2 = getBoundsOnScreen(fromShared2);

        final String sharedElementName = swapSource ? "blueSquare" : "greenSquare";

        mActivityRule.runOnUiThread(() -> {
            mFragmentManager.beginTransaction()
                    .setReorderingAllowed(mReordered)
                    .addSharedElement(fromShared1, "blueSquare")
                    .replace(R.id.fragmentContainer1, to1)
                    .addToBackStack(null)
                    .commit();
            mFragmentManager.beginTransaction()
                    .setReorderingAllowed(mReordered)
                    .addSharedElement(fromShared2, sharedElementName)
                    .replace(R.id.fragmentContainer2, to2)
                    .addToBackStack(null)
                    .commit();
        });
        FragmentTestUtil.waitForExecution(mActivityRule);

        assertEquals(startNumOnBackStackChanged + changesPerOperation, mOnBackStackChangedTimes);

        from1.waitForTransition();
        from2.waitForTransition();
        to1.waitForTransition();
        to2.waitForTransition();

        final View toEnter1 = findViewById(to1, R.id.greenSquare);
        final View toShared1 = findViewById(to1, R.id.blueSquare);
        final Rect toSharedRect1 = getBoundsOnScreen(toShared1);

        final View toEnter2 = findViewById(to2, fromSharedId2);
        final View toShared2 = findViewById(to2, fromExitId2);
        final Rect toSharedRect2 = getBoundsOnScreen(toShared2);

        verifyAndClearTransition(from1.exitTransition, fromSharedRect1, fromExit1);
        verifyAndClearTransition(from2.exitTransition, fromSharedRect2, fromExit2);
        verifyNoOtherTransitions(from1);
        verifyNoOtherTransitions(from2);

        verifyAndClearTransition(to1.enterTransition, toSharedRect1, toEnter1);
        verifyAndClearTransition(to2.enterTransition, toSharedRect2, toEnter2);
        verifyAndClearTransition(to1.sharedElementEnter, fromSharedRect1, fromShared1, toShared1);
        verifyAndClearTransition(to2.sharedElementEnter, fromSharedRect2, fromShared2, toShared2);
        verifyNoOtherTransitions(to1);
        verifyNoOtherTransitions(to2);

        // Now pop it back
        mActivityRule.runOnUiThread(() -> {
            mFragmentManager.popBackStack();
            mFragmentManager.popBackStack();
        });
        FragmentTestUtil.waitForExecution(mActivityRule);
        assertEquals(startNumOnBackStackChanged + changesPerOperation + 1,
                mOnBackStackChangedTimes);

        from1.waitForTransition();
        from2.waitForTransition();
        to1.waitForTransition();
        to2.waitForTransition();

        final View returnEnter1 = findViewById(from1, R.id.greenSquare);
        final View returnShared1 = findViewById(from1, R.id.blueSquare);

        final View returnEnter2 = findViewById(from2, fromExitId2);
        final View returnShared2 = findViewById(from2, fromSharedId2);

        verifyAndClearTransition(to1.returnTransition, toSharedRect1, toEnter1);
        verifyAndClearTransition(to2.returnTransition, toSharedRect2, toEnter2);
        verifyAndClearTransition(to1.sharedElementReturn, toSharedRect1, toShared1, returnShared1);
        verifyAndClearTransition(to2.sharedElementReturn, toSharedRect2, toShared2, returnShared2);
        verifyNoOtherTransitions(to1);
        verifyNoOtherTransitions(to2);

        verifyAndClearTransition(from1.reenterTransition, fromSharedRect1, returnEnter1);
        verifyAndClearTransition(from2.reenterTransition, fromSharedRect2, returnEnter2);
        verifyNoOtherTransitions(from1);
        verifyNoOtherTransitions(from2);
    }

    private void verifyPopTransition(final int numPops, TransitionFragment from,
            TransitionFragment to, TransitionFragment... others) throws Throwable {
        final int startOnBackStackChanged = mOnBackStackChangedTimes;
        final View startBlue = findBlue();
        final View startGreen = findGreen();
        final View startRed = findRed();
        final Rect startSharedRect = getBoundsOnScreen(startBlue);

        mActivityRule.runOnUiThread(() -> {
            for (int i = 0; i < numPops; i++) {
                mFragmentManager.popBackStack();
            }
        });
        FragmentTestUtil.waitForExecution(mActivityRule);
        assertEquals(startOnBackStackChanged + 1, mOnBackStackChangedTimes);

        to.waitForTransition();
        final View endGreen = findGreen();
        final View endBlue = findBlue();
        final View endRed = findRed();
        final Rect endSharedRect = getBoundsOnScreen(endBlue);

        if (startRed != null) {
            verifyAndClearTransition(from.returnTransition, startSharedRect, startGreen, startRed);
        } else {
            verifyAndClearTransition(from.returnTransition, startSharedRect, startGreen);
        }
        verifyAndClearTransition(from.sharedElementReturn, startSharedRect, startBlue, endBlue);
        verifyNoOtherTransitions(from);

        if (endRed != null) {
            verifyAndClearTransition(to.reenterTransition, endSharedRect, endGreen, endRed);
        } else {
            verifyAndClearTransition(to.reenterTransition, endSharedRect, endGreen);
        }
        verifyNoOtherTransitions(to);

        if (others != null) {
            for (TransitionFragment fragment : others) {
                verifyNoOtherTransitions(fragment);
            }
        }
    }

    private static Rect getBoundsOnScreen(View view) {
        final int[] loc = new int[2];
        view.getLocationOnScreen(loc);
        return new Rect(loc[0], loc[1], loc[0] + view.getWidth(), loc[1] + view.getHeight());
    }

    public static class ComplexTransitionFragment extends TransitionFragment {
        public final TrackingTransition sharedElementEnterTransition1 = new TrackingTransition();
        public final TrackingTransition sharedElementEnterTransition2 = new TrackingTransition();
        public final TrackingTransition sharedElementReturnTransition1 = new TrackingTransition();
        public final TrackingTransition sharedElementReturnTransition2 = new TrackingTransition();

        public final TransitionSet sharedElementEnterTransition = new TransitionSet()
                .addTransition(sharedElementEnterTransition1)
                .addTransition(sharedElementEnterTransition2);
        public final TransitionSet sharedElementReturnTransition = new TransitionSet()
                .addTransition(sharedElementReturnTransition1)
                .addTransition(sharedElementReturnTransition2);

        public ComplexTransitionFragment() {
            sharedElementEnterTransition1.addTarget(R.id.blueSquare);
            sharedElementEnterTransition2.addTarget(R.id.greenSquare);
            sharedElementReturnTransition1.addTarget(R.id.blueSquare);
            sharedElementReturnTransition2.addTarget(R.id.greenSquare);
            setSharedElementEnterTransition(sharedElementEnterTransition);
            setSharedElementReturnTransition(sharedElementReturnTransition);
        }
    }

    public static class InvisibleFragment extends TransitionFragment {
        @Override
        public void onViewCreated(View view, Bundle savedInstanceState) {
            view.setVisibility(View.INVISIBLE);
            super.onViewCreated(view, savedInstanceState);
        }
    }
}