InfyOm Blog

The Basic Concept of Sanity Testing

When time is brief, Sanity testing are often a far better option than not testing in the least. it's performed to check the modules so their impact are often determined, but without going in-depth. it's useful when deadlines are strict and there's not enough time available to thoroughly test the appliance.

In an Agile environment, big releases are planned systematically and delivered to the client, whereas sometimes, because the situation demands, small releases got to be delivered where there's no overtime available for the testing, leaving no time for documentation of the test cases, bug reporting or Regression Testing.

Items to think about in Sanity Testing

Sanity Testing is performed when time is just too short to check the build thoroughly, and it’s impossible to execute all the test cases. this example risky, and therefore the possible implications are tremendous. To minimise mistakes and oversights, a tester should lookout of a couple of things at their end.

It is advisable to not accept the build where there are not any written requirements available. Sometimes the client conveys changes and/or requirements verbally and expects us to regulate accordingly. Compel the client to supply some written points on acceptance criteria.

Sanity testing is completed when there's not enough time to check the appliance thoroughly, leaving you unable to document bugs and test cases. this is often a but ideal situation so make certain to form your own notes. Document your bugs roughly on your notepad and if there's a while left, share those together with your team for future reference. Throw the ball into the courts of others. Email the list of issues to each stakeholder.

Automation testing can help reduce the pressure of manual efforts.Finally, draft an email containing the most details that you simply have tested, also as what you probably did not test. Give justification and reasons for the bugs that are resolved and people which haven't been.

Advantages of Sanity Testing

Sanity testing focuses on a couple of major areas of functionality which may help in identifying core functionality issues, ultimately saving time Sanity testing is typically non-documented During sanity testing, we are ready to identify missing and dependent functionalities.

Disadvantages of Sanity Testing

The primary focus of the sanity test is to see that the functions of the appliance work needless to say During times when deadlines are tight, organizations like better to perform sanity testing (bypassing regression testing) which leaves a number of the functionalities unattended. this will mean issues continue the assembly environment leaving a nasty impact on the companies. As said, it's non-documented so no official reference is out there.

Conclusion

In the end, the sort of testing you select that situation depends on the intuition of testers. Devise a technique to realize your end-goal. Define how you'll proceed and what you aim to realize with the short time span.

Linear

It is the most common style of icon in projects. With its simplicity, it is perfect for a minimalist and modern style.

Bold

These icons have a fill. We often use them to emphasize the effect of an active option in the navigation of desktop or mobile applications.

Two colors / Duocolor

As the name suggests, it is a two-color style. this, we can distinguish their more important fragments.

Bulk

It is a combination of the two colors and bold styles. this, the icons are better visible through filling, and at some time, we can emphasize their more important parts.

Broken

This style is characterized 'zed by a partial indentation in a given fragment of the icon. This effect distinguishes the icons from the rest and gives them a bit of spice.

Customer retention is the process of attracting repeat customers and preventing them from moving toward competitors. It is an important aspect of business strategy, and it can help businesses gain a competitive advantage.

The following ways to increase customer retention apply to virtually any type of business

Deliver more than you promised

The next step in the process is to deliver more than you promised - which means going beyond and beyond the call of duty and delivering to your customers the things they didn't expect. For example, you could offer a free bonus (such as a product, discount, or value-added) out of the blue, or anticipate a new customer's need and actively address it.

Meet your customers wherever they are

When you really understand your customers - that is, you know who they are, what they want from you, what their challenges are, and where they spend their time - you will reach them wherever they are. You can create the type of content they want and want (eg blog, video, social media) and then share it wherever they are (eg various websites, media channels, social platforms, etc.).

Good values ​​build good relationships

Your company values ​​are important to you. It should reflect your business processes, the quality of your products, and how you treat your customers. These things should make your values ​​clear to your customers, but reminding them occasionally doesn't hurt.

Trust is the good relationship

Creating a brand that is easily relevant is the first step in building trust with your customers. Having something in common parental trust is the key to building a successful business, through a strong relationship and expansion.

Accept feedback

You never know what your customers really want until you ask. Take regular surveys and request feedback from all your customers. You never know what is missing in you - and what areas need improvement.

Follow up with your existing customers

High touch is the key to retaining the customer. The only unusual thing about personal follow-up is how little companies do it. Getting referrals from happy customers is easier than finding and converting a new business.

The field of design is rich in tools and software that make the process of designing simple and rapid. Many firms have developed tools for designers to make the wireframing and prototype process more fluid. However, one piece of software has had the most influence on the market: Figma.

Figma is a design and user interface tool that runs on the cloud. The UX/UI design industry was able to enhance workflow and get creative because of its live collaboration, cloud-based design, and easy tools. Let's look at why you should know about Figma and what Figma can accomplish that other design tools can't in order to grasp how and why this tool took the design industry by storm.

Real-time collaboration

Real-time collaboration is available in Figma, which implies that everything the designer generates is done in real-time. It may be viewed by anybody with the link and permission. On the same canvas, developers may code as designers work on the next page. They may also leave each other remarks. Figma also enables unlimited people in a single file, in addition to Live Collaboration with no latency or crashes. This eliminates the need for huge teams to tag in and out members.

Browser-Based

Figma is a browser-based design tool, so all you need is an internet connection and a good browser to get started. You can work even if your internet is down, and it will autosave when the connection is restored. You're no longer restricted to a single device or platform when you use a cloud-based app. Other popular tools confine you to a single device, generating issues for people who operate across many devices.

Advanced Prototyping

Figma is a fantastic tool for prototyping user interface and user experience ideas. With powerful yet simple-to-use capabilities, it allows you to develop interactive flows right in the design file. Overlays, move-in, and move-out animations, smart animate property, interactions with a long press, hover, after delay, clicks, and most recently, scrolling animation are just a few of the features available. You may convert your static designs into a realistic rendition of your website or product in only a few minutes.

Easy Handoff

Figma features a built-in inspection tool. As a result, there is no need to employ another tool for handoff. Apart from CSS codes, Figma's handoff also includes iOS and Android codes. You and your colleagues may see and copy the existing code and data for your designs using the Inspect tab. To make the development process easier, copy single line items or complete sets of values.

Crash-free Zone

Figma saves your work by adding checkpoints to the version history of the file. After 30 minutes of inactivity in the file, as well as if you lose your internet connection or Figma fails, it creates a new checkpoint. This implies that your work will be saved even if you shut the tab. When working on a volatile device, the autosave/auto-backup feature will come in handy, and it also includes version control. You'll be able to restore lost projects thanks to Figma's built-in automated backup mechanism.

Figma Community

Figma is home to a fantastic community of designers and engineers. They make plugins for designers and make their work available for anyone to utilize. Thousands of custom-made files and Figma plugins created by Figma users for Figma users may be found in the community. This means you won't have to start from zero on each project; there will be no learning curve and no time wasted figuring out how to automate things. You may grab and go from the Figma Community.

Thank you for taking the time to read, I hope I was able to provide you with useful knowledge. Our articles are written with utmost dedication and are based on the Designers Learning Experience Team's research.

A variable gives us the ability to store a value inside it and then reuse it throughout the code. CSS variables make our work easier and more manageable.

Imagine you have a large project and you have to make changes to the fonts and colors. Now, one common way to do that is by changing them all manually and individually. But this is a nightmare and there are chances that you might miss something.

But with the use of CSS variables, you can do it with a few keystrokes. You just have to change the value of the variable where you have defined it and that's it. So you see that this is where CSS variables come in handy. And CSS variables can be accessed and modified in JavaScript.

Syntax of CSS variables

.root { 
     --primary-color: #151515;
}

• A CSS variable is defined by adding double hyphens before your property name that follows the property name.
• The property name could be anything. You can name it whatever you want, but try giving them a reasonable name.
• After that, you give value to that. CSS variables are case sensitive so be careful while declaring and using one.

To use a CSS variable we use a function called var(). This function recalls the value of the variable and returns it.

Use of the variable:

.title {
     color: var(--primary-color);
}

The above code will set the value of .title class selector's color to #151515.

Scopes of CSS variables :

CSS variables have two scopes

• Global
• Local

Global scope :

A variable is said to be in global scope if it is defined in the highest level possible. For that, we use the : root selector for declaring the variables.

:root {
    --text-font-family: sans-serif; 
}

A global scope variable can be accessed anywhere in the code. And you can also modify it.

Local scope :

We can restrict the use of CSS variables to a specific element by declaring in a low-level selector.For example, using it for a specific class.

.container {
     --main-color:#151515;
} 

.container .heading { 
     color: var(--main-color);
} 

Now this variable can only be used by .container selector or its child elements, And all the elements inside .container will initially inherit this property, but elements outside of .container cannot use it.

Overriding CSS variables :

CSS variables can be overridden. If in any part of your code you want to change the value of the variable you can do that.

This is possible by accessing the variable in the local scope and giving it another value.

:root {
     --text-color red; 
}

header {
    --text-color: green; 
    color: var(--text-color); /*color: green*/
}

footer {
    --text-color: blue; 
    color: var(--text-color); /*color: blue; */
}

Now, overriding only works for the element that it is overridden in.

And all the elements inside header and footer tags will get the new property value.

The keyboard is one of the basic components of any Android application. Typically, we use the keyboard to take input from the user. Soft keyboards are used in Android applications, and the Android system gives you with a keyboard to receive user input in any EditText or anything similar. Also, the keyboard will be invisible from the screen if the user has given input. So, in this blog, we will learn how to check if keyboard appears in Android app. How can I make this keyboard invisible or turn it off if it is visible?. So, let's get started.

Step 1 − Create a new project in Android Studio, Add the following code to activity_main.xml.

Step 3 − Add the following code to MainActivity.java

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
   ConstraintLayout constraintLayout;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);
      Button button = findViewById(R.id.button);
      EditText editText=findViewById(R.id.editext);
      editText.requestFocus();
      constraintLayout=findViewById(R.id.main_layout);
      constraintLayout.getViewTreeObserver().addOnGlobalLayoutListener(new  ViewTreeObserver.OnGlobalLayoutListener() {
         @Override
         public void onGlobalLayout() {
            Rect r = new Rect();
            constraintLayout.getWindowVisibleDisplayFrame(r);
            int screenHeight = constraintLayout.getRootView().getHeight();
            int keypadHeight = screenHeight - r.bottom;
            if (keypadHeight > screenHeight * 0.15) {
               Toast.makeText(MainActivity.this,"Keyboard is showing",Toast.LENGTH_LONG).show();
            } else {
               Toast.makeText(MainActivity.this,"keyboard closed",Toast.LENGTH_LONG).show();
            }
         }
      });
      button.setOnClickListener(this);
   }

   @Override
   public void onClick(View v) {
      switch (v.getId()) {
         case R.id.button:
         hideSoftkeybard(v);
         break;
      }
   }

   private void hideSoftkeybard(View v) {
      InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
      inputMethodManager.hideSoftInputFromWindow(v.getWindowToken(), 0);
   }
}

Here, we are using hideSoftKeyboard to hide the keyboard if the keyboard is visible on clicking the button.

So, finally, run the application and see the output on your mobile device.

In this blog, we learned how to check if the keyboard is visible or not on the screen. Also, we have if the keyboard is visible then how to close it. That’s it for this blog.

In practically every form of mobile or desktop application, website, or interface, interactivity, or user input, is anticipated. While utilizing an interface, users enter personal information, modify application settings, and navigate through various menus. It is our obligation as designers to give users the appropriate controls to make these inputs easier and faster.

Toggle switches and checkboxes, two of the most ubiquitous controls, appear to achieve the same goal, and their use cases are frequently misinterpreted as a result. However, there are a few circumstances where one or the other should be used. This blog will discuss the differences between checkboxes and toggle switches, as well as when each should be used in your user interfaces.

How to Tell the Difference Between Checkbox and Toggle Switches

There are two possibilities for checkbox controls: chosen and not selected. When the user can choose from any of the alternatives listed, the checkbox should be used. The checkbox will normally require buttons such as "Submit, OK, Next, Apply" after the box has been checked.

A toggle switch, like a light switch, represents a physical switch and is a "either/or" control that allows users to turn things on or off. The impacts of switching a light switch are felt quickly, much like flipping a light switch. Toggle switches in the user interface have the same trait.

Switches can assist mobile users in a variety of ways. In comparison to checkboxes, switches have a larger touchpoint to engage with and can deliver greater haptic feedback.

A toggle switch requires two steps: selection and execution, whereas a checkbox requires only the selection of an option, and the execution/saving action is normally required later or at a different area.

A few use-cases are provided below to assist you in determining which control is best for your user interface.

When to Use a Toggle Switch

• Without review or confirmation, an immediate response is required.
• An on/off or show/hide operation is required for a setting.

When to Use Checkboxes

• Before submitting any options, the user must confirm or evaluate them.
• For modifications to take effect, the user must take additional actions.

• There are several possibilities accessible, and the user must choose one or more of them.

• There is only one yes/no option, or only one alternative may be picked, and the message is evident.

• You want to provide two alternatives for an on/off decision when the user is toggling separate features or behaviors.

Focus on context rather than function when choosing between a switch and a checkbox. Consider if a setting should take effect right away. Ask yourself whether users need to check their settings before they apply them.

What is GUI Testing?

GUI Testing is a type of testing in which an applications’ Graphical User Interface (GUI) is tested to make sure it is in line with the expectations. GUI testing involves checking the objects on the UI (User Interface), which are the objects that we can see on the screen. Anything the user sees in the system or application is a GUI. Let us consider that if you visit a website, then the homepage is the GUI (graphical user interface) of the site. The source code will not be visible as the user can see only the UI interface. Mainly the focus of GUI testing is on the design pattern, images, alignment, spellings and the overall look and feel of the UI.

Why do we need GUI testing?

To get the answer you need to think as a user, not as a tester. It is the User Interface of the Software/Application that is a deciding factor to know whether a user is going to use the Application further or not. The looks and designs of the Application/Software are what a typical user will first look at. Secondly, he checks how easy it will be for him to understand and navigate through the UI. If the Software/Application is more complex and not appealing or if the user is not comfortable with the Interface design, then he is not going to use that Application again. That’s the reason, GUI testing is a matter for concern and should be taken very seriously. Also, proper testing should be carried out in order to make sure that GUI is free from any issues.

How to create test cases and how to do GUI testing?

UI Testing mostly involves the checking the various elements on the screen for their look and feel, the test cases should be written in such a way that they validate the following points for each of the UI objects. Size, position, width, and height of the objects with reference to other objects on the screen, Error messages displayed on the screen, the color and font of the error message. Errors are normally in Red color. Readable and inconsistent across the application unless specified by the client. Checking the same screen in different resolution with the help of zooming in and zooming out like 640 x 480, 600×800, etc. Also if there is a requirement you may want to check it in a mobile browser as well. Font color, hyperlink color, error/warning message color, etc. Quality of the images on the screen, if applicable. Spellings, grammar, and punctuations. Scrollbars according to the size of the page if any. Checking disabled fields if any. Checking the size of the images.

Challenges in GUI Testing:

The list of GUI test cases can be very exhaustive and time-consuming and it requires a lot of manual effort and the quality of the testing would depend on the skills of the tester. Number of automation tools available is very limited GUI is usually unstable during the initial development phases, so GUI testing is postponed to the end of the testing cycle, which sometimes creates a time crunch.