Manual Testing :-
Writing Testcases ,Review , Execute The Test cases
We are using the AGILE Methodology
Reporting tool :- JIRA
in scrum we have a sprint meet in that sprint we plan sprint
Understanding The requirements
write test cases
Execute Test cases
Finding the Defects / Bugs
Report to the Developer about Bugs/Defects
Participate different review meets
write test cases using test design Technique like
Boundary value Analysis
Equivalence class Partitioning
Decision Table based
State Transmition
Error guessing
1)Boundary Value Analysis :::---(min-1(false),min(True),min+1(True) ::: max-
1(True),max(True),max+1(false))...
2)Equivalence class partitioning :::---
In equivalence class partitioning we divided data into 2 partitions
like ---valid inputs
Invalid inputs..
3)decision table Based Testing :::---
Decision table based techinque is used for more number of conditions
Example :::--- Transfer money online to an account which is already approved and added..
In this Senario :::---
conditions are
Account already added
OTP need to match
Sufficient amount to Transfer
Actions:::---
Money transferred
OTP not matched
Insufficient Amount in Account
State - Transmission :::---
In State transmission Technique change the input condition to the State of AUT(Application Under Test),
In the state-transmission Technique tester to test behavior of an AUT
Error Guessing :::---
which type of testing’s you used to work with :-
mainly we are using work with Regression and Re-testing
Agile Methodology ::---
In Agile we are using Scrum Framework
In Scrum Frame work we have a different type of fields
like we have product backlog
sprint plan meeting (Estimated Stories)
Sprint backlog(any backlogs from old sprint)
Normally sprint time will be 2 to 4 weeks(once sprint time is decided it will not be changeable)
we have a daily scrum meets as well (in the starting of the day)
once we finished the sprint we have a sprint review meet (completed of every sprint)
Sprint Retrospective :- after complete the sprint . in that sprint what went well , what went
wrong & where we need to improve the areas of coming sprint
Bug Life Cycle :::---
(DUPLICATE)
(DEFERED)
(REJECTED)
NEW ---> ASSIGN ----> OPEN ---> fIXING -----> PENDING FOR RE-TEST ----> RE-TESTING ----> FIXIED ----> CLOSED
! !
RE-OPEN !
! !
<----------------- BUG NOT FIX ----------------------------------
JIRA :-
Automation ::---
Writing Automation Scripts
Executing Automation Scripts
Generate Report's (about Bugs/Defects)
Status Report send to Management Teams.
Implicit Wait :-
It's a global Wait
once we implement IMPLICIT WAIT Defaultly it will applicable to all WEB-ELEMENT in the WEBPAGE
Syntax Of Implicit Wait ::---
driver().manage().timeouts.implicitlywait(20,Timeunit.seconds);
Explicit Wait :::---
It's also called as a WEBDERIVER WAIT
Explicit Wait is Applicable only Perticular WEB-ELEMENT(it's not a global wait)
Syntax Of Explicit Wait ::---
WebDriverWait wait= new WebDriverWait(driver,20)
WebElement aboutme;
aboutme= wait.until(Expectedconditions.VisibilityOfElementLocated(By.id("about_me")));
aboutme.click;
Overloading & OverRiding :::----
Over loading :::---
when 2 or more methods in same class have same name but different parameters , with same are
different return types.
It is an examole of complie time Polymorphism
which method to call is decided by compiler.
Syntax :::---
<return-type>method_Name(Parameters);
int add(int a,int b)
float add(float a, float b)
int add(int a ,int b ,int c )
Example ::--
class Animal
public void add()
//code
}
public void add(int a , int b)
{//code
public int add(int a, int b , int c)
{//code
}}
Overriding :::---
in overriding Occurs in 2 class that is parent and child class (i.e Inheritance is involved),
in method overloading the Method name and Parameters are same,
The return type also same
in Overriding Use the method in child class which is alredy present in the parent class and if we want we
can modified the code in child class ..
It is an Example of Run Time Ploymorphism.
method call is decided by JVM in run time
Example ::--
class Animal {
Public void feauthers()
//Animal Features
class Dog extends Animal {
public void features(){
//your modified dog code
}
}
Polymorphism In Java :::---
1)complie time Polymorphism(Method Overloading)
2)Run time Plymorphism (Method Overriding)
oops concepts :::---
1)Object
2)Class
3)Inheritance
4)Polymorphism
5)Abstraction
6)Encapsulation
1)Object :--
Object is a real time entity,
Object can be defined as an Instance of a class, an object contains an address and takes up some
space in memory.
Example :-
Class :---
Collection of Objects called class
A class can also be defined as a BLUEPRINT of Object , class can’t consume any space
Abstraction ::--
Abstration is the methodology of hiding the implementation of internal data and showing the
Functionality to the users.
Interface ::--
Basic Statement we all Know in Selenium Is Webdriver driver=new FirefoxDriver():
WebDriver itself is an Interface . so based on above statement WebDriver driver=new FirefoxDriver();
We are initializing firefox driver using selenium WebDriver. It means we are creating a reference
variable(driver) of the interface (WebDriver) and creating an Object , here webdriver is an interface as
mentioned earlier and firefox is a class.
Inheritance ::--
One class acquires the properties(instance variables ) and functionalitys to the another classs
Like from parent class to child class.
Encapsulation ::--
Encapsulation is the process of binding data and code together . it is used to hide the
implementation details
Polymorphism ::--
Polymorphism is a concept of performing single task in different ways
There is a two types of polymorphism
1)static polymorphism (compile-Time (Method over-Loading))
2)Dynamic polymorphism(Run-Time (Method over-Riding))
Action Class in Selenium ::--
Action class in selenium for handling KEYWORDS and MOUSE EVENTS.
METHOD DESCRIPTION
clickAndHold() Clicks(without releasing) at the current mouse location
context click() Perform a context-click at the current mouse location (it’s also called RIGHT
CLICK also)
Double-Click
Drag and Drop
keyDown(modifier_key) parameters::- modifier_key any of the modifier keys(keys.ALT,keys.SHIFT,or
Keys.CONTROL)
keyUp()
Constructor ::--
Constructor is a block of code that allows you to create an object of the class ,
Constructor is look’s like a method but it’s not ,
Methods can have a return type or no return type , but constructor don’t have any return type not
Even void.
Types of Constructor ::--
1)Default
2)No-arg Constructor
3)parameterized constructor
1)default constructor :--
If you do not implements any constructor in your class, java compiler inserts a default constructor
into your code.
Verify In Selenium ::--
Verify in Selenium is also known as a Soft Assertion
In hard Assertion when assertion fails , it terminates or about test
If the tester does n’t want to terminate the script they cannot use hard assertion to overcome this use
Soft assertion on Verify.
DropDowns :-
1)to find the no of webelements & Print the all WEbelements or Text.
2)How to select particular text/Web element in drop downs
TestNg (Frame Work)::--
1)TestNg Annotations ::-
1.1)@BeforeSuite :- If u want to run code Before Suite is run we r using Before Suite Annotation
1.2)@AfterSuite :- If u want to run code After Suite is run we r using After Suite Annotation
1.3)@BeforeClass ,,
1.4)@AfterClass ,,
1.5)@BeforeMethod ,,
1.6)@AfterMethod ,,
1.7)@BeforeTest ,,
1.8)@AfterTest ,,
1.9)@BeforeGroup
1.10)@AfterGroup
1.11)@DataProvider
1.12)@Parameters
1.13)@Factory
1.14)@Listeners
1.15)@Ignore
All Annotation will run based on TestNg XML FILE (each file having own pattern)
Import org.testing.annotations.Test;
Run All
Public class AnnotationsTest(){
@Test
Run | Debug
Public void testtimehold1(){
System.out.println(“Test Method”);
@BeforeMethod
Public void beforeMethod (){
System.out.println(“BeforeMethod”);
@AfterMethod
Public void afterMethod (){
System.out.println(“afterMethod”);
@BeforeClass
Public void beforeClass (){
System.out.println(“BeforeClass”);
@AfterClass
Public void afterClass (){
System.out.println(“afterClass”);
@BeforeTest
Public void beforeTest(){
System.out.println(“BeforeTest”);
@AfterTest
Public void afterTest (){
System.out.println(“aftertest”);
@BeforeSuite
Public void beforeSuite(){
System.out.println(“BeforeSuite”);
@AfterSuite
Public void afterSuite (){
System.out.println(“aftersuite”);
////////////////////////////////////////
<!DOCTYPE suite SYSTEM “https://testng.org./testing-1.0.1”>
<suite name=”suite”>
<test name= “test1”>
<classes>
<class name=”com.hyr.Tests,AnnotationsTest”>
<method>
<include name=”testmethod1” />
</method>
</class>
</classes>
</test>
</suite>
Example :-
2)how Test Cases will run in TestNg(Default Execute Order)
3)how to Run 1 test case in multiple testcases
