@react-native-firebase/app 26.4.0 → 27.1.0

package/android/src/test/java/io/invertase/firebase/common/UniversalFirebasePreferencesTest.kt

@@ -0,0 +1,217 @@
+package io.invertase.firebase.common
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.Log
+import io.invertase.firebase.app.ReactNativeFirebaseApp
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.mockStatic
+import org.mockito.Mockito.never
+import org.mockito.Mockito.times
+import org.mockito.Mockito.verify
+import org.mockito.Mockito.verifyNoMoreInteractions
+import org.mockito.Mockito.`when`
+import java.lang.reflect.Modifier
+
+/** Plain JUnit4 + Mockito coverage for universal preferences (AndroidTest-AD-1). */
+class UniversalFirebasePreferencesTest {
+  @Test
+  fun javaVisibleApiPreservesConstructorSingletonAndExactMethodTypes() {
+    val preferencesClass = UniversalFirebasePreferences::class.java
+    val constructor = preferencesClass.getConstructor()
+    val sharedInstanceMethod = preferencesClass.getMethod("getSharedInstance")
+
+    assertTrue(Modifier.isPublic(constructor.modifiers))
+    assertFalse(Modifier.isFinal(preferencesClass.modifiers))
+    assertTrue(Modifier.isStatic(sharedInstanceMethod.modifiers))
+    assertEquals(preferencesClass, sharedInstanceMethod.returnType)
+    assertSame(
+      UniversalFirebasePreferences.getSharedInstance(),
+      UniversalFirebasePreferences.getSharedInstance(),
+    )
+    assertEquals(
+      Boolean::class.javaPrimitiveType,
+      preferencesClass.getMethod("contains", String::class.java).returnType,
+    )
+    assertEquals(
+      Void.TYPE,
+      preferencesClass
+        .getMethod("setBooleanValue", String::class.java, Boolean::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Boolean::class.javaPrimitiveType,
+      preferencesClass
+        .getMethod("getBooleanValue", String::class.java, Boolean::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Void.TYPE,
+      preferencesClass
+        .getMethod("setIntValue", String::class.java, Int::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Int::class.javaPrimitiveType,
+      preferencesClass
+        .getMethod("getIntValue", String::class.java, Int::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Void.TYPE,
+      preferencesClass
+        .getMethod("setLongValue", String::class.java, Long::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Long::class.javaPrimitiveType,
+      preferencesClass
+        .getMethod("getLongValue", String::class.java, Long::class.javaPrimitiveType)
+        .returnType,
+    )
+    assertEquals(
+      Void.TYPE,
+      preferencesClass
+        .getMethod("setStringValue", String::class.java, String::class.java)
+        .returnType,
+    )
+    assertEquals(
+      String::class.java,
+      preferencesClass
+        .getMethod("getStringValue", String::class.java, String::class.java)
+        .returnType,
+    )
+    assertEquals(Void.TYPE, preferencesClass.getMethod("clearAll").returnType)
+    assertEquals(
+      SharedPreferences.Editor::class.java,
+      preferencesClass.getMethod("remove", String::class.java).returnType,
+    )
+    preferencesClass.declaredMethods
+      .filterNot { Modifier.isStatic(it.modifiers) || Modifier.isPrivate(it.modifiers) }
+      .forEach { method ->
+        assertFalse("${method.name} must remain overridable", Modifier.isFinal(method.modifiers))
+      }
+  }
+
+  @Test
+  fun lazyPreferencesUseApplicationContextFileAndModeOnce() {
+    val preferences = mock(SharedPreferences::class.java)
+    val applicationContext = mock(Context::class.java)
+    `when`(
+      applicationContext.getSharedPreferences("io.invertase.firebase", Context.MODE_PRIVATE),
+    ).thenReturn(preferences)
+    `when`(preferences.contains("present")).thenReturn(true)
+
+    val previous: Context? = ReactNativeFirebaseApp.getApplicationContext()
+    mockStatic(Log::class.java).use {
+      ReactNativeFirebaseApp.setApplicationContext(applicationContext)
+    }
+    try {
+      val subject = UniversalFirebasePreferences()
+
+      assertTrue(subject.contains("present"))
+      assertTrue(subject.contains("present"))
+
+      verify(applicationContext, times(1))
+        .getSharedPreferences("io.invertase.firebase", Context.MODE_PRIVATE)
+      verify(preferences, times(2)).contains("present")
+    } finally {
+      mockStatic(Log::class.java).use {
+        ReactNativeFirebaseApp.setApplicationContext(previous)
+      }
+    }
+  }
+
+  @Test
+  fun scalarGettersDelegateAndReturnStoredValues() {
+    val preferences = mock(SharedPreferences::class.java)
+    val subject = subjectWith(preferences)
+    `when`(preferences.contains("present")).thenReturn(true)
+    `when`(preferences.contains("missing")).thenReturn(false)
+    `when`(preferences.getBoolean("boolean", false)).thenReturn(true)
+    `when`(preferences.getInt("integer", 0)).thenReturn(42)
+    `when`(preferences.getLong("long", 0L)).thenReturn(4_294_967_296L)
+    `when`(preferences.getString("string", "fallback")).thenReturn("value")
+
+    assertTrue(subject.contains("present"))
+    assertFalse(subject.contains("missing"))
+    assertTrue(subject.getBooleanValue("boolean", false))
+    assertEquals(42, subject.getIntValue("integer", 0))
+    assertEquals(4_294_967_296L, subject.getLongValue("long", 0L))
+    assertEquals("value", subject.getStringValue("string", "fallback"))
+  }
+
+  @Test
+  fun scalarSettersAndClearApplyAsynchronously() {
+    val preferences = mock(SharedPreferences::class.java)
+    val editor = mock(SharedPreferences.Editor::class.java)
+    val subject = subjectWith(preferences)
+    `when`(preferences.edit()).thenReturn(editor)
+    `when`(editor.putBoolean("boolean", true)).thenReturn(editor)
+    `when`(editor.putInt("integer", 42)).thenReturn(editor)
+    `when`(editor.putLong("long", 4_294_967_296L)).thenReturn(editor)
+    `when`(editor.putString("string", "value")).thenReturn(editor)
+    `when`(editor.clear()).thenReturn(editor)
+
+    subject.setBooleanValue("boolean", true)
+    subject.setIntValue("integer", 42)
+    subject.setLongValue("long", 4_294_967_296L)
+    subject.setStringValue("string", "value")
+    subject.clearAll()
+
+    verify(editor).putBoolean("boolean", true)
+    verify(editor).putInt("integer", 42)
+    verify(editor).putLong("long", 4_294_967_296L)
+    verify(editor).putString("string", "value")
+    verify(editor).clear()
+    verify(editor, times(5)).apply()
+    verify(editor, never()).commit()
+    verifyNoMoreInteractions(editor)
+  }
+
+  @Test
+  fun removeReturnsEditorWithoutApplyingOrCommitting() {
+    val preferences = mock(SharedPreferences::class.java)
+    val editor = mock(SharedPreferences.Editor::class.java)
+    val subject = subjectWith(preferences)
+    `when`(preferences.edit()).thenReturn(editor)
+    `when`(editor.remove("obsolete")).thenReturn(editor)
+
+    assertSame(editor, subject.remove("obsolete"))
+
+    verify(preferences).edit()
+    verify(editor).remove("obsolete")
+    verify(editor, never()).apply()
+    verify(editor, never()).commit()
+    verifyNoMoreInteractions(editor)
+  }
+
+  private fun subjectWith(preferences: SharedPreferences): UniversalFirebasePreferences {
+    val subject = UniversalFirebasePreferences()
+    val field = UniversalFirebasePreferences::class.java.getDeclaredField("preferences")
+    field.isAccessible = true
+    field.set(subject, preferences)
+    return subject
+  }
+}

package/android/src/test/java/io/invertase/firebase/commoncompat/ReactNativeFirebaseModuleJavaCompatibilityTest.java

@@ -0,0 +1,176 @@
+package io.invertase.firebase.commoncompat;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import io.invertase.firebase.common.ReactNativeFirebaseModule;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import org.junit.Test;
+import org.mockito.MockedStatic;
+
+/** Compile-time and reflection contract for external Java subclasses and callers. */
+public class ReactNativeFirebaseModuleJavaCompatibilityTest {
+  @Test
+  public void outerClassPreservesConstructorsMethodsAndModifiers() throws Exception {
+    assertTrue(Modifier.isPublic(ReactNativeFirebaseModule.class.getModifiers()));
+    assertFalse(Modifier.isFinal(ReactNativeFirebaseModule.class.getModifiers()));
+
+    Constructor<ReactNativeFirebaseModule> constructor =
+        ReactNativeFirebaseModule.class.getConstructor(ReactApplicationContext.class, String.class);
+    assertTrue(Modifier.isPublic(constructor.getModifiers()));
+
+    assertOpen("initialize");
+    assertOpen("invalidate");
+    assertOpen("onCatalystInstanceDestroy");
+    assertOpen("getName");
+    assertOpen("getConstants");
+    assertFinal("getExecutor");
+    assertFinal("getTransactionalExecutor");
+    assertFinal("getTransactionalExecutor", String.class);
+    assertFinal("removeEventListeningExecutor", String.class);
+
+    assertTrue(
+        ReactNativeFirebaseModule.class
+            .getMethod("onCatalystInstanceDestroy")
+            .isAnnotationPresent(Deprecated.class));
+
+    Method constants = ReactNativeFirebaseModule.class.getMethod("getConstants");
+    assertEquals(Map.class, constants.getReturnType());
+    ParameterizedType genericReturn = (ParameterizedType) constants.getGenericReturnType();
+    assertEquals(String.class, genericReturn.getActualTypeArguments()[0]);
+    assertEquals(Object.class, genericReturn.getActualTypeArguments()[1]);
+  }
+
+  @Test
+  public void staticHelperDescriptorsRemainJavaCallable() throws Exception {
+    assertStatic("rejectPromiseWithExceptionMap", Promise.class, Exception.class);
+    assertStatic("rejectPromiseWithCodeAndMessage", Promise.class, String.class, String.class);
+    assertStatic(
+        "rejectPromiseWithCodeAndMessage",
+        Promise.class,
+        String.class,
+        String.class,
+        ReadableMap.class);
+    assertStatic(
+        "rejectPromiseWithCodeAndMessage", Promise.class, String.class, String.class, String.class);
+  }
+
+  @Test
+  public void staticOuterHelpersExecuteFromJava() {
+    Promise promise = mock(Promise.class);
+    WritableMap map = mock(WritableMap.class);
+    ReadableMap resolver = mock(ReadableMap.class);
+    try (MockedStatic<Arguments> arguments = mockStatic(Arguments.class)) {
+      when(Arguments.createMap()).thenReturn(map);
+
+      ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(
+          promise, "resolver-code", "message", resolver);
+      ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(promise, "plain-code", "message");
+      ReactNativeFirebaseModule.rejectPromiseWithCodeAndMessage(
+          promise, "native-code", "message", "native");
+
+      verify(promise).reject("resolver-code", "message", map);
+      verify(promise).reject("plain-code", "message", map);
+      verify(promise).reject("native-code", "message", map);
+    }
+
+    Exception exception = new Exception("failure");
+    try (MockedStatic<Arguments> arguments = mockStatic(Arguments.class)) {
+      when(Arguments.createMap()).thenReturn(map);
+
+      ReactNativeFirebaseModule.rejectPromiseWithExceptionMap(promise, exception);
+
+      verify(promise).reject(exception, map);
+      verify(map).putString("code", "unknown");
+      verify(map).putString("nativeErrorCode", "unknown");
+      verify(map).putString("message", "failure");
+      verify(map).putString("nativeErrorMessage", "failure");
+    }
+  }
+
+  @SuppressWarnings({"deprecation", "removal"})
+  private static final class ExternalJavaModule extends ReactNativeFirebaseModule {
+    ExternalJavaModule(ReactApplicationContext reactContext) {
+      super(reactContext, null);
+    }
+
+    @Override
+    public void initialize() {
+      super.initialize();
+    }
+
+    @Override
+    public void invalidate() {
+      super.invalidate();
+    }
+
+    @Override
+    public void onCatalystInstanceDestroy() {
+      super.onCatalystInstanceDestroy();
+    }
+
+    @Override
+    public String getName() {
+      return "ExternalJavaModule";
+    }
+
+    @Override
+    public Map<String, Object> getConstants() {
+      return super.getConstants();
+    }
+
+    ExecutorService executor(String identifier) {
+      return getTransactionalExecutor(identifier);
+    }
+  }
+
+  private static void assertOpen(String name, Class<?>... parameterTypes) throws Exception {
+    Method method = ReactNativeFirebaseModule.class.getMethod(name, parameterTypes);
+    assertTrue(Modifier.isPublic(method.getModifiers()));
+    assertFalse(Modifier.isFinal(method.getModifiers()));
+  }
+
+  private static void assertFinal(String name, Class<?>... parameterTypes) throws Exception {
+    Method method = ReactNativeFirebaseModule.class.getMethod(name, parameterTypes);
+    assertTrue(Modifier.isPublic(method.getModifiers()));
+    assertTrue(Modifier.isFinal(method.getModifiers()));
+  }
+
+  private static void assertStatic(String name, Class<?>... parameterTypes) throws Exception {
+    Method method = ReactNativeFirebaseModule.class.getMethod(name, parameterTypes);
+    assertTrue(Modifier.isPublic(method.getModifiers()));
+    assertTrue(Modifier.isStatic(method.getModifiers()));
+    assertEquals(void.class, method.getReturnType());
+  }
+}

package/android/src/test/java/io/invertase/firebase/commoncompat/ReactNativeFirebaseModuleKotlinCompatibilityTest.kt

@@ -0,0 +1,52 @@
+package io.invertase.firebase.commoncompat
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import com.facebook.react.bridge.ReactApplicationContext
+import io.invertase.firebase.common.ReactNativeFirebaseModule
+import org.junit.Assert.assertFalse
+import org.junit.Test
+import java.lang.reflect.Modifier
+
+/** Compile-time contract for a Kotlin subclass outside the production package. */
+class ReactNativeFirebaseModuleKotlinCompatibilityTest {
+  @Test
+  fun externalKotlinSubclassCanOverrideJavaVirtualSurface() {
+    assertFalse(Modifier.isFinal(ExternalKotlinModule::class.java.modifiers))
+  }
+
+  private open class ExternalKotlinModule(
+    reactContext: ReactApplicationContext?,
+  ) : ReactNativeFirebaseModule(reactContext, null) {
+    override fun initialize() {
+      super.initialize()
+    }
+
+    override fun invalidate() {
+      super.invalidate()
+    }
+
+    @Suppress("DEPRECATION")
+    override fun onCatalystInstanceDestroy() {
+      super.onCatalystInstanceDestroy()
+    }
+
+    override fun getName(): String = "ExternalKotlinModule"
+
+    override fun getConstants(): MutableMap<String, Any> = super.getConstants()
+  }
+}

package/android/src/test/java/io/invertase/firebase/interfaces/InterfacesJavaCompatibilityTest.java

@@ -0,0 +1,144 @@
+package io.invertase.firebase.interfaces;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import android.app.Activity;
+import android.content.Context;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.junit.Test;
+
+public class InterfacesJavaCompatibilityTest {
+  @Test
+  public void contextProvider_preservesExactAbstractGetterApi() {
+    Map<String, Method> methods = declaredMethods(ContextProvider.class);
+
+    assertEquals(
+        Arrays.asList("getActivity", "getApplicationContext", "getContext"),
+        methods.keySet().stream().sorted().collect(Collectors.toList()));
+    assertGetter(methods.get("getActivity"), Activity.class);
+    assertGetter(methods.get("getContext"), ReactContext.class);
+    assertGetter(methods.get("getApplicationContext"), Context.class);
+  }
+
+  @Test
+  public void nativeError_preservesExactAbstractGetterApi() {
+    Map<String, Method> methods = declaredMethods(NativeError.class);
+
+    assertEquals(
+        Arrays.asList(
+            "getErrorCode",
+            "getErrorMessage",
+            "getFirebaseAppName",
+            "getFirebaseServiceName",
+            "getUserInfo"),
+        methods.keySet().stream().sorted().collect(Collectors.toList()));
+    assertGetter(methods.get("getErrorCode"), String.class);
+    assertGetter(methods.get("getErrorMessage"), String.class);
+    assertGetter(methods.get("getFirebaseAppName"), String.class);
+    assertGetter(methods.get("getFirebaseServiceName"), String.class);
+    assertGetter(methods.get("getUserInfo"), WritableMap.class);
+  }
+
+  @Test
+  public void javaCanImplementAndCallContextProviderWithNulls() {
+    ContextProvider provider =
+        new ContextProvider() {
+          @Override
+          public Activity getActivity() {
+            return null;
+          }
+
+          @Override
+          public ReactContext getContext() {
+            return null;
+          }
+
+          @Override
+          public Context getApplicationContext() {
+            return null;
+          }
+        };
+
+    assertNull(provider.getActivity());
+    assertNull(provider.getContext());
+    assertNull(provider.getApplicationContext());
+  }
+
+  @Test
+  public void javaCanImplementAndCallNativeErrorWithNulls() {
+    NativeError error =
+        new NativeError() {
+          @Override
+          public String getErrorCode() {
+            return null;
+          }
+
+          @Override
+          public String getErrorMessage() {
+            return null;
+          }
+
+          @Override
+          public String getFirebaseAppName() {
+            return null;
+          }
+
+          @Override
+          public String getFirebaseServiceName() {
+            return null;
+          }
+
+          @Override
+          public WritableMap getUserInfo() {
+            return null;
+          }
+        };
+
+    assertNull(error.getErrorCode());
+    assertNull(error.getErrorMessage());
+    assertNull(error.getFirebaseAppName());
+    assertNull(error.getFirebaseServiceName());
+    assertNull(error.getUserInfo());
+  }
+
+  private static Map<String, Method> declaredMethods(Class<?> interfaceClass) {
+    assertTrue(interfaceClass.isInterface());
+    assertTrue(Modifier.isPublic(interfaceClass.getModifiers()));
+    assertTrue(Modifier.isAbstract(interfaceClass.getModifiers()));
+    return Arrays.stream(interfaceClass.getDeclaredMethods())
+        .collect(Collectors.toMap(Method::getName, Function.identity()));
+  }
+
+  private static void assertGetter(Method method, Class<?> returnType) {
+    assertEquals(returnType, method.getReturnType());
+    assertEquals(0, method.getParameterCount());
+    assertTrue(Modifier.isPublic(method.getModifiers()));
+    assertTrue(Modifier.isAbstract(method.getModifiers()));
+  }
+}

package/android/src/test/java/io/invertase/firebase/interfaces/NativeEventTest.kt

@@ -0,0 +1,56 @@
+package io.invertase.firebase.interfaces
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import com.facebook.react.bridge.WritableMap
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.lang.reflect.Modifier
+
+class NativeEventTest {
+  @Test
+  fun javaVisibleApi_hasExactAbstractGetterSignatures() {
+    val methods = NativeEvent::class.java.declaredMethods.associateBy { it.name }
+
+    assertEquals(setOf("getEventName", "getEventBody", "getFirebaseAppName"), methods.keys)
+    assertEquals(String::class.java, methods.getValue("getEventName").returnType)
+    assertEquals(WritableMap::class.java, methods.getValue("getEventBody").returnType)
+    assertEquals(String::class.java, methods.getValue("getFirebaseAppName").returnType)
+    methods.values.forEach { method ->
+      assertEquals(0, method.parameterCount)
+      assertTrue(Modifier.isAbstract(method.modifiers))
+    }
+  }
+
+  @Test
+  fun firebaseAppName_isNullableInKotlin() {
+    val event =
+      object : NativeEvent {
+        override fun getEventName(): String = "event_name"
+
+        override fun getEventBody(): WritableMap = error("Not used")
+
+        override fun getFirebaseAppName(): String? = null
+      }
+    val firebaseAppName: String? = event.getFirebaseAppName()
+
+    assertNull(firebaseAppName)
+  }
+}