Java variables and its data types

This article specially deals to understand about the variables in Java and its data types. It really helpful for the Java Beginners and Selenium Freshers who want to be a professional selenium tester. First we need to try to understand what is variable ?

Generally variables are  used to store the data that may be number,character or String(group of characters). Variable can be also referred as name of the reserved area allocated in memory location.

How to declare a variable ?

 int a = 100;  // a is the variable of type Integer that holds the value 100 reserved in the RAM.

There are different types of variables available in Java. Those variables are given as below.

1. Local variable
2. Instance variable 
3. Static variable

Local variable:

Variables that are declared with in methods and it will have scope with in that method


Instance variable:

Variables that are declared with in Class area but not with in methods are termed as Instance variables. It can be used by all the methods inside that class. It denotes the state of that specific class.

Static variable:

If the variables is declared as static then it can be used as local. Value of the variable can be changed only in static methods. Modification of static static variable will be reflected in the all the objects or instances using that variable.

What is meant by Datatype ?

Datatype is to denote that what type of data is going to be stored in specific variable. Two different types of datatypes are listed below.

·         primitive data types

·         non-primitive data types

Data Type	Default Value	Default size
boolean	false	1 bit
char	'\u0000'	2 byte
byte	0	1 byte
short	0	2 byte
int	0	4 byte
long	0L	8 byte
float	0.0f	4 byte
double	0.0d	8 byte

selenium training for freshers | selenium training with placement assistance | learn selenium + java from experts | selenium certification training in chennai 

Java Introduction

This article is specifically deals with details of Java and its introduction. Understanding Java is more needed for working efficiently with the Automation testing tools like Selenium.

Java is created and introduced by James Gosling as programming language in 1991. Introduced company is Sun Microsystems. First version of Java is 1.0 (1995) and the latest version is 1.8 termed as Java8. Oracle acquired the company Sun Micro Systems inn year 2010. It has the general license called GPL – General public license.

Java Platform consists of below items:

1.       Programming language -  Java language has its own structure , syntax , programming paradigm and rules. It is derived from c language so the code blocks are modularized same as like { }. Structurally java starts with Namespace àProject àPackageàClasses àmethods and variables etc hierarchy.

2.       Java Compiler – Generally when we program for java platform, source code will be in .java files. During the compilation, the compiler checks against the syntax and converts/write into byte code in .Class files. These byte codes are targeted to run on JVM(java virtual machine). Java compilers differs from other compilers

3.       JVM -  During runtime, it interprets the .class files into native program instructions where CPU would interpret assembly language instructions. Difference is that JVM is software that will be specific for specific platform. – “Write Once, Run Anywhere”

Java distribution comes under two flavours

JRE – Java Run Time Environment

JDK – Java Development Kit

Difference between JDK and JRE:

1.       JRE consists of the JVM and the Java class libraries. Those contain the necessary functionality to start Java programs.

2.       JDK additionally contains the development tools necessary to create Java programs. The JDK therefore consists of a Java compiler, the Java virtual machine and the Java class libraries.

Java features:

1.       Platform Independent – “Write Once and Run anywhere”

2.       Object Oriented Programming Language - Except the primitive data types, all elements in Java are objects.

3.       Strongly typed programming language -Java is strongly-typed, e.g., the types of the used variables must be pre-defined and conversion to other objects is relatively strict, e.g., must be done in most cases by the programmer.

4.       Interpreted and Compiled language - JVM

5.       Garbage Collector -Automatic garbage collection is another great feature of Java with which it prevents inadvertent corruption of memory. Similar to C++, Java has a new operator to allocate memory on the heap for a new object. But it does not use delete operator to free the memory as it is done in C++ to free the memory if the object is no longer needed. It is done automatically with garbage collector.

6.       Java supports Multithreading -Java language is that it allows multiple threads of execution to run concurrently within the same program A single Java program can have many different threads executing independently and continuously. Multiple Java applets can run on the browser at the same time sharing the CPU time.

7.       Java is distributed - extensive set of routines to handle TCP/IP protocols like HTTP and FTP java can open and access the objects across net via URLs.
 

Types of locators in selenium with Simple examples

Locators in selenium are used to locate the web elements in page. Identification of correct expected web element and to perform some action on it will be the expectation in Automation. Selenium IDE is the plugin that will be more helpful to identify the locate the elements in GUI page. We can use that locator value while doing the scripting. Each and every web element are presented in HTML tag with open and End tag will be identified through its attributes.

Different types of locators in selenium are listed below.

• ID
• Name
• Link
• CSS Selector
• Xpath
• DOM

Target Area - IDE

Locating by ID:

Always ID is the attribute present in html tag of the web element will be unique. Some of the web elements will not have the ID attribute.

Syntax :

 id= value of Id of that Specific element

Locating by Name:

Name attribute will be used to identify the element using the name attribute of element.

Syntax :

Name = Value of Name attribute of that specific element

Locating by Link:

It used to identify the hyperlink element in the webpage.

Syntax :

Link = linktext

Locating by CSS Selector:

It is used to identify the web elements using string patterns. When an element doesn’t have usual attributes with unique values such as ID,Name, Class name etc, we can make use of it.

It will be very fast in accessing the web elements comparing to other locators.

Syntax and its CSS types:

• Tag and ID   ----> css=Tag#id
•  Tag and class ----> css= Tag.class
•  Tag and attribute ----> css= tag[attribute = Value]
• Tag, class, and attribute ----> css=tag.class[attribute = value]
•  Inner text ---> Tag:contains("text")

When using this strategy, we always prefix the Target box with "css=" as will be shown on the following examples.

Locating by Xpath:

XPath is the language used when locating XML (Extensible Markup Language) nodes. There are two types in Xpath.

Absolute path – Full path

          Relative path – Reference path

Syntax and its Xpath types:

• Using Single attribute  -//Tag[@attribute = ‘value’] 
• Using Multiple attribute-//Tag[@attribute1=’value1’] [@attribute2=’value2’]
• Using Contains method   -//Tag[contains(@attribute,’value’)]
• Using Starts-with       -//Tag[starts-with(@attribute,’value’)]
• Using Following         -//Tag[@attribute =’value’]/following::Tag/
• Using Preceding         -//Tag[@attribute =’value’]/preceding::Tag/
• Parent                  -//Tag[@attribute ='value']/parent::*---->
• Child                   -//child::tag
• Siblings                -//Tag[@attribute =’value’]/preceding-sibling::Tag/
• Siblings                -//Tag[@attribute =’value’]/following-sibling::Tag/

Document Object Model (DOM)

HTML elements are structured. Selenium IDE is able to use the DOM in accessing page elements.

Syntax for DOM:

•      document.getElementById("pass")
•      document.getElementsByName("servClass")[1]
•      document.forms["home"].elements["userName"]   ----> Only applicable when having forms
•      document.forms[0].elements[3]

Software testing Lifecycle - Simple article

Phases in Software testing life cycle will be listed below. This cycle later phases will get changed based on traditional development life cycle and latest agile methodology or Scrum framework. 

Requirement Analysis:

This phase deals with analysing the requirements through SRS(System requirement) and BRS(Business requirement) documents. Traditional SDLC like Waterfall, Prototype and spiral will have late testing is due to this that we will cover on principles of testing. Analysing the requirements at later stage and identifying the requirement issues at later stage will cause major impacts to the application in sense of business. Outcome of requirement analysis phase is Strategy document.

Test Strategy Document -  Test Manager – Static Document

1.       Business priorities

2.       Risk and its mitigation

3.       Testing tools

4.       Automation testing needed or not

5.       Process of test execution

6.       Type of testing

7.       Training needed or not

Test Planning:

Test Plan Document - Test Manager/ Test lead – Dynamic document

It will change throughout the testing lifecycle and also it will answers the below questions with planning.

1.      When- When the testing for the feature or module is going to be performed?

2.      What - What are the expectation in the functionality or feature?

3.      Where - Where refers the test environment includes os and browser.

4.       How - How means the approach or type of testing going to be performed for that feature.

5.       Who -Who means the resource person going to execute the specific feature or functionality as per plan.

Test Case Development:

1.       Preparing test cases

2.       Test data Preparation

3.       Automation Framework Selection

Environment Setup:

1.       Test case review - Review the prepared test cases and ensure with the team that the scope is covered in the test case.

2.       Updating of test cases based on the feedback received from the peers.

Test Execution:

1.       Executing the test cases and identifying potential bugs

2.       Assigning bugs to appropriate developers and follow-up for its closure

3.       For Agile, It will happen in parallel cycles in every build

Test Cycle Closure:

1.       Preparing the test report

2.       Sent it to appropriate distribution list daily, weekly or bi weekly manner.