Blog 2.0

All Posts (1170)

A software, no matter how it may be intuitively designed could not perform its functions if there are technical flaws and hitches. Thus, it is crucial for a software product to undergo a QA testing service. The number of enterprise and consumer mobile apps have exponentially grown over the years, leaving the end user with humongous amount of applications to choose from. Nevertheless, how does a user choose the app that will take up precious space on a device? The key is the quality of the app and could only be achieved via mobile app testing.


The success of an app could be measured by the amount of downloads, positive comments and fast implementation of bug fixes and new features. Testing an app should be done by a reliable software testing company. The practice allows delivering better software and helps the app to be successful through testing its usability, functionality and consistency, growing the user base.

In fact, testing is an integral part of each software development process and with mobile applications has become much more relevant. The growing number of mobile phones and devices leads to a massive fragmentation of screen sizes, operating systems, standard OS variations and more. With agile processes, testing is done every so often to ensure the best quality possible. Bug fixes and new features should be released with short intervals to that users will not lose interest and new features must not bring new bugs. Testing is vital for the survival of an application.


QA testing companies admit that there are main challenges in mobile application testing. Mobile app testing is more complex compared to traditional desktop and web apps testing and has its own challenges. The greatest challenge is the number of different mobile devices around. All the devices have different shapes, sizes, software, software version and hardware and it requires testing enough devices to ascertain that majority of users are happy. Some challenges include the following.

1. Multiple mobiles. There are a lot of mobile devices released regularly. The devices include smart phones, regular handsets, iPhones, tablets and iPads. It is not a guarantee however that the device would perfectly work fine on another device. The reason is that the hardware and screen resolution is different.

2. Wide range of mobile applications. Testing these kinds of mobile applications, which are native application, hybrid or web app varies from one another due to their application.

3. Device segments challenges. One of the concerns in device parts is the testing matrix. While an iOS device is increasing daily, these segments pose huge challenge for the Android OS and the engineering teams. Also, it has challenges in terms of suitability issues.

4. Several testing tools. There are quite huge varieties of mobile application testing tools available, whether free or paid for a web app, native app, Android or iOS. It is thus important to make inquiries on one that suits the device or devices.


Manual Testing

This approach is a human input, evaluation or analysis. Its user centric that focuses on explorative ways of monitoring if a mobile app meets the user expectations and requirements. The app should be tested for the feel and look for usability, ensuring that it is user friendly. Manual testing should not be used on all testing, but just around 20 percent of them, the rest would do fine with automated testing.

Automated Testing

It is another mobile app testing approach. Ideally, one should set up as much cases as possible, which enable one to automate around 80 percent of testing. There are particular test instances that must be automated, such as:

  • Automate test cases with predictable results
  • Automate most frequent test-cases
  • Automate the most tedious manual testing cases
  • Automate test cases with predictable results
  • Automate functionality that’s frequently used
  • Automate test instance that are impossible to do manually
  • Automate test instances that run on various software or hardware platforms and configuration


Many organizations opt to outsource their QA testing process, which makes a lot of sense. Overall, outsourcing the process to a reliable service provider is the best option to go for.

1. Reduce staffing expenses. While development resources are costly enough to maintain in-house, an outsourced QA team could help a business allocate funds better toward the development, depending on priorities. In limited funding, most organizations prioritize actual product development over testing. Often, QA gets the short end of the stick. Outsourcing could bridge the gap.

2. Free up development source to iterate. Inspiration strikes at all hours in the mind of a software developer. The solution could come in the shower, morning commute or any time. Knowing that a new feature or fix could be handled off to testing, while a developer keeps moving on with the process could truly help create and keep momentum.

3. Overnight test results. A lot of offshore QA teams are up to twelve hours out of phase with the time zone, meaning that the development team could submit code for resting at the end of the day, and arrive in the morning to find the results already.

4. Domain expertise. Typically, outsourced QA teams have exposure to a huge range of domains, which make it easy to assemble a pool of industry savvy source to test a current project. This natural expertise significantly reduces the cost associated with product training and provides accurate testing results much quickly.

5. Objectivity. It is very easy to lose sight of the forest of trees when it comes to one’s own creations, which is why QA and development teams typically have been kept separate and somewhat in adversarial roles. An outsourced testing team could provide ultimate objectivity and a fresh eye on a project. Ideally, someone else should check the work because that someone else is more likely to spot flaws.

Mobile application testing is essential before an application is launched since it calls attention to errors made when the app was still in the development phase. Also, testing is relevant since it helps reassure a client on dependability and fulfillment in the application.



Read more…

Mobile apps can often crash for many reasons. Nothing is as excruciating as memory leaks. It starts with your app crashing often, or becoming slow or maybe making your entire phone slow down, taking longer time to load activities. Memory leaks are notoriously hard to detect, and thus can easily surprise you. Have we ever thought why most of the users uninstall the application after some use?

Which is why it is critical for Developers to understand the memory consumption by any mobile application. How do you detect memory leaks during Mobile Application Testing? And if so, how can you prevent them from hogging mobile resource consumption?

A little knack for Mobile Application testing always comes handy.

Memory is critical to device

Memory is one of the key resources of the mobile device.And memory leaks in Android is an important thing to be kept in mind. Java is a garbage collecting language, which removes the need for developers to dig deep to manage allocated memory. This reduces the chances of any segmentation fault crashing an app or any unfreed memory allocation from eating up space of the heap area, thus creating a safer code.

However, a garbage collector is never an insurance against memory leaks. There are other ways by which memory can be leaked within Java. This means that your android mobile application is still pretty prone to wasting unnecessary memory allocation and crashing with out-of-memory (OOM) errors.

Toptal 300w" sizes="(max-width: 323px) 100vw, 323px" />

Figure 1: Image Credit- Toptal

Why are Memory Leaks Bad?

Cause:Memory leaks occur when some variable of the application still has references to some objects that are unnecessary, no longer in use or used to be with the app anymore, is bloating the allocated memory heap and the Garbage Collector is not being able to release that memory.

Effect: Android devices mostly run on phones with limited memory, so as a result of too many leaks, the app runs out of available memory. This triggers more frequent Garbage Collector events which paralyze the device (Stop-the-world GC events) by almost stopping the rendering of UI and processing of events. This leads to an Out of Memory Exception and translates to the user as the app being unresponsive.

Testing for Memory Leaks

Android App Testing

Memory Leaks are caused by the failure to not be able to de-allocate memory that is no longer in use, which is why they cannot be identified during black box testing. The best phase to find the memory leaks is when developers are developing the application, at a code level.

It’s best to check for memory leaks during unit testing. However, testers can follow these tips:

Release Unused Memory: Memory leaks can be present because of the bad design of the application and thus might consume lot of memory when the application is in use

Test on Multiple devices:The memory consumption by the application should be monitored while doing the system & functional testing. One shouldn’t rely on a single device testing as there are plethora of devices in the market.

Detecting Memory Leaks

There are quite a few techniques and tools devised by developers to pin point memory leaks. Android’s very own Android Studio has a powerful tool to monitor not only memory usage but also for network, GPU and CPU usage as well, called the Android Monitor.

Memory Monitor in this helps track memory usage, find de-allocated objects, identify memory leaks and helps get an overall sense of how your app allocates and frees memory. It’s done in three steps:

1. During and use and debugging of app, track the memory monitor. If the memory usage graph rises for your app and doesn’t fall even if put in background, it’s a memory leak.

2. Using the Allocation tracker, you can check the percentage of memory allocated to different types of variables in your app. This gives you a sense of how much memory is consumed by which object.

3. Create a Java Heap Option to create a heap dump that keeps a snapshot of the memory at any given point of time, thus providing the data consumption data.

Despite Android’s monitor to detect memory leaks, there are a few platforms from developers that help extract memory consumption data without so many steps for faster testing cycles.

pCloudy’s very own platform for example, generates the statistics for Memory consumption while doing the normal functional Mobile Application testing on real mobile devices.It also generates other vital data such as CPU consumption, battery consumption & data consumption for testers and developers who reiterate several test cycles across multiple physical devices.

Mobile App Testing , Mobile Application TestingAndroid App TestingiOS App TestingAutomation  TestingOnline Android EmulatorApp TestingMobile Responsive Test

Read more…

It’s critical for a business to adapt to the dynamic changes in the technology and market evolution, with regular updates of software applications. The success of an app isn’t solely dependent on development but on quality as well. Regardless of how intuitively a software is designed and the functionalities that are made simple, if there are technical hitches, then it will hinder usability. That is why it is mandatory for any product to undergo software testing. Quality assurance testing assures smooth operation, flawless user experience and meet overall quality aspects of the system.

Computer software examination, or software QA testing is provided by software development service providers. In the process, quality assurance is an integral part of each and every project undertaken. Effective and reliable service providers follow industry standard testing methods to help clients meet their quality assurance goals. QA experts are proficient in numerous testing technologies tools, standards and platforms, which enable them to apply integrated testing services as well as the best solutions.

Data is the lifeline in any organization and is growing bigger with each passing day. Back in 2011, experts predicted that Big Data would be the next frontier of competition, productivity and innovation. Nowadays, businesses face data challenges when it comes to volume, sources and variety. Structured business data is supplemented with unstructured data as well as semi-structured data from social media and other parties.

There are numerous advantages of Big Data mining. However, separation of the required data from junk isn’t easy. The Quality Assurance team should overcome different challenges in testing of such huge data.

Some include the following:

1. Big volume and heterogeneity. Testing a large volume of data is in itself the biggest challenge. Ten years ago, a pool of data of 10 million records was considered gigantic. Nowadays, businesses should store Exabyte or Petabyte data extracted from different offline and online sources, to perform their daily business. Testers have to audit such voluminous data to ascertain that they fit business purposes.

2. Understanding data. For an effective testing strategy, testers need to monitor and validate the 4Vs continuously. These are volume, variety, velocity and value. Understanding data and its impact on business is the real challenged faced by any big data tester. It isn’t easy measuring the testing efforts and strategy without the right knowledge of the available data’s nature.

3. Dealing with emotions and sentiments. In a big data system, unstructured data that’s drawn from sources like text documents, tweets and social media posts supplement data feed. The biggest challenge that testers face while dealing with unstructured data is the sentiment that’s attached to it. Testers should capture their sentiments and transform them to insights for further business analysis and decision making.

4. Lack of coordination and technical expertise. Technology is growing, and everyone struggles to understand the big data processing algorithm. Testers of huge data should understand the components of the ecosystem thoroughly. Nowadays, testers should understand that they should think beyond the regular parameters of manual and automated testing.

The following figure provides high level of overviews of phases in testing data applications. The tests include.

1. Data staging validation. The first step to big data testing also referred as pre-Hadoop stage involves a validation process. Data from different sources, such as weblogs, RDBMS, social media and others must be validated to ensure that correct data is pulled into the system. Comparing source data with data pushed into Hadoop ensures that they match. Tools such as Datameer and Talend could be used for data staging validation.

2. Validation of MapReduce. In this step, the tester verifies business logic validation on each node and validate them after running against numerous nodes, making sure that MapReduce process works correctly. Data segregation and aggregation rules are implemented on the data.

3. Output the validation phase. The third or final stage of Big Data testing is output validation process. The output data files are acquired and ready to be moved to enterprise data warehouse or any other system that’s based on the requirement.

4. Architecture Testing. Hadoop processes very big data volumes and highly resource intensive. Thus, architectural testing is paramount to ensure success of any big data project. Improper or poorly designed system could lead to degradation of performance and the system could fail to meet the requirement.

5. Performance testing. Performance testing for big data app involves testing of big data volumes for both structured and unstructured data. Moreover, it requires a certain testing approach to test such massive data.

Big Data, all in all has a lot of prominence in businesses these days. If the right test strategies are embraced and the best practices are followed, defects could be determined in the early stages of the overall testing expenses could be reduced while achieving quality at speed.

Read more…

Did you know?
There are 300+ Million Android devices across the globe
850,000 daily Android activations
Google play has over 450,000 Android Apps available

Take a look few key App Highlights to discuss further

Google’s Android ecosystem is continuing to expand rapidly. It is evident that new mobile OEMs are emerging in every corner of the world adds in different screen sizes, ROM/firmware, chipsets, etc. For Android developers/testers, it becomes relatively difficult to cope up with the fragmentation.

Luckily, Android developers/Testers have unlimited access to some advanced cloud-based mobile testing solution, like Testdroid Cloud, for the Large-Scale Automation of real devices for quality assurance.

Also, the emergence of different Android testing frameworks has substantially relieved Android developers’/Tester lives.

In this blog, we are going to discuss five most used Android testing frameworks and break down the basics and code examples of each.


robotium logo 378w" sizes="(max-width: 378px) 100vw, 378px" />Definitely, Robotium was once the most widely used Android testing framework in the early days of the Android world. It is similar to Selenium in Android and makes testing API simpler.

Robotium is an open source library extending JUnit with abundant useful testing methods for Android UI testing. It offers powerful and robust automatic black-box test cases for Android apps (native and hybrid) and web testing. With Robotium we can write function, system and acceptance test scenarios, and test applications where the source code is available.


// Public void for the operation
public void testRecorded() throws Exception {
// Wait for the text ‘Hello!’ to be shown for newbie
if (solo.waitForText(“Hello!”)) {
// R class ID identifier for ‘Sign in’ – and click it
// R class ID identifier for entering username
solo.enterText((EditText) solo.findViewById(“”),”username”);
// R class ID identifier for entering password
solo.enterText((EditText) solo.findViewById(“”),”password”);
// R class ID identifier for clicking log in
// Wait until log in is done
// Activate the text field to compose a tweet
// Type the tweet
solo.enterText((EditText) solo.findViewById(“”), “Testdroid”);
// Tweeting!

Mobile Resting in Real Devices

For convenience, Testdroid Recorder is used. It is an amazing recording tool built with Robotium for test script creation. By performing actual actions on the real device, the tool records every step or action taken and converts it to Javascript for further modification.

In addition to that, it is also entitled to download and utilize the extension Library – ExtSolo.

It includes useful methods that have not been merged into Robotium, for instance:

  • Automatic scaling of clicks for any resolution
  • Multi-path drags
  • Automatic test failure screenshots
  • Mock locations
  • Change device language
  • WiFi control


UIautomator logoAlthough Robotium is a good yet basic framework, UIAutomator offers Android apps and games testing. Google’s test framework allows user interface (UI) testing of native Android apps on one or more devices. Another advantage of UIAutomator is that it runs JUnit test cases with special privileges. This means that the test cases can span across different processes. It also provides five different classes to use, including

UiCollection | UiDevice | UiObject | Uiscrollable | UiSelector

But, it only works on Android devices with API level 16 or higher. Another downside of UIAutomator is that the tool doesn’t support web view, with no way for direct access to Android objects.


// Public void for the operation
public void testSignInAndTweet() throws Exception {
// Starting application:
getUiDevice().wakeUp(); // Press Home button to ensure we’re on homescreen
getUiDevice().pressHome(); // Select ‘Apps’ and click button
new UiObject(new UiSelector().description(“Apps”)).click(); // Select ‘Twitter’ and click
new UiObject(new UiSelector().text(“Twitter”)).click(); // Locate and select ‘Sign in’
UiSelector signIn = new UiSelector().text(“Sign In”); // If button is available, click
UiObject signInButton = new UiObject(signIn);
if (signInButton.exists()) {; // Set the username
new UiObject(new
new UiObject(new
new UiObject(new UiSelector().className(“android.widget.Button”).
text(“Sign In”).instance(0)).click(); // Wait Sign in progress window
getUiDevice().waitForWindowUpdate(null, 2000); // Wait for main window
getUiDevice().waitForWindowUpdate(null, 30000);
new UiObject(new UiSelector().description(“New tweet”)).click(); // Typing text for a tweet
new UiObject(new UiSelector().className(“android.widget.LinearLayout”).instance(8)).
setText(“Awesome #Testdroid!”); // Tweeting!
new UiObject(new UiSelector().text(“Tweet”)).click();


espresso logo 590w" sizes="(max-width: 590px) 100vw, 590px" />Espresso is the latest Android test automation framework that got open-sourced by Google. It is now available for developers and testers to beat out the UIs. Espresso has an API which is small, predictable, easy to learn and built on top of the Android instrumentation framework. Also, Android UI tests can be quickly written with it. It supports API level from 8 (Froyo), 10 (Gingerbread), and 15 (Ice Cream Sandwich) and afterwards.

It’s quite reliable, synchronizing with the UI thread is fast, because, there is no need for any sleeps (test run on same millisecond when an app becomes idle).
But it does not support web views.


public void testEspresso() {
// Check if view with the text ‘Hello.’ is shown
// R class ID identifier for ‘Sign in’ – and click it
.getIdentifier(“”, null, null))).perform(click());
// R class ID identifier for entering username
.getIdentifier(“”, null, null))).perform((typeText(“username”)));
// R class ID identifier for entering password
.getIdentifier(“”, null, null))).perform((typeText(“password”)));
// R class ID identifier for clicking log in
.getIdentifier(“”, null, null))).perform(click());
// Activate the text field to compose a tweet
.getIdentifier(“”, null, null))).perform(click());
// Type the tweet
.getIdentifier(“”, null, null))).perform((typeText(”#Testdroid”)));
// Tweeting!
.getIdentifier(“”, null, null))).perform(click());


Calabash logo 636w" sizes="(max-width: 636px) 100vw, 636px" />Calabash is a cross-platform test automation framework for Android and iOS native and hybrid applications. Calabash has easy-to-understand syntax, which enables even non-technical persons to create and execute automated acceptance tests for apps on both of these mobile platforms. Calabash’s tests are first described in Cucumber and then it is converted to Robotium or Frank in run time. It supports almost 80 different natural language commands (controllers), and new controllers can be implemented to it in Ruby or Java.


Feature: Login feature
Scenario: As a valid user I can log into my app
I wait for text “Hello”
Then I press view with id “Sign in”
Then I enter text “username” into “login_username”
Then I enter text “password” into “login_password”
Then I wait for activity “HomeTabActivity”
Then I press view with id “menu_compose_tweet”
Then I enter text “Testdroid” into field with id “edit”
Then I press view with id “composer_post”


appium logo 600w" sizes="(max-width: 600px) 100vw, 600px" />Appium is a mobile test automation framework (and tool) for native, hybrid and mobile-web apps for iOS and Android. It uses JSONWireProtocol to interact with iOS and Android apps using Selenium’s WebDriver. It supports Android via UIAutomator (API level 16 or higher) and Seledroid (API level lower than 16), iOS via UI Automation, and mobile web as Selenium driver for Android and iOS. Looking for a complete

One of the biggest advantages of Appium is that you can write Appium scripts can be written in almost any programming language (e.g. Java, Objective-C, JavaScript, PHP, Ruby, Python or C#, etc), freedom to select tools, compatibility across the most important platforms (Android and iOS), freedom to install and configure devices to test. Also, familiarity with Selenium makes it easy to use Appium in mobile app testing. They use the same WebDriver and the desired capabilities are also used in the same way. Configuring an application to run on Appium has a lot of similarities to Selenium.


# wait for hello
textFields = driver.find_elements_by_tag_name(‘textField’)
assertEqual(textFields[0].get_attribute(“value”), “Hello”)
# click sign-in button
driver.find_elements_by_name(‘Sign in’)[0].click()
# find the text fields again, and enter username and password
textFields = driver.find_elements_by_tag_name(‘textField’)
# click the Login button (the first button in the view)
# sleep
# click the first button with name “Compose”
# type in the tweet message
driver.find_elements_by_tag_name(‘textField’)[0].send_keys(”#Testdroid is awesome!”)
# press the Send button
# exit


Here are top 5 android testing frameworks for daily Android builds, creation, and correction. Certainly, each of them has its own pros and cons.

Appium is good in testing both your Android and iOS versions at the same time. If it is for a loyal Android developer with only Android-version app, for instance, then using Robotium is a good idea too.
Also, Testdroid Recorder will definitely save lots of time and money and It’s free. Therefore, think about testing need – functional testing, compatibility testing, UI testing, etc. – and select the right and best Android testing framework(s).

Thanks for Reading!

Read more…

Difference Between Regression Testing Retesting 768w, 1024w, 1200w" sizes="(max-width: 1200px) 100vw, 1200px" />

Many testing aspirants have difficulty in understanding the difference between regression testing and retesting. In this blog, we are going to look into the key difference between these two types of testing. Also, we are going to learn more about the relationship between regression testing and retesting.

So, let’s try to answer the question

What is the difference between Regression Testing and Retesting?

Regression Testing is a type of software testing executed to ensure whether a code change/update/release/patch has not unfavorably disturbed current features & functions of an application.


Mobile Resting in Real Devices

Get in Touch with us today for a Cost-Effective Regression Testing Suite

Re-testing is a type of testing performed to check whether test cases that were unsuccessful in the final execution are successfully passed after the defects are repaired.

In the Regression Testing, the test cases are extracted from functional testing to ensure that no new defects are included due to the software update/change & to check whether original features and functionality are working as expected. Regression testing also ensures that no new defect is introduced to the system. Once the regression test suite is created, the test cases can be automated using automation tool but the same is not applicable for Re-testing.

Jumping into the detailed comparison

Regression Testing


Regression testing is to ensure that changes have not affected unchanged part.Retesting is done to make sure that the tests cases which failed in last execution are passed after the defects are fixed.
Regression testing is not carried out for specific defect fixes.Retesting is carried out based on the defect fixes.
In Regression testing, the test cases which passed earlier can be included to check the functionality which was working earlier.In Retesting, the cases which are failed earlier can be included to check if the functionality failure in an earlier build.
Regression test cases are derived from the functional specification, the user manuals, user tutorials, and defect reports in relation to corrected problems.Test cases for Retesting cannot be prepared before start testing. In Retesting, test cases that are failed in the prior execution are only re-executed.
Automation is the key for regression testing. Manual regression testing tends to get more expensive with each new release. Automation always complements the regression test process.Test cases for re-testing cannot be automated due to uncertainty
Defect verification doesn’t fall under Regression testing.Defect verification is coming under Retesting.
Based on the resource availability the Regression testing can be carried out in parallel with Retesting.Priority of Retesting over Regression testing is higher, so it is carried out before regression testing.

In regression testing, the defect logged by tester while testing the software application is fixed by the developer. In Retesting the same defect is checked to make sure whether the defect is fixed or not using steps to reproduce mentioned in the defect.

If you like this blog, please subscribe to get all testing updates in your Inbox for FREE.

Read more…

Application testing vs Game testing 768w, 1024w, 1200w" sizes="(max-width: 1200px) 100vw, 1200px" />

What Is Different About Software Testing?

Unlike game testing, software testing greatly utilizes automation scripts, and it is the matter of testing a software application, not games. These scripts can be created before or after producing written test cases, as either can be used to supplement the testing of the other similar application or program. A number of tools and frameworks have been developed to make automation quicker, as setting up automation scripts can initially take a bit of your time.

As software testing makes greater use of test cases and test scripts, this generally means that the job of a software tester is more technical than a games tester.

The field of software testing is usually seen as a more skilled profession than game testing, even though the skills required to be a games tester are exactly the same as those needed as a manual software tester.

“For software testing, you usually need a degree in computer science, software engineering, math, or anything technical, really.” 

“For games testing, a degree may be useful and a love of games, attention to detail, and a strong work ethic can usually get you into the field.”

Software Testing

Differences by Testing Platforms

Game TestingSoftware Testing

PC, Consoles, Web/Cloud (online games likes MMOs, HTML5 and Facebook) Mobile

PC, Web, Mobile & Cloud

What Makes Game Testing Unique?

Below are the few testing types to the list of game testing checklist, which makes game testing unique.

  • Fun Factor Testing
  • Balance Testing
  • Realism Testing
  • Game Level Testing
  • Game Play Testing
  • Multi-player Testing
  • Modification API Testing
  • Game Network Testing
  • Al Testing

A game tester should have the same knowledge as of software tester, but with a special focus on what makes

Game Testing is not an easy task. It requires more dedication and concentration. Now a day’s business requires for gaming consoles and game applications that are perfect from all viewpoints. For creating a good image and better response that are required to deliver games that are free from bugs and capable to run for across devices and platforms.

In games, the app is designed to give the user the least amount of access to the actions of the program as possible.

Game designers give the players with no choice but to take time to explore and discover what the game does. They want to preserve the mystery of the game world, the pursuit, the fantasy. The harder it is, and the more time it takes for the user to obtain the ‘desired results’. “Winning”.

Mobile Resting in Real Devices

A game is an enormously complex database or series of databases, within a shell that is built to obscure its purpose from the user.

Adding a feature of randomizer, the game design is unpredictable. Events don’t function the same way twice.

As a game tester, the interaction is only with an intentionally limiting interface that is constantly changing the way of its functions, as well as the way it looks.

“It is almost impossible to know if what is in the
screen is what is supposed to be seen”.

A game tester should be able to keep track of enormous amounts of dynamic details.

In a game’s database, it is not necessary that the same series of actions do not cause the same reaction. This makes recreating bugs extremely difficult.

Game Tester 500w" sizes="(max-width: 500px) 100vw, 500px" />Games push the technology innovation envelope. They tend to drive the hardware market, while other software conforms to it.

Gamers are often technology wizards, and are looking for the next level of performance, speed, and visual quality in their game experience. Games are always developed with an eye toward the newest, fastest, latest hardware, so game testers must keep ahead of the trends.

Testers must be educated and certified in all new hardware and have it all available in the testing environment. This technological knowledge is critical in this industry because the game developer will most often take the blame if it the game doesn’t function with the new hardware, and that failure can mean game death.

Games are more system demanding than most other software, so installation, setup, and compatibility testing is critical. Game function will be affected by video, sound, memory, and other issues more than any other type of software.

In contrast to that, the latest versions of today’s business software are released to be compatible with the standard issue in system configuration.


There are many similar and unique aspects between software testing and game testing but all types of testing require experts to perform it well and in a structured way.

Read more…

6 Key Areas in Mobile Game Testing

Key Areas in Mobile Game Testing 768w, 1024w, 1200w" sizes="(max-width: 1200px) 100vw, 1200px" />

No – 1: User Interface and Functionality

The User Interface and the gameplay of the game determine the success of the game in the market. One has to ensure that device fragmentation doesn’t break any of these. In the UI various things need to be tested:

  • UI layouts and elements: All games are typically targeted for the maximal set of different screen resolutions and different types of screens. Regression testing should be done each and every time when UI layout changes to ensure that game works.
  • Menu structure and functions: Testing menu structure, functionality, and correct behavior can be automated with the help of different test automation frameworks.
  • Screen orientation: Surprisingly, this gets so wrong with many games out there. For example, if screen orientation changes during the game what happens, and what actually supposed to happen? Does the game work well in both landscape and portrait modes?
  • Screen resolution: There are lots of screen resolutions especially on Android and typically auto scale can help game developers. However, it is highly recommended to test your game across these different resolutions to ensure that the graphics do not get stretched.

No – 2: Graphics Performance

Game Graphics Performance 648w" sizes="(max-width: 648px) 100vw, 648px" />

Performance needs to be consistent across all different device variants that your game’s users have. Because of this, it is highly recommended that you use as many real devices for testing as possible. In order to determine how well your game responds to various levels of usage, you should consider creating tests which last for hours to observe how well the game as well as how much of battery is used during long usage. To determine if your game will be able to run successfully for a sustained duration under heavy load, Load/Stress tests can be used. The performance tests will measure how responsive your game can be on a real device.

For example, take a look at Gamebench. It can help game developers to understand those potential bottlenecks in performance, reveal unused potential with CPU and GPU resources, and help to push the boundaries of Android gaming and visuals, without forgetting the most important thing – a need to test the game on real devices.

No – 3: Usability and User Experience (=Good Entertainment)

Testing usability, navigation flow, and eventually, what user experience your game delivers to gamers simply cannot be done on a desktop with a mouse and keyboard. So forget emulators and use only real devices for testing. And to get the best possible understanding of how great usability and entertainment your game is providing, here are two important things you should consider when testing ‘user experience’:

User Interactions and Excellent Responsiveness – It is important to test the game for its performance as this will make either the positive or negative user experience. For example, performance lags are easy to expose using actual devices.

Mobile Resting in Real Devices

Real occurring events on background – Interrupts, battery consumption, how charger effects to overall performance and usage. These all have the significant impact on user experience – and good entertainment level.

No – 4: Multi-player/User Features

Nowadays, multi-player/user feature is very common in mobile games. A need to test multi-player abilities is there and is naturally more challenging and requires the other end to perform as a real counterpart. For example, the typical case is that the game communicates with the backend server. In these cases, connectivity is essential and the synchronization between backend and devices that need to get information about the gameplay. There are tons of different scenarios you should be testing and many of those will severely impact the game’s experience, resulting in negative feedback and gets uninstalled by users.

No – 5: Social Integrations

Social network integration is also very important part of your game. In many games, it is essential to be able to share results across your ecosystem, friends or just for yourself. This should be thoroughly tested in the context of real Android and iOS devices, with different OS versions and different device configurations, to understand the functionality and easiness-of-use.

Social Integrations in Game Testing 583w" sizes="(max-width: 583px) 100vw, 583px" />

No – 6: Security and Liabilities

Nearly all game developers use some open source components as part of their game. This is highly recommended and well-accepted development practice as it offloads the task of developing code for non-core functions in your mobile game. However, identifying third-party code, its vulnerabilities, and license restrictions are very often neglected by game devs.

This was the first blog post on the series of the Best Practices in Mobile Game Testing. Next time we will focus more on graphics, image recognition and other things related to improving testing for your mobile games.

Read more…

Mobile testing has become a nightmare due to increasing number of devices and configurations that mobile apps and websites need to be cross-checked against. These tests should confirm the seamless running of applications. Thankfully, today we have a wide range of testing tools for thorough testing.

These tools can be categorized into three broad categories: emulators, simulators, or real devices.

Well, few may say that emulators and simulators can be clubbed in a single group. But, real device testing does what the name implies – it tests the application as they run on the users’ smartphones.

Let’s take a deeper look at the categories.

Real device mobile testing requires the use of the actual smartphone. But emulators and simulators are based on the concept of virtual testing. Virtual testing involves testing the software that provides the same functionality as provided by the real phone.

For testing mobile apps, an emulator is a desktop application that mimics the hardware and OS of the applications that should be tested. A simulator does not mimic the hardware/OS, but rather it mimics the basic behavior of a device. While simulators are usually simpler in function than emulators, they are not as useful as emulators. Real device testing checks the functionality of mobile apps thoroughly and ensures the appropriate working of the apps.

Emulators provide better results compared to simulators as they can be used to test specific situations or cases, and also can mimic multiple devices. Emulators are often used more as they are relatively cheaper – specifically if compared to real devices.

Emulator/Simulators VS Real Devices

Let us try to compare what provides better benefits in the following scenarios:

  • Situation-based scenarios: In situation-based scenarios, buying required mobile devices may be tough – while using the emulator/simulator may take care of the need. This means, not all the scenarios can be tested in simulators/emulators – this is possible only if testing is done on the mobile.
  • Ease-of-use scenarios: Emulators or Simulators make testing the plethora of apps on the multiple mobile devices available today much easier, but they miss out the UI and UX aspects of an app, including the color and brightness display.
  • Ease-of-access scenarios: Testing on mobile devices is reliable – however, testing on Emulators and Simulators makes it easier as it requires only the URL for the app.
  • Validating battery scenarios: Mobile devices can perform this test as required whereas emulators and simulators usually are not able to mimic the issues related to the battery.
  • Validating Performance: This is a very crucial part of testing a mobile application. Testing the performance of an app on a mobile device usually gives a more accurate result as compared when tested on emulators or simulators.

Which is the better option?

While both Emulators and Simulators look like great alternatives for testing apps, since having a wide range of real devices also accounts for the cost involved. But, they have issues that may generate both false positive and negative results, which will surely have a negative impact on the business ROI. Another disadvantage of emulator/simulator is that howsoever much close their feature may be to the real app, emulator/simulator may still not cover all features/scenarios and the results obtained may not be as accurate as we would want them to be.

Real device testing wins the challenge over either of the two. With an efficient testing process, real devices can validate for every possible scenario with almost 100% accuracy.

However, having all three options have their own benefits, and can be used according to the need, helping the organizations meet their goals.

Subscribe to read more on Mobile Test concepts, tools, and strategies.

Read more…

Mobile Game Performance Testing 768w, 1024w, 1200w" sizes="(max-width: 1200px) 100vw, 1200px" />

This article is the continuation of our previous topic in Mobile Game Testing. In this article, we are going to discuss the State of Mobile Gaming with the key aspects of mobile game performance evaluation.

To understand more about the mobile gaming performance, let us take a look at some interesting numbers to relate.

Game Performance 619w" sizes="(max-width: 619px) 100vw, 619px" />

game performance testing 630w" sizes="(max-width: 630px) 100vw, 630px" />

The above numbers give us a clear picture of the diversity of mobile games and the performance of any mobile game is closely related to its user experience. This makes us think more about the performance factor so that the players don’t get disappointed.

Striking graphics, rich media, animations and their effects makes the mobile game attractive, but if the performance of the mobile lags, then they are pretty much useless.

In the gameplay, gamers expect consistent progress and should experience a personalized touch of the game, and nothing should slow down their gaming experience.

This explains the importance of performance evaluation of every mobile game.

Game Testing Services 450w" sizes="(max-width: 450px) 100vw, 450px" />

There is the wide range of methods and tactics to test the performance of a mobile game. Naturally, this leaves us with the option of using real devices (phone, tablet) and preferably different versions of those.

It’s not overstating to initiate performance tests in the early phase of mobile game development. The sooner we spot the performance bottlenecks; the better the game will be. Before the game gets published in Google Play or App Store, games should have run through different types of performance tests on all possible device configurations.

For example, the most common performance test done for mobile games is the general stress test to determine the responsiveness and stability of the game. The game should have the consistent performance for certain load or user interaction pattern. Below discussed are the mobile game performance testing checklist which should be considered before publishing a game.

There are three pillars Mobile Game Performance Testing

Device Performance Test 600w" sizes="(max-width: 600px) 100vw, 600px" />

Device Performance Testing

When the user experiences the slow game, they get annoyed.

For device performance, the following should be checked –

Game Start Up

How much time the game takes to start up?

It is the first game performance parameter adjudged by the user. As a thumb rule, after the user taps on a game icon the first screen should be shown in 1-2 seconds.

Battery Time while playing

Constant use of mobile games consumes a high amount of battery life and heat the phone. This factor contributes a lot to the performance of any mobile game and could normally happen when the game is using more resources than required. Excessive resource usage creates a load on the processor and phone gets heated up.

Memory Consumption

When testing a mobile game, the memory consumption should be given priority. Adding more functionalities to the game increases the memory consumption.

For example, in a game with push notifications and social integration consumes more memory compared to other games.

In some cases, it has been observed that memory usage by the whole OS is mere 14%, but the game by itself consumes 11%.

So, this must be handled before launching the game or by launching it for beta testing.

Hardware/Software Variation

We have already discussed in this blog about the diversity of the mobile devices. It is mandatory to validate the game performance on different devices.

It could be the case that the game is running smoothly on one device but not on other. Like for different vendors of Android devices, the game should be checked on Samsung, HTC, and Lenovo phones.

Similarly, the game needs to be tested with different RAM and processor specifications.

Usage with Other Apps

When the game under test is running in parallel with other apps, there should be no interference. The best way to check it is by switching game under testing and other apps.

App in background

An app that is running in the background is retrieved, it should remain in the same state as it was before. If this scenario is not handled properly, then the data get lost. Again you have to enter data from scratch upon retrieving the app.

Testing Server API Performance 768w, 1024w, 1701w" sizes="(max-width: 1701px) 100vw, 1701px" />

Testing Server/API Performance

When the game is interacting with the server via API, the response time becomes critical to evaluate the game performance.

For Server performance, the following factors are to be considered-

Data to and from server

The game should handle data efficiently that is sent from the server. It must not take too much time while loading the data. In certain games, data is sent in a specified format. So, before displaying it in the game, it should be converted to the relevant format. In this process, games sometimes become slower and response time becomes longer.

API Calls Generated from Games

The number of calls raised from the game under test should be lesser to the calls generated by the server. In some cases, multiple API calls are made for the same functionality. For better performance, this should be handled with less number of calls.s

Server Down Time

Due to some reason if the server is down or unreachable then the data can be saved in the native database. So, whenever the server is down, the data which is saved in the native database can be shown. Another solution could be the failover database servers i.e. if one of the servers is down or in maintenance phase the backup server should be available to switch over. The failover/backup server should always be in continuous replication and synchronization with the main server.

Network-Performance-Testing 768w, 1024w, 1701w" sizes="(max-width: 1701px) 100vw, 1701px" />

Network Performance Testing

The performance of the game on different networks and network properties need to be measured.

For Network performance testing, the following things should be checked.


When there is a delay in receiving information on the network, then it is termed as jitters. It is a problem with the connectionless networks or packet switch networks. As the information is distributed into packets, packets can travel by a dissimilar path from the sender to the receiver. When data arrives at the intended location, it becomes scrambled than it was originally sent. In the case of Jitters, the game should be built in a such a way to handle it.

Appropriate notification should be sent to the end user, either to resend the request or wait till the system responds again.

Packet Loss

In the case of complete packet loss, the game should be able to resend the request for the information or should generate the alerts accordingly. If data is incomplete, then the player will not be able to comprehend information displayed in the game. This can be stressful for the player. So, it is better to display a suitable message or prompt player to try again.

Network Speed

The app needs to be checked on a variety of networks with variable speed. The app should be tested on 2.5G, 3G & 4G networks. Both Wi-Fi and mobile networks are included in this. Also, the behavior should be monitored according to the network. Especially, when both networks are available, and switching between one network to another.

For example, an issue may arise in the game for the users while switching phone network from 4G to WIFI and vice versa. In this case, the game becomes unresponsive and may require a restart before the gameplay.

That’s pretty much about the performance factors of Mobile Game Testing.

Happy Testing!

Stay tuned to read our next blog on Mobile Testing

Please comment with your queries. We will be very happy to help you.

Read more…

Test Automation in Large Scale

Test Automation in Large Scale 768w, 1024w, 1200w" sizes="(max-width: 1200px) 100vw, 1200px" />

Digital businesses must adapt to new functionalities into production on daily basis to take full advantage of the flexibility offered by the virtual world.

Automation for digital business is not science fiction. It’s real and happening today. For one of the largest U.S. Federal programs, more than half a million business process were automated every day in 2 hours on more than 100 virtual machines.

In another example, a global manufacturer of luxury brands validates their core business processes worldwide with 600 hours of automation on more than 30 virtual machines every day!

We can see every day that today’s digital technology projects take place on a swift timeline than ever before, where typical projects last days-to-weeks rather than months-to-years. Large-scale automation makes it possible to deploy this new business functionality early and often – while significantly mitigating risks of business disruption or major glitches during the process.

The real world scenario explained in three words

FAST                FREQUENT                  FLAWLESS

Test Automation Large Scale 300w" sizes="(max-width: 300px) 100vw, 300px" />The quality of application is determined by its swiftness, frequency of updates and defects

Automation is the key. Test Automation for process validation and functional testing allows you to run through literally millions of business process steps just like the end users, to validate that no code is broken.

Though test automation does not look a very rewarding or a feasible option due to the costs involved in setting up the environment or the tools – but definitely, in the long run, its benefits surely surpass the initial glitches.

It is said, that “there’s a method for every madness”.

To maximize the ROI using Test Automation, a specific plan of action is required.

What actually might set up the best way of implementing large scale test automation so as to maximize ROI?

  1. Robust Product Road Map: When organizations begin to automate anything, they should ensure that they have a clear goal set. There should be absolute clarity on the product road map and on the automation check list. Else, there will be confusion and chaos around the whole process and the efforts prove to be a big scale failure. Hence, defining the product roadmap is a must.
  2. Optimized Test Process: To meet a defined roadmap, a clear demarcation of the test process is a must. The test process must be defined keeping in mind the risks, costs, and training involved while implementing test automation.
  3. The Framework: Whether it is a data-driven or a keyword-driven framework, or a hybrid one, defining and selecting a framework will have a definite positive impact on the ROI as it will implement the road map you defined earlier.
  4. Tools to be used: Though testers have a wide variety of choice for testing solutions, wrong decisions regarding the test automation tools can lead to effects that may not be reversible. Therefore, selecting the right tools is a business-critical requirement for ensuring successful test runs. All variables such as integration, installation, cost, maintenance, and compatibility with the testing environment must be considered while selecting a tool. 
  5. Script Management: The scope of script management usually floats around the areas of the standard process that are well documented, logging the errors that are generated, and most importantly testing if the script was written is able to withstand unexpected behaviors.
  6. Manual Effort: Automation is an end result of a lot of manual activities such as script and test case writing, setting up the machines and selecting the tests, and once the test is run – analyze the results. These cannot be done in a jiffy, and need to be planned for both costs and efforts.
  7. Testing Team: If an organization realizes the significance of the manual effort required, it must give a due diligence while planning the work and effort estimation with regards to the team and the skills required for the implementation of test automation.
  8. True Measure of Success: A few good examples of this definition may include measuring benefits such as faster time to market, improved ROI, or, on the other hand, the number of bugs have decreased. 

Scaling up with virtual machines

Test Automation ServicesThe automation framework can be run on masses of virtual machines in the cloud to get scale. During automated business process validation, each of these machines interacts with the applications, running through all complex business scenarios with real time data. This verifies that things are working as expected. The machines will only be turned up on demand and can be decommissioned when the scenarios finish executing.

Please share your thoughts on test automation. Subscribe to get notifications on our upcoming test automation blogs.

Read more…

Accelerated Mobile App Testing powered by pCloudy

When it comes to the more favorable app in the market, the true measure of a developer’s success is the app’s retention rate. An app has to have the right mix of touch, feel and design for the best user experience that represents your business value; as well as the functionality and performance true to the needs of the user and his device health.

With touch devices everywhere now, more than 3 million apps for those devices are available for download and the numbers keep on increasing. App users are increasingly demanding too. When reports have shown that Android users are far more likely to uninstall apps than iOS users for a number of reasons, it becomes easier to collate it with the information that currently Android users are more than four times the market share of iOS devices. Both have a duopoly of 99.6 percent in smartphones. At the same time, unlike iOS, Android is pretty fragmented. Which means, your app must be compatible with tons of device versions and Android versions.

Hence, more and more businesses need to churn out apps for their growing users, and developers having to churn out more and more apps faster, with qualitative inspection of each application that shouldn’t lag, crash, have bugs or glitches, drain phone memory or battery and work anywhere in the world from a smartphone. Added to that, 70 percent of apps get deleted by users within a couple of minutes of their installation.

That’s a tall order!
And technology is the only way to sway the game in our favor.

If your app has to compete on the qualitative level of a 5 star rated app in the app store, it needs a thorough and quick check before you hit the launch button. In-house testing within companies can only do so much, there aren’t enough device in-house, there is a lack of right tools or the testing cycles take far too long to make it to the market before ten new apps pop up in the app store. Low ratings, mean low revenue.

How pCloudy is changing the game
Machines and intelligent technology are the newest recruits to the workforce in the world. We at pCloudy have always worked with an approach to apply technology to exponentially enhance the ability of individuals, teams, and businesses.

pCloudy’s helps you create the magical combination of your internal workforce and intelligent platform. With pCloudy, your teams get a wide spectrum of the latest Android and iOS devices in the market to maximize testing coverage, cognitive software bots to run quick, thorough checks on your App and the power of the crowd so that you are aware of what your users think about your app.

pCloudy has developed a Single Click App certification feature within its platform enabling testers to deliver on faster test cycles for users whose attention span is shorter & shorter with every bug, crash, drain or slip that an app can suffer from. Reality check is critical for every developer. So is the need for it to be quicker.

Today pCloudy is working with global companies who have often realized not just the growing potential of the market, but also the need for a crucial wing for testing with pCloudy’s platform. This is probably due to a growing desire from companies across sizes to fully understand the buyers experience consistently.

Watch out this space as we unveil the power of pCloudy’s Test Cloud over next couple of weeks.

Sign Up for Free Trial to test your apps on real android and ios devices Click Here.

Read more…

Free Webinar (September 12 at 11:00 am PST): Accelerate Your Automation With API Testing

Application Program Interface (API) is becoming the go-to technology as we move forward towards an era of automation. With APIs becoming an integral part of the upcoming products and services, it is important to consider API testing as an important aspect of automation.

Join Rajeev Rai, CEO at QASource, one of the well-known API testing company in the webinar ‘Accelerate your automation with API testing’ on September 12 at 11:00 am PST.

You'll leave this webinar with:

• Latest trends of API testing
• Best practices
• Case Studies
• Actionable plans and
• Free takeaways

Organized by : QASource
Presenter : Rajeev Rai
Time & Date : September 12 at 11:00 am PST
Registration link :

Read more…

If recent past has been any indication, then it is a certainty there are growing expectations from Testers and Developers alike, to take quality head on, as a joint feature. More so in the Mobile App Testing projects where changes are required faster than ever.

As part of DevOps practices, it’s has become imperative for developers to run as many tests as possible with every code check-in. These tests could be automated functional, API or Unit Tests. Some of the popular tools to used by Developers to create their tests are Espresso, XCTest and Appium.

Following are some the Challenges faced by developers:

  • Developers need access of right set of devices across different versions to be able to run their tests.
  • Debugging capability on those devices so that they can fix issues quickly.
  • Access to a specific model of devices to debug production issues.

Try taking a look at a typical developer’s cubicle and you will see a series of mobile devices connected with several long USB cables running into computers. It does get frustrating to see others furiously plugging USB cables in and out of the mobile devices for App Testing on various devices.

Many of the organizations are shifting to device cloud to provide their teams access of right Mobile Devices. Device cloud are solving the need of test teams but provide limited debugging capabilities and hence not preferred by Developers.

To directly address need of Developers, pCloudy recently introduced DeviceTunnel, which fully allows developers to take complete control of the device in cloud. This unique solution provides access of cloud devices through the Android Studio or Eclipse IDE and the command line tool installed in your computer.

It works as if Device is connected directly to your computer through a USB cable. From the point of view of tools like Android Studio or Eclipse, a cloud-based device appears physically attached. In reality, the Device Tunnel communicates with pCloudy’s servers over Internet.

App Testing

Access devices directly from your terminal

Once a connection is established, the developers can perform the following actions on these devices:

  • Issuing a range of ADB commands for debugging, shell creations, port forwarding, and viewing general information about any cloud-based Android device
  • Copying and pushing files to connected cloud-based devices
  • Installing and uninstalling applications
  • Debugging apps during development or testing by adding breakpoints, inspecting variables, analyzing run-time metrics to optimize your app and more
  • Run their tests on the device directly from their IDE

To know more on how to connect any device on pCloudy using Device Tunnel Click Here.

It is undeniable that developers and testers need quicker access to diverse devices for the brisk evaluation of app and debugging. Device Tunnel enables both sets of engineers to instantly connect to any device hosted on cloud and run faster debug sessions and thereby, maximize the quality of their build cycles.

Sign Up for Free Trial to test your apps on real android and ios devices Click Here

Read more…

Testing the battery Drain for Android App

If you are anything like me, you’d agree that the armor of present day mobile phone technology has a few chinks on it. Nothing is worse than applications draining the battery resources of your mobile device faster than you can fill it back up. The sunnier side of course, is that you can create teachable moments for your kids better by hiding their phone chargers and watch the colors drain from their faces.

Studies show that battery life is a top priority for smartphone buyers. In fact, just recently, an IDC survey showed that 56% of Android buyers, 49% of iPhone buyers and 53% of Windows Phone buyers said that battery life was a key reason when they bought their particular device.

It is rare to find mobile app testing tools that assure proper usage of resource by the mobile app as, included in the overall test plan and strategy.

It’s rather a tedious and long process for conventional mobile app testing methods and as such, Let us talk about how resource consumption as an app takes top priority, because nothing stops a user to uninstall their resource draining apps from their phone. Also we’ll talk about how developers and testers efficiently test mobile apps for Android applications.

Why battery testing is important:

Thousands of new mobile apps are being launched every day. And these apps have gone beyond just utilities, games and shopping apps, nowadays, apps need to be integrated into self-driving cars, digital assistants, wearable devices etc. Billions of users need to install apps that are not only compatible with their varying devices, but also provide quality experience of the app so that it doesn’t prompt the user to uninstall it and move to an alternate app.

When you get worried about potential battery abuse, its fair economics to identify the markers that can cause increased consumption of energy by the mobile application. Critical are the functionality, usability, performance and security to make sure that the app does what it was meant to do, seamlessly. The growing need for perfect enterprise and consumer apps and the continuous need to upgrade the application to match it with what the consumer exactly wants is a job that creates high pressure for developers and testers alike, who are responsible to delivering them.

We would get deep into the best practices and tactics that should be kept in mind while testing for battery drain in your mobile app in a later blog post. For now, let us look at how developers can test for battery consumption during Android App Testing.

How to test battery consumption for mobile apps:

So far there hasn’t come a good automation method to test app battery drain. So testing Real Mobile Devices meets many requirements for efficiency in the process. Let us check out a few parameters to test battery drainage due to mobile apps.

  • Battery test flow

This will vary based on the functionalities of the applications. But overall the below approach or points should be considered while testing for battery consumption.

  • Check the status of the battery before the test begins
  • Enable the location services for the application if app supports
  • Start the data sync of the application if app supports
  • Start the streaming service of the application if app supports
  • Check if the application send/receive the data when in the background
  • Check if the application send analytics to its server
  • Observe the battery consumption while doing above supported features by your application.

This will give us an idea as what is the battery consumption by the application.

  • Testing as end user

It is very critical to test the environment needs of the app from a real user perspective. Environments like device types, operating system, background popular apps installed and running, network conditions (WiFi, 2G, 3G, 4G, Roaming) as well as diverse set of devices with different battery states, brings DevOps teams as close as they can come to end users.

  • Android App Testing across varying devices

Android is guilty of OS fragmentation due to its open approach to OEM vendors. Different devices have varying battery capacity and each loses its battery chemistry over time, negatively impacting performance and battery hours. This is why we must check the battery consumption for the mobile app on variety of mobile devices. The best practice is to use multiple devices from device labs/ device clouds.

Different tools available in the market.

Android’s built in Battery App

Your Android Mobile Phone has a ubiquitous battery testing resource, as it comes preinstalled on all Android mobile devices. Android’s native battery analyzer, for example, (Settings> Device> Battery) is built into Android’s OS and helps analyze each app and let you know which are the ones draining the most fuel.

Commercial Battery Saving Apps

There are a few commercial Android Battery Analyzers which are available for free in the market, like:

GSam Battery Monitor can reset testing cycles as you go, which means there is no need for draining and recharging the battery like in android’s native battery app, and monitor app power usage without having to wait to get an information reset.

Clean Master on another hand, lets you know through its notification feature as and when an app is causing the phone’s battery/CPU to drain, which gives instant information on any CPU overuse.

pCloudy platform for Testing Battery Drain

pCloudy platform allows comprehensive features for Android App Testing. Moreover, Using pCloudy’s platform, one can monitor the battery consumption by the application. additionally, the user can also monitor memory, CPU and data consumption by the application.

The user can do the complete functional app testing on the application by touching all the critical/non-critical paths in the application. The pCloudy platform provides the necessary data for the work flow.

Sign Up for Free Trial to test your apps on real android and ios devices Click Here.

Read more…

Trends in Mobile Test Automation

Hello, Readers!

In this blog, we are going to discuss the trends in Mobile Test Automation.

Test Automation and Unlimited Concurrency

First of all, it is difficult to perform a huge number of test runs on device farm without test automation. Test automation is the enabler that makes concurrent use of mobile devices possible and enables users to run their application and test simultaneously on any number of devices. This is also one of the sweet spots of any testing vendor/test team as there is no limitation on the number of devices that users can use simultaneously for their tests.

It’s a great news for the native app and game developers as they can use the same device roster too. But, with slightly different test scripts and frameworks. The same foundation serves both the user groups extremely well.

Test Automation 300w, 50w, 65w, 641w" sizes="(max-width: 641px) 100vw, 641px" />Especially during the past two years, mobile test automation has come into play and helped mobile game/native app developers to quickly and easily see how their games work across device combinations and versions to get the vital debugging information on which things should be fixed before the release. This has produced tons of great data of how game/ app can be optimized for end-user devices.

Today, the mobile test runs hammer thousands of devices every day, producing an enormous amount of data, results, screenshots, recorded videos out of devices runs, and performance statistics. This shows how a mobile app/game work on these different handsets.

From the recent survey data, close to 84% of mobile test runs were done on Android devices and less than 16% on iOS devices. This provided just a bit higher failure rate (17.8%) than on iOS devices (15.5%).

This sort of finding states that there are lots of issues also on iOS devices, with an increasing trend. Mainly, this is because of new iOS versions and some new form factors with iOS devices plus new APIs, new notification system etc.

What’s really awesome to see is that concurrency has been going up quarter by quarter. The average number of used mobile devices per test run is now over 10 devices per a test run. However, there is still lots of outliers and variation, as many of users still use one-device-at-time and some test automation experts use tens (or sometimes even hundreds) of devices simultaneously for their test runs.

The average test time also varies a lot.

For example

Quick and fast tests typically complete quickly to some extent, through Appium where some test runs may even take 10x time. As expected, it’s all about the scope of testing and the logics included in Appium tests. 

The Most Popular Mobile Test Automation Frameworks

Appium is the most popular framework for functional testing of mobile apps, games and, to the certain extent, mobile web as well (we didn’t include Selenium in these numbers as the majority of all those selenium tweaks are more or less Appium-based). There are lots of good reasons why people have been using Appium (cross-platform, support for literally any programming language, great coverage with API etc) and frankly, it has worked extremely well until recent changes with iOS UI Automation.

On Android, Espresso and UIAutomator have been very popular as well. And they’re also good reasons why people use/love these frameworks. Espresso provides very fast test execution and UIAutomator provides a light-weight API that is easy to adopt and use for your native apps. Both these frameworks, however, are somewhat limited to native apps. Again, the majority of the developers either use Appium or some internal grown/developed framework.

Another (promising) new framework that has come into play is the Robot Framework and it quickly took over the Robotium, which used to be one of the mainstream frameworks in the early days of Android test automation.


On iOS Appium and Calabash, both being cross-platform frameworks, have been popular choices for iOS test automation. As many developers have been using Appium it’s also obvious from the data that usage has been on both major platforms – Android and iOS.

Another highly used framework on iOS has been UI Automation (until the last quarter of 2016). Since then, there has been (and will be) a clear replacement movement to some other framework and I’ll cover this with a bit more details in the next chapter.

On both platforms, there are also lots of other frameworks that didn’t get listed here. Some of those are internal, proprietary or just niche frameworks that their users happen to use. As stated, there is no wrong choice for the framework if that does the job efficiently and provides exact results on how apps, games and web stuff work on real mobile devices.


Okay, let’s speculate a bit.

Currently, we don’t see any major changes taking place in Android mobile test automation. Appium, Calabash, and Espresso will be definitely in high use and probably even grow stronger as Google tends to favour Espresso and there are lots of Appium fans out there as well. Calabash hasn’t provided much new to the ecosystem lately but one of its strength is that “if you speak English, you can write a mobile test”.

The most significant changes are going on in the iOS side of things. As UI Automation got deprecated by Apple, XCTest and XCUITest got an excellent start to be the next big frameworks in iOS test automation. However, the change by Apple hit Appium, as it was relying on UI Automation as its foundation.

android ios tools levels

Now, the big question is that what happens to Appium with UI Automation depreciation. If things start to work well with Appium, there is a good chance that many of UI Automation users go to Appium (instead of XCTest/XCUITest, that we see on going now). It’s always worth to consider which framework (XCTest vs Appium) could provide a more stable environment for test automation runs for next years.

If you are looking some guidance on what’s going on with Appium (and how to use the latest version of it efficiently), take a look at this awesome post by my colleague.

Alright. Let’s speculate a bit more. Let us know in the comment section below which frameworks will fall, which will flourish, and why!


Read more…

mobile apps performance testing 768w, 1024w, 1200w" sizes="(max-width: 1200px) 100vw, 1200px" />

Why is performance testing important for mobile apps?

Why is performance testing important and why should you be doing it? Well, very simply, it is the key to user engagement, getting people to use your app and continue using your app.

User engagement/experience is definitely a challenge on mobile. This graph is based on data from Apple and Google shows that 80% of apps are never used again after the first day they are downloaded and less than 4% are still used a month after they are downloaded. Looking at the graph, it’s evident that keeping users engaged with your mobile app is difficult.

A side point is that I have had people in the past say that while they accept this for consumer-facing apps, it’s not relevant to them because they are making employee facing apps or some other B2B type apps. But the reality is that adoption and engagement are just as much a challenge in employee facing apps as it is in B2B apps.

Going a bit further I would like to illustrate with two examples with data points, which basically impacts the impacts of performance of user engagement and ultimately the revenue

  • Amazon has reported that a 100-millisecond increase in response time of their app reduces revenue by 1%.
  • Google reported similar findings that a 100-400 milliseconds increase in search response time led to a $90 million dollar reduction in ad revenue.

It’s important to note that there’s nothing unique about Amazon or Google, meaning that this impacts them. So, clearly performance is critical to users, so we need to be testing it.

Importance of Mobile Apps Performance

As the usage of mobile phones is increasing, the importance of mobile apps performance is also increasing simultaneously.  Mobile phone users are very demanding and always expect mobile apps to perform like their desktop apps.

According to a survey,

  • 71% users expect a website to open on their mobile as quickly as on their desktop.
  • 5 seconds is considered as turnaround time for mobile applications and websites.
  • 74% users leave the mobile websites and 50% users exit mobile apps after 5 seconds or more response time.
  • 35% of the frustrated users go to competitors’ applications.

Normally mobile phone users try to access the troubled application twice and nearly half of them never return to the application if they still face the same issue(s) on their mobile device. Achieving and maintaining a good response time of a mobile application is more challenging for performance engineers than a desktop application due to its complex architecture and fewer resources it uses.

Difference between Traditional Desktop Web Apps & Mobile Apps

The both Desktop web applications and mobile applications are quite similar technologies and don’t need to select a unique performance testing tools for mobile apps.

Top 5 Mobile App performance related issues

Client Side

Server Side

  •  Network (Wi-Fi-/2G/3G/4G) impact of connectivity issues
  • CPU Usage
  • Memory Usage
  • 2d & 3d Graphics Card
  • Battery Usage consumption 
  • CPU Usage
  • Memory Usage
  • Cache
  • I/O
  • Bandwidth Usage
  • Connections

Top 3 Performance issues which we have encountered while carrying load testing of mobile based application and solution

Bandwidth Consumption issue
1During our mobile app performance, test execution network bandwidth was high due to image & page size was hugeBandwidth consumption decreased by compressing and reducing page & image resources to make it faster
Response Time / Page Load issue
2During mobile app performance test execution, the page load time was high.Reducing the number of HTTP requests between the client and server.
Data Loss Issue
3We experienced in one of our microfinance client application while filling the forms and uploading the images in mobile application and if network connection loss/drops the middle of completing all the data will lose.Create an offline mode/data save option method in the mobile application so that whenever network drops the data won’t lose. We can resume the continued activity once the connection has been re-established. This kind of method will use for travel apps


There is no choice about the exponential growth of mobile application usage in this world. To better user experience the mobile apps should be quick to respond as expected by the customer.

The Performance testing of mobile apps is not different from our traditional web/desktop applications. However, Performance engineers need to understand all types of mobile apps architecture and details completely (like Network bandwidth, screen size, processing power etc…)so that it will improve the user experience and apparently the user base & revenue.


Read more…

Integration of TestNG project with pCloudy platform

TestNG is a testing framework inspired from JUnit and NUnit but introducing new functionalities that make it more powerful and easier to use.

It is an open source automated testing framework; where NG of TestNG means Next Generation. TestNG is similar to JUnit, especially when testing integrated classes.

TestNG eliminates most of the limitations of the older framework and gives the developer the ability to write more flexible and powerful tests with help of easy annotations, grouping, sequencing & parameterizing.

Benefits of TestNG

There are number of benefits but from Selenium perspective, major advantages of TestNG are:

  • It gives the ability to produce HTML Reports of execution
  • Annotations made testers life easy
  • Test cases can be Grouped & Prioritized more easily
  • Parallel testing is possible
  • Generates Logs
  • Data Parameterization is possible

Architecture of the TestNG framework


pCloudy platform provides single click access to real Android and IOS devices directly from your browser. Use these real Mobile Devices to click-and-perform Manual Testing and execution of Automation Testing for your App. Integrate our platform with CI for continuous Automation Testing and test your App on multiple real Mobile Devices with every change of your App.

Now it’s very much simple to integrate your existing TestNG project with pCloudy.

Architecture of the TestNG framework with pCloudy

Read full article @ .

Sign Up for Free Trial to Test your apps on real android and ios devices Click Here.

Read more…

Why Mobile App Automation Testing?

Testing of Mobile Apps in quite cumbersome because of sheer magnitude of testing required on variety of devices. Moreover, Mobile Apps require changes faster than other kind of Applications (Web or Desktop). That’s the reason, more and more organizations have started realizing the need of using Automation Testing as much as possible.

Mobile App Automation Testing can be a massive undertaking, and if unaware, one can end up complicating the process by selecting a bad tool. With a major trending shift to open-source mobile test automation tools, there have been a plethora of tools available in most open-source software markets.

So how do you know which are the best tool available in the market? Which tools will give you the most efficient solution to fulfill your enterprise’s need for speed and integration?

This blog post is to help you quickly choose which open source test automation tool will be right for your automation testing

Benchmarks for selecting the right tool

You would need a set of criteria to fulfil when assessing your selection of the right open-source automation tool. Here are a crucial few questions to ask:

  • Do you have the required skilled resource for automation tasks?
  • Is there ease of script development to support agile processes and shorter iteration cycles?
  • Does the tool support cross team collaboration for seamless use by QA and Dev?
  • Can it match app platform with test development language?
  • Will it have performance capabilities gaps while testing?
  • Will it support both real devices and emulators?
  • Does the app support multiple platforms — Mobile and Web?
  • Does it have multi device execution capability
  • How easily can it integrated with external Device cloud platforms?

Best Open-Source Mobile Testing Frameworks to use:

To take the final call, testers must have a strong awareness of the tool’s strong and weak aspects, what it can do and what it cannot, and find a balance between cost and benefit.

These are top highly adopted open source test automation frameworks available in the market. Each of these frameworks are backed by different communities due to their unique offerings to the target audiences and relevant platforms. The overall benefits are that they cover a wide range of devices. However, for technical clarity it’s important to know the pros and cons of the framework based on your mobile and web testing needs:

1. Appium: Widely adopted, it is the leading open-source test framework for mobile app (Android, iOS) test automation.


  • Best suited for QA teams to test the functionality of mobile web, native and mobile hybrid apps across iOS and Android.
  • Its reports are limited from debugging and fast feedback loop.
  • Supports development tools using any WebDriver compatible language including Java, C#, Ruby etc.
  • Cross Browser Support and cross platform capabilities

Con: It is less suitable for performing and developing unit testing.

2. Calabash: It is a Behavior-driven development (BDD) test framework based on Ruby development language.


  • Has a large community support
  • Cross platform development support (Android and iOS)
  • Provides solid reports and insights to QA and Dev teams
  • Easy path to both develop and test features in parallel
  • Simple and easy-to-read test statements

Con: It is not friendly to languages other than Ruby.

3. Espresso & XCTest UI: Both are very similar tools as they were designed for the target users. Espresso for Android and XCTest for iOS are fully maintained by Google and Apple, assuring the latest features for respective platforms.


  • Latest feature integrations assure lead in market curve for developers and testers
  • Easy to develop techniques including test recorders
  • Support both types of unit testing and functional UI

Con: Both are app context only, which means limited ability to test for user condition scenarios

4. Selendroid: An open source automation framework which drives off the UI of android native, hybrid and mobile web application. A powerful testing tool that can be used on emulators and real devices. And because it still reuses the existing infrastructure for web, you can write tests using the Selenium 2 client APIs.


  • Can interact with multiple Android devices and simulators simultaneously
  • Can simulate human actions like touch, swipe, drag etc. on devices
  • Supports development tools using any WebDriver compatible language including Java, C#, Ruby etc.

5. Robotium: Widely adopted open source Android test Automation framework.


  • Easy to write powerful test scenarios
  • Full support for native and hybrid Android Apps
  • Easy to use recorder
  • Handles multiple Android routines automatically

6. EarlGrey: EarlGrey is a native iOS UI automation test framework that enables you to write clear, concise tests. It integrates with Xcode’s Test Navigator so you can run tests directly from Xcode or the command line.


  • Works directly from XCode
  • Full support for native and hybrid Android Apps
  • Synchronization features which automatically synchronizes with the UI and network requests.

Sign Up of Free Trial to test your apps on Real Android and iOS devices Click Here.

Read more…

Multisoft Virtual Academy is a renowned name in the world of online education and considered as a brand amongst the candidates, who are willing to enroll in online training around the globe. Multisoft Virtual Academy is providing more than 300 courses online; no matter whether you are from technical background or from non technical one Multisoft Virtual Academy is the perfect destination for you as it offers what your career requires to take off. The most amazing factor is the 24/7 learning access, which provides you the chance to quench your learning needs anywhere, anytime around the globe for sure.

For more info:

Read more…
Welcome to Mobile QA Zone, a Next Generation Software Testing Community.Invite your friends to join this community.Write to us to become a featured member.