A Brief Overview of Functional and Performance Testing

So, I just desire to afford a small bit of a refresher on the eccentric of testing that we ’ re considering today. First of all, we receive, which I ’ m sure many of you are quite conversant with already. But if you are form of wondering what ’ s underneath this term of functional examination, we can go back to the word function in its numerical sense. So, if you ’ ve ever, you know, done algebra or calculus you ’ ve realize, you know, formulas or par that seem like this, you know, f (x) equals something else (equals why in this case). In this outline, f is the gens of a function and functions take an input, or one or more stimulus, but from a mathematical position usually one stimulation, and then you can compose multiple use together to cover with multiple inputs. Anyway, you ’ ve got your stimulation and so you ’ ve got your solution. So, you know different functions are defined by the different way that inputs Pb to output.

So, from the perspective of functional testing, we might re-categorize this as saying functional tasks is asking, you know, perform f (x) actually adequate y? So, when I take my coating, which we can consider to be a function or a set of functions, and when we put in an input of a certain kind, whether that ’ s a tap or a whole series of actions, is the correct output make?

So, this is what we mean by functional testing. It ’ s basically, given the right inputs, does my application behave correctly? And, sometimes given the wrong inputs, does my application bear correctly consider with those wrong inputs. Are the mistake conditions handled appropriately make certain the app doesn ’ t crash or something like that.

Test your mobile apps on thousands of real devices.!

There are a crew of aspects of testing which people don ’ t usually include when they ’ re guess about functional testing.

One of these is time. You know, before we inquire does f (x) equal y. Well, we didn ’ t ask “ and how long did it take to touch y? ” You know, this is something which is significant for users but not genuinely an panorama of functional testing if it direct 10 second or 20 minute. The functionality still worked.

Another aspect of an covering that doesn ’ t usually evidence up in functional test is appearance. Does an app look full is it usable from a visual position? Does it contain any visual fixation – things like that? As long as the functionality of the app isn ’ t impacted, usually appearance isn ’ t view as part of functional testing. Security is another issue. Security and functionality go hand-in-hand obviously. Security could be regard as an element of functionality, but very often it ’ s not and so really often, for security testing you get to a different bed of the test mickle and see it as a freestanding thing that is a responsibility of another squad than the citizenry writing functional trial. Things like that. So, there are these aspects that aren ’ t often considered in functional examination.

This is often ponder in the employment of Appium, because Appium is fundamentally just a UI automation tool. It ’ s not a test framework. It doesn ’ t give you all the features that you postulate for compose and pass tryout. Its main focus is to let you automatize the use of a user interface.

So, in early words, it ’ s kind of like in the numerical formula we had earlier. We had this function, which you could consider of as your application, and we had this way of passing in an comment which we telephone X and so mold an output which we phone Y. And Appium is but a way of letting you input X into your application and letting you figure out what Y is, what befall on your covering after we input X. So, in other words, it kind of provides the I/O, or the stimulus and output, for functional testing. That ’ s why Appium is, I would say, chiefly used for functional testing, yet though it can also be apply in other kinds of testing as good.

One of the most significant early kind of essay is what we call performance examination. So, if we go back to our little schema here, which we were using for functional testing, f (x) equals Y, we could ask additional interrogation beyond does f (x) adequate Y and that gets us into the domain of execution testing. So, these are some of the questions we might ask within the domain of.

Okay, so f (x) was Y. We find that with our functional testing, but did it become Y fast enough? Are we locomote to meet the users ’ expectations of speed and responsivity? Did f (x) maybe consume too much memory? Now this is something that the user might not see themselves, but might impact the operation of the system, might affect the further operation of the app, or might cause a clash down the road. This is something home to the operation of the function, not something that is visible within the UI, at least not until it let to a crisis point.

On Android, you might have an out-of-memory slayer that close the app down. Things like that might happen. We might ask: what are the various kinds of bottlenecks inside the operation of the application? We can look at the coating from an internal perspective and ask, you know, when I tap this button and when I waited for this solution to appear on the blind, what were all the parts of my application internals that that be voyage through that were called, and how much time did the app spend in each of those?We can project out bottlenecks on our application as a way of trying to point out problems or give us area to potentially act on for improvement of the performance.

We could ask beyond the app itself, did running our application experience any consequences on the device at large or the system at large? What could these negative consequences be? Could we be habituate way too much CPU, such that early applications are negatively wedged or that the battery is drain too quickly? Things like that.

We might also ask about how much data our app devour, because if we ’ re developing our apps with the assumption that all of our users are on Wi-Fi speeds, we might run into an issue where our app is download so much information over the network that it becomes unuseable in cellular conditions, 3G weather, or 2G weather.

So, this would show up to the user as something like slowness, butasking how much information was drawn down over a period of clip is a really full way at visualize out again where we could optimize or where we ’ re fashioning assumption about our exploiter ’ experiences. So, these are the variety of things that we verbalize about in execution testing.

Now since we ’ re talking about HeadSpin today in this webinar and it ’ s being hosted by my friends there, I took a screenshot of the HeadSpin application.

This is a UI, which is given to you after you run one of your. I cognise that the slide is believably showing you a cluster of stuff that ’ s too minor to read and it ’ s not important for us to go through this in detail. My point is that all of these small metrics and graph and potential issues that you see here are the kinds of thing that you care about more in performance examination than functional examination.

You could have an app employment totally fine on a functional level but two tally of the same covering and two different conditions might give you a very different set of performance datum here. In some situations, it might be really concerning and some situation might not be.

For example, in this example, HeadSpin has mechanically found some issues that we might want to take a look at. So, it ’ s valuate several aspects of the performance data of the application that we didn ’ t have to capture ourselves. It was sort of capturing them automatically as we are running our tests, but it ’ s sharing that this app – it ’ s the Walmart app in fact – had a loading living on the blind for more than a 2d, which is cognise to be a potential spot of frustration for user. So, it ’ s saying we ’ ve got 11 counts of this error, so hopefully the Walmart team is taking a aspect at this sort of thing. I cognise from experience, feature played around essay to, that it is painfully slow.

We can look at a lot of different issues not just as a bear warning but o'er time as well. This is the kind of clobber that we ’ re talking about when we speak about performance. Most of these bits of information pertain to network information and how long it lead thing to download and how long it lead thing to display on the blind.

We could also dig even more deep into the coating internals. Here ’ s a caboodle of timelines and some graphs of internal system resource usage. So, we ’ ve got a graph of the CPU usage over time.

We could see for example, and of trend if we were actually on the website, we could tangle the mouse over hither and be greeted with a screenshot of the coating at this especial time, so if we saw a especial spike in CPU, we could put our mouse over it and say, what ’ s happening here within the coating? There are former ways to do this looking at process graphs and thing like that too that are passably interesting, particularly when you ’ re fag into the nitty-gritty of the performance of your app. We can look at memory as well as CPU. Things like that. IO.

So, there ’ s all sort of pretty standard types of performance data that is really interesting to appear at formerly you kind of dig a little deeper than the functional level.

Appium actually permit you regain some raw performance information just using the regular old Appium APIs, and I commend checking that out. Some of the early edition of Appium Pro were on this topic. There ’ s an article on and an article on. If you just search from appiumpro.com you can go and find them or I ’ m sure Google will take you thither directly as good. So, check that out.

As I showed you in the screenshots, one of the cool thing about HeadSpin is that they actually catch all this performance data automatically while you ’ re just running your functional tests, so you don ’ t experience to do anything to capture their performance data. That ’ s all execute kind of under the strong-armer transparently to you. So, it ’ s kind of nice because you can focus on writing your functional tryout asking does f (x) equal y, but so in add-on to that just by running on HeadSpin you get a account back that aver by the way, here ’ s how long it took for y to show up on screen and hither ’ s all your bottlenecks and here ’ s all these possible issues.

So that ’ s a genuinely great thing about their service that I really appreciate. Something else to mention is that I mean this is true for all kinds of testing, but I think it ’ s especially relevant for execution testing. You can run one-off performance tryout, but it ’ s often more utile to think of performance as something that shouldn ’ t just be examine at discrete point at time but should be monitored and should be automatically checked. You know, you want to make certain that there is nothing maybe in the back-end of your coating that ’ s changing that is have performance issues. Things like that.

‍

‍

So that ’ s just a brief overview of functional performance testing. I thought it ’ s occupy to dig a little deeper into that because I cognise that we can often throw the lyric around but may not know the concepts super clearly. Without further ado, let ’ s move on to some examples of some of the tools that I use to germinate Appium tests and to do certain that they perform good.

Appium Desktop

So 1st thing I want to talk about is Appium Desktop. Appium Desktop is a user interface for Appium that you can use without even needing to download anything from the command line or open up your end. It ’ s a all self-contained covering.

So, if you ’ ve never used Appium Desktop, check it out. It ’ s at github.com/appium/appium-desktop and you can download binary release for Mac, Windows, and Linux there. Rather than show you a bunch of slides, I ’ ll just open it up and do a little demo of some of the things that I use it for when I ’ m germinate Appium test.

Also read:

So, I apologize – thing probably will show up kind of small on my screen. I ’ ll maximize things as much as I can. Actually, I wonder if I can. I can ’ t change the zoom within the application hither, because it ’ s not actually a web browser. So, this is Appium Desktop. When you open it up, it greets you with this kind of screen that says hey, I ’ m Appium what host support do you want to run me on. I ’ m just going to go onward and close down some other window too so that we can see it in all its beauty.

Here we are. You can see my really filthy desktop as well. So, hither ’ s Appium. What we can do formerly we ’ ve got it downloaded is we can actually start an Appium server. So, an Appium server is running. It says welcome to Appium version 1.15.1. So, I don ’ t need to run Appium from the command line if I don ’ t want to, and I could run an Appium test from my IDE or anything else. It says its running on Port 4723, which is what I selected, but commonly what I use play desktop for is not just as the server, but I use it to inspect my application so that I cognize how to find the component in the most efficient way possible. To do that I can go over here and start an inspector session.

Once this load up, I basically have a pick of host here. I can opt an automatic server, which is the one that ’ s already running. I can prefer a custom server, and I can still select cloud providers to run on including HeadSpin. Then I basically set up an inspector session by typing in the desired capability, or I can use a protected capability.

I ’ m go to select a set of capabilities that I implemented for this webinar so we can see we ’ re going to run on iOS 11.4 using an iPhone 8 simulator and I ’ ve got this application that I developed that I ’ m testing, and I ’ ve got this other capability hither which I ’ ll explain a little bit later on. Once I ’ ve got my capability set, I can go ahead and start session.

I ’ ll go ahead and throw up the so you can see what clobber is happening. Obviously the Appium logs are scrolling by in the background.

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

So erstwhile the session laden what we have is a screenshot of the app here and I can linger over all the different elements, just kind of like Chrome or Safari or Firefox devtools. I can tap on one of these component that Appium knows about and I can see a whole cluster of occupy metadata about it like its name, its label, its position.

But the most interesting thing is that Appium Desktop actually gives me suggestions of how to find this component in my trial. So for this element, I can actually find it by accessibility ID, which is favour and here ’ s the selector that I can use to find that.

So, I can really test this out if I require just by tap on the element here so I can click tap and we can see that we got to a new screen, new elements, new UI tree hither, and the tap was actually successful. So let ’ s try and regain something else.

Here ’ s a save button. Now, it does have an accessibility ID, but as you can see in the XML tree, it ’ s accessibility ID is not unique, because it ’ s the like as the element that ’ s its parent, and that ’ s because I ’ m using react aboriginal to develop my application. So, it just variety of perform this – whether I like it or not.

So, the selector that Appium has recommended in this case is X path, but it hasn ’ t given me a variety of unintelligent XPath chooser. It ’ s given me one that has some unique information in it videlicet. Here ’ s the name of the factor. The name itself isn ’ t unique, but the fact that it ’ s the 2nd one of those on the screen makes it singular.

Now, some feature that I use that I know a lot of people don ’ t really cognize about is something called the search for element dialogue. So let ’ s say I didn ’ t actually know that this XPath was the suggested one or I was examine one out in my exam and my codification, but I ’ m getting an “ element not institute ” error. So I can load the app up in this screen. I can click hunt for constituent. I can choose my locator strategy.

So, let ’ s choose accessibility ID, and I ’ m going to go onwards and type in what I imagine possibly was the name of that special button. Then I can click hunting, and Appium will come back with all the elements that it thinks correspond to this element. So actually, there ’ s two – so they sort of occur in more or less the like space on the screen. So, the fact that there ’ s two ingredient here could indicate to me the cause of a bug in my trial script.

Don & # x27; t bury to check:

Maybe I assumed there was only one or maybe I was trying to interact with one of them, but I was actually interacting with the other one. Of course, with this selected, I can also tap it or do different things here. So that ’ s kind of a fun little tool within Appium Desktop.

Something else you can do within Appium Desktop that some people don ’ t cognise about – this is with more late edition – is we actually have an actions tab over here.

This is when we want to perform Appium commands that aren ’ t genuinely link to elements per se. So Appium has all these different actions that do with the twist or the session. So, let ’ s just pick session hither and you can see we have all these different groups of commands. What should we try?

Let ’ s try orientation. Let ’ s get the orientation of the app. So, we get the resultant commanders regress result portrait. Okay, that ’ s cool. I question if we can even set the orientation. Let ’ s try set it to be landscape and voila. So, I ’ m going to change it back to portraiture now.

So, you can do a lot of things with Appium beyond just notice and interact with element specifically. So have a look at this activeness tab. There ’ s a bunch of interesting stuff in there.

Another kind of fun tool, that ’ s especially utilitarian when you ’ re germinate tests is the recorder. So, we got something here already. I ’ m going to clear out. It ’ s actually saved my last action. But if I turn on the recorder, I can intermit it or start it again, and if I perform some activity like for example “ go rearward ”.

We can see that that command has be added here in text, but this is the command in a particular language so I could if I require sort of transcript and paste this into my trial code. This is python. We could use Java or anything else, and if you require to guide this and actually variety of make a entire test out of it, that you could simulate into your ID and execute. You can demonstrate and hide boilerplate code.

So, now I ’ ve got all of this in the context of the right capabilities that I use to start the test and actually even puts it into a decent examination method for me. Here ’ s the back command that we used. Let ’ s really go to the web vista page hither. So, I & # x27; ll tap this.

You can see that the element was constitute and clicked in the code as well. So that ’ s a jolly utilitarian feature of Appium Desktop. Currently, there is no ability to play this back within, but that ’ s something that we ’ ve be working on and we ’ ll release at some point.

So, one of the things that – I ’ m going to go forrader and shut out the recorder here – one of the things you ’ ll observation that if you ’ ve got a Webview that fundamentally it simply shows up as this sight element here. It doesn ’ t give you a bunch of context underneath it still though there might be elements within this.

So, Appium Desktop doesn ’ t actually endorse inspecting within a Webview, at least any elements that aren ’ t automatically further to native elements like this one here. Apple is promoted to a aboriginal factor yet though it ’ s actually a web element. But, we can ’ t use the contacts API within Appium Desktop, and the reason is because you can actually already do that really well using Safari for iOS and Chrome for Android. So just as a way of spotlight that let ’ s go ahead and open up Safari.

I could make it a little smaller. So, hither ’ s Safari. If I go up to develop, I can see that there ’ s actually an iOS simulator in this list, and there are two web contexts within it about: blank and JS circumstance. Now, I ’ m not incisively sure which one of these is this, so I ’ m going to first of all case into the box and go to AppiumPro.com.

Sadly, with the most recent version of that code, there ’ s a bit of a delay in direct keystrokes, and this is a bug and XCUITest which hopefully Apple will be fixing presently. Maybe I ’ ll just type it in manually instead of waiting here.

Oh, it looks like the whole simulators is reside. Well, that ’ s not very happy is it. Now it ’ s actually get my system slow. Okay. Well. We ’ ll go ahead and just blame one of these web views, and we ’ ll see which one is the right one.

So, I ’ m going to blame about: blank, and now I get really a web inspector hither that shows me everything that ’ s available within sight within the Webview. So, this one doesn ’ t actually have any constituent in it. So, potentially this was not the one that I wanted to work with. Let ’ s try the other one.

This is merely the JavaScript context for that one as good. So, I cerebrate that believably because the simulator is hanging, it ’ s not actually showing me the element within this Webview.

Anyway, this is how you would do it. I apologize on behalf of Apple for their untested software. So yeah, you can do the same thing with Chrome on Android as well. I really have some Appium Pro articles on how to do that. So, this was all fundamentally how to visit your applications, how to exercise them using a optic interface, and you can do both the native view your application and the web panorama using Safari Chrome. So, we ’ ll come back to this. I might hold to quit the simulator. See if that works. Okay, we will try that again later.

So, back to the presentation here. Something else that I want to mouth about this morning is a new tool that has be liberate recently telephone Web2driver. So, Web2driver is a new kind of Appium node. So, you ’ re thinking Appium client, you ’ re thinking okay, there ’ s the java client, the python client, .NET, crimson, you know couple JavaScript clients. These all run from your trial scripts, which you run on the command line, right? Or from your editor like IntelliJ or whatever.

Web2Driver

So, this is an premise which has been true for a long time – until now. So,Web2driveris actually an Appium client that bunk within a web page. It ’ s site at HeadSpin ’ s GitHub organization which is telephone “ projectxyzio/web2driver ” on GitHub. So, you can check it out. Here ’ s a little icon of the readme.

As it aver, Web2driver is a pure JavaScript web driver client that can run in a browser. One of the interesting facts about Web2driver is that because it runs in a browser, it variety of depends on the browser ’ s cross-site asking to speak to the Appium server. But, because of browser touchstone to do with protection and make sure the bad people can ’ t do things you don ’ t want, your browser can ’ t just use JavaScript to utter to a different server than the one that function it the webpage to commence with.

So if you want Web2driver to be able to mouth to your Appium host, you actually have to start the Appium server with a exceptional iris, which is called allow CORS, which is the cross-origin request security. I don ’ t remember what ‘ S ’ stand for – something about cross-origin postulation, I think.

So, Appium doesn ’ t have this turned on by nonremittal, because it is again potentially a security jeopardy. You could go to a web page, and somebody could begin bunk examination on your Appium server – running on your machine without your cognition. That ’ s pretty scary. So, you have to start the Appium server with that particular flag to make certain that that ’ s able to hap. Otherwise, you can bundle this web driver package into your own JavaScript projects that you can run within a web page. So, that ’ s pretty amazing.

The Web2driver code look really much like something you ’ d expect from WebDriver IO, and in fact, we built Web2driver on top of the same code that WebDriver IO is built off of. So, it uses all that logic, which has patently been quite battle-tested over the years. So, running a test looks like defining your capability, starting a session, finding elements. Everything is promise-based, so you can use async/await to keep your code clean.

So, it ’ s pretty much a standard WebDriver and Appium client. I say Appium customer, but really could use this for Selenium too. Although Selenium doesn ’ t support the allow CORS headers. So, you ’ re sort of out of destiny, unless you put a placeholder in front of Selenium that you built.

Read:

Why do we need a web-based Appium node?

Well, what if we could progress Appium tools that command naught but a browser – no downloads, no command line – just your browser. This is, I imagine, pretty interesting.

So, this is exactly what we ’ ve been working on at HeadSpin. Here ’ s a little video of something called theHeadSpin Recorder, which is I hypothesis in beta now. So, if you ’ re a HeadSpin user – talk to your chronicle people and see if you can get access to this presently. But, the idea is that you load your app, you define the character of device you want to use, and so this recorder interface pops up.

The interface look different, but it ’ s actually very similar to Appium Desktop, in the sense that it gives you a kind of point-and-click interface to use with your application. But, what ’ s happening is that this is all just taking place in your browser.

So, you only go to your HeadSpin account, go to your recorder tab, and you can charge it up. You don ’ t have to download Appium Desktop or anything else. And, what ’ s really interest about it is that not only perform the recorder record your activity, but so you can have them play backwards and you can yet set them to play back at set intervals. So, you can essentially define your own Appium-based test without expend any code. So obviously there are limitations to any sort of no-code coming, but this can get you pretty far and it ’ s been pretty stable so far as I ’ ve been play with it.

So, this is only kind of showing you some exemplar of you know, clicking on things and finding an factor – really similar to Appium Desktop. You can see the activeness proceeding here. So, there ’ s all kind of different interactions you can use. You can even do swipes. So, here ’ s a swipe occurrent, and so you can still find constituent by image. This is one of the cool thing about the HeadSpin Recorder. You can select a region of the screen that may or may not be an element, and so that screen indication will be passed to Appium as an picture, and it can be tapped during later runs.

So, in the picture, the tests are just form of finished and said, you know, I ’ m done, and now the registrar is mechanically moving into the review phase where it ’ s lade up the twist again with a new session. It ’ s going to replay all of these steps for you to kind of see – oh, yeah, this works like I expect. I ’ m travel to subscribe off on this and now can schedule the test.

So, it ’ s going to jump ahead, you cognize, so here we are walking through the different steps for the application. We ’ re in the centre of a swipe hither. Then, again once we ’ re done, we can create a report and decide how often we ’ d like this report to be regenerated by re-running all these command.

So again, this is variety of an representative of the kind of thing you could build with Web2driver because it ’ s a full-fledged Appium client. So, you can build these great experiences on top of Appium just in a browser that make it much more accessible, require no especial package, are accessible from Mac and Linux and Windows and any operating system that can run Firefox. That kind of thing. So that is the recorder.

Last thing I want to talk about is something called Event Timings. Event Timings is an Appium lineament that can be helpful for of your tryout itself, kind of giving you a little mind of what ’ s going on under the hood of the test- the different steps that Appium is taking that you may not even know it ’ s taking – that can help you discover where there are possible bottlenecks within your test code.

Events API

So, the primal idea here is that Appium takes time to do stuff.

This is pretty obvious. Not exactly mind-blowing, but a interrogative we can ask is good, how long? How long does it take to do those different thing? We ’ re just sitting thither running a test, and it appear like it ’ s taking forever. Obviously, something ’ s happening. How many things are bechance, and when are they bechance? And what is the thing that is induce the holdup?

So, the Appium team has developed something called the Events API to help us determine this. Now, when you start a normal Appium test, you use capacity like this. This is the kind of stuff that we ’ ve been using today.

To turn on the Events API, essentially you add a new capability telephone “ eventTimings ” and just set it to true. Now, when “ eventTimings ” is set to true, then you have the ability to get a crew of occupy timing data from Appium just by calling the “ getSessionDetails ” bid. So, this is I think in the Java client it ’ s “ driver.getSessionDetails ” – something like that.

Now that reply will have a bunch of other information like your capability and things like that, but there will be this key in the response telephone “ events ”. Within the case object here, we have basically two main portion.

One is a list of commands. So, every command that you send during the course of your tryout will get lend hither, including the command name and the start clip and the end time, which you could obviously use to fancy out how long did each command take. And so there are a bunch of other kind of special events that we ’ ve built into the Appium inauguration flow.

For model, this is an iOS trial that I got this data from. So, there ’ s an event in the startup of an iOS test called ‘ xcodeDetailsRetrieved ’. So, we log that when you have the ‘ eventTimings ” API turned on, so that you can sort of see when did this happen, and then you can see the next thing that happened, and so on. You can see that the final thing that happened within this particular test that I ran was that I set the orientation, or the orientation was set automatically, I guess, by the Appium host when I start it up.

So, we could plot all of these on a map or on a timeline and build out: where are the infinite in between these different events? But you don ’ t actually have to do that manually, because we receive something called theAppium Event Parserthat will generate a nice timeline for you from that datum. So, you can take that data, use it on your own, whatever you want to do with it, but we can also generate a nice timeline.

So, here ’ s an illustration of the output for the Event Parser for some of this case data that I glue into a file and ran through the Event Parser. So, you can see that all of these different event happened – xcodeDetails were retrieved, the app was configured, the reset was depart, the reset was complete. Then we actually see this is all to scale. We can see there ’ s a gap here of almost three seconds – between resetComplete and logCaptureStarted.

So, what was proceed on between here? Did it actually take three seconds for the log to start or maybe the Appium team needs to add a little bit more graininess in here so we can see what ’ s befall? Or perchance simultaneously the simulator was starting? Maybe that ’ s what lead some time.

Maybe we ’ ve got other gap of almost five seconds for the app to be installed and for us to start launching WebDriverAgent? Then by far the biggest sum of time taken here was the WebDriverAgent showtime. So, between start attempted and session started, it was almost seven, or a little over six, seconds.

So, this is pretty interesting. Let ’ s run a quick demo of this actually. So, to run this demo, I ’ m going to go onwards and start up a examination again, and I ’ ve got the eventTimings capability turned on here.

The simulator is booting because it was frozen for

FAQs

Q1: Can Appium be used for cross-platform examination?

Appium is a cross-platform tool, which means that QA teams can use Appium to write test cases for iOS, Android, and Windows with the same code.

Q2: What are some popular load examination tools?

Some of the most commonly used load examination tools are:

1. LoadRunner
2. Apache JMeter
3. HeadSpin
4. Gatling
5. LoadNinja

Q3: What are some alternatives to Appium?

While Appium is a outstanding tool, it might not fit all applications. Some alternatives to Appium are

1. Selenium: Beneficial for web apps
2. Microsoft Visual Studio App Center
3. Cypress
4. qTest by Tricentis

Q4: What is the difference between scalability essay and stress testing?

Scalability and stress examination are part of performance testing. Scalability testing trial the covering & # x27; s content to handle the gradually increasing or decreasing load. On the former manus, stress testing identifies the breaking point of an coating.

4 Parts

Connet Now