react-native-navigation 8.2.1 → 8.2.2

package/lib/android/app/src/androidTest/java/com/reactnativenavigation/utils/ButtonPresenterTest.kt

@@ -0,0 +1,379 @@
+package com.reactnativenavigation.utils
+
+import android.app.Activity
+import android.app.Application
+import android.content.res.Configuration
+import android.graphics.Color
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffColorFilter
+import android.text.SpannableString
+import android.view.Menu
+import android.view.MenuItem
+import android.widget.TextView
+import androidx.appcompat.widget.ActionMenuView
+import androidx.test.espresso.Espresso
+import androidx.test.ext.junit.rules.ActivityScenarioRule
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.reactnativenavigation.BaseAndroidTest
+import com.reactnativenavigation.TestActivity
+import com.reactnativenavigation.fakes.IconResolverFake
+import com.reactnativenavigation.mocks.ImageLoaderMock.mock
+import com.reactnativenavigation.options.ButtonOptions
+import com.reactnativenavigation.options.IconBackgroundOptions
+import com.reactnativenavigation.options.params.Bool
+import com.reactnativenavigation.options.params.Colour
+import com.reactnativenavigation.options.params.Number
+import com.reactnativenavigation.options.params.Text
+import com.reactnativenavigation.options.params.ThemeColour
+import com.reactnativenavigation.viewcontrollers.stack.topbar.button.ButtonController
+import com.reactnativenavigation.viewcontrollers.stack.topbar.button.ButtonPresenter
+import com.reactnativenavigation.views.stack.topbar.titlebar.ButtonBar
+import com.reactnativenavigation.views.stack.topbar.titlebar.IconBackgroundDrawable
+import com.reactnativenavigation.views.stack.topbar.titlebar.TitleBarButtonCreator
+import org.assertj.core.api.Java6Assertions
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito
+import java.util.Objects
+
+@RunWith(AndroidJUnit4::class)
+class ButtonPresenterTest : BaseAndroidTest() {
+    private lateinit var titleBar: ButtonBar
+    private lateinit var uut: ButtonPresenter
+    private lateinit var buttonController: ButtonController
+    private lateinit var button: ButtonOptions
+    private lateinit var activity: Activity
+
+    @get:Rule
+    val rule = ActivityScenarioRule(TestActivity::class.java)
+
+    @Before
+    fun beforeEach() {
+        rule.scenario.onActivity { activity: TestActivity ->
+            this.activity =
+                activity
+            titleBar = ButtonBar(activity)
+            activity.setContentView(titleBar)
+            button = createButton()
+
+            val imageLoaderMock =
+                mock()
+            initUUt(imageLoaderMock)
+        }
+    }
+
+    private fun initUUt(imageLoaderMock: ImageLoader) {
+        val iconResolver = IconResolverFake(
+            activity, imageLoaderMock
+        )
+        uut = ButtonPresenter(activity, button, iconResolver)
+        buttonController = ButtonController(
+            activity,
+            uut,
+            button,
+            Mockito.mock(TitleBarButtonCreator::class.java),
+            Mockito.mock(
+                ButtonController.OnClickListener::class.java
+            )
+        )
+    }
+
+    @Test
+    fun applyOptions_buttonIsAddedToMenu() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            addButtonAndApplyOptions()
+            Java6Assertions.assertThat(findButtonView().text.toString())
+                .isEqualTo(BTN_TEXT)
+        }
+    }
+
+    @Test
+    fun applyOptions_appliesColorOnButtonTextView() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            button.color =
+                ThemeColour(Colour(Color.RED), Colour(Color.RED))
+            addButtonAndApplyOptions()
+        }
+        Espresso.onIdle()
+        Java6Assertions.assertThat(findButtonView().currentTextColor).isEqualTo(Color.RED)
+    }
+
+    @Test
+    fun applyOptions_appliesColorOnButtonTextViewOnDarkMode() {
+        val application = InstrumentationRegistry.getInstrumentation().targetContext.applicationContext as Application
+        application.resources.configuration.uiMode = Configuration.UI_MODE_NIGHT_NO
+        button.color = ThemeColour(Colour(Color.RED), Colour(Color.BLACK))
+        var menuItem: MenuItem? = null
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            menuItem = addButtonAndApplyOptions()
+        }
+        Espresso.onIdle()
+        Java6Assertions.assertThat(findButtonView().currentTextColor).isEqualTo(Color.RED)
+
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            application.resources.configuration.uiMode = Configuration.UI_MODE_NIGHT_YES
+            uut.applyOptions(titleBar, menuItem!!) { buttonController.view }
+        }
+        Espresso.onIdle()
+        Java6Assertions.assertThat(findButtonView().currentTextColor).isEqualTo(Color.BLACK)
+    }
+
+    @Test
+    fun apply_disabledColor() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            button.enabled = Bool(false)
+            addButtonAndApplyOptions()
+        }
+        Espresso.onIdle()
+        Java6Assertions.assertThat(findButtonView().currentTextColor)
+            .isEqualTo(ButtonPresenter.DISABLED_COLOR)
+    }
+
+    @Test
+    fun applyColor_shouldChangeColor() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            val menuItem = addMenuButton()
+            uut.applyOptions(titleBar, menuItem) { buttonController.view }
+            val color =
+                ThemeColour(Colour(Color.RED), Colour(Color.RED))
+            uut.applyColor(titleBar, menuItem, color)
+        }
+        Espresso.onIdle()
+        Java6Assertions.assertThat(findButtonView().currentTextColor).isEqualTo(Color.RED)
+    }
+
+    @Test
+    fun applyBackgroundColor_shouldChangeBackgroundColor() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            val mockD = Mockito.mock(
+                IconBackgroundDrawable::class.java
+            )
+            initUUt(mock(mockD))
+            button.enabled = Bool(true)
+            button.icon = Text("icon")
+            button.color =
+                ThemeColour(Colour(Color.RED), Colour(Color.RED))
+            val iconBackground = IconBackgroundOptions()
+            iconBackground.color = ThemeColour(
+                Colour(Color.GREEN),
+                Colour(Color.GREEN)
+            )
+            button.iconBackground = iconBackground
+            val menuItem = Mockito.spy(addMenuButton())
+            uut.applyOptions(titleBar, menuItem) { buttonController.view }
+
+            Java6Assertions.assertThat((menuItem.icon as IconBackgroundDrawable).backgroundColor)
+                .isEqualTo(Color.GREEN)
+
+            uut.applyBackgroundColor(
+                titleBar, menuItem,
+                ThemeColour(
+                    Colour(Color.BLACK),
+                    Colour(Color.BLACK)
+                )
+            )
+            Java6Assertions.assertThat((menuItem.icon as IconBackgroundDrawable).backgroundColor)
+                .isEqualTo(Color.BLACK)
+        }
+    }
+
+    @Test
+    fun applyOptions_shouldChangeIconColorTint() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            val mockD = Mockito.mock(
+                IconBackgroundDrawable::class.java
+            )
+            initUUt(mock(mockD))
+            button.enabled = Bool(true)
+            button.icon = Text("icon")
+            button.color =
+                ThemeColour(Colour(Color.RED), Colour(Color.RED))
+            val menuItem = Mockito.spy(addMenuButton())
+            uut.applyOptions(titleBar, menuItem) { buttonController.view }
+
+            val icon = menuItem.icon
+            Java6Assertions.assertThat(
+                icon
+            ).isNotNull()
+            Mockito.verify(icon)?.colorFilter =
+                PorterDuffColorFilter(Color.RED, PorterDuff.Mode.SRC_IN)
+        }
+    }
+
+    @Test
+    fun applyOptions_shouldChangeIconDisabledColorTint() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            val mockD = Mockito.mock(
+                IconBackgroundDrawable::class.java
+            )
+            initUUt(mock(mockD))
+            button.enabled = Bool(false)
+            button.icon = Text("icon")
+            button.color =
+                ThemeColour(Colour(Color.RED), Colour(Color.RED))
+            button.disabledColor = ThemeColour(
+                Colour(Color.YELLOW),
+                Colour(Color.YELLOW)
+            )
+            val menuItem = Mockito.spy(addMenuButton())
+            uut.applyOptions(titleBar, menuItem) { buttonController.view }
+
+            val icon = menuItem.icon
+            Java6Assertions.assertThat(
+                icon
+            ).isNotNull()
+            Mockito.verify(icon)?.colorFilter =
+                PorterDuffColorFilter(Color.YELLOW, PorterDuff.Mode.SRC_IN)
+        }
+    }
+
+    @Test
+    fun applyOptions_shouldChangeIconColorBackground() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            val mockD = Mockito.mock(
+                IconBackgroundDrawable::class.java
+            )
+            initUUt(mock(mockD))
+            button.enabled = Bool(true)
+            button.icon = Text("icon")
+            button.color =
+                ThemeColour(Colour(Color.RED), Colour(Color.RED))
+            val iconBackground = IconBackgroundOptions()
+            iconBackground.color = ThemeColour(
+                Colour(Color.GREEN),
+                Colour(Color.GREEN)
+            )
+            button.iconBackground = iconBackground
+            val menuItem = Mockito.spy(addMenuButton())
+            uut.applyOptions(titleBar, menuItem) { buttonController.view }
+
+            val icon = menuItem.icon
+            Java6Assertions.assertThat(
+                icon
+            ).isNotNull()
+            Java6Assertions.assertThat(
+                icon
+            ).isInstanceOf(
+                IconBackgroundDrawable::class.java
+            )
+            val modifed = icon as IconBackgroundDrawable?
+            Mockito.verify(modifed!!.getWrappedDrawable()).colorFilter =
+                PorterDuffColorFilter(Color.RED, PorterDuff.Mode.SRC_IN)
+            Java6Assertions.assertThat(modifed.backgroundColor)
+                .isEqualTo(Color.GREEN)
+        }
+    }
+
+    @Test
+    fun applyOptions_shouldChangeIconDisabledColorBackground() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            val mockD = Mockito.mock(
+                IconBackgroundDrawable::class.java
+            )
+            initUUt(mock(mockD))
+            button.enabled = Bool(false)
+            button.icon = Text("icon")
+            button.color =
+                ThemeColour(Colour(Color.RED), Colour(Color.RED))
+            button.disabledColor = ThemeColour(
+                Colour(Color.YELLOW),
+                Colour(Color.YELLOW)
+            )
+            val iconBackground = IconBackgroundOptions()
+            iconBackground.color = ThemeColour(
+                Colour(Color.GREEN),
+                Colour(Color.GREEN)
+            )
+            iconBackground.disabledColor = ThemeColour(
+                Colour(Color.CYAN),
+                Colour(Color.CYAN)
+            )
+            button.iconBackground = iconBackground
+            val menuItem = Mockito.spy(addMenuButton())
+            uut.applyOptions(titleBar, menuItem) { buttonController.view }
+
+            val icon = menuItem.icon
+            Java6Assertions.assertThat(
+                icon
+            ).isNotNull()
+            Java6Assertions.assertThat(
+                icon
+            ).isInstanceOf(
+                IconBackgroundDrawable::class.java
+            )
+            val modifed = icon as IconBackgroundDrawable?
+            Mockito.verify(modifed!!.getWrappedDrawable()).colorFilter =
+                PorterDuffColorFilter(Color.YELLOW, PorterDuff.Mode.SRC_IN)
+            Java6Assertions.assertThat(modifed.backgroundColor)
+                .isEqualTo(Color.CYAN)
+        }
+    }
+
+    @Test
+    fun applyColor_shouldChangeDisabledColor() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            button.enabled = Bool(false)
+            val menuItem = addMenuButton()
+            uut.applyOptions(titleBar, menuItem) { buttonController.view }
+            val disabledColor = ThemeColour(
+                Colour(Color.BLUE),
+                Colour(Color.BLUE)
+            )
+            uut.applyDisabledColor(titleBar, menuItem, disabledColor)
+        }
+        Espresso.onIdle()
+        Java6Assertions.assertThat(findButtonView().currentTextColor).isEqualTo(Color.BLUE)
+    }
+
+    @Test
+    fun apply_allCaps() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            button.allCaps = Bool(false)
+            addButtonAndApplyOptions()
+            Java6Assertions.assertThat(findButtonView().isAllCaps)
+                .isEqualTo(false)
+        }
+    }
+
+    private fun addButtonAndApplyOptions(): MenuItem {
+        val menuItem = addMenuButton()
+        uut.applyOptions(titleBar, menuItem) { buttonController.view }
+        return menuItem
+    }
+
+    private fun addMenuButton(): MenuItem {
+        return titleBar.addButton(
+            Menu.NONE,
+            1,
+            0,
+            SpannableString.valueOf(button.text["text"])
+        ) ?: throw IllegalStateException("MenuItem should not be null")
+    }
+
+    private fun findButtonView(): TextView {
+        return ViewUtils.findChildrenByClass(
+            Objects.requireNonNull(
+                ViewUtils.findChildByClass(
+                    titleBar,
+                    ActionMenuView::class.java
+                )
+            ),
+            TextView::class.java
+        ) { child: Any? -> true }[0] as TextView
+    }
+
+    private fun createButton(): ButtonOptions {
+        val b = ButtonOptions()
+        b.id = "btn1"
+        b.text = Text(BTN_TEXT)
+        b.showAsAction = Number(MenuItem.SHOW_AS_ACTION_ALWAYS)
+        return b
+    }
+
+    companion object {
+        private const val BTN_TEXT = "button1"
+    }
+}

package/lib/android/app/src/androidTest/java/com/reactnativenavigation/viewcontrollers/bottomtabs/attacher/modes/AfterInitialTabTest.kt

@@ -0,0 +1,42 @@
+package com.reactnativenavigation.viewcontrollers.bottomtabs.attacher.modes
+
+import androidx.test.espresso.Espresso
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Before
+import org.junit.Test
+import org.mockito.Mockito.verify
+import org.mockito.kotlin.any
+
+class AfterInitialTabTest : AttachModeTest() {
+
+    @Before
+    override fun setup() {
+        super.setup()
+        uut = AfterInitialTab(parent, tabs, presenter, options)
+    }
+
+    @Test
+    fun attach_initialTabIsAttached() {
+        uut.attach()
+        assertIsChild(parent, tab2)
+    }
+
+    @Test
+    fun attach_otherTabsAreAttachedAfterInitialTab() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync {
+            uut.attach()
+
+            assertNotChildOf(parent, *otherTabs())
+
+            initialTab().onViewWillAppear()
+        }
+        Espresso.onIdle()
+        assertIsChild(parent, *otherTabs())
+    }
+
+    @Test
+    fun destroy() {
+        uut.destroy()
+        verify(initialTab()).removeOnAppearedListener(any())
+    }
+} 

package/lib/android/app/src/androidTest/java/com/reactnativenavigation/viewcontrollers/bottomtabs/attacher/modes/AttachModeTest.kt

@@ -0,0 +1,98 @@
+package com.reactnativenavigation.viewcontrollers.bottomtabs.attacher.modes
+
+import android.view.View
+import android.view.ViewGroup
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.test.ext.junit.rules.ActivityScenarioRule
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.reactnativenavigation.TestActivity
+import com.reactnativenavigation.mocks.SimpleViewController
+import com.reactnativenavigation.options.Options
+import com.reactnativenavigation.options.params.Number
+import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabsPresenter
+import com.reactnativenavigation.viewcontrollers.child.ChildControllersRegistry
+import com.reactnativenavigation.viewcontrollers.viewcontroller.ViewController
+import com.reactnativenavigation.views.bottomtabs.BottomTabsBehaviour
+import org.assertj.core.api.AssertionsForInterfaceTypes.assertThat
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito
+import org.mockito.Mockito.spy
+
+@RunWith(AndroidJUnit4::class)
+abstract class AttachModeTest {
+    private val INITIAL_TAB = 1
+
+    private lateinit var childRegistry: ChildControllersRegistry
+    protected lateinit var parent: ViewGroup
+    protected lateinit var tab1: ViewController<*>
+    protected lateinit var tab2: ViewController<*>
+    protected lateinit var tabs: List<ViewController<*>>
+    protected lateinit var options: Options
+    protected lateinit var presenter: BottomTabsPresenter
+    protected lateinit var uut: AttachMode
+
+    @get:Rule
+    val rule = ActivityScenarioRule(TestActivity::class.java)
+
+    @Before
+    open fun setup() {
+        rule.scenario.onActivity { activity ->
+            childRegistry = ChildControllersRegistry()
+            parent = CoordinatorLayout(activity)
+            tabs = createTabs(activity)
+        }
+        options = Options()
+        options.bottomTabsOptions.currentTabIndex = Number(INITIAL_TAB)
+        presenter = Mockito.mock(BottomTabsPresenter::class.java)
+    }
+
+    @Test
+    fun attach_layoutOptionsAreApplied() {
+        uut.attach(tab1)
+        val lp = tab1.getView().layoutParams as CoordinatorLayout.LayoutParams
+        assertThat(lp).isNotNull
+        assertThat(lp.behavior).isInstanceOf(BottomTabsBehaviour::class.java)
+    }
+
+    @Test
+    fun attach_initialTabIsVisible() {
+        uut.attach(initialTab())
+        assertThat(initialTab().getView().visibility).isEqualTo(View.VISIBLE)
+    }
+
+    @Test
+    fun attach_otherTabsAreInvisibleWhenAttached() {
+        otherTabs().forEach { t -> uut.attach(t) }
+        otherTabs().forEach { t -> assertThat(t.getView().visibility).isEqualTo(View.INVISIBLE) }
+    }
+
+    protected fun otherTabs(): Array<ViewController<*>> {
+        return tabs.filter { t -> t != initialTab() }.toTypedArray()
+    }
+
+    protected fun initialTab(): ViewController<*> {
+        return tabs[INITIAL_TAB]
+    }
+
+    private fun createTabs(activity: android.app.Activity): List<ViewController<*>> {
+        tab1 = SimpleViewController(activity, childRegistry, "child1", Options())
+        tab2 = spy(SimpleViewController(activity, childRegistry, "child2", Options()))
+        val tab3 = SimpleViewController(activity, childRegistry, "child3", Options())
+        return listOf(tab1, tab2, tab3)
+    }
+
+    protected fun assertIsChild(parent: ViewGroup, vararg children: ViewController<*>) {
+        children.forEach { child ->
+            assertThat(child.getView().parent).isEqualTo(parent)
+        }
+    }
+
+    protected fun assertNotChildOf(parent: ViewGroup, vararg children: ViewController<*>) {
+        children.forEach { child ->
+            assertThat(child.getView().parent).isNotEqualTo(parent)
+        }
+    }
+} 

package/lib/android/app/src/androidTest/java/com/reactnativenavigation/viewcontrollers/bottomtabs/attacher/modes/OnSwitchToTabTest.kt

@@ -0,0 +1,32 @@
+package com.reactnativenavigation.viewcontrollers.bottomtabs.attacher.modes
+
+import org.junit.Before
+import org.junit.Test
+
+class OnSwitchToTabTest : AttachModeTest() {
+
+    @Before
+    override fun setup() {
+        super.setup()
+        uut = OnSwitchToTab(parent, tabs, presenter, options)
+    }
+
+    @Test
+    fun attach_onlyInitialTabIsAttached() {
+        uut.attach()
+        assertIsChild(parent, initialTab())
+        assertNotChildOf(parent, *otherTabs())
+    }
+
+    @Test
+    fun onTabSelected_initialTabIsNotHandled() {
+        uut.onTabSelected(initialTab())
+        assertNotChildOf(parent, initialTab())
+    }
+
+    @Test
+    fun onTabSelected_otherTabIsAttached() {
+        uut.onTabSelected(tab1)
+        assertIsChild(parent, tab1)
+    }
+} 

package/lib/android/app/src/androidTest/java/com/reactnativenavigation/viewcontrollers/bottomtabs/attacher/modes/TogetherTest.kt

@@ -0,0 +1,19 @@
+package com.reactnativenavigation.viewcontrollers.bottomtabs.attacher.modes
+
+import org.junit.Before
+import org.junit.Test
+
+class TogetherTest : AttachModeTest() {
+
+    @Before
+    override fun setup() {
+        super.setup()
+        uut = Together(parent, tabs, presenter, options)
+    }
+
+    @Test
+    fun attach_allTabsAreAttached() {
+        uut.attach()
+        assertIsChild(parent, *tabs.toTypedArray())
+    }
+} 

package/lib/android/app/src/androidTest/java/com/reactnativenavigation/viewcontrollers/child/ChildControllerTest.java

@@ -0,0 +1,102 @@
+package com.reactnativenavigation.viewcontrollers.child;
+
+import androidx.test.ext.junit.rules.ActivityScenarioRule;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.core.app.ActivityScenario;
+
+import com.reactnativenavigation.BaseAndroidTest;
+import com.reactnativenavigation.TestActivity;
+import com.reactnativenavigation.mocks.SimpleViewController;
+import com.reactnativenavigation.options.Options;
+import com.reactnativenavigation.viewcontrollers.viewcontroller.Presenter;
+import com.reactnativenavigation.viewcontrollers.parent.ParentController;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+@RunWith(AndroidJUnit4.class)
+public class ChildControllerTest extends BaseAndroidTest {
+    private ChildController<?> uut;
+    private ChildControllersRegistry childRegistry;
+    private Presenter presenter;
+    private Options resolvedOptions = new Options();
+
+    @Rule
+    public ActivityScenarioRule<TestActivity> rule = new ActivityScenarioRule<>(TestActivity.class);
+
+    @Before
+    public void beforeEach() {
+        rule.getScenario().onActivity(activity -> {
+            childRegistry = spy(new ChildControllersRegistry());
+            presenter = Mockito.mock(Presenter.class);
+            uut = new SimpleViewController(activity, childRegistry, "childId", presenter, new Options()) {
+                @Override
+                public Options resolveCurrentOptions() {
+                    return resolvedOptions;
+                }
+            };
+            ParentController<?> parent = Mockito.mock(ParentController.class);
+            Mockito.when(parent.resolveChildOptions(uut)).thenReturn(Options.EMPTY);
+            uut.setParentController(parent);
+        });
+    }
+
+    @Test
+    public void onViewAppeared() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> uut.onViewWillAppear());
+        verify(childRegistry, times(1)).onViewAppeared(uut);
+    }
+
+    @Test
+    public void onViewDisappear() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> {
+            uut.onViewWillAppear();
+            uut.onViewDisappear();
+        });
+        verify(childRegistry, times(1)).onViewDisappear(uut);
+    }
+
+    @Test
+    public void mergeOptions() {
+        try (ActivityScenario<TestActivity> scenario = ActivityScenario.launch(TestActivity.class)) {
+            scenario.onActivity(activity -> {
+                activity.setContentView(uut.getView());
+                Options options = new Options();
+                uut.mergeOptions(options);
+                verify(presenter).mergeOptions(uut, options);
+            });
+        }
+    }
+
+    @Test
+    public void mergeOptions_emptyOptionsAreIgnored() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> {
+            uut.mergeOptions(Options.EMPTY);
+            verify(presenter, times(0)).mergeOptions(any(), any());
+        });
+    }
+
+    @Test
+    public void mergeOptions_mergeWithParentViewController() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> {
+            Options options = new Options();
+            uut.mergeOptions(options);
+            verify(uut.getParentController()).mergeChildOptions(options, uut);
+        });
+    }
+
+    @Test
+    public void destroy() {
+        InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> uut.destroy());
+        verify(childRegistry).onChildDestroyed(uut);
+    }
+}