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

• Selenium is a portable software testing framework for web applications.

• Selenium provides a record/playback tool for authoring tests without learning a test scripting 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.

Components1)Selenium IDE is a complete integrated development

environment (IDE) for Selenium tests. • It is implemented as a Firefox 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 wasdeveloped to support dynamic web pageswhere elements of a page keep changing.5)Frameworks with real time applications:Linear Automation Framework.Function Driven ,Data driven, Module drivenFramework.

Why java for selenium

• Selenium is platform independent• Java is also platform independent

Installing java and eclipse

->Go to selenium software's folder->java software’s 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 software’s 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.Keywords2.Identifiers3.LiteralsEx: 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 name3.Inside class body we can develop any java script Main method is mandatory to start the execution4.Java file is compiled using a command javac

Note contd….5.compiler generates .class file if there are no errors6.by default .class file will be saved in same location where

java file is saved7.every statement in java must be terminated by ;8.The java class can be executed by using a cmd java

ClassName9.When ever a class is executed java starts the execution

by running main method10.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 ways1.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}• Switch statement 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

• Java’s 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

the static keyword 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

EXpublic 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 Functionpublic 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 poolvi)java calls main methods for executionvii)main method enters into stack on top of javaviii)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 memoryxiii)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 referencesString 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 constructor3.this keyword can be used to invoke current class method

(implicitly).4.this can be passed as an argument in the method call5.this can be passed as argument in the constructor call6.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 can’t change)2.Before a method (you can’t over ride)3.Before a class(you can’t 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

B

a

b c

A B

C

Interface • Java supports 3 different structures1. Fully implemented 2. Fully unimplemented3. 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• Fully unimplemented

structure that contains all abstract metods

• Interface contains only constants

• The object of interface can’t be created directly ,anomous class is recquired to create object for this class

• Uses “implements “

Abstract class• Partly implemented or

unimplemented structure• Can contain variables• Can contain constructors• Abstract class object get

created automatically when sub class object got created

• Uses “extends”

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 methods MUST have a different argument

list.• overloaded methods MAY change the return type (in

case argument list is different).• overloaded methods MAY change the access modifier.• reference type determines which overloaded method

will be used at compile time.• constructors MAY be 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.• Applies ONLY to inherited methods• is related to polymorphism• object type (NOT reference variable type) determines which over

riden method will be used at runtime• overriding method MUST have the same argument list (if not, it

might be a case of overloading)• Abstract methods MUST be overridden• Final methods CANNOT be overridden• Static methods CANNOT be overridden• Constructors CANNOT be overridden

Packages• Java Package is a mechanism for organizing Java

classes in to a namespace.• Classes present in the package can access theeach 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.

• The static modifier for creating class methods and variables

• The final modifier for finalizing the implementations of classes, methods, and variables.

• The abstract modifier for creating abstract classes and methods.

• The synchronized and volatile modifiers, 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

contdTypes of Exception1)Checked Exception: A checked exception is an exceptionthat is typically a user error or a problem that cannotbe foreseen by the programmer. EX: If a file is to be opened, but the file cannot be found, an

exception occurs2)A runtime exception is an exception that occurs thatprobably 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 error’s 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

• The java.util.Hashtable class 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