fix e2e, fixed indentation

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/ApplicationLifecycleTest.java

 package com.reactnativenavigation.e2e.androide2e;
 
-import android.content.Intent;
-import android.net.Uri;
-import android.provider.Settings;
-import android.support.test.uiautomator.By;
-import android.view.KeyEvent;
+import android.content.*;
+import android.net.*;
+import android.provider.*;
+import android.support.test.uiautomator.*;
+import android.view.*;
 
-import org.junit.Assume;
-import org.junit.Test;
+import org.junit.*;
 
-import static android.support.test.InstrumentationRegistry.getInstrumentation;
+import static android.support.test.InstrumentationRegistry.*;
 
 public class ApplicationLifecycleTest extends BaseTest {
 
-	@Test
-	public void relaunchFromBackground() throws Exception {
-		elementByText("PUSH").click();
-		assertExists(By.text("Pushed Screen"));
-
-		device().pressHome();
-		device().pressRecentApps();
-		elementByText("Playground").click();
-
-		assertExists(By.text("Pushed Screen"));
-	}
-
-	@Test
-	public void relaunchAfterClose() throws Exception {
-		elementByText("PUSH").click();
-		assertExists(By.text("Pushed Screen"));
-
-		device().pressBack();
-
-		launchTheApp();
-		assertMainShown();
-	}
-
-	@Test
-	public void deviceOrientationDoesNotDestroyActivity() throws Exception {
-		elementByText("PUSH").click();
-		assertExists(By.text("Pushed Screen"));
-
-		device().setOrientationLeft();
-		Thread.sleep(100);
-
-		assertExists(By.text("Pushed Screen"));
-	}
-
-	@Test
-	public void relaunchAfterActivityKilledBySystem() throws Exception {
-		elementByText("PUSH").click();
-		assertExists(By.text("Pushed Screen"));
-
-		killAppSaveInstanceState_ByTogglingPermissions();
-
-		device().pressRecentApps();
-		elementByText("Playground").click();
-		assertMainShown();
-	}
-
-	@Test
-	public void pressingMenuOpensDevMenu() throws Exception {
-		Assume.assumeTrue(isDebug());
-		device().pressKeyCode(KeyEvent.KEYCODE_MENU);
-		assertExists(By.text("Debug JS Remotely"));
-	}
-
-	@Test
-	public void pressingRTwiceInSuccessionReloadsReactNative() throws Exception {
-		Assume.assumeTrue(isDebug());
-
-		elementByText("PUSH").click();
-		assertExists(By.text("Pushed Screen"));
-
-		device().pressKeyCode(KeyEvent.KEYCODE_R);
-		device().pressKeyCode(KeyEvent.KEYCODE_R);
-		device().waitForIdle();
-		assertMainShown();
-	}
-
-	@Test
-	public void pressingRTwiceWithDelayDoesNothing() throws Exception {
-		Assume.assumeTrue(isDebug());
-
-		elementByText("PUSH").click();
-		assertExists(By.text("Pushed Screen"));
-
-		device().pressKeyCode(KeyEvent.KEYCODE_R);
-		Thread.sleep(1500);
-		device().pressKeyCode(KeyEvent.KEYCODE_R);
-		assertExists(By.text("Pushed Screen"));
-	}
-
-	@Test
-	public void sendingReloadBroadcastReloadsReactNative() throws Exception {
-		Assume.assumeTrue(isDebug());
-
-		elementByText("PUSH").click();
-		assertExists(By.text("Pushed Screen"));
-
-		device().executeShellCommand("am broadcast -a com.reactnativenavigation.broadcast.RELOAD");
-		device().waitForIdle();
-		assertMainShown();
-	}
-
-	private void killAppSaveInstanceState_ByTogglingPermissions() throws Exception {
-		device().pressHome();
-
-		device().waitForIdle();
-		launchAppInfoSettings();
-		device().waitForIdle();
-
-		elementByText("Permissions").click();
-		elementByText("Storage").click();
-		elementByText("Storage").click();
-		device().pressBack();
-		device().pressBack();
-		device().pressHome();
-		device().waitForIdle();
-	}
-
-	private void launchAppInfoSettings() {
-		Intent intent = new Intent();
-		intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
-		intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-		intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
-		intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
-		Uri uri = Uri.fromParts("package", PACKAGE_NAME, null);
-		intent.setData(uri);
-		getInstrumentation().getTargetContext().startActivity(intent);
-	}
+    @Test
+    public void relaunchFromBackground() throws Exception {
+        elementByText("PUSH").click();
+        assertExists(By.text("Pushed Screen"));
+
+        device().pressHome();
+        device().pressRecentApps();
+        elementByText("Playground").click();
+
+        assertExists(By.text("Pushed Screen"));
+    }
+
+    @Test
+    public void relaunchAfterClose() throws Exception {
+        elementByText("PUSH").click();
+        assertExists(By.text("Pushed Screen"));
+
+        device().pressBack();
+
+        launchTheApp();
+        assertMainShown();
+    }
+
+    @Test
+    public void deviceOrientationDoesNotDestroyActivity() throws Exception {
+        elementByText("PUSH").click();
+        assertExists(By.text("Pushed Screen"));
+
+        device().setOrientationLeft();
+        Thread.sleep(100);
+
+        assertExists(By.text("Pushed Screen"));
+    }
+
+    @Test
+    public void relaunchAfterActivityKilledBySystem() throws Exception {
+        elementByText("PUSH").click();
+        assertExists(By.text("Pushed Screen"));
+
+        killAppSaveInstanceState_ByTogglingPermissions();
+
+        device().pressRecentApps();
+        elementByText("Playground").click();
+        assertMainShown();
+    }
+
+    @Test
+    public void pressingMenuOpensDevMenu() throws Exception {
+        Assume.assumeTrue(isDebug());
+        device().pressKeyCode(KeyEvent.KEYCODE_MENU);
+        assertExists(By.text("Debug JS Remotely"));
+    }
+
+    @Test
+    public void pressingRTwiceInSuccessionReloadsReactNative() throws Exception {
+        Assume.assumeTrue(isDebug());
+
+        elementByText("PUSH").click();
+        assertExists(By.text("Pushed Screen"));
+
+        device().pressKeyCode(KeyEvent.KEYCODE_R);
+        device().pressKeyCode(KeyEvent.KEYCODE_R);
+        device().waitForIdle();
+        assertMainShown();
+    }
+
+    @Test
+    public void pressingRTwiceWithDelayDoesNothing() throws Exception {
+        Assume.assumeTrue(isDebug());
+
+        elementByText("PUSH").click();
+        assertExists(By.text("Pushed Screen"));
+
+        device().pressKeyCode(KeyEvent.KEYCODE_R);
+        Thread.sleep(1500);
+        device().pressKeyCode(KeyEvent.KEYCODE_R);
+        assertExists(By.text("Pushed Screen"));
+    }
+
+    @Test
+    public void sendingReloadBroadcastReloadsReactNative() throws Exception {
+        Assume.assumeTrue(isDebug());
+
+        elementByText("PUSH").click();
+        assertExists(By.text("Pushed Screen"));
+
+        device().executeShellCommand("am broadcast -a com.reactnativenavigation.broadcast.RELOAD");
+        device().waitForIdle();
+        assertMainShown();
+    }
+
+    private void killAppSaveInstanceState_ByTogglingPermissions() throws Exception {
+        device().pressHome();
+
+        device().waitForIdle();
+        launchAppInfoSettings();
+        device().waitForIdle();
+
+        elementByText("Permissions").click();
+        elementByText("Storage").click();
+        elementByText("Storage").click();
+        device().pressBack();
+        device().pressBack();
+        device().pressHome();
+        device().waitForIdle();
+    }
+
+    private void launchAppInfoSettings() {
+        Intent intent = new Intent();
+        intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
+        Uri uri = Uri.fromParts("package", PACKAGE_NAME, null);
+        intent.setData(uri);
+        getInstrumentation().getTargetContext().startActivity(intent);
+    }
 }

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/BackHandlerTest.java

 package com.reactnativenavigation.e2e.androide2e;
 
-import android.support.test.uiautomator.By;
+import android.support.test.uiautomator.*;
 
-import org.junit.Test;
+import org.junit.*;
 
 public class BackHandlerTest extends BaseTest {
     @Test

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/BaseTest.java

         return bitmap;
     }
 
-	public void swipeOpenFromLeft() {
-		int w = device().getDisplayWidth();
-		int h = device().getDisplayHeight();
-		device().swipe(5, h / 2, w / 2, h / 2, 20);
-	}
-
-	public void swipeOpenFromRight() {
-		int w = device().getDisplayWidth();
-		int h = device().getDisplayHeight();
-		device().swipe(w - 5, h / 2, w / 2, h / 2, 20);
-	}
+    public void swipeOpenFromLeft() {
+        int w = device().getDisplayWidth();
+        int h = device().getDisplayHeight();
+        device().swipe(5, h / 2, w / 2, h / 2, 20);
+    }
+
+    public void swipeOpenFromRight() {
+        int w = device().getDisplayWidth();
+        int h = device().getDisplayHeight();
+        device().swipe(w - 5, h / 2, w / 2, h / 2, 20);
+    }
 
     public void swipeUp() {
         int w = device().getDisplayWidth();

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/EnvironmentTest.java

 package com.reactnativenavigation.e2e.androide2e;
 
-import android.support.test.runner.AndroidJUnit4;
+import android.support.test.runner.*;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.*;
+import org.junit.runner.*;
 
-import static android.support.test.InstrumentationRegistry.getInstrumentation;
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static android.support.test.InstrumentationRegistry.*;
+import static org.assertj.core.api.Java6Assertions.*;
 
 @RunWith(AndroidJUnit4.class)
 public class EnvironmentTest {
-	@Test
-	public void instrumentationAndAssertJ() throws Exception {
-		assertThat(getInstrumentation().getTargetContext().getPackageName()).isEqualTo("com.reactnativenavigation.e2e.androide2e");
-	}
+    @Test
+    public void instrumentationAndAssertJ() throws Exception {
+        assertThat(getInstrumentation().getTargetContext().getPackageName()).isEqualTo("com.reactnativenavigation.e2e.androide2e");
+    }
 }

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/ModalsTest.java

 package com.reactnativenavigation.e2e.androide2e;
 
-import android.support.test.uiautomator.By;
+import android.support.test.uiautomator.*;
 
-import org.junit.Test;
+import org.junit.*;
 
 public class ModalsTest extends BaseTest {
 
-	@Test
-	public void showModal() throws Exception {
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Screen"));
-	}
-
-	@Test
-	public void dismissModal() throws Exception {
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Screen"));
-
-		elementByText("DISMISS MODAL").click();
-		assertMainShown();
-
-	}
-
-	@Test
-	public void showMultipleModals() throws Exception {
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 1"));
-
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 2"));
-
-		elementByText("DISMISS MODAL").click();
-		assertExists(By.text("Modal Stack Position: 1"));
-
-		elementByText("DISMISS MODAL").click();
-		assertMainShown();
-	}
-
-	@Test
-	public void dismissUnknownContainerId() throws Exception {
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 1"));
-
-		elementByText("DISMISS UNKNOWN MODAL").click();
-		assertExists(By.text("Modal Stack Position: 1"));
-
-		elementByText("DISMISS MODAL").click();
-		assertMainShown();
-	}
-
-	@Test
-	public void dismissModalByContainerIdWhenNotOnTop() throws Exception {
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 1"));
-
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 2"));
-
-		elementByText("DISMISS PREVIOUS MODAL").click();
-		assertExists(By.text("Modal Stack Position: 2"));
-
-		elementByText("DISMISS MODAL").click();
-		assertMainShown();
-	}
-
-	@Test
-	public void dismissAllPreviousModalsByIdWhenTheyAreBelowTopPresented() throws Exception {
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 1"));
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 2"));
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 3"));
-
-		elementByText("DISMISS ALL PREVIOUS MODALS").click();
-		assertExists(By.text("Modal Stack Position: 3"));
-
-		elementByText("DISMISS MODAL").click();
-		assertMainShown();
-	}
-
-	@Test
-	public void dismissSomeModalByIdDeepInTheStack() throws Exception {
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 1"));
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 2"));
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 3"));
-
-		elementByText("DISMISS FIRST IN STACK").click();
-		assertExists(By.text("Modal Stack Position: 3"));
-
-		elementByText("DISMISS MODAL").click();
-		assertExists(By.text("Modal Stack Position: 2"));
-
-		elementByText("DISMISS MODAL").click();
-		assertMainShown();
-	}
-
-	@Test
-	public void dismissAllModals() throws Exception {
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 1"));
-		elementByText("SHOW MODAL").click();
-		assertExists(By.text("Modal Stack Position: 2"));
-
-		elementByText("DISMISS ALL MODALS").click();
-		assertMainShown();
-	}
-
-	@Test
+    @Test
+    public void showModal() throws Exception {
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Screen"));
+    }
+
+    @Test
+    public void dismissModal() throws Exception {
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Screen"));
+
+        elementByText("DISMISS MODAL").click();
+        assertMainShown();
+
+    }
+
+    @Test
+    public void showMultipleModals() throws Exception {
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 1"));
+
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 2"));
+
+        elementByText("DISMISS MODAL").click();
+        assertExists(By.text("Modal Stack Position: 1"));
+
+        elementByText("DISMISS MODAL").click();
+        assertMainShown();
+    }
+
+    @Test
+    public void dismissUnknownContainerId() throws Exception {
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 1"));
+
+        elementByText("DISMISS UNKNOWN MODAL").click();
+        assertExists(By.text("Modal Stack Position: 1"));
+
+        elementByText("DISMISS MODAL").click();
+        assertMainShown();
+    }
+
+    @Test
+    public void dismissModalByContainerIdWhenNotOnTop() throws Exception {
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 1"));
+
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 2"));
+
+        elementByText("DISMISS PREVIOUS MODAL").click();
+        assertExists(By.text("Modal Stack Position: 2"));
+
+        elementByText("DISMISS MODAL").click();
+        assertMainShown();
+    }
+
+    @Test
+    public void dismissAllPreviousModalsByIdWhenTheyAreBelowTopPresented() throws Exception {
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 1"));
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 2"));
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 3"));
+
+        elementByText("DISMISS ALL PREVIOUS MODALS").click();
+        assertExists(By.text("Modal Stack Position: 3"));
+
+        elementByText("DISMISS MODAL").click();
+        assertMainShown();
+    }
+
+    @Test
+    public void dismissSomeModalByIdDeepInTheStack() throws Exception {
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 1"));
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 2"));
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 3"));
+
+        elementByText("DISMISS FIRST IN STACK").click();
+        assertExists(By.text("Modal Stack Position: 3"));
+
+        elementByText("DISMISS MODAL").click();
+        assertExists(By.text("Modal Stack Position: 2"));
+
+        elementByText("DISMISS MODAL").click();
+        assertMainShown();
+    }
+
+    @Test
+    public void dismissAllModals() throws Exception {
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 1"));
+        elementByText("SHOW MODAL").click();
+        assertExists(By.text("Modal Stack Position: 2"));
+
+        elementByText("DISMISS ALL MODALS").click();
+        assertMainShown();
+    }
+
+    @Test
     public void pushIntoModal() throws Exception {
         elementByText("SHOW MODAL").click();
         elementByText("PUSH SCREEN").click();

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/NavigationOptionsTest.java

 package com.reactnativenavigation.e2e.androide2e;
 
-import android.support.test.uiautomator.By;
-import android.support.test.uiautomator.Until;
+import android.support.test.uiautomator.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class NavigationOptionsTest extends BaseTest {
 
     @Test
     public void testTopBarHidden() throws Exception {
         elementByText("PUSH OPTIONS SCREEN").click();
-        int topWithNavigation = elementByText("HIDE TOP BAR").getVisibleBounds().top;
         elementByText("HIDE TOP BAR").click();
-        int topWithoutNavigation = elementByText("HIDE TOP BAR").getVisibleBounds().top;
-        assertThat(topWithoutNavigation).isLessThan(topWithNavigation);
+        assertThat(elementByText("Static Title").exists()).isFalse();
         elementByText("SHOW TOP BAR").click();
         assertExists(By.text("Static Title"));
     }

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/ScreenLifecycleTest.java

 package com.reactnativenavigation.e2e.androide2e;
 
-import android.support.test.uiautomator.By;
+import android.support.test.uiautomator.*;
 
-import org.junit.Test;
+import org.junit.*;
 
 public class ScreenLifecycleTest extends BaseTest {
 
-	@Test
-	public void didAppearDidDisappear() throws Exception {
-		elementByText("PUSH LIFECYCLE SCREEN").click();
-		assertExists(By.text("didAppear"));
-		elementByText("PUSH TO TEST DIDDISAPPEAR").click();
-		assertExists(By.text("didDisappear"));
-	}
+    @Test
+    public void didAppearDidDisappear() throws Exception {
+        elementByText("PUSH LIFECYCLE SCREEN").click();
+        assertExists(By.text("didAppear"));
+        elementByText("PUSH TO TEST DIDDISAPPEAR").click();
+        assertExists(By.text("didDisappear"));
+    }
 
-	@Test
-	public void unmountIsCalledWhenPopped() throws Exception {
-		elementByText("PUSH LIFECYCLE SCREEN").click();
-		assertExists(By.text("didAppear"));
+    @Test
+    public void unmountIsCalledWhenPopped() throws Exception {
+        elementByText("PUSH LIFECYCLE SCREEN").click();
+        assertExists(By.text("didAppear"));
 
-		device().pressBack();
+        device().pressBack();
 
-		assertExists(By.text("componentWillUnmount"));
-		elementByText("OK").click();
-		assertExists(By.text("didDisappear"));
-		elementByText("OK").click();
-		assertMainShown();
-	}
+        assertExists(By.text("componentWillUnmount"));
+        elementByText("OK").click();
+        assertExists(By.text("didDisappear"));
+        elementByText("OK").click();
+        assertMainShown();
+    }
 }

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/ScreenStackTest.java

 package com.reactnativenavigation.e2e.androide2e;
 
-import android.support.test.uiautomator.By;
+import android.support.test.uiautomator.*;
 
-import org.junit.Test;
+import org.junit.*;
 
 public class ScreenStackTest extends BaseTest {
 
-	@Test
-	public void pushAndPopScreen() throws Exception {
-		elementByText("PUSH").click();
-		assertExists(By.text("Pushed Screen"));
-		elementByText("POP").click();
-		assertMainShown();
-	}
+    @Test
+    public void pushAndPopScreen() throws Exception {
+        elementByText("PUSH").click();
+        assertExists(By.text("Pushed Screen"));
+        elementByText("POP").click();
+        assertMainShown();
+    }
 
-	@Test
-	public void popScreenDeepInTheStack() throws Exception {
-		elementByText("PUSH").click();
-		assertExists(By.text("Pushed Screen"));
-		assertExists(By.text("Stack Position: 1"));
-		elementByText("PUSH").click();
-		assertExists(By.text("Stack Position: 2"));
-		elementByText("POP PREVIOUS").click();
-		assertExists(By.text("Stack Position: 2"));
-		elementByText("POP").click();
-		assertMainShown();
-	}
+    @Test
+    public void popScreenDeepInTheStack() throws Exception {
+        elementByText("PUSH").click();
+        assertExists(By.text("Pushed Screen"));
+        assertExists(By.text("Stack Position: 1"));
+        elementByText("PUSH").click();
+        assertExists(By.text("Stack Position: 2"));
+        elementByText("POP PREVIOUS").click();
+        assertExists(By.text("Stack Position: 2"));
+        elementByText("POP").click();
+        assertMainShown();
+    }
 
-	@Test
-	public void popToId() throws Exception {
-		elementByText("PUSH").click();
-		elementByText("PUSH").click();
-		elementByText("PUSH").click();
-		assertExists(By.text("Stack Position: 3"));
-		elementByText("POP TO STACK POSITION 1").click();
-		assertExists(By.text("Stack Position: 1"));
-	}
+    @Test
+    public void popToId() throws Exception {
+        elementByText("PUSH").click();
+        elementByText("PUSH").click();
+        elementByText("PUSH").click();
+        assertExists(By.text("Stack Position: 3"));
+        elementByText("POP TO STACK POSITION 1").click();
+        assertExists(By.text("Stack Position: 1"));
+    }
 
-	@Test
-	public void popToRoot() throws Exception {
-		elementByText("PUSH").click();
-		elementByText("PUSH").click();
-		elementByText("PUSH").click();
-		elementByText("POP TO ROOT").click();
-		assertMainShown();
-	}
+    @Test
+    public void popToRoot() throws Exception {
+        elementByText("PUSH").click();
+        elementByText("PUSH").click();
+        elementByText("PUSH").click();
+        elementByText("POP TO ROOT").click();
+        assertMainShown();
+    }
 }

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/TopLevelApiTest.java

 package com.reactnativenavigation.e2e.androide2e;
 
-import android.support.test.uiautomator.By;
+import android.support.test.uiautomator.*;
 
-import org.junit.Test;
+import org.junit.*;
 
 public class TopLevelApiTest extends BaseTest {
 
-	@Test
-	public void switchToTabBasedApp_PassPropsFunction() throws Exception {
-		elementByText("SWITCH TO TAB BASED APP").click();
-		assertExists(By.text("This is tab 1"));
-		assertExists(By.text("Hello from a function!"));
-  }
-  
-  @Test
-	public void switchToTabBasedApp_SwitchTab() throws Exception {
-		elementByText("SWITCH TO TAB BASED APP").click();
-		assertExists(By.text("This is tab 1"));
+    @Test
+    public void switchToTabBasedApp_PassPropsFunction() throws Exception {
+        elementByText("SWITCH TO TAB BASED APP").click();
+        assertExists(By.text("This is tab 1"));
+        assertExists(By.text("Hello from a function!"));
+    }
+
+    @Test
+    public void switchToTabBasedApp_SwitchTab() throws Exception {
+        elementByText("SWITCH TO TAB BASED APP").click();
+        assertExists(By.text("This is tab 1"));
         elementByText("SWITCH TO TAB 2").click();
         assertExists(By.text("This is tab 2"));
-	}
+    }
 
-	@Test
-	public void switchToTabsWithSideMenu() throws Exception {
-		elementByText("SWITCH TO APP WITH SIDE MENUS").click();
-		assertExists(By.textStartsWith("This is a side menu center screen tab 1"));
-		swipeOpenFromLeft();
-		assertExists(By.text("This is a left side menu screen"));
-	}
+    @Test
+    public void switchToTabsWithSideMenu() throws Exception {
+        elementByText("SWITCH TO APP WITH SIDE MENUS").click();
+        assertExists(By.textStartsWith("This is a side menu center screen tab 1"));
+        swipeOpenFromLeft();
+        assertExists(By.text("This is a left side menu screen"));
+    }
 }

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

 package com.reactnativenavigation.parse;
 
 
-import com.reactnativenavigation.parse.NavigationOptions.BooleanOptions;
+import com.reactnativenavigation.parse.Options.BooleanOptions;
 
 import org.json.JSONObject;
 

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

 import java.util.ArrayList;
 
 import static com.reactnativenavigation.parse.DEFAULT_VALUES.NO_VALUE;
-import static com.reactnativenavigation.parse.NavigationOptions.NO_INT_VALUE;
+import static com.reactnativenavigation.parse.Options.NO_INT_VALUE;
 
 public class Button {
 	public String id;
 	public String title;
-	public NavigationOptions.BooleanOptions disabled;
-	public NavigationOptions.BooleanOptions disableIconTint;
+	public Options.BooleanOptions disabled;
+	public Options.BooleanOptions disableIconTint;
 	public int showAsAction;
 	@ColorInt public int buttonColor;
 	public int buttonFontSize;
 		Button button = new Button();
 		button.id = json.optString("id");
 		button.title = json.optString("title", NO_VALUE);
-		button.disabled = NavigationOptions.BooleanOptions.parse(json.optString("disabled", NO_VALUE));
-		button.disableIconTint = NavigationOptions.BooleanOptions.parse(json.optString("disableIconTint", NO_VALUE));
+		button.disabled = Options.BooleanOptions.parse(json.optString("disabled", NO_VALUE));
+		button.disableIconTint = Options.BooleanOptions.parse(json.optString("disableIconTint", NO_VALUE));
 		button.showAsAction = parseShowAsAction(json.optString("showAsAction", NO_VALUE));
 		button.buttonColor = json.optInt("buttonColor", NO_INT_VALUE);
 		button.buttonFontSize = json.optInt("buttonFontSize", NO_INT_VALUE);

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

 
 	private final Activity activity;
 	private final ReactInstanceManager reactInstanceManager;
-    private NavigationOptions defaultOptions;
+    private Options defaultOptions;
     private final TypefaceLoader typefaceManager;
 
-    public LayoutFactory(Activity activity, final ReactInstanceManager reactInstanceManager, NavigationOptions defaultOptions) {
+    public LayoutFactory(Activity activity, final ReactInstanceManager reactInstanceManager, Options defaultOptions) {
 		this.activity = activity;
 		this.reactInstanceManager = reactInstanceManager;
         this.defaultOptions = defaultOptions;
 	private ViewController createComponent(LayoutNode node) {
 		String id = node.id;
 		String name = node.data.optString("name");
-		NavigationOptions options = NavigationOptions.parse(typefaceManager, node.data.optJSONObject("options"), defaultOptions);
+		Options options = Options.parse(typefaceManager, node.data.optJSONObject("options"), defaultOptions);
 		return new ComponentViewController(activity,
                 id,
                 name,
             tabController.setTabIndex(i);
             tabs.add(tabController);
         }
-        NavigationOptions options = NavigationOptions.parse(typefaceManager, node.getNavigationOptions(), defaultOptions);
+        Options options = Options.parse(typefaceManager, node.getNavigationOptions(), defaultOptions);
         return new TopTabsController(activity, node.id, tabs, new TopTabsLayoutCreator(activity, tabs), options);
     }
 
     private ViewController createTopTab(LayoutNode node) {
         String id = node.id;
         String name = node.data.optString("name");
-        NavigationOptions options = NavigationOptions.parse(typefaceManager, node.getNavigationOptions(), defaultOptions);
+        Options options = Options.parse(typefaceManager, node.getNavigationOptions(), defaultOptions);
         return new TopTabController(activity,
                 id,
                 name,

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

 
 import org.json.JSONObject;
 
-public class NavigationOptions implements DEFAULT_VALUES {
+public class Options implements DEFAULT_VALUES {
 
     public enum BooleanOptions {
 		True,
 	}
 
     @NonNull
-    public static NavigationOptions parse(TypefaceLoader typefaceManager, JSONObject json) {
-        return parse(typefaceManager, json, new NavigationOptions());
+    public static Options parse(TypefaceLoader typefaceManager, JSONObject json) {
+        return parse(typefaceManager, json, new Options());
     }
 
 	@NonNull
-	public static NavigationOptions parse(TypefaceLoader typefaceManager, JSONObject json, @NonNull NavigationOptions defaultOptions) {
-		NavigationOptions result = new NavigationOptions();
+	public static Options parse(TypefaceLoader typefaceManager, JSONObject json, @NonNull Options defaultOptions) {
+		Options result = new Options();
 		if (json == null) return result;
 
 		result.topBarOptions = TopBarOptions.parse(typefaceManager, json.optJSONObject("topBar"));
     @NonNull public TopTabOptions topTabOptions = new TopTabOptions();
     @NonNull public BottomTabsOptions bottomTabsOptions = new BottomTabsOptions();
 
-	public void mergeWith(final NavigationOptions other) {
+	public void mergeWith(final Options other) {
         topBarOptions.mergeWith(other.topBarOptions);
         topTabsOptions.mergeWith(other.topTabsOptions);
         bottomTabsOptions.mergeWith(other.bottomTabsOptions);
     }
 
-    NavigationOptions withDefaultOptions(final NavigationOptions other) {
+    Options withDefaultOptions(final Options other) {
         topBarOptions.mergeWithDefault(other.topBarOptions);
         topTabsOptions.mergeWithDefault(other.topTabsOptions);
         bottomTabsOptions.mergeWithDefault(other.bottomTabsOptions);

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

         options.textColor = json.optInt("textColor", NO_COLOR_VALUE);
         options.textFontSize = (float) json.optDouble("textFontSize", NO_FLOAT_VALUE);
         options.textFontFamily = typefaceManager.getTypeFace(json.optString("textFontFamily", NO_VALUE));
-        options.hidden = NavigationOptions.BooleanOptions.parse(json.optString("hidden"));
-        options.animateHide = NavigationOptions.BooleanOptions.parse(json.optString("animateHide"));
-        options.hideOnScroll = NavigationOptions.BooleanOptions.parse(json.optString("hideOnScroll"));
-        options.drawBehind = NavigationOptions.BooleanOptions.parse(json.optString("drawBehind"));
+        options.hidden = Options.BooleanOptions.parse(json.optString("hidden"));
+        options.animateHide = Options.BooleanOptions.parse(json.optString("animateHide"));
+        options.hideOnScroll = Options.BooleanOptions.parse(json.optString("hideOnScroll"));
+        options.drawBehind = Options.BooleanOptions.parse(json.optString("drawBehind"));
         options.rightButtons = Button.parseJsonArray(json.optJSONArray("rightButtons"));
         options.leftButtons = Button.parseJsonArray(json.optJSONArray("leftButtons"));
 
     @ColorInt public int textColor = NO_COLOR_VALUE;
     public float textFontSize = NO_FLOAT_VALUE;
     @Nullable public Typeface textFontFamily;
-    public NavigationOptions.BooleanOptions hidden = NavigationOptions.BooleanOptions.NoValue;
-    public NavigationOptions.BooleanOptions animateHide = NavigationOptions.BooleanOptions.NoValue;
-    public NavigationOptions.BooleanOptions hideOnScroll = NavigationOptions.BooleanOptions.NoValue;
-    public NavigationOptions.BooleanOptions drawBehind = NavigationOptions.BooleanOptions.NoValue;
+    public Options.BooleanOptions hidden = Options.BooleanOptions.NoValue;
+    public Options.BooleanOptions animateHide = Options.BooleanOptions.NoValue;
+    public Options.BooleanOptions hideOnScroll = Options.BooleanOptions.NoValue;
+    public Options.BooleanOptions drawBehind = Options.BooleanOptions.NoValue;
     public ArrayList<Button> leftButtons;
     public ArrayList<Button> rightButtons;
 
             textFontSize = other.textFontSize;
         if (other.textFontFamily != null)
             textFontFamily = other.textFontFamily;
-        if (other.hidden != NavigationOptions.BooleanOptions.NoValue) {
+        if (other.hidden != Options.BooleanOptions.NoValue) {
             hidden = other.hidden;
         }
-        if (other.animateHide != NavigationOptions.BooleanOptions.NoValue) {
+        if (other.animateHide != Options.BooleanOptions.NoValue) {
             animateHide = other.animateHide;
         }
-        if (other.hideOnScroll != NavigationOptions.BooleanOptions.NoValue) {
+        if (other.hideOnScroll != Options.BooleanOptions.NoValue) {
             hideOnScroll = other.hideOnScroll;
         }
-        if (other.drawBehind != NavigationOptions.BooleanOptions.NoValue) {
+        if (other.drawBehind != Options.BooleanOptions.NoValue) {
             drawBehind = other.drawBehind;
         }
         if (other.leftButtons != null)
             textFontSize = defaultOptions.textFontSize;
         if (textFontFamily == null)
             textFontFamily = defaultOptions.textFontFamily;
-        if (hidden == NavigationOptions.BooleanOptions.NoValue)
+        if (hidden == Options.BooleanOptions.NoValue)
             hidden = defaultOptions.hidden;
-        if (animateHide == NavigationOptions.BooleanOptions.NoValue)
+        if (animateHide == Options.BooleanOptions.NoValue)
             animateHide = defaultOptions.animateHide;
-        if (hideOnScroll == NavigationOptions.BooleanOptions.NoValue)
+        if (hideOnScroll == Options.BooleanOptions.NoValue)
             hideOnScroll = defaultOptions.hideOnScroll;
-        if (drawBehind == NavigationOptions.BooleanOptions.NoValue)
+        if (drawBehind == Options.BooleanOptions.NoValue)
             drawBehind = defaultOptions.drawBehind;
         if (leftButtons == null)
             leftButtons = defaultOptions.leftButtons;

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

 package com.reactnativenavigation.presentation;
 
 
-import com.reactnativenavigation.parse.NavigationOptions;
+import com.reactnativenavigation.parse.Options;
 
 public interface NavigationOptionsListener {
-	void mergeNavigationOptions(NavigationOptions options);
+	void mergeNavigationOptions(Options options);
 }

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

 package com.reactnativenavigation.presentation;
 
 import com.reactnativenavigation.parse.Button;
-import com.reactnativenavigation.parse.NavigationOptions;
+import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.TopBarOptions;
 import com.reactnativenavigation.parse.TopTabOptions;
 import com.reactnativenavigation.parse.TopTabsOptions;
 
 import java.util.ArrayList;
 
-import static com.reactnativenavigation.parse.NavigationOptions.BooleanOptions.False;
-import static com.reactnativenavigation.parse.NavigationOptions.BooleanOptions.True;
+import static com.reactnativenavigation.parse.Options.BooleanOptions.False;
+import static com.reactnativenavigation.parse.Options.BooleanOptions.True;
 
 public class OptionsPresenter {
 
         this.topBar = reactComponent.getTopBar();
     }
 
-    public void applyOptions(NavigationOptions options) {
+    public void applyOptions(Options options) {
         applyTopBarOptions(options.topBarOptions);
         applyButtons(options.topBarOptions.leftButtons, options.topBarOptions.rightButtons);
         applyTopTabsOptions(options.topTabsOptions);
         topBar.setTitleFontSize(options.textFontSize);
 
         topBar.setTitleTypeface(options.textFontFamily);
-        if (options.hidden == NavigationOptions.BooleanOptions.True) {
+        if (options.hidden == Options.BooleanOptions.True) {
             topBar.hide(options.animateHide);
         }
-        if (options.hidden == NavigationOptions.BooleanOptions.False) {
+        if (options.hidden == Options.BooleanOptions.False) {
             topBar.show(options.animateHide);
         }
         if (options.drawBehind == True) {

lib/android/app/src/main/java/com/reactnativenavigation/react/NavigationModule.java

 import com.reactnativenavigation.parse.LayoutFactory;
 import com.reactnativenavigation.parse.LayoutNode;
 import com.reactnativenavigation.parse.LayoutNodeParser;
-import com.reactnativenavigation.parse.NavigationOptions;
+import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.OverlayOptions;
 import com.reactnativenavigation.utils.TypefaceLoader;
 import com.reactnativenavigation.utils.UiThread;
 
 	@ReactMethod
 	public void setDefaultOptions(final ReadableMap options) {
-        final NavigationOptions defaultOptions = NavigationOptions.parse(new TypefaceLoader(activity()), JSONParser.parse(options));
+        final Options defaultOptions = Options.parse(new TypefaceLoader(activity()), JSONParser.parse(options));
         handle(() -> navigator().setDefaultOptions(defaultOptions));
     }
 
 	@ReactMethod
 	public void setOptions(final String onComponentId, final ReadableMap options) {
-		final NavigationOptions navOptions = NavigationOptions.parse(new TypefaceLoader(activity()), JSONParser.parse(options));
+		final Options navOptions = Options.parse(new TypefaceLoader(activity()), JSONParser.parse(options));
 		handle(() -> navigator().setOptions(onComponentId, navOptions));
 	}
 

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

 import android.view.ViewGroup;
 import android.widget.RelativeLayout;
 
-import com.reactnativenavigation.parse.NavigationOptions;
+import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.NavigationOptionsListener;
 import com.reactnativenavigation.utils.CompatUtils;
 
 	}
 
 	@Override
-	public void mergeNavigationOptions(NavigationOptions options) {
+	public void mergeNavigationOptions(Options options) {
 		if (options.bottomTabsOptions != null) {
 			if (options.bottomTabsOptions.currentTabIndex != NO_INT_VALUE) {
 				selectTabAtIndex(options.bottomTabsOptions.currentTabIndex);

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

     private final String componentName;
 
     private final ReactViewCreator viewCreator;
-    private NavigationOptions options;
+    private Options options;
     private ReactComponent component;
 
     public ComponentViewController(final Activity activity,
                                    final String id,
                                    final String componentName,
                                    final ReactViewCreator viewCreator,
-                                   final NavigationOptions initialNavigationOptions) {
+                                   final Options initialNavigationOptions) {
         super(activity, id);
         this.componentName = componentName;
         this.viewCreator = viewCreator;
     }
 
     @Override
-    public void mergeNavigationOptions(NavigationOptions options) {
+    public void mergeNavigationOptions(Options options) {
         this.options.mergeWith(options);
-        component.applyOptions(options);
+        component.applyOptions(this.options);
     }
 
-    NavigationOptions getOptions() {
+    Options getOptions() {
         return options;
     }
 

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

 import android.widget.FrameLayout;
 
 import com.facebook.react.bridge.Promise;
-import com.reactnativenavigation.parse.NavigationOptions;
+import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.OverlayOptions;
 import com.reactnativenavigation.presentation.NavigationOptionsListener;
 import com.reactnativenavigation.presentation.OverlayPresenter;
 	private final ModalStack modalStack = new ModalStack();
 	private ViewController root;
 	private OverlayPresenter overlayPresenter;
-    private NavigationOptions defaultOptions = new NavigationOptions();
+    private Options defaultOptions = new Options();
 
     public Navigator(final Activity activity) {
 		super(activity, "navigator" + CompatUtils.generateViewId());
 		}
 	}
 
-    public void setDefaultOptions(NavigationOptions defaultOptions) {
+    public void setDefaultOptions(Options defaultOptions) {
         this.defaultOptions = defaultOptions;
     }
 
-    public NavigationOptions getDefaultOptions() {
+    public Options getDefaultOptions() {
         return defaultOptions;
     }
 
-	public void setOptions(final String componentId, NavigationOptions options) {
+	public void setOptions(final String componentId, Options options) {
 		ViewController target = findControllerById(componentId);
 		if (target instanceof NavigationOptionsListener) {
 			((NavigationOptionsListener) target).mergeNavigationOptions(options);

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

 import android.view.ViewManager;
 import android.view.ViewTreeObserver;
 
-import com.reactnativenavigation.parse.NavigationOptions;
+import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.utils.CompatUtils;
 import com.reactnativenavigation.utils.StringUtils;
 import com.reactnativenavigation.utils.Task;
         isShown = false;
     }
 
-    public void applyOptions(NavigationOptions options) {
+    public void applyOptions(Options options) {
 
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabController.java

 import android.app.Activity;
 import android.view.View;
 
-import com.reactnativenavigation.parse.NavigationOptions;
+import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.NavigationOptionsListener;
 import com.reactnativenavigation.viewcontrollers.ComponentViewController;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
     private final String componentName;
     private ComponentViewController.ReactViewCreator viewCreator;
-    private final NavigationOptions options;
+    private final Options options;
     private TopTab topTab;
     private boolean isSelectedTab;
 
-    public TopTabController(Activity activity, String id, String name, ComponentViewController.ReactViewCreator viewCreator, NavigationOptions initialOptions) {
+    public TopTabController(Activity activity, String id, String name, ComponentViewController.ReactViewCreator viewCreator, Options initialOptions) {
         super(activity, id);
         this.componentName = name;
         this.viewCreator = viewCreator;
     }
 
     @Override
-    public void applyOptions(NavigationOptions options) {
+    public void applyOptions(Options options) {
         getParentController().applyOptions(options);
     }
 
     }
 
     @Override
-    public void mergeNavigationOptions(NavigationOptions options) {
+    public void mergeNavigationOptions(Options options) {
         this.options.mergeWith(options);
         applyOptions(this.options);
     }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabsController.java

 import android.support.annotation.NonNull;
 import android.view.ViewGroup;
 
-import com.reactnativenavigation.parse.NavigationOptions;
+import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.presentation.NavigationOptionsListener;
 import com.reactnativenavigation.utils.Task;
 import com.reactnativenavigation.viewcontrollers.ParentController;
     private List<TopTabController> tabs;
     private TopTabsLayout topTabsLayout;
     private TopTabsLayoutCreator viewCreator;
-    private NavigationOptions options;
+    private Options options;
 
-    public TopTabsController(Activity activity, String id, List<TopTabController> tabs, TopTabsLayoutCreator viewCreator, NavigationOptions options) {
+    public TopTabsController(Activity activity, String id, List<TopTabController> tabs, TopTabsLayoutCreator viewCreator, Options options) {
         super(activity, id);
         this.viewCreator = viewCreator;
         this.options = options;
     }
 
     @Override
-    public void applyOptions(NavigationOptions options) {
+    public void applyOptions(Options options) {
         topTabsLayout.applyOptions(options);
     }
 
     @Override
-    public void mergeNavigationOptions(NavigationOptions options) {
+    public void mergeNavigationOptions(Options options) {
 
     }
 

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

 package com.reactnativenavigation.views;
 
-import android.support.annotation.RestrictTo;
 import android.view.View;
 
-import com.reactnativenavigation.parse.NavigationOptions;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
+import com.reactnativenavigation.parse.Options;
 
 public interface Component {
-    void applyOptions(NavigationOptions options);
+    void applyOptions(Options options);
 
     void sendOnNavigationButtonPressed(String id);
 

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

 
 	public ComponentLayout(Context context, IReactView reactView, EventDispatcher eventDispatcher) {
 		super(context);
-		this.topBar = new TopBar(context, this, eventDispatcher);
 		this.reactView = reactView;
+		this.topBar = new TopBar(context, this, eventDispatcher);
         optionsPresenter = new OptionsPresenter(this);
         initViews();
     }
 	}
 
     @Override
-    public void applyOptions(NavigationOptions options) {
+    public void applyOptions(Options options) {
         optionsPresenter.applyOptions(options);
     }
 

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

 import android.widget.TextView;
 
 import com.reactnativenavigation.parse.Button;
-import com.reactnativenavigation.parse.NavigationOptions;
+import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.utils.ImageUtils;
 import com.reactnativenavigation.utils.UiUtils;
 
 	void addToMenu(Context context, final Menu menu) {
 		MenuItem menuItem = menu.add(button.title);
 		menuItem.setShowAsAction(button.showAsAction);
-		menuItem.setEnabled(button.disabled != NavigationOptions.BooleanOptions.True);
+		menuItem.setEnabled(button.disabled != Options.BooleanOptions.True);
 		menuItem.setOnMenuItemClickListener(this);
 
 		if (hasIcon()) {
 	}
 
 	private void setIconColor() {
-		if (button.disabled == NavigationOptions.BooleanOptions.False || button.disabled == NavigationOptions.BooleanOptions.NoValue) {
+		if (button.disabled == Options.BooleanOptions.False || button.disabled == Options.BooleanOptions.NoValue) {
 			UiUtils.tintDrawable(icon, button.buttonColor);
 			return;
 		}
 
-		if (button.disableIconTint == NavigationOptions.BooleanOptions.True) {
+		if (button.disableIconTint == Options.BooleanOptions.True) {
 			UiUtils.tintDrawable(icon, button.buttonColor);
 		} else {
 			UiUtils.tintDrawable(icon, Color.LTGRAY);

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

         collapsingBehavior.disableCollapse();
     }
 
-    public void show(NavigationOptions.BooleanOptions animated) {
+    public void show(Options.BooleanOptions animated) {
         if (getVisibility() == View.VISIBLE) {
             return;
         }
-        if (animated == NavigationOptions.BooleanOptions.True) {
+        if (animated == Options.BooleanOptions.True) {
             animator.show();
         } else {
             setVisibility(View.VISIBLE);
         }
     }
 
-    public void hide(NavigationOptions.BooleanOptions animated) {
+    public void hide(Options.BooleanOptions animated) {
         if (getVisibility() == View.GONE) {
             return;
         }
-        if (animated == NavigationOptions.BooleanOptions.True) {
+        if (animated == Options.BooleanOptions.True) {
             animator.hide();
         } else {
             setVisibility(View.GONE);

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

     }
 
     @Override
-    public void applyOptions(NavigationOptions options) {
+    public void applyOptions(Options options) {
         optionsPresenter.applyOptions(options);
     }
 

lib/android/app/src/test/java/com/reactnativenavigation/BaseTest.java

 @RunWith(RobolectricTestRunner.class)
 @Config(sdk = 27, application = TestApplication.class)
 public abstract class BaseTest {
-	@Before
-	public void beforeEach() {
-		//
-	}
-
-	@After
-	public void afterEach() {
-		//
-	}
-
-	public Activity newActivity() {
-		return Robolectric.setupActivity(AppCompatActivity.class);
-	}
-
-	public void assertIsChildById(ViewGroup parent, View child) {
-		assertThat(parent).isNotNull();
-		assertThat(child).isNotNull();
-		assertThat(child.getId()).isNotZero().isPositive();
-		assertThat(parent.findViewById(child.getId())).isNotNull().isEqualTo(child);
-	}
-
-	public void assertNotChildOf(ViewGroup parent, View child) {
-		assertThat(parent).isNotNull();
-		assertThat(child).isNotNull();
-		assertThat(child.getId()).isNotZero().isPositive();
-		assertThat(parent.findViewById(child.getId())).isNull();
-	}
+    @Before
+    public void beforeEach() {
+        //
+    }
+
+    @After
+    public void afterEach() {
+        //
+    }
+
+    public Activity newActivity() {
+        return Robolectric.setupActivity(AppCompatActivity.class);
+    }
+
+    public void assertIsChildById(ViewGroup parent, View child) {
+        assertThat(parent).isNotNull();
+        assertThat(child).isNotNull();
+        assertThat(child.getId()).isNotZero().isPositive();
+        assertThat(parent.findViewById(child.getId())).isNotNull().isEqualTo(child);
+    }
+
+    public void assertNotChildOf(ViewGroup parent, View child) {
+        assertThat(parent).isNotNull();
+        assertThat(child).isNotNull();
+        assertThat(child.getId()).isNotZero().isPositive();
+        assertThat(parent.findViewById(child.getId())).isNull();
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/EnvironmentTest.java

 package com.reactnativenavigation;
 
-import android.support.design.widget.FloatingActionButton;
-import android.support.v7.app.AppCompatActivity;
+import android.support.design.widget.*;
+import android.support.v7.app.*;
 
-import com.facebook.react.common.ReactConstants;
+import com.facebook.react.common.*;
 
-import org.junit.Test;
-import org.robolectric.RuntimeEnvironment;
+import org.junit.*;
+import org.robolectric.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class EnvironmentTest extends BaseTest {
-	@Test
-	public void assertJ() {
-		assertThat(1 + 2).isEqualTo(3).isGreaterThan(2).isLessThan(4).isNotNegative().isPositive().isNotZero();
-	}
-
-	@Test
-	public void react() {
-		assertThat(ReactConstants.TAG).isNotEmpty();
-	}
-
-	@Test
-	public void supportV7AppCompat() {
-		assertThat(AppCompatActivity.class).isNotNull();
-	}
-
-	@Test
-	public void supportDesign() {
-		assertThat(FloatingActionButton.class).isNotNull();
-	}
-
-	@Test
-	public void androidR() {
-		assertThat(R.string.bottom_sheet_behavior).isNotZero();
-	}
-
-	@Test
-	public void ableToLoadApplication() throws Exception {
-		assertThat(RuntimeEnvironment.application).isNotNull();
-	}
+    @Test
+    public void assertJ() {
+        assertThat(1 + 2).isEqualTo(3).isGreaterThan(2).isLessThan(4).isNotNegative().isPositive().isNotZero();
+    }
+
+    @Test
+    public void react() {
+        assertThat(ReactConstants.TAG).isNotEmpty();
+    }
+
+    @Test
+    public void supportV7AppCompat() {
+        assertThat(AppCompatActivity.class).isNotNull();
+    }
+
+    @Test
+    public void supportDesign() {
+        assertThat(FloatingActionButton.class).isNotNull();
+    }
+
+    @Test
+    public void androidR() {
+        assertThat(R.string.bottom_sheet_behavior).isNotZero();
+    }
+
+    @Test
+    public void ableToLoadApplication() throws Exception {
+        assertThat(RuntimeEnvironment.application).isNotNull();
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/TestApplication.java

 import android.app.*;
 
 public class TestApplication extends Application {
-	@Override
-	public void onCreate() {
-		super.onCreate();
-		setTheme(R.style.Theme_AppCompat);
-	}
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        setTheme(R.style.Theme_AppCompat);
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/anim/ViewAnimationSetBuilderTest.java

 package com.reactnativenavigation.anim;
 
-import android.view.View;
-import android.view.animation.AlphaAnimation;
-import android.view.animation.Animation;
+import android.view.*;
+import android.view.animation.*;
 
-import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.*;
 
-import org.junit.Test;
-import org.robolectric.shadow.api.Shadow;
+import org.junit.*;
+import org.robolectric.shadow.api.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.assertj.core.api.Java6Assertions.*;
+import static org.mockito.Mockito.*;
 
 public class ViewAnimationSetBuilderTest extends BaseTest {
 
-	private Runnable mockListener;
+    private Runnable mockListener;
 
-	@Override
-	public void beforeEach() {
-		super.beforeEach();
-		mockListener = mock(Runnable.class);
-	}
+    @Override
+    public void beforeEach() {
+        super.beforeEach();
+        mockListener = mock(Runnable.class);
+    }
 
-	@Test
-	public void implementsViewAnimationListener() throws Exception {
-		assertThat(new ViewAnimationSetBuilder()).isInstanceOf(Animation.AnimationListener.class);
-	}
+    @Test
+    public void implementsViewAnimationListener() throws Exception {
+        assertThat(new ViewAnimationSetBuilder()).isInstanceOf(Animation.AnimationListener.class);
+    }
 
-	@Test
-	public void optionalCompletionListener() throws Exception {
-		new ViewAnimationSetBuilder()
-				.add(someView(), someAnimation())
-				.start();
-		verify(mockListener, times(0)).run();
-	}
+    @Test
+    public void optionalCompletionListener() throws Exception {
+        new ViewAnimationSetBuilder()
+                .add(someView(), someAnimation())
+                .start();
+        verify(mockListener, times(0)).run();
+    }
 
-	@Test
-	public void startsAllAnimations() throws Exception {
-		Animation anim1 = someAnimation();
-		Animation anim2 = someAnimation();
-		new ViewAnimationSetBuilder()
-				.withEndListener(mockListener)
-				.add(someView(), anim1)
-				.add(someView(), anim2)
-				.start();
-		assertThat(anim1.hasStarted()).isTrue();
-		assertThat(anim2.hasStarted()).isTrue();
-	}
+    @Test
+    public void startsAllAnimations() throws Exception {
+        Animation anim1 = someAnimation();
+        Animation anim2 = someAnimation();
+        new ViewAnimationSetBuilder()
+                .withEndListener(mockListener)
+                .add(someView(), anim1)
+                .add(someView(), anim2)
+                .start();
+        assertThat(anim1.hasStarted()).isTrue();
+        assertThat(anim2.hasStarted()).isTrue();
+    }
 
-	@Test
-	public void callsEndListenerOnlyAfterAllAnimationsFinish() throws Exception {
-		Animation anim1 = someAnimation();
-		Animation anim2 = someAnimation();
-		ViewAnimationSetBuilder uut = new ViewAnimationSetBuilder();
-		uut.withEndListener(mockListener)
-				.add(someView(), anim1)
-				.add(someView(), anim2)
-				.start();
-		verify(mockListener, times(1)).run();
-	}
+    @Test
+    public void callsEndListenerOnlyAfterAllAnimationsFinish() throws Exception {
+        Animation anim1 = someAnimation();
+        Animation anim2 = someAnimation();
+        ViewAnimationSetBuilder uut = new ViewAnimationSetBuilder();
+        uut.withEndListener(mockListener)
+           .add(someView(), anim1)
+           .add(someView(), anim2)
+           .start();
+        verify(mockListener, times(1)).run();
+    }
 
-	@Test
-	public void clearsAnimationFromViewsAfterFinished() throws Exception {
-		View v1 = someView();
-		View v2 = someView();
-		new ViewAnimationSetBuilder()
-				.withEndListener(mockListener)
-				.add(v1, someAnimation())
-				.start();
-		assertThat(v1.getAnimation()).isNull();
-		assertThat(v2.getAnimation()).isNull();
-	}
+    @Test
+    public void clearsAnimationFromViewsAfterFinished() throws Exception {
+        View v1 = someView();
+        View v2 = someView();
+        new ViewAnimationSetBuilder()
+                .withEndListener(mockListener)
+                .add(v1, someAnimation())
+                .start();
+        assertThat(v1.getAnimation()).isNull();
+        assertThat(v2.getAnimation()).isNull();
+    }
 
-	private Animation someAnimation() {
-		return Shadow.newInstanceOf(AlphaAnimation.class);
-	}
+    private Animation someAnimation() {
+        return Shadow.newInstanceOf(AlphaAnimation.class);
+    }
 
-	private View someView() {
-		return Shadow.newInstanceOf(View.class);
-	}
+    private View someView() {
+        return Shadow.newInstanceOf(View.class);
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/MockPromise.java

 package com.reactnativenavigation.mocks;
 
-import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.*;
 
-import javax.annotation.Nullable;
+import javax.annotation.*;
 
 
 public class MockPromise implements Promise {
 
-	@Override
-	public void resolve(@Nullable Object value) {
+    @Override
+    public void resolve(@Nullable Object value) {
 
-	}
+    }
 
-	@Override
-	public void reject(String code, String message) {
+    @Override
+    public void reject(String code, String message) {
 
-	}
+    }
 
-	@Override
-	public void reject(String code, Throwable e) {
+    @Override
+    public void reject(String code, Throwable e) {
 
-	}
+    }
 
-	@Override
-	public void reject(String code, String message, Throwable e) {
+    @Override
+    public void reject(String code, String message, Throwable e) {
 
-	}
+    }
 
-	@Override
-	public void reject(String message) {
+    @Override
+    public void reject(String message) {
 
-	}
+    }
 
-	@Override
-	public void reject(Throwable reason) {
+    @Override
+    public void reject(Throwable reason) {
 
-	}
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/SimpleComponentViewController.java

 package com.reactnativenavigation.mocks;
 
-import android.app.Activity;
+import android.app.*;
 
-import com.reactnativenavigation.parse.NavigationOptions;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
+import com.reactnativenavigation.parse.*;
+import com.reactnativenavigation.viewcontrollers.*;
 
 public class SimpleComponentViewController extends ComponentViewController {
-	public SimpleComponentViewController(final Activity activity, final String id) {
-		super(activity, id, "theComponentName", new TestComponentViewCreator(), new NavigationOptions());
-	}
+    public SimpleComponentViewController(final Activity activity, final String id) {
+        super(activity, id, "theComponentName", new TestComponentViewCreator(), new Options());
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/SimpleViewController.java

 package com.reactnativenavigation.mocks;
 
-import android.app.Activity;
-import android.view.View;
+import android.app.*;
+import android.view.*;
 
-import com.reactnativenavigation.viewcontrollers.ViewController;
+import com.reactnativenavigation.viewcontrollers.*;
 
 public class SimpleViewController extends ViewController {
 
-	public SimpleViewController(final Activity activity, String id) {
-		super(activity, id);
-	}
+    public SimpleViewController(final Activity activity, String id) {
+        super(activity, id);
+    }
 
-	@Override
-	protected View createView() {
-		return new View(getActivity());
-	}
+    @Override
+    protected View createView() {
+        return new View(getActivity());
+    }
 
-	@Override
-	public String toString() {
-		return "SimpleViewController " + getId();
-	}
+    @Override
+    public String toString() {
+        return "SimpleViewController " + getId();
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TestComponentLayout.java

 package com.reactnativenavigation.mocks;
 
-import android.content.Context;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.RelativeLayout;
+import android.content.*;
+import android.view.*;
+import android.widget.*;
 
-import com.reactnativenavigation.parse.NavigationOptions;
-import com.reactnativenavigation.presentation.OptionsPresenter;
-import com.reactnativenavigation.views.ReactComponent;
-import com.reactnativenavigation.views.TopBar;
+import com.reactnativenavigation.parse.*;
+import com.reactnativenavigation.presentation.*;
+import com.reactnativenavigation.views.*;
 
 public class TestComponentLayout extends RelativeLayout implements ReactComponent {
 
     private final OptionsPresenter optionsPresenter;
 
     public TestComponentLayout(final Context context) {
-		super(context);
+        super(context);
         topBar = new TopBar(context, this, null);
         contentView = new View(context);
         addView(topBar);
     }
 
     @Override
-    public void applyOptions(NavigationOptions options) {
+    public void applyOptions(Options options) {
         optionsPresenter.applyOptions(options);
     }
 

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TestComponentView.java

 package com.reactnativenavigation.mocks;
 
-import android.content.Context;
-import android.view.View;
+import android.content.*;
+import android.view.*;
 
-import com.reactnativenavigation.parse.NavigationOptions;
-import com.reactnativenavigation.views.ReactComponent;
-import com.reactnativenavigation.views.TopBar;
+import com.reactnativenavigation.parse.*;
+import com.reactnativenavigation.views.*;
 
 public class TestComponentView extends View implements ReactComponent {
 
     private TopBar topBar;
 
-	public TestComponentView(final Context context) {
-		super(context);
-		topBar = new TopBar(context, this, null);
+    public TestComponentView(final Context context) {
+        super(context);
+        topBar = new TopBar(context, this, null);
 
-	}
+    }
 
     @Override
     public boolean isReady() {
     public void destroy() {
     }
 
-	@Override
-	public void sendComponentStart() {
-	}
+    @Override
+    public void sendComponentStart() {
+    }
 
-	@Override
-	public void sendComponentStop() {
-	}
+    @Override
+    public void sendComponentStop() {
+    }
 
     @Override
-    public void applyOptions(NavigationOptions options) {
+    public void applyOptions(Options options) {
 
     }
 

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TestComponentViewCreator.java

 package com.reactnativenavigation.mocks;
 
-import android.app.Activity;
+import android.app.*;
 
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController.ReactViewCreator;
+import com.reactnativenavigation.viewcontrollers.*;
+import com.reactnativenavigation.viewcontrollers.ComponentViewController.*;
 
 public class TestComponentViewCreator implements ReactViewCreator {
-	@Override
-	public ComponentViewController.IReactView create(final Activity activity, final String componentId, final String componentName) {
-		return new TestComponentLayout(activity);
-	}
+    @Override
+    public ComponentViewController.IReactView create(final Activity activity, final String componentId, final String componentName) {
+        return new TestComponentLayout(activity);
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TestNavigationAnimator.java

 package com.reactnativenavigation.mocks;
 
-import android.view.View;
+import android.view.*;
 
-import com.reactnativenavigation.anim.NavigationAnimator;
+import com.reactnativenavigation.anim.*;
 
-import org.robolectric.RuntimeEnvironment;
+import org.robolectric.*;
 
 public class TestNavigationAnimator extends NavigationAnimator {
 
-	public TestNavigationAnimator() {
-		super(RuntimeEnvironment.application);
-	}
+    public TestNavigationAnimator() {
+        super(RuntimeEnvironment.application);
+    }
 
-	@Override
-	public void animatePush(final View enteringView, NavigationAnimationListener animationListener) {
-		if (animationListener != null) animationListener.onAnimationEnd();
-	}
+    @Override
+    public void animatePush(final View enteringView, NavigationAnimationListener animationListener) {
+        if (animationListener != null) animationListener.onAnimationEnd();
+    }
 
-	@Override
-	public void animatePop(final View enteringView, NavigationAnimationListener animationListener) {
-		if (animationListener != null) animationListener.onAnimationEnd();
-	}
+    @Override
+    public void animatePop(final View enteringView, NavigationAnimationListener animationListener) {
+        if (animationListener != null) animationListener.onAnimationEnd();
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TopTabLayoutMock.java

 package com.reactnativenavigation.mocks;
 
-import android.content.Context;
-import android.view.View;
+import android.content.*;
+import android.view.*;
 
-import com.reactnativenavigation.viewcontrollers.ComponentViewController;
+import com.reactnativenavigation.viewcontrollers.*;
 
 public class TopTabLayoutMock extends View implements ComponentViewController.IReactView {
 

lib/android/app/src/test/java/com/reactnativenavigation/mocks/TypefaceLoaderMock.java

 package com.reactnativenavigation.mocks;
 
-import com.reactnativenavigation.utils.TypefaceLoader;
+import com.reactnativenavigation.utils.*;
 
 public class TypefaceLoaderMock extends TypefaceLoader {
 

lib/android/app/src/test/java/com/reactnativenavigation/parse/JSONParserTest.java

 package com.reactnativenavigation.parse;
 
-import com.facebook.react.bridge.JavaOnlyArray;
-import com.facebook.react.bridge.JavaOnlyMap;
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.parse.JSONParser;
+import com.facebook.react.bridge.*;
+import com.reactnativenavigation.*;
 
-import org.json.JSONArray;
-import org.json.JSONObject;
-import org.junit.Test;
+import org.json.*;
+import org.junit.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class JSONParserTest extends BaseTest {
-	@Test
-	public void parsesMap() throws Exception {
-		JavaOnlyMap input = new JavaOnlyMap();
-		input.putString("keyString", "stringValue");
-		input.putInt("keyInt", 123);
-		input.putDouble("keyDouble", 123.456);
-		input.putBoolean("keyBoolean", true);
-		input.putArray("keyArray", new JavaOnlyArray());
-		input.putMap("keyMap", new JavaOnlyMap());
-		input.putNull("bla");
-
-		JSONObject result = JSONParser.parse(input);
-
-
-		assertThat(result.keys()).containsOnly(
-				"keyString",
-				"keyInt",
-				"keyDouble",
-				"keyBoolean",
-				"keyMap",
-				"keyArray");
-
-		assertThat(result.get("keyString")).isEqualTo("stringValue");
-		assertThat(result.get("keyInt")).isEqualTo(123);
-		assertThat(result.get("keyDouble")).isEqualTo(123.456);
-		assertThat(result.get("keyBoolean")).isEqualTo(true);
-		assertThat(result.getJSONObject("keyMap").keys()).isEmpty();
-		assertThat(result.getJSONArray("keyArray").length()).isZero();
-	}
-
-	@Test
-	public void parsesArrays() throws Exception {
-		JavaOnlyArray input = new JavaOnlyArray();
-		input.pushString("Hello");
-		input.pushInt(123);
-		input.pushDouble(123.456);
-		input.pushBoolean(true);
-		input.pushArray(new JavaOnlyArray());
-		input.pushMap(new JavaOnlyMap());
-		input.pushNull();
-
-		JSONArray result = JSONParser.parse(input);
-		assertThat(result.length()).isEqualTo(6);
-		assertThat(result.get(0)).isEqualTo("Hello");
-		assertThat(result.get(1)).isEqualTo(123);
-		assertThat(result.get(2)).isEqualTo(123.456);
-		assertThat(result.get(3)).isEqualTo(true);
-		assertThat(result.getJSONArray(4).length()).isZero();
-		assertThat(result.getJSONObject(5).keys()).isEmpty();
-	}
+    @Test
+    public void parsesMap() throws Exception {
+        JavaOnlyMap input = new JavaOnlyMap();
+        input.putString("keyString", "stringValue");
+        input.putInt("keyInt", 123);
+        input.putDouble("keyDouble", 123.456);
+        input.putBoolean("keyBoolean", true);
+        input.putArray("keyArray", new JavaOnlyArray());
+        input.putMap("keyMap", new JavaOnlyMap());
+        input.putNull("bla");
+
+        JSONObject result = JSONParser.parse(input);
+
+
+        assertThat(result.keys()).containsOnly(
+                "keyString",
+                "keyInt",
+                "keyDouble",
+                "keyBoolean",
+                "keyMap",
+                "keyArray");
+
+        assertThat(result.get("keyString")).isEqualTo("stringValue");
+        assertThat(result.get("keyInt")).isEqualTo(123);
+        assertThat(result.get("keyDouble")).isEqualTo(123.456);
+        assertThat(result.get("keyBoolean")).isEqualTo(true);
+        assertThat(result.getJSONObject("keyMap").keys()).isEmpty();
+        assertThat(result.getJSONArray("keyArray").length()).isZero();
+    }
+
+    @Test
+    public void parsesArrays() throws Exception {
+        JavaOnlyArray input = new JavaOnlyArray();
+        input.pushString("Hello");
+        input.pushInt(123);
+        input.pushDouble(123.456);
+        input.pushBoolean(true);
+        input.pushArray(new JavaOnlyArray());
+        input.pushMap(new JavaOnlyMap());
+        input.pushNull();
+
+        JSONArray result = JSONParser.parse(input);
+        assertThat(result.length()).isEqualTo(6);
+        assertThat(result.get(0)).isEqualTo("Hello");
+        assertThat(result.get(1)).isEqualTo(123);
+        assertThat(result.get(2)).isEqualTo(123.456);
+        assertThat(result.get(3)).isEqualTo(true);
+        assertThat(result.getJSONArray(4).length()).isZero();
+        assertThat(result.getJSONObject(5).keys()).isEmpty();
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/parse/LayoutNodeParserTest.java

 package com.reactnativenavigation.parse;
 
-import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.*;
 
-import org.json.JSONObject;
-import org.junit.Test;
+import org.json.*;
+import org.junit.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class LayoutNodeParserTest extends BaseTest {
-	@Test
-	public void dto() throws Exception {
-		LayoutNode node = new LayoutNode("the id", LayoutNode.Type.Component);
-		assertThat(node.id).isEqualTo("the id");
-		assertThat(node.type).isEqualTo(LayoutNode.Type.Component);
-		assertThat(node.data.keys()).isEmpty();
-		assertThat(node.children).isEmpty();
-	}
-
-	@Test
-	public void parseType() throws Exception {
-		assertThat(LayoutNode.Type.valueOf("Component")).isEqualTo(LayoutNode.Type.Component);
-	}
-
-	@Test(expected = RuntimeException.class)
-	public void invalidType() throws Exception {
-		LayoutNode.Type.valueOf("some type");
-	}
-
-	@Test
-	public void parseFromTree() throws Exception {
-		JSONObject tree = new JSONObject("{id: node1, " +
-				"type: Stack, " +
-				"data: {dataKey: dataValue}, " +
-				"children: [{id: childId1, type: Component}]}");
-
-		LayoutNode result = LayoutNodeParser.parse(tree);
-
-		assertThat(result).isNotNull();
-		assertThat(result.id).isEqualTo("node1");
-		assertThat(result.type).isEqualTo(LayoutNode.Type.Stack);
-		assertThat(result.data.length()).isEqualTo(1);
-		assertThat(result.data.getString("dataKey")).isEqualTo("dataValue");
-		assertThat(result.children).hasSize(1);
-		assertThat(result.children.get(0).id).isEqualTo("childId1");
-		assertThat(result.children.get(0).type).isEqualTo(LayoutNode.Type.Component);
-		assertThat(result.children.get(0).data.keys()).isEmpty();
-		assertThat(result.children.get(0).children).isEmpty();
-	}
+    @Test
+    public void dto() throws Exception {
+        LayoutNode node = new LayoutNode("the id", LayoutNode.Type.Component);
+        assertThat(node.id).isEqualTo("the id");
+        assertThat(node.type).isEqualTo(LayoutNode.Type.Component);
+        assertThat(node.data.keys()).isEmpty();
+        assertThat(node.children).isEmpty();
+    }
+
+    @Test
+    public void parseType() throws Exception {
+        assertThat(LayoutNode.Type.valueOf("Component")).isEqualTo(LayoutNode.Type.Component);
+    }
+
+    @Test(expected = RuntimeException.class)
+    public void invalidType() throws Exception {
+        LayoutNode.Type.valueOf("some type");
+    }
+
+    @Test
+    public void parseFromTree() throws Exception {
+        JSONObject tree = new JSONObject("{id: node1, " +
+                "type: Stack, " +
+                "data: {dataKey: dataValue}, " +
+                "children: [{id: childId1, type: Component}]}");
+
+        LayoutNode result = LayoutNodeParser.parse(tree);
+
+        assertThat(result).isNotNull();
+        assertThat(result.id).isEqualTo("node1");
+        assertThat(result.type).isEqualTo(LayoutNode.Type.Stack);
+        assertThat(result.data.length()).isEqualTo(1);
+        assertThat(result.data.getString("dataKey")).isEqualTo("dataValue");
+        assertThat(result.children).hasSize(1);
+        assertThat(result.children.get(0).id).isEqualTo("childId1");
+        assertThat(result.children.get(0).type).isEqualTo(LayoutNode.Type.Component);
+        assertThat(result.children.get(0).data.keys()).isEmpty();
+        assertThat(result.children.get(0).children).isEmpty();
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/parse/NavigationOptionsTest.java

 package com.reactnativenavigation.parse;
 
-import android.graphics.Typeface;
-import android.support.annotation.NonNull;
+import android.graphics.*;
+import android.support.annotation.*;
 
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.TypefaceLoaderMock;
-import com.reactnativenavigation.utils.TypefaceLoader;
+import com.reactnativenavigation.*;
+import com.reactnativenavigation.mocks.*;
+import com.reactnativenavigation.utils.*;
 
-import org.json.JSONException;
-import org.json.JSONObject;
-import org.junit.Test;
-import org.mockito.Mockito;
+import org.json.*;
+import org.junit.*;
+import org.mockito.*;
 
-import static com.reactnativenavigation.parse.NavigationOptions.BooleanOptions.True;
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static com.reactnativenavigation.parse.Options.BooleanOptions.*;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class NavigationOptionsTest extends BaseTest {
 
     private static final int TOP_BAR_FONT_SIZE = 18;
     private static final String TOP_BAR_FONT_FAMILY = "HelveticaNeue-CondensedBold";
     private static final Typeface TOP_BAR_TYPEFACE = Typeface.create("HelveticaNeue-CondensedBold", Typeface.BOLD);
-    private static final NavigationOptions.BooleanOptions TOP_BAR_HIDDEN = True;
-    private static final NavigationOptions.BooleanOptions TOP_BAR_DRAW_BEHIND = True;
-    private static final NavigationOptions.BooleanOptions TOP_BAR_HIDE_ON_SCROLL = True;
-    private static final NavigationOptions.BooleanOptions BOTTOM_TABS_ANIMATE_HIDE = True;
-    private static final NavigationOptions.BooleanOptions BOTTOM_TABS_HIDDEN = True;
+    private static final Options.BooleanOptions TOP_BAR_HIDDEN = True;
+    private static final Options.BooleanOptions TOP_BAR_DRAW_BEHIND = True;
+    private static final Options.BooleanOptions TOP_BAR_HIDE_ON_SCROLL = True;
+    private static final Options.BooleanOptions BOTTOM_TABS_ANIMATE_HIDE = True;
+    private static final Options.BooleanOptions BOTTOM_TABS_HIDDEN = True;
     private static final int BOTTOM_TABS_BADGE = 3;
     private static final String BOTTOM_TABS_CURRENT_TAB_ID = "ComponentId";
     private static final int BOTTOM_TABS_CURRENT_TAB_INDEX = 1;
 
     @Test
     public void parsesNullAsDefaultEmptyOptions() throws Exception {
-        assertThat(NavigationOptions.parse(mockLoader, null)).isNotNull();
+        assertThat(Options.parse(mockLoader, null)).isNotNull();
     }
 
     @Test
         JSONObject json = new JSONObject()
                 .put("topBar", createTopBar())
                 .put("bottomTabs", createTabBar());
-        NavigationOptions result = NavigationOptions.parse(mockLoader, json);
+        Options result = Options.parse(mockLoader, json);
         assertResult(result);
     }
 
-    private void assertResult(NavigationOptions result) {
+    private void assertResult(Options result) {
         assertThat(result.topBarOptions.title).isEqualTo(TITLE);
         assertThat(result.topBarOptions.backgroundColor).isEqualTo(TOP_BAR_BACKGROUND_COLOR);
         assertThat(result.topBarOptions.textColor).isEqualTo(TOP_BAR_TEXT_COLOR);
         JSONObject json = new JSONObject();
         json.put("topBar", createTopBar());
         json.put("bottomTabs", createTabBar());
-        NavigationOptions defaultOptions = NavigationOptions.parse(mockLoader, json);
-        NavigationOptions options = new NavigationOptions();
+        Options defaultOptions = Options.parse(mockLoader, json);
+        Options options = new Options();
 
         options.mergeWith(defaultOptions);
         assertResult(options);
         JSONObject defaultJson = new JSONObject()
                 .put("topBar", createOtherTopBar())
                 .put("bottomTabs", createOtherTabBar());
-        NavigationOptions defaultOptions = NavigationOptions.parse(mockLoader, defaultJson);
+        Options defaultOptions = Options.parse(mockLoader, defaultJson);
 
         JSONObject json = new JSONObject()
                 .put("topBar", createTopBar())
                 .put("bottomTabs", createTabBar());
-        NavigationOptions options = NavigationOptions.parse(mockLoader, json);
+        Options options = Options.parse(mockLoader, json);
         options.withDefaultOptions(defaultOptions);
         assertResult(options);
     }
 
     @Test
     public void defaultEmptyOptions() throws Exception {
-        NavigationOptions uut = new NavigationOptions();
+        Options uut = new Options();
         assertThat(uut.topBarOptions.title).isEmpty();
     }
 }

lib/android/app/src/test/java/com/reactnativenavigation/parse/OverlayOptionsTest.java

 
 import android.graphics.Color;
 
-import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.*;
 
-import org.json.JSONObject;
-import org.junit.Test;
+import org.json.*;
+import org.junit.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class OverlayOptionsTest extends BaseTest {
 
-	@Test
-	public void parsesNullAsDefaultEmptyOptions() throws Exception {
-		assertThat(OverlayOptions.parse(null)).isNotNull();
-	}
-
-	@Test
-	public void parsesJson() throws Exception {
-		JSONObject json = new JSONObject();
-		json.put("title", "the title");
-		json.put("text", "the text");
-		JSONObject nestedButton = new JSONObject();
-		nestedButton.put("text", "OK");
-		nestedButton.put("action", "action");
-		json.put("positiveButton", nestedButton);
-		json.put("textColor", Color.RED);
-		json.put("duration", "short");
-		json.put("backgroundColor", Color.RED);
-
-		OverlayOptions result = OverlayOptions.parse(json);
-		assertThat(result.getTitle()).isEqualTo("the title");
-		assertThat(result.getText()).isEqualTo("the text");
-		assertThat(result.getPositiveButton().getText()).isEqualTo("OK");
-		assertThat(result.getPositiveButton().getAction()).isEqualTo("action");
-		assertThat(result.getTextColor()).isEqualTo(Color.RED);
-		assertThat(result.getDuration()).isEqualTo("short");
-		assertThat(result.getBackgroundColor()).isEqualTo(Color.RED);
-	}
-
-	@Test
-	public void defaultEmptyOptions() throws Exception {
-		OverlayOptions uut = new OverlayOptions();
-		assertThat(uut.getTitle()).isEmpty();
-	}
+    @Test
+    public void parsesNullAsDefaultEmptyOptions() throws Exception {
+        assertThat(OverlayOptions.parse(null)).isNotNull();
+    }
+
+    @Test
+    public void parsesJson() throws Exception {
+        JSONObject json = new JSONObject();
+        json.put("title", "the title");
+        json.put("text", "the text");
+        JSONObject nestedButton = new JSONObject();
+        nestedButton.put("text", "OK");
+        nestedButton.put("action", "action");
+        json.put("positiveButton", nestedButton);
+        json.put("textColor", Color.RED);
+        json.put("duration", "short");
+        json.put("backgroundColor", Color.RED);
+
+        OverlayOptions result = OverlayOptions.parse(json);
+        assertThat(result.getTitle()).isEqualTo("the title");
+        assertThat(result.getText()).isEqualTo("the text");
+        assertThat(result.getPositiveButton().getText()).isEqualTo("OK");
+        assertThat(result.getPositiveButton().getAction()).isEqualTo("action");
+        assertThat(result.getTextColor()).isEqualTo(Color.RED);
+        assertThat(result.getDuration()).isEqualTo("short");
+        assertThat(result.getBackgroundColor()).isEqualTo(Color.RED);
+    }
+
+    @Test
+    public void defaultEmptyOptions() throws Exception {
+        OverlayOptions uut = new OverlayOptions();
+        assertThat(uut.getTitle()).isEmpty();
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/react/NavigationReactNativeHostTest.java

 package com.reactnativenavigation.react;
 
-import com.facebook.react.ReactPackage;
-import com.facebook.react.shell.MainReactPackage;
-import com.reactnativenavigation.BaseTest;
+import com.facebook.react.*;
+import com.facebook.react.shell.*;
+import com.reactnativenavigation.*;
 
-import org.junit.Test;
-import org.robolectric.RuntimeEnvironment;
+import org.junit.*;
+import org.robolectric.*;
 
-import java.util.Arrays;
-import java.util.Collections;
+import java.util.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.Mockito.mock;
+import static org.assertj.core.api.Java6Assertions.*;
+import static org.mockito.Mockito.*;
 
 public class NavigationReactNativeHostTest extends BaseTest {
 
-	@Test
-	public void getPackagesDefaults() throws Exception {
-		NavigationReactNativeHost uut = new NavigationReactNativeHost(RuntimeEnvironment.application, false, null);
-		assertThat(uut.getPackages()).hasSize(2).extracting("class").containsOnly(MainReactPackage.class, NavigationPackage.class);
-	}
-
-	@Test
-	public void getPackagesAddsAdditionalPackages() throws Exception {
-		ReactPackage myPackage = mock(ReactPackage.class);
-		NavigationReactNativeHost uut = new NavigationReactNativeHost(RuntimeEnvironment.application, false, Collections.singletonList(myPackage));
-		assertThat(uut.getPackages()).hasSize(3).containsOnlyOnce(myPackage);
-	}
-
-	@Test
-	public void getPackages_DoesNotAddDefaultTwice() throws Exception {
-		NavigationReactNativeHost uut = new NavigationReactNativeHost(
-				RuntimeEnvironment.application,
-				false,
-				Arrays.<ReactPackage>asList(
-						new MainReactPackage(),
-						new MainReactPackage(),
-						new MainReactPackage()));
-		assertThat(uut.getPackages()).hasSize(2).extracting("class").containsOnly(MainReactPackage.class, NavigationPackage.class);
-	}
+    @Test
+    public void getPackagesDefaults() throws Exception {
+        NavigationReactNativeHost uut = new NavigationReactNativeHost(RuntimeEnvironment.application, false, null);
+        assertThat(uut.getPackages()).hasSize(2).extracting("class").containsOnly(MainReactPackage.class, NavigationPackage.class);
+    }
+
+    @Test
+    public void getPackagesAddsAdditionalPackages() throws Exception {
+        ReactPackage myPackage = mock(ReactPackage.class);
+        NavigationReactNativeHost uut = new NavigationReactNativeHost(RuntimeEnvironment.application, false, Collections.singletonList(myPackage));
+        assertThat(uut.getPackages()).hasSize(3).containsOnlyOnce(myPackage);
+    }
+
+    @Test
+    public void getPackages_DoesNotAddDefaultTwice() throws Exception {
+        NavigationReactNativeHost uut = new NavigationReactNativeHost(
+                RuntimeEnvironment.application,
+                false,
+                Arrays.<ReactPackage>asList(
+                        new MainReactPackage(),
+                        new MainReactPackage(),
+                        new MainReactPackage()));
+        assertThat(uut.getPackages()).hasSize(2).extracting("class").containsOnly(MainReactPackage.class, NavigationPackage.class);
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/utils/CompatUtilsTest.java

 package com.reactnativenavigation.utils;
 
-import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class CompatUtilsTest extends BaseTest {
 
-	@Test
-	public void generateViewId() throws Exception {
-		assertThat(CompatUtils.generateViewId())
-				.isPositive()
-				.isNotEqualTo(CompatUtils.generateViewId());
-	}
+    @Test
+    public void generateViewId() throws Exception {
+        assertThat(CompatUtils.generateViewId())
+                .isPositive()
+                .isNotEqualTo(CompatUtils.generateViewId());
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/utils/ReflectionUtilsTest.java

 package com.reactnativenavigation.utils;
 
-import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class ReflectionUtilsTest extends BaseTest {
 
-	static class Foo {
-		private String bar = "old value";
-	}
+    static class Foo {
+        private String bar = "old value";
+    }
 
-	@Test
-	public void setField() throws Exception {
-		Foo target = new Foo();
-		ReflectionUtils.setField(target, "bar", "a new value");
-		assertThat(target.bar).isEqualTo("a new value");
-	}
+    @Test
+    public void setField() throws Exception {
+        Foo target = new Foo();
+        ReflectionUtils.setField(target, "bar", "a new value");
+        assertThat(target.bar).isEqualTo("a new value");
+    }
 
-	@Test
-	public void getDeclaredField() throws Exception {
-		assertThat(ReflectionUtils.getDeclaredField(new Foo(), "bar")).isEqualTo("old value");
-	}
+    @Test
+    public void getDeclaredField() throws Exception {
+        assertThat(ReflectionUtils.getDeclaredField(new Foo(), "bar")).isEqualTo("old value");
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/utils/StringUtilsTest.java

 package com.reactnativenavigation.utils;
 
-import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class StringUtilsTest extends BaseTest {
-	@Test
-	public void isEqual() throws Exception {
-		assertThat(StringUtils.isEqual(null, "a")).isFalse();
-		assertThat(StringUtils.isEqual("a", null)).isFalse();
-		assertThat(StringUtils.isEqual("a", "b")).isFalse();
-		assertThat(StringUtils.isEqual("a", "A")).isFalse();
-		assertThat(StringUtils.isEqual("a", "a")).isTrue();
-		assertThat(StringUtils.isEqual("", "")).isTrue();
-	}
+    @Test
+    public void isEqual() throws Exception {
+        assertThat(StringUtils.isEqual(null, "a")).isFalse();
+        assertThat(StringUtils.isEqual("a", null)).isFalse();
+        assertThat(StringUtils.isEqual("a", "b")).isFalse();
+        assertThat(StringUtils.isEqual("a", "A")).isFalse();
+        assertThat(StringUtils.isEqual("a", "a")).isTrue();
+        assertThat(StringUtils.isEqual("", "")).isTrue();
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/utils/TypefaceLoaderTest.java

 package com.reactnativenavigation.utils;
 
-import android.content.Context;
-import android.graphics.Typeface;
-import android.test.mock.MockContext;
+import android.content.*;
+import android.graphics.*;
+import android.test.mock.*;
 
-import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.*;
 
-import org.junit.Test;
-import org.mockito.Mockito;
+import org.junit.*;
+import org.mockito.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class TypefaceLoaderTest extends BaseTest {
 
-	@Test
-	public void loadTypefaceNoAssets() {
-		Context context = new MockContext();
-		TypefaceLoader mockedLoader = Mockito.spy(new TypefaceLoader(context));
-		Mockito.doReturn(null).when(mockedLoader).getTypefaceFromAssets("Helvetica-Bold");
+    @Test
+    public void loadTypefaceNoAssets() {
+        Context context = new MockContext();
+        TypefaceLoader mockedLoader = Mockito.spy(new TypefaceLoader(context));
+        Mockito.doReturn(null).when(mockedLoader).getTypefaceFromAssets("Helvetica-Bold");
 
-		Typeface typeface = mockedLoader.getTypeFace("Helvetica-Bold");
-		assertThat(typeface).isNotNull();
-		assertThat(typeface.getStyle()).isEqualTo(Typeface.BOLD);
-	}
+        Typeface typeface = mockedLoader.getTypeFace("Helvetica-Bold");
+        assertThat(typeface).isNotNull();
+        assertThat(typeface.getStyle()).isEqualTo(Typeface.BOLD);
+    }
 
-	@Test
-	public void loadTypefaceWithAssets() {
+    @Test
+    public void loadTypefaceWithAssets() {
         Context context = new MockContext();
         TypefaceLoader mockedLoader = Mockito.spy(new TypefaceLoader(context));
-		Mockito.doReturn(Typeface.create("Helvetica-Italic", Typeface.ITALIC)).when(mockedLoader).getTypefaceFromAssets("Helvetica-Italic");
+        Mockito.doReturn(Typeface.create("Helvetica-Italic", Typeface.ITALIC)).when(mockedLoader).getTypefaceFromAssets("Helvetica-Italic");
 
-		Typeface typeface = mockedLoader.getTypeFace("Helvetica-Italic");
-		assertThat(typeface).isNotNull();
-		assertThat(typeface.getStyle()).isEqualTo(Typeface.ITALIC);
-	}
+        Typeface typeface = mockedLoader.getTypeFace("Helvetica-Italic");
+        assertThat(typeface).isNotNull();
+        assertThat(typeface.getStyle()).isEqualTo(Typeface.ITALIC);
+    }
 
-	@Test
-	public void loadTypefaceWrongName() {
+    @Test
+    public void loadTypefaceWrongName() {
         Context context = new MockContext();
         TypefaceLoader mockedLoader = Mockito.spy(new TypefaceLoader(context));
-		Mockito.doReturn(null).when(mockedLoader).getTypefaceFromAssets("Some-name");
+        Mockito.doReturn(null).when(mockedLoader).getTypefaceFromAssets("Some-name");
 
-		Typeface typeface = mockedLoader.getTypeFace("Some-name");
-		assertThat(typeface).isNotNull();
-		assertThat(typeface.getStyle()).isEqualTo(Typeface.NORMAL);
-	}
+        Typeface typeface = mockedLoader.getTypeFace("Some-name");
+        assertThat(typeface).isNotNull();
+        assertThat(typeface.getStyle()).isEqualTo(Typeface.NORMAL);
+    }
 
-	@Test
-	public void loadTypefaceNull() {
+    @Test
+    public void loadTypefaceNull() {
         Context context = new MockContext();
         TypefaceLoader mockedLoader = Mockito.spy(new TypefaceLoader(context));
-		Mockito.doReturn(null).when(mockedLoader).getTypefaceFromAssets(null);
+        Mockito.doReturn(null).when(mockedLoader).getTypefaceFromAssets(null);
 
-		Typeface typeface = mockedLoader.getTypeFace(null);
-		assertThat(typeface).isNull();
-	}
+        Typeface typeface = mockedLoader.getTypeFace(null);
+        assertThat(typeface).isNull();
+    }
 }
 
 

lib/android/app/src/test/java/com/reactnativenavigation/utils/UiThreadTest.java

 package com.reactnativenavigation.utils;
 
-import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.*;
 
-import org.junit.Test;
-import org.robolectric.shadows.ShadowLooper;
+import org.junit.*;
+import org.robolectric.shadows.*;
 
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.*;
 
 public class UiThreadTest extends BaseTest {
-	@Test
-	public void postOnUiThread() throws Exception {
-		Runnable task = mock(Runnable.class);
-		ShadowLooper.pauseMainLooper();
-		UiThread.post(task);
-		verifyZeroInteractions(task);
-		ShadowLooper.runUiThreadTasks();
-		verify(task, times(1)).run();
-	}
+    @Test
+    public void postOnUiThread() throws Exception {
+        Runnable task = mock(Runnable.class);
+        ShadowLooper.pauseMainLooper();
+        UiThread.post(task);
+        verifyZeroInteractions(task);
+        ShadowLooper.runUiThreadTasks();
+        verify(task, times(1)).run();
+    }
 
-	@Test
-	public void postDelayedOnUiThread() throws Exception {
-		Runnable task = mock(Runnable.class);
-		UiThread.postDelayed(task, 1000);
-		verifyZeroInteractions(task);
-		ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
-		verify(task, times(1)).run();
-	}
+    @Test
+    public void postDelayedOnUiThread() throws Exception {
+        Runnable task = mock(Runnable.class);
+        UiThread.postDelayed(task, 1000);
+        verifyZeroInteractions(task);
+        ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
+        verify(task, times(1)).run();
+    }
 }

lib/android/app/src/test/java/com/reactnativenavigation/utils/UiUtilsTest.java

 import static org.mockito.Mockito.*;
 
 public class UiUtilsTest extends BaseTest {
-	@Test
-	public void runOnPreDrawOnce() throws Exception {
-		View view = new View(newActivity());
-		Runnable task = mock(Runnable.class);
-		verifyZeroInteractions(task);
+    @Test
+    public void runOnPreDrawOnce() throws Exception {
+        View view = new View(newActivity());
+        Runnable task = mock(Runnable.class);
+        verifyZeroInteractions(task);
 
-		UiUtils.runOnPreDrawOnce(view, task);
-		view.getViewTreeObserver().dispatchOnPreDraw();
-		verify(task, times(1)).run();
-	}
+        UiUtils.runOnPreDrawOnce(view, task);
+        view.getViewTreeObserver().dispatchOnPreDraw();
+        verify(task, times(1)).run();
+    }
 }

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Activity;
-import android.support.annotation.NonNull;
-import android.support.design.widget.BottomNavigationView;
-import android.view.View;
-import android.widget.RelativeLayout;
+import android.app.*;
+import android.support.annotation.*;
+import android.support.design.widget.*;
+import android.view.*;
+import android.widget.*;
 
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.SimpleViewController;
+import com.reactnativenavigation.*;
+import com.reactnativenavigation.mocks.*;
 
-import org.assertj.core.api.iterable.Extractor;
-import org.junit.Test;
+import org.assertj.core.api.iterable.*;
+import org.junit.*;
 
-import java.util.Arrays;
-import java.util.List;
+import java.util.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
+import static org.assertj.core.api.Java6Assertions.*;
+import static org.mockito.Mockito.*;
 
 public class BottomTabsControllerTest extends BaseTest {
 
-	private Activity activity;
-	private BottomTabsController uut;
-	private ViewController child1;
-	private ViewController child2;
-	private ViewController child3;
-	private ViewController child4;
-	private ViewController child5;
-
-	@Override
-	public void beforeEach() {
-		super.beforeEach();
-		activity = newActivity();
-		uut = new BottomTabsController(activity, "uut");
-		child1 = new SimpleViewController(activity, "child1");
-		child2 = new SimpleViewController(activity, "child2");
-		child3 = new SimpleViewController(activity, "child3");
-		child4 = new SimpleViewController(activity, "child4");
-		child5 = new SimpleViewController(activity, "child5");
-	}
-
-	@Test
-	public void containsRelativeLayoutView() throws Exception {
-		assertThat(uut.getView()).isInstanceOf(RelativeLayout.class);
-		assertThat(uut.getView().getChildAt(0)).isInstanceOf(BottomNavigationView.class);
-	}
-
-	@Test(expected = RuntimeException.class)
-	public void setTabs_ThrowWhenMoreThan5() throws Exception {
-		List<ViewController> tabs = createTabs();
-		tabs.add(new SimpleViewController(activity, "6"));
-		uut.setTabs(tabs);
-	}
-
-	@Test
-	public void setTabs_AddAllViewsAsGoneExceptFirst() throws Exception {
-		List<ViewController> tabs = createTabs();
-		uut.setTabs(tabs);
-		assertThat(uut.getView().getChildCount()).isEqualTo(6);
-		assertThat(uut.getChildControllers()).extracting(new Extractor<ViewController, Integer>() {
-			@Override
-			public Integer extract(final ViewController input) {
-				return input.getView().getVisibility();
-			}
-		}).containsExactly(View.VISIBLE, View.GONE, View.GONE, View.GONE, View.GONE);
-	}
-
-	@Test
-	public void selectTabAtIndex() throws Exception {
-		uut.setTabs(createTabs());
-		assertThat(uut.getSelectedIndex()).isZero();
-
-		uut.selectTabAtIndex(3);
-
-		assertThat(uut.getSelectedIndex()).isEqualTo(3);
-		assertThat(uut.getChildControllers()).extracting(new Extractor<ViewController, Integer>() {
-			@Override
-			public Integer extract(final ViewController input) {
-				return input.getView().getVisibility();
-			}
-		}).containsExactly(View.GONE, View.GONE, View.GONE, View.VISIBLE, View.GONE);
-	}
-
-	@Test
-	public void findControllerById_ReturnsSelfOrChildren() throws Exception {
-		assertThat(uut.findControllerById("123")).isNull();
-		assertThat(uut.findControllerById(uut.getId())).isEqualTo(uut);
-		StackController inner = new StackController(activity, "inner");
-		inner.push(child1);
-		assertThat(uut.findControllerById(child1.getId())).isNull();
-		uut.setTabs(Arrays.<ViewController>asList(inner));
-		assertThat(uut.findControllerById(child1.getId())).isEqualTo(child1);
-	}
-
-	@Test
-	public void handleBack_DelegatesToSelectedChild() throws Exception {
-		assertThat(uut.handleBack()).isFalse();
-
-		List<ViewController> tabs = createTabs();
-		ViewController spy = spy(tabs.get(2));
-		tabs.set(2, spy);
-		when(spy.handleBack()).thenReturn(true);
-		uut.setTabs(tabs);
-
-		assertThat(uut.handleBack()).isFalse();
-		uut.selectTabAtIndex(2);
-		assertThat(uut.handleBack()).isTrue();
-
-		verify(spy, times(1)).handleBack();
-	}
-
-	@NonNull
-	private List<ViewController> createTabs() {
-		return Arrays.asList(child1, child2, child3, child4, child5);
-	}
+    private Activity activity;
+    private BottomTabsController uut;
+    private ViewController child1;
+    private ViewController child2;
+    private ViewController child3;
+    private ViewController child4;
+    private ViewController child5;
+
+    @Override
+    public void beforeEach() {
+        super.beforeEach();
+        activity = newActivity();
+        uut = new BottomTabsController(activity, "uut");
+        child1 = new SimpleViewController(activity, "child1");
+        child2 = new SimpleViewController(activity, "child2");
+        child3 = new SimpleViewController(activity, "child3");
+        child4 = new SimpleViewController(activity, "child4");
+        child5 = new SimpleViewController(activity, "child5");
+    }
+
+    @Test
+    public void containsRelativeLayoutView() throws Exception {
+        assertThat(uut.getView()).isInstanceOf(RelativeLayout.class);
+        assertThat(uut.getView().getChildAt(0)).isInstanceOf(BottomNavigationView.class);
+    }
+
+    @Test(expected = RuntimeException.class)
+    public void setTabs_ThrowWhenMoreThan5() throws Exception {
+        List<ViewController> tabs = createTabs();
+        tabs.add(new SimpleViewController(activity, "6"));
+        uut.setTabs(tabs);
+    }
+
+    @Test
+    public void setTabs_AddAllViewsAsGoneExceptFirst() throws Exception {
+        List<ViewController> tabs = createTabs();
+        uut.setTabs(tabs);
+        assertThat(uut.getView().getChildCount()).isEqualTo(6);
+        assertThat(uut.getChildControllers()).extracting(new Extractor<ViewController, Integer>() {
+            @Override
+            public Integer extract(final ViewController input) {
+                return input.getView().getVisibility();
+            }
+        }).containsExactly(View.VISIBLE, View.GONE, View.GONE, View.GONE, View.GONE);
+    }
+
+    @Test
+    public void selectTabAtIndex() throws Exception {
+        uut.setTabs(createTabs());
+        assertThat(uut.getSelectedIndex()).isZero();
+
+        uut.selectTabAtIndex(3);
+
+        assertThat(uut.getSelectedIndex()).isEqualTo(3);
+        assertThat(uut.getChildControllers()).extracting(new Extractor<ViewController, Integer>() {
+            @Override
+            public Integer extract(final ViewController input) {
+                return input.getView().getVisibility();
+            }
+        }).containsExactly(View.GONE, View.GONE, View.GONE, View.VISIBLE, View.GONE);
+    }
+
+    @Test
+    public void findControllerById_ReturnsSelfOrChildren() throws Exception {
+        assertThat(uut.findControllerById("123")).isNull();
+        assertThat(uut.findControllerById(uut.getId())).isEqualTo(uut);
+        StackController inner = new StackController(activity, "inner");
+        inner.push(child1);
+        assertThat(uut.findControllerById(child1.getId())).isNull();
+        uut.setTabs(Arrays.<ViewController>asList(inner));
+        assertThat(uut.findControllerById(child1.getId())).isEqualTo(child1);
+    }
+
+    @Test
+    public void handleBack_DelegatesToSelectedChild() throws Exception {
+        assertThat(uut.handleBack()).isFalse();
+
+        List<ViewController> tabs = createTabs();
+        ViewController spy = spy(tabs.get(2));
+        tabs.set(2, spy);
+        when(spy.handleBack()).thenReturn(true);
+        uut.setTabs(tabs);
+
+        assertThat(uut.handleBack()).isFalse();
+        uut.selectTabAtIndex(2);
+        assertThat(uut.handleBack()).isTrue();
+
+        verify(spy, times(1)).handleBack();
+    }
+
+    @NonNull
+    private List<ViewController> createTabs() {
+        return Arrays.asList(child1, child2, child3, child4, child5);
+    }
 }

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Activity;
+import android.app.*;
 
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.TestComponentLayout;
-import com.reactnativenavigation.parse.NavigationOptions;
+import com.reactnativenavigation.*;
+import com.reactnativenavigation.mocks.*;
+import com.reactnativenavigation.parse.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
+import static org.assertj.core.api.Java6Assertions.*;
+import static org.mockito.Mockito.*;
 
 public class ComponentViewControllerTest extends BaseTest {
-	private ComponentViewController uut;
-	private ComponentViewController.IReactView view;
+    private ComponentViewController uut;
+    private ComponentViewController.IReactView view;
 
-	@Override
-	public void beforeEach() {
-		super.beforeEach();
-		Activity activity = newActivity();
-		view = spy(new TestComponentLayout(activity));
-		uut = new ComponentViewController(activity, "componentId1", "componentName", new ComponentViewController.ReactViewCreator() {
-			@Override
-			public ComponentViewController.IReactView create(final Activity activity1, final String componentId, final String componentName) {
-				return view;
-			}
-		}, new NavigationOptions());
-	}
+    @Override
+    public void beforeEach() {
+        super.beforeEach();
+        Activity activity = newActivity();
+        view = spy(new TestComponentLayout(activity));
+        uut = new ComponentViewController(activity, "componentId1", "componentName", new ComponentViewController.ReactViewCreator() {
+            @Override
+            public ComponentViewController.IReactView create(final Activity activity1, final String componentId, final String componentName) {
+                return view;
+            }
+        }, new Options());
+    }
 
-	@Test
-	public void createsViewFromComponentViewCreator() throws Exception {
-		assertThat(uut.getView()).isSameAs(view);
-	}
+    @Test
+    public void createsViewFromComponentViewCreator() throws Exception {
+        assertThat(uut.getView()).isSameAs(view);
+    }
 
-	@Test
-	public void componentViewDestroyedOnDestroy() throws Exception {
-		uut.ensureViewIsCreated();
-		verify(view, times(0)).destroy();
-		uut.destroy();
-		verify(view, times(1)).destroy();
-	}
+    @Test
+    public void componentViewDestroyedOnDestroy() throws Exception {
+        uut.ensureViewIsCreated();
+        verify(view, times(0)).destroy();
+        uut.destroy();
+        verify(view, times(1)).destroy();
+    }
 
-	@Test
-	public void lifecycleMethodsSentToComponentView() throws Exception {
-		uut.ensureViewIsCreated();
-		verify(view, times(0)).sendComponentStart();
-		verify(view, times(0)).sendComponentStop();
-		uut.onViewAppeared();
-		verify(view, times(1)).sendComponentStart();
-		verify(view, times(0)).sendComponentStop();
-		uut.onViewDisappear();
-		verify(view, times(1)).sendComponentStart();
-		verify(view, times(1)).sendComponentStop();
-	}
+    @Test
+    public void lifecycleMethodsSentToComponentView() throws Exception {
+        uut.ensureViewIsCreated();
+        verify(view, times(0)).sendComponentStart();
+        verify(view, times(0)).sendComponentStop();
+        uut.onViewAppeared();
+        verify(view, times(1)).sendComponentStart();
+        verify(view, times(0)).sendComponentStop();
+        uut.onViewDisappear();
+        verify(view, times(1)).sendComponentStart();
+        verify(view, times(1)).sendComponentStop();
+    }
 
-	@Test
-	public void isViewShownOnlyIfComponentViewIsReady() throws Exception {
-		assertThat(uut.isViewShown()).isFalse();
-		uut.ensureViewIsCreated();
-		when(view.asView().isShown()).thenReturn(true);
-		assertThat(uut.isViewShown()).isFalse();
-		when(view.isReady()).thenReturn(true);
-		assertThat(uut.isViewShown()).isTrue();
-	}
+    @Test
+    public void isViewShownOnlyIfComponentViewIsReady() throws Exception {
+        assertThat(uut.isViewShown()).isFalse();
+        uut.ensureViewIsCreated();
+        when(view.asView().isShown()).thenReturn(true);
+        assertThat(uut.isViewShown()).isFalse();
+        when(view.isReady()).thenReturn(true);
+        assertThat(uut.isViewShown()).isTrue();
+    }
 }

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

 package com.reactnativenavigation.viewcontrollers;
 
-import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class IdStackTest extends BaseTest {
 
-	private IdStack<Integer> uut;
-
-	@Override
-	public void beforeEach() {
-		super.beforeEach();
-		uut = new IdStack<>();
-	}
-
-	@Test
-	public void isEmpty() throws Exception {
-		assertThat(uut.isEmpty()).isTrue();
-		uut.push("123", 123);
-		assertThat(uut.isEmpty()).isFalse();
-	}
-
-	@Test
-	public void size() throws Exception {
-		assertThat(uut.size()).isEqualTo(0);
-		uut.push("123", 123);
-		assertThat(uut.size()).isEqualTo(1);
-	}
-
-	@Test
-	public void peek() throws Exception {
-		assertThat(uut.peek()).isNull();
-		uut.push("123", 123);
-		uut.push("456", 456);
-		assertThat(uut.peek()).isEqualTo(456);
-	}
-
-	@Test
-	public void pop() throws Exception {
-		assertThat(uut.pop()).isNull();
-		uut.push("123", 123);
-		uut.push("456", 456);
-		assertThat(uut.pop()).isEqualTo(456);
-	}
-
-	@Test
-	public void peekId() throws Exception {
-		assertThat(uut.peekId()).isNull();
-		uut.push("123", 123);
-		assertThat(uut.peekId()).isEqualTo("123");
-	}
-
-	@Test
-	public void clear() throws Exception {
-		uut.push("123", 123);
-		uut.push("456", 456);
-		uut.clear();
-		assertThat(uut.isEmpty()).isTrue();
-	}
-
-	@Test
-	public void getById() throws Exception {
-		assertThat(uut.get("123")).isNull();
-		uut.push("123", 123);
-		uut.push("456", 456);
-		assertThat(uut.get("123")).isEqualTo(123);
-	}
-
-	@Test
-	public void containsId() throws Exception {
-		assertThat(uut.containsId("123")).isFalse();
-		uut.push("123", 123);
-		assertThat(uut.containsId("123")).isTrue();
-	}
-
-	@Test
-	public void remove() throws Exception {
-		assertThat(uut.remove("123")).isNull();
-
-		uut.push("123", 123);
-		uut.push("456", 456);
-
-		assertThat(uut.remove("123")).isEqualTo(123);
-	}
-
-	@Test
-	public void iterableIds() throws Exception {
-		assertThat(uut).isInstanceOf(Iterable.class);
-		assertThat(uut).isEmpty();
-		uut.push("123", 123);
-		uut.push("456", 456);
-		assertThat(uut).containsExactly("456", "123");
-	}
-
-	@Test
-	public void isTop() throws Exception {
-		assertThat(uut.isTop("123")).isFalse();
-		uut.push("123", 123);
-		assertThat(uut.isTop("123")).isTrue();
-		uut.push("456", 456);
-		assertThat(uut.isTop("123")).isFalse();
-	}
-
-	@Test
-	public void values() throws Exception {
-		assertThat(uut.values()).isNotNull().isEmpty();
-		uut.push("123", 123);
-		uut.push("456", 456);
-		assertThat(uut.values()).isNotNull().containsExactlyInAnyOrder(123, 456);
-	}
+    private IdStack<Integer> uut;
+
+    @Override
+    public void beforeEach() {
+        super.beforeEach();
+        uut = new IdStack<>();
+    }
+
+    @Test
+    public void isEmpty() throws Exception {
+        assertThat(uut.isEmpty()).isTrue();
+        uut.push("123", 123);
+        assertThat(uut.isEmpty()).isFalse();
+    }
+
+    @Test
+    public void size() throws Exception {
+        assertThat(uut.size()).isEqualTo(0);
+        uut.push("123", 123);
+        assertThat(uut.size()).isEqualTo(1);
+    }
+
+    @Test
+    public void peek() throws Exception {
+        assertThat(uut.peek()).isNull();
+        uut.push("123", 123);
+        uut.push("456", 456);
+        assertThat(uut.peek()).isEqualTo(456);
+    }
+
+    @Test
+    public void pop() throws Exception {
+        assertThat(uut.pop()).isNull();
+        uut.push("123", 123);
+        uut.push("456", 456);
+        assertThat(uut.pop()).isEqualTo(456);
+    }
+
+    @Test
+    public void peekId() throws Exception {
+        assertThat(uut.peekId()).isNull();
+        uut.push("123", 123);
+        assertThat(uut.peekId()).isEqualTo("123");
+    }
+
+    @Test
+    public void clear() throws Exception {
+        uut.push("123", 123);
+        uut.push("456", 456);
+        uut.clear();
+        assertThat(uut.isEmpty()).isTrue();
+    }
+
+    @Test
+    public void getById() throws Exception {
+        assertThat(uut.get("123")).isNull();
+        uut.push("123", 123);
+        uut.push("456", 456);
+        assertThat(uut.get("123")).isEqualTo(123);
+    }
+
+    @Test
+    public void containsId() throws Exception {
+        assertThat(uut.containsId("123")).isFalse();
+        uut.push("123", 123);
+        assertThat(uut.containsId("123")).isTrue();
+    }
+
+    @Test
+    public void remove() throws Exception {
+        assertThat(uut.remove("123")).isNull();
+
+        uut.push("123", 123);
+        uut.push("456", 456);
+
+        assertThat(uut.remove("123")).isEqualTo(123);
+    }
+
+    @Test
+    public void iterableIds() throws Exception {
+        assertThat(uut).isInstanceOf(Iterable.class);
+        assertThat(uut).isEmpty();
+        uut.push("123", 123);
+        uut.push("456", 456);
+        assertThat(uut).containsExactly("456", "123");
+    }
+
+    @Test
+    public void isTop() throws Exception {
+        assertThat(uut.isTop("123")).isFalse();
+        uut.push("123", 123);
+        assertThat(uut.isTop("123")).isTrue();
+        uut.push("456", 456);
+        assertThat(uut.isTop("123")).isFalse();
+    }
+
+    @Test
+    public void values() throws Exception {
+        assertThat(uut.values()).isNotNull().isEmpty();
+        uut.push("123", 123);
+        uut.push("456", 456);
+        assertThat(uut.values()).isNotNull().containsExactlyInAnyOrder(123, 456);
+    }
 }

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Activity;
-import android.support.annotation.NonNull;
+import android.app.*;
+import android.support.annotation.*;
 
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.MockPromise;
-import com.reactnativenavigation.mocks.SimpleComponentViewController;
-import com.reactnativenavigation.mocks.SimpleViewController;
-import com.reactnativenavigation.mocks.TestNavigationAnimator;
-import com.reactnativenavigation.parse.NavigationOptions;
-import com.reactnativenavigation.utils.CompatUtils;
+import com.reactnativenavigation.*;
+import com.reactnativenavigation.mocks.*;
+import com.reactnativenavigation.parse.*;
+import com.reactnativenavigation.utils.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import java.util.Arrays;
+import java.util.*;
 
 import javax.annotation.Nullable;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
+import static org.assertj.core.api.Java6Assertions.*;
+import static org.mockito.Mockito.*;
 
 public class NavigatorTest extends BaseTest {
-	private Activity activity;
-	private Navigator uut;
-	private SimpleViewController child1;
-	private ViewController child2;
-	private ViewController child3;
-	private ViewController child4;
-	private ViewController child5;
-
-
-	@Override
-	public void beforeEach() {
-		super.beforeEach();
-		activity = newActivity();
-		uut = new Navigator(activity);
-		child1 = new SimpleViewController(activity, "child1");
-		child2 = new SimpleViewController(activity, "child2");
-		child3 = new SimpleViewController(activity, "child3");
-		child4 = new SimpleViewController(activity, "child4");
-		child5 = new SimpleViewController(activity, "child5");
-	}
-
-	@Test
-	public void setRoot_AddsChildControllerView() throws Exception {
-		assertThat(uut.getView().getChildCount()).isZero();
-		uut.setRoot(child1);
-		assertIsChildById(uut.getView(), child1.getView());
-	}
-
-	@Test
-	public void setRoot_ReplacesExistingChildControllerViews() throws Exception {
-		uut.setRoot(child1);
-		uut.setRoot(child2);
-		assertIsChildById(uut.getView(), child2.getView());
-	}
-
-	@Test
-	public void hasUniqueId() throws Exception {
-		assertThat(uut.getId()).startsWith("navigator");
-		assertThat(new Navigator(activity).getId()).isNotEqualTo(uut.getId());
-	}
-
-	@Test
-	public void push() throws Exception {
-		StackController stackController = newStack();
-		stackController.push(child1);
-		uut.setRoot(stackController);
-
-		assertIsChildById(uut.getView(), stackController.getView());
-		assertIsChildById(stackController.getView(), child1.getView());
-
-		uut.push(child1.getId(), child2);
-
-		assertIsChildById(uut.getView(), stackController.getView());
-		assertIsChildById(stackController.getView(), child2.getView());
-	}
-
-	@Test
-	public void push_InvalidPushWithoutAStack_DoesNothing() throws Exception {
-		uut.setRoot(child1);
-		uut.push(child1.getId(), child2);
-		assertIsChildById(uut.getView(), child1.getView());
-	}
-
-	@Test
-	public void push_OnCorrectStackByFindingChildId() throws Exception {
-		BottomTabsController bottomTabsController = newTabs();
-		StackController stack1 = newStack();
-		StackController stack2 = newStack();
-		stack1.push(child1);
-		stack2.push(child2);
-		bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-		uut.setRoot(bottomTabsController);
-
-		SimpleViewController newChild = new SimpleViewController(activity, "new child");
-		uut.push(child2.getId(), newChild);
-
-		assertThat(stack1.getChildControllers()).doesNotContain(newChild);
-		assertThat(stack2.getChildControllers()).contains(newChild);
-	}
-
-	@Test
-	public void pop_InvalidDoesNothing() throws Exception {
-		uut.pop("123");
-		uut.setRoot(child1);
-		uut.pop(child1.getId());
-		assertThat(uut.getChildControllers()).hasSize(1);
-	}
-
-	@Test
-	public void pop_FromCorrectStackByFindingChildId() throws Exception {
-		BottomTabsController bottomTabsController = newTabs();
-		StackController stack1 = newStack();
-		StackController stack2 = newStack();
-		stack1.push(child1);
-		stack2.push(child2);
-		stack2.push(child3);
-		stack2.push(child4);
-		bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-		uut.setRoot(bottomTabsController);
-
-		uut.pop("child4");
-
-		assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
-	}
-
-	@Test
-	public void popSpecific() throws Exception {
-		BottomTabsController bottomTabsController = newTabs();
-		StackController stack1 = newStack();
-		StackController stack2 = newStack();
-		stack1.push(child1);
-		stack2.push(child2);
-		stack2.push(child3);
-		stack2.push(child4);
-		bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-		uut.setRoot(bottomTabsController);
-
-		uut.popSpecific(child2.getId());
-
-		assertThat(stack2.getChildControllers()).containsOnly(child4, child3);
-	}
-
-	@Test
-	public void popTo_FromCorrectStackUpToChild() throws Exception {
-		BottomTabsController bottomTabsController = newTabs();
-		StackController stack1 = newStack();
-		StackController stack2 = newStack();
-		stack1.push(child1);
-		stack2.push(child2);
-		stack2.push(child3);
-		stack2.push(child4);
-		stack2.push(child5);
-		bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-		uut.setRoot(bottomTabsController);
-
-		uut.popTo(child2.getId());
-
-		assertThat(stack2.getChildControllers()).containsOnly(child2);
-	}
-
-	@Test
-	public void popToRoot() throws Exception {
-		BottomTabsController bottomTabsController = newTabs();
-		StackController stack1 = newStack();
-		StackController stack2 = newStack();
-		stack1.push(child1);
-		stack2.push(child2);
-		stack2.push(child3);
-		stack2.push(child4);
-		stack2.push(child5);
-
-		bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-		uut.setRoot(bottomTabsController);
-
-		uut.popToRoot(child3.getId());
-
-		assertThat(stack2.getChildControllers()).containsOnly(child2);
-	}
-
-	@Test
-	public void handleBack_DelegatesToRoot() throws Exception {
-		assertThat(uut.handleBack()).isFalse();
-		ViewController spy = spy(child1);
-		uut.setRoot(spy);
-		when(spy.handleBack()).thenReturn(true);
-		assertThat(uut.handleBack()).isTrue();
-		verify(spy, times(1)).handleBack();
-	}
-
-	@Test
-	public void setOptions_CallsApplyNavigationOptions() {
-		ComponentViewController componentVc = new SimpleComponentViewController(activity, "theId");
-		uut.setRoot(componentVc);
-		assertThat(componentVc.getOptions().topBarOptions.title).isEmpty();
-
-		NavigationOptions options = new NavigationOptions();
-		options.topBarOptions.title = "new title";
-
-		uut.setOptions("theId", options);
-		assertThat(componentVc.getOptions().topBarOptions.title).isEqualTo("new title");
-	}
-
-	@Test
-	public void setOptions_AffectsOnlyComponentViewControllers() {
-		uut.setOptions("some unknown child id", new NavigationOptions());
-	}
-
-	@NonNull
-	private BottomTabsController newTabs() {
-		return new BottomTabsController(activity, "tabsController");
-	}
-
-	@NonNull
-	private StackController newStack() {
-		return new StackController(activity, "stack" + CompatUtils.generateViewId(), new TestNavigationAnimator());
-	}
-
-	@Test
-	public void push_Promise() throws Exception {
-		final StackController stackController = newStack();
-		stackController.push(child1);
-		uut.setRoot(stackController);
-
-		assertIsChildById(uut.getView(), stackController.getView());
-		assertIsChildById(stackController.getView(), child1.getView());
-
-		uut.push(child1.getId(), child2, new MockPromise() {
-			@Override
-			public void resolve(@Nullable Object value) {
-				assertIsChildById(uut.getView(), stackController.getView());
-				assertIsChildById(stackController.getView(), child2.getView());
-			}
-		});
-	}
-
-	@Test
-	public void push_InvalidPushWithoutAStack_DoesNothing_Promise() throws Exception {
-		uut.setRoot(child1);
-		uut.push(child1.getId(), child2, new MockPromise() {
-			@Override
-			public void reject(String code, Throwable e) {
-				assertIsChildById(uut.getView(), child1.getView());
-			}
-		});
-
-	}
-
-	@Test
-	public void pop_InvalidDoesNothing_Promise() throws Exception {
-		uut.pop("123");
-		uut.setRoot(child1);
-		uut.pop(child1.getId(), new MockPromise() {
-			@Override
-			public void reject(Throwable reason) {
-				assertThat(uut.getChildControllers()).hasSize(1);
-			}
-		});
-	}
-
-	@Test
-	public void pop_FromCorrectStackByFindingChildId_Promise() throws Exception {
-		BottomTabsController bottomTabsController = newTabs();
-		StackController stack1 = newStack();
-		final StackController stack2 = newStack();
-		stack1.push(child1);
-		stack2.push(child2);
-		stack2.push(child3);
-		stack2.push(child4);
-		bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
-		uut.setRoot(bottomTabsController);
-
-		uut.pop("child4", new MockPromise() {
-			@Override
-			public void resolve(@Nullable Object value) {
-				assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
-			}
-		});
-	}
-
-	@Test
+    private Activity activity;
+    private Navigator uut;
+    private SimpleViewController child1;
+    private ViewController child2;
+    private ViewController child3;
+    private ViewController child4;
+    private ViewController child5;
+
+
+    @Override
+    public void beforeEach() {
+        super.beforeEach();
+        activity = newActivity();
+        uut = new Navigator(activity);
+        child1 = new SimpleViewController(activity, "child1");
+        child2 = new SimpleViewController(activity, "child2");
+        child3 = new SimpleViewController(activity, "child3");
+        child4 = new SimpleViewController(activity, "child4");
+        child5 = new SimpleViewController(activity, "child5");
+    }
+
+    @Test
+    public void setRoot_AddsChildControllerView() throws Exception {
+        assertThat(uut.getView().getChildCount()).isZero();
+        uut.setRoot(child1);
+        assertIsChildById(uut.getView(), child1.getView());
+    }
+
+    @Test
+    public void setRoot_ReplacesExistingChildControllerViews() throws Exception {
+        uut.setRoot(child1);
+        uut.setRoot(child2);
+        assertIsChildById(uut.getView(), child2.getView());
+    }
+
+    @Test
+    public void hasUniqueId() throws Exception {
+        assertThat(uut.getId()).startsWith("navigator");
+        assertThat(new Navigator(activity).getId()).isNotEqualTo(uut.getId());
+    }
+
+    @Test
+    public void push() throws Exception {
+        StackController stackController = newStack();
+        stackController.push(child1);
+        uut.setRoot(stackController);
+
+        assertIsChildById(uut.getView(), stackController.getView());
+        assertIsChildById(stackController.getView(), child1.getView());
+
+        uut.push(child1.getId(), child2);
+
+        assertIsChildById(uut.getView(), stackController.getView());
+        assertIsChildById(stackController.getView(), child2.getView());
+    }
+
+    @Test
+    public void push_InvalidPushWithoutAStack_DoesNothing() throws Exception {
+        uut.setRoot(child1);
+        uut.push(child1.getId(), child2);
+        assertIsChildById(uut.getView(), child1.getView());
+    }
+
+    @Test
+    public void push_OnCorrectStackByFindingChildId() throws Exception {
+        BottomTabsController bottomTabsController = newTabs();
+        StackController stack1 = newStack();
+        StackController stack2 = newStack();
+        stack1.push(child1);
+        stack2.push(child2);
+        bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
+        uut.setRoot(bottomTabsController);
+
+        SimpleViewController newChild = new SimpleViewController(activity, "new child");
+        uut.push(child2.getId(), newChild);
+
+        assertThat(stack1.getChildControllers()).doesNotContain(newChild);
+        assertThat(stack2.getChildControllers()).contains(newChild);
+    }
+
+    @Test
+    public void pop_InvalidDoesNothing() throws Exception {
+        uut.pop("123");
+        uut.setRoot(child1);
+        uut.pop(child1.getId());
+        assertThat(uut.getChildControllers()).hasSize(1);
+    }
+
+    @Test
+    public void pop_FromCorrectStackByFindingChildId() throws Exception {
+        BottomTabsController bottomTabsController = newTabs();
+        StackController stack1 = newStack();
+        StackController stack2 = newStack();
+        stack1.push(child1);
+        stack2.push(child2);
+        stack2.push(child3);
+        stack2.push(child4);
+        bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
+        uut.setRoot(bottomTabsController);
+
+        uut.pop("child4");
+
+        assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
+    }
+
+    @Test
+    public void popSpecific() throws Exception {
+        BottomTabsController bottomTabsController = newTabs();
+        StackController stack1 = newStack();
+        StackController stack2 = newStack();
+        stack1.push(child1);
+        stack2.push(child2);
+        stack2.push(child3);
+        stack2.push(child4);
+        bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
+        uut.setRoot(bottomTabsController);
+
+        uut.popSpecific(child2.getId());
+
+        assertThat(stack2.getChildControllers()).containsOnly(child4, child3);
+    }
+
+    @Test
+    public void popTo_FromCorrectStackUpToChild() throws Exception {
+        BottomTabsController bottomTabsController = newTabs();
+        StackController stack1 = newStack();
+        StackController stack2 = newStack();
+        stack1.push(child1);
+        stack2.push(child2);
+        stack2.push(child3);
+        stack2.push(child4);
+        stack2.push(child5);
+        bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
+        uut.setRoot(bottomTabsController);
+
+        uut.popTo(child2.getId());
+
+        assertThat(stack2.getChildControllers()).containsOnly(child2);
+    }
+
+    @Test
+    public void popToRoot() throws Exception {
+        BottomTabsController bottomTabsController = newTabs();
+        StackController stack1 = newStack();
+        StackController stack2 = newStack();
+        stack1.push(child1);
+        stack2.push(child2);
+        stack2.push(child3);
+        stack2.push(child4);
+        stack2.push(child5);
+
+        bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
+        uut.setRoot(bottomTabsController);
+
+        uut.popToRoot(child3.getId());
+
+        assertThat(stack2.getChildControllers()).containsOnly(child2);
+    }
+
+    @Test
+    public void handleBack_DelegatesToRoot() throws Exception {
+        assertThat(uut.handleBack()).isFalse();
+        ViewController spy = spy(child1);
+        uut.setRoot(spy);
+        when(spy.handleBack()).thenReturn(true);
+        assertThat(uut.handleBack()).isTrue();
+        verify(spy, times(1)).handleBack();
+    }
+
+    @Test
+    public void setOptions_CallsApplyNavigationOptions() {
+        ComponentViewController componentVc = new SimpleComponentViewController(activity, "theId");
+        uut.setRoot(componentVc);
+        assertThat(componentVc.getOptions().topBarOptions.title).isEmpty();
+
+        Options options = new Options();
+        options.topBarOptions.title = "new title";
+
+        uut.setOptions("theId", options);
+        assertThat(componentVc.getOptions().topBarOptions.title).isEqualTo("new title");
+    }
+
+    @Test
+    public void setOptions_AffectsOnlyComponentViewControllers() {
+        uut.setOptions("some unknown child id", new Options());
+    }
+
+    @NonNull
+    private BottomTabsController newTabs() {
+        return new BottomTabsController(activity, "tabsController");
+    }
+
+    @NonNull
+    private StackController newStack() {
+        return new StackController(activity, "stack" + CompatUtils.generateViewId(), new TestNavigationAnimator());
+    }
+
+    @Test
+    public void push_Promise() throws Exception {
+        final StackController stackController = newStack();
+        stackController.push(child1);
+        uut.setRoot(stackController);
+
+        assertIsChildById(uut.getView(), stackController.getView());
+        assertIsChildById(stackController.getView(), child1.getView());
+
+        uut.push(child1.getId(), child2, new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                assertIsChildById(uut.getView(), stackController.getView());
+                assertIsChildById(stackController.getView(), child2.getView());
+            }
+        });
+    }
+
+    @Test
+    public void push_InvalidPushWithoutAStack_DoesNothing_Promise() throws Exception {
+        uut.setRoot(child1);
+        uut.push(child1.getId(), child2, new MockPromise() {
+            @Override
+            public void reject(String code, Throwable e) {
+                assertIsChildById(uut.getView(), child1.getView());
+            }
+        });
+
+    }
+
+    @Test
+    public void pop_InvalidDoesNothing_Promise() throws Exception {
+        uut.pop("123");
+        uut.setRoot(child1);
+        uut.pop(child1.getId(), new MockPromise() {
+            @Override
+            public void reject(Throwable reason) {
+                assertThat(uut.getChildControllers()).hasSize(1);
+            }
+        });
+    }
+
+    @Test
+    public void pop_FromCorrectStackByFindingChildId_Promise() throws Exception {
+        BottomTabsController bottomTabsController = newTabs();
+        StackController stack1 = newStack();
+        final StackController stack2 = newStack();
+        stack1.push(child1);
+        stack2.push(child2);
+        stack2.push(child3);
+        stack2.push(child4);
+        bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
+        uut.setRoot(bottomTabsController);
+
+        uut.pop("child4", new MockPromise() {
+            @Override
+            public void resolve(@Nullable Object value) {
+                assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
+            }
+        });
+    }
+
+    @Test
     public void pushIntoModal() throws Exception {
         StackController stackController = newStack();
         stackController.push(child1);

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Activity;
+import android.app.*;
 import android.graphics.Color;
-import android.graphics.drawable.ColorDrawable;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.RelativeLayout;
+import android.graphics.drawable.*;
+import android.view.*;
+import android.widget.*;
 
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.TestComponentLayout;
-import com.reactnativenavigation.parse.NavigationOptions;
+import com.reactnativenavigation.*;
+import com.reactnativenavigation.mocks.*;
+import com.reactnativenavigation.parse.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import static android.widget.RelativeLayout.BELOW;
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.Mockito.spy;
+import static android.widget.RelativeLayout.*;
+import static org.assertj.core.api.Java6Assertions.*;
+import static org.mockito.Mockito.*;
 
 public class OptionsApplyingTest extends BaseTest {
-	private Activity activity;
-	private ComponentViewController uut;
-	private ComponentViewController.IReactView view;
-	private NavigationOptions initialNavigationOptions;
-
-	@Override
-	public void beforeEach() {
-		super.beforeEach();
-		activity = newActivity();
-		initialNavigationOptions = new NavigationOptions();
-		view = spy(new TestComponentLayout(activity));
-		uut = new ComponentViewController(activity,
+    private Activity activity;
+    private ComponentViewController uut;
+    private ComponentViewController.IReactView view;
+    private Options initialNavigationOptions;
+
+    @Override
+    public void beforeEach() {
+        super.beforeEach();
+        activity = newActivity();
+        initialNavigationOptions = new Options();
+        view = spy(new TestComponentLayout(activity));
+        uut = new ComponentViewController(activity,
                 "componentId1",
                 "componentName",
                 (activity1, componentId, componentName) -> view,
         assertThat(uut.getParentStackController()).isNull();
     }
 
-	@Test
-	public void initialOptionsAppliedOnAppear() throws Exception {
-		assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
-		initialNavigationOptions.topBarOptions.title = "the title";
-		StackController stackController = new StackController(activity, "stackId");
-		stackController.push(uut);
-		assertThat(uut.getTopBar().getTitle()).isEmpty();
+    @Test
+    public void initialOptionsAppliedOnAppear() throws Exception {
+        assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
+        initialNavigationOptions.topBarOptions.title = "the title";
+        StackController stackController = new StackController(activity, "stackId");
+        stackController.push(uut);
+        assertThat(uut.getTopBar().getTitle()).isEmpty();
 
         uut.onViewAppeared();
         assertThat(uut.getTopBar().getTitle()).isEqualTo("the title");
     }
 
-	@Test
-	public void mergeNavigationOptionsUpdatesCurrentOptions() throws Exception {
-		assertThat(uut.getOptions().topBarOptions.title).isEmpty();
-		NavigationOptions options = new NavigationOptions();
-		options.topBarOptions.title = "new title";
-		uut.mergeNavigationOptions(options);
-		assertThat(uut.getOptions().topBarOptions.title).isEqualTo("new title");
-		assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
-	}
+    @Test
+    public void mergeNavigationOptionsUpdatesCurrentOptions() throws Exception {
+        assertThat(uut.getOptions().topBarOptions.title).isEmpty();
+        Options options = new Options();
+        options.topBarOptions.title = "new title";
+        uut.mergeNavigationOptions(options);
+        assertThat(uut.getOptions().topBarOptions.title).isEqualTo("new title");
+        assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
+    }
 
     @Test
     public void reappliesOptionsOnMerge() throws Exception {
         uut.onViewAppeared();
         assertThat(uut.getTopBar().getTitle()).isEmpty();
 
-        NavigationOptions opts = new NavigationOptions();
+        Options opts = new Options();
         opts.topBarOptions.title = "the new title";
         uut.mergeNavigationOptions(opts);
 
         //TODO: FIX TEST
         assertThat(((ColorDrawable) uut.getTopBar().getTitleBar().getBackground()).getColor()).isNotEqualTo(Color.RED);
 
-        NavigationOptions opts = new NavigationOptions();
+        Options opts = new Options();
         opts.topBarOptions.backgroundColor = Color.RED;
         uut.mergeNavigationOptions(opts);
 
         assertThat(((ColorDrawable) uut.getTopBar().getTitleBar().getBackground()).getColor()).isEqualTo(Color.RED);
     }
 
-	@Test
-	public void appliesTopBarTextColor() throws Exception {
-		assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
-		initialNavigationOptions.topBarOptions.title = "the title";
-		uut.onViewAppeared();
-		assertThat(uut.getTopBar().getTitleTextView().getCurrentTextColor()).isNotEqualTo(Color.RED);
+    @Test
+    public void appliesTopBarTextColor() throws Exception {
+        assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
+        initialNavigationOptions.topBarOptions.title = "the title";
+        uut.onViewAppeared();
+        assertThat(uut.getTopBar().getTitleTextView().getCurrentTextColor()).isNotEqualTo(Color.RED);
 
-        NavigationOptions opts = new NavigationOptions();
+        Options opts = new Options();
         opts.topBarOptions.title = "the title";
         opts.topBarOptions.textColor = Color.RED;
         uut.mergeNavigationOptions(opts);
         assertThat(uut.getTopBar().getTitleTextView().getCurrentTextColor()).isEqualTo(Color.RED);
     }
 
-	@Test
-	public void appliesTopBarTextSize() throws Exception {
-		assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
-		initialNavigationOptions.topBarOptions.title = "the title";
-		uut.onViewAppeared();
-		assertThat(uut.getTopBar().getTitleTextView().getTextSize()).isNotEqualTo(18);
+    @Test
+    public void appliesTopBarTextSize() throws Exception {
+        assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
+        initialNavigationOptions.topBarOptions.title = "the title";
+        uut.onViewAppeared();
+        assertThat(uut.getTopBar().getTitleTextView().getTextSize()).isNotEqualTo(18);
 
-        NavigationOptions opts = new NavigationOptions();
+        Options opts = new Options();
         opts.topBarOptions.title = "the title";
         opts.topBarOptions.textFontSize = 18;
         uut.mergeNavigationOptions(opts);
         assertThat(uut.getTopBar().getTitleTextView().getTextSize()).isEqualTo(18);
     }
 
-	@Test
-	public void appliesTopBarHidden() throws Exception {
-		assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
-		initialNavigationOptions.topBarOptions.title = "the title";
-		uut.onViewAppeared();
-		assertThat(uut.getTopBar().getVisibility()).isNotEqualTo(View.GONE);
+    @Test
+    public void appliesTopBarHidden() throws Exception {
+        assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
+        initialNavigationOptions.topBarOptions.title = "the title";
+        uut.onViewAppeared();
+        assertThat(uut.getTopBar().getVisibility()).isNotEqualTo(View.GONE);
 
-        NavigationOptions opts = new NavigationOptions();
-        opts.topBarOptions.hidden = NavigationOptions.BooleanOptions.True;
+        Options opts = new Options();
+        opts.topBarOptions.hidden = Options.BooleanOptions.True;
         uut.mergeNavigationOptions(opts);
 
         assertThat(uut.getTopBar().getVisibility()).isEqualTo(View.GONE);
     public void appliesDrawUnder() throws Exception {
         assertThat(uut.getOptions()).isSameAs(initialNavigationOptions);
         initialNavigationOptions.topBarOptions.title = "the title";
-        initialNavigationOptions.topBarOptions.drawBehind = NavigationOptions.BooleanOptions.False;
+        initialNavigationOptions.topBarOptions.drawBehind = Options.BooleanOptions.False;
         uut.onViewAppeared();
         RelativeLayout.LayoutParams uutLayoutParams = (RelativeLayout.LayoutParams) ((ViewGroup) uut.getComponent().asView()).getChildAt(1).getLayoutParams();
         assertThat(uutLayoutParams.getRule(BELOW)).isNotEqualTo(0);
 
-        NavigationOptions opts = new NavigationOptions();
-        opts.topBarOptions.drawBehind = NavigationOptions.BooleanOptions.True;
+        Options opts = new Options();
+        opts.topBarOptions.drawBehind = Options.BooleanOptions.True;
         uut.mergeNavigationOptions(opts);
 
         uutLayoutParams = (RelativeLayout.LayoutParams) ((ViewGroup) uut.getComponent().asView()).getChildAt(1).getLayoutParams();

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Activity;
-import android.support.annotation.NonNull;
-import android.view.ViewGroup;
-import android.widget.FrameLayout;
+import android.app.*;
+import android.support.annotation.*;
+import android.view.*;
+import android.widget.*;
 
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.SimpleViewController;
-import com.reactnativenavigation.mocks.TestNavigationAnimator;
+import com.reactnativenavigation.*;
+import com.reactnativenavigation.mocks.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
+import java.util.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.assertj.core.api.Java6Assertions.*;
+import static org.mockito.Mockito.*;
 
 public class ParentControllerTest extends BaseTest {
 
-	private Activity activity;
-	private List<ViewController> children;
-	private ParentController uut;
-
-	@Override
-	public void beforeEach() {
-		super.beforeEach();
-		activity = newActivity();
-		children = new ArrayList<>();
-		uut = new ParentController(activity, "uut") {
-
-			@NonNull
-			@Override
-			protected ViewGroup createView() {
-				return new FrameLayout(activity);
-			}
-
-			@NonNull
-			@Override
-			public Collection<ViewController> getChildControllers() {
-				return children;
-			}
-		};
-	}
-
-	@Test
-	public void holdsViewGroup() throws Exception {
-		assertThat(uut.getView()).isInstanceOf(ViewGroup.class);
-	}
-
-	@Test
-	public void mustHaveChildControllers() throws Exception {
-		assertThat(uut.getChildControllers()).isNotNull();
-	}
-
-	@Test
-	public void findControllerById_ChildById() throws Exception {
-		SimpleViewController child1 = new SimpleViewController(activity, "child1");
-		SimpleViewController child2 = new SimpleViewController(activity, "child2");
-		children.add(child1);
-		children.add(child2);
-
-		assertThat(uut.findControllerById("uut")).isEqualTo(uut);
-		assertThat(uut.findControllerById("child1")).isEqualTo(child1);
-	}
-
-	@Test
-	public void findControllerById_Recursive() throws Exception {
-		StackController stackController = new StackController(activity, "stack", new TestNavigationAnimator());
-		SimpleViewController child1 = new SimpleViewController(activity, "child1");
-		SimpleViewController child2 = new SimpleViewController(activity, "child2");
-		stackController.push(child1);
-		stackController.push(child2);
-		children.add(stackController);
-
-		assertThat(uut.findControllerById("child2")).isEqualTo(child2);
-	}
-
-	@Test
-	public void destroy_DestroysChildren() throws Exception {
-		ViewController child1 = spy(new SimpleViewController(activity, "child1"));
-		children.add(child1);
-
-		verify(child1, times(0)).destroy();
-		uut.destroy();
-		verify(child1, times(1)).destroy();
-	}
+    private Activity activity;
+    private List<ViewController> children;
+    private ParentController uut;
+
+    @Override
+    public void beforeEach() {
+        super.beforeEach();
+        activity = newActivity();
+        children = new ArrayList<>();
+        uut = new ParentController(activity, "uut") {
+
+            @NonNull
+            @Override
+            protected ViewGroup createView() {
+                return new FrameLayout(activity);
+            }
+
+            @NonNull
+            @Override
+            public Collection<ViewController> getChildControllers() {
+                return children;
+            }
+        };
+    }
+
+    @Test
+    public void holdsViewGroup() throws Exception {
+        assertThat(uut.getView()).isInstanceOf(ViewGroup.class);
+    }
+
+    @Test
+    public void mustHaveChildControllers() throws Exception {
+        assertThat(uut.getChildControllers()).isNotNull();
+    }
+
+    @Test
+    public void findControllerById_ChildById() throws Exception {
+        SimpleViewController child1 = new SimpleViewController(activity, "child1");
+        SimpleViewController child2 = new SimpleViewController(activity, "child2");
+        children.add(child1);
+        children.add(child2);
+
+        assertThat(uut.findControllerById("uut")).isEqualTo(uut);
+        assertThat(uut.findControllerById("child1")).isEqualTo(child1);
+    }
+
+    @Test
+    public void findControllerById_Recursive() throws Exception {
+        StackController stackController = new StackController(activity, "stack", new TestNavigationAnimator());
+        SimpleViewController child1 = new SimpleViewController(activity, "child1");
+        SimpleViewController child2 = new SimpleViewController(activity, "child2");
+        stackController.push(child1);
+        stackController.push(child2);
+        children.add(stackController);
+
+        assertThat(uut.findControllerById("child2")).isEqualTo(child2);
+    }
+
+    @Test
+    public void destroy_DestroysChildren() throws Exception {
+        ViewController child1 = spy(new SimpleViewController(activity, "child1"));
+        children.add(child1);
+
+        verify(child1, times(0)).destroy();
+        uut.destroy();
+        verify(child1, times(1)).destroy();
+    }
 }

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Activity;
+import android.app.*;
 
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.SimpleViewController;
-import com.reactnativenavigation.mocks.TestNavigationAnimator;
+import com.reactnativenavigation.*;
+import com.reactnativenavigation.mocks.*;
 
-import org.assertj.core.api.iterable.Extractor;
-import org.junit.Test;
+import org.assertj.core.api.iterable.*;
+import org.junit.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.assertj.core.api.Java6Assertions.*;
+import static org.mockito.Mockito.*;
 
 public class StackControllerTest extends BaseTest {
 
-	private Activity activity;
-	private StackController uut;
-	private ViewController child1;
-	private ViewController child2;
-	private ViewController child3;
-
-	@Override
-	public void beforeEach() {
-		super.beforeEach();
-		activity = newActivity();
-		uut = new StackController(activity, "uut", new TestNavigationAnimator());
-		child1 = new SimpleViewController(activity, "child1");
-		child2 = new SimpleViewController(activity, "child2");
-		child3 = new SimpleViewController(activity, "child3");
-	}
-
-	@Test
-	public void isAViewController() throws Exception {
-		assertThat(uut).isInstanceOf(ViewController.class);
-	}
-
-	@Test
-	public void holdsAStackOfViewControllers() throws Exception {
-		assertThat(uut.isEmpty()).isTrue();
-		uut.push(child1);
-		uut.push(child2);
-		uut.push(child3);
-		assertThat(uut.peek()).isEqualTo(child3);
-		assertContainsOnlyId(child1.getId(), child2.getId(), child3.getId());
-	}
-
-	@Test
-	public void push() throws Exception {
-		assertThat(uut.isEmpty()).isTrue();
-		uut.push(child1);
-		assertContainsOnlyId(child1.getId());
-	}
-
-	@Test
-	public void pop() throws Exception {
-		uut.push(child1);
-		uut.push(child2);
-		assertContainsOnlyId(child2.getId(), child1.getId());
-		uut.pop();
-		assertContainsOnlyId(child1.getId());
-	}
-
-	@Test
-	public void stackOperations() throws Exception {
-		assertThat(uut.peek()).isNull();
-		assertThat(uut.size()).isZero();
-		assertThat(uut.isEmpty()).isTrue();
-		uut.push(child1);
-		assertThat(uut.peek()).isEqualTo(child1);
-		assertThat(uut.size()).isEqualTo(1);
-		assertThat(uut.isEmpty()).isFalse();
-	}
-
-	@Test
-	public void pushAssignsRefToSelfOnPushedController() throws Exception {
-		assertThat(child1.getParentStackController()).isNull();
-		uut.push(child1);
-		assertThat(child1.getParentStackController()).isEqualTo(uut);
-
-		StackController anotherNavController = new StackController(activity, "another", new TestNavigationAnimator());
-		anotherNavController.push(child2);
-		assertThat(child2.getParentStackController()).isEqualTo(anotherNavController);
-	}
-
-	@Test
-	public void handleBack_PopsUnlessSingleChild() throws Exception {
-		assertThat(uut.isEmpty()).isTrue();
-		assertThat(uut.handleBack()).isFalse();
-
-		uut.push(child1);
-		assertThat(uut.size()).isEqualTo(1);
-		assertThat(uut.handleBack()).isFalse();
-
-		uut.push(child2);
-		assertThat(uut.size()).isEqualTo(2);
-		assertThat(uut.handleBack()).isTrue();
-		assertThat(uut.size()).isEqualTo(1);
-		assertThat(uut.handleBack()).isFalse();
-	}
-
-	@Test
-	public void popDoesNothingWhenZeroOrOneChild() throws Exception {
-		assertThat(uut.isEmpty()).isTrue();
-		uut.pop();
-		assertThat(uut.isEmpty()).isTrue();
-
-		uut.push(child1);
-		uut.pop();
-		assertContainsOnlyId(child1.getId());
-	}
-
-	@Test
-	public void canPopWhenSizeIsMoreThanOne() throws Exception {
-		assertThat(uut.isEmpty()).isTrue();
-		assertThat(uut.canPop()).isFalse();
-		uut.push(child1);
-		assertContainsOnlyId(child1.getId());
-		assertThat(uut.canPop()).isFalse();
-		uut.push(child2);
-		assertContainsOnlyId(child1.getId(), child2.getId());
-		assertThat(uut.canPop()).isTrue();
-	}
-
-	@Test
-	public void pushAddsToViewTree() throws Exception {
-		assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
-		uut.push(child1);
-		assertThat(uut.getView().findViewById(child1.getView().getId())).isNotNull();
-	}
-
-	@Test
-	public void pushRemovesPreviousFromTree() throws Exception {
-		assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
-		uut.push(child1);
-		assertThat(uut.getView().findViewById(child1.getView().getId())).isNotNull();
-		uut.push(child2);
-		assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
-		assertThat(uut.getView().findViewById(child2.getView().getId())).isNotNull();
-	}
-
-	@Test
-	public void popReplacesViewWithPrevious() throws Exception {
-		uut.push(child1);
-		uut.push(child2);
-		assertIsChildById(uut.getView(), child2.getView());
-		assertNotChildOf(uut.getView(), child1.getView());
-		uut.pop();
-		assertNotChildOf(uut.getView(), child2.getView());
-		assertIsChildById(uut.getView(), child1.getView());
-	}
-
-	@Test
-	public void popSpecificWhenTopIsRegularPop() throws Exception {
-		uut.push(child1);
-		uut.push(child2);
-		uut.popSpecific(child2);
-		assertContainsOnlyId(child1.getId());
-		assertIsChildById(uut.getView(), child1.getView());
-	}
-
-	@Test
-	public void popSpecificDeepInStack() throws Exception {
-		uut.push(child1);
-		uut.push(child2);
-		assertIsChildById(uut.getView(), child2.getView());
-		uut.popSpecific(child1);
-		assertContainsOnlyId(child2.getId());
-		assertIsChildById(uut.getView(), child2.getView());
-	}
-
-	@Test
-	public void popTo_PopsTopUntilControllerIsNewTop() throws Exception {
-		uut.push(child1);
-		uut.push(child2);
-		uut.push(child3);
-
-		assertThat(uut.size()).isEqualTo(3);
-		assertThat(uut.peek()).isEqualTo(child3);
-
-		uut.popTo(child1);
-
-		assertThat(uut.size()).isEqualTo(1);
-		assertThat(uut.peek()).isEqualTo(child1);
-	}
-
-	@Test
-	public void popTo_NotAChildOfThisStack_DoesNothing() throws Exception {
-		uut.push(child1);
-		uut.push(child3);
-		assertThat(uut.size()).isEqualTo(2);
-		uut.popTo(child2);
-		assertThat(uut.size()).isEqualTo(2);
-	}
-
-	@Test
-	public void popToRoot_PopsEverythingAboveFirstController() throws Exception {
-		uut.push(child1);
-		uut.push(child2);
-		uut.push(child3);
-
-		assertThat(uut.size()).isEqualTo(3);
-		assertThat(uut.peek()).isEqualTo(child3);
-
-		uut.popToRoot();
-
-		assertThat(uut.size()).isEqualTo(1);
-		assertThat(uut.peek()).isEqualTo(child1);
-	}
-
-	@Test
-	public void popToRoot_EmptyStackDoesNothing() throws Exception {
-		assertThat(uut.isEmpty()).isTrue();
-		uut.popToRoot();
-		assertThat(uut.isEmpty()).isTrue();
-	}
-
-	@Test
-	public void findControllerById_ReturnsSelfOrChildrenById() throws Exception {
-		assertThat(uut.findControllerById("123")).isNull();
-		assertThat(uut.findControllerById(uut.getId())).isEqualTo(uut);
-		uut.push(child1);
-		assertThat(uut.findControllerById(child1.getId())).isEqualTo(child1);
-	}
-
-	@Test
-	public void findControllerById_Deeply() throws Exception {
-		StackController stack = new StackController(activity, "stack2", new TestNavigationAnimator());
-		stack.push(child2);
-		uut.push(stack);
-		assertThat(uut.findControllerById(child2.getId())).isEqualTo(child2);
-	}
-
-	@Test
-	public void pop_CallsDestroyOnPoppedChild() throws Exception {
-		child1 = spy(child1);
-		child2 = spy(child2);
-		child3 = spy(child3);
-		uut.push(child1);
-		uut.push(child2);
-		uut.push(child3);
-
-		verify(child3, times(0)).destroy();
-		uut.pop();
-		verify(child3, times(1)).destroy();
-	}
-
-	@Test
-	public void popSpecific_CallsDestroyOnPoppedChild() throws Exception {
-		child1 = spy(child1);
-		child2 = spy(child2);
-		child3 = spy(child3);
-		uut.push(child1);
-		uut.push(child2);
-		uut.push(child3);
-
-		verify(child2, times(0)).destroy();
-		uut.popSpecific(child2);
-		verify(child2, times(1)).destroy();
-	}
-
-	@Test
-	public void popTo_CallsDestroyOnPoppedChild() throws Exception {
-		child1 = spy(child1);
-		child2 = spy(child2);
-		child3 = spy(child3);
-		uut.push(child1);
-		uut.push(child2);
-		uut.push(child3);
-
-		verify(child2, times(0)).destroy();
-		verify(child3, times(0)).destroy();
-		uut.popTo(child1);
-		verify(child2, times(1)).destroy();
-		verify(child3, times(1)).destroy();
-	}
-
-	private void assertContainsOnlyId(String... ids) {
-		assertThat(uut.size()).isEqualTo(ids.length);
-		assertThat(uut.getChildControllers()).extracting(new Extractor<ViewController, String>() {
-			@Override
-			public String extract(final ViewController input) {
-				return input.getId();
-			}
-		}).containsOnly(ids);
-	}
+    private Activity activity;
+    private StackController uut;
+    private ViewController child1;
+    private ViewController child2;
+    private ViewController child3;
+
+    @Override
+    public void beforeEach() {
+        super.beforeEach();
+        activity = newActivity();
+        uut = new StackController(activity, "uut", new TestNavigationAnimator());
+        child1 = new SimpleViewController(activity, "child1");
+        child2 = new SimpleViewController(activity, "child2");
+        child3 = new SimpleViewController(activity, "child3");
+    }
+
+    @Test
+    public void isAViewController() throws Exception {
+        assertThat(uut).isInstanceOf(ViewController.class);
+    }
+
+    @Test
+    public void holdsAStackOfViewControllers() throws Exception {
+        assertThat(uut.isEmpty()).isTrue();
+        uut.push(child1);
+        uut.push(child2);
+        uut.push(child3);
+        assertThat(uut.peek()).isEqualTo(child3);
+        assertContainsOnlyId(child1.getId(), child2.getId(), child3.getId());
+    }
+
+    @Test
+    public void push() throws Exception {
+        assertThat(uut.isEmpty()).isTrue();
+        uut.push(child1);
+        assertContainsOnlyId(child1.getId());
+    }
+
+    @Test
+    public void pop() throws Exception {
+        uut.push(child1);
+        uut.push(child2);
+        assertContainsOnlyId(child2.getId(), child1.getId());
+        uut.pop();
+        assertContainsOnlyId(child1.getId());
+    }
+
+    @Test
+    public void stackOperations() throws Exception {
+        assertThat(uut.peek()).isNull();
+        assertThat(uut.size()).isZero();
+        assertThat(uut.isEmpty()).isTrue();
+        uut.push(child1);
+        assertThat(uut.peek()).isEqualTo(child1);
+        assertThat(uut.size()).isEqualTo(1);
+        assertThat(uut.isEmpty()).isFalse();
+    }
+
+    @Test
+    public void pushAssignsRefToSelfOnPushedController() throws Exception {
+        assertThat(child1.getParentStackController()).isNull();
+        uut.push(child1);
+        assertThat(child1.getParentStackController()).isEqualTo(uut);
+
+        StackController anotherNavController = new StackController(activity, "another", new TestNavigationAnimator());
+        anotherNavController.push(child2);
+        assertThat(child2.getParentStackController()).isEqualTo(anotherNavController);
+    }
+
+    @Test
+    public void handleBack_PopsUnlessSingleChild() throws Exception {
+        assertThat(uut.isEmpty()).isTrue();
+        assertThat(uut.handleBack()).isFalse();
+
+        uut.push(child1);
+        assertThat(uut.size()).isEqualTo(1);
+        assertThat(uut.handleBack()).isFalse();
+
+        uut.push(child2);
+        assertThat(uut.size()).isEqualTo(2);
+        assertThat(uut.handleBack()).isTrue();
+        assertThat(uut.size()).isEqualTo(1);
+        assertThat(uut.handleBack()).isFalse();
+    }
+
+    @Test
+    public void popDoesNothingWhenZeroOrOneChild() throws Exception {
+        assertThat(uut.isEmpty()).isTrue();
+        uut.pop();
+        assertThat(uut.isEmpty()).isTrue();
+
+        uut.push(child1);
+        uut.pop();
+        assertContainsOnlyId(child1.getId());
+    }
+
+    @Test
+    public void canPopWhenSizeIsMoreThanOne() throws Exception {
+        assertThat(uut.isEmpty()).isTrue();
+        assertThat(uut.canPop()).isFalse();
+        uut.push(child1);
+        assertContainsOnlyId(child1.getId());
+        assertThat(uut.canPop()).isFalse();
+        uut.push(child2);
+        assertContainsOnlyId(child1.getId(), child2.getId());
+        assertThat(uut.canPop()).isTrue();
+    }
+
+    @Test
+    public void pushAddsToViewTree() throws Exception {
+        assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
+        uut.push(child1);
+        assertThat(uut.getView().findViewById(child1.getView().getId())).isNotNull();
+    }
+
+    @Test
+    public void pushRemovesPreviousFromTree() throws Exception {
+        assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
+        uut.push(child1);
+        assertThat(uut.getView().findViewById(child1.getView().getId())).isNotNull();
+        uut.push(child2);
+        assertThat(uut.getView().findViewById(child1.getView().getId())).isNull();
+        assertThat(uut.getView().findViewById(child2.getView().getId())).isNotNull();
+    }
+
+    @Test
+    public void popReplacesViewWithPrevious() throws Exception {
+        uut.push(child1);
+        uut.push(child2);
+        assertIsChildById(uut.getView(), child2.getView());
+        assertNotChildOf(uut.getView(), child1.getView());
+        uut.pop();
+        assertNotChildOf(uut.getView(), child2.getView());
+        assertIsChildById(uut.getView(), child1.getView());
+    }
+
+    @Test
+    public void popSpecificWhenTopIsRegularPop() throws Exception {
+        uut.push(child1);
+        uut.push(child2);
+        uut.popSpecific(child2);
+        assertContainsOnlyId(child1.getId());
+        assertIsChildById(uut.getView(), child1.getView());
+    }
+
+    @Test
+    public void popSpecificDeepInStack() throws Exception {
+        uut.push(child1);
+        uut.push(child2);
+        assertIsChildById(uut.getView(), child2.getView());
+        uut.popSpecific(child1);
+        assertContainsOnlyId(child2.getId());
+        assertIsChildById(uut.getView(), child2.getView());
+    }
+
+    @Test
+    public void popTo_PopsTopUntilControllerIsNewTop() throws Exception {
+        uut.push(child1);
+        uut.push(child2);
+        uut.push(child3);
+
+        assertThat(uut.size()).isEqualTo(3);
+        assertThat(uut.peek()).isEqualTo(child3);
+
+        uut.popTo(child1);
+
+        assertThat(uut.size()).isEqualTo(1);
+        assertThat(uut.peek()).isEqualTo(child1);
+    }
+
+    @Test
+    public void popTo_NotAChildOfThisStack_DoesNothing() throws Exception {
+        uut.push(child1);
+        uut.push(child3);
+        assertThat(uut.size()).isEqualTo(2);
+        uut.popTo(child2);
+        assertThat(uut.size()).isEqualTo(2);
+    }
+
+    @Test
+    public void popToRoot_PopsEverythingAboveFirstController() throws Exception {
+        uut.push(child1);
+        uut.push(child2);
+        uut.push(child3);
+
+        assertThat(uut.size()).isEqualTo(3);
+        assertThat(uut.peek()).isEqualTo(child3);
+
+        uut.popToRoot();
+
+        assertThat(uut.size()).isEqualTo(1);
+        assertThat(uut.peek()).isEqualTo(child1);
+    }
+
+    @Test
+    public void popToRoot_EmptyStackDoesNothing() throws Exception {
+        assertThat(uut.isEmpty()).isTrue();
+        uut.popToRoot();
+        assertThat(uut.isEmpty()).isTrue();
+    }
+
+    @Test
+    public void findControllerById_ReturnsSelfOrChildrenById() throws Exception {
+        assertThat(uut.findControllerById("123")).isNull();
+        assertThat(uut.findControllerById(uut.getId())).isEqualTo(uut);
+        uut.push(child1);
+        assertThat(uut.findControllerById(child1.getId())).isEqualTo(child1);
+    }
+
+    @Test
+    public void findControllerById_Deeply() throws Exception {
+        StackController stack = new StackController(activity, "stack2", new TestNavigationAnimator());
+        stack.push(child2);
+        uut.push(stack);
+        assertThat(uut.findControllerById(child2.getId())).isEqualTo(child2);
+    }
+
+    @Test
+    public void pop_CallsDestroyOnPoppedChild() throws Exception {
+        child1 = spy(child1);
+        child2 = spy(child2);
+        child3 = spy(child3);
+        uut.push(child1);
+        uut.push(child2);
+        uut.push(child3);
+
+        verify(child3, times(0)).destroy();
+        uut.pop();
+        verify(child3, times(1)).destroy();
+    }
+
+    @Test
+    public void popSpecific_CallsDestroyOnPoppedChild() throws Exception {
+        child1 = spy(child1);
+        child2 = spy(child2);
+        child3 = spy(child3);
+        uut.push(child1);
+        uut.push(child2);
+        uut.push(child3);
+
+        verify(child2, times(0)).destroy();
+        uut.popSpecific(child2);
+        verify(child2, times(1)).destroy();
+    }
+
+    @Test
+    public void popTo_CallsDestroyOnPoppedChild() throws Exception {
+        child1 = spy(child1);
+        child2 = spy(child2);
+        child3 = spy(child3);
+        uut.push(child1);
+        uut.push(child2);
+        uut.push(child3);
+
+        verify(child2, times(0)).destroy();
+        verify(child3, times(0)).destroy();
+        uut.popTo(child1);
+        verify(child2, times(1)).destroy();
+        verify(child3, times(1)).destroy();
+    }
+
+    private void assertContainsOnlyId(String... ids) {
+        assertThat(uut.size()).isEqualTo(ids.length);
+        assertThat(uut.getChildControllers()).extracting(new Extractor<ViewController, String>() {
+            @Override
+            public String extract(final ViewController input) {
+                return input.getId();
+            }
+        }).containsOnly(ids);
+    }
 }

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Activity;
+import android.app.*;
 
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.TopTabLayoutMock;
-import com.reactnativenavigation.parse.NavigationOptions;
-import com.reactnativenavigation.viewcontrollers.toptabs.TopTabController;
+import com.reactnativenavigation.*;
+import com.reactnativenavigation.mocks.*;
+import com.reactnativenavigation.parse.*;
+import com.reactnativenavigation.viewcontrollers.toptabs.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.*;
 
 public class TopTabControllerTest extends BaseTest {
     private TopTabController uut;
     private TopTabLayoutMock view;
     private ParentController parentController;
-    private NavigationOptions initialOptions;
+    private Options initialOptions;
 
     @Override
     public void beforeEach() {
         super.beforeEach();
         Activity activity = newActivity();
         view = spy(new TopTabLayoutMock(activity));
-        initialOptions = new NavigationOptions();
+        initialOptions = new Options();
         uut = new TopTabController(activity,
                 "componentId",
                 "componentName",
     public void styleIsAppliedOnParentControllerWhenOptionsAreSetDynamically() throws Exception {
         uut.ensureViewIsCreated();
         uut.onViewAppeared();
-        uut.mergeNavigationOptions(new NavigationOptions());
+        uut.mergeNavigationOptions(new Options());
         verify(parentController, times(2)).applyOptions(initialOptions);
     }
 

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Activity;
-import android.support.annotation.NonNull;
-import android.view.ViewGroup;
+import android.app.*;
+import android.support.annotation.*;
+import android.view.*;
 
-import java.util.Collection;
+import java.util.*;
 
 public class TopTabsControllerMock extends ParentController {
     TopTabsControllerMock(Activity activity, String id) {

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Activity;
-import android.view.ViewGroup;
+import android.app.*;
+import android.view.*;
 
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.TopTabLayoutMock;
-import com.reactnativenavigation.parse.NavigationOptions;
-import com.reactnativenavigation.viewcontrollers.ComponentViewController.IReactView;
-import com.reactnativenavigation.viewcontrollers.toptabs.TopTabController;
-import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsAdapter;
-import com.reactnativenavigation.viewcontrollers.toptabs.TopTabsController;
-import com.reactnativenavigation.views.TopTabsLayout;
-import com.reactnativenavigation.views.TopTabsLayoutCreator;
+import com.reactnativenavigation.*;
+import com.reactnativenavigation.mocks.*;
+import com.reactnativenavigation.parse.*;
+import com.reactnativenavigation.viewcontrollers.ComponentViewController.*;
+import com.reactnativenavigation.viewcontrollers.toptabs.*;
+import com.reactnativenavigation.views.*;
 
-import org.junit.Test;
-import org.mockito.Mockito;
+import org.junit.*;
+import org.mockito.*;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.*;
 
 public class TopTabsViewControllerTest extends BaseTest {
 
     private TopTabsController uut;
     private List<TopTabLayoutMock> tabs = new ArrayList<>(SIZE);
     private List<TopTabController> tabControllers = new ArrayList<>(SIZE);
-    private List<NavigationOptions> tabOptions = new ArrayList<>(SIZE);
-    private NavigationOptions options;
+    private List<Options> tabOptions = new ArrayList<>(SIZE);
+    private Options options;
     private TopTabsLayout topTabsLayout;
 
     @Override
         tabs.clear();
         Activity activity = newActivity();
         createTabs(activity);
-        options = new NavigationOptions();
+        options = new Options();
         topTabsLayout = spy(new TopTabsLayout(activity, tabControllers, new TopTabsAdapter(tabControllers)));
 
         TopTabsLayoutCreator layoutCreator = Mockito.mock(TopTabsLayoutCreator.class);
         for (int i = 0; i < SIZE; i++) {
             TopTabLayoutMock reactView = spy(new TopTabLayoutMock(activity));
             tabs.add(reactView);
-            tabOptions.add(new NavigationOptions());
+            tabOptions.add(new Options());
             tabControllers.add(spy(new TopTabController(activity,
                     "idTab" + i,
                     "tab" + i,

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

 package com.reactnativenavigation.viewcontrollers;
 
-import android.app.Activity;
-import android.view.View;
-import android.view.ViewParent;
-import android.widget.LinearLayout;
+import android.app.*;
+import android.view.*;
+import android.widget.*;
 
-import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.SimpleViewController;
+import com.reactnativenavigation.*;
+import com.reactnativenavigation.mocks.*;
 
-import org.assertj.android.api.Assertions;
-import org.junit.Test;
-import org.robolectric.Shadows;
+import org.assertj.android.api.*;
+import org.junit.*;
+import org.robolectric.*;
 
-import java.lang.reflect.Field;
+import java.lang.reflect.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.assertj.core.api.Java6Assertions.*;
+import static org.mockito.Mockito.*;
 
 public class ViewControllerTest extends BaseTest {
 
-	private ViewController uut;
-	private Activity activity;
-
-	@Override
-	public void beforeEach() {
-		super.beforeEach();
-		activity = newActivity();
-		uut = new SimpleViewController(activity, "uut");
-	}
-
-	@Test
-	public void holdsAView() throws Exception {
-		assertThat(uut.getView()).isNotNull().isInstanceOf(View.class);
-	}
-
-	@Test
-	public void holdsARefToActivity() throws Exception {
-		assertThat(uut.getActivity()).isNotNull().isEqualTo(activity);
-	}
-
-	@Test
-	public void canOverrideViewCreation() throws Exception {
-		final View otherView = new View(activity);
-		ViewController myController = new ViewController(activity, "vc") {
-			@Override
-			protected View createView() {
-				return otherView;
-			}
-		};
-		assertThat(myController.getView()).isEqualTo(otherView);
-	}
-
-	@Test
-	public void holdsAReferenceToStackControllerOrNull() throws Exception {
-		assertThat(uut.getParentStackController()).isNull();
-		StackController nav = new StackController(activity, "stack");
-		nav.push(uut);
-		assertThat(uut.getParentStackController()).isEqualTo(nav);
-	}
-
-	@Test
-	public void handleBackDefaultFalse() throws Exception {
-		assertThat(uut.handleBack()).isFalse();
-	}
-
-	@Test
-	public void holdsId() throws Exception {
-		assertThat(uut.getId()).isEqualTo("uut");
-	}
-
-	@Test
-	public void isSameId() throws Exception {
-		assertThat(uut.isSameId("")).isFalse();
-		assertThat(uut.isSameId(null)).isFalse();
-		assertThat(uut.isSameId("uut")).isTrue();
-	}
-
-	@Test
-	public void findControllerById_SelfOrNull() throws Exception {
-		assertThat(uut.findControllerById("456")).isNull();
-		assertThat(uut.findControllerById("uut")).isEqualTo(uut);
-	}
-
-	@Test
-	public void onAppear_WhenShown() throws Exception {
-		ViewController spy = spy(uut);
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-		Assertions.assertThat(spy.getView()).isNotShown();
-		verify(spy, times(0)).onViewAppeared();
-
-		Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-		Assertions.assertThat(spy.getView()).isShown();
-
-		verify(spy, times(1)).onViewAppeared();
-	}
-
-	@Test
-	public void onAppear_CalledAtMostOnce() throws Exception {
-		ViewController spy = spy(uut);
-		Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
-		Assertions.assertThat(spy.getView()).isShown();
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-
-		verify(spy, times(1)).onViewAppeared();
-	}
-
-	@Test
-	public void onDisappear_WhenNotShown_AfterOnAppearWasCalled() throws Exception {
-		ViewController spy = spy(uut);
-		Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
-		Assertions.assertThat(spy.getView()).isShown();
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-		verify(spy, times(1)).onViewAppeared();
-		verify(spy, times(0)).onViewDisappear();
-
-		spy.getView().setVisibility(View.GONE);
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-		Assertions.assertThat(spy.getView()).isNotShown();
-		verify(spy, times(1)).onViewDisappear();
-	}
-
-	@Test
-	public void onDisappear_CalledAtMostOnce() throws Exception {
-		ViewController spy = spy(uut);
-		Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
-		Assertions.assertThat(spy.getView()).isShown();
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-		spy.getView().setVisibility(View.GONE);
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-		verify(spy, times(1)).onViewDisappear();
-	}
-
-	@Test
-	public void onDestroy_RemovesGlobalLayoutListener() throws Exception {
-		new SimpleViewController(activity, "ensureNotNull").destroy();
-
-		ViewController spy = spy(uut);
-		View view = spy.getView();
-		Shadows.shadowOf(view).setMyParent(mock(ViewParent.class));
-
-		spy.destroy();
-
-		Assertions.assertThat(view).isShown();
-		view.getViewTreeObserver().dispatchOnGlobalLayout();
-		verify(spy, times(0)).onViewAppeared();
-		verify(spy, times(0)).onViewDisappear();
-
-		Field field = ViewController.class.getDeclaredField("view");
-		field.setAccessible(true);
-		assertThat(field.get(spy)).isNull();
-	}
-
-	@Test
-	public void onDestroy_CallsOnDisappearIfNeeded() throws Exception {
-		ViewController spy = spy(uut);
-		Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
-		Assertions.assertThat(spy.getView()).isShown();
-		spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
-		verify(spy, times(1)).onViewAppeared();
-
-		spy.destroy();
-
-		verify(spy, times(1)).onViewDisappear();
-	}
-
-	@Test
-	public void assignsIdToCreatedView() throws Exception {
-		assertThat(uut.getView().getId()).isPositive();
-	}
-
-	@Test
-	public void onDestroy_RemovesSelfFromParentIfExists() throws Exception {
-		LinearLayout parent = new LinearLayout(activity);
-		parent.addView(uut.getView());
-
-		uut.destroy();
-		assertThat(parent.getChildCount()).withFailMessage("expected not to have children").isZero();
-	}
-
-	@Test
-	public void ensureViewIsCreated() throws Exception {
-		ViewController spy = spy(uut);
-		verify(spy, times(0)).getView();
-		spy.ensureViewIsCreated();
-		verify(spy, times(1)).getView();
-	}
+    private ViewController uut;
+    private Activity activity;
+
+    @Override
+    public void beforeEach() {
+        super.beforeEach();
+        activity = newActivity();
+        uut = new SimpleViewController(activity, "uut");
+    }
+
+    @Test
+    public void holdsAView() throws Exception {
+        assertThat(uut.getView()).isNotNull().isInstanceOf(View.class);
+    }
+
+    @Test
+    public void holdsARefToActivity() throws Exception {
+        assertThat(uut.getActivity()).isNotNull().isEqualTo(activity);
+    }
+
+    @Test
+    public void canOverrideViewCreation() throws Exception {
+        final View otherView = new View(activity);
+        ViewController myController = new ViewController(activity, "vc") {
+            @Override
+            protected View createView() {
+                return otherView;
+            }
+        };
+        assertThat(myController.getView()).isEqualTo(otherView);
+    }
+
+    @Test
+    public void holdsAReferenceToStackControllerOrNull() throws Exception {
+        assertThat(uut.getParentStackController()).isNull();
+        StackController nav = new StackController(activity, "stack");
+        nav.push(uut);
+        assertThat(uut.getParentStackController()).isEqualTo(nav);
+    }
+
+    @Test
+    public void handleBackDefaultFalse() throws Exception {
+        assertThat(uut.handleBack()).isFalse();
+    }
+
+    @Test
+    public void holdsId() throws Exception {
+        assertThat(uut.getId()).isEqualTo("uut");
+    }
+
+    @Test
+    public void isSameId() throws Exception {
+        assertThat(uut.isSameId("")).isFalse();
+        assertThat(uut.isSameId(null)).isFalse();
+        assertThat(uut.isSameId("uut")).isTrue();
+    }
+
+    @Test
+    public void findControllerById_SelfOrNull() throws Exception {
+        assertThat(uut.findControllerById("456")).isNull();
+        assertThat(uut.findControllerById("uut")).isEqualTo(uut);
+    }
+
+    @Test
+    public void onAppear_WhenShown() throws Exception {
+        ViewController spy = spy(uut);
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        Assertions.assertThat(spy.getView()).isNotShown();
+        verify(spy, times(0)).onViewAppeared();
+
+        Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        Assertions.assertThat(spy.getView()).isShown();
+
+        verify(spy, times(1)).onViewAppeared();
+    }
+
+    @Test
+    public void onAppear_CalledAtMostOnce() throws Exception {
+        ViewController spy = spy(uut);
+        Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
+        Assertions.assertThat(spy.getView()).isShown();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+
+        verify(spy, times(1)).onViewAppeared();
+    }
+
+    @Test
+    public void onDisappear_WhenNotShown_AfterOnAppearWasCalled() throws Exception {
+        ViewController spy = spy(uut);
+        Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
+        Assertions.assertThat(spy.getView()).isShown();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        verify(spy, times(1)).onViewAppeared();
+        verify(spy, times(0)).onViewDisappear();
+
+        spy.getView().setVisibility(View.GONE);
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        Assertions.assertThat(spy.getView()).isNotShown();
+        verify(spy, times(1)).onViewDisappear();
+    }
+
+    @Test
+    public void onDisappear_CalledAtMostOnce() throws Exception {
+        ViewController spy = spy(uut);
+        Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
+        Assertions.assertThat(spy.getView()).isShown();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        spy.getView().setVisibility(View.GONE);
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        verify(spy, times(1)).onViewDisappear();
+    }
+
+    @Test
+    public void onDestroy_RemovesGlobalLayoutListener() throws Exception {
+        new SimpleViewController(activity, "ensureNotNull").destroy();
+
+        ViewController spy = spy(uut);
+        View view = spy.getView();
+        Shadows.shadowOf(view).setMyParent(mock(ViewParent.class));
+
+        spy.destroy();
+
+        Assertions.assertThat(view).isShown();
+        view.getViewTreeObserver().dispatchOnGlobalLayout();
+        verify(spy, times(0)).onViewAppeared();
+        verify(spy, times(0)).onViewDisappear();
+
+        Field field = ViewController.class.getDeclaredField("view");
+        field.setAccessible(true);
+        assertThat(field.get(spy)).isNull();
+    }
+
+    @Test
+    public void onDestroy_CallsOnDisappearIfNeeded() throws Exception {
+        ViewController spy = spy(uut);
+        Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
+        Assertions.assertThat(spy.getView()).isShown();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        verify(spy, times(1)).onViewAppeared();
+
+        spy.destroy();
+
+        verify(spy, times(1)).onViewDisappear();
+    }
+
+    @Test
+    public void assignsIdToCreatedView() throws Exception {
+        assertThat(uut.getView().getId()).isPositive();
+    }
+
+    @Test
+    public void onDestroy_RemovesSelfFromParentIfExists() throws Exception {
+        LinearLayout parent = new LinearLayout(activity);
+        parent.addView(uut.getView());
+
+        uut.destroy();
+        assertThat(parent.getChildCount()).withFailMessage("expected not to have children").isZero();
+    }
+
+    @Test
+    public void ensureViewIsCreated() throws Exception {
+        ViewController spy = spy(uut);
+        verify(spy, times(0)).getView();
+        spy.ensureViewIsCreated();
+        verify(spy, times(1)).getView();
+    }
 }
 

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

 package com.reactnativenavigation.views;
 
-import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.*;
 
-import org.junit.Test;
+import org.junit.*;
 
-import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.assertj.core.api.Java6Assertions.*;
 
 public class TopBarTest extends BaseTest {
-	@Test
-	public void title() throws Exception {
-		TopBar topBar = new TopBar(newActivity(), null, null);
-		assertThat(topBar.getTitle()).isEmpty();
+    @Test
+    public void title() throws Exception {
+        TopBar topBar = new TopBar(newActivity(), null, null);
+        assertThat(topBar.getTitle()).isEmpty();
 
-		topBar.setTitle("new title");
-		assertThat(topBar.getTitle()).isEqualTo("new title");
-	}
+        topBar.setTitle("new title");
+        assertThat(topBar.getTitle()).isEqualTo("new title");
+    }
 }

playground/android/app/src/main/java/com/reactnativenavigation/playground/MainActivity.java

 package com.reactnativenavigation.playground;
 
-import com.reactnativenavigation.NavigationActivity;
+import com.reactnativenavigation.*;
 
 public class MainActivity extends NavigationActivity {
 }

playground/android/app/src/main/java/com/reactnativenavigation/playground/MainApplication.java

 package com.reactnativenavigation.playground;
 
-import android.support.annotation.Nullable;
+import android.support.annotation.*;
 
-import com.facebook.react.ReactPackage;
-import com.reactnativenavigation.NavigationApplication;
+import com.facebook.react.*;
+import com.reactnativenavigation.*;
 
-import java.util.List;
+import java.util.*;
 
 public class MainApplication extends NavigationApplication {
 
-	@Override
-	public boolean isDebug() {
-		return BuildConfig.DEBUG;
-	}
+    @Override
+    public boolean isDebug() {
+        return BuildConfig.DEBUG;
+    }
 
-	@Nullable
-	@Override
-	public List<ReactPackage> createAdditionalReactPackages() {
-		return null;
-	}
+    @Nullable
+    @Override
+    public List<ReactPackage> createAdditionalReactPackages() {
+        return null;
+    }
 }

playground/src/screens/ModalScreen.js

   }
 
   onClickPushScreen() {
-    Navigation.push(this.props.containerId, {
+    Navigation.push(this.props.componentId, {
       component: {
         name: `navigation.playground.PushedScreen`,
         passProps: {

playground/src/screens/WelcomeScreen.js

 
   async onClickShowModal() {
     await Navigation.showModal({
-      component: {
-        name: 'navigation.playground.ModalScreen'
+      stack: {
+        children: [
+          {
+            component: {
+              name: 'navigation.playground.ModalScreen'
+            }
+          }
+        ]
       }
     });
   }