/**
 * Copyright (c) 2014-present, Facebook, Inc.
 * All rights reserved.
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 */

package com.facebook.react.tests;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import com.facebook.react.bridge.BaseJavaModule;
import com.facebook.react.bridge.CatalystInstance;
import com.facebook.react.bridge.Dynamic;
import com.facebook.react.bridge.InvalidIteratorException;
import com.facebook.react.bridge.JavaScriptModule;
import com.facebook.react.bridge.NoSuchKeyException;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.ReadableMapKeySetIterator;
import com.facebook.react.bridge.ReadableNativeMap;
import com.facebook.react.bridge.ReadableType;
import com.facebook.react.bridge.UiThreadUtil;
import com.facebook.react.bridge.UnexpectedNativeTypeException;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.bridge.WritableNativeMap;
import com.facebook.react.modules.systeminfo.AndroidInfoModule;
import com.facebook.react.testing.FakeWebSocketModule;
import com.facebook.react.testing.ReactIntegrationTestCase;
import com.facebook.react.testing.ReactTestHelper;
import com.facebook.react.uimanager.UIImplementationProvider;
import com.facebook.react.uimanager.UIManagerModule;
import com.facebook.react.uimanager.ViewManager;
import com.facebook.react.views.view.ReactViewManager;

/**
 * Integration test to verify passing various types of parameters from JS to Java works
 *
 * TODO: we should run these tests with isBlockingSynchronousMethod = true as well,
 * since they currrently use a completely different codepath
 */
public class CatalystNativeJSToJavaParametersTestCase extends ReactIntegrationTestCase {

  private interface TestJSToJavaParametersModule extends JavaScriptModule {
    void returnBasicTypes();
    void returnBoxedTypes();
    void returnDynamicTypes();

    void returnArrayWithBasicTypes();
    void returnNestedArray();
    void returnArrayWithMaps();

    void returnMapWithBasicTypes();
    void returnNestedMap();
    void returnMapWithArrays();

    void returnArrayWithStringDoubleIntMapArrayBooleanNull();
    void returnMapWithStringDoubleIntMapArrayBooleanNull();

    void returnMapForMerge1();
    void returnMapForMerge2();

    void returnMapWithMultibyteUTF8CharacterString();
    void returnArrayWithMultibyteUTF8CharacterString();

    void returnArrayWithLargeInts();
    void returnMapWithLargeInts();
  }

  private RecordingTestModule mRecordingTestModule;
  private CatalystInstance mCatalystInstance;

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    List<ViewManager> viewManagers = Arrays.<ViewManager>asList(
        new ReactViewManager());
    final UIManagerModule mUIManager = new UIManagerModule(
        getContext(),
        viewManagers,
        new UIImplementationProvider(),
        false);
    UiThreadUtil.runOnUiThread(
        new Runnable() {
          @Override
          public void run() {
            mUIManager.onHostResume();
          }
        });
    waitForIdleSync();

    mRecordingTestModule = new RecordingTestModule();
    mCatalystInstance = ReactTestHelper.catalystInstanceBuilder(this)
        .addNativeModule(mRecordingTestModule)
        .addNativeModule(new AndroidInfoModule())
        .addNativeModule(new FakeWebSocketModule())
        .addNativeModule(mUIManager)
        .addJSModule(TestJSToJavaParametersModule.class)
        .build();
  }

  public void testBasicTypes() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnBasicTypes();
    waitForBridgeAndUIIdle();

    List<Object[]> basicTypesCalls = mRecordingTestModule.getBasicTypesCalls();
    assertEquals(1, basicTypesCalls.size());

    Object[] args = basicTypesCalls.get(0);
    assertEquals("foo", args[0]);
    assertEquals(3.14, args[1]);
    assertEquals(true, args[2]);
    assertNull(args[3]);
  }

  public void testBoxedTypes() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnBoxedTypes();
    waitForBridgeAndUIIdle();

    List<Object[]> boxedTypesCalls = mRecordingTestModule.getBoxedTypesCalls();
    assertEquals(1, boxedTypesCalls.size());

    Object[] args = boxedTypesCalls.get(0);
    assertEquals(Integer.valueOf(42), args[0]);
    assertEquals(Double.valueOf(3.14), args[1]);
    assertEquals(Boolean.valueOf(true), args[2]);
  }

  public void testDynamicType() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnDynamicTypes();
    waitForBridgeAndUIIdle();

    List<Dynamic> dynamicCalls = mRecordingTestModule.getDynamicCalls();
    assertEquals(2, dynamicCalls.size());

    assertEquals("foo", dynamicCalls.get(0).asString());
    assertEquals(3.14, dynamicCalls.get(1).asDouble());
  }

  public void testArrayWithBasicTypes() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnArrayWithBasicTypes();
    waitForBridgeAndUIIdle();

    List<ReadableArray> calls = mRecordingTestModule.getArrayCalls();
    assertEquals(1, calls.size());
    ReadableArray array = calls.get(0);
    assertNotNull(array);
    assertEquals(5, array.size());
    assertFalse(array.isNull(0));
    assertEquals("foo", array.getString(0));
    assertFalse(array.isNull(1));
    assertEquals(3.14, array.getDouble(1));
    assertFalse(array.isNull(2));
    assertEquals(-111, array.getInt(2));
    assertFalse(array.isNull(3));
    assertTrue(array.getBoolean(3));
    assertTrue(array.isNull(4));
    assertEquals(null, array.getString(4));
    assertEquals(null, array.getMap(4));
    assertEquals(null, array.getArray(4));
  }

  public void testNestedArray() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnNestedArray();
    waitForBridgeAndUIIdle();

    List<ReadableArray> calls = mRecordingTestModule.getArrayCalls();
    assertEquals(1, calls.size());
    ReadableArray array = calls.get(0);
    assertNotNull(array);
    assertEquals(2, array.size());
    assertEquals("we", array.getString(0));

    assertFalse(array.isNull(1));
    ReadableArray subArray = array.getArray(1);
    assertEquals(2, subArray.size());
    assertEquals("have", subArray.getString(0));

    subArray = subArray.getArray(1);
    assertEquals(2, subArray.size());
    assertEquals("to", subArray.getString(0));

    subArray = subArray.getArray(1);
    assertEquals(2, subArray.size());
    assertEquals("go", subArray.getString(0));

    subArray = subArray.getArray(1);
    assertEquals(1, subArray.size());
    assertEquals("deeper", subArray.getString(0));
  }

  public void testArrayWithMaps() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnArrayWithMaps();
    waitForBridgeAndUIIdle();

    List<ReadableArray> calls = mRecordingTestModule.getArrayCalls();
    assertEquals(1, calls.size());
    ReadableArray array = calls.get(0);
    assertEquals(2, array.size());

    assertFalse(array.isNull(0));
    ReadableMap m1 = array.getMap(0);
    ReadableMap m2 = array.getMap(1);

    assertEquals("m1v1", m1.getString("m1k1"));
    assertEquals("m1v2", m1.getString("m1k2"));
    assertEquals("m2v1", m2.getString("m2k1"));
  }

  public void testMapWithBasicTypes() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithBasicTypes();
    waitForBridgeAndUIIdle();

    List<ReadableMap> calls = mRecordingTestModule.getMapCalls();
    assertEquals(1, calls.size());
    ReadableMap map = calls.get(0);
    assertNotNull(map);

    assertTrue(map.hasKey("stringKey"));
    assertFalse(map.isNull("stringKey"));
    assertEquals("stringValue", map.getString("stringKey"));

    assertTrue(map.hasKey("doubleKey"));
    assertFalse(map.isNull("doubleKey"));
    assertTrue(Math.abs(3.14 - map.getDouble("doubleKey")) < .0001);

    assertTrue(map.hasKey("intKey"));
    assertFalse(map.isNull("intKey"));
    assertEquals(-11, map.getInt("intKey"));

    assertTrue(map.hasKey("booleanKey"));
    assertFalse(map.isNull("booleanKey"));
    assertTrue(map.getBoolean("booleanKey"));

    assertTrue(map.hasKey("nullKey"));
    assertTrue(map.isNull("nullKey"));
    assertNull(map.getString("nullKey"));
    assertNull(map.getMap("nullKey"));
    assertNull(map.getArray("nullKey"));

    assertFalse(map.hasKey("nonExistentKey"));
  }

  public void testNestedMap() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnNestedMap();
    waitForBridgeAndUIIdle();

    List<ReadableMap> calls = mRecordingTestModule.getMapCalls();
    assertEquals(1, calls.size());
    ReadableMap map = calls.get(0);
    assertNotNull(map);

    assertTrue(map.hasKey("weHaveToGoDeeper"));
    assertFalse(map.isNull("weHaveToGoDeeper"));
    ReadableMap nestedMap = map.getMap("weHaveToGoDeeper");
    assertTrue(nestedMap.hasKey("inception"));
    assertTrue(nestedMap.getBoolean("inception"));
  }

  public void testMapParameterWithArrays() throws InterruptedException {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithArrays();
    waitForBridgeAndUIIdle();

    List<ReadableMap> calls = mRecordingTestModule.getMapCalls();
    assertEquals(1, calls.size());
    ReadableMap map = calls.get(0);
    assertNotNull(map);

    ReadableArray arrayParameter;
    assertTrue(map.hasKey("empty"));
    arrayParameter = map.getArray("empty");
    assertNotNull(arrayParameter);
    assertEquals(0, arrayParameter.size());

    assertTrue(map.hasKey("ints"));
    assertFalse(map.isNull("ints"));
    arrayParameter = map.getArray("ints");
    assertNotNull(arrayParameter);
    assertEquals(2, arrayParameter.size());
    assertEquals(43, arrayParameter.getInt(0));
    assertEquals(44, arrayParameter.getInt(1));

    assertTrue(map.hasKey("mixed"));
    arrayParameter = map.getArray("mixed");
    assertNotNull(arrayParameter);
    assertEquals(3, arrayParameter.size());
    assertEquals(77, arrayParameter.getInt(0));
    assertEquals("string", arrayParameter.getString(1));
    ReadableArray nestedArray = arrayParameter.getArray(2);
    assertEquals(2, nestedArray.size());
  }

  public void testMapParameterDump() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithBasicTypes();
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnNestedMap();
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithArrays();
    waitForBridgeAndUIIdle();

    List<ReadableMap> calls = mRecordingTestModule.getMapCalls();
    assertEquals(3, calls.size());

    // App should not crash while generating debug string representation of arguments
    assertNotNull(calls.get(0).toString());
    assertNotNull(calls.get(1).toString());
    assertNotNull(calls.get(2).toString());
  }

  public void testGetTypeFromArray() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class)
        .returnArrayWithStringDoubleIntMapArrayBooleanNull();
    waitForBridgeAndUIIdle();

    List<ReadableArray> calls = mRecordingTestModule.getArrayCalls();
    assertEquals(1, calls.size());
    ReadableArray array = calls.get(0);

    assertEquals(ReadableType.String, array.getType(0));
    assertEquals(ReadableType.Number, array.getType(1));
    assertEquals(ReadableType.Number, array.getType(2));
    assertEquals(ReadableType.Map, array.getType(3));
    assertEquals(ReadableType.Array, array.getType(4));
    assertEquals(ReadableType.Boolean, array.getType(5));
    assertEquals(ReadableType.Null, array.getType(6));
  }

  public void testGetTypeFromMap() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class)
        .returnMapWithStringDoubleIntMapArrayBooleanNull();
    waitForBridgeAndUIIdle();

    List<ReadableMap> calls = mRecordingTestModule.getMapCalls();
    assertEquals(1, calls.size());
    ReadableMap map = calls.get(0);

    assertEquals(ReadableType.String, map.getType("string"));
    assertEquals(ReadableType.Number, map.getType("double"));
    assertEquals(ReadableType.Number, map.getType("int"));
    assertEquals(ReadableType.Map, map.getType("map"));
    assertEquals(ReadableType.Array, map.getType("array"));
    assertEquals(ReadableType.Boolean, map.getType("boolean"));
    assertEquals(ReadableType.Null, map.getType("null"));
  }

  public void testGetWrongTypeFromArray() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class)
        .returnArrayWithStringDoubleIntMapArrayBooleanNull();
    waitForBridgeAndUIIdle();

    List<ReadableArray> calls = mRecordingTestModule.getArrayCalls();
    assertEquals(1, calls.size());
    ReadableArray array = calls.get(0);

    assertUnexpectedTypeExceptionThrown(array, 0, "boolean");
    assertUnexpectedTypeExceptionThrown(array, 1, "string");
    assertUnexpectedTypeExceptionThrown(array, 2, "array");
    assertUnexpectedTypeExceptionThrown(array, 3, "double");
    assertUnexpectedTypeExceptionThrown(array, 4, "map");
    assertUnexpectedTypeExceptionThrown(array, 5, "array");
  }

  public void testGetWrongTypeFromMap() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class)
        .returnMapWithStringDoubleIntMapArrayBooleanNull();
    waitForBridgeAndUIIdle();

    List<ReadableMap> calls = mRecordingTestModule.getMapCalls();
    assertEquals(1, calls.size());
    ReadableMap map = calls.get(0);

    assertUnexpectedTypeExceptionThrown(map, "string", "double");
    assertUnexpectedTypeExceptionThrown(map, "double", "map");
    assertUnexpectedTypeExceptionThrown(map, "int", "boolean");
    assertUnexpectedTypeExceptionThrown(map, "map", "array");
    assertUnexpectedTypeExceptionThrown(map, "array", "boolean");
    assertUnexpectedTypeExceptionThrown(map, "boolean", "string");
  }

  public void testArrayOutOfBoundsExceptionThrown() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnArrayWithBasicTypes();
    waitForBridgeAndUIIdle();

    List<ReadableArray> calls = mRecordingTestModule.getArrayCalls();
    assertEquals(1, calls.size());
    ReadableArray array = calls.get(0);
    assertNotNull(array);

    assertArrayOutOfBoundsExceptionThrown(array, -1, "boolean");
    assertArrayOutOfBoundsExceptionThrown(array, -1, "string");
    assertArrayOutOfBoundsExceptionThrown(array, -1, "double");
    assertArrayOutOfBoundsExceptionThrown(array, -1, "int");
    assertArrayOutOfBoundsExceptionThrown(array, -1, "map");
    assertArrayOutOfBoundsExceptionThrown(array, -1, "array");

    assertArrayOutOfBoundsExceptionThrown(array, 10, "boolean");
    assertArrayOutOfBoundsExceptionThrown(array, 10, "string");
    assertArrayOutOfBoundsExceptionThrown(array, 10, "double");
    assertArrayOutOfBoundsExceptionThrown(array, 10, "int");
    assertArrayOutOfBoundsExceptionThrown(array, 10, "map");
    assertArrayOutOfBoundsExceptionThrown(array, 10, "array");
  }

  public void testNoSuchKeyExceptionThrown() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithBasicTypes();
    waitForBridgeAndUIIdle();

    List<ReadableMap> calls = mRecordingTestModule.getMapCalls();
    assertEquals(1, calls.size());
    ReadableMap map = calls.get(0);
    assertNotNull(map);

    assertNoSuchKeyExceptionThrown(map, "noSuchKey", "double");
    assertNoSuchKeyExceptionThrown(map, "noSuchKey", "int");
    assertNoSuchKeyExceptionThrown(map, "noSuchKey", "map");
    assertNoSuchKeyExceptionThrown(map, "noSuchKey", "array");
    assertNoSuchKeyExceptionThrown(map, "noSuchKey", "boolean");
    assertNoSuchKeyExceptionThrown(map, "noSuchKey", "string");
  }

  public void testIntOutOfRangeThrown() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnArrayWithLargeInts();
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithLargeInts();
    waitForBridgeAndUIIdle();

    assertEquals(1, mRecordingTestModule.getArrayCalls().size());
    assertEquals(1, mRecordingTestModule.getMapCalls().size());

    ReadableArray array = mRecordingTestModule.getArrayCalls().get(0);
    assertNotNull(array);

    ReadableMap map = mRecordingTestModule.getMapCalls().get(0);
    assertNotNull(map);

    assertEquals(ReadableType.Number, array.getType(0));
    assertUnexpectedTypeExceptionThrown(array, 0, "int");
    assertEquals(ReadableType.Number, array.getType(1));
    assertUnexpectedTypeExceptionThrown(array, 1, "int");

    assertEquals(ReadableType.Number, map.getType("first"));
    assertUnexpectedTypeExceptionThrown(map, "first", "int");
    assertEquals(ReadableType.Number, map.getType("second"));
    assertUnexpectedTypeExceptionThrown(map, "second", "int");
  }

  public void testMapMerging() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapForMerge1();
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapForMerge2();
    waitForBridgeAndUIIdle();

    List<ReadableMap> maps = mRecordingTestModule.getMapCalls();
    assertEquals(2, maps.size());

    WritableMap dest = new WritableNativeMap();
    dest.merge(maps.get(0));
    dest.merge(maps.get(1));

    assertTrue(dest.hasKey("a"));
    assertTrue(dest.hasKey("b"));
    assertTrue(dest.hasKey("c"));
    assertTrue(dest.hasKey("d"));
    assertTrue(dest.hasKey("e"));
    assertTrue(dest.hasKey("f"));
    assertTrue(dest.hasKey("newkey"));

    assertEquals("overwrite", dest.getString("a"));
    assertEquals(41, dest.getInt("b"));
    assertEquals("string", dest.getString("c"));
    assertEquals(77, dest.getInt("d"));
    assertTrue(dest.isNull("e"));
    assertEquals(3, dest.getArray("f").size());
    assertEquals("newvalue", dest.getString("newkey"));
  }

  public void testMapAccessibleAfterMerge() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapForMerge1();
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapForMerge2();
    waitForBridgeAndUIIdle();

    List<ReadableMap> maps = mRecordingTestModule.getMapCalls();
    assertEquals(2, maps.size());

    WritableMap dest = new WritableNativeMap();
    dest.merge(maps.get(0));
    dest.merge(maps.get(1));

    ReadableMap source = maps.get(1);

    assertTrue(source.hasKey("a"));
    assertTrue(source.hasKey("d"));
    assertTrue(source.hasKey("e"));
    assertTrue(source.hasKey("f"));
    assertTrue(source.hasKey("newkey"));

    assertFalse(source.hasKey("b"));
    assertFalse(source.hasKey("c"));

    assertEquals("overwrite", source.getString("a"));
    assertEquals(77, source.getInt("d"));
    assertTrue(source.isNull("e"));
    assertEquals(3, source.getArray("f").size());
    assertEquals("newvalue", source.getString("newkey"));
  }

  public void testMapIterateOverMapWithBasicTypes() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithBasicTypes();
    waitForBridgeAndUIIdle();

    List<ReadableMap> calls = mRecordingTestModule.getMapCalls();
    assertEquals(1, calls.size());
    ReadableNativeMap map = (ReadableNativeMap) calls.get(0);
    assertNotNull(map);

    ReadableMapKeySetIterator mapIterator = map.keySetIterator();
    Set<String> keys = new HashSet<String>();
    while (mapIterator.hasNextKey()) {
      keys.add(mapIterator.nextKey());
    }

    Set<String> expectedKeys = new HashSet<String>(
        Arrays.asList("stringKey", "doubleKey", "intKey", "booleanKey", "nullKey"));
    assertEquals(keys, expectedKeys);
  }

  public void testMapIterateOverNestedMaps() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnNestedMap();
    waitForBridgeAndUIIdle();

    List<ReadableMap> calls = mRecordingTestModule.getMapCalls();
    assertEquals(1, calls.size());
    ReadableNativeMap map = (ReadableNativeMap) calls.get(0);
    assertNotNull(map);

    ReadableMapKeySetIterator firstLevelIterator = map.keySetIterator();
    String firstLevelKey = firstLevelIterator.nextKey();
    assertEquals(firstLevelKey, "weHaveToGoDeeper");

    ReadableNativeMap secondMap = map.getMap("weHaveToGoDeeper");
    ReadableMapKeySetIterator secondLevelIterator = secondMap.keySetIterator();
    String secondLevelKey = secondLevelIterator.nextKey();
    assertEquals(secondLevelKey, "inception");
    assertTrue(secondMap.getBoolean(secondLevelKey));
  }

  public void testInvalidIteratorExceptionThrown() {
    mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class).returnMapWithBasicTypes();
    waitForBridgeAndUIIdle();

    List<ReadableMap> calls = mRecordingTestModule.getMapCalls();
    assertEquals(1, calls.size());
    ReadableNativeMap map = (ReadableNativeMap) calls.get(0);
    assertNotNull(map);

    ReadableMapKeySetIterator mapIterator = map.keySetIterator();
    while (mapIterator.hasNextKey()) {
      mapIterator.nextKey();
    }
    assertInvalidIteratorExceptionThrown(mapIterator);
  }

  public void testStringWithMultibyteUTF8Characters() {
    TestJSToJavaParametersModule jsModule =
        mCatalystInstance.getJSModule(TestJSToJavaParametersModule.class);
    jsModule.returnMapWithMultibyteUTF8CharacterString();
    jsModule.returnArrayWithMultibyteUTF8CharacterString();
    waitForBridgeAndUIIdle();

    List<ReadableMap> maps = mRecordingTestModule.getMapCalls();
    assertEquals(1, maps.size());

    ReadableMap map = maps.get(0);
    assertEquals("a", map.getString("one-byte"));
    assertEquals("\u00A2", map.getString("two-bytes"));
    assertEquals("\u20AC", map.getString("three-bytes"));
    assertEquals("\uD83D\uDE1C", map.getString("four-bytes"));
    assertEquals(
        "\u017C\u00F3\u0142\u0107 g\u0119\u015Bl\u0105 \u6211 \uD83D\uDE0E ja\u017A\u0107",
        map.getString("mixed"));

    List<ReadableArray> arrays = mRecordingTestModule.getArrayCalls();
    assertEquals(1, arrays.size());

    ReadableArray array = arrays.get(0);
    assertEquals("a", array.getString(0));
    assertEquals("\u00A2", array.getString(1));
    assertEquals("\u20AC", array.getString(2));
    assertEquals("\uD83D\uDE1C", array.getString(3));
    assertEquals(
        "\u017C\u00F3\u0142\u0107 g\u0119\u015Bl\u0105 \u6211 \uD83D\uDE0E ja\u017A\u0107",
        array.getString(4));
  }

  private void assertUnexpectedTypeExceptionThrown(
      ReadableArray array,
      int index,
      String typeToAskFor) {
    boolean gotException = false;
    try {
      arrayGetByType(array, index, typeToAskFor);
    } catch (UnexpectedNativeTypeException expected) {
      gotException = true;
    }

    assertTrue(gotException);
  }

  private void assertUnexpectedTypeExceptionThrown(
      ReadableMap map,
      String key,
      String typeToAskFor) {
    boolean gotException = false;
    try {
      mapGetByType(map, key, typeToAskFor);
    } catch (UnexpectedNativeTypeException expected) {
      gotException = true;
    }

    assertTrue(gotException);
  }

  private void assertArrayOutOfBoundsExceptionThrown(
      ReadableArray array,
      int index,
      String typeToAskFor) {
    boolean gotException = false;
    try {
      arrayGetByType(array, index, typeToAskFor);
    } catch (ArrayIndexOutOfBoundsException expected) {
      gotException = true;
    }

    assertTrue(gotException);
  }

  private void assertNoSuchKeyExceptionThrown(
      ReadableMap map,
      String key,
      String typeToAskFor) {
    boolean gotException = false;
    try {
      mapGetByType(map, key, typeToAskFor);
    } catch (NoSuchKeyException expected) {
      gotException = true;
    }

    assertTrue(gotException);
  }

  private static void assertInvalidIteratorExceptionThrown(
      ReadableMapKeySetIterator iterator) {
    boolean gotException = false;
    try {
      iterator.nextKey();
    } catch (InvalidIteratorException expected) {
      gotException = true;
    }

    assertTrue(gotException);
  }

  private void arrayGetByType(ReadableArray array, int index, String typeToAskFor) {
    if (typeToAskFor.equals("double")) {
      array.getDouble(index);
    } else if (typeToAskFor.equals("int")) {
      array.getInt(index);
    } else if (typeToAskFor.equals("string")) {
      array.getString(index);
    } else if (typeToAskFor.equals("array")) {
      array.getArray(index);
    } else if (typeToAskFor.equals("map")) {
      array.getMap(index);
    } else if (typeToAskFor.equals("boolean")) {
      array.getBoolean(index);
    } else {
      throw new RuntimeException("Unknown type: " + typeToAskFor);
    }
  }

  private void mapGetByType(ReadableMap map, String key, String typeToAskFor) {
    if (typeToAskFor.equals("double")) {
      map.getDouble(key);
    } else if (typeToAskFor.equals("int")) {
      map.getInt(key);
    } else if (typeToAskFor.equals("string")) {
      map.getString(key);
    } else if (typeToAskFor.equals("array")) {
      map.getArray(key);
    } else if (typeToAskFor.equals("map")) {
      map.getMap(key);
    } else if (typeToAskFor.equals("boolean")) {
      map.getBoolean(key);
    } else {
      throw new RuntimeException("Unknown type: " + typeToAskFor);
    }
  }

  private static class RecordingTestModule extends BaseJavaModule {

    private final List<Object[]> mBasicTypesCalls = new ArrayList<Object[]>();
    private final List<Object[]> mBoxedTypesCalls = new ArrayList<Object[]>();
    private final List<ReadableArray> mArrayCalls = new ArrayList<ReadableArray>();
    private final List<ReadableMap> mMapCalls = new ArrayList<ReadableMap>();
    private final List<Dynamic> mDynamicCalls = new ArrayList<Dynamic>();

    @Override
    public String getName() {
      return "Recording";
    }

    @ReactMethod
    public void receiveBasicTypes(String s, double d, boolean b, String nullableString) {
      mBasicTypesCalls.add(new Object[]{s, d, b, nullableString});
    }

    @ReactMethod
    public void receiveBoxedTypes(Integer i, Double d, Boolean b) {
      mBoxedTypesCalls.add(new Object[]{i, d, b});
    }

    @ReactMethod
    public void receiveArray(ReadableArray array) {
      mArrayCalls.add(array);
    }

    @ReactMethod
    public void receiveMap(ReadableMap map) {
      mMapCalls.add(map);
    }

    @ReactMethod
    public void receiveDynamic(Dynamic dynamic) {
      mDynamicCalls.add(dynamic);
    }

    public List<Object[]> getBasicTypesCalls() {
      return mBasicTypesCalls;
    }

    public List<Object[]> getBoxedTypesCalls() {
      return mBoxedTypesCalls;
    }

    public List<ReadableArray> getArrayCalls() {
      return mArrayCalls;
    }

    public List<ReadableMap> getMapCalls() {
      return mMapCalls;
    }

    public List<Dynamic> getDynamicCalls() {
      return mDynamicCalls;
    }
  }
}