Blog

Preventing App Crashes by Testing Your App’s Stability

by admin | Nov 5, 2021 | Mobile App Testing, Blog, Latest Post | 0 comments

An application crash is a developer’s worst nightmare. Even though it happens to everyone, it could be unbearable for your users and may cost you financial damages. Recurring crashes lead to more uninstalls; therefore, it’s great that there are numerous techniques to avoid them during mobile app testing. To accomplish this, your program must consistently provide a good user experience.

To ensure the stability of your application, first, identify the primary sources of crashes and devise methods to avoid them. Here’s how you can prevent app crashes by testing your app’s stability:

Memory and Processing Management

Memory difficulties are a leading cause of software crashes because not all users own high-end tablets and smartphones. As a result, your software must perform its intended functions while maintaining memory management.

To proceed, take caution not to utilize too much RAM. When possible, make use of your cache. Determine which parts of your software consume the most data or have the most complex data structures, and make sure they are all required. 

Additionally, you can also profile your program to find memory leaks. As you structure network inquiries to avoid overburdening the device, craft methods and strategies to save memory and prepare a list of what to keep and what to delete.

Error Surveillance

Once you’ve identified errors and problems, you can rectify them. And when it comes to fixing app breakdowns and issues, you must go above and beyond. One method is to monitor the performance of the Internet Information Server and look for flaws.

For example, if a user’s WiFi connection goes down during a file transfer, you can notify them via a communication channel. When failures occur as a result of unexpected app behavior, you’ll need crash detection tools in your mobile app testing kit.

App Compatibility Testing

To test your program or app, use as many platforms, devices, manufacturers, and generations as possible. You can use this method to determine your compatibility. The majority, if not all, of devices and platforms are supported. 

You must, however, be mindful of your limitations. Comprehensive mobile app testing will ensure that your app is compatible with a wide range of devices and will aid you in finding and addressing flaws before its release.

Activate Offline Use

Continuous network connectivity issues can harm your application system and may lead to a bad reputation. Users may be dissatisfied if they need your program but cannot access it due to a lack of internet access. 

By employing a local data store such as Google Room, you can create an app that functions flawlessly offline. The application’s offline mode can help you prevent crashes and freezes caused by a sluggish internet connection.

However, early testing of mobile apps on slow networks may reveal weaknesses, preventing software from becoming inoperable on all networks. So, make it a point to check if the program works on unreliable networks.

Conclusion

While not all accidents are avoidable, those that are can be corrected quickly. This notion applies to developing applications as well. To put it simply, one of the most effective ways to learn about and fix your crashes is to use crash reporting tools. As you gather data and further broaden your knowledge, you’ll be able to create an app that is efficient and useful to your users.

Are you looking for mobile app testing services? Codoid is a forerunner in quality assurance comprising a team that guides and leads the community. For your assurance, our brilliant engineers attend meetup groups, forums, software quality assurance events, and automated testing conferences on a regular basis. Get in touch with us today!

The Complete Appium Guide to Run Tests on Real Device

by admin | Nov 4, 2021 | Mobile App Testing, Blog, Latest Post | 0 comments

Appium is a great choice if you are on the lookout for open source tools to automate mobile applications. Be it native, web, or hybrid applications, Appium will be able to automate it. In addition to that, it has cross-platform support across Android, iOS, and Windows as well. Last but not the least, its support for multiple programming languages like C#, Python, Java, Ruby, PHP, JavaScript with node.js, and so on. As a leading QA company, Appium has been always been our go-to tool in many of our projects. So in this Appium guide, we will be giving you a thorough walkthrough of how you can run tests on real devices using Appium. Let’s take a look at a few other advantages that Appium has to offer before we proceed further.

Advantages of Appium

• Appium is an open-source tool that is very easy to install. Reinstallation of the application is also not needed when there are any small changes that have to be made.
• Appium doesn’t require any application source code or library.
• It has an active and helpful community.
• Unlike other testing tools, you wouldn’t have to include any additional agents in your app for making it compatible with Appium for automation. It will test the same app that will be uploaded to the App or Play Store.
• Beyond testing the mobile apps from Android and iOS, it can also be used to test windows desktop applications.
• Parallel execution of test scripts can be achieved by using Appium.

Prerequisites for using Appium

Now in this Appium Guide, let’s take a look at few of the prerequisite you’ll be needing in order to get Appium up and running. You would have to install the following,

• Java (JDK)
• Android Studio
• Additional Android SDK tools
• Appium jar file
• Appium Desktop Client
• Eclipse IDE for Java

Note: Node.js and NPM will be there by default whenever the Appium server is installed. It is not required to install node.js and NPM separately as would be already included in the current version of Appium.

Appium Guide to install Appium with Node.js

Step 1: Check if node.js is installed on your system by entering the below-mentioned code in Command prompt. Step 1 isn’t the only step where we have mentioned the codes. So make sure to use the appropriate codes we have highlighted in the command prompt.

node --version 
             
npm –version

Step 2: Download the node.js installer

Step 3: Run the installer & install node.js & npm

Step 4: Check if node.js & npm are installed.

node --version
             npm --version
             where node
             where npm

Step 5: Install Appium with node.js

npm install -g appium 

Step 6: Check if Appium has been installed

appium -v
where appium

Step 7: Start Appium

Installing Appium with APPIUM DESKTOP CLIENT in Windows

Step 1: Download the Appium desktop client

http://appium.io/

https://github.com/appium/appium-desk

Step 2: Install the Appium desktop client

Step 3: Start Appium through the desktop client

Appium Guide to install Appium on MacOS

Step 1: Check if node is installed on your system

node -v

Step 2: Install node.js

https://nodejs.org/en/download/

https://brew.sh/

brew install node

Step 3: Check if node is installed using these codes

node -v
            
npm -v

Step 4: Install Appium

npm install -g appium

Step 5: Check if Appium is installed

appium -v

Step 6: Use the below code to start appium

appium

Installing Appium with Appium desktop client

Step 1: Download the Appium desktop client

http://appium.io/

https://github.com/appium/appium-desktop

Step 2: Double click on the .dmg file to install the Appium desktop client

Step 3: Start the Appium desktop client

To verify Appium’s installation and its dependencies

Install Appium-doctor as it is a tool used to verify Appium installation. We can install it by using npm as we’ve already installed node

npm install appium doctor -g

If you want to check the version of Appium doctor, use the following code

appium -doctor --version

How to uninstall Appium

If you had installed through node.js, then use the below code,

npm uninstall -g Appium

If you had installed the Appium Desktop Client, then just delete the app

Appium Guide to connect a Real Android Mobile Device on Windows

Step 1: Download SDK tools

https://developer.android.com/studio

Step 2: Unzip the folder and then extract the platform-tools using the below code

sdkmanager “platform-tools” “platforms;android-28”

This command will extract the platform-tools

Step 3: Set the environment variables

ANDROID_HOME=location of SDK folder

Path: Append the path of the plaform_tools folder

Step 4: Check the command ‘adb devices’ in the command line

Step 5: Make the device ready

Enable developer mode to turn on ‘USB Debugging’

Step 6: Connect the real device to the computer using a USB cable.

Step 7: Run the below command

adb devices
adb = android debug bridge

Check if your device ID is displayed.

Appium Guide to Connect Real Android Device on macOS

To achieve this, you must have Java installed on your system, and the JAVA_HOME should be set in the environment variables command to check the Java –version. You should have also installed homebrew.

Step 1: Download the Android SDK

You can download it using this link directly and install it using the below-mentioned codes.

brew install android-sdk
brew cask install android-sdk

Step 2: Extract the platform-tools folder using the following command

sdkmanager “platform-tools” “platforms;android-28”

Step 3: Add environment variables

ANDROID_HOME = path of android-sdk folder

Path: Append the path of the platform-tools folder

export ANDROID_HOME=/usr/local/share/android-sdk
   echo $ANDROID_HOME
   export PATH="/usr/local/Caskroom/android-sdk/4333796/platform-tools:${PATH}"

Use the below code to set the environment variables permanently on the Mac system

   cd ~/
   cat .bash_profile

If bash_profile does not exist

touch .bash_profile

bash_profile
Press i and add the following

For setting the PATH for ANDROID_HOME

   export ANDROID_HOME=/usr/local/share/android-sdk

For adding the platform tools to the PATH

  
PATH="/usr/local/Caskroom/android-sdk/4333796/platform-tools:${PATH}”

Press the ‘Esc’ key

   :wq!

Hit ‘Enter’

Now Android Home and Path have been set permanently.

   echo $ANDROID_HOME
   echo $PATH

You should be able to run the command ‘adb devices’ now.

Step 4: Same as Windows, make your mobile device ready for automation by enabling developer options and turning on the ‘USB Debugging’ option.

Step 5: Connect the real device with your computer system using a USB cable.

Step 6: Run the following command

adb devices

Check if the Device ID is displayed

Running Your First Test on a Real Mobile Device

Step 1: Download Eclipse or any other IDE for Java

Step 2: Create a Java project

Step 3: Add the following libraries

1. Selenium Java

2. Appium Java client

https://mvnrepository.com/

Step 4: Connect your device and run the below command

adb devices

Step 5: Start the Appium server either from the command line or using the Appium Desktop Client

Step 6: Add the code to start automation on your mobile device.

Set the desired capabilities and start the calculator application.

 deviceName
    udid
    platformName
    platformVersion

    appPackage
    appActivity

Step 7: Run and validate

Appium Test Case for Native Android App (Calculator)

Step 1: Download the ADT Eclipse plugin or download the ADT bundle separately

Step 2: Open Eclipse and Create a new Project >> Package >> Class

Step 3: Import the Selenium library and TestNG inside that new project.

Step 4: Now create a small test Program for ‘Calculator.app’ to add two numbers.

package src_Appium;
import java.net.MalformedURLException;
import java.net.URL;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
//import org.openqa.selenium.remote.CapabilityType;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.testng.annotations.*;


public class Calculator {
WebDriver driver;

@BeforeClass
public void setUp() throws MalformedURLException{
           //Set up desired capabilities and pass the Android app-activity and app-package to Appium
           DesiredCapabilities capabilities = new DesiredCapabilities();
           capabilities.setCapability("BROWSER_NAME", "Android");
           capabilities.setCapability("VERSION", "4.4.2"); 
           capabilities.setCapability("deviceName","Emulator");
           capabilities.setCapability("platformName","Android");

   
  
capabilities.setCapability("appPackage", "com.android.calculator2");
// This package name of your app (you can get it from apk info app)
 capabilities.setCapability("appActivity","com.android.calculator2.Calculator"); // This is Launcher activity of your app (you can get it from apk info app)
//Create RemoteWebDriver instance and connect to the Appium server
 //It will launch the Calculator App in Android Device using the configurations specified in Desired Capabilities
   driver = new RemoteWebDriver(new URL("https://127.0.0.1:4723/wd/hub"), capabilities);
}

@Test
public void testCal() throws Exception {
   //locate the Text on the calculator by using By.name()
   WebElement two=driver.findElement(By.name("2"));
   two.click();
   WebElement plus=driver.findElement(By.name("+"));
   plus.click();
   WebElement four=driver.findElement(By.name("4"));
   four.click();
   WebElement equalTo=driver.findElement(By.name("="));
   equalTo.click();
   //locate the edit box of the calculator by using By.tagName()
   WebElement results=driver.findElement(By.tagName("EditText"));
           //Check the calculated value on the edit box
assert results.getText().equals("6"):"Actual value is : "+results.getText()+" did not match with expected value: 6";

}

@AfterClass
public void teardown(){
           //close the app
           driver.quit();
}
}

Conclusion

So we have done a comprehensive coverage of everything that you would need to know in this Appium Guide like the advantages of Appium, the methods to install Appium on both Windows and macOS, and also saw how to connect a real device on both platforms and run a test. We hope you’ve found this blog to be informative. As one of the best mobile app testing services providers, we highly recommend Appium for your testing projects to get the best results.

The XCUITest Framework Guide : Understanding It’s True Value

by admin | Nov 1, 2021 | Mobile App Testing, Blog, Latest Post | 0 comments

Automation tests are a crucial part of the process that makes sure your iOS app is up-to-par with the required standards. We can say without any doubt that the bar has been raised to new heights because of the standards set by Apple. Automation testing on their end is highly standardized. The apps must go through rigorous checks before they can be approved for the App Store. The parameters include numerous guidelines set by Apple that are followed up with strict implementation rules. The XCUITest framework not only allows you to execute automated functional and performance checks but also shares information across devices in order to identify any inconsistencies between them before it’s too late! So in this blog, we will discuss how the XCUITest framework will be instrumental in helping you meet the high standards set by Apple.

Though the XCUITest framework is a popular tool from Apple, it’s still an independent module with many features that can be harnessed by any developer in the industry – even beginners! We know that XCUITest provides a framework that can be used for testing your iOS app. Since it supports Swift and Objective-C languages, it allows you to write tests in either of these programming languages instead of coding directly with Xcode or using another tool like StoryTest. These interactions are more realistic since they reflect how users will interact with your mobile application on their own devices rather than just simulating this behavior through code while being tethered by wires during development – it makes integration easy!

As one of the best mobile app testing companies, we have been able to use XCUITest in our projects to reap the wonderful benefits it has to offer. So let’s explore the tool’s potential by understanding the need.

UI Automation Testing

UI Automation Testing is a relatively new practice and has only recently started becoming popular among software engineers who want more control over how their work gets tested before it goes live. Frameworks like XCUITest allows testers to develop clean automation test suites for an app’s UI. These tests can run on different devices to check if the apps work properly regardless of the type or size of the screen you use them on. This makes it very convenient when testing apps that have international versions available but aren’t yet localized. Now let’s take a look at a few benefits UI automation testing has to offer.

Preserving Time and Money

Automation will pay off your investment with far greater returns as time goes on. The primary reason is that UI has such an important role to play in helping the customer feel satisfied with any application. A poorly designed UI has the potential to single-handedly derail your app’s success.

Automating Code isn’t Sufficient

UI testing shouldn’t be seen as something that has to be ticked off in your checklist. It is one of the best methods to ensure that your application works perfectly. Many developers use third-party frameworks like Appium to automate repetitive tasks to save time and to be more thorough. Developers must also perform code test cases to check the behavior and interactivity with the other modules. But the issue here is that they do not have any metrics that show how development sprint cycles or new builds affect UI functionality.

For example, if it takes more than the expected time to load or if some change has rendered any component from the previous release to become non-functional now. There are so many more similar scenarios that could happen. So the developers will be at risk when automating manual tasks using Test Automation Frameworks like Appium. These tools are only useful to automate parts of an automated assessment, whereas, the entire context needs attention. That is why tools like XCUITest and XCTest are very crucial.

Basics of the XCUITest Framework

With XCUITest, testers can write test cases to check how an application behaves when user actions are performed and compare the results they get with the expected outcomes. Using the two fundamental concepts behind XCUITest, they will be able to precisely monitor what a person would experience while using your app by utilizing their input device or system. They would also be able to validate the current state at any given time based on the documented interactions from the earlier tests to simulate real-life use conditions before the release.

XCTest

XCTest is the base testing framework for both iOS and OSX apps. It provides testers with various tools to write test cases in either Objective-C or Swift, to create UI tests classes (e.g., methods), and to assert the behavior validation when running them through Xcode. So all of this would be seamlessly integrated at your fingertips with XCTest!

Accessibility Features

QAs can also add accessibility features to the apps for people with disabilities. Accessibility technology has given QAs a new way of testing the app’s functionality when it is being used by someone who may not be able to use conventional input methods or have full access to all the components on the screen. So the UI test cases are created using functions provided within the Accessibility Core library that executes and validates tests against various parameters including size changes in width/height values. Changing these values will paint us a clear picture of how our program behaves differently depending on the user’s perspective.

XCUIApplication

Every time testers need to automate a test for an app, they have to ensure that it’s launched by specifying the XCUIApplication instance and calling the launch method on this object before the testing even begins. It should also terminate once all of its tasks have been completed so that no lingering processes are left behind after the tests have finished running. It will help to avoid any problems with sensitive data being leaked or tampered with during the analysis stage.

XCUIElement

The XCUITest framework provides a suite of components to help UI testers with their tests. These elements can be used in different ways, such as navigating & interacting within the view or performing actions like tapping & swiping on the screen. The class is responsible for handling these interactions between the user input devices (such as touchscreens) and the app logic. It also grants you access to look into how an element hierarchy unfolds — this way; we know which parts will respond when interacted with by our users!

XCUIElementQuery

The XCUIElementQuery is one of the most important classes in the UI framework. This class will allow testers to search for a particular element on that user interface, perform some action, and then move on to another task!

Conclusion

Xcode has many built-in features which allow developers of all levels to quickly explore potential bugs in their software before releasing them on the App Store. Plus, getting started is fairly easy for any iOS developer as it can be done without having to learn a new framework or language. As one of the best software testing companies in India, we always make sure to use the best tools and wrote this blog to help others understand the importance of XCUITest.

XCUITest is a powerful tool to help you find issues in your app’s code and pinpoint the root cause. With XCUITest, we can fiddle with our apps’ UI elements and ensure that end-users do not encounter unexpected results or have poor experiences. It provides an excellent way to test mobile apps, but it will only work if the tests are running on real devices or in emulated environments with XCUI Automation Platform integration enabled – which gives us total control over the computing resources during our automated testing sessions.