react-native-navigation 7.24.3 → 7.25.1

package/lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/navigator/RootPresenterTest.kt

@@ -1,254 +0,0 @@
-package com.reactnativenavigation.viewcontrollers.navigator
-
-import android.app.Activity
-import androidx.coordinatorlayout.widget.CoordinatorLayout
-import com.facebook.react.ReactInstanceManager
-import com.reactnativenavigation.BaseTest
-import com.reactnativenavigation.TestActivity
-import com.reactnativenavigation.hierarchy.root.RootAnimator
-import com.reactnativenavigation.mocks.SimpleViewController
-import com.reactnativenavigation.options.*
-import com.reactnativenavigation.options.params.Bool
-import com.reactnativenavigation.react.CommandListenerAdapter
-import com.reactnativenavigation.viewcontrollers.child.ChildControllersRegistry
-import com.reactnativenavigation.viewcontrollers.viewcontroller.LayoutDirectionApplier
-import com.reactnativenavigation.viewcontrollers.viewcontroller.RootPresenter
-import com.reactnativenavigation.viewcontrollers.viewcontroller.ViewController
-import com.reactnativenavigation.views.BehaviourDelegate
-import org.assertj.core.api.Java6Assertions
-import org.junit.Test
-import org.mockito.ArgumentCaptor
-import org.mockito.Mockito
-import org.mockito.kotlin.any
-import org.mockito.kotlin.eq
-import org.mockito.kotlin.never
-import org.robolectric.android.controller.ActivityController
-
-class RootPresenterTest : BaseTest() {
-    private lateinit var uut: RootPresenter
-    private lateinit var rootContainer: CoordinatorLayout
-    private lateinit var root: ViewController<*>
-    private lateinit var root2: ViewController<*>
-    private lateinit var animator: RootAnimator
-    private lateinit var layoutDirectionApplier: LayoutDirectionApplier
-    private lateinit var defaultOptions: Options
-    private lateinit var reactInstanceManager: ReactInstanceManager
-    private lateinit var activity: Activity
-    private lateinit var activityController: ActivityController<TestActivity>
-    private lateinit var root1View: SimpleViewController.SimpleView
-    private lateinit var root2View: SimpleViewController.SimpleView
-    override fun beforeEach() {
-        activityController = newActivityController(TestActivity::class.java)
-        activity = activityController.create().get()
-        reactInstanceManager = Mockito.mock(ReactInstanceManager::class.java)
-        rootContainer = CoordinatorLayout(activity)
-        root1View = SimpleViewController.SimpleView(activity)
-        root2View = SimpleViewController.SimpleView(activity)
-
-        root = object : SimpleViewController(activity, ChildControllersRegistry(), "child1", Options()) {
-            override fun createView(): SimpleView {
-                return root1View
-            }
-        }
-        root2 = object : SimpleViewController(activity, ChildControllersRegistry(), "child1", Options()) {
-            override fun createView(): SimpleView {
-                return root2View
-            }
-        }
-        setupWithAnimator(Mockito.spy(createAnimator()))
-    }
-
-    @Test
-    fun setRoot_viewIsAddedToContainer() {
-        uut.setRoot(root, null, defaultOptions, CommandListenerAdapter(), reactInstanceManager)
-        Java6Assertions.assertThat(root.view.parent).isEqualTo(rootContainer)
-        Java6Assertions.assertThat((root.view.layoutParams as CoordinatorLayout.LayoutParams).behavior).isInstanceOf(BehaviourDelegate::class.java)
-    }
-
-    @Test
-    fun setRoot_reportsOnSuccess() {
-        val listener = Mockito.spy(CommandListenerAdapter())
-        uut.setRoot(root, null, defaultOptions, listener, reactInstanceManager)
-        Mockito.verify(listener).onSuccess(root.id)
-    }
-
-    @Test
-    fun setRoot_doesNotAnimateByDefault() {
-        val listener = Mockito.spy(CommandListenerAdapter())
-        uut.setRoot(root, null, defaultOptions, listener, reactInstanceManager)
-        Mockito.verifyNoInteractions(animator)
-        Mockito.verify(listener).onSuccess(root.id)
-    }
-
-    @Test
-    fun setRoot_playNoAnimationWhenOptionsHaveThemDisabled() {
-        setupWithAnimator(RootAnimator())
-        val animatedSetRoot = Options()
-        val enter = Mockito.spy(AnimationOptions())
-        val exit = Mockito.spy(AnimationOptions())
-        enter.enabled = Bool(false)
-        exit.enabled = Bool(false)
-        Mockito.`when`(enter.hasValue()).thenReturn(true)
-        Mockito.`when`(enter.hasAnimation()).thenReturn(true)
-
-        Mockito.`when`(exit.hasValue()).thenReturn(true)
-        Mockito.`when`(exit.hasValue()).thenReturn(true)
-
-
-        animatedSetRoot.animations.setRoot = createEnterExitTransitionAnim(enter, exit)
-        val spy = Mockito.spy(root)
-        val spy2 = Mockito.spy(root2)
-        Mockito.`when`(spy.resolveCurrentOptions(defaultOptions)).thenReturn(animatedSetRoot)
-        val listener = Mockito.spy(CommandListenerAdapter())
-        uut.setRoot(spy, spy2, defaultOptions, listener, reactInstanceManager)
-
-        Mockito.verify(enter, never()).getAnimation(spy.view)
-        Mockito.verify(exit, never()).getAnimation(spy2.view)
-    }
-
-    @Test
-    fun setRoot_playEnterAnimOnlyWhenNoDisappearingView() {
-        setupWithAnimator(RootAnimator())
-        val animatedSetRoot = Options()
-        val enter = Mockito.spy(AnimationOptions())
-        val exit = Mockito.spy(AnimationOptions())
-
-        Mockito.`when`(enter.hasValue()).thenReturn(true)
-        Mockito.`when`(enter.hasAnimation()).thenReturn(true)
-        Mockito.`when`(exit.hasValue()).thenReturn(false)
-
-        animatedSetRoot.animations.setRoot = createEnterExitTransitionAnim(enter, exit)
-        val spy = Mockito.spy(root)
-        Mockito.`when`(spy.resolveCurrentOptions(defaultOptions)).thenReturn(animatedSetRoot)
-        val listener = Mockito.spy(CommandListenerAdapter())
-        uut.setRoot(spy, null, defaultOptions, listener, reactInstanceManager)
-        Mockito.verify(enter).getAnimation(spy.view)
-        Mockito.verify(exit, never()).getAnimation(spy.view)
-    }
-
-    @Test
-    fun setRoot_playExitAnimOnlyWhenNoEnterAnimation() {
-        setupWithAnimator(RootAnimator())
-        val animatedSetRoot = Options()
-        val enter = Mockito.spy(AnimationOptions())
-        val exit = Mockito.spy(AnimationOptions())
-
-        Mockito.`when`(enter.hasValue()).thenReturn(false)
-        Mockito.`when`(enter.hasAnimation()).thenReturn(false)
-
-        Mockito.`when`(exit.hasValue()).thenReturn(true)
-        Mockito.`when`(exit.hasAnimation()).thenReturn(true)
-
-        animatedSetRoot.animations.setRoot = createEnterExitTransitionAnim(enter, exit)
-        val spy = Mockito.spy(root)
-        val spy2 = Mockito.spy(root2)
-        Mockito.`when`(spy.resolveCurrentOptions(defaultOptions)).thenReturn(animatedSetRoot)
-        val listener = Mockito.spy(CommandListenerAdapter())
-        uut.setRoot(spy, spy2, defaultOptions, listener, reactInstanceManager)
-        Mockito.verify(enter, never()).getAnimation(spy.view)
-        Mockito.verify(exit).getAnimation(spy2.view)
-    }
-
-
-    @Test
-    fun setRoot_playEnterExitAnimOnBothViews() {
-        setupWithAnimator(RootAnimator())
-        val animatedSetRoot = Options()
-        val enter = Mockito.spy(AnimationOptions())
-        val exit = Mockito.spy(AnimationOptions())
-
-        Mockito.`when`(enter.hasValue()).thenReturn(true)
-        Mockito.`when`(enter.hasAnimation()).thenReturn(true)
-
-        Mockito.`when`(exit.hasValue()).thenReturn(true)
-        Mockito.`when`(exit.hasAnimation()).thenReturn(true)
-
-        animatedSetRoot.animations.setRoot = createEnterExitTransitionAnim(enter, exit)
-        val spy = Mockito.spy(root)
-        val spy2 = Mockito.spy(root2)
-        Mockito.`when`(spy.resolveCurrentOptions(defaultOptions)).thenReturn(animatedSetRoot)
-        val listener = Mockito.spy(CommandListenerAdapter())
-        uut.setRoot(spy, spy2, defaultOptions, listener, reactInstanceManager)
-
-        Mockito.verify(enter).getAnimation(spy.view)
-        Mockito.verify(exit).getAnimation(spy2.view)
-    }
-
-
-
-    @Test
-    fun setRoot_animates() {
-        val animatedSetRoot = Options()
-        val enter = Mockito.spy(AnimationOptions())
-        Mockito.`when`(enter.hasValue()).thenReturn(true)
-        Mockito.`when`(enter.hasAnimation()).thenReturn(true)
-
-        animatedSetRoot.animations.setRoot = createEnterTransitionAnim(enter)
-        val spy = Mockito.spy(root)
-        Mockito.`when`(spy.resolveCurrentOptions(defaultOptions)).thenReturn(animatedSetRoot)
-        val listener = Mockito.spy(CommandListenerAdapter())
-        uut.setRoot(spy, null, defaultOptions, listener, reactInstanceManager)
-        Mockito.verify(listener).onSuccess(spy.id)
-        Mockito.verify(animator).setRoot(eq(spy), eq(null), eq(animatedSetRoot.animations.setRoot), any())
-    }
-
-    @Test
-    fun setRoot_waitForRenderIsSet() {
-        root.options.animations.setRoot.enter.waitForRender = Bool(true)
-        val spy = Mockito.spy(root)
-        uut.setRoot(spy, null, defaultOptions, CommandListenerAdapter(), reactInstanceManager)
-        val captor = ArgumentCaptor.forClass(Bool::class.java)
-        Mockito.verify(spy).setWaitForRender(captor.capture())
-        Java6Assertions.assertThat(captor.value.get()).isTrue()
-    }
-
-    @Test
-    fun setRoot_waitForRender() {
-        root.options.animations.setRoot.enter.waitForRender = Bool(true)
-        val spy = Mockito.spy(root)
-        val listener = Mockito.spy(CommandListenerAdapter())
-        uut.setRoot(spy, null, defaultOptions, listener, reactInstanceManager)
-        Mockito.verify(spy).addOnAppearedListener(any())
-        Java6Assertions.assertThat(spy.view.alpha).isZero()
-        Mockito.verifyNoInteractions(listener)
-        spy.onViewWillAppear()
-        idleMainLooper()
-        Java6Assertions.assertThat(spy.view.alpha).isOne()
-        Mockito.verify(listener).onSuccess(spy.id)
-    }
-
-    @Test
-    fun setRoot_appliesLayoutDirection() {
-        val listener = Mockito.spy(CommandListenerAdapter())
-        uut.setRoot(root, null, defaultOptions, listener, reactInstanceManager)
-        Mockito.verify(layoutDirectionApplier).apply(root, defaultOptions, reactInstanceManager)
-    }
-
-    private fun createAnimator(): RootAnimator {
-        return object : RootAnimator() {
-            override fun setRoot(appearing: ViewController<*>, disappearing: ViewController<*>?, setRoot: TransitionAnimationOptions, onAnimationEnd: () -> Unit) {
-                super.setRoot(appearing, disappearing, setRoot, onAnimationEnd)
-            }
-        }
-    }
-
-    private fun createEnterExitTransitionAnim(enter: AnimationOptions, exit: AnimationOptions): TransitionAnimationOptions {
-        return TransitionAnimationOptions(enter, exit, SharedElements(), ElementTransitions())
-    }
-
-    private fun createEnterTransitionAnim(enter: AnimationOptions): TransitionAnimationOptions {
-        return createEnterExitTransitionAnim(enter, AnimationOptions())
-    }
-
-    private fun createExitTransitionAnim(exit: AnimationOptions): TransitionAnimationOptions {
-        return createEnterExitTransitionAnim(AnimationOptions(), exit)
-    }
-
-    private fun setupWithAnimator(rootAnimator: RootAnimator) {
-        animator = rootAnimator
-        layoutDirectionApplier = Mockito.mock(LayoutDirectionApplier::class.java)
-        uut = RootPresenter(animator, layoutDirectionApplier)
-        uut.setRootContainer(rootContainer)
-        defaultOptions = Options()
-    }
-}

package/lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/overlay/OverlayManagerTest.java

@@ -1,108 +0,0 @@
-package com.reactnativenavigation.viewcontrollers.overlay;
-
-import android.app.Activity;
-import android.view.View;
-import android.widget.FrameLayout;
-
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.SimpleViewController;
-import com.reactnativenavigation.options.Options;
-import com.reactnativenavigation.react.CommandListener;
-import com.reactnativenavigation.react.CommandListenerAdapter;
-import com.reactnativenavigation.viewcontrollers.child.ChildControllersRegistry;
-
-import org.junit.Test;
-
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-public class OverlayManagerTest extends BaseTest {
-    private static final String OVERLAY_ID_1 = "OVERLAY_1";
-    private static final String OVERLAY_ID_2 = "OVERLAY_2";
-
-    private OverlayManager uut;
-    private SimpleViewController overlay1;
-    private SimpleViewController overlay2;
-    private FrameLayout contentLayout;
-    private FrameLayout overlayContainer;
-
-    @Override
-    public void beforeEach() {
-        super.beforeEach();
-        Activity activity = newActivity();
-        contentLayout = new FrameLayout(activity);
-        contentLayout.layout(0, 0, 1000, 1000);
-        activity.setContentView(contentLayout);
-        overlayContainer = new FrameLayout(activity);
-        contentLayout.addView(overlayContainer);
-
-        ChildControllersRegistry childRegistry = new ChildControllersRegistry();
-        overlay1 = spy(new SimpleViewController(activity, childRegistry, OVERLAY_ID_1, new Options()));
-        overlay2 = spy(new SimpleViewController(activity, childRegistry, OVERLAY_ID_2, new Options()));
-        uut = new OverlayManager();
-    }
-
-    @Test
-    public void show_attachesOverlayContainerToContentLayout() {
-        uut.show(overlayContainer, overlay1, new CommandListenerAdapter());
-        assertThat(overlayContainer.getParent()).isEqualTo(contentLayout);
-        uut.show(overlayContainer, overlay2, new CommandListenerAdapter());
-    }
-
-    @Test
-    public void show() {
-        CommandListenerAdapter listener = spy(new CommandListenerAdapter());
-        uut.show(overlayContainer, overlay1, listener);
-        idleMainLooper();
-        verify(listener).onSuccess(OVERLAY_ID_1);
-        verify(overlay1).onViewDidAppear();
-        assertThat(overlay1.getView().getParent()).isEqualTo(overlayContainer);
-        assertMatchParent(overlay1.getView());
-    }
-
-    @Test
-    public void dismiss() {
-        uut.show(overlayContainer, overlay1, new CommandListenerAdapter());
-        assertThat(uut.size()).isOne();
-        CommandListener listener = spy(new CommandListenerAdapter());
-        uut.dismiss(overlayContainer, overlay1.getId(), listener);
-        assertThat(uut.size()).isZero();
-        verify(listener, times(1)).onSuccess(OVERLAY_ID_1);
-        verify(overlay1, times(1)).destroy();
-    }
-
-    @Test
-    public void dismiss_rejectIfOverlayNotFound() {
-        CommandListener listener = spy(new CommandListenerAdapter());
-        uut.dismiss(overlayContainer, overlay1.getId(), listener);
-        verify(listener, times(1)).onError(any());
-    }
-
-    @Test
-    public void dismiss_onViewReturnedToFront() {
-        uut.show(overlayContainer, overlay1, new CommandListenerAdapter());
-        uut.show(overlayContainer, overlay2, new CommandListenerAdapter());
-        idleMainLooper();
-        verify(overlay1, never()).onViewBroughtToFront();
-
-        uut.dismiss(overlayContainer, OVERLAY_ID_2, new CommandListenerAdapter());
-        idleMainLooper();
-        verify(overlay1).onViewBroughtToFront();
-    }
-
-    @Test
-    public void dismiss_overlayContainerIsHiddenIfAllOverlaysAreDismissed() {
-        uut.show(overlayContainer, overlay1, new CommandListenerAdapter());
-        uut.show(overlayContainer, overlay2, new CommandListenerAdapter());
-
-        uut.dismiss(overlayContainer, OVERLAY_ID_2, new CommandListenerAdapter());
-        assertThat(overlayContainer.getVisibility()).isEqualTo(View.VISIBLE);
-        assertThat(overlayContainer.getParent()).isEqualTo(contentLayout);
-        uut.dismiss(overlayContainer, OVERLAY_ID_1, new CommandListenerAdapter());
-        assertThat(overlayContainer.getVisibility()).isEqualTo(View.GONE);
-    }
-}

package/lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/parent/ParentControllerTest.java

@@ -1,299 +0,0 @@
-package com.reactnativenavigation.viewcontrollers.parent;
-
-import android.app.Activity;
-import android.view.ViewGroup;
-import android.widget.FrameLayout;
-
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.TestUtils;
-import com.reactnativenavigation.mocks.SimpleViewController;
-import com.reactnativenavigation.options.Options;
-import com.reactnativenavigation.options.params.Text;
-import com.reactnativenavigation.viewcontrollers.viewcontroller.Presenter;
-import com.reactnativenavigation.react.CommandListenerAdapter;
-import com.reactnativenavigation.viewcontrollers.child.ChildControllersRegistry;
-import com.reactnativenavigation.viewcontrollers.stack.StackController;
-import com.reactnativenavigation.viewcontrollers.viewcontroller.ViewController;
-
-import org.junit.Test;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-
-import androidx.annotation.NonNull;
-
-import static com.reactnativenavigation.utils.CollectionUtils.*;
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-public class ParentControllerTest extends BaseTest {
-
-    private static final String INITIAL_TITLE = "initial title";
-    private Activity activity;
-    private ChildControllersRegistry childRegistry;
-    private List<ViewController<?>> children;
-    private ParentController<?> uut;
-    private Presenter presenter;
-
-    @Override
-    public void beforeEach() {
-        super.beforeEach();
-        activity = newActivity();
-        childRegistry = new ChildControllersRegistry();
-        children = new ArrayList<>();
-        Options initialOptions = new Options();
-        initialOptions.topBar.title.text = new Text(INITIAL_TITLE);
-        presenter = spy(new Presenter(activity, new Options()));
-        uut = spy(new ParentController<ViewGroup>(activity, childRegistry, "uut", presenter, initialOptions) {
-
-            @Override
-            public ViewController<?> getCurrentChild() {
-                return children.get(0);
-            }
-
-            @NonNull
-            @Override
-            public ViewGroup createView() {
-                FrameLayout layout = new FrameLayout(activity);
-                for (ViewController<?> child : children) {
-                    child.setParentController(this);
-                    layout.addView(child.getView());
-                }
-                return layout;
-            }
-
-            @Override
-            public void sendOnNavigationButtonPressed(String buttonId) {
-
-            }
-
-            @NonNull
-            @Override
-            public Collection<ViewController<?>> getChildControllers() {
-                return children;
-            }
-        });
-    }
-
-    @Test
-    public void onConfigurationChange_shouldCallConfigurationChangeForPresenterAndChildren() {
-        children.add(spy(new SimpleViewController(activity, childRegistry, "child1", new Options())));
-        children.add(spy(new SimpleViewController(activity, childRegistry, "child2", new Options())));
-        ParentController<?> spyUUT = spy(uut);
-        spyUUT.onConfigurationChanged(mockConfiguration);
-        verify(presenter).onConfigurationChanged(any(),any());
-        for (ViewController<?> controller : children) {
-            verify(controller).onConfigurationChanged(any());
-        }
-    }
-
-    @Test
-    public void onViewDidAppearShouldCallCurrentChildDidAppear(){
-        SimpleViewController child1 = spy(new SimpleViewController(activity, childRegistry, "child1", new Options()));
-        SimpleViewController child2 = spy(new SimpleViewController(activity, childRegistry, "child2", new Options()));
-        children.add(child1);
-        children.add(child2);
-
-        uut.onViewDidAppear();
-
-        verify(child1).onViewDidAppear();
-        verify(child2,never()).onViewDidAppear();
-    }
-
-    @Test
-    public void onViewDisappearShouldCallCurrentChildDisAppear(){
-        SimpleViewController child1 = spy(new SimpleViewController(activity, childRegistry, "child1", new Options()));
-        SimpleViewController child2 = spy(new SimpleViewController(activity, childRegistry, "child2", new Options()));
-        children.add(child1);
-        children.add(child2);
-
-        uut.onViewDisappear();
-
-        verify(child1).onViewDisappear();
-        verify(child2,never()).onViewDisappear();
-    }
-    @Test
-    public void holdsViewGroup() {
-        assertThat(uut.getView()).isInstanceOf(ViewGroup.class);
-    }
-
-    @Test
-    public void mustHaveChildControllers() {
-        assertThat(uut.getChildControllers()).isNotNull();
-    }
-
-    @Test
-    public void findControllerById_ChildById() {
-        SimpleViewController child1 = new SimpleViewController(activity, childRegistry, "child1", new Options());
-        SimpleViewController child2 = new SimpleViewController(activity, childRegistry, "child2", new Options());
-        children.add(child1);
-        children.add(child2);
-
-        assertThat(uut.findController("uut")).isEqualTo(uut);
-        assertThat(uut.findController("child1")).isEqualTo(child1);
-    }
-
-    @Test
-    public void findControllerById_Recursive() {
-        StackController stackController = TestUtils.newStackController(activity).build();
-        stackController.ensureViewIsCreated();
-        SimpleViewController child1 = new SimpleViewController(activity, childRegistry, "child1", new Options());
-        SimpleViewController child2 = new SimpleViewController(activity, childRegistry, "child2", new Options());
-        stackController.push(child1, new CommandListenerAdapter());
-        stackController.push(child2, new CommandListenerAdapter());
-        children.add(stackController);
-
-        assertThat(uut.findController("child2")).isEqualTo(child2);
-    }
-
-    @Test
-    public void destroy_DestroysChildren() {
-        ViewController<?> child1 = spy(new SimpleViewController(activity, childRegistry, "child1", new Options()));
-        children.add(child1);
-
-        verify(child1, times(0)).destroy();
-        uut.destroy();
-        verify(child1, times(1)).destroy();
-    }
-
-    @Test
-    public void optionsAreClearedWhenChildIsAppeared() {
-        StackController stackController = spy(TestUtils.newStackController(activity).build());
-        stackController.ensureViewIsCreated();
-        SimpleViewController child1 = new SimpleViewController(activity, childRegistry, "child1", new Options());
-        stackController.push(child1, new CommandListenerAdapter());
-
-        child1.onViewWillAppear();
-        verify(stackController, times(1)).clearOptions();
-    }
-
-    @Test
-    public void mergeOptions_optionsAreMergedWhenChildAppears() {
-        Options options = new Options();
-        options.topBar.title.text = new Text("new title");
-        ViewController<?> child1 = spy(new SimpleViewController(activity, childRegistry, "child1", options));
-        children.add(child1);
-        uut.ensureViewIsCreated();
-
-        child1.ensureViewIsCreated();
-        child1.onViewWillAppear();
-        ArgumentCaptor<Options> optionsCaptor = ArgumentCaptor.forClass(Options.class);
-        verify(uut, times(1)).clearOptions();
-        verify(uut, times(1)).applyChildOptions(optionsCaptor.capture(), eq(child1));
-        assertThat(optionsCaptor.getValue().topBar.title.text.get()).isEqualTo("new title");
-    }
-
-    @Test
-    public void mergeOptions_initialParentOptionsAreNotMutatedWhenChildAppears() {
-        Options options = new Options();
-        options.topBar.title.text = new Text("new title");
-        ViewController<?> child1 = spy(new SimpleViewController(activity, childRegistry, "child1", options));
-        children.add(child1);
-
-        uut.ensureViewIsCreated();
-
-        child1.ensureViewIsCreated();
-        child1.onViewWillAppear();
-        assertThat(uut.initialOptions.topBar.title.text.get()).isEqualTo(INITIAL_TITLE);
-    }
-
-    @Test
-    public void resolveCurrentOptions_returnOptionsIfNoChildren() {
-        assertThat(uut.getChildControllers().size()).isZero();
-        assertThat(uut.resolveCurrentOptions()).isEqualTo(uut.initialOptions);
-    }
-
-    @Test
-    public void resolveCurrentOptions_mergesWithCurrentChild() {
-        ViewController child1 = Mockito.mock(ViewController.class);
-        when(child1.getView()).thenReturn(new FrameLayout(activity));
-        Options copiedChildOptions = spy(new Options());
-        Options childOptions = spy(new Options() {
-            @Override
-            public Options copy() {
-                return copiedChildOptions;
-            }
-        });
-        when(child1.resolveCurrentOptions()).thenReturn(childOptions);
-
-        children.add(child1);
-
-        uut.ensureViewIsCreated();
-        assertThat(uut.getCurrentChild()).isEqualTo(child1);
-        uut.resolveCurrentOptions();
-        verify(child1).resolveCurrentOptions();
-        verify(copiedChildOptions).withDefaultOptions(uut.initialOptions);
-    }
-
-    @Test
-    public void resolveCurrentOptions_withDefaultOptions() {
-        SimpleViewController child1 = new SimpleViewController(activity, childRegistry, "child1", new Options());
-        children.add(child1);
-        uut.ensureViewIsCreated();
-
-        Options defaultOptions = new Options();
-        Options currentOptions = spy(new Options());
-        ParentController<?> spy = spy(uut);
-        Mockito.when(spy.resolveCurrentOptions()).thenReturn(currentOptions);
-        spy.resolveCurrentOptions(defaultOptions);
-        verify(currentOptions).withDefaultOptions(defaultOptions);
-    }
-
-    @Test
-    public void applyTopInset() {
-        children.addAll(createChildren());
-        uut.applyTopInset();
-        forEach(children, c -> verify(c).applyTopInset());
-    }
-
-    @Test
-    public void getTopInset() {
-        assertThat(uut.getTopInset()).isZero();
-    }
-
-    @Test
-    public void getTopInsetForChild() {
-        ParentController<?> parent = Mockito.mock(ParentController.class);
-        Mockito.when(parent.resolveChildOptions(uut)).thenReturn(Options.EMPTY);
-
-        when(parent.getTopInset(any())).thenReturn(123);
-        uut.setParentController(parent);
-
-        assertThat(uut.getTopInset(Mockito.mock(ViewController.class))).isEqualTo(123);
-    }
-
-    @Test
-    public void applyBottomInset() {
-        children.addAll(createChildren());
-        uut.applyBottomInset();
-        forEach(children, c -> verify(c).applyBottomInset());
-    }
-
-    @Test
-    public void getBottomInsetForChild() {
-        ParentController<?> parent = Mockito.mock(ParentController.class);
-        Mockito.when(parent.resolveChildOptions(uut)).thenReturn(Options.EMPTY);
-
-        when(parent.getBottomInset(any())).thenReturn(123);
-        uut.setParentController(parent);
-
-        assertThat(uut.getBottomInset(Mockito.mock(ViewController.class))).isEqualTo(123);
-    }
-
-    private List<ViewController<?>> createChildren() {
-        return Arrays.asList(
-                spy(new SimpleViewController(activity, childRegistry, "child1", new Options())),
-                spy(new SimpleViewController(activity, childRegistry, "child2", new Options()))
-        );
-    }
-}