MergeOptions only applies passed options

Previously, all options were cleared and reapplied whenever mergeOptions was called

lib/android/app/src/main/java/com/reactnativenavigation/anim/NavigationAnimator.java

 import android.support.annotation.Nullable;
 import android.view.View;
 
+import com.reactnativenavigation.parse.AnimationsOptions;
+
 @SuppressWarnings("ResourceType")
 public class NavigationAnimator extends BaseAnimator {
 
         });
         set.start();
     }
+
+    public void setOptions(AnimationsOptions options) {
+        this.options = options;
+    }
+
+    public void mergeOptions(AnimationsOptions options) {
+        this.options.mergeWith(options);
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/AnimationsOptions.java

     public AnimationOptions showModal = new AnimationOptions();
     public AnimationOptions dismissModal = new AnimationOptions();
 
-    void mergeWith(AnimationsOptions other) {
+    public void mergeWith(AnimationsOptions other) {
         push.mergeWith(other.push);
         pop.mergeWith(other.pop);
         startApp.mergeWith(other.startApp);

lib/android/app/src/main/java/com/reactnativenavigation/parse/FabOptions.java

             size = defaultOptions.size;
         }
     }
+
+    public boolean hasValue() {
+        return id.hasValue() || icon.hasValue();
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/Options.java

         sideMenuRootOptions = new SideMenuRootOptions();
         return this;
     }
+
+    public Options clearAnimationOptions() {
+        animationsOptions = new AnimationsOptions();
+        return this;
+    }
+
+    public Options clearFabOptions() {
+        fabOptions = new FabOptions();
+        return this;
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/OrientationOptions.java

         if (other.hasValue()) orientations = other.orientations;
     }
 
-    private boolean hasValue() {
+    public boolean hasValue() {
         return !orientations.isEmpty();
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/parse/TitleOptions.java

     private static void validate(TitleOptions options) {
         if (options.component.hasValue() && options.text.hasValue()) {
             if (BuildConfig.DEBUG) Log.w("RNN", "A screen can't use both text and component - clearing text.");
-            options.text = new Text("");
+            options.text = new NullText();
         }
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/presentation/OptionsPresenter.java

     }
 
     private void applyButtons(ArrayList<Button> leftButtons, ArrayList<Button> rightButtons) {
-        topBar.setButtons(leftButtons, rightButtons);
+        topBar.setLeftButtons(leftButtons);
+        topBar.setRightButtons(rightButtons);
     }
 
     private void applyTopTabsOptions(TopTabsOptions options) {
             childDisappearListener.childDisappear();
         }
     }
+
+    public void mergeChildOptions(Options options, Component child) {
+        mergeOrientation(options.orientationOptions);
+        mergeButtons(options.topBarOptions.leftButtons, options.topBarOptions.rightButtons);
+        mergeTopBarOptions(options.topBarOptions, child);
+        mergeTopTabsOptions(options.topTabsOptions);
+        mergeTopTabOptions(options.topTabOptions);
+    }
+
+    private void mergeOrientation(OrientationOptions orientationOptions) {
+        if (orientationOptions.hasValue()) applyOrientation(orientationOptions);
+    }
+
+    private void mergeButtons(ArrayList<Button> leftButtons, ArrayList<Button> rightButtons) {
+        if (leftButtons != null) topBar.setLeftButtons(leftButtons);
+        if (rightButtons != null) topBar.setRightButtons(rightButtons);
+    }
+
+    private void mergeTopBarOptions(TopBarOptions options, Component component) {
+        if (options.title.text.hasValue()) topBar.setTitle(options.title.text.get());
+        if (options.title.component.hasValue()) topBar.setComponent(options.title.component.get(), options.title.alignment);
+        if (options.background.color.hasValue()) topBar.setBackgroundColor(options.background.color);
+        if (options.title.color.hasValue()) topBar.setTitleTextColor(options.title.color);
+        if (options.title.fontSize.hasValue()) topBar.setTitleFontSize(options.title.fontSize);
+        if (options.testId.hasValue()) topBar.setTestId(options.testId.get());
+
+        if (options.title.fontFamily != null) topBar.setTitleTypeface(options.title.fontFamily);
+        if (options.visible.isFalse()) {
+            topBar.hide(options.animate);
+        }
+        if (options.visible.isTrue()) {
+            topBar.show(options.animate);
+        }
+        if (options.drawBehind.isTrue()) {
+            component.drawBehindTopBar();
+        }
+        if (options.drawBehind.isFalse()) {
+            component.drawBelowTopBar(topBar);
+        }
+        if (options.hideOnScroll.isTrue() && component instanceof IReactView) {
+            topBar.enableCollapse(((IReactView) component).getScrollEventListener());
+        }
+        if (options.hideOnScroll.isFalse()) {
+            topBar.disableCollapse();
+        }
+    }
+
+    private void mergeTopTabsOptions(TopTabsOptions options) {
+        if (options.selectedTabColor.hasValue() && options.unselectedTabColor.hasValue()) topBar.applyTopTabsColors(options.selectedTabColor, options.unselectedTabColor);
+        if (options.fontSize.hasValue()) topBar.applyTopTabsFontSize(options.fontSize);
+        if (options.visible.hasValue()) topBar.setTopTabsVisible(options.visible.isTrue());
+    }
+
+    private void mergeTopTabOptions(TopTabOptions topTabOptions) {
+        if (topTabOptions.fontFamily != null) topBar.setTopTabFontFamily(topTabOptions.tabIndex, topTabOptions.fontFamily);
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ComponentViewController.java

 
     @Override
     public void mergeOptions(Options options) {
+        view.applyOptions(options);
+        applyOnParentController(parentController -> parentController.mergeChildOptions(options, view));
         this.options = this.options.mergeWith(options);
-        view.applyOptions(this.options);
-        applyOnParentController(parentController -> parentController.applyChildOptions(this.options, view));
     }
 
     ReactComponent getComponent() {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ParentController.java

 
     @CallSuper
     public void applyChildOptions(Options options, Component child) {
-        mergeChildOptions(options);
+        this.options = this.options.mergeWith(options);
     }
 
-    private void mergeChildOptions(Options options) {
-        this.options = this.options.mergeWith(options);
+    @CallSuper
+    public void mergeChildOptions(Options options, Component child) {
+
     }
 
 	@Override

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/StackController.java

 
     public StackController(final Activity activity, ReactViewCreator topBarButtonCreator, TitleBarReactViewCreator titleBarReactViewCreator, String id, Options initialOptions) {
         super(activity, id, initialOptions);
-        animator = new NavigationAnimator(activity);
+        animator = createAnimator();
         this.topBarButtonCreator = topBarButtonCreator;
         this.titleBarReactViewCreator = titleBarReactViewCreator;
     }
     public void applyChildOptions(Options options, Component child) {
         super.applyChildOptions(options, child);
         getView().applyChildOptions(this.options, child);
+        if (child instanceof ReactComponent) {
+            fabOptionsPresenter.applyOptions(this.options.fabOptions, (ReactComponent) child, getView());
+        }
         applyOnParentController(parentController ->
-                ((ParentController) parentController).applyChildOptions(this.options.copy().clearTopBarOptions(), child)
+                ((ParentController) parentController).applyChildOptions(
+                        this.options.copy().clearTopBarOptions().clearAnimationOptions().clearFabOptions(),
+                        child
+                )
         );
-        if (child instanceof ReactComponent) {
+        animator.setOptions(options.animationsOptions);
+    }
+
+    @Override
+    public void mergeChildOptions(Options options, Component child) {
+        super.mergeChildOptions(options, child);
+        getView().mergeChildOptions(options, child);
+        animator.mergeOptions(options.animationsOptions);
+        if (options.fabOptions.hasValue() && child instanceof ReactComponent) {
             fabOptionsPresenter.applyOptions(options.fabOptions, (ReactComponent) child, getView());
         }
-        animator.setOptions(options.animationsOptions);
+        applyOnParentController(parentController ->
+                ((ParentController) parentController).mergeChildOptions(
+                        options.copy().clearTopBarOptions().clearAnimationOptions().clearFabOptions(),
+                        child
+                )
+        );
     }
 
     @Override
         getView().clearTopTabs();
     }
 
+     NavigationAnimator createAnimator() {
+        return new NavigationAnimator(getActivity());
+    }
+
     @RestrictTo(RestrictTo.Scope.TESTS)
     TopBar getTopBar() {
         return getView().getTopBar();

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/TitleBarReactViewController.java

     private final TitleBarReactViewCreator reactViewCreator;
     private String componentName;
 
+    public TitleBarReactViewController(TitleBarReactViewController reactViewController) {
+        this(reactViewController.getActivity(), reactViewController.reactViewCreator);
+    }
+
     public TitleBarReactViewController(Activity activity, TitleBarReactViewCreator reactViewCreator) {
         super(activity, CompatUtils.generateViewId() + "", new Options());
         this.reactViewCreator = reactViewCreator;
     }
 
-    public TitleBarReactViewController(TitleBarReactViewController reactViewController) {
-        super(reactViewController.getActivity(), CompatUtils.generateViewId() + "", new Options());
-        this.reactViewCreator = reactViewController.reactViewCreator;
-    }
-
     @Override
     protected TitleBarReactView createView() {
         return reactViewCreator.create(getActivity(), getId(), componentName);

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ViewController.java

         this.viewVisibilityListener = viewVisibilityListener;
     }
 
-    @SuppressWarnings("WeakerAccess")
     @VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE)
     public void ensureViewIsCreated() {
         getView();
         }
     }
 
-    @NonNull
     public T getView() {
         if (view == null) {
             if (isDestroyed) {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/bottomtabs/BottomTabsController.java

     @Override
     public void applyChildOptions(Options options, Component child) {
         super.applyChildOptions(options, child);
-        int tabIndex = bottomTabFinder.findByComponent(child);
+        final int tabIndex = bottomTabFinder.findByComponent(child);
         if (tabIndex >= 0) new BottomTabsOptionsPresenter(bottomTabs, bottomTabFinder).present(this.options, tabIndex);
         applyOnParentController(parentController ->
                 ((ParentController) parentController).applyChildOptions(this.options.copy().clearBottomTabsOptions().clearBottomTabOptions(), child)
         );
     }
 
+    @Override
+    public void mergeChildOptions(Options options, Component child) {
+        super.mergeChildOptions(options, child);
+        final int tabIndex = bottomTabFinder.findByComponent(child);
+        new BottomTabsOptionsPresenter(bottomTabs, bottomTabFinder).present(options, tabIndex);
+        applyOnParentController(parentController ->
+                ((ParentController) parentController).mergeChildOptions(options.copy().clearBottomTabsOptions(), child)
+        );
+    }
+
     @Override
 	public boolean handleBack() {
 		return !tabs.isEmpty() && tabs.get(bottomTabs.getCurrentItem()).handleBack();

lib/android/app/src/main/java/com/reactnativenavigation/views/ComponentLayout.java

 
     private IReactView reactView;
     private final OverlayTouchDelegate touchDelegate;
+    private final ComponentOptionsPresenter optionsPresenter;
 
     public ComponentLayout(Context context, IReactView reactView) {
 		super(context);
         addView(reactView.asView(), MATCH_PARENT, MATCH_PARENT);
         setContentDescription("ComponentLayout");
         touchDelegate = new OverlayTouchDelegate(reactView);
+        optionsPresenter = new ComponentOptionsPresenter(this);
     }
 
     @Override
 
     @Override
     public void applyOptions(Options options) {
-        new ComponentOptionsPresenter(this).present(options);
+        optionsPresenter.present(options);
         touchDelegate.setInterceptTouchOutside(options.overlayOptions.interceptTouchOutside.isTrue());
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/views/StackLayout.java

     public TopBar getTopBar() {
         return topBar;
     }
+
+    public void mergeChildOptions(Options options, Component child) {
+        optionsPresenter.mergeChildOptions(options, child);
+    }
 }

lib/android/app/src/main/java/com/reactnativenavigation/views/TopBar.java

         topTabs.setVisibility(this, visible);
     }
 
-    public void setButtons(List<Button> leftButtons, List<Button> rightButtons) {
-        titleBar.setButtons(leftButtons, rightButtons);
+    public void setLeftButtons(List<Button> leftButtons) {
+        titleBar.setLeftButtons(leftButtons);
+    }
+
+    public void setRightButtons(List<Button> rightButtons) {
+        titleBar.setRightButtons(rightButtons);
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)

lib/android/app/src/main/java/com/reactnativenavigation/views/TopTabsStyleHelper.java

     }
 
     void applyTopTabsColors(Color selected, Color unselected) {
-        if (!selected.hasValue() && !unselected.hasValue()) return;
-
         ColorStateList originalColors = topTabs.getTabTextColors();
         int selectedTabColor = originalColors != null ? originalColors.getColorForState(topTabs.getSelectedTabColors(), -1) : -1;
         int tabTextColor = originalColors != null ? originalColors.getColorForState(topTabs.getDefaultTabColors(), -1) : -1;

lib/android/app/src/main/java/com/reactnativenavigation/views/titlebar/TitleBar.java

     }
 
     public void setComponent(String componentName, TitleOptions.Alignment alignment) {
+        clearTitle();
         reactViewController.setComponent(componentName);
         addView(reactViewController.getView(), getComponentLayoutParams(alignment));
     }
     }
 
     public void clear() {
-        setTitle(null);
+        clearTitle();
         clearRightButtons();
         clearLeftButton();
         clearComponent();
     }
 
+    private void clearTitle() {
+        setTitle(null);
+    }
+
     private void clearComponent() {
         reactViewController.destroy();
         reactViewController = new TitleBarReactViewController(reactViewController);
         getMenu().clear();
     }
 
-    public void setButtons(List<Button> leftButtons, List<Button> rightButtons) {
-        setLeftButtons(leftButtons);
-        setRightButtons(rightButtons);
-    }
-
-    private void setLeftButtons(List<Button> leftButtons) {
+    public void setLeftButtons(List<Button> leftButtons) {
         if (leftButtons == null) return;
         if (leftButtons.isEmpty()) {
             clearLeftButton();

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/OptionsMergingTest.java

+package com.reactnativenavigation.viewcontrollers;
+
+import android.app.Activity;
+import android.graphics.Typeface;
+
+import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.mocks.TestComponentLayout;
+import com.reactnativenavigation.mocks.TestReactView;
+import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.OrientationOptions;
+import com.reactnativenavigation.parse.TitleOptions;
+import com.reactnativenavigation.parse.params.Bool;
+import com.reactnativenavigation.parse.params.Color;
+import com.reactnativenavigation.parse.params.Fraction;
+import com.reactnativenavigation.parse.params.Number;
+import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.presentation.OptionsPresenter;
+import com.reactnativenavigation.views.TopBar;
+
+import org.json.JSONObject;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.mock;
+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 OptionsMergingTest extends BaseTest {
+
+    private OptionsPresenter uut;
+    private TestComponentLayout child;
+    private Activity activity;
+    private TopBar topBar;
+
+    @Override
+    public void beforeEach() {
+        activity = spy(newActivity());
+        topBar = mockTopBar();
+        uut = spy(new OptionsPresenter(topBar));
+        child = spy(new TestComponentLayout(activity, new TestReactView(activity)));
+    }
+
+    @Test
+    public void mergeOrientation() throws Exception {
+        Options options = new Options();
+        uut.mergeChildOptions(options, child);
+        verify(uut, times(0)).applyOrientation(any());
+
+        JSONObject orientation = new JSONObject().put("orientation", "landscape");
+        options.orientationOptions = OrientationOptions.parse(orientation);
+        uut.mergeChildOptions(options, child);
+        verify(uut, times(1)).applyOrientation(options.orientationOptions);
+    }
+
+    @Test
+    public void mergeButtons() throws Exception {
+        Options options = new Options();
+        uut.mergeChildOptions(options, child);
+        verify(topBar, times(0)).setRightButtons(any());
+        verify(topBar, times(0)).setLeftButtons(any());
+
+        options.topBarOptions.rightButtons = new ArrayList<>();
+        uut.mergeChildOptions(options, child);
+        verify(topBar, times(1)).setRightButtons(any());
+
+        options.topBarOptions.leftButtons = new ArrayList<>();
+        uut.mergeChildOptions(options, child);
+        verify(topBar, times(1)).setLeftButtons(any());
+    }
+
+    @Test
+    public void mergeTopBarOptions() throws Exception {
+        Options options = new Options();
+        uut.mergeChildOptions(options, child);
+        assertTopBarOptions(0);
+
+        TitleOptions titleOptions = new TitleOptions();
+        titleOptions.text = new Text("abc");
+        titleOptions.component = new Text("someComponent");
+        titleOptions.color = new Color(0);
+        titleOptions.fontSize = new Fraction(1.0f);
+        titleOptions.fontFamily = Typeface.DEFAULT_BOLD;
+        options.topBarOptions.title = titleOptions;
+        options.topBarOptions.background.color = new Color(0);
+        options.topBarOptions.testId = new Text("test123");
+        options.topBarOptions.visible = new Bool(false);
+        options.topBarOptions.drawBehind = new Bool(false);
+        options.topBarOptions.hideOnScroll = new Bool(false);
+        uut.mergeChildOptions(options, child);
+
+        assertTopBarOptions(1);
+
+        options.topBarOptions.drawBehind = new Bool(true);
+        uut.mergeChildOptions(options, child);
+        verify(child, times(1)).drawBehindTopBar();
+    }
+
+    @Test
+    public void mergeTopTabsOptions() throws Exception {
+        Options options = new Options();
+        uut.mergeChildOptions(options, child);
+        verify(topBar, times(0)).applyTopTabsColors(any(), any());
+        verify(topBar, times(0)).applyTopTabsFontSize(any());
+        verify(topBar, times(0)).setTopTabsVisible(anyBoolean());
+
+        options.topTabsOptions.selectedTabColor = new Color(1);
+        options.topTabsOptions.unselectedTabColor = new Color(1);
+        options.topTabsOptions.fontSize = new Number(1);
+        options.topTabsOptions.visible = new Bool(true);
+        uut.mergeChildOptions(options, child);
+        verify(topBar, times(1)).applyTopTabsColors(options.topTabsOptions.selectedTabColor, options.topTabsOptions.unselectedTabColor);
+        verify(topBar, times(1)).applyTopTabsFontSize(options.topTabsOptions.fontSize);
+        verify(topBar, times(1)).setTopTabsVisible(anyBoolean());
+    }
+
+    @Test
+    public void mergeTopTabOptions() throws Exception {
+        Options options = new Options();
+        uut.mergeChildOptions(options, child);
+
+        verify(topBar, times(0)).setTopTabFontFamily(anyInt(), any());
+
+        options.topTabOptions.tabIndex = 1;
+        options.topTabOptions.fontFamily = Typeface.DEFAULT_BOLD;
+        uut.mergeChildOptions(options, child);
+
+        verify(topBar, times(1)).setTopTabFontFamily(1, Typeface.DEFAULT_BOLD);
+    }
+
+
+    private void assertTopBarOptions(int t) {
+        verify(topBar, times(t)).setTitle(any());
+        verify(topBar, times(t)).setComponent(any(), any());
+        verify(topBar, times(t)).setBackgroundColor(any());
+        verify(topBar, times(t)).setTitleTextColor(any());
+        verify(topBar, times(t)).setTitleFontSize(any());
+        verify(topBar, times(t)).setTestId(any());
+        verify(topBar, times(t)).setTitleTypeface(any());
+        verify(topBar, times(t)).hide(any());
+        verify(child, times(t)).drawBelowTopBar(topBar);
+        verify(child, times(0)).drawBehindTopBar();
+    }
+
+    private TopBar mockTopBar() {
+        TopBar topBar = mock(TopBar.class);
+        when(topBar.getContext()).then(invocation -> activity);
+        return topBar;
+    }
+}

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/StackControllerTest.java

 import android.view.View;
 
 import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
+import com.reactnativenavigation.parse.AnimationOptions;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.utils.ViewHelper;
+import com.reactnativenavigation.views.Component;
 import com.reactnativenavigation.views.ReactComponent;
 import com.reactnativenavigation.views.StackLayout;
 
 import org.assertj.core.api.iterable.Extractor;
+import org.json.JSONObject;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
 
 import javax.annotation.Nullable;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
     private ViewController child1;
     private ViewController child2;
     private ViewController child3;
+    private NavigationAnimator animator;
 
     @Override
     public void beforeEach() {
         verify(child1, times(1)).sendOnNavigationButtonPressed("btn1");
     }
 
+    @Test
+    public void mergeChildOptions_updatesViewWithNewOptions() throws Exception {
+        final StackLayout[] stackLayout = new StackLayout[1];
+        StackController uut = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), "stack", new Options()) {
+            @NonNull
+            @Override
+            protected StackLayout createView() {
+                stackLayout[0] = spy(super.createView());
+                return stackLayout[0];
+            }
+        };
+        Options optionsToMerge = new Options();
+        Component component = mock(Component.class);
+        uut.mergeChildOptions(optionsToMerge, component);
+        verify(stackLayout[0], times(1)).mergeChildOptions(optionsToMerge, component);
+    }
+
+    @Test
+    public void mergeChildOptions_updatesParentControllerWithNewOptions() throws Exception {
+        final StackLayout[] stackLayout = new StackLayout[1];
+        StackController uut = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), "stack", new Options()) {
+            @NonNull
+            @Override
+            protected StackLayout createView() {
+                stackLayout[0] = spy(super.createView());
+                return stackLayout[0];
+            }
+        };
+        ParentController parentController = Mockito.mock(ParentController.class);
+        uut.setParentController(parentController);
+        Options optionsToMerge = new Options();
+        optionsToMerge.topBarOptions.testId = new Text("topBarID");
+        optionsToMerge.bottomTabsOptions.testId = new Text("bottomTabsID");
+        Component component = mock(Component.class);
+        uut.mergeChildOptions(optionsToMerge, component);
+
+        ArgumentCaptor<Options> captor = ArgumentCaptor.forClass(Options.class);
+        verify(parentController, times(1)).mergeChildOptions(captor.capture(), eq(component));
+        assertThat(captor.getValue().topBarOptions.testId.hasValue()).isFalse();
+        assertThat(captor.getValue().bottomTabsOptions.testId.get()).isEqualTo(optionsToMerge.bottomTabsOptions.testId.get());
+    }
+
+    @Test
+    public void mergeChildOptions_mergeAnimationOptions() throws Exception {
+        Options options = new Options();
+        Component component = mock(Component.class);
+
+        uut.mergeChildOptions(options, component);
+        verify(animator, times(0)).setOptions(options.animationsOptions);
+        verify(animator, times(1)).mergeOptions(options.animationsOptions);
+    }
+
+    @Test
+    public void mergeChildOptions_StackRelatedOptionsAreCleared() throws Exception {
+        ParentController parentController = Mockito.mock(ParentController.class);
+        uut.setParentController(parentController);
+        Options options = new Options();
+        options.animationsOptions.push = AnimationOptions.parse(new JSONObject());
+        options.topBarOptions.testId = new Text("id");
+        options.fabOptions.id = new Text("fabId");
+        Component component = mock(Component.class);
+
+        assertThat(options.fabOptions.hasValue()).isTrue();
+        uut.mergeChildOptions(options, component);
+        ArgumentCaptor<Options> captor = ArgumentCaptor.forClass(Options.class);
+        verify(parentController, times(1)).mergeChildOptions(captor.capture(), eq(component));
+        assertThat(captor.getValue().animationsOptions.push.hasValue()).isFalse();
+        assertThat(captor.getValue().topBarOptions.testId.hasValue()).isFalse();
+        assertThat(captor.getValue().fabOptions.hasValue()).isFalse();
+    }
+
     private void assertContainsOnlyId(String... ids) {
         assertThat(uut.size()).isEqualTo(ids.length);
         assertThat(uut.getChildControllers()).extracting((Extractor<ViewController, String>) ViewController::getId).containsOnly(ids);
     }
 
     private StackController createStackController(String id) {
-        return new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), id, new Options());
+        return new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), id, new Options()) {
+            @Override
+            NavigationAnimator createAnimator() {
+                animator = Mockito.mock(NavigationAnimator.class);
+                return animator;
+            }
+        };
     }
 }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/TitleBarTest.java

 
     @Test
     public void setButton_setsTextButton() {
-        uut.setButtons(leftButton(leftButton), rightButtons(textButton));
+        uut.setRightButtons(rightButtons(textButton));
+        uut.setLeftButtons(leftButton(leftButton));
         assertThat(uut.getMenu().getItem(0).getTitle()).isEqualTo(textButton.title.get());
     }
 
     @Test
     public void setButton_setsCustomButton() {
-        uut.setButtons(leftButton(leftButton), rightButtons(customButton));
+        uut.setLeftButtons(leftButton(leftButton));
+        uut.setRightButtons(rightButtons(customButton));
         ReactView btnView = (ReactView) uut.getMenu().getItem(0).getActionView();
         assertThat(btnView.getComponentName()).isEqualTo(customButton.component.get());
     }
 
     @Test
     public void destroy_destroysButtonControllers() throws Exception {
-        uut.setButtons(leftButton(leftButton), rightButtons(customButton, textButton));
+        uut.setLeftButtons(leftButton(leftButton));
+        uut.setRightButtons(rightButtons(customButton, textButton));
         uut.clear();
         for (TopBarButtonController controller : buttonControllers.values()) {
             verify(controller, times(1)).destroy();
 
     @Test
     public void setRightButtons_destroysRightButtons() throws Exception {
-        uut.setButtons(leftButton(leftButton), rightButtons(customButton));
-        uut.setButtons(leftButton(leftButton), rightButtons(textButton));
+        uut.setLeftButtons(leftButton(leftButton));
+        uut.setRightButtons(rightButtons(customButton));
+        uut.setLeftButtons(leftButton(leftButton));
+        uut.setRightButtons(rightButtons(textButton));
         verify(buttonControllers.get(customButton.id), times(1)).destroy();
     }
 
     @Test
     public void setRightButtons_onlyDestroysRightButtons() throws Exception {
-        uut.setButtons(leftButton(leftButton), rightButtons(customButton));
-        uut.setButtons(null, rightButtons(textButton));
+        uut.setLeftButtons(leftButton(leftButton));
+        uut.setRightButtons(rightButtons(customButton));
+        uut.setLeftButtons(null);
+        uut.setRightButtons(rightButtons(textButton));
         verify(buttonControllers.get(leftButton.id), times(0)).destroy();
     }
 
     @Test
     public void setRightButtons_emptyButtonsListClearsRightButtons() throws Exception {
-        uut.setButtons(new ArrayList<>(), rightButtons(customButton, textButton));
-        uut.setButtons(new ArrayList<>(), new ArrayList<>());
+        uut.setLeftButtons(new ArrayList<>());
+        uut.setRightButtons(rightButtons(customButton, textButton));
+        uut.setLeftButtons(new ArrayList<>());
+        uut.setRightButtons(new ArrayList<>());
         for (TopBarButtonController controller : buttonControllers.values()) {
             verify(controller, times(1)).destroy();
         }
 
     @Test
     public void setLeftButtons_emptyButtonsListClearsLeftButton() throws Exception {
-        uut.setButtons(leftButton(leftButton), rightButtons(customButton));
-        uut.setButtons(new ArrayList<>(), rightButtons(textButton));
+        uut.setLeftButtons(leftButton(leftButton));
+        uut.setRightButtons(rightButtons(customButton));
+        uut.setLeftButtons(new ArrayList<>());
+        uut.setRightButtons(rightButtons(textButton));
         verify(buttonControllers.get(leftButton.id), times(1)).destroy();
     }
 
     @Test
     public void setRightButtons_buttonsAreAddedInReverseOrderToMatchOrderOnIOs() throws Exception {
-        uut.setButtons(new ArrayList<>(), rightButtons(textButton, customButton));
+        uut.setLeftButtons(new ArrayList<>());
+        uut.setRightButtons(rightButtons(textButton, customButton));
         assertThat(uut.getMenu().getItem(1).getTitle()).isEqualTo(textButton.title.get());
     }
 

lib/android/app/src/test/java/com/reactnativenavigation/views/TopBarTest.java

 
     @Test
     public void button_TitleBarButtonOnClickInvoked() throws Exception {
-        uut.setButtons(new ArrayList<>(), rightButtons);
+        uut.setLeftButtons(new ArrayList<>());
+        uut.setRightButtons(rightButtons);
         for (int i = 0; i < rightButtons.size(); i++) {
             Button rightButton = rightButtons.get(i);
             TitleBarHelper.getRightButton(uut.getTitleBar(), i).callOnClick();