iOS Simulator or Real Device for Appium?

An trial formerly ran clean on the simulator, green across the plank. I go the same test to a existent iPhone, and it immediately fail. A swipe didn ’ t registry, a permission prompt appear recent, and the trial time out. Nothing in the codification had vary, yet the result had.

That moment make the trade-off clear. Simulators are fast and predictable, but real devices behave differently in fashion that matter.

This tutorial breaks down those differences and shows how I decide when simulators are enough and when real iOS devices are the only reliable option.

How does Appium work on iOS?

To understand this concept, all you want to cognise about the Client-Server Architecture of Appium.

• Appium Client:It render bindings in different languages and helps the clients to perform compulsory activeness on the devices.
• Appium Server:It ’ s a Node.js based server which helps to transmit with iOS and Android program and make session to interact with them.

Communication between guest and server:

1. The Appium guest (ex. Java/Python/C # etc.) sends a connexion petition to the appium server via JSON Wire protocol over HTTP.
2. Then the server creates a session as per the request and connects to the automation model like XCUITest.
3. The framework communicates to the end device like a simulator/emulator/real device.
4. After that, the end gimmick will perform the task on your coating under testing.
5. After performance of the test lawsuit, the end device sends a answer to the appium server for the previous asking.

Run Appium Tests on iOS Simulator

Set up the Environment

1. Download the IDE.

2. Start up an iOS simulator using XCode.

XCode provides a simulator for iPhone, iPad, and Apple watch besides.

Here, are few things to do for setting the simulator –

• First, launch XCode.
• Then launch the simulator. So, go toXcode & gt; Open Developer Tool & gt; Simulator

3. Download the latest version of appium client.

4. Install a supported programming language ’ s client library for appium. If you are using Python, then you have to download the Client because it supports appium ’ s WebDriver protocol.

5. Use the next bid to install it

pip install Appium-Python-Client

6. (a) Now, get the appium host console by double clicking on the appium file.

(b) Then depart the appium node server by tick the launch button.

Run the Appium Test

Now, the environment set-up is completed for the Appium trial. So, let ’ s get get with the examination!

1. First, download the source codification of the targeted app for testing. It will be better if the source code language chosen is Swift.

2. Now launch the XCode IDE and open the.xcodeprojfile inside the Swift folder.

3. Then you need the.app file and bundle id to run the test script on the simulator. The .app file can be found from below path –

/Library/Developer/CoreSimulator/Devices/ {{Device Code}} /data/Containers/Bundle/Application

4. After that, the appium test will search for the simulator ’ s details (Name, iOS version, ID). Thus we need to find out the xpath of different elements like the Search field. So, we will use Appium Inspector for this.

(a) Launch the appium inspector.

(b) Now it will research for the particular to build the xpath for the lookup battlefield.

(c) Xpath of Search field =“ //UIASearchBar [@ name= ’ Search ’] ”

5. Then, establish the.

6. Adjacent, run the undermentioned command to install the appium with npm.

npm install –g appium
Pro tip: Tools like SUSA can handle this autonomously — upload your app and get results without writing a single test script.

7. Now install appiumWebDriverAgent. It ’ s a WebDriver for iOS. You can discover it from the following directory:

/Applications/Appium.app/Contents/Resources/app/node_modules/appium/node_modules/appium-webdriver

Then run the bidding to install it:

mkdir -p Resources/WebDriverAgent.bundle ./Scripts/bootstrap.sh –d

8. Then test your WebDriver with follow hope capabilities-

DesiredCapabilities capabilities = new DesiredCapabilities (); capabilities.setCapability (MobileCapabilityType.PLATFORM_NAME, `` iOS ''); capabilities.setCapability (MobileCapabilityType.PLATFORM_VERSION, `` 7.1 ''); capabilities.setCapability (MobileCapabilityType.DEVICE_NAME, `` iPhone Simulator ''); capabilities.setCapability (MobileCapabilityType.APP, APP_NAME);

• First, you need to set a path for thebrowser_name _driver.exe file. Ex. chromedriver.exe
• Succeeding create an target of that browser ’ sDesiredCapabilitiesclass and pass it to the WebDriver instance.

9. After that write the test script.

App location for the following codification:Table_Search.pyis the tryout script, create in this directory-

$ Directory_Of_My_Choice

It is based on the snippet below. Here is a sampleSearch.swift.appfile inside the‘ TableSearchwithUISearchController/Swift ’folder within the above- mentioned directory identify$ Directoy_Of_My_Choice.

There is an in-built route in this example but you can use a combination ofos.path.abspath and os.path.dirname (__file__)to make it a path adjusted to your test file.

app = os.path.abspath (app) self.driver = webdriver.Remote (command_executor='http: //127.0.0.1:4723/wd/hub ', desired_capabilities= {'app ': app, 'platformName ': 'iOS ', 'platformVersion ': ' 9.2 ', 'deviceName ': 'iPhone 5s ', 'bundleId ': 'com.example.apple-samplecode.Search-swift'}) def test_search_field (self): # Search for an Apple device and click on it to view the details and navigate back # Find the search ingredient and perform send key activity search_element = self.driver.find_element_by_xpath (`` //UIASearchBar [@ name='Search '] '') search_element.send_keys (`` iPad '') sleep (2) # Get the xpath of first element first_element = self.driver.find_element_by_xpath (`` //UIAApplication [1] /UIAWindow [1] /UIATableView [1] /UIATableCell [1] /UIAStaticText [1] '') # Assert that the textbook match self.assertEqual ('iPad ', first_element.get_attribute ('name ')) # Perform click activeness first_element.click () slumber (2) # Click on hunting element self.driver.find_element_by_name (`` Search '') .click () def tearDown (self): self.driver.quit () if __name__ == '__main__ ': suite = unittest.TestLoader () .loadTestsFromTestCase (TableSearchTest) unittest.TextTestRunner (verbosity=2) .run (suite)

Go to the location advert in the paragraph App location for the following code to find the app

app = os.path.abspath (app) self.driver = webdriver.Remote (command_executor='http: //127.0.0.1:4723/wd/hub ', desired_capabilities= {'app ': app, 'platformName ': 'iOS ', 'platformVersion ': ' 9.2 ', 'deviceName ': 'iPhone 5s ', 'bundleId ': 'com.example.apple-samplecode.Search-swift'}) def test_search_field (self): # Search for an Apple gimmick and clink on it to view the details and navigate back # Find the lookup element and perform send keys action search_element = self.driver.find_element_by_xpath (`` //UIASearchBar [@ name='Search '] '') search_element.send_keys (`` iPad '') kip (2) # Get the xpath of first element first_element = self.driver.find_element_by_xpath (`` //UIAApplication [1] /UIAWindow [1] /UIATableView [1] /UIATableCell [1] /UIAStaticText [1] '') # Assert that the text lucifer self.assertEqual ('iPad ', first_element.get_attribute ('name ')) # Perform click action first_element.click () sleep (2) # Click on search element self.driver.find_element_by_name (`` Search '') .click () def tearDown (self): self.driver.quit () if __name__ == '__main__ ': suite = unittest.TestLoader () .loadTestsFromTestCase (TableSearchTest) unittest.TextTestRunner (verbosity=2) .run (suite)

10. Finally, run thehandwriting (.py file)and check the result.

Running Appium tests on Real iOS Devices

Running Appium exam on real iOS device expose hardware, OS, and user interaction doings that simulator can not reliably replicate.

Set up the environment

A mac device (macOS version 10.11 or higher than 10) and an iOS gimmick (iOS version 9.3 or higher) must be needed for this test. Then you have to install the following software in your macOS.

1. Install Homebrew for managing those missing package which Apple can ’ t. Command for installing this:

Bash brew install carthage

2. Install Carthage. It manages dependencies and includes binary frameworks for your project. So, run the Command:

brewage install carthage

3. Appium server is written in Node.js language. So, install Node for the Appium server and besides install NPM. You can install the appium server directly from NPM. Command:

brewage install node

4. Install Java and set up the environment for this.

5. Install Eclipse IDE for Java.

6. Install Maven. Command:

brew install champion

7. Install XCode 7 or higher. But it will be better if you are using XCode 11.

8. Install driver.

9. Install TestNG.

Run the Appium test

1. Launch the Appium waiter on the craved iOS device.

2. Now, bring the point of the iOS twist. The details includedevice name, iOS version and bundle ID. These details are needed to set the coveted appium capabilities and instantiation of the appium driver.

In this illustration we are examine the Google Chrome app on a real iOS gimmick. So, the bundle ID for Google chrome iscom.google.Chrome.

Note: In this instance XCUITest driver is used for. So, it ’ s compulsory to set the automationName to XCUITest.

3. Then write the. So, create a new project in Eclipse and make the required package and class libraries for this.

4. Finally, run the test script. It will make the Google Chrome app open on attached iOS devices.

Appium Test Script for Real iOS Device

import io.appium.java_client.ios.IOSDriver; import java.net.MalformedURLException; import java.net.URL; import org.junit.After; significance org.junit.Before; import org.junit.Test; import org.openqa.selenium.remote.DesiredCapabilities; public class Edition041_iOS_Real_Device {private IOSDriver driver; @ Before public void setUp () throws MalformedURLException {//Setting Desired Capabilities DesiredCapabilities capabilities = new DesiredCapabilities (); capabilities.setCapability (`` platformName '', `` iOS ''); capabilities.setCapability (`` platformVersion '', `` 12.4.7 ''); capabilities.setCapability (`` deviceName '', `` iPhone 7 ''); capabilities.setCapability (`` udid '', `` & lt; your iPhone ’ s udid & gt; ''); capabilities.setCapability (`` bundleId '', `` com.google.Chrome ''); capabilities.setCapability (`` xcodeOrgId '', `` & lt; your org id & gt; ''); capabilities.setCapability (`` xcodeSigningId '', `` & lt; your signing id & gt; ''); capabilities.setCapability (`` updatedWDABundleId '', `` com.google.chrome.ios ''); @ After public void tearDown () {if (driver! = null) {driver.quit ();}} @ Test public void testFindingAnElement () {driver.findElementByAccessibilityId (`` Login Screen '');}} driver = new IOSDriver & lt; & gt; (new URL (`` http: //localhost:4723/wd/hub ''), potentiality);}

Running Appium Tests on Simulator vs Real Device

Choosing between an for Appium testing immediately impacts test accuracy, coverage, and release confidence. The table below highlights how both approaches differ across key testing factors.

Talk to an Expert

Disadvantages of running Appium iOS Tests on Simulator?

iOS simulators are useful for early validation, but they introduce gaps that limit their reliability for release-critical examination.

• Inaccurate demeanor:Simulators approximate taps, swipes, and multi-touch interactions apply mouse or trackpad remark. This often hides gesture failures that occur on real trace screens.
• Missing hardware and sensor validation:Simulators do not replicate camera deportment, GPS accuracy, biometric authentication,, or device-specific sensors, leading to incomplete coverage.

• Unrealistic performance metric:Simulators run on background hardware, disguise memory pressure, CPU throttling, and rendering delays that affect real iPhones.
• Limited OS-level behavior:System alerts, permission prompts, background app handling, and gap behave differently on simulators, causing false positives in tryout results.
• Mistaken self-confidence before release:Tests may pass consistently on simulator while failing on existent device, creating a gap between test success and genuine user experience.

Advantages of running Appium iOS Tests on Real Devices?

Existent devices provide production-aligned validation, making them all-important for mature and dependable iOS testing.

• True user interaction validation:Real devices accurately trance touch responsiveness, gesture sensitivity, and screen behavior as users experience them.
• Hardware and OS pragmatism:Tests run against literal camera, detector,, notifications, and system dialogs, exposing issues simulator can not surface.
• Reliable performance penetration:Memory usage, app launch clip, brio, and responsiveness reflect real-world constraints, helping detect execution regression early.
• Accurate meshwork and environs deportment:Existent devices reveal issues caused by meshwork unevenness, ground processes, and OS-level resource management.
• High liberation confidence:Validating Appium test on real iOS devices ensure test results align with production behavior, reducing post-release failures and hotfixes.

Benefits of Appium Testing on BrowserStack App Automate

Appium testing on remove the mutual crack squad front when relying only on local setups or simulators, especially for real-world mobile behavior.

• It proffer cloud-based access to a wide range of real iOS and Android devices, including the latest and legacy models.
• It eliminates the overhead of sustain physical device labs, helping teams salve time and meet release deadline quicker.
• It countenance essay of native and hybrid mobile applications expend the Appium automation model on thou of existent devices.
• It supports execution, enabling faster feedback by lam multiple Appium tests simultaneously across device and OS version.
• Appium tests run on real wandering devices reflect literal exploiter conditions, make tryout results more reliable and production-ready.
• It save time and helps to converge deadlines as tight as possible.
• It enables you to and hybrid mobile applications habituate the Appium mechanization framework on thousands of existent device.
• Appium tests are best run on real mobile devices because monitoring apps in leads to 100 % accurate results.

Conclusion

Apple devices continue to see strong market adoption, making dependable iOS prove a non-negotiable requirement. Appium is wide used for iOS testing on both because it supports multiple iOS adaptation, enables fast performance, and works across a broad range of testing scenarios.

For production-ready validation, real iOS devices remain the most dependable option. A real twist cloud simplifies this process by allowing teams to take the required device, configure Appium capabilities, and run without managing physical substructure.

This attack ensures test results reflect existent user behavior before an app hit the App Store.

Related Guides