Initial TopBar refactor

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

 import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabsController;
 import com.reactnativenavigation.viewcontrollers.externalcomponent.ExternalComponentCreator;
 import com.reactnativenavigation.viewcontrollers.externalcomponent.ExternalComponentViewController;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsController;
 import com.reactnativenavigation.views.ComponentViewCreator;
-import com.reactnativenavigation.views.titlebar.TitleBarReactViewCreator;
 import com.reactnativenavigation.views.titlebar.TitleBarButtonCreator;
-import com.reactnativenavigation.views.toptabs.TopTabsLayoutCreator;
+import com.reactnativenavigation.views.titlebar.TitleBarReactViewCreator;
 import com.reactnativenavigation.views.topbar.TopBarBackgroundViewCreator;
+import com.reactnativenavigation.views.toptabs.TopTabsLayoutCreator;
 
 import java.util.ArrayList;
 import java.util.List;
                 new TitleBarButtonCreator(reactInstanceManager),
                 new TitleBarReactViewCreator(reactInstanceManager),
                 new TopBarBackgroundViewCreator(reactInstanceManager),
+                new TopBarController(),
                 node.id,
                 getOptions(node)
         );

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

 import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.utils.NoOpPromise;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.Component;
 import com.reactnativenavigation.views.ReactComponent;
 import com.reactnativenavigation.views.StackLayout;
     private final ReactViewCreator topBarButtonCreator;
     private final TitleBarReactViewCreator titleBarReactViewCreator;
     private TopBarBackgroundViewCreator topBarBackgroundViewCreator;
+    private TopBarController topBarController;
 
-    public StackController(final Activity activity, ReactViewCreator topBarButtonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewCreator topBarBackgroundViewCreator, String id, Options initialOptions) {
+    public StackController(final Activity activity, ReactViewCreator topBarButtonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewCreator topBarBackgroundViewCreator, TopBarController topBarController, String id, Options initialOptions) {
         super(activity, id, initialOptions);
+        this.topBarController = topBarController;
         animator = createAnimator();
         this.topBarButtonCreator = topBarButtonCreator;
         this.titleBarReactViewCreator = titleBarReactViewCreator;
         );
     }
 
+    @Override
+    public void destroy() {
+        topBarController.clear();
+        super.destroy();
+    }
+
     @Override
     void clearOptions() {
         super.clearOptions();
-        getView().clearOptions();
+        topBarController.clear();
     }
 
     public void push(ViewController child, final Promise promise) {
     @NonNull
     @Override
     protected StackLayout createView() {
-        return new StackLayout(getActivity(), topBarButtonCreator, titleBarReactViewCreator, topBarBackgroundViewCreator, this::sendOnNavigationButtonPressed, getId());
+        return new StackLayout(getActivity(), topBarButtonCreator, titleBarReactViewCreator, topBarBackgroundViewCreator, topBarController, this::sendOnNavigationButtonPressed, getId());
     }
 
     @NonNull

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

                 throw new RuntimeException("Tried to create view after it has already been destroyed");
             }
             view = createView();
-            if (view.getId() < 0) {
+            if (view.getId() != 0) {
                 view.setId(CompatUtils.generateViewId());
             }
             view.getViewTreeObserver().addOnGlobalLayoutListener(this);
         }
     }
 
-    public void runOnPreDraw(Task<T> task) {
+    void runOnPreDraw(Task<T> task) {
         UiUtils.runOnPreDrawOnce(getView(), () -> task.run(getView()));
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/topbar/TopBarController.java

+package com.reactnativenavigation.viewcontrollers.topbar;
+
+import android.content.Context;
+import android.support.v4.view.ViewPager;
+import android.view.View;
+
+import com.reactnativenavigation.utils.CompatUtils;
+import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
+import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
+import com.reactnativenavigation.views.StackLayout;
+import com.reactnativenavigation.views.titlebar.TitleBarReactViewCreator;
+import com.reactnativenavigation.views.topbar.TopBar;
+import com.reactnativenavigation.views.topbar.TopBarBackgroundViewCreator;
+
+
+public class TopBarController {
+    private TopBar topBar;
+
+    public View createTopBar(Context context, ReactViewCreator buttonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewCreator backgroundViewCreator, TopBarButtonController.OnClickListener topBarButtonClickListener, StackLayout stackLayout) {
+        if (topBar == null) {
+            topBar = new TopBar(context, buttonCreator, titleBarReactViewCreator, backgroundViewCreator, topBarButtonClickListener, stackLayout);
+            topBar.setId(CompatUtils.generateViewId());
+        }
+        return topBar;
+    }
+
+    public void clear() {
+        topBar.clear();
+    }
+
+    public TopBar getTopBar() {
+        return topBar;
+    }
+
+    public void initTopTabs(ViewPager viewPager) {
+        topBar.initTopTabs(viewPager);
+    }
+
+    public void clearTopTabs() {
+        topBar.clearTopTabs();
+    }
+}

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

 import com.reactnativenavigation.interfaces.ChildDisappearListener;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.OptionsPresenter;
-import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.viewcontrollers.ReactViewCreator;
 import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.titlebar.TitleBarReactViewCreator;
 import com.reactnativenavigation.views.topbar.TopBar;
 import com.reactnativenavigation.views.topbar.TopBarBackgroundViewCreator;
 
 @SuppressLint("ViewConstructor")
 public class StackLayout extends RelativeLayout {
-    private TopBar topBar;
+    private TopBarController topBarController;
     private String stackId;
     private final OptionsPresenter optionsPresenter;
 
-    public StackLayout(Context context, ReactViewCreator topBarButtonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewCreator topBarBackgroundViewCreator, TopBarButtonController.OnClickListener topBarButtonClickListener, String stackId) {
+    public StackLayout(Context context, ReactViewCreator topBarButtonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewCreator topBarBackgroundViewCreator, TopBarController topBarController, TopBarButtonController.OnClickListener topBarButtonClickListener, String stackId) {
         super(context);
+        this.topBarController = topBarController;
         this.stackId = stackId;
         createLayout(topBarButtonCreator, titleBarReactViewCreator, topBarBackgroundViewCreator, topBarButtonClickListener);
-        optionsPresenter = new OptionsPresenter(topBar);
+        optionsPresenter = new OptionsPresenter(topBarController.getTopBar());
         setContentDescription("StackLayout");
     }
 
     private void createLayout(ReactViewCreator buttonCreator, TitleBarReactViewCreator titleBarReactViewCreator, TopBarBackgroundViewCreator BackgroundViewCreator, TopBarButtonController.OnClickListener topBarButtonClickListener) {
-        topBar = new TopBar(getContext(), buttonCreator, titleBarReactViewCreator, BackgroundViewCreator, topBarButtonClickListener, this);
-        topBar.setId(CompatUtils.generateViewId());
-        addView(topBar, MATCH_PARENT, WRAP_CONTENT);
+        addView(topBarController.createTopBar(getContext(), buttonCreator, titleBarReactViewCreator, BackgroundViewCreator, topBarButtonClickListener, this), MATCH_PARENT, WRAP_CONTENT);
     }
 
     public void applyChildOptions(Options options) {
         optionsPresenter.onChildWillDisappear(disappearing, appearing, childDisappearListener);
     }
 
-    public void clearOptions() {
-        topBar.clear();
-    }
-
     public void initTopTabs(ViewPager viewPager) {
-        topBar.initTopTabs(viewPager);
+        topBarController.initTopTabs(viewPager);
     }
 
     public void clearTopTabs() {
-        topBar.clearTopTabs();
+        topBarController.clearTopTabs();
     }
 
     @RestrictTo(RestrictTo.Scope.TESTS)
     public TopBar getTopBar() {
-        return topBar;
+        return topBarController.getTopBar();
     }
 
     public void mergeChildOptions(Options options, Component child) {

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

 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.OptionHelper;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabsController;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.BottomTabs;
 import com.reactnativenavigation.views.ReactComponent;
 
     }
 
     @Test
-    public void containsRelativeLayoutView() throws Exception {
+    public void containsRelativeLayoutView() {
         assertThat(uut.getView()).isInstanceOf(RelativeLayout.class);
         assertThat(uut.getView().getChildAt(0)).isInstanceOf(BottomTabs.class);
     }
 
     @Test(expected = RuntimeException.class)
-    public void setTabs_ThrowWhenMoreThan5() throws Exception {
+    public void setTabs_ThrowWhenMoreThan5() {
         List<ViewController> tabs = createTabs();
         tabs.add(new SimpleViewController(activity, "6", tabOptions));
         uut.setTabs(tabs);
     }
 
     @Test
-    public void setTab_controllerIsSetAsParent() throws Exception {
+    public void setTab_controllerIsSetAsParent() {
         List<ViewController> tabs = createTabs();
         uut.setTabs(tabs);
         for (ViewController tab : tabs) {
     }
 
     @Test
-    public void setTabs_AddAllViews() throws Exception {
+    public void setTabs_AddAllViews() {
         List<ViewController> tabs = createTabs();
         uut.setTabs(tabs);
         assertThat(uut.getView().getChildCount()).isEqualTo(2);
     }
 
     @Test
-    public void selectTabAtIndex() throws Exception {
+    public void selectTabAtIndex() {
         uut.setTabs(createTabs());
         assertThat(uut.getSelectedIndex()).isZero();
 
     }
 
     @Test
-    public void findControllerById_ReturnsSelfOrChildren() throws Exception {
+    public void findControllerById_ReturnsSelfOrChildren() {
         assertThat(uut.findControllerById("123")).isNull();
         assertThat(uut.findControllerById(uut.getId())).isEqualTo(uut);
         StackController inner = createStack("inner");
     }
 
     @Test
-    public void handleBack_DelegatesToSelectedChild() throws Exception {
+    public void handleBack_DelegatesToSelectedChild() {
         assertThat(uut.handleBack()).isFalse();
 
         List<ViewController> tabs = createTabs();
     }
 
     @Test
-    public void applyOptions_bottomTabsOptionsAreClearedAfterApply() throws Exception {
+    public void applyOptions_bottomTabsOptionsAreClearedAfterApply() {
         List<ViewController> tabs = createTabs();
         child1.options.bottomTabsOptions.tabColor = new Color(android.graphics.Color.RED);
         uut.setTabs(tabs);
     }
 
     @Test
-    public void mergeOptions_currentTabIndex() throws Exception {
+    public void mergeOptions_currentTabIndex() {
         List<ViewController> tabs = createTabs();
         uut.setTabs(tabs);
         uut.ensureViewIsCreated();
     }
 
     @Test
-    public void buttonPressInvokedOnCurrentTab() throws Exception {
+    public void buttonPressInvokedOnCurrentTab() {
         uut.setTabs(createTabs());
         uut.ensureViewIsCreated();
         uut.selectTabAtIndex(1);
     }
 
     private StackController createStack(String id) {
-        return new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), id, tabOptions);
+        return new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), id, tabOptions);
     }
 }

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

 import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.StackLayout;
 
 import org.junit.Test;
         super.beforeEach();
         Activity activity = newActivity();
         view = spy(new TestComponentLayout(activity, new TestReactView(activity)));
-        ParentController<StackLayout> parentController = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), "stack", new Options());
+        ParentController<StackLayout> parentController = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), "stack", new Options());
         uut = new ComponentViewController(activity, "componentId1", "componentName", (activity1, componentId, componentName) -> view, new Options());
         uut.setParentController(parentController);
         parentController.ensureViewIsCreated();
     }
 
     @Test
-    public void createsViewFromComponentViewCreator() throws Exception {
+    public void createsViewFromComponentViewCreator() {
         assertThat(uut.getView()).isSameAs(view);
     }
 
     @Test
-    public void componentViewDestroyedOnDestroy() throws Exception {
+    public void componentViewDestroyedOnDestroy() {
         uut.ensureViewIsCreated();
         verify(view, times(0)).destroy();
         uut.onViewAppeared();
     }
 
     @Test
-    public void lifecycleMethodsSentToComponentView() throws Exception {
+    public void lifecycleMethodsSentToComponentView() {
         uut.ensureViewIsCreated();
         verify(view, times(0)).sendComponentStart();
         verify(view, times(0)).sendComponentStop();
     }
 
     @Test
-    public void isViewShownOnlyIfComponentViewIsReady() throws Exception {
+    public void isViewShownOnlyIfComponentViewIsReady() {
         assertThat(uut.isViewShown()).isFalse();
         uut.ensureViewIsCreated();
         when(view.asView().isShown()).thenReturn(true);
     }
 
     @Test
-    public void onNavigationButtonPressInvokedOnReactComponent() throws Exception {
+    public void onNavigationButtonPressInvokedOnReactComponent() {
         uut.ensureViewIsCreated();
         uut.sendOnNavigationButtonPressed("btn1");
         verify(view, times(1)).sendOnNavigationButtonPressed("btn1");

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

 import com.reactnativenavigation.parse.FabOptions;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.Fab;
 import com.reactnativenavigation.views.FabMenu;
 import com.reactnativenavigation.views.StackLayout;
     public void beforeEach() {
         super.beforeEach();
         activity = newActivity();
-        stackController = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(),"stackController", new Options());
+        stackController = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), "stackController", new Options());
         Options options = getOptionsWithFab();
         childFab = new SimpleViewController(activity, "child1", options);
         childNoFab = new SimpleViewController(activity, "child2", new Options());
     }
 
     @Test
-    public void showOnPush() throws Exception {
+    public void showOnPush() {
         stackController.push(childFab, new MockPromise());
         childFab.onViewAppeared();
         assertThat(hasFab()).isTrue();
     }
 
     @Test
-    public void hideOnPush() throws Exception {
+    public void hideOnPush() {
         stackController.push(childFab, new MockPromise());
         childFab.onViewAppeared();
         assertThat(hasFab()).isTrue();
     }
 
     @Test
-    public void hideOnPop() throws Exception {
+    public void hideOnPop() {
         stackController.push(childNoFab, new MockPromise());
         stackController.push(childFab, new MockPromise());
         childFab.onViewAppeared();
     }
 
     @Test
-    public void showOnPop() throws Exception {
+    public void showOnPop() {
         stackController.push(childFab, new MockPromise());
         stackController.push(childNoFab, new MockPromise());
         childNoFab.onViewAppeared();
     }
 
     @Test
-    public void hasChildren() throws Exception {
+    public void hasChildren() {
         childFab = new SimpleViewController(activity, "child1", getOptionsWithFabActions());
         stackController.push(childFab, new MockPromise());
         childFab.onViewAppeared();

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

 import com.reactnativenavigation.utils.ImageLoader;
 import com.reactnativenavigation.utils.OptionHelper;
 import com.reactnativenavigation.viewcontrollers.bottomtabs.BottomTabsController;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 
 import org.junit.Test;
 
     }
 
     @Test
-    public void setRoot_AddsChildControllerView() throws Exception {
+    public void setRoot_AddsChildControllerView() {
         assertThat(uut.getView().getChildCount()).isZero();
         uut.setRoot(child1, new MockPromise());
         assertIsChildById(uut.getView(), child1.getView());
     }
 
     @Test
-    public void setRoot_ReplacesExistingChildControllerViews() throws Exception {
+    public void setRoot_ReplacesExistingChildControllerViews() {
         uut.setRoot(child1, new MockPromise());
         uut.setRoot(child2, new MockPromise());
         assertIsChildById(uut.getView(), child2.getView());
     }
 
     @Test
-    public void hasUniqueId() throws Exception {
+    public void hasUniqueId() {
         assertThat(uut.getId()).startsWith("navigator");
         assertThat(new Navigator(activity).getId()).isNotEqualTo(uut.getId());
     }
 
     @Test
-    public void push() throws Exception {
+    public void push() {
         StackController stackController = newStack();
         stackController.animatePush(child1, new MockPromise());
         uut.setRoot(stackController, new MockPromise());
     }
 
     @Test
-    public void push_InvalidPushWithoutAStack_DoesNothing() throws Exception {
+    public void push_InvalidPushWithoutAStack_DoesNothing() {
         uut.setRoot(child1, new MockPromise());
         uut.push(child1.getId(), child2, new MockPromise());
         assertIsChildById(uut.getView(), child1.getView());
     }
 
     @Test
-    public void push_OnCorrectStackByFindingChildId() throws Exception {
+    public void push_OnCorrectStackByFindingChildId() {
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
     }
 
     @Test
-    public void pop_InvalidDoesNothing() throws Exception {
+    public void pop_InvalidDoesNothing() {
         uut.pop("123", new MockPromise());
         uut.setRoot(child1, new MockPromise());
         uut.pop(child1.getId(), new MockPromise());
     }
 
     @Test
-    public void pop_FromCorrectStackByFindingChildId() throws Exception {
+    public void pop_FromCorrectStackByFindingChildId() {
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
     }
 
     @Test
-    public void popSpecific() throws Exception {
+    public void popSpecific() {
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
     }
 
     @Test
-    public void popTo_FromCorrectStackUpToChild() throws Exception {
+    public void popTo_FromCorrectStackUpToChild() {
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
     }
 
     @Test
-    public void popToRoot() throws Exception {
+    public void popToRoot() {
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         StackController stack2 = newStack();
     }
 
     @Test
-    public void handleBack_DelegatesToRoot() throws Exception {
+    public void handleBack_DelegatesToRoot() {
         ViewController root = spy(child1);
         uut.setRoot(root, new MockPromise());
         when(root.handleBack()).thenReturn(true);
     }
 
     @Test
-    public void handleBack_modalTakePrecedenceOverRoot() throws Exception {
+    public void handleBack_modalTakePrecedenceOverRoot() {
         ViewController root = spy(child1);
         uut.setRoot(root, new MockPromise());
         uut.showModal(child2, new MockPromise());
 
     @NonNull
     private StackController newStack() {
-        return new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), "stack" + CompatUtils.generateViewId(), tabOptions);
+        return new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(),
+                "stack" + CompatUtils.generateViewId(), tabOptions);
     }
 
     @Test
-    public void push_Promise() throws Exception {
+    public void push_Promise() {
         final StackController stackController = newStack();
         stackController.animatePush(child1, new MockPromise());
         uut.setRoot(stackController, new MockPromise());
     }
 
     @Test
-    public void push_InvalidPushWithoutAStack_DoesNothing_Promise() throws Exception {
+    public void push_InvalidPushWithoutAStack_DoesNothing_Promise() {
         uut.setRoot(child1, new MockPromise());
         uut.push(child1.getId(), child2, new MockPromise() {
             @Override
     }
 
     @Test
-    public void pop_InvalidDoesNothing_Promise() throws Exception {
+    public void pop_InvalidDoesNothing_Promise() {
         uut.pop("123", new MockPromise());
         uut.setRoot(child1, new MockPromise());
         uut.pop(child1.getId(), new MockPromise() {
     }
 
     @Test
-    public void pop_FromCorrectStackByFindingChildId_Promise() throws Exception {
+    public void pop_FromCorrectStackByFindingChildId_Promise() {
         BottomTabsController bottomTabsController = newTabs();
         StackController stack1 = newStack();
         final StackController stack2 = newStack();
     }
 
     @Test
-    public void pushIntoModal() throws Exception {
+    public void pushIntoModal() {
         uut.setRoot(parentController, new MockPromise());
         StackController stackController = newStack();
         stackController.push(child1, new MockPromise());
     }
 
     @Test
-    public void pushedStackCanBePopped() throws Exception {
+    public void pushedStackCanBePopped() {
         StackController parent = newStack();
         parent.ensureViewIsCreated();
         uut.setRoot(parent, new MockPromise());
     }
 
     @Test
-    public void showModal_onViewDisappearIsInvokedOnRoot() throws Exception {
+    public void showModal_onViewDisappearIsInvokedOnRoot() {
         uut.setRoot(parentController, new MockPromise());
         uut.showModal(child1, new MockPromise() {
             @Override
     }
 
     @Test
-    public void dismissModal_onViewAppearedInvokedOnRoot() throws Exception {
+    public void dismissModal_onViewAppearedInvokedOnRoot() {
         uut.setRoot(parentController, new MockPromise());
         uut.showModal(child1, new MockPromise() {
             @Override

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

 import com.reactnativenavigation.parse.params.Fraction;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.utils.ViewUtils;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.topbar.TopBarBackgroundView;
 
 import org.json.JSONObject;
                 (activity1, componentId, componentName) -> view,
                 initialNavigationOptions
         );
-        stackController = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), "stack", new Options());
+        stackController = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), "stack", new Options());
         stackController.ensureViewIsCreated();
         uut.setParentController(stackController);
     }
 
     @Test
-    public void applyNavigationOptionsHandlesNoParentStack() throws Exception {
+    public void applyNavigationOptionsHandlesNoParentStack() {
         uut.setParentController(null);
         assertThat(uut.getParentController()).isNull();
         uut.ensureViewIsCreated();
     }
 
     @Test
-    public void initialOptionsAppliedOnAppear() throws Exception {
+    public void initialOptionsAppliedOnAppear() {
         uut.options.topBarOptions.title.text = new Text("the title");
-        StackController stackController = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), "stackId", new Options());
+        StackController stackController = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), "stackId", new Options());
         stackController.animatePush(uut, new MockPromise() {});
         assertThat(stackController.getTopBar().getTitle()).isEmpty();
 
     }
 
     @Test
-    public void mergeNavigationOptionsUpdatesCurrentOptions() throws Exception {
+    public void mergeNavigationOptionsUpdatesCurrentOptions() {
         uut.ensureViewIsCreated();
         assertThat(uut.options.topBarOptions.title.text.get("")).isEmpty();
         Options options = new Options();
     }
 
     @Test
-    public void reappliesOptionsOnMerge() throws Exception {
+    public void reappliesOptionsOnMerge() {
         uut.ensureViewIsCreated();
         uut.onViewAppeared();
         assertThat(stackController.getTopBar().getTitle()).isEmpty();
     }
 
     @Test
-    public void appliesTopBackBackgroundColor() throws Exception {
+    public void appliesTopBackBackgroundColor() {
         uut.ensureViewIsCreated();
         uut.onViewAppeared();
 
     }
 
     @Test
-    public void appliesTopBarTextColor() throws Exception {
+    public void appliesTopBarTextColor() {
         assertThat(uut.initialOptions).isSameAs(initialNavigationOptions);
         stackController.animatePush(uut, new MockPromise() {
             @Override
     }
 
     @Test
-    public void appliesTopBarTextSize() throws Exception {
+    public void appliesTopBarTextSize() {
         assertThat(uut.initialOptions).isSameAs(initialNavigationOptions);
         initialNavigationOptions.topBarOptions.title.text = new Text("the title");
         uut.ensureViewIsCreated();
     }
 
     @Test
-    public void appliesTopBarVisible() throws Exception {
+    public void appliesTopBarVisible() {
         assertThat(uut.initialOptions).isSameAs(initialNavigationOptions);
         initialNavigationOptions.topBarOptions.title.text = new Text("the title");
         uut.ensureViewIsCreated();
     }
 
     @Test
-    public void appliesDrawUnder() throws Exception {
+    public void appliesDrawUnder() {
         uut.options.topBarOptions.title.text = new Text("the title");
         uut.options.topBarOptions.drawBehind = new Bool(false);
         uut.ensureViewIsCreated();

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

 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.ReactComponent;
 
 import org.junit.Test;
 
 public class ParentControllerTest extends BaseTest {
 
-    public static final String INITIAL_TITLE = "initial title";
+    private static final String INITIAL_TITLE = "initial title";
     private Activity activity;
     private List<ViewController> children;
     private ParentController uut;
     }
 
     @Test
-    public void holdsViewGroup() throws Exception {
+    public void holdsViewGroup() {
         assertThat(uut.getView()).isInstanceOf(ViewGroup.class);
     }
 
     @Test
-    public void mustHaveChildControllers() throws Exception {
+    public void mustHaveChildControllers() {
         assertThat(uut.getChildControllers()).isNotNull();
     }
 
     @Test
-    public void findControllerById_ChildById() throws Exception {
+    public void findControllerById_ChildById() {
         SimpleViewController child1 = new SimpleViewController(activity, "child1", new Options());
         SimpleViewController child2 = new SimpleViewController(activity, "child2", new Options());
         children.add(child1);
     }
 
     @Test
-    public void findControllerById_Recursive() throws Exception {
+    public void findControllerById_Recursive() {
         StackController stackController = createStack();
         SimpleViewController child1 = new SimpleViewController(activity, "child1", new Options());
         SimpleViewController child2 = new SimpleViewController(activity, "child2", new Options());
     }
 
     @Test
-    public void destroy_DestroysChildren() throws Exception {
+    public void destroy_DestroysChildren() {
         ViewController child1 = spy(new SimpleViewController(activity, "child1", new Options()));
         children.add(child1);
 
     }
 
     @Test
-    public void optionsAreClearedWhenChildIsAppeared() throws Exception {
+    public void optionsAreClearedWhenChildIsAppeared() {
         StackController stackController = spy(createStack());
         SimpleViewController child1 = new SimpleViewController(activity, "child1", new Options());
         stackController.animatePush(child1, new MockPromise());
     }
 
     @Test
-    public void mergeOptions_optionsAreMergedWhenChildAppears() throws Exception {
+    public void mergeOptions_optionsAreMergedWhenChildAppears() {
         Options options = new Options();
         options.topBarOptions.title.text = new Text("new title");
         ViewController child1 = spy(new SimpleViewController(activity, "child1", options));
     }
 
     @Test
-    public void mergeOptions_initialParentOptionsAreNotMutatedWhenChildAppears() throws Exception {
+    public void mergeOptions_initialParentOptionsAreNotMutatedWhenChildAppears() {
         Options options = new Options();
         options.topBarOptions.title.text = new Text("new title");
         ViewController child1 = spy(new SimpleViewController(activity, "child1", options));
     }
 
     private StackController createStack() {
-        return new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(),"stack", new Options());
+        return new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), "stack", new Options());
     }
 }

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

 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.utils.ViewHelper;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 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.Ignore;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mockito;
     private ViewController child2;
     private ViewController child3;
     private NavigationAnimator animator;
+    private TopBarController topBarController;
 
     @Override
     public void beforeEach() {
     @Test
     public void pop_layoutHandlesChildWillDisappear() {
         final StackLayout[] stackLayout = new StackLayout[1];
-        uut = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), "uut", new Options()) {
+        uut = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), "uut", new Options()) {
             @NonNull
             @Override
             protected StackLayout createView() {
     @Test
     public void mergeChildOptions_updatesViewWithNewOptions() {
         final StackLayout[] stackLayout = new StackLayout[1];
-        StackController uut = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), "stack", new Options()) {
+        StackController uut = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), "stack", new Options()) {
             @NonNull
             @Override
             protected StackLayout createView() {
     @Test
     public void mergeChildOptions_updatesParentControllerWithNewOptions() {
         final StackLayout[] stackLayout = new StackLayout[1];
-        StackController uut = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), "stack", new Options()) {
+        StackController uut = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), "stack", new Options()) {
             @NonNull
             @Override
             protected StackLayout createView() {
         assertThat(captor.getValue().fabOptions.hasValue()).isFalse();
     }
 
+    @Test
+    public void destroy() {
+        uut.ensureViewIsCreated();
+        uut.destroy();
+        verify(topBarController, times(1)).clear();
+    }
+
     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(), new TopBarBackgroundViewCreatorMock(), id, new Options()) {
+        topBarController = spy(new TopBarController());
+        return new StackController(activity,
+                new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(),
+                topBarController, id, new Options()) {
             @Override
             NavigationAnimator createAnimator() {
                 animator = Mockito.mock(NavigationAnimator.class);

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

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Button;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 
 import org.junit.Ignore;
 import org.junit.Test;
 
         TopBarButtonCreatorMock buttonCreatorMock = new TopBarButtonCreatorMock();
         uut = spy(new TopBarButtonController(activity, button, buttonCreatorMock, (buttonId) -> {}));
-        stackController = spy(new StackController(activity, buttonCreatorMock, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), "stack", new Options()));
+        stackController = spy(new StackController(activity, buttonCreatorMock, new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), "stack", new Options()));
 
     }
 
     @Test
-    public void buttonDoesNotClearStackOptionsOnAppear() throws Exception {
+    public void buttonDoesNotClearStackOptionsOnAppear() {
         uut.ensureViewIsCreated();
         uut.onViewAppeared();
         verify(stackController, times(0)).clearOptions();
     }
 
     @Test @Ignore
-    public void destroy_buttonIsDestroyedWhenStackIsDestroyed() throws Exception {
+    public void destroy_buttonIsDestroyedWhenStackIsDestroyed() {
         uut.ensureViewIsCreated();
         uut.onViewAppeared();
         stackController.destroy();

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

 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.utils.ViewHelper;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsAdapter;
 import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsController;
 import com.reactnativenavigation.views.ReactComponent;
 
     @NonNull
     private StackController createStackController(String id) {
-        return new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), id, new Options());
+        return new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), id, new Options());
     }
 
     @NonNull
     }
 
     @Test
-    public void createsViewFromComponentViewCreator() throws Exception {
+    public void createsViewFromComponentViewCreator() {
         uut.ensureViewIsCreated();
         for (int i = 0; i < SIZE; i++) {
             verify(tabControllers.get(i), times(1)).createView();
     }
 
     @Test
-    public void componentViewDestroyedOnDestroy() throws Exception {
+    public void componentViewDestroyedOnDestroy() {
         uut.ensureViewIsCreated();
         TopTabsViewPager topTabs = uut.getView();
         for (int i = 0; i < SIZE; i++) {
     }
 
     @Test
-    public void lifecycleMethodsSentWhenSelectedTabChanges() throws Exception {
+    public void lifecycleMethodsSentWhenSelectedTabChanges() {
         parentController.ensureViewIsCreated();
         uut.ensureViewIsCreated();
         tabControllers.get(0).ensureViewIsCreated();
     }
 
     @Test
-    public void lifecycleMethodsSentWhenSelectedPreviouslySelectedTab() throws Exception {
+    public void lifecycleMethodsSentWhenSelectedPreviouslySelectedTab() {
         parentController.ensureViewIsCreated();
         uut.ensureViewIsCreated();
         uut.onViewAppeared();
     }
 
     @Test
-    public void setOptionsOfInitialTab() throws Exception {
+    public void setOptionsOfInitialTab() {
         parentController.ensureViewIsCreated();
         uut.ensureViewIsCreated();
         uut.onViewAppeared();
     }
 
     @Test
-    public void setOptionsWhenTabChanges() throws Exception {
+    public void setOptionsWhenTabChanges() {
         parentController.ensureViewIsCreated();
         uut.ensureViewIsCreated();
         tabControllers.get(0).ensureViewIsCreated();
     }
 
     @Test
-    public void appliesOptionsOnLayoutWhenVisible() throws Exception {
+    public void appliesOptionsOnLayoutWhenVisible() {
         tabControllers.get(0).ensureViewIsCreated();
         parentController.ensureViewIsCreated();
         uut.ensureViewIsCreated();
     }
 
     @Test
-    public void applyOptions_applyOnlyOnFirstTopTabs() throws Exception {
+    public void applyOptions_applyOnlyOnFirstTopTabs() {
         tabOptions.get(0).topTabOptions.title = new Text("tab title");
         tabControllers.get(0).onViewAppeared();
         ArgumentCaptor<Options> optionsCaptor = ArgumentCaptor.forClass(Options.class);
     }
 
     @Test
-    public void applyOptions_tabsAreRemovedAfterViewDisappears() throws Exception {
+    public void applyOptions_tabsAreRemovedAfterViewDisappears() {
         parentController.getView().removeAllViews();
 
         StackController stackController = spy(createStackController("stack"));
     }
 
     @Test
-    public void onNavigationButtonPressInvokedOnCurrentTab() throws Exception {
+    public void onNavigationButtonPressInvokedOnCurrentTab() {
         uut.ensureViewIsCreated();
         uut.switchToTab(1);
         uut.sendOnNavigationButtonPressed("btn1");

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

 import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarButtonCreatorMock;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 
 import org.assertj.android.api.Assertions;
 import org.junit.Test;
     }
 
     @Test
-    public void holdsAView() throws Exception {
+    public void holdsAView() {
         assertThat(uut.getView()).isNotNull().isInstanceOf(View.class);
     }
 
     @Test
-    public void holdsARefToActivity() throws Exception {
+    public void holdsARefToActivity() {
         assertThat(uut.getActivity()).isNotNull().isEqualTo(activity);
     }
 
     @Test
-    public void canOverrideViewCreation() throws Exception {
+    public void canOverrideViewCreation() {
         final FrameLayout otherView = new FrameLayout(activity);
         ViewController myController = new ViewController(activity, "vc", new Options()) {
             @Override
     }
 
     @Test
-    public void holdsAReferenceToStackControllerOrNull() throws Exception {
+    public void holdsAReferenceToStackControllerOrNull() {
         assertThat(uut.getParentController()).isNull();
-        StackController nav = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), "stack", new Options());
+        StackController nav = new StackController(activity, new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), "stack", new Options());
         nav.animatePush(uut, new MockPromise());
         assertThat(uut.getParentController()).isEqualTo(nav);
     }
 
     @Test
-    public void handleBackDefaultFalse() throws Exception {
+    public void handleBackDefaultFalse() {
         assertThat(uut.handleBack()).isFalse();
     }
 
     @Test
-    public void holdsId() throws Exception {
+    public void holdsId() {
         assertThat(uut.getId()).isEqualTo("uut");
     }
 
     @Test
-    public void isSameId() throws Exception {
+    public void isSameId() {
         assertThat(uut.isSameId("")).isFalse();
         assertThat(uut.isSameId(null)).isFalse();
         assertThat(uut.isSameId("uut")).isTrue();
     }
 
     @Test
-    public void findControllerById_SelfOrNull() throws Exception {
+    public void findControllerById_SelfOrNull() {
         assertThat(uut.findControllerById("456")).isNull();
         assertThat(uut.findControllerById("uut")).isEqualTo(uut);
     }
 
     @Test
-    public void onAppear_WhenShown() throws Exception {
+    public void onAppear_WhenShown() {
         ViewController spy = spy(uut);
         spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
         Assertions.assertThat(spy.getView()).isNotShown();
     }
 
     @Test
-    public void onAppear_CalledAtMostOnce() throws Exception {
+    public void onAppear_CalledAtMostOnce() {
         ViewController spy = spy(uut);
         Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
         Assertions.assertThat(spy.getView()).isShown();
     }
 
     @Test
-    public void onDisappear_WhenNotShown_AfterOnAppearWasCalled() throws Exception {
+    public void onDisappear_WhenNotShown_AfterOnAppearWasCalled() {
         ViewController spy = spy(uut);
         Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
         Assertions.assertThat(spy.getView()).isShown();
     }
 
     @Test
-    public void onDisappear_CalledAtMostOnce() throws Exception {
+    public void onDisappear_CalledAtMostOnce() {
         ViewController spy = spy(uut);
         Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
         Assertions.assertThat(spy.getView()).isShown();
     }
 
     @Test
-    public void onDestroy_CallsOnDisappearIfNeeded() throws Exception {
+    public void onDestroy_CallsOnDisappearIfNeeded() {
         ViewController spy = spy(uut);
         Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
         Assertions.assertThat(spy.getView()).isShown();
     }
 
     @Test
-    public void assignsIdToCreatedView() throws Exception {
+    public void assignsIdToCreatedView() {
         assertThat(uut.getView().getId()).isPositive();
     }
 
     @Test
-    public void onDestroy_RemovesSelfFromParentIfExists() throws Exception {
+    public void onDestroy_RemovesSelfFromParentIfExists() {
         LinearLayout parent = new LinearLayout(activity);
         parent.addView(uut.getView());
 
     }
 
     @Test
-    public void ensureViewIsCreated() throws Exception {
+    public void ensureViewIsCreated() {
         ViewController spy = spy(uut);
         verify(spy, times(0)).getView();
         spy.ensureViewIsCreated();

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

 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.utils.ViewUtils;
 import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.topbar.TopBar;
 import com.reactnativenavigation.views.topbar.TopBarBackgroundView;
 
                 return backgroundView;
             }
         };
-        StackLayout parent = new StackLayout(newActivity(), new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), backgroundViewCreator, onClickListener, null);
+        StackLayout parent = new StackLayout(newActivity(), new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), backgroundViewCreator, new TopBarController(), onClickListener, null);
         uut = new TopBar(newActivity(), new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), backgroundViewCreator, onClickListener, parent);
         parent.addView(uut);
     }
 
     @Test
-    public void setBackgroundComponent() throws Exception {
+    public void setBackgroundComponent() {
         uut.getLayoutParams().height = 100;
         uut.setBackgroundComponent(new Text("someComponent"));
         TopBarBackgroundView background = (TopBarBackgroundView) ViewUtils.findChildrenByClassRecursive(uut, TopBarBackgroundView.class).get(0);
     }
 
     @Test
-    public void setBackgroundComponent_doesNotSetIfNoComponentIsDefined() throws Exception {
+    public void setBackgroundComponent_doesNotSetIfNoComponentIsDefined() {
         uut.setBackgroundComponent(new Text("someComponent"));
         assertThat(uut.findViewById(R.id.topBarBackgroundComponent)).isNull();
     }
 
     @Test
-    public void clear_componentIsDestroyed() throws Exception {
+    public void clear_componentIsDestroyed() {
         uut.setBackgroundComponent(new Text("someComponent"));
         uut.clear();
         verify(backgroundView, times(1)).destroy();

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

 import com.reactnativenavigation.parse.params.Text;
 import com.reactnativenavigation.utils.TitleBarHelper;
 import com.reactnativenavigation.viewcontrollers.TopBarButtonController;
+import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.topbar.TopBar;
 
 import org.junit.Test;
                 Log.i("TopBarTest", "onPress: " + buttonId);
             }
         });
-        StackLayout parent = new StackLayout(newActivity(), new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), this.onClickListener, null);
+        StackLayout parent = new StackLayout(newActivity(), new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), new TopBarController(), this.onClickListener, null);
         uut = new TopBar(newActivity(), new TopBarButtonCreatorMock(), new TitleBarReactViewCreatorMock(), new TopBarBackgroundViewCreatorMock(), this.onClickListener, parent);
         animator = spy(new TopBarAnimator(uut));
         uut.setAnimator(animator);
     }
 
     @Test
-    public void title() throws Exception {
+    public void title() {
         assertThat(uut.getTitle()).isEmpty();
         uut.setTitle("new title");
         assertThat(uut.getTitle()).isEqualTo("new title");
     }
 
     @Test
-    public void hide_animate() throws Exception {
+    public void hide_animate() {
         AnimationOptions options = new AnimationOptions();
         uut.hideAnimate(options);
         verify(animator, times(1)).hide(options, null);
     }
 
     @Test
-    public void show_animate() throws Exception {
+    public void show_animate() {
         AnimationOptions options = new AnimationOptions();
         uut.hide();
         uut.showAnimate(options);
     }
 
     @Test
-    public void button_TitleBarButtonOnClickInvoked() throws Exception {
+    public void button_TitleBarButtonOnClickInvoked() {
         uut.setLeftButtons(new ArrayList<>());
         uut.setRightButtons(rightButtons);
         for (int i = 0; i < rightButtons.size(); i++) {