With iOS edition 10, Apple introduced a new framework for automated user interface testing as part of XCTest (XCTest (UI)). This new framework allows you to write and or iPad without needing a Mac or any coding expertise. XCTest is easy to use and intuitive, making it the utter tool for anyone looking to take their app maturation skills to the next level. This usher will walk you through everything you need to know about XCTest, from installation to usage tips and trick. So, if you & # x27; re ready to start test your apps like a pro, keep reading!

XCTest and Its History

XCTest is Apple & # x27; s proprietary examination fabric. The WebDriver protocol is an industry measure for browser automation, and developers use XCTest to write unit tests for their apps. By compound these two technology, Apple has created a powerful and easy-to-use testing fabric perfect for anyone looking to.

XCTest was first announced at WWDC 2016, alongside the release of iOS 10. Before XCTest, automated examine on iOS was exclusively potential utilise the UI Automation fabric via instruments. UI Automation had some limitations, such as the need for a Mac and JavaScript coding expertise. With XCTest, Apple direct these limitations by allowing tests to run direct on an iPhone or iPad without needing a Mac.

Check out:

Benefits of apply XCTest

There are many benefits to habituate XCTest over other essay frameworks.

• First and foremost, XCTest is very leisurely to use and requires but Swift experience, which is a standard ontogenesis language. This makes it the double-dyed tool for anyone who wants to start indite automated tests but doesn & # x27; t know where to begin.
• Secondly, XCTest is rattling visceral and leisurely to understand. The syntax is like to English, making it simple to say and write tests.
• Finally, XCTest is a fully-fledged testing fabric that can be used for more than simply UI examine. With XCTest, you can write unit tests, performance tests, and even test your app & # x27; s compatibility with former apps and service.

Also Check:

Why was XCTest created?

XCTest was created to address these limit by grant tryout to be run directly on an iPhone or iPad. With XCTest, Apple wanted to develop a testing model that was easy to use and didn & # x27; t take any anterior coding expertise. They also wanted to ensure that XCTest was based on industry-standard protocols, such as the WebDriver protocol. By doing this, they confirmed that XCTest would get a wide ambit of resources and support usable.

XCTest vs. Other Testing Frameworks

XCTest provides many improvements over different. Here & # x27; s a little comparison between XCTest and its competitors:

XCTest vs. Appium

• XCTest is built into the iOS SDK, while Appium is a third-party library.
• XCTest only supports Apple product, while Appium can be used to essay Android and iOS apps.
• XCTest can write in Swift/Objective-C, but Appium does not provide Swift customer formally

XCTest vs. Calabash

• XCTest is built into the iOS SDK, while Calabash is a third-party library.
• XCTest only supports iOS apps, while Calabash can be utilise to test Android and iOS apps.
• XCTest doesn & # x27; t require a Mac, while Calabash make.

XCTest vs. EarlGrey

• Both XCTest and EarlGrey are built into the iOS SDK.
• EarlGrey supports iOS 8 and supra, while XCTest support iOS 10 and above.

XCTest vs UI Automation

• XCTest is built into the iOS SDK, while UI Automation is a deprecated framework.
• XCTest doesn & # x27; t demand a Mac, while UI Automation perform.

See:

How to get started with XCTest?

Now that you cognise what XCTest is and why it & # x27; s so good, you might be wondering how you can start using it. Luckily, getting started with XCTest is very easy! All you need is a Mac with Xcode installed, along with an iPhone or iPad to screen on.

Once you have those two things, you & # x27; re ready to start pen tests. To do so, simply unfastened Xcode and make a new project. When prompted, choose the & quot; iOS Unit Testing Bundle & quot; template. This will create a basic test suite for you to work with.

If you & # x27; re not conversant with how to write tests, don & # x27; t worry! The XCTest documentation is very comprehensive and easy to follow. Apple also provides respective sample tryout you can use as a start point.

Also See:

Once you & # x27; ve publish your tests, you can run them directly on your iPhone or iPad by selecting the & quot; Run & quot; push in Xcode. Xcode will then deploy your app to the device and run the trial. You can view the results of the tryout in the & quot; Test Navigator & quot; panel in Xcode.

Installing XCTest

XCTest is included in the Xcode 8.0+ release notes, so you will ask to feature Xcode 8.0 or afterward establish on your machine. You can check your Xcode edition by opening the & quot; About Xcode & quot; dialog from the Xcode menu. Once you have verified that you have the right version of Xcode install, you are ready to establish XCTest.

There are two ways to establish XCTest:

Download the latest version of Xcode from the Apple Developer site. Once Xcode is instal, you will find XCTest under the & quot; Developer Tools & quot; section.

Read:

Learning How to Use XCTest

Now that you have XCTest installed let & # x27; s aspect at how it works. The first thing you can do is make a new projection in Xcode. Once your undertaking is create, open the & quot; Tests & quot; folder and create a new file called & quot; MyFirstTest.swift & quot;.

XCTest uses the XCTest framework to write trial. This means that if you are conversant with compose unit tests in Xcode, then you will already be familiar with the syntax expend by XCTest. If you have never written a unit test before, don & # x27; t worry; it & # x27; s straightforward to learn.

The canonic construction of an XCTest is as follows:

import XCTest stratum MyFirstTest: XCTestCase {... override func frame-up () {… // Put setup codification here. This method is telephone before the invocation of each test method in the class. super.setUp ()} override func tearDown () {... // Put teardown code hither. This method is called after the invocation of each test method in the class. super.tearDown ()} func testExample () {… // This is an example of a functional tryout case. // Use XCTAssert and related mapping to control your tests make the right consequence} func testPerformanceExample () {… // This is an model of a performance test case. self.measure {… // Put the code you want to measure the time of here.}}}

As you can see, an XCTest consists of two parts: the frame-up () method and the testExample () method.

• The setUp () method is ring before each test is run. This is where you should put any code that needs to be executed before the test start. For model, if you want to launch an app before running a test, you would do it in the setUp () method.
• The testExample () method is where the existent examination codification goes. This is where you will write affirmation to ascertain that your app is behaving as expected.

Also read:

Executing your first trial

Now that you have write your first trial, it & # x27; s clip to run it. In Xcode, select the & quot; MyFirstTest.swift & quot; file and click on the & quot; Run & quot; button in the toolbar. This will found the simulator and execute your trial.

You should see the following output in the console:

Test Suite 'MyFirstTest ' started at 2017-02-12 23:04:21.191 Test Case '- [MyFirstTest testExample] ' started. t = 0.000s Start Test at 2017-02-12 23:04:21.192 t = 0.000s Set Up 2017-02-12 23:04:21.001 MyAppNameUITests-Runner.app/MyAppNameUITests-Runner (0x102829b00) launch t = 0.057s Launch Application (lldb)

This output present that the trial was successful. If the exam had failed, you would see an & quot; X & quot; adjacent to the test name in the console.

Read:

Assertions in XCTest

SUSA automates exploratory testing with persona-driven behavior, catching bugs that scripted automation misses.

Assertions are used to verify that a specific condition is true. If the condition is not valid, the assertion will fail, and the test will stop execution. Assertions are written using the XCTest framework, and they get the following syntax:

XCTAssert (condition, substance)

The condition is a Boolean value that determines whether the assertion passes or fails. The substance is an optional String that is display if the assertion betray.

Check out:

For illustration, let & # x27; s say we want to assert that 1 + 1 equal 2. We would write this assertion as postdate:

XCTAssert (1 + 1 == 2, `` 1 + 1 do not equal 2 '')

If the assertion passes, aught happens, and the exam uphold fulfill. If the assertion fails, the test will quit playing, and Xcode will print out the failure content. In this case, it would publish out & quot; 1 + 1 execute not equal 2 & quot;.

Also check out:

You can likewise use the XCTAssertEqual () method to insure if two values are equal. This is often used to check if a value that we get from our app is the expected value. For instance, let & # x27; s say we need to check if the textbook & quot; Hello World & quot; is displayed on a label in our app. We would write this assertion as follows:

XCTAssertEqual (label.text, `` Hello World '', `` Label textbook is not equal to 'Hello World ' '')

If the label & # x27; s text is indeed & quot; Hello World, & quot; then the assertion will pass, and the examination will continue executing. If the label & # x27; s text is anything other than & quot; Hello World, & quot; the assertion will fail, and the tryout will stop running.

Check:

Matchers in XCTest

In addition to assertions, XCTest has several built-in method that can be used for testing. These methods are called & quot; matchers, & quot; which are employ to find constituent in the UI. For example, let & # x27; s say we want to find a button with the schoolbook & quot; Hello World & quot; on it. We would use the following codification:

let button = app.buttons [`` Hello World '']

This code will find the first push in the app with the text & quot; Hello World & quot; on it. The return value is XCUIElement. Matchers can besides be used to assure if an constituent exists or does not exist. For example, let & # x27; s say we want to insure if a button with the schoolbook & quot; Hello World & quot; exists. We would use the following code:

XCTAssertTrue (app.buttons [`` Hello World ''] .exists, `` Button with text 'Hello World ' does not exist '')

If the button exists, the statement will surpass, and the test will continue executing. If the button execute not exist, the assertion will betray, and the test will halt running.

Also Check:

Debugging in XCTest

In addition to assertions and matcher, XCTest has several built-in method that can be used for debugging. For exemplar, let & # x27; s say we desire to publish out all of the elements in the UI. We would use the following code:

mark (app.debugDescription)

This code will print out a debug description of the app, include all of the UI factor. This can be helpful for trouble-shoot use.

Now that you cognise how to write and run a basic XCTest, let & # x27; s expression at some of the more advanced features that XCTest offers.

Recommended post:

Advanced Features of XCTest

XCTest has respective advanced features that can make your tests more rich and reliable. In this section, we will look at some of these features and how they can be used.

Waiting For Elements to Appear

One common issue when writing is that elements may not appear on the screen immediately after launching the app. This can befall for many reasons, such as slow mesh weather or lengthy database query. In these lawsuit, it is crucial to tell XCTest to wait for the element to appear before interacting with it. The return value is Boolean. This can be perform using the XCUIElement.waitForExistence (timeout:) method.

The following example shows how this method can be habituate to expect for a button to appear:

let button = app.buttons [`` Login ''] let universe = button.waitForExistence (timeout: 5) XCTAssertTrue (existence) // The button will now be guaranteed to exist so we can interact with it. button.tap ()

In this example, we are waiting for a push labeled & quot; Login & quot; to appear. If the button perform not appear within 5 seconds, an error will be cast, and the trial will fail.

See:

Accessing Elements That Are Not Visible on The Screen

Another common issue when writing tests is that some factor may not be visible on the blind when the tryout is run. This is because for various reasons, such as scrolling or opening a carte. In these cases, it is all-important to state XCTest to look for the element in the entire view hierarchy, not just the visible part of the screen. This can be done using the XCUIElement.descendants (matching:) method.

For example, suppose we have a button inside a coil view. The button is not visible on the screen when the test starts, but it can be accessed by scrolling down. We can use the following code to access the button:

let scrollView = app.scrollViews [`` Content ''] let button = scrollView.descendants (matching: .button) .element (boundBy: 0) button.tap ()

In this example, we use the descendants (matching:) method to find all descendant elements of type .button. We then use the component (boundBy:) method to get the initiative button in the listing. Finally, we tap on the button to trigger the action.

Also read:

Accessing Elements That Are Disabled

Another common issue when writing tests is that some element may be disabled when the examination starts. This can happen for several reasons, such as the user not being logged in or the app being in a specific state. In these cases, checking if the element is enabled earlier trying to interact with it is important. This can be do using the XCUIElement.isEnabled property.

The following example shows how this property can be used to check if a button is enable:

let button = app.buttons [`` Login ''] if button.isEnabled {button.tap ()} else {// The button is disabled, so we can not interact with it.}

In this example, we control if a button with the label & quot; Login & quot; is enabled. If it is, we tap on the button to trigger the action. If it is not, we do not try to interact with it.

Check out:

Accessing Elements That Do Not Exist Yet

Another common issue when writing tests is that some elements may not exist when the tryout begin. This can happen for respective reasons, such as the element only being displayed after a specific activeness is conduct. In these cases, see if the element exists is essential before trying to interact with it. This can be execute using the XCUIElement.exists property.

The following illustration shows how this property can be apply to check if an constituent subsist:

let element = app.buttons [`` Login ''] if element.exists {element.tap ()} else {// The element execute not survive, so we can not interact with it.}

In this example, we check if a push with the label & quot; Login & quot; exists. If it does, we tap on the button to trigger the action. If it does not, we do not try to interact with it.

Read:

Waiting for an Element to Appear

Another common issue when writing tests is that some elements may not appear directly when the trial starts. This can happen for several reasons, such as the element merely be expose after a specific action is taken. In these cause, look for the factor to appear before interacting with it is all-important. This can be perform using the XCUIElement.waitForExistence (timeout:) method.

The next example shows how this method can be used to wait for an component to appear:

let element = app.buttons [`` Login ''] let existence = element.waitForExistence (timeout: 30) XCTAssertTrue (macrocosm) // The element will now be guaranteed to exist. element.tap ()

In this example, we are waiting for a button label & quot; Login & quot; to appear. We use a timeout of 30 moment, which mean the method will regress after 30 mo still if the ingredient has not yet occurred. Once the method returns, we know that the component exists if the value was true, and we can tap on it to trigger the activity.

Check:

XCTest Better Practices

There are a few better praxis to continue in mind when using XCTest:

• Make sure that your app is in a testable province before running tests.
• Use the XCUIApplication form to launch your app.
• Use the XCUIDevice form to get information about the device that is being tested.
• Use the XCUIElement class to interact with elements on the blind.
• Check for the existence of factor before interacting with them.
• Wait for elements to seem before interacting with them.
• Use the isEnabled, isSelected, and isHittable properties to assure the province of elements.
• Use the XCUIElement.tap () method to trigger actions on elements.
• Use the XCUIElement.typeText () method to enter text into fields.
• Use the XCUIElement.swipeLeft (), .swipeRight (), .swipeUp (), and .swipeDown () method to perform gestures.
• Use the XCTestCase stratum to write your tryout.
• Use the apparatus () and tearDown () methods to prepare for and pick up after each test.
• Use the XCTContext to structure your tests.
• Use the XCTAssert and XCTFail methods to verify the results of your exam.
• Use the XCTestRecorder tool to give tests from user actions.
• Use the -logger argument to generate logs during test execution.
• Use the -resultBundlePath parameter to generate a report after test execution.
• Use the -onlyTesting parameter to delimit which tests should be run.
• Use the -skipTesting argument to specify which tests should not be run.
• Use the -- helper or -h parameters to get help with command-line options.

How do XCTest integrate with HeadSpin Platform?

HeadSpin provides a comprehensive set of services to help youdeliver amazing mobile experiences. One of these service is our mobile examination mechanization program, which allows you to write and run automated tests for your apps direct on your iPhone or iPad.

XCTest is a new improver to the HeadSpin platform that do it easy to get started with mobile test automation. With XCTest, you can write tests in Swift or Objective-C and run them on real devices without receive to jailbreak them. You can also use XCTest to make and manage a testing farm of devices, so you can run your trial in parallel on multiple devices at the like time.

In gain, XCTest integrates with popular CI/CD tools like Jenkins and Travis, so you can easily set up a pipeline.

To execute XCTest native tests in HeadSpin, postdate the step-by-step process below:

• Open the HeadSpin dashboard and set up your project.
• Add the HSConnect to your project and device.
• Write your tests in Swift or Objective-C.
• Run your tests on existent devices without jailbreaking them.
• Use XCTest to create and handle a quiz farm of devices in the HeadSpin fascia.
• Integrate with popular CI/CD tools like Jenkins and Travis.
• Get start with roving test automation today!

The Bottom Line

XCTest is a knock-down tool that can be use to automate tests for your iOS apps. It is elementary to use and very nonrational, create it the perfect tool for those new to coding. In addition, XCTest can care various common issues that can occur when indite tests, such as elements that are disabled or do not be yet. With XCTest, you can ensure that your app is functioning correctly and that your users are having the best experience possible.

XCTest Framework FAQs

Q: What type of test can I pen with XCTest?

A:You can use XCTest to indite unit, functional, andexecution tests. Unit tests focus on specific classes or methods, while functional tests examine the end-to-end functionality of your app. Performance examination measure the reactivity and stability of your app under different conditions.

Q: I & # x27; m having trouble getting XCTest to work. What can I do?

A: If you & # x27; re feature trouble getting started with XCTest, we recommend checking out the official documentation or watching one of the many helpful online tutorials. You can also ask for help on the Apple Developer Forums or Stack Overflow.

Q: Where can I learn more about utilize XCTest?

A: You can find more information about employ XCTest in the official documentation. You can also see one of the many helpful tutorials available online. Finally, you can ask for supporter on the Apple Developer Forums or Stack Overflow.

Q: What are some common problems that can occur when using XCTest?

A:Some common problems when using XCTest include elements that are disabled or do not exist yet. Additionally, tests may fail if the app under test collapse or if it is not responding to user input.

Q: How do I handle these mutual problems?

A:To handle elements that are incapacitate or do not exist, you can use the isEnabled, isSelected, and isHittable holding to check the state of ingredient. You can too use the waitForExistence () method to expect for an component to appear before interacting with it. If the app under examination clang or is unresponsive, you can use the XCTestRecorder puppet to generate a trial case that can be expend to reproduce the issue.

Q: What are some tips for writing good test?

A:Some bakshish for writing good tests include using descriptive names for your test methods, keeping your tryout small and focussed, and using the given-when-then keywords to structure your tests. Additionally, you should clean up after each test so that your trial are isolated from each early. Finally, you can use the XCTAssert and XCTFail methods to control the results of your tests.

4 Parts

Connet Now