Discussion on Selenide Appium - Mutated Java Appium Client by Amuthan Sakthivel | Testμ 2023

:iphone::sparkles: Master Selenide Appium!

Elevate your app testing with this mutation of Appium Java Client.

Discover concise, fluent, and readable tests. :rocket:

Still not registered? Hurry up and grab your free tickets: Register Now!

If you have already registered and up for the session, feel free to post your questions in the thread below :point_down:

Here are some Q&As from the session!

How does the mutation of the Java Appium Client in Selenide Appium enhance the capabilities and performance of mobile test automation?

Amuthan: It makes testing easy without slowing down performance. You save time writing tests, and they’re easier to read. The Java Appium client in Selenide Appium provides shortcuts so you can focus on testing, not technical details. It doesn’t affect performance; it improves code quality.

What impact does Selenide Appium have on the readability and structure of test scripts?

Amuthan: I’ve been using Appium for a long time, and I’ve seen how it evolves rapidly, which can be challenging to keep up with. Ensuring code works across different devices with varying specifications is complex. However, in our organization, adopting Selenide Appium has significantly improved test readability and our testing speed. Before, we could only create 1 or 2 scripts per day, but now we manage 4 to 8 scripts daily, making our testing process faster and more efficient.

Could you discuss a scenario where this combination facilitated cross-platform testing, saving time and effort?

Amuthan: Yes. Selenide can be used for automating both Android and iOS, and I can personally vouch for its effectiveness. I’ve used it in my personal and office projects, and it has consistently saved us a lot of time when creating tests. I highly recommend giving it a try.

Can you elaborate on some of the key mutations or enhancements that set Selenide Appium apart from the traditional Appium Client?

Amuthan: Sure, we can call these enhancements “mutations.” Without altering Appium itself, we’ve crafted adaptable wrappers. Launching the app is simplified using provider classes and the Webdriver provider interface. Our wrappers manage sessions and support parallel test execution, improving code clarity and readability. Plus, you can effortlessly switch back to Appium using AppiumDriverRunner.getDriver() if Selenide lacks a specific capability.

Now, let’s see some of the unanswered questions!

What is Selenide Appium, and how does it differ from a standard Java Appium client?

What is the most difficult scenario to test with Selenide Appium?

Do you need a server machine to run tests on Appium?

Could you please provide more details about your experience using the mutated Java Appium client with Selenide for mobile app testing? What specific advantages or challenges have you encountered by combining these technologies?

What advantage do Selenide have over Appium?

What Appium alternatives we have?

Hi there,

If you couldn’t catch the session live, don’t worry! You can watch the recording here:

Additionally, we’ve got you covered with a detailed session blog:


I would like to share my thoughts on this query as I actively attend this session.

Combining Appium and Selenide for mobile app testing can offer advantages like a unified testing framework, simplified test code, and rich assertions. However, it may involve challenges related to a learning curve, integration complexity, maintaining compatibility, and potential limitations of the Appium mutated client.


Being an active participant in this session, I would like to respond to you with my point of view.

Selenide offers advantages over Appium in terms of simplified test code, concise syntax, and rich assertions, making mobile app testing more efficient and easier to manage.

Hope this information was helpful.


To answer your question I would like to share my thoughts here.

There are several alternatives to Appium for mobile app testing, including Espresso, Detox, XCUITest, Calabash, and UI Automator. Each of these tools has its own features and capabilities, making it essential to evaluate them based on your specific testing requirements and project constraints.

Selenide Appium is a testing framework that combines the capabilities of two popular testing tools: Selenide and Appium. It is primarily used for mobile app testing, allowing you to write automated tests for mobile applications on Android and iOS devices. Selenide is a wrapper for Selenium, simplifying the interaction with web applications, while Appium is a widely used tool for mobile app automation.

Here’s how Selenide Appium differs from a standard Java Appium client:

  1. Ease of Use: Selenide Appium aims to provide a more user-friendly and concise API for mobile app testing. It simplifies the test code and reduces boilerplate code, making it easier for testers to write and maintain test scripts.

  2. Fluent and Readable Syntax: Selenide, which Selenide Appium is built upon, is known for its fluent and readable syntax. Selenide Appium inherits these qualities, resulting in more human-readable test scripts that are easier to understand and maintain.

  3. Integration with Selenide Features: Selenide Appium leverages Selenide’s features and capabilities, such as automatic waiting for elements to appear, built-in WebDriver management, and reporting, which are not as readily available in a standard Java Appium client.

  4. Cross-Platform Testing: Selenide Appium is suitable for cross-platform mobile app testing, allowing you to write tests that can be executed on both Android and iOS devices without significant code changes.

  5. Integrated Test Runner Support: Selenide Appium supports popular test runners like TestNG and JUnit, making it easy to integrate mobile app testing into your existing testing infrastructure.

  6. Improved Debugging: Selenide Appium provides better error messages and debugging support, making it easier to identify and resolve issues during test script development.


The difficulty of testing scenarios with Selenide Appium, like any other testing framework, can vary depending on the specific application and the test objectives. However, there are some common scenarios that tend to be more challenging to test in the context of mobile app automation using Selenide Appium:

  1. Complex Gestures and Interactions: Testing scenarios that involve complex gestures like pinch, zoom, multi-finger taps, or swipes in specific patterns can be challenging. These interactions may require precise coordination and synchronization between different touch events, which can be tricky to automate accurately.

  2. Dynamic Content and Timing: Mobile apps often contain dynamically changing content or elements that appear or disappear based on user interactions. Testing such scenarios, where you need to handle dynamic waits and adapt to changing conditions, can be more complex.

  3. Cross-Platform Compatibility: Ensuring that your mobile app tests work correctly on both Android and iOS platforms can be challenging. Handling platform-specific differences in UI elements, behavior, or layout requires careful consideration and conditional logic.

  4. Native and Hybrid Apps: Testing hybrid apps, which combine both native and web components, can be more complex as you need to switch between native and web contexts. Managing this transition and interacting with elements in both contexts can be challenging.

  5. Performance and Load Testing: Performance testing, such as measuring app responsiveness under varying loads, can be challenging with Selenide Appium. It may require additional tools and techniques to simulate and monitor performance metrics effectively.

In these challenging scenarios, careful test design, synchronization strategies, and use of advanced Appium capabilities become crucial.

Additionally, effective error handling and reporting are essential to identify and diagnose issues during testing. To address such challenges, it’s often helpful to work closely with app developers, gather detailed requirements, and consider the use of third-party tools and libraries that extend the capabilities of Selenide Appium.

Appium is a mobile app automation framework that allows you to write and execute tests for mobile applications on real devices or emulators/simulators. Whether you need a server machine to run tests on Appium depends on how you intend to set up your testing environment.

Here are the two common approaches to running Appium tests:

  1. Local Machine Testing: In this scenario, you can set up and run Appium tests on your local development machine. You don’t necessarily need a dedicated server for this. You can install Appium, set up your test project, connect to physical devices, or configure emulators/simulators, and run tests locally. Many developers and testers start with local testing for small-scale or development-level testing.

  2. Remote Testing (Cloud Testing): For large-scale or distributed testing, you may choose to run Appium tests on remote servers or cloud-based testing platforms. These platforms provide a range of real devices and emulators/simulators on which you can execute your tests. In this case, you do not need to set up your own server machine; you can use the infrastructure provided by the cloud testing service.

In either case, it’s essential to ensure that your local machine or server machine meets the necessary system requirements, which can include specific versions of operating systems, Appium, and mobile device emulators or simulators. The choice between running tests locally or in the cloud will depend on factors like the scale of testing, device diversity, and the specific needs of your testing project.

To summarize, while you can run Appium tests on your local machine, you may also opt for remote testing on cloud-based platforms that offer pre-configured server environments, saving you the trouble of setting up and maintaining a dedicated server for testing.