FragmentTransactionTest.java revision af556dcfc63652cafa822a3d742ad96c78bff037 
1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package android.support.v4.app;
17
18import static junit.framework.TestCase.assertFalse;
19import static junit.framework.TestCase.assertTrue;
20
21import android.support.fragment.test.R;
22import android.support.test.InstrumentationRegistry;
23import android.support.test.rule.ActivityTestRule;
24import android.support.test.runner.AndroidJUnit4;
25import android.support.v4.app.test.FragmentTestActivity;
26
27import org.junit.Before;
28import org.junit.Rule;
29import org.junit.Test;
30import org.junit.runner.RunWith;
31
32/**
33 * Tests usage of the {@link FragmentTransaction} class.
34 */
35@RunWith(AndroidJUnit4.class)
36public class FragmentTransactionTest {
37
38    @Rule
39    public ActivityTestRule<FragmentTestActivity> mActivityRule =
40            new ActivityTestRule<>(FragmentTestActivity.class);
41
42    private FragmentTestActivity mActivity;
43
44    @Before
45    public void setUp() {
46        mActivity = mActivityRule.getActivity();
47    }
48
49    @Test
50    public void testAddTransactionWithValidFragment() {
51        final Fragment fragment = new CorrectFragment();
52        InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() {
53            @Override
54            public void run() {
55                mActivity.getSupportFragmentManager().beginTransaction()
56                        .add(R.id.content, fragment)
57                        .addToBackStack(null)
58                        .commit();
59                mActivity.getSupportFragmentManager().executePendingTransactions();
60            }
61        });
62        InstrumentationRegistry.getInstrumentation().waitForIdleSync();
63        assertTrue(fragment.isAdded());
64    }
65
66    @Test
67    public void testAddTransactionWithPrivateFragment() {
68        final Fragment fragment = new PrivateFragment();
69        InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() {
70            @Override
71            public void run() {
72                boolean exceptionThrown = false;
73                try {
74                    mActivity.getSupportFragmentManager().beginTransaction()
75                            .add(R.id.content, fragment)
76                            .addToBackStack(null)
77                            .commit();
78                    mActivity.getSupportFragmentManager().executePendingTransactions();
79                } catch (IllegalStateException e) {
80                    exceptionThrown = true;
81                } finally {
82                    assertTrue("Exception should be thrown", exceptionThrown);
83                    assertFalse("Fragment shouldn't be added", fragment.isAdded());
84                }
85            }
86        });
87        InstrumentationRegistry.getInstrumentation().waitForIdleSync();
88    }
89
90    @Test
91    public void testAddTransactionWithPackagePrivateFragment() {
92        final Fragment fragment = new PackagePrivateFragment();
93        InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() {
94            @Override
95            public void run() {
96                boolean exceptionThrown = false;
97                try {
98                    mActivity.getSupportFragmentManager().beginTransaction()
99                            .add(R.id.content, fragment)
100                            .addToBackStack(null)
101                            .commit();
102                    mActivity.getSupportFragmentManager().executePendingTransactions();
103                } catch (IllegalStateException e) {
104                    exceptionThrown = true;
105                } finally {
106                    assertTrue("Exception should be thrown", exceptionThrown);
107                    assertFalse("Fragment shouldn't be added", fragment.isAdded());
108                }
109            }
110        });
111        InstrumentationRegistry.getInstrumentation().waitForIdleSync();
112    }
113
114    @Test
115    public void testAddTransactionWithAnonymousFragment() {
116        final Fragment fragment = new Fragment() {};
117        InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() {
118            @Override
119            public void run() {
120                boolean exceptionThrown = false;
121                try {
122                    mActivity.getSupportFragmentManager().beginTransaction()
123                            .add(R.id.content, fragment)
124                            .addToBackStack(null)
125                            .commit();
126                    mActivity.getSupportFragmentManager().executePendingTransactions();
127                } catch (IllegalStateException e) {
128                    exceptionThrown = true;
129                } finally {
130                    assertTrue("Exception should be thrown", exceptionThrown);
131                    assertFalse("Fragment shouldn't be added", fragment.isAdded());
132                }
133            }
134        });
135        InstrumentationRegistry.getInstrumentation().waitForIdleSync();
136    }
137
138    @Test
139    public void testAddTransactionWithNonStaticFragment() {
140        final Fragment fragment = new NonStaticFragment();
141        InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() {
142            @Override
143            public void run() {
144                boolean exceptionThrown = false;
145                try {
146                    mActivity.getSupportFragmentManager().beginTransaction()
147                            .add(R.id.content, fragment)
148                            .addToBackStack(null)
149                            .commit();
150                    mActivity.getSupportFragmentManager().executePendingTransactions();
151                } catch (IllegalStateException e) {
152                    exceptionThrown = true;
153                } finally {
154                    assertTrue("Exception should be thrown", exceptionThrown);
155                    assertFalse("Fragment shouldn't be added", fragment.isAdded());
156                }
157            }
158        });
159        InstrumentationRegistry.getInstrumentation().waitForIdleSync();
160    }
161
162    public static class CorrectFragment extends Fragment {}
163
164    private static class PrivateFragment extends Fragment {}
165
166    static class PackagePrivateFragment extends Fragment {}
167
168    private class NonStaticFragment extends Fragment {}
169}
170