Why Automation?

Test Automation->A software tool to run test

cases repeatedly against the application.
To check the correct whether the application
is behaving as expected or not.
EX: Regression Testing.
Test Automation Supports:
Regression testing.
Finding defects missed by manual testing
Disciplined documentation of test cases.
 When not to automate?

We should not use the automation

tool when the UI or web application
behavoiur keeps changing like when
the application behaviour is not
stable.
If an application has a very tight
deadline, there is currently no test
automation available.
 Selenium Overview
Seleniumis a portablesoftware testing
frameworkforweb applications.
Selenium provides a record/playback
tool for authoring tests without learning
a testscripting language(Selenium IDE)
Selenium provides a domain specific
language i.e, tests can be written in any
language like java, c#...
Selenium can be deployed on any
platform.
 Components
1)Selenium IDEis a complete integrated
development environment(IDE) for Selenium
tests.
It is implemented as aFirefox extension
It allows recording, editing, and debugging tests.
2)Selenium RC: RC makes it possible to write
automated tests for a web application in any
programming language.
3)Junit: it is a unit testing framework for java
where it promotes First testing then coding
using annotations and assertions.
3)TestNG:It is testing framework which covers all
categories of testing requires JDK5 or higher.
4)Selenium Web Driver: Selenium
WebDriver was
developed to support dynamic web pages
where elements of a page keep changing.
5)Frameworks with real time
applications:
Linear Automation Framework.
Function Driven ,Data driven, Module
driven
Framework.
 Why java for selenium
Selenium is platform independent
Java is also platform independent
 Installing java and eclipse
->Go to selenium software's folder->java softwares
folder->double click .Check in c drive->Java->
jre6, jre1.5.0_12
Jre=java run time environment(it has supporting
files to run java)
Jde=java development kit(it has code)

-> selenium softwares folder->eclipse->click on

round purple color eclipse icon or create short cut
for it on desktop
 Features of java
Simple
Secure
Portable
Object oriented
Robust
Multithreaded
Architecture neutral
Interpreted
High performance
Distributed
dynamic
 OOP Principles
Data Abstraction
Encapsulation
Polymorphism
Inheritance
 Data abstraction
Abstraction involves extracting only relevant information .
In other words, Abstraction means looking for what you want in
an object or a class
Ex: An Automobile salesperson is aware that different people have
different preferences.some people are interested in the speed of
car, some in the engine, some in style.although all of them want
to buy a car, each of them is interested in a specific attribute or
feature.
Sales man knows all the details of a car, but he presents only the
relevant information to a potential customer.As a result, the sales
man practices abstraction and presents only relevant details to
customer.
 Encapsulation
Encapsulation literally means to enclose in or as if in
a capsule.
Encapsulation is defined as the process of enclosing
one or more items with in a physical or logical section.
It involves preventing access to non essential details
Ex:when u plug in the cord of the vaccum cleaner and
turn on the switch, the vaccum cleaner starts.we do
not see the complex process needed to actually
convert electricity into suction power.
In other words,the exact working of the cleaner has
been encapsulated.
Therefore encapsulation is also defined as information
hiding or data hiding because it involves hiding many
of the important details of an object from the user.
 polymorphism
It is the ability that helps in executing
different operations in response to the
same message.
We can implement polymorphism by
creating more than one function with in a
function within a class that have the same
name.
The difference in the functions lies in the
number and types of parameters passed to
each function.
 Inheritance
Deriving the properties from parent
to child is inheritance
with parent reference ,we can access
child class methods
With child reference, we cannot
access parent class methods
Concept of class and object
Class is collection of properties and
methods
Object is the instance of class
Ex of class =car
Properties=colour,power,speed,model,
height
Methods=fwd(),bkd(),stop(),start()
Ex of object= honda car , toyota car..
 Program made up of
Program made of
1.Keywords
2.Identifiers
3.Literals
Ex: Int EmpId =10310;
Int = keyword
EmpId =identifier
10310 =literal
 Strurture of java program
//documentation section
//package section
//import section
//class section
{
Variables
Methods
}
Comments // for single line comment
Multiline comment /*-------*/
 Platform independence
The output of java compiler is not
executable code. rather it is byte code.
Byte code is highly optimized set of
instructions designed to be executed by
java run time system, which is called
java virtual machine.
Translating a java program into byte
code helps makes it easier to run a
program in a wide variety of
environments. Only the JVM needs to be
implemented for each platform.
 Explanation of structure
To tell about the program like when, who, what, why
Package is like a folder,folder contain any thing but package contains
all related classes
We use Package keyword to specify it is package ex: Package
pk.sub
In a class only one package is created; multiline packages cannot be
created
Package will be the first line in program.
By default Java.lang Package is imported
Import java.lang.*; all methods are available in program; but not
included.
We can import many packages in one class
Class is a user defined method ;it is collection of variables and
methods.
At least one class must be created in a program;program can
contain many classes
Program name can be any thing but extension must be .java
Program name need not be same as class name
.class file is created same as class name
 note
1.Every java program should have class
definition block
class ClassName
{
body
}
2.While saving a java program the file name
should be same as class name
3.Inside class body we can develop any java
script
Main method is mandatory to start the
execution
4.Java file is compiled using a command javac
 Note contd.
5.compiler generates .class file if there are no
errors
6.by default .class file will be saved in same
location where java file is saved
7.every statement in java must be terminated by ;
8.The java class can be executed by using a cmd
java ClassName
9.When ever a class is executed java starts the
execution by running main method
10.Java executes all the statements sequentially of
main method
11.Java throws error if main method is not defined .
 Datatypes in java
Java support 8 different types of datatypes under 4 families:
Integer : 1.Byte 2.Short 3.Int 4.Long
Real: float ,Double
Char: char
Boolean: boolean
Length of datatypes
1byte 8 bits =(-2^7 to (2^7-1)= -128 to +127
short -2bytes=16bits=(-2^15 to +(2^15-1))
Int -4 bytes = 32 bits=(-2^31 to (2^31-1))
Long -8 bytes=64 bits=(-2^63 to (2^63-1))
Float -4 bytes
Double - 8 bytes
Char 2 bytes
Boolean -1 byte
Default values for datatypes:
Integer =0,char=space ,boolean = false,real=0.0
 String class
We can store String data in 3 ways
1.charArray
Char name[]={o,n,e,f,o,r,c,e}
2.String class object
String name =oneforce;
or
String name= new String(oneforce);
name = name.concat(jayanagar);

3.String Buffer class

StringBuffer sb =new
StringBuffer(oneforce);
Sb.append(jayanagar);
 Conditional and concatenation
operator
If(condition){ statment1;}
If-else
If (condition){stat1}else{stat2;}
If(condition){stat1}-else if(condition){stat2}
Switchstatement allows a variable to be
tested for equality against a list of values.
switch(expression){
case value1 : //Statements
break;
default : //Statements }
 Concatenation operator
public class concatenation {
public static void main(String[] args)
{
int a=10;
int b=20;
String str1="Hello";
String str2="world";
System.out.println(str1+str2);
System.out.println(str1+str2+a+b);
System.out.println(a+b);
System.out.println("sum of two numbers :"+(a+b));

}
}
//for numbers + symbol acts as arthemetic operator
//for non numerics +symbol acts as concatenation operator
 loops
Javas iteration statements are
For
While
Do-while
 Arrays
Grouping the data objects of same
type in a contiguous block of
memory.
Array is an object created with new
operator.
Array index starts with zero.
Array size cannot be resized.
 Array Declaration and
Instantiation
-> Array Declaration:
<Data type> [ ]<array name >
Ex: int[] myArray;

-> Constructing an Array:

<array name > = new<data type>
<array Size >
myArray=new int[5];
 Initialization of Array

-> Primitive Array:

Int[] myArray={1,2,3,4,5}
-> Explicit initialization:
MyArray[0]=10;
MyArray[1]=20;
Two dimensional Array:
int sample[][] = new int[3][3];
 Drawbacks of Array
Large arrays take up space.
Arrays can hold only one data
type at a time.
Searching and sorting arrays is
difficult.
Inserting and removing data
from arrays is clumsy.
 Local Variables
Local variable are variables defined
inside methods, constructors or
blocks.
The variable will be declared and
initialized within the method and the
variable will be destroyed when the
method has completed.
 Global variable
Global variables are declared in a class,
but outside a method, constructor or any
block.

Global variables can be accessed any

where in the class ,methods defined in
the class.
 Static and Non Static Variables
-> Static variables are declared with
thestatickeyword in a class, but outside a
method, constructor or a block.
->A single copy will be maintained irrespective
of number of objects.
Static variables can be accessed by calling:
With classname
Without object
-> NonStatic variables are can be accessed by
object.
-> It can have multiple copies as much as
object creation for class
 EX
public class Test {
static int a= 6 ;
int b= 8;
public static void main(String[] args) {
Test obj1=new Test();
Test obj2=new Test();
obj1.a=10;
obj2.a=12;
obj1.b=24;
obj2.b=3 6 ;
System.out.println("Static a + obj1.a); //12
System.out.println("Static a + obj2.a); //12
System.out.println("Static a +a); //12
System.out.println("Static b + obj1.b); //24
System.out.println("Static b +obj2.b); //36
}
}
 Static variable Example

public class Statvariable {

private static int salary;
public static void main(String args[]){
//classname.salary
salary = 1000;
System.out.println("salary: is +salary);
}
}
 Static and Non Static
Functions
-> Static Functions belongs to the class
and can be accessed by the main
method directly and also by the object
creation or by class name.
-> A static method can access only static
members
-> Non Static Functions belongs to the
object of
Class and can only be accessed by object .
 Static Function
public class A {
static int add(int i,int j) {
return( I + j);
}
}

public class B extends A {

public static void main(String args[]) {
int s= 9;
System.out.println(add(s, 6 ));
}
}
 Non Static Function

ppublic class A {
int add(int i,int j) {
return( I + j);
}
}
public class B extends A {
public static void main(String args[]) {
B b =new B();
int s= 9 ;
System.out.println(b.add(s, 6 ));
}
}
 Static/NonStatic members
works
when ever a java program is executed
.....the following steps happen
i)memory is allotted for execution
ii)and this memory is divided into heap
and stack
iii)java enter into stack and calls class
loader
iv)the class loader loads static members
of class into heap memory.
v)all static members of class reside in an area called static pool
vi)java calls main methods for execution
vii)main method enters into stack on top of java
viii)when ever a object creation statement encounters , object will get
created into heap.
ix)on that time, the non static members of the class will be loaded into
object.
x)we can create multiple objects of a class .for each object creation a
copy of non static members will be loaded.
xi)after the completion of main method , the JVM calls garbage collection
to clean the heap.
xii)After that java releases the memory back to main memory
xiii)local variables are created in the stack and the life of the variable is
as long as the method is in the stack.
java gives preferences to local variables.
xiv)if any object does not have a reference then such object are known
as abundant object.
 Object and Object References
Object is the instance of class.
Object Reference is the information on
how to find the object.
A Single object can have more than 1
object references.
EX : 2 objects[java,C+ +)] 2 reference
objects(Str1,Srtr2).
String Str1=new String(Java);
String Str2=new String(C+ + );
EX : 1 object with 2 object references
String Str1=new String(Java);
String Str2=Str1;
 Call By Value
Passing a value held in the variable as
an argument to the method.
The value is copied to method
parameters and changes takes place
to that parameters.
That is why changes made to the
variable within the method had no
effect on the variable that was
passed.
 Call By Reference
The Object is passed as an argument
to the method.
No copy of object is made here.
Changes made in the method will be
reflected in the original object
 constructors
It can be tedious to initialize all of the variables in a
class each time an instance is created.
it would be simpler and more concise to have all of
the setup done at the time the object is first created.
Java allows objects to initialize themselves when
they are created. This automatic initialization is
performed through the use of a constructor.
Constructor is a special block in java class invoked at
the time of object creation
Constructor should always be public
A constructor name is same as class name ,the
constructor should not have return type and
return statement
Whenever we create an object , the constructor body
will get executed.
Difference between constructor
and method
Method
Method can be executed
when we explicitly call it.
Method name will not
have same name as
class name
Method should have
return type
A method can be
executed n number of
times on a object
constructor
Constructor gets
executed only when
object is created
Constructor name will
be same as class name
Constructor should not
have return type
Constructor will get
executed only once per
object
 Super keyword
Using super keyword
We can call immediate super class
instance variable.
 this
1.this keyword can be used to refer current class
instance variable.
2.this() can be used to invoke current class constructor
3.this keyword can be used to invoke current class
method (implicitly).
4.this can be passed as an argument in the method call
5.this can be passed as argument in the constructor call
6.this keyword can also be used to return the class
instance.
7.We cannot use this and super at a time
 final
Final is the keyword to avoid
inheritance
We use final in three ways
1.Before a variable(you cant change)
2.Before a method (you cant over
ride)
3.Before a class(you cant inherit)
 Inheritance
Deriving members of one class to another class is known as
inheritance.
The class from where member s are inherited are known a
super class or base class
The class to which members are inherited are known as
subclass or derived class
The general syntax to write inheritance class
Class SubClassName extends SuperClassName
Using extends keyword a class can inherit from super class
Always inheritance happens from super class to subclass.
Static members of the super class will not be inherited to
subclass because the static members will not be loaded into
object memory
Whenever an object of subclass is created both super class
member and sub class member will be loaded into object
Inheritance happens through constructor chain.
 Inheritance contd
Whenever an object of sub class is
created ,the subclass constructor
calls super class constructor ,the
super class constructor calls its super
class constructor . this is known as
constructor chain.
 Types of inheritance
There are 3 types of inheritance
Single
Circular(no prg supports )
Multiple (java does not support)
a A B
A

b c
B C
 Interface
Java supports 3 different structures
1. Fully implemented
2. Fully unimplemented
3. Partly implemented/unimplemented
Interface contains abstract methods(with no body)
Interface is an fully unimplemented structure
We need to provide body for all methods in interface
In interface, we cannot create the object of interface
Can contain constants, but not variables
All methods, variables are public static final
 Interface
It is a class with no implemented methods
Interface must not be static
It contains only declarations
Methods in interface must be static
All variables must be assigned a value
Interface variables are static ;we cannot change values
Interface methods are neither static nor non static
Creating interface reference ,we can access
implemented class methods which are defined in
interface class but not methods defined in
implemented class.
 Abstract class
It is partly unimplemented or partly
implemented class which contains zero or
more abstract methods
Concrete method is the method with body
Abstract method is the method with out
body
If user want to inherit the abstract
class;he need to extend but not
implement
 Difference between interface
and abstract class
interface Abstract class
Fully unimplemented Partly implemented or
structure that contains unimplemented structure
all abstract metods Can contain variables
Interface contains only Can contain constructors
constants Abstract class object get
The object of interface created automatically
cant be created when sub class object
directly ,anomous class got created
is recquired to create
Uses extends
object for this class
Uses implements
 Overloading and over riding
methods
Redefining method of parent class with the
same name in child class is method over
riding
Redefining same method with different
parameters is called method overloading
Note:
1.Reference type determines which
overloaded method is used at compile
time.
2.Object type determines which over
riden method is used at runtime.
 Over loading
Overloading is about creating multiple methods
with the same name, but different signatures, in
the same scope.
overloading can take place in the same class or
in the subclass.
overloaded methodsMUSThave a different
argument list.
overloaded methodsMAYchange the return type
(in case argument list is different).
overloaded methodsMAYchange the access
modifier.
reference type determines which overloaded
method will be used at compile time.
constructorsMAYbe overloaded .
 Over Riding
Overriding is about changing the behavior of a certain
method in the child class from the way it is behaving in
the parent class.
AppliesONLYto inherited methods
is related to polymorphism
object type (NOTreference variable type) determines
which over riden method will be used at runtime
overriding methodMUSThave the same argument list
(if not, it might be a case of overloading)
Abstract methodsMUSTbe overridden
Final methodsCANNOTbe overridden
Static methodsCANNOTbe overridden
ConstructorsCANNOTbe overridden
 Packages
Java Package is a mechanism for organizing
Java classes in to a namespace.
Classes present in the package can access
the
each others class members.
We are going to import classes from the
package.
Package name usually starts with lower case.
Classes within a package can access classes
and members declared with default access
and class members declared with the
protected.
 Access Control Modifiers
Java provides a number of access
modifiers to set access levels for
classes, variables, methods and
constructors. The four access levels are:
Default:-Visible to the package. No
modifiers are needed.
Private:-Visible to the class only .
Public:-Visible to the world.
Protected:-Visible to the package and all
subclasses.
 Non Access Modifiers
Java provides a number of non-access
modifiers to achieve many other
functionality.
Thestaticmodifier for creating class
methods and variables
Thefinalmodifier for finalizing the
implementations of classes, methods, and
variables.
Theabstractmodifier for creating abstract
classes and methods.
Thesynchronizedandvolatilemodifiers,
which are used for threads.
 Exception Handling
->Exception is an Event which halts
normal execution abruptly and
alternatively the program will be
terminated.
Exception occurs when our code asks JVM
to do technically impossible tasks.
Ex:Divide by Zero.
All Exception classes are subclasses of
Throwable.
Throwable has two subclass :Exception
and Error
 contd
Types of Exception
1)Checked Exception: A checked exception is an
exception
that is typically a user error or a problem that cannot
be foreseen by the programmer.
EX: If a file is to be opened, but the file cannot be found,
an exception occurs
2)A runtime exception is an exception that occurs that
probably could have been avoided by the programmer.
EX:ArrayIndexOutOfBoundException

3)Error describes internal error and resource exhaustion.

Mostly beyond the programmers control.
 Exception Handling
1. Anticipate the error by the user/system.

2. Return the program to a safe state that

enables the user to execute other
commands.

3. Inform the user of the errors cause.

4. Allow the user to save work and terminate

the program gracefully.

63
 Keywords of Exception
Try
Catch
Throw
Throws
finally
 Try-Catch block
In this mechanism Try block will
contain the code which may throw
the exception.
Catch block will declare the type of
exception occurred.
EX:try{ }
catch(Exception E){ }
 Throws-Throws
If a method does not handle a checked
exception, throws keyword should be used
at the end of a method's signature.
To explicitly throw the exception of a newly
instantiated one or an exception that you
just caught, we use Throw keyword.
EX: public void deposit(double amount)
throws RemoteException { // Method
implementation throw new
RemoteException(); } //Remainder of class
definition }
 Finally
The finally keyword is used to create
a block of code that follows a try
block. A finally block of code always
executes, whether or not an
exception has occurred.
A finally block appears at the end of
the catch blocks .
 Collections
Collection is a set containing the classes
and interfaces which implements reusable
data structures like List,Array,HashTable.
There are so many interfaces available like
java.util.ArrayList;
java.util.Iterator;
java.util.List;
java.util.ListIterator;
 Array List
1)We are Creating the ArrayList as
ArrayList<String> list =
newArrayList<String>();
2)To add elements to the list is
list.add("A");
List.add(2,S);//index=2
3)To get the element from list
list.get(index).
 stack
Stack is a subclass of Vector that
implements a standard last-in, first-
out stack.
boolean empty()
Object peek( )
Object pop( )
Object push(Object element)
int search(Object element)
 HashTable
Thejava.util.Hashtableclass implements
a hashtable, which maps keys to values.
Hash function will compute unique value
as a index to the key.
Methods are:
Set<Map.Entry<K,V>> entrySet()
Collection<String> collection =ht.values();
Set<String> set1 =ht.keySet()
 Linked HashSet
Linked HashSet maintains a list of
the entries in the set, in the order in
which they were inserted. This allows
insertion-order iteration over the set.
The values will be retrieved in same
order of insertion using iterator.
Reflection API