MockK Android API 35 Requirement: NextLong Issue

Dec 4, 2025 by Alex Johnson 49 views

MockK 1.14.6 and Android API Level 35 Compatibility Issue

This article addresses a critical compatibility issue encountered in MockK version 1.14.6 related to the java.util.RandomGenerator.nextLong(long origin, long bound) method and its requirement for Android API level 35. This issue leads to crashes on Android devices running API levels lower than 35.

Understanding the Problem

The core of the issue lies in the utilization of the nextLong(long origin, long bound) method within the JvmSignatureValueGenerator.kt class in MockK. This method, introduced in Java 17, is not available in older Android API versions. Specifically, Android API levels below 35 lack this method in the java.util.Random class. Consequently, when MockK 1.14.6 attempts to use this method on devices with lower API levels, a NoSuchMethodError is thrown, causing the application to crash.

The Technical Details

The problematic code snippet can be found in JvmSignatureValueGenerator.kt within the MockK repository. The method generateSafeLong attempts to call nextLong(long origin, long bound) on an instance of java.util.Random. For Android devices with an API level less than 35, this call results in the following crash:

java.lang.NoSuchMethodError: No virtual method nextLong(JJ)J in class Ljava/util/Random; or its super classes (declaration of 'java.util.Random' appears in /apex/com.android.art/javalib/core-oj.jar)
    at io.mockk.impl.recording.JvmSignatureValueGenerator.generateSafeLong(JvmSignatureValueGenerator.kt:74)
    at io.mockk.impl.recording.JvmSignatureValueGenerator.instantiate(JvmSignatureValueGenerator.kt:48)
    at io.mockk.impl.recording.JvmSignatureValueGenerator.signatureValue(JvmSignatureValueGenerator.kt:35)
    at io.mockk.impl.recording.states.RecordingState.matcher(RecordingState.kt:46)
    at io.mockk.impl.recording.CommonCallRecorder.matcher(CommonCallRecorder.kt:52)

This error clearly indicates that the nextLong(JJ)J method is missing from the java.util.Random class in the Android runtime environment for API levels below 35.

Impact on Android Development

This issue significantly impacts Android developers using MockK for testing their applications. If an application targets Android API levels lower than 35 and uses MockK 1.14.6, it will likely encounter this crash during testing or even in production if the relevant code paths are executed. This can lead to unstable applications and a poor user experience.

Analyzing the Root Cause

The root cause of this issue is the introduction of a Java 17 feature (nextLong(long origin, long bound)) in MockK without proper consideration for compatibility with older Android API levels. While Java 17 offers performance improvements and new functionalities, it's crucial to ensure that libraries using these features maintain backward compatibility, especially in the Android ecosystem where a wide range of devices with varying API levels are prevalent.

The Importance of Backward Compatibility

In Android development, backward compatibility is paramount. Applications often need to support a range of Android versions to reach a broader audience. Introducing dependencies that require newer API levels can severely limit the application's reach and force developers to make difficult choices between using the latest libraries and supporting their existing user base. Therefore, library developers must carefully consider the minimum supported API level and avoid using features that are not available in those versions.

MockK's Role in Testing

MockK is a popular mocking library for Kotlin, widely used in Android development for writing unit and integration tests. Its purpose is to simplify the process of creating test doubles, allowing developers to isolate and test individual components of their applications. However, when MockK itself introduces compatibility issues, it undermines its core value proposition by making testing more difficult and error-prone.

Potential Solutions and Workarounds

Several potential solutions and workarounds can address this issue. These range from temporary fixes to more permanent solutions that require changes in MockK's codebase.

1. Downgrading MockK Version

The most immediate workaround is to downgrade to a MockK version prior to 1.14.6. Versions before this one do not use the problematic nextLong(long origin, long bound) method and are therefore not affected by this issue. While this resolves the crash, it also means foregoing any new features or bug fixes introduced in 1.14.6.

2. Conditional Code Execution

Another workaround is to conditionally execute the code that uses MockK 1.14.6 only on devices with Android API level 35 or higher. This can be achieved by checking the Build.VERSION.SDK_INT value at runtime. However, this approach adds complexity to the codebase and may not be feasible in all situations.

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) { // Android 35
    // Use MockK 1.14.6
} else {
    // Use a different approach or MockK version
}

3. Patching MockK Locally

For developers who need to use MockK 1.14.6 and cannot upgrade to API level 35, a local patch can be applied to the JvmSignatureValueGenerator.kt file. This involves replacing the call to nextLong(long origin, long bound) with an alternative implementation that is compatible with older API levels. This is a more advanced solution that requires familiarity with MockK's codebase and Kotlin.

4. MockK Library Update

The most ideal solution is for the MockK maintainers to release an updated version that addresses this compatibility issue. This could involve using a different method for generating random longs or providing a platform-specific implementation that uses the appropriate API for the current Android version. This ensures that MockK remains compatible with a wide range of Android devices and API levels.

MockK's Response and Future Plans

It is crucial for the MockK team to acknowledge this issue and provide a fix in a timely manner. This demonstrates a commitment to backward compatibility and ensures that developers can continue to rely on MockK for their testing needs. The resolution could involve either reverting the change that introduced the dependency on API level 35 or implementing a workaround that provides equivalent functionality on older Android versions.

Community Involvement

The MockK community can also play a role in resolving this issue. By reporting the bug, providing feedback, and even contributing code, developers can help ensure that MockK remains a robust and reliable testing library for Kotlin and Android development. Open-source projects thrive on community involvement, and this is an opportunity for developers to contribute to the betterment of the MockK library.

Best Practices for Library Development

This issue highlights the importance of following best practices for library development, particularly when targeting the Android platform.

1. Define Minimum Supported API Level

Clearly define the minimum Android API level that the library supports. This allows developers to make informed decisions about whether the library is suitable for their projects.

2. Test on Multiple API Levels

Thoroughly test the library on a range of Android API levels, including older versions. This helps identify compatibility issues early in the development process.

3. Use Conditional Compilation or Platform-Specific Implementations

When using features that are only available on newer API levels, consider using conditional compilation or platform-specific implementations. This allows the library to provide the same functionality on older platforms without requiring newer APIs.

4. Provide Clear Error Messages

If the library encounters an API that is not available on the current platform, provide a clear and informative error message. This helps developers understand the issue and take appropriate action.

5. Stay Informed About Platform Changes

Keep up-to-date with changes in the Android platform, including new API levels and deprecated features. This allows library developers to proactively address compatibility issues and ensure that their libraries remain up-to-date.

Conclusion

The java.util.RandomGenerator.nextLong(long origin, long bound) issue in MockK 1.14.6 highlights the challenges of maintaining compatibility in the Android ecosystem. While using newer Java features can provide performance benefits, it's essential to consider the impact on older Android versions. By understanding the root cause of the problem and implementing appropriate solutions, developers can mitigate the issue and ensure that their applications remain stable and reliable across a wide range of Android devices.

We hope this article has provided a comprehensive overview of the issue, its potential solutions, and best practices for library development. Remember to always prioritize backward compatibility and thoroughly test your applications on various Android API levels.

For more information on Android API levels and compatibility, please visit the official Android developer documentation.