react-native-navigation 8.4.3 → 8.5.0

package/android/src/test/java/com/reactnativenavigation/viewcontrollers/stack/StackPresenterTest.kt

@@ -0,0 +1,1078 @@
+package com.reactnativenavigation.viewcontrollers.stack
+
+import android.app.Activity
+import android.content.Context
+import android.content.res.Configuration
+import android.graphics.Color
+import android.graphics.Typeface
+import android.view.View
+import android.view.ViewGroup
+import org.mockito.kotlin.*
+import com.reactnativenavigation.BaseTest
+import com.reactnativenavigation.TestUtils
+import com.reactnativenavigation.fakes.IconResolverFake
+import com.reactnativenavigation.mocks.*
+import com.reactnativenavigation.options.*
+import com.reactnativenavigation.options.params.*
+import com.reactnativenavigation.options.params.Number
+import com.reactnativenavigation.options.parsers.TypefaceLoader
+import com.reactnativenavigation.react.CommandListenerAdapter
+import com.reactnativenavigation.utils.*
+import com.reactnativenavigation.viewcontrollers.child.ChildControllersRegistry
+import com.reactnativenavigation.viewcontrollers.stack.topbar.TopBarController
+import com.reactnativenavigation.viewcontrollers.stack.topbar.button.ButtonController
+import com.reactnativenavigation.viewcontrollers.stack.topbar.button.ButtonPresenter
+import com.reactnativenavigation.viewcontrollers.stack.topbar.button.IconResolver
+import com.reactnativenavigation.viewcontrollers.stack.topbar.title.TitleBarReactViewController
+import com.reactnativenavigation.viewcontrollers.statusbar.StatusBarPresenter
+import com.reactnativenavigation.viewcontrollers.viewcontroller.ViewController
+import com.reactnativenavigation.views.stack.StackLayout
+import com.reactnativenavigation.views.stack.topbar.TopBar
+import com.reactnativenavigation.views.stack.topbar.titlebar.DEFAULT_LEFT_MARGIN_PX
+import com.reactnativenavigation.views.stack.topbar.titlebar.TitleBarReactView
+import com.reactnativenavigation.views.stack.topbar.titlebar.TitleSubTitleLayout
+import org.assertj.core.api.Assertions
+import org.assertj.core.api.Java6Assertions.assertThat
+import org.json.JSONObject
+import org.junit.Ignore
+import org.junit.Test
+import org.mockito.Mockito
+import org.robolectric.shadows.ShadowLooper
+import java.util.*
+import kotlin.collections.ArrayList
+
+@Ignore("New architecture - WIP")
+class StackPresenterTest : BaseTest() {
+    private lateinit var parent: StackController
+    private lateinit var uut: StackPresenter
+    private lateinit var ogUut: StackPresenter
+    private lateinit var child: ViewController<*>
+    private lateinit var otherChild: ViewController<*>
+    private lateinit var activity: Activity
+    private lateinit var topBar: TopBar
+    private lateinit var renderChecker: RenderChecker
+    private val textBtn1 = TitleBarHelper.textualButton("btn1")
+    private val textBtn2 = TitleBarHelper.textualButton("btn2")
+    private val componentBtn1 = TitleBarHelper.reactViewButton("btn1_")
+    private val componentBtn2 = TitleBarHelper.reactViewButton("btn2_")
+    private val titleComponent1 = TitleBarHelper.titleComponent("component1")
+    private val titleComponent2 = TitleBarHelper.titleComponent("component2")
+    private lateinit var topBarController: TopBarController
+    private lateinit var childRegistry: ChildControllersRegistry
+    private lateinit var typefaceLoader: TypefaceLoader
+    private lateinit var iconResolver: IconResolver
+    private lateinit var buttonCreator: TitleBarButtonCreatorMock
+    private lateinit var reactTitleView: TitleBarReactView
+
+    override fun beforeEach() {
+        super.beforeEach()
+        activity = spy(newActivity())
+        StatusBarPresenter.init(activity)
+        val titleViewCreator: TitleBarReactViewCreatorMock = object : TitleBarReactViewCreatorMock() {
+            override fun create(context: Context, componentId: String, componentName: String): TitleBarReactView {
+                reactTitleView = spy(super.create(context, componentId, componentName))
+                return reactTitleView
+            }
+        }
+        renderChecker = spy(RenderChecker())
+        typefaceLoader = createTypeFaceLoader()
+        iconResolver = IconResolverFake(activity)
+        buttonCreator = TitleBarButtonCreatorMock()
+        topBarController = createTopBarController()
+        ogUut = StackPresenter(
+            activity,
+            titleViewCreator,
+            buttonCreator,
+            topBarController,
+            iconResolver,
+            typefaceLoader,
+            renderChecker,
+            Options(),
+            TopBarBackgroundViewCreatorMock()
+        )
+        uut = spy(ogUut)
+        parent = TestUtils.newStackController(activity)
+                .setTopBarController(topBarController)
+                .setStackPresenter(uut)
+                .build()
+        childRegistry = ChildControllersRegistry()
+        child = spy(SimpleViewController(activity, childRegistry, "child1", Options.EMPTY))
+        otherChild = spy(SimpleViewController(activity, childRegistry, "child1", Options.EMPTY))
+        activity.setContentView(parent.view)
+    }
+
+    @Test
+    fun onConfigurationChange_shouldApplyColors() {
+        val options = Options.EMPTY.copy()
+        options.topBar.borderColor = ThemeColour.of(Color.BLACK, Color.RED)
+        options.topBar.background = TopBarBackgroundOptions().apply {
+            color = ThemeColour.of(Color.BLACK, Color.RED)
+        }
+        options.topBar.title = TitleOptions().apply {
+            color = ThemeColour.of(Color.BLACK, Color.RED)
+        }
+        options.topBar.subtitle = SubtitleOptions().apply {
+            color = ThemeColour.of(Color.BLACK, Color.RED)
+        }
+        options.topBar.buttons.back = BackButton().apply {
+            color = ThemeColour.of(Color.BLACK, Color.RED)
+            visible = Bool(true)
+        }
+        options.topBar.rightButtonColor = ThemeColour.of(Color.BLACK, Color.RED)
+        options.topBar.buttons.left = arrayListOf(ButtonOptions())
+        options.topBar.buttons.right = arrayListOf(ButtonOptions())
+
+        options.topTabs.selectedTabColor = ThemeColour.of(Color.BLACK, Color.RED)
+        options.topTabs.unselectedTabColor = ThemeColour.of(Color.BLACK, Color.RED)
+
+        mockConfiguration.uiMode = Configuration.UI_MODE_NIGHT_NO
+        uut.onConfigurationChanged(options)
+
+        verify(topBar).setTitleTextColor(Color.BLACK)
+        verify(topBar).setSubtitleColor(Color.BLACK)
+        verify(topBar).setBackgroundColor(Color.BLACK)
+        verify(topBar).setBorderColor(Color.BLACK)
+        verify(topBar).applyTopTabsColors(options.topTabs.selectedTabColor,options.topTabs.unselectedTabColor)
+        verify(topBar).setOverflowButtonColor(Color.BLACK)
+        verify(topBar).setBackButton(any())
+
+        mockConfiguration.uiMode = Configuration.UI_MODE_NIGHT_YES
+        uut.onConfigurationChanged(options)
+
+        verify(topBar).setTitleTextColor(Color.RED)
+        verify(topBar).setSubtitleColor(Color.RED)
+        verify(topBar).setBackgroundColor(Color.RED)
+        verify(topBar).setBorderColor(Color.RED)
+        verify(topBar,times(2)).applyTopTabsColors(options.topTabs.selectedTabColor,options.topTabs.unselectedTabColor)
+        verify(topBar).setOverflowButtonColor(Color.RED)
+        verify(topBar,times(2)).setBackButton(any())
+
+    }
+
+    @Test
+    fun onConfigurationChange_shouldApplyColorsOnTopBarButtons() {
+        val options = Options.EMPTY.copy()
+        options.topBar.buttons.left = arrayListOf(ButtonOptions())
+        options.topBar.buttons.right = arrayListOf(ButtonOptions())
+        uut.applyChildOptions(options,parent,child)
+
+        uut.onConfigurationChanged(options)
+
+        verify(topBarController, times(2)).applyRightButtons(any())
+        verify(topBarController, times(2)).applyLeftButtons(any())
+    }
+
+    @Test
+    fun isRendered() {
+        val o1 = Options()
+        o1.topBar.title.component = component(Alignment.Default)
+        o1.topBar.background.component = component(Alignment.Default)
+        o1.topBar.buttons.right = ArrayList(listOf(componentBtn1))
+        o1.topBar.buttons.left = ArrayList(listOf(componentBtn2))
+
+        uut.applyChildOptions(o1, parent, child)
+        uut.isRendered(child.view)
+
+        val controllers = argumentCaptor<Collection<ViewController<*>>>()
+        verify(renderChecker).areRendered(controllers.capture())
+        val items = controllers.firstValue
+        assertThat(items.size).isEqualTo(4)
+        assertThat(items.containsAll(listOf(
+                uut.getComponentButtons(child.view)[0],
+                uut.titleComponents[child.view] as ViewController<*>,
+                uut.backgroundComponents[child.view]
+        ))).isTrue()
+    }
+
+    @Test
+    fun applyChildOptions_setTitleComponent() {
+        val options = Options()
+        options.topBar.title.component = component(Alignment.Default)
+        uut.applyChildOptions(options, parent, child)
+        verify(topBar).setTitleComponent(uut.titleComponents[child.view]!!.view, Alignment.Default)
+    }
+
+    @Test
+    fun applyChildOptions_setTitleComponentCreatesOnce() {
+        val options = Options()
+        options.topBar.title.component = component(Alignment.Default)
+        uut.applyChildOptions(options, parent, child)
+        uut.applyChildOptions(Options.EMPTY, parent, otherChild)
+        val titleController = uut.titleComponents[child.view]
+        uut.applyChildOptions(options, parent, child)
+        assertThat(uut.titleComponents.size).isOne()
+        assertThat(uut.titleComponents[child.view]).isEqualTo(titleController)
+    }
+
+    @Test
+    fun applyChildOptions_setTitleComponentAlignmentCenter() {
+        val options = Options()
+        parent.view.layout(0, 0, 1000, 1000)
+        options.topBar.title.component = component(Alignment.Center)
+        uut.applyChildOptions(options, parent, child)
+        val component = topBar.titleAndButtonsContainer.getComponent()
+        Assertions.assertThat(component).isEqualTo(reactTitleView)
+        child.view.requestLayout()
+        idleMainLooper()
+        Assertions.assertThat(component?.left).isEqualTo(parent.view.width / 2 - reactTitleView.width / 2)
+        Assertions.assertThat(component?.right).isEqualTo(parent.view.width / 2 + reactTitleView.width / 2)
+    }
+
+    @Test
+    fun applyChildOptions_setTitleComponentAlignmentStart() {
+        val options = Options()
+        options.topBar.title.component = component(Alignment.Fill)
+        uut.applyChildOptions(options, parent, child)
+        val component = topBar.titleAndButtonsContainer.getComponent()
+        Assertions.assertThat(component).isEqualTo(reactTitleView)
+        Mockito.doReturn(100).`when`(reactTitleView).measuredWidth
+        child.view.requestLayout()
+        idleMainLooper()
+        Assertions.assertThat(component?.left).isEqualTo(DEFAULT_LEFT_MARGIN_PX)
+        Assertions.assertThat(component?.right).isEqualTo(DEFAULT_LEFT_MARGIN_PX + reactTitleView.measuredWidth + DEFAULT_LEFT_MARGIN_PX)
+    }
+
+    @Test
+    fun onChildDestroyed_destroyTitleComponent() {
+        val options = Options()
+        options.topBar.title.component = component(Alignment.Default)
+        uut.applyChildOptions(options, parent, child)
+        val titleView = uut.titleComponents[child.view]!!.view
+        uut.onChildDestroyed(child)
+        verify(titleView).destroy()
+    }
+
+    @Test
+    fun mergeOrientation() {
+        val options = Options()
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        verify(uut, never()).applyOrientation(any())
+        val orientation = JSONObject().put("orientation", "landscape")
+        options.layout.orientation = OrientationOptions.parse(orientation)
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        verify(uut).applyOrientation(options.layout.orientation)
+    }
+
+    @Test
+    fun mergeButtons() {
+        uut.mergeChildOptions(EMPTY_OPTIONS, EMPTY_OPTIONS, parent, child)
+        verify(topBarController, never()).applyRightButtons(any())
+        verify(topBarController, never()).applyLeftButtons(any())
+
+        val options = Options()
+        val button = ButtonOptions()
+        button.text = Text("btn")
+        options.topBar.buttons.right = ArrayList(setOf(button))
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        verify(topBarController).mergeRightButtons(any(), any())
+
+        options.topBar.buttons.left = ArrayList(setOf(button))
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        verify(topBarController).mergeLeftButtons(any(), any())
+    }
+
+    @Test
+    fun `mergeButtons - modify BackButton should not have effect on stack with with one child`() {
+        val options = Options()
+        options.topBar.buttons.back = BackButton.parse(activity, JSONObject().apply {
+            put("color", Color.RED)
+        })
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        verify(topBar, times(0)).setBackButton(any())
+    }
+
+    @Test
+    fun mergeButtons_previousRightButtonsAreDestroyed() {
+        val options = Options()
+        options.topBar.buttons.right = ArrayList(listOf(componentBtn1))
+        uut.applyChildOptions(options, parent, child)
+        val initialButtons = uut.getComponentButtons(child.view)
+        CollectionUtils.forEach(initialButtons) { obj: ButtonController -> obj.ensureViewIsCreated() }
+        options.topBar.buttons.right = ArrayList(listOf(componentBtn2))
+        uut.mergeChildOptions(options, Options.EMPTY, parent, child)
+        for (button in initialButtons) {
+            assertThat(button.isDestroyed).isTrue()
+        }
+    }
+
+    @Test
+    fun mergeRightButtons_mergingButtonsOnlyDestroysRightButtons() {
+        val a = Options()
+        a.topBar.buttons.right = ArrayList(listOf(componentBtn1))
+        a.topBar.buttons.left = ArrayList(listOf(componentBtn2))
+        uut.applyChildOptions(a, parent, child)
+        val initialButtons = uut.getComponentButtons(child.view)
+        CollectionUtils.forEach(initialButtons) { obj: ButtonController -> obj.ensureViewIsCreated() }
+        val b = Options()
+        b.topBar.buttons.right = ArrayList(listOf(componentBtn2))
+        uut.mergeChildOptions(b, Options.EMPTY, parent, child)
+        assertThat(initialButtons[0].isDestroyed).isTrue()
+        assertThat(initialButtons[1].isDestroyed).isFalse()
+    }
+
+    @Test
+    fun mergeRightButtons_buttonsAreCreatedOnlyIfNeeded() {
+        val toApply = Options()
+        textBtn1.color = ThemeColour(Colour(Color.GREEN))
+        toApply.topBar.buttons.right = arrayListOf(textBtn1, componentBtn1)
+        uut.applyChildOptions(toApply, parent, child)
+
+        val captor1 = argumentCaptor<List<ButtonController>>()
+        verify(topBarController).applyRightButtons(captor1.capture())
+        assertThat(topBar.rightButtonBar.menu.size()).isEqualTo(2)
+
+        val appliedButtons = captor1.firstValue
+        val toMerge = Options()
+        toMerge.topBar.buttons.right = ArrayList(toApply.topBar.buttons.right!!.map(ButtonOptions::copy))
+        toMerge.topBar.buttons.right!![0].color = ThemeColour(Colour(Color.RED))
+        toMerge.topBar.buttons.right!!.add(1, componentBtn2)
+        uut.mergeChildOptions(toMerge, Options.EMPTY, parent, child)
+
+        assertThat(topBar.rightButtonBar.menu.size()).isEqualTo(3)
+        val captor2 = argumentCaptor<List<ButtonController>>()
+        verify(topBarController).mergeRightButtons(captor2.capture(), any())
+        val mergedButtons = captor2.firstValue
+        assertThat(mergedButtons).hasSize(3)
+        assertThat(appliedButtons[0]).isNotEqualTo(mergedButtons[0])
+        assertThat(appliedButtons[1]).isEqualTo(mergedButtons[2])
+    }
+
+    @Test
+    fun mergeButtons_mergingLeftButtonsDoesNotDestroyRightButtons() {
+        val a = Options()
+        a.topBar.buttons.right = ArrayList(listOf(componentBtn1))
+        a.topBar.buttons.left = ArrayList(listOf(componentBtn2))
+        uut.applyChildOptions(a, parent, child)
+
+        val initialButtons = uut.getComponentButtons(child.view)
+        initialButtons.forEach(ButtonController::ensureViewIsCreated)
+        val b = Options()
+        b.topBar.buttons.left = ArrayList(listOf(componentBtn2))
+        uut.mergeChildOptions(b, Options.EMPTY, parent, child)
+        assertThat(initialButtons[0].isDestroyed).isFalse()
+    }
+
+    @Test
+    fun mergeChildOptions_backButtonShouldNotAffectLeftButtons() {
+        val options = Options()
+        options.topBar.buttons.right = ArrayList(listOf(textBtn1))
+        options.topBar.buttons.back = BackButton.parse(activity, JSONObject())
+        options.topBar.buttons.back.setVisible()
+        options.topBar.buttons.left = ArrayList(listOf(textBtn2))
+        uut.applyChildOptions(options, parent, child)
+        ShadowLooper.idleMainLooper()
+        verify(topBar, times(1)).clearLeftButtons()
+        verify(topBar, times(1)).clearBackButton()
+
+        val backButtonHidden = Options()
+        backButtonHidden.topBar.buttons.back.setHidden()
+        uut.mergeChildOptions(backButtonHidden, options, parent, child)
+        ShadowLooper.idleMainLooper()
+        verify(topBar, times(1)).clearLeftButtons()
+        verify(topBar, times(2)).clearBackButton()
+    }
+
+    @Test
+    fun mergeButtons_backButtonIsRemovedIfVisibleFalse() {
+        val pushedChild = spy<ViewController<*>>(SimpleViewController(activity, childRegistry, "child2", Options()))
+        disablePushAnimation(child, pushedChild)
+
+        parent.push(child, CommandListenerAdapter())
+        assertThat(topBar.navigationIcon).isNull()
+
+        parent.push(pushedChild, CommandListenerAdapter())
+        ShadowLooper.idleMainLooper()
+        verify(pushedChild).onViewWillAppear()
+        assertThat(topBar.navigationIcon).isInstanceOf(BackDrawable::class.java)
+
+        val backButtonHidden = Options()
+        backButtonHidden.topBar.buttons.back.setHidden()
+        uut.mergeChildOptions(backButtonHidden, backButtonHidden, parent, child)
+        ShadowLooper.idleMainLooper()
+        assertThat(topBar.navigationIcon).isNull()
+    }
+
+    @Test
+    fun mergeButtons_actualLeftButtonIsAppliedEvenIfBackButtonHasValue() {
+        val toMerge = Options()
+        toMerge.topBar.buttons.back.setHidden()
+        toMerge.topBar.buttons.left = ArrayList()
+        val leftButton = ButtonOptions()
+        leftButton.id = "id"
+        leftButton.icon = Text("")
+        toMerge.topBar.buttons.left!!.add(leftButton)
+
+        assertThat(toMerge.topBar.buttons.back.hasValue()).isTrue()
+        uut.mergeChildOptions(toMerge, Options.EMPTY, parent, child)
+        verify(topBarController).mergeLeftButtons(any(), any())
+        verify(topBar, never()).clearLeftButtons()
+    }
+
+    @Test
+    fun mergeChildOptions_mergeAnimateLeftRightButtons() {
+        val options = Options().apply {
+            topBar.animateLeftButtons = Bool(false)
+        }
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        verify(topBar).animateLeftButtons(false)
+        verify(topBar, never()).animateRightButtons(any())
+
+        options.apply {
+            topBar.animateRightButtons = Bool(true)
+        }
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        verify(topBar).animateRightButtons(true)
+
+
+        options.apply {
+            topBar.animateRightButtons = Bool(false)
+            topBar.animateLeftButtons = Bool(true)
+        }
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        verify(topBar).animateRightButtons(false)
+        verify(topBar).animateLeftButtons(true)
+    }
+    @Test
+    fun mergeTopBarOptions() {
+        val options = Options()
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        assertTopBarOptions(options, 0)
+        val title = TitleOptions()
+        title.text = Text("abc")
+        title.color = ThemeColour(Colour(0))
+        title.fontSize = Fraction(1.0)
+        title.font = FontOptions()
+        title.font.fontStyle = Text("bold")
+        options.topBar.title = title
+        val subtitleOptions = SubtitleOptions()
+        subtitleOptions.text = Text("Sub")
+        subtitleOptions.color = ThemeColour(Colour(1))
+        subtitleOptions.font.fontStyle = Text("bold")
+        subtitleOptions.fontSize = Fraction(1.0)
+        options.topBar.subtitle = subtitleOptions
+        options.topBar.background.color = ThemeColour(Colour(0))
+        options.topBar.testId = Text("test123")
+        options.topBar.animate = Bool(false)
+        options.topBar.visible = Bool(false)
+        options.topBar.drawBehind = Bool(false)
+        options.topBar.hideOnScroll = Bool(false)
+        options.topBar.validate()
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        assertTopBarOptions(options, 1)
+        options.topBar.drawBehind = Bool(true)
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+    }
+
+    @Test
+    fun mergeOptions_defaultOptionsAreNotApplied() {
+        val defaultOptions = Options()
+        defaultOptions.topBar.background.color = ThemeColour(Colour(10))
+        uut.defaultOptions = defaultOptions
+        val toMerge = Options()
+        toMerge.topBar.title.text = Text("someText")
+        uut.mergeOptions(toMerge, parent, child)
+        verify(topBar, never()).setBackgroundColor(any())
+    }
+
+    @Test
+    fun mergeOptions_shouldUpdateTitleAlignmentWhenNotDefault() {
+        val defaultOptions = Options()
+        defaultOptions.topBar.title.text = Text("title")
+        uut.defaultOptions = defaultOptions
+        val toMerge = Options()
+        toMerge.topBar.title.text = Text("newTitle")
+        uut.mergeOptions(toMerge, parent, child)
+
+        val alignmentOptions = Options()
+        alignmentOptions.topBar.title.alignment = Alignment.Center
+        uut.mergeOptions(alignmentOptions, parent, child)
+        verify(topBarController).alignTitleComponent(Alignment.Center)
+    }
+
+    @Test
+    fun mergeOptions_resolvedTitleFontOptionsAreApplied() {
+        val childOptions = Options()
+        childOptions.topBar.title.font.fontFamily = Text(SOME_FONT_FAMILY)
+        child.mergeOptions(childOptions)
+        val parentOptions = Options()
+        parentOptions.topBar.title.color = ThemeColour.of(Color.RED)
+        parent.mergeOptions(parentOptions)
+        val defaultOptions = Options()
+        defaultOptions.topBar.title.fontSize = Fraction(9.0)
+        uut.defaultOptions = defaultOptions
+        val toMerge = Options()
+        toMerge.topBar.title.text = Text("New Title")
+        uut.mergeOptions(toMerge, parent, child)
+        val title = (topBar.titleAndButtonsContainer.getTitleComponent() as TitleSubTitleLayout).getTitleTxtView()
+        assertThat(title).isNotNull()
+        assertThat(title.typeface).isEqualTo(SOME_TYPEFACE)
+        verify(topBar).setTitleFontSize(9.0)
+        verify(topBar).setTitleTextColor(Color.RED)
+    }
+
+    @Test
+    fun mergeOptions_resolvedSubtitleFontOptionsAreApplied() {
+        val childOptions = Options()
+        childOptions.topBar.subtitle.font.fontFamily = Text(SOME_FONT_FAMILY)
+        child.mergeOptions(childOptions)
+        val parentOptions = Options()
+        parentOptions.topBar.subtitle.color = ThemeColour(Colour(Color.RED))
+        parent.mergeOptions(parentOptions)
+        val defaultOptions = Options()
+        defaultOptions.topBar.subtitle.fontSize = Fraction(9.0)
+        uut.defaultOptions = defaultOptions
+        val toMerge = Options()
+        toMerge.topBar.subtitle.text = Text("New Title")
+        uut.mergeOptions(toMerge, parent, child)
+        val subtitle = (topBar.titleAndButtonsContainer.getTitleComponent() as TitleSubTitleLayout).getSubTitleTxtView()
+        assertThat(subtitle).isNotNull()
+        assertThat(subtitle.typeface).isEqualTo(SOME_TYPEFACE)
+        verify(topBar).setSubtitleFontSize(9.0)
+        verify(topBar).setSubtitleColor(Color.RED)
+    }
+
+    @Test
+    fun mergeChildOptions_resolvedTitleFontOptionsAreApplied() {
+        val defaultOptions = Options()
+        defaultOptions.topBar.title.fontSize = Fraction(9.0)
+        uut.defaultOptions = defaultOptions
+        val resolvedOptions = Options()
+        resolvedOptions.topBar.title.font.fontFamily = Text(SOME_FONT_FAMILY)
+        resolvedOptions.topBar.title.color = ThemeColour(Colour(Color.RED))
+        val toMerge = Options()
+        toMerge.topBar.title.text = Text("New Title")
+        uut.mergeChildOptions(toMerge, resolvedOptions, parent, child)
+        val title = (topBar.titleAndButtonsContainer.getTitleComponent() as TitleSubTitleLayout).getTitleTxtView()
+        assertThat(title).isNotNull()
+        assertThat(title.typeface).isEqualTo(SOME_TYPEFACE)
+        verify(topBar).setTitleFontSize(9.0)
+        verify(topBar).setTitleTextColor(Color.RED)
+    }
+
+    @Test
+    fun mergeChildOptions_resolvedSubtitleFontOptionsAreApplied() {
+        val defaultOptions = Options()
+        defaultOptions.topBar.subtitle.fontSize = Fraction(9.0)
+        uut.defaultOptions = defaultOptions
+        val resolvedOptions = Options()
+        resolvedOptions.topBar.subtitle.font.fontFamily = Text(SOME_FONT_FAMILY)
+        resolvedOptions.topBar.subtitle.color = ThemeColour(Colour(Color.RED))
+        val toMerge = Options()
+        toMerge.topBar.subtitle.text = Text("New Title")
+        uut.mergeChildOptions(toMerge, resolvedOptions, parent, child)
+        val subtitle = (topBar.titleAndButtonsContainer.getTitleComponent() as TitleSubTitleLayout).getSubTitleTxtView()
+        assertThat(subtitle).isNotNull()
+        assertThat(subtitle.typeface).isEqualTo(SOME_TYPEFACE)
+        verify(topBar).setSubtitleFontSize(9.0)
+        verify(topBar).setSubtitleColor(Color.RED)
+    }
+
+    @Test
+    fun mergeChildOptions_defaultOptionsAreNotApplied() {
+        val defaultOptions = Options()
+        defaultOptions.topBar.background.color = ThemeColour(Colour(10))
+        uut.defaultOptions = defaultOptions
+        val childOptions = Options()
+        childOptions.topBar.title.text = Text("someText")
+        uut.mergeChildOptions(childOptions, EMPTY_OPTIONS, parent, child)
+        verify(topBar, never()).setBackgroundColor(any())
+    }
+
+    @Test
+    fun applyTopBarOptions_setTitleComponent() {
+        val applyComponent = Options()
+        applyComponent.topBar.title.component.name = Text("Component1")
+        applyComponent.topBar.title.component.componentId = Text("Component1id")
+        uut.applyChildOptions(applyComponent, parent, child)
+        verify(topBarController).setTitleComponent(any())
+    }
+
+    @Test
+    fun mergeTopBarOptions_settingTitleDestroysComponent() {
+        val componentOptions = Options()
+        componentOptions.topBar.title.component = titleComponent1
+        uut.applyChildOptions(componentOptions, parent, child)
+        val applyCaptor = argumentCaptor<TitleBarReactViewController>()
+        verify(topBarController).setTitleComponent(applyCaptor.capture())
+        val titleOptions = Options()
+        titleOptions.topBar.title.text = Text("Some title")
+        uut.mergeChildOptions(titleOptions, Options.EMPTY, parent, child)
+        assertThat(applyCaptor.firstValue.isDestroyed).isTrue()
+    }
+
+    @Test
+    fun mergeTopBarOptions_doesNotRecreateTitleComponentIfEquals() {
+        val options = Options()
+        options.topBar.title.component = titleComponent1
+        uut.applyChildOptions(options, parent, child)
+        val applyCaptor = argumentCaptor<TitleBarReactViewController>()
+        verify(topBarController).setTitleComponent(applyCaptor.capture())
+        uut.mergeChildOptions(options, Options.EMPTY, parent, child)
+        verify(topBarController, times(2)).setTitleComponent(applyCaptor.firstValue)
+    }
+
+    @Test
+    fun mergeTopBarOptions_previousTitleComponentIsDestroyed() {
+        val options = Options()
+        options.topBar.title.component = titleComponent1
+        uut.applyChildOptions(options, parent, child)
+
+        val toMerge = Options()
+        toMerge.topBar.title.component = titleComponent2
+        uut.mergeChildOptions(toMerge, Options.EMPTY, parent, child)
+        val captor = argumentCaptor<TitleBarReactViewController>()
+        verify(topBarController, times(2)).setTitleComponent(captor.capture())
+        assertThat(captor.firstValue).isNotEqualTo(captor.secondValue)
+        assertThat(captor.firstValue.isDestroyed).isTrue()
+    }
+
+    @Test
+    fun mergeTopTabsOptions() {
+        val options = Options()
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        verify(topBar, never()).applyTopTabsColors(any(), any())
+        verify(topBar, never()).applyTopTabsFontSize(any())
+        verify(topBar, never()).setTopTabsVisible(any())
+        options.topTabs.selectedTabColor = ThemeColour(Colour(1))
+        options.topTabs.unselectedTabColor = ThemeColour(Colour(1))
+        options.topTabs.fontSize = Number(1)
+        options.topTabs.visible = Bool(true)
+        uut.mergeChildOptions(options, EMPTY_OPTIONS, parent, child)
+        verify(topBar).applyTopTabsColors(options.topTabs.selectedTabColor, options.topTabs.unselectedTabColor)
+        verify(topBar).applyTopTabsFontSize(options.topTabs.fontSize)
+        verify(topBar).setTopTabsVisible(any())
+    }
+
+    @Test
+    fun applyInitialChildLayoutOptions() {
+        val options = Options()
+        options.topBar.visible = Bool(false)
+        options.topBar.animate = Bool(true)
+        uut.applyInitialChildLayoutOptions(options)
+        verify(topBarController).hide()
+    }
+
+    @Test
+    fun applyButtons_buttonColorIsMergedToButtons() {
+        val options = Options()
+        val rightButton1 = ButtonOptions()
+        val rightButton2 = ButtonOptions()
+        val leftButton = ButtonOptions()
+        options.topBar.rightButtonColor = ThemeColour(Colour(10))
+        options.topBar.leftButtonColor = ThemeColour(Colour(100))
+        options.topBar.buttons.right = ArrayList()
+        options.topBar.buttons.right!!.add(rightButton1)
+        options.topBar.buttons.right!!.add(rightButton2)
+        options.topBar.buttons.left = ArrayList()
+        options.topBar.buttons.left!!.add(leftButton)
+        uut.applyChildOptions(options, parent, child)
+        val rightCaptor = argumentCaptor<List<ButtonController>>()
+        verify(topBarController).applyRightButtons(rightCaptor.capture())
+        assertThat(rightCaptor.firstValue[0].button.color.get()).isEqualTo(options.topBar.rightButtonColor.get())
+        assertThat(rightCaptor.firstValue[1].button.color.get()).isEqualTo(options.topBar.rightButtonColor.get())
+        assertThat(rightCaptor.firstValue[0]).isNotEqualTo(rightButton1)
+        assertThat(rightCaptor.firstValue[1]).isNotEqualTo(rightButton2)
+        val leftCaptor = argumentCaptor<List<ButtonController>>()
+        verify(topBarController).applyLeftButtons(leftCaptor.capture())
+        assertThat(leftCaptor.firstValue[0].button.color).isEqualTo(options.topBar.leftButtonColor)
+        assertThat(leftCaptor.firstValue[0]).isNotEqualTo(leftButton)
+    }
+
+    @Test
+    fun applyTopBarOptions_backgroundComponentIsCreatedOnceIfNameAndIdAreEqual() {
+        val o = Options()
+        o.topBar.background.component.name = Text("comp")
+        o.topBar.background.component.componentId = Text("compId")
+        uut.applyChildOptions(o, parent, Mocks.viewController())
+        assertThat(uut.backgroundComponents.size).isOne()
+        uut.applyChildOptions(o, parent, Mocks.viewController())
+        assertThat(uut.backgroundComponents.size).isOne()
+    }
+
+    @Test
+    fun mergeChildOptions_applyTopBarButtonsColor() {
+        val mergeOptions = Options()
+        val initialOptions = Options()
+        val rightButton = ButtonOptions()
+        val leftButton = ButtonOptions()
+        initialOptions.topBar.buttons.right = ArrayList(listOf(rightButton))
+        initialOptions.topBar.buttons.left = ArrayList(listOf(leftButton))
+
+        //add buttons
+        uut.applyChildOptions(initialOptions, parent, child)
+
+        //Merge color change for right and left buttons
+        mergeOptions.topBar.rightButtonColor = ThemeColour(Colour(100))
+        mergeOptions.topBar.leftButtonColor = ThemeColour(Colour(10))
+        val rightController = spy(ButtonController(activity, ButtonPresenter(activity, rightButton, iconResolver), rightButton, buttonCreator, mock()))
+        val leftController = spy(ButtonController(activity, ButtonPresenter(activity, leftButton, iconResolver), leftButton, buttonCreator, mock()))
+        uut.setComponentsButtonController(child.view, rightController, leftController)
+        uut.mergeChildOptions(mergeOptions, initialOptions, parent, child)
+
+        val rightColorCaptor = argumentCaptor<ThemeColour>()
+        verify(rightController).applyColor(any(), rightColorCaptor.capture())
+        assertThat(rightColorCaptor.allValues[0]).isEqualTo(mergeOptions.topBar.rightButtonColor)
+
+        val leftColorCaptor = argumentCaptor<ThemeColour>()
+        verify(leftController).applyColor(any(), leftColorCaptor.capture())
+        assertThat(leftColorCaptor.allValues[0]).isEqualTo(mergeOptions.topBar.leftButtonColor)
+    }
+
+    @Test
+    fun mergeChildOptions_applyTopBarButtonsDisabledColor() {
+        val mergeOptions = Options()
+        val initialOptions = Options()
+        val rightButton = ButtonOptions()
+        val leftButton = ButtonOptions()
+        initialOptions.topBar.buttons.right = ArrayList(listOf(rightButton))
+        initialOptions.topBar.buttons.left = ArrayList(listOf(leftButton))
+
+        //add buttons
+        uut.applyChildOptions(initialOptions, parent, child)
+
+        //Merge color change for right and left buttons
+        mergeOptions.topBar.rightButtonDisabledColor = ThemeColour(Colour(100))
+        mergeOptions.topBar.leftButtonDisabledColor = ThemeColour(Colour(10))
+        val rightController = spy(ButtonController(activity, ButtonPresenter(activity, rightButton, iconResolver), rightButton, buttonCreator, mock { }))
+        val leftController = spy(ButtonController(activity, ButtonPresenter(activity, leftButton, iconResolver), leftButton, buttonCreator, mock { }))
+        uut.setComponentsButtonController(child.view, rightController, leftController)
+        uut.mergeChildOptions(mergeOptions, initialOptions, parent, child)
+
+        val rightColorCaptor = argumentCaptor<ThemeColour>()
+        verify(rightController).applyDisabledColor(any(), rightColorCaptor.capture())
+        assertThat(rightColorCaptor.allValues[0]).isEqualTo(mergeOptions.topBar.rightButtonDisabledColor)
+
+        val leftColorCaptor = argumentCaptor<ThemeColour>()
+        verify(leftController).applyDisabledColor(any(), leftColorCaptor.capture())
+        assertThat(leftColorCaptor.allValues[0]).isEqualTo(mergeOptions.topBar.leftButtonDisabledColor)
+    }
+
+    @Test
+    fun mergeChildOptions_ignoreColorWhenClearingButtons() {
+        val mergeOptions = Options()
+        val initialOptions = Options()
+        val rightButton = ButtonOptions()
+        val leftButton = ButtonOptions()
+
+
+        //add buttons
+        initialOptions.topBar.buttons.right = ArrayList()
+        initialOptions.topBar.buttons.left = ArrayList()
+        uut.applyChildOptions(initialOptions, parent, child)
+
+        //Merge color change for right and left buttons with clear buttons
+        mergeOptions.topBar.buttons.right = ArrayList()
+        mergeOptions.topBar.buttons.left = ArrayList()
+        mergeOptions.topBar.rightButtonColor = ThemeColour(Colour(100))
+        mergeOptions.topBar.leftButtonColor = ThemeColour(Colour(100))
+        mergeOptions.topBar.rightButtonDisabledColor = ThemeColour(Colour(100))
+        mergeOptions.topBar.leftButtonDisabledColor = ThemeColour(Colour(10))
+        val rightController = spy(ButtonController(activity, ButtonPresenter(activity, rightButton, iconResolver), rightButton, buttonCreator, mock { }))
+        val leftController = spy(ButtonController(activity, ButtonPresenter(activity, leftButton, iconResolver), leftButton, buttonCreator, mock { }))
+        uut.setComponentsButtonController(child.view, rightController, leftController)
+        uut.mergeChildOptions(mergeOptions, initialOptions, parent, child)
+
+        verify(rightController, never()).applyColor(any(), any())
+        verify(leftController, never()).applyColor(any(), any())
+        verify(leftController, never()).applyDisabledColor(any(), any())
+        verify(leftController, never()).applyDisabledColor(any(), any())
+
+    }
+
+
+    @Test
+    fun mergeChildOptions_buttonColorIsResolvedFromAppliedOptions() {
+        val appliedOptions = Options()
+        appliedOptions.topBar.rightButtonColor = ThemeColour(Colour(10))
+        appliedOptions.topBar.leftButtonColor = ThemeColour(Colour(100))
+
+        val options2 = Options()
+        val rightButton1 = ButtonOptions()
+        val rightButton2 = ButtonOptions()
+        val leftButton = ButtonOptions()
+        options2.topBar.buttons.right = ArrayList(listOf(rightButton1, rightButton2))
+        options2.topBar.buttons.left = ArrayList(listOf(leftButton))
+
+        uut.mergeChildOptions(options2, appliedOptions, parent, child)
+        val rightCaptor = argumentCaptor<List<ButtonController>>()
+        verify(topBarController).mergeRightButtons(rightCaptor.capture(), any())
+        assertThat(rightCaptor.firstValue[0].button.color.get()).isEqualTo(appliedOptions.topBar.rightButtonColor.get())
+        assertThat(rightCaptor.firstValue[1].button.color.get()).isEqualTo(appliedOptions.topBar.rightButtonColor.get())
+        assertThat(rightCaptor.firstValue[0]).isNotEqualTo(rightButton1)
+        assertThat(rightCaptor.firstValue[1]).isNotEqualTo(rightButton2)
+        val leftCaptor = argumentCaptor<List<ButtonController>>()
+        verify(topBarController).mergeLeftButtons(leftCaptor.capture(), any())
+        assertThat(leftCaptor.firstValue[0].button.color.get()).isEqualTo(appliedOptions.topBar.leftButtonColor.get())
+        assertThat(leftCaptor.firstValue[0]).isNotEqualTo(leftButton)
+    }
+
+    @Test
+    fun mergeChildOptions_buttonColorIsResolvedFromMergedOptions() {
+        val resolvedOptions = Options()
+        resolvedOptions.topBar.rightButtonColor = ThemeColour(Colour(10))
+        resolvedOptions.topBar.leftButtonColor = ThemeColour(Colour(100))
+
+        val rightButton1 = ButtonOptions()
+        val rightButton2 = ButtonOptions()
+        val leftButton = ButtonOptions()
+        val options2 = Options()
+        options2.topBar.buttons.right = ArrayList(listOf(rightButton1, rightButton2))
+        options2.topBar.buttons.left = ArrayList(listOf(leftButton))
+
+        uut.mergeChildOptions(options2, resolvedOptions, parent, child)
+        val rightCaptor = argumentCaptor<List<ButtonController>>()
+        verify(topBarController).mergeRightButtons(rightCaptor.capture(), any())
+        assertThat(rightCaptor.firstValue[0].button.color.get()).isEqualTo(resolvedOptions.topBar.rightButtonColor.get())
+        assertThat(rightCaptor.firstValue[1].button.color.get()).isEqualTo(resolvedOptions.topBar.rightButtonColor.get())
+        assertThat(rightCaptor.firstValue[0]).isNotEqualTo(rightButton1)
+        assertThat(rightCaptor.firstValue[1]).isNotEqualTo(rightButton2)
+        val leftCaptor = argumentCaptor<List<ButtonController>>()
+        verify(topBarController).mergeLeftButtons(leftCaptor.capture(), any())
+        assertThat(leftCaptor.firstValue[0].button.color.get()).isEqualTo(resolvedOptions.topBar.leftButtonColor.get())
+        assertThat(leftCaptor.firstValue[0]).isNotEqualTo(leftButton)
+    }
+
+    @Test
+    fun buttonControllers_buttonControllersArePassedToTopBar() {
+        val options = Options()
+        options.topBar.buttons.right = ArrayList(listOf(textBtn1))
+        options.topBar.buttons.left = ArrayList(listOf(textBtn1))
+        uut.applyChildOptions(options, parent, child)
+        val rightCaptor = argumentCaptor<List<ButtonController>>()
+        val leftCaptor = argumentCaptor<List<ButtonController>>()
+        verify(topBarController).applyRightButtons(rightCaptor.capture())
+        verify(topBarController).applyLeftButtons(leftCaptor.capture())
+        assertThat(rightCaptor.firstValue.size).isOne()
+        assertThat(leftCaptor.firstValue.size).isOne()
+    }
+
+    @Test
+    fun buttonControllers_storesButtonsByComponent() {
+        val options = Options()
+        options.topBar.buttons.right = ArrayList(listOf(textBtn1))
+        options.topBar.buttons.left = ArrayList(listOf(textBtn2))
+        uut.applyChildOptions(options, parent, child)
+        val componentButtons = uut.getComponentButtons(child.view)
+        assertThat(componentButtons.size).isEqualTo(2)
+        assertThat(componentButtons[0].button.text.get()).isEqualTo(textBtn1.text.get())
+        assertThat(componentButtons[1].button.text.get()).isEqualTo(textBtn2.text.get())
+    }
+
+    @Test
+    fun buttonControllers_createdOnce() {
+        val options = Options()
+        options.topBar.buttons.right = ArrayList(listOf(textBtn1))
+        options.topBar.buttons.left = ArrayList(listOf(textBtn2))
+        uut.applyChildOptions(options, parent, child)
+        val buttons1 = uut.getComponentButtons(child.view)
+        uut.applyChildOptions(options, parent, child)
+        val buttons2 = uut.getComponentButtons(child.view)
+        for (i in 0..1) {
+            assertThat(buttons1[i]).isEqualTo(buttons2[i])
+        }
+    }
+
+    @Test
+    fun applyButtons_doesNotDestroyOtherComponentButtons() {
+        val options = Options()
+        options.topBar.buttons.right = ArrayList(listOf(componentBtn1))
+        options.topBar.buttons.left = ArrayList(listOf(componentBtn2))
+        uut.applyChildOptions(options, parent, child)
+        val buttons = uut.getComponentButtons(child.view)
+        buttons.forEach(ButtonController::ensureViewIsCreated)
+        uut.applyChildOptions(options, parent, otherChild)
+        buttons.forEach { assertThat(it.isDestroyed).isFalse() }
+    }
+
+    @Test
+    fun applyChildOptions_shouldNotPassAnimateLeftRightButtonBarWhenNoValue() {
+        val options = Options().apply {
+            topBar.buttons.right = ArrayList(listOf(componentBtn1))
+            topBar.buttons.left = ArrayList(listOf(componentBtn2))
+
+        }
+        uut.applyChildOptions(options, parent, child)
+        verify(topBar, never()).animateLeftButtons(any())
+        verify(topBar, never()).animateLeftButtons(any())
+    }
+
+    @Test
+    fun applyChildOptions_shouldPassAnimateLeftRightButtonBar() {
+        val options = Options().apply {
+            topBar.buttons.right = ArrayList(listOf(componentBtn1))
+            topBar.buttons.left = ArrayList(listOf(componentBtn2))
+            topBar.animateLeftButtons = Bool(false)
+            topBar.animateRightButtons = Bool(true)
+        }
+
+        uut.applyChildOptions(options, parent, child)
+        verify(topBar).animateRightButtons(true)
+        verify(topBar).animateLeftButtons(false)
+    }
+
+    @Test
+    fun onChildDestroyed_destroyedButtons() {
+        val options = Options()
+        options.topBar.buttons.right = ArrayList(listOf(componentBtn1))
+        options.topBar.buttons.left = ArrayList(listOf(componentBtn2))
+        uut.applyChildOptions(options, parent, child)
+        val buttons = uut.getComponentButtons(child.view)
+        buttons.forEach(ButtonController::ensureViewIsCreated)
+        uut.onChildDestroyed(child)
+        buttons.forEach { assertThat(it.isDestroyed).isTrue() }
+        assertThat(uut.getComponentButtons(child.view, null)).isNull()
+    }
+
+    @Test
+    fun onChildDestroyed_mergedRightButtonsAreDestroyed() {
+        val options = Options()
+        options.topBar.buttons.right = ArrayList(listOf(componentBtn1))
+        uut.mergeChildOptions(options, Options.EMPTY, parent, child)
+        val buttons = uut.getComponentButtons(child.view)
+        assertThat(buttons).hasSize(1)
+        uut.onChildDestroyed(child)
+        assertThat(buttons[0].isDestroyed).isTrue()
+    }
+
+    @Test
+    fun applyChildOptions_topBarShouldExtendBehindStatusBarWhenDrawBehind() {
+        val statusBarHeight = 10
+        val statusBarHeightDp = 20
+        val topBarHeightDp = 100
+        val options = Options().apply {
+            statusBar.drawBehind = Bool(true)
+        }
+        Mockito.`when`(child.resolveCurrentOptions()).thenReturn(options)
+        mockSystemUiUtils(statusBarHeight, statusBarHeightDp) {
+            uut.applyChildOptions(Options.EMPTY.copy().apply {
+                topBar.height = Number(topBarHeightDp)
+            }, parent, child)
+            assertThat(topBar.paddingTop).isEqualTo(statusBarHeight)
+            assertThat(topBar.y).isEqualTo(0f)
+            assertThat(topBar.layoutParams.height).isEqualTo(statusBarHeightDp + topBarHeightDp)
+        }
+    }
+
+    @Test
+    fun mergeChildOptions_topBarShouldExtendBehindStatusBarWhenDrawBehind() {
+        val statusBarHeight = 10
+        val statusBarHeightDp = 20
+        val topBarHeightDp = 100
+
+        mockSystemUiUtils(statusBarHeight, statusBarHeightDp) {
+            uut.mergeChildOptions(Options.EMPTY.copy().apply {
+                topBar.height = Number(topBarHeightDp)
+                statusBar.drawBehind = Bool(true)
+            }, Options.EMPTY, parent, child)
+            assertThat(topBar.paddingTop).isEqualTo(statusBarHeight)
+            assertThat(topBar.y).isEqualTo(0f)
+            assertThat(topBar.layoutParams.height).isEqualTo(statusBarHeightDp + topBarHeightDp)
+        }
+    }
+
+    @Test
+    fun mergeChildOptions_topBarShouldNotExtendBehindStatusBarWhenNoDrawBehind() {
+        val statusBarHeight = 10
+        val statusBarHeightDp = 20
+        val topBarHeightDp = 100
+
+        mockSystemUiUtils(statusBarHeight, statusBarHeightDp) {
+            uut.mergeChildOptions(Options.EMPTY.copy().apply {
+                topBar.height = Number(topBarHeightDp)
+                statusBar.drawBehind = Bool(false)
+            }, Options.EMPTY, parent, child)
+            assertThat(topBar.paddingTop).isEqualTo(0)
+            assertThat(topBar.y).isEqualTo(0f)
+            assertThat(topBar.layoutParams.height).isEqualTo( topBarHeightDp)
+        }
+    }
+
+    @Test
+    fun applyTopInsets_topBarIsDrawnUnderStatusBarIfDrawBehindIsTrue() {
+        val options = Options()
+        options.statusBar.drawBehind = Bool(true)
+        uut.applyTopInsets(parent, child)
+        assertThat(topBar.y).isEqualTo(0f)
+    }
+
+    @Test
+    fun applyTopInsets_topBarIsDrawnUnderStatusBarIfStatusBarIsHidden() {
+        val options = Options()
+        options.statusBar.visible = Bool(false)
+        uut.applyTopInsets(parent, Mocks.viewController())
+        assertThat(topBar.y).isEqualTo(0f)
+    }
+
+    @Test
+    fun applyTopInsets_delegatesToChild() {
+        uut.applyTopInsets(parent, child)
+        verify(child).applyTopInset()
+    }
+
+    @Test
+    fun applyChildOptions_shouldNotChangeTopMargin() {
+        val options = Options()
+        (topBar.layoutParams as ViewGroup.MarginLayoutParams).topMargin = 20
+        uut.applyChildOptions(options, parent, child)
+        assertThat((topBar.layoutParams as ViewGroup.MarginLayoutParams).topMargin).isEqualTo(20)
+    }
+
+    @Test
+    fun applyChildOptions_shouldChangeTopMargin() {
+        val options = Options()
+        (topBar.layoutParams as ViewGroup.MarginLayoutParams).topMargin = 20
+        options.topBar.topMargin = Number(10)
+        uut.applyChildOptions(options, parent, child)
+        assertThat((topBar.layoutParams as ViewGroup.MarginLayoutParams).topMargin).isEqualTo(10)
+    }
+
+    private fun assertTopBarOptions(options: Options, t: Int) {
+        if (options.topBar.title.component.hasValue()) {
+            verify(topBar, never()).title = any()
+            verify(topBar, never()).setSubtitle(any())
+            verify(topBar, times(t)).setTitleComponent(any<View>(), any<Alignment>())
+        } else if (options.topBar.title.text.hasValue()) {
+            verify(topBar, times(t)).title = any()
+            verify(topBar, times(t)).setSubtitle(any())
+            verify(topBar, never()).setTitleComponent(any<View>())
+        }
+        verify(topBar, times(t)).setBackgroundColor(any())
+        verify(topBar, times(t)).setTitleTextColor(any())
+        verify(topBar, times(t)).setSubtitleFontSize(any())
+        verify(topBar, times(t)).setTitleTypeface(any(), any())
+        verify(topBar, times(t)).setSubtitleTypeface(any(), any())
+        verify(topBar, times(t)).setSubtitleColor(any())
+        verify(topBar, times(t)).setTestId(any())
+        verify(topBarController, times(t)).hide()
+    }
+
+    private fun createTopBarController(): TopBarController {
+        return spy(object : TopBarController() {
+            override fun createTopBar(context: Context, stackLayout: StackLayout): TopBar {
+                topBar = spy(super.createTopBar(context, stackLayout))
+                topBar.layout(0, 0, 1000, UiUtils.getTopBarHeight(activity))
+                return topBar
+            }
+        })
+    }
+
+    fun component(alignment: Alignment): ComponentOptions {
+        val component = ComponentOptions()
+        component.name = Text("myComp")
+        component.alignment = alignment
+        component.componentId = Text("compId")
+        return component
+    }
+
+    private fun createTypeFaceLoader(): TypefaceLoaderMock {
+        val map: MutableMap<String, Typeface> = HashMap()
+        map[SOME_FONT_FAMILY] = SOME_TYPEFACE
+        return TypefaceLoaderMock(map)
+    }
+
+    companion object {
+        private val EMPTY_OPTIONS = Options()
+        const val SOME_FONT_FAMILY = "someFontFamily"
+        val SOME_TYPEFACE = mock<Typeface>()
+    }
+}