Below are the causes to face this exception:

Thrown to indicate that although an element is present on the DOM, it is not visible, and so is not able to be interacted with. To overcome this kind of situation we need to use synchronization concept in selenium. So, add an explicit wait to wait for the correct conditions to be met before trying to interact with the element. We have an option to use wait in so many ways or conditions. Will make use of all those things depends on the situation and will try to resolve or handle these type of scenarios.

Sometimes if the element is there on the web page and not in the visible area then also you can find this type of exception. To overcome this situation we need to scroll to that particular web element first then you can interact with that element to resolve this type of exception. Most of the times selenium webdriver will take care of this situation that it will find the element which is not there on the visible area and it will interact with that element. But some times, if the situation comes, then we need to scroll to the particular web element or scroll in the webpage and then can interact with the required element.

This way we can overcome the ElementNotVisibleException in selenium webdriver.

Please watch the YouTube video for this blog for better understanding.

The post Selenium ElementNotVisibleException appeared first on Selenium Webdriver Appium Complete Tutorial.

Below are the causes to face this exception:

1. This exception is caused because the list of windows hold by the driver.getWindowHandles() method is not up to date. One of the windows that previously existed is no longer exists; so, you can not switch to that window. To handle this we need to make sure that you are not closing a window without refreshing the available list of windows using this method.
2. The other reason behind this exception is that you may trying to switch to window before handling all the opened windows using driver.getWindowHandles() method. And we need to keep in mind that we should know which window we are trying to switch as getWindowHandles() holds all the windows which are opened. To get the main window then you can use one the webdriver methods called “driver.getWindowHandle()”. Once you have all the windows with you then you can loop through all the windows which are there in the list and we can switch to the desired window.

Once you done with your work, then you need to come to the parent or default windows then only your execution will be smooth. This way can overcome the NoSuchWindowException in selenium webdriver.

Please watch the YouTube video for this blog for better understanding.

The post Selenium NoSuchWindowException appeared first on Selenium Webdriver Appium Complete Tutorial.

Below are the causes to face this exception:

1. Let’s assume in your application if you have a frame and it contains some elements (for example we will take a textbox in this scenarios) and you want to enter something into that textbox. For this we have captured the locator of the textbox and used the same in the code and everything is correct as per the logic. But after execution of the script we will find NoSuchFrameException. And best part here is selenium will tell us with the proper exception, instead if it says NoSuchElementException then it will be very difficult us to resolve these kind of scenarios.Actually the issue is, if you have frames in your application then you need to switch to that frame first and then only you will be able to interact with the elements which are there inside the frame in selenium.
2. Let’s assume one more scenario where you have a webpage with more than one frame. We will call them frame A and frame B. We will assume that we first switched to frame B to check/verify something in the frame B. If we then try to find frame A, we will get NoSuchFrameException. This is because frame A does not exist in the context of frame B.

To overcome this issue is to always go back to the parent frame before trying to switch to another frame

If you have a frame inside a frame then you no need to go back to parent content. You can directly switch to that frame. But after completion of all the things which you want to perform inside the frames need to come out of the frames to continue further script capturing and execution.

You can use frame IDs or WebElements to locate the frames and then you can switch to them. You can also use frame indexes to switch to them but use this as a last option.

Please watch the YouTube video for this blog for better understanding.

The post Selenium NoSuchFrameException appeared first on Selenium Webdriver Appium Complete Tutorial.

Below are the reasons to get this exception:

1. The locator which you are using to locate the element is incorrect/changed.
2. The element which you are looking is not rendered.
3. Trying to find the element before it was rendered.

Locator is Incorrect/changed:

Here we have two possibilities that the locator which you have written to identify an element may be incorrect or sometimes after writing/capturing the code, if there are any changes in the application then the locator may change. In both scenarios tool will not able to identify the element and it will throw NoSuchElementException.

To overcome this, we need to take the element locator which is causing this issue and validate against the application that the locator is identifying/highlighting any element on the application or not? For this we can use Firefox add-ons i.e. firebug and firepath then you place the locator in the firepath and validate the same against application that it is highlighting the element or not?

And sometimes if you are not navigated to a particular page after clicking on a link or button then it will cause this issue as it will look for the element to interact in the new page but actually it is not navigated to that page. But here the actual error show that it is not able to find particular element but the issue is not with that element as the page not yet navigated to that page. This kind of situation is bit tricky, but we need to find these type of issues also. Best example for this is navigating to application using login page but if the credentials are wrong then you might get this issue.

To overcome this issue, we can capture the screenshots for these type of scenarios and can find the issues by looking into these screenshots.

Element Not Rendered:

It is bit difficult to find this as something is not rendering on the application then you need to debug the code and see what could be the real issue. If something is not rendering then that is a bug in the application.

Here if you use the first issue resolution then it will not work as if you try to highlight the element in the application using firebug and firepath then it will not show anything in the console. But this is not an issue with the locator instead the element is not rendering on the application.

To overcome this issue, we can capture the screenshots for these type of scenarios and can find the issues by looking into these screenshots.




Trying to find the element before it was rendered:

Sometimes we are trying to interact with an element which is not yet rendered on the application. Here also we will get the same kind of issue which we saw in the above. But in the above case the element is not completely rendering, here it is rendering but taking bit more time to load. Now a days lots of modern websites use technologies such as jQuery or AngularJS, which use the JavaScript to manipulate the DOM. And Our Selenium is very fast. In many cases, it’s ready to start interacting with your website before the JavaScript has finished doing its job.

To overcome this, we need to think that how a manual tester will test these kind of scenarios. They will wait until the element renders on the application. So, same way we need to wait to load that particular element. For this we will use Synchronization concept i.e. we need to stop the code execution until the element renders. For this we can use ExpectedConditions class and its methods to achieve this functionality.

Please watch the YouTube video for this blog for better understanding.

The post Selenium NoSuchElementException appeared first on Selenium Webdriver Appium Complete Tutorial.

One of the good things in selenium is while looking into the exception we will come to know what went wrong as the exception names will give some what clear picture for the error which we will face.

Below are some of the Exceptions which we will see while automating the applications:

1. NoSuchElementException
2. NoSuchFrameException
3. NoSuchWindowException
4. ElementNotVisibleException
5. StaleElementReferenceException
6. InvalidElementStateException
7. UnreachableBrowserException
8. SessionNotFoundException

Now we will see briefly about these exceptions:

NoSuchElementException:

This is the most and frequent facing exception. You will definitely find this kind of exception while automating the application. The reason for this exception is, the element you are trying to find does not exist.

NoSuchFrameException:

This is also most and frequent facing exception. In modern applications people are using iFrames very frequently. When you try to find an iFrame on application and it is not exist in the application then code will throw NoSuchFrameException.

NoSuchWindowException:

This is also very similar to the previous exception. A Window is a browser which is opened by the webdriver or child window(i.e.another browser opened from the parent browser). When you try find a Window and that is not available at present, then the code will throw NoSuchWindowException.

ElementNotVisibleException:

This is also most and very frequent facing exception. This ElementNotVisibleException tells you that the WebElement that you are trying to interact with is not visible to the user.

StaleElementReferenceException:

This is an exception that you will quite often see when you work with AJAX or heavy JavaScript websites, where the DOM is continually being changed. When the element is no longer attached to the DOM then you will face this exception.

InvalidElementStateException:

This exception you can not find very frequently. When you try to interact with any element then an unexpected popup will come but we are not sure why and what it is. An InvalidElementStateException is thrown when the WebElement that you are trying to interact with is not in a state that would allow you to perform the action that you would like to perform.

UnreachableBrowserException:

Sometimes you will face this type of Exception. As we know that selenium sends commands to the browser to execute and get the response back. Sometimes we will not get the response from the browser then we will get UnreachableBrowserException.

SessionNotFoundException:

You will not get this kind of exception frequently. But while you executing your tests and something will go wrong and will lose connection with the browser instance that you are driving. Then you will get SessionNotFoundException.

These are the most frequently exceptions we will face while automating any kind of application.

Please watch the YouTube video for this blog for better understanding.

The post Selenium WebDriver Exceptions appeared first on Selenium Webdriver Appium Complete Tutorial.

In this, we will see how we will handle the below elements which are frequent in any application:

1. Textbox
2. Button
3. Radio Button
4. CheckBox etc…

To achieve this we will write one simple sample program to automate the AUT(Application Under Test). Here we will see the process in step by step. For this we need to follow the below steps:

1. Install/Download any IDE(to write the code)
2. Download and Add Selenium Jar files
3. Create a Java Project In IDE
4. Create a Class under the Project
5. Write Sample Code
   • Open Browser
   • Navigate to the application URL
   • Capture the locators of the Web Element which are there on the application
   • Write the code for automating the functionality
   • Execute the program.

Below is the Sample Program:

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;

public class SampleProgram
{
   public static void main(String[] args) throws InterruptedException
   {
       System.setProperty("webdriver.gecko.driver", "Path of gecko driver");
       WebDriver driver = new FirefoxDriver();
       driver.get("http://demo.automationtesting.in/Register.html");
       driver.findElement(By.cssSelector("input[placeholder='First Name']")).sendKeys("Krishna");
       driver.findElement(By.cssSelector("input[placeholder='Last Name']")).sendKeys("Kumar");
       driver.findElement(By.cssSelector("#submitbtn")).click();
       Thread.sleep(5000);
       driver.quit();
   }
}

In the above program we are handling some of the basic elements (i.e. Textbox and Button).  For each and every webelement it is mandatory to get the locator and use the same in the code to identify that element.

We have separate API/methods to handle different types of elements. To handle textbox we have separate method and to handle the button we have separate methods. Same way we have different API to handle different web elements. We need to understand the element before interacting with it. And the selenium simulates the human interactions means how you interact with the application manually almost same way selenium also interacts with the application.

Please watch the YouTube video for this blog for better understanding.

The post Handling Basic Elements in Selenium appeared first on Selenium Webdriver Appium Complete Tutorial.

But as an automation tester while writing/capturing the scripts using selenium then it is mandatory to find the locator of each and every element which we want to interact. If we are very good at writing the XPath or CSS Selector though it will take so much time to capture the locators. Each browser has its own plug ins to find the elements but easiest and powerful plugins are available with Firefox browser.

Below are the plugins which are very helpful to find the elements and co-ordinates:

1. Firebug
2. Firepath
3. WebDriver Element Locator
4. MeasureIt

FireBug:

This is most popular and powerful web development tool. It is used to inspect the HTML and modify style and layout in real time. But in selenium we will use this to inspect the elements on the web page to get the locator. It will show the HTML written behind the web page in a structured manner and it will highlight the particular element which you inspected.

You can get more information and you can download this plugin from this link. Apart from this you can directly go to the Add-ons > Extensions of the firefox and search for the firebug from the search box available here and can install. Need to restart the firefox to effect the changes.

FirePath:

Firebug only highlights the element but it will not give the locator value. But using Firepath we can get the locator value directly without writing anything. But these may not be accurate as it uses its own logic to construct the locator. To write effective locators we can customize the firepath given value. Most of the times we can directly use the value which is provided by the firepath. And sometimes we need to change the value of this according to the situation.

You can get more information and you can download this plugin from this link. Apart from this you can directly go to the Add-ons > Extensions of the firefox and search for the firepath from the search box available here and can install. Need to restart the firefox to effect the changes.

Firepath will give XPath and CSS Selector values directly when you inspect the element using firebug.

WebDriver Element Locator:

This plugin is also used to find the locators of the particular element on the web page. This is combination of Firepath and Firebug we can say as if you right click on any element on the webpage it will give so many language(i.e. Java, C#, Ruby and Python) options along with XPath. You just right click on any element and then you can get the XPath of that particular element and you can copy in the code. It will make your life more easy.

You can get more information and you can download this plugin from this link. Apart from this you can directly go to the Add-ons > Extensions of the firefox and search for the WebDriver Element Locator from the search box available here and can install. Need to restart the firefox to effect the changes.

MeasureIt:

This plugin is used to find the coordinates of the particular element. Sometimes in selenium locators may not work or may not possible to get those. In those situations we will depend upon the coordinates. For ex, if you want drag and drop particular element; sometimes destination might be dynamic then we can use the coordinates to find the area where we want to drop the element.

You can get more information and you can download this plugin from this link. Apart from this you can directly go to the Add-ons > Extensions of the firefox and search for the measureit from the search box available here and can install. Need to restart the firefox to effect the changes.

These are the basic and very helpful plugins while automating the applications using selenium. We have so many other alternatives for different browsers but these are the very suitable and helpful plugins and it will make your automation life easy 🙂

Please watch the YouTube video for this blog for better understanding.

The post Useful Tools and Plugins in Selenium appeared first on Selenium Webdriver Appium Complete Tutorial.

CSS Selector in Selenium Web Driver will describe the importance of the CSS Selector in Selenium automation.It is very common that when you want to automate any application the most important thing is to identify the element to interact with it. Particularly when you using Selenium as your automation tool, explicitly you have to identify the element on web page. There are so many ways to identify the elements in Selenium and those are called locators. One of the most used, popular and fastest locators is CSS Selector.

CSS Selector is a way of identifying the element on web page. In simple words, finding address of an element on the web page. You can use so many ways to identify the element using CSS Selector.

Using CSS is best practice when you compare to XPath. The advantages of CSS over XPath are:

• CSS Selector will not change browser to browser as XPath will change.
• CSS is native to browsers and XPath is not
• XPath can traverse up the document from a child element to parents.
• XPath engines are different in each browser, hence make them inconsistent
• IE does not have a native xpath engine, therefore selenium injects its own xpath engine for compatibility of its API. Hence we lose the advantage of using native browser features that WebDriver inherently promotes.

However there are some situations where, you need to use XPath and that will depend on the application.

By using below methods we can identify the elements uniquely.

1. TagName
2. Id
3. ClassName
4. Attributes
5. Contains
6. Starts-with
7. Ends With

TagName:

Using tag name we can identify the element. But it will locate so many elements on the web page as page may have same tags in many places. So, it will not locate the element uniquely. This is not a good practice to use the tag name individually to locate the element.

Example:

input

In the above image, the input tag highlighted/located 15 elements. So, tag name may not useful while identifying the element uniquely.

ID:

ID is an attribute to the element or tag to describe what kind of element that is. IDs are         unique. If you want to use ID as locator then need to use ‘#’ symbol in front of ID.

#IDValue

Example:

#optionsRadiosInline1

In the above example, only one element highlighted using ID. # is mandatory to identify the element using ID.

Class Name:

Class is also an attribute to the element to apply the styles to that tag/element. Class names are not unique. So, if use these; it locate so many elements which are using the same class. If you want to locate an element using class name use any other attributes as extra parameters to identify the element uniquely.

If you want to use Class Name as locator then need to use ‘.’(i.e. dot) symbol in front of class name.

.className

Example:

.radio-inline

In the above example, 2 elements highlighted using className. . (dot) is mandatory to identify the element using class name




Attributes:

    As class Names are not unique, need to use the other attribute values along with class name to identify element uniquely.

Sometimes single attribute is enough to identify, but some times it will not suffice to identify the element then we will use multiple attributes to identify the element uniquely.

Single Attribute:

tagName[attribute = ‘attributeValue’]

Example:

input[placeholder=’First name’]

Multiple Attributes:

tagName[attribute1=’attributeValue1’][attribute2=’attributeValue2’]

Example:

input[type=’text’][placeholder=’First name’]

Contains:

We can use contains method to identify the element. Need to use ‘*’ (i.e. Star) symbol to identify the element.

tagName[attribute*=’partialAttributeValue’]

Example:

input[placeholder*=’First’]

Starts With:

We can use startswith method to identify the element. Need to use ‘^’(i.e Cap) symbol to identify the element.

tagName[attribute^=’attributeStartingValue’]

Example:

input[name^=’first’]

Ends With:

We can use endswith method to identify the element. Need to use ‘$’(i.e Dollar) symbol to identify the element.

tagName[attribute$=’attributeStartingValue’]

Example:

input[name$=’rstName’]

Conclusion:

Here the conclusion is, need to identify the element uniquely on the web page to interact with exactly. The above are the only examples to demonstrate. Those CSS will vary depends on the application and how the HTML is written.

Please watch the youtube video for better understanding.

The post CSS Selector in Selenium WebDriver appeared first on Selenium Webdriver Appium Complete Tutorial.

XPath in Selenium Web Driver will describe the importance of the XPath in Selenium automation.It is very common that when you want to automate any application the most important thing is to identify the element to interact with it. Particularly when you using Selenium as your automation tool, explicitly you have to identify the element on web page. There are so many ways to identify the elements in Selenium and those are called locators. One of the most used and popular locators is XPath.

XPath (XML Path Language),  is a query language for selecting nodes from an XML document. The XPath language is based on a tree representation of the XML document, and provides the ability to navigate around the tree, selecting nodes by a variety of criteria.

XML contain one or more elements/tags/nodes, an element may contain content/data or may contain other elements as child nodes. Each element should have starting tag and ending tag. The element content will reside in between these two tags. Apart from the content each tag  may have attributes. These attributes will give extra information about the element.

Below is the sample XML:

 
<automation>
      <selenium type="opensource">
          <webdriver>
             Open Source Automation Testing Tool.
          </webdriver>
      </selenium>   
      <qtp type="licenced">
      </qtp>
 </automation>

Brief information about the above XML:

1. <automation>, <selenium>, <webdriver&> and <qtp> are the tags/nodes/elements.
2. <automation> is the root tag.
3. <automation> have 2 child nodes called <selenium&gt; and <qtp>.
4. <webdriver> is the child of <selenium> and grand child of <automation>.
5. <webdriver> have content (i.e. Open Source Automation Testing Tool.).
6. <qtp> does not have any content.
7. type is an attribute of the element and it will give extra information about the element.

XPath is a way of identifying the element on web page. In simple words, finding address of an element on the web page. You can use so many ways to identify the element using XPath. In the XML, starting node is called as root node or context node.

XPath in Selenium Web Driver has 2 types to identify the element:

1. Absolute XPath
2. Relative XPath

1.1 Absolute XPath:

1. Absolute XPath starts with the root/context node (i.e. html) as html is the starting tag of any web application or with the single forward slash(i.e. / )
2. Writing Absolute XPath is very easy.
3. It identifies the element very fast.
4. Apart from the advantages, there are few disadvantages also.
   • You can not recollect or remember for which element you have written this XPath.
   • This XPath may broke once an extra element is added in between or an element is removed in between.

Example:

in the above image the absolute XPath is :

html/body/section/div/div/div[1]/form/div[1]/div[1]/input

we can observe some of the div tags had [1] as suffix. It indicates that if a parent node have the multiple same child nodes, then this number indicates the child number. In this case this is the first div in the child nodes.




1.2 Relative XPath:

1. Relative XPath starts with any of the element which we want.
2. Relative XPath will not starts with the root node.
3. Writing Relative XPath is bit time consuming.
4. The chances of failing Relative XPath is very less i.e. the way we construct the XPath.
5. It will start with the double forward slashes i.e.(i.e. // )
6. It will not be long as absolute XPath.

Example:

In the example, the relative XPath is:

//*[@id=’basicBootstrapForm’]/div[1]/div[1]/input

Here, XPath starts from “form” tag to identify the element. We can observe a ‘*’ after the double forward slash, that indicates it might be any element in the XML. It will search all the elements in the XML. To fasten the search of the element we can use the specific element tag instead of this ‘*’.

Here, in this example we can replace the ‘*’ with “form” tag as the XPath is starting from the “form ” tag. It searches all the form tags for the element instead of all the tags.

We can identify the elements using attributes in the Relative XPath. Tags may contain attributes to specify what kind of element it is. A tag can contain a single attribute or multiple attributes.

By using below methods we can identify the elements uniquely:

1. Single Attribute
2. Multiple Attributes
3. Contains
4. Starts-With
5. Text
6. Ancestor
7. Preceding
8. Descendant
9. Following

Single Attribute:

By using single attribute also, we can identify the element.

//tagName[@attribute=’attributValue’]

Example:

In the example, the relative XPath is:

//input[@name=’firstName’]

Multiple Attributes:

Sometimes single attribute may not help to identify the element. Then we can make use of multiple attributes to identify the element uniquely on the web page.

//tagname[@attribute1=’attribute1Value  and @attribute2 = ‘attribute2Value’] or

//tagname[@attribute1=’attribute1Value][@attribute2 = ‘attribute2Value’]

Example:

In the example, the relative XPath is:

//input[@name=’firstName’  and @placeholder = ‘First name’] or

//input[@name=’firstName’][@placeholder = ‘First name’]

Contains:

We can use contains method to identify the element.

//tagName[contains(@attribute,’partialAttributeValue/fullAttributeValue’)]

Example:

In the example, the relative XPath is:

//input[contains(@name,’first’)]

Starts-With:

We can use starts-with method to identify the element.

//tagName[starts-with(@attribute,’partialAttributeValue/fullAttributeValue’)]

Example:

In the example, the relative XPath is:

//input[starts-with(@name,’first’)]




Text:

We can use text method to identify the element.

//tagName

Example:

In the example, the relative XPath is:

//label

Ancestor:

Selects all ancestors (parent, grandparent, etc.) of the current node.

Example:

In the example, the relative XPath is:

//label

//ancestor::div

Preceding:

Selects all nodes that appear before the current node in the document, except ancestors, attribute nodes and namespace nodes.

Example:

In the example, the relative XPath is:

//label

//preceding::div

Descendant:

Selects all descendants (children, grandchildren, etc.) of the current node.

Example:

In the example, the relative XPath is:

//*[@id=’basicBootstrapForm’]//descendant::div

Following:

Selects everything in the document after the closing tag of the current node.

Example:

In the example, the relative XPath is:

//*[@id=’basicBootstrapForm’]//following::div

Conclusion:

Here the conclusion is, need to identify the element uniquely on the web page to interact with exactly. The above are the only examples to demonstrate. Those XPath will vary depends on the application and how the XML is written.

Please watch youtube video for better understanding.

The post XPath in Selenium WebDriver appeared first on Selenium Webdriver Appium Complete Tutorial.

Selenium WebDriver Locators will discuss about the different kinds of locators which are available in the selenium webdriver. The basic use of locator is to identify the element on the web page uniquely. All the elements which are there on the webpage are called WebElements in selenium webdriver.

Below are the webdriver supported locators:

1. ID
2. ClassName
3. TagName
4. Name
5. LinkText
6. Partial LinkText
7. CSS Selector
8. XPath

Now we will discuss all these things in detail.

ID:

This is the most efficient and preferred way to locate an element. This is one of the attributes to the tags which are used to develop the application. The concept of putting ID to an element is to identify the element uniquely. But developers may put or may not put the IDs to the tags. If we use IDs to locate the elements, then the identifying the element is accurate and fast.

Sample HTML Code:

<input id="datepicker2" class="is-datepick" type="text"/>

The above code will indicate a textbox on the web page. If I want to interact with this text box we can use the below code.

Selenium Code:

driver.findElement(By.id("datepicker2"));

ClassName:

This is also one of the attributes to the tags which are used to develop the application. But the basic motto of using a class is to apply some style to the element. There is a chance of using the same class name to different type of elements to apply the same style. So, this attribute is not unique to identify the elements. But combination of classes can be used to identify the element.

Sample HTML Code:

<input id="datepicker2" class="is-datepick" type="text"/>

The above code will indicate a textbox on the web page. If I want to interact with this text box we can use the below code.

Selenium Code:

driver.findElement(By.className("is-datepick"));

TagName:

By using tagName also we can identify the elements in selenium webdriver. But there is a chance of having more elements with the same tag name. So it is very difficult to identify a single element using tag name. But if you want to identify more than an element which is having the same tag name then we can go with tag name.

Sample HTML Code:

<input id="datepicker2" class="is-datepick" type="text"/>

Selenium Code:

driver.findElements(By.tagName("input"));

Here it might return more than one element as there is a chance of more ‘input’ elements on the page. It is not a good practice to identify single element using tagName always. It is very helpful while finding more elements.

Name:

This is also one of the attributes to the tags which are used to develop the application. But this is not mandatory to any tag. This will give just an extra information about the tag.

Sample HTML Code:

<input id="datepicker2" name="enableddatepicker" type="text"/>

Selenium Code:

driver.findElements(By.name("enableddatepicker"));

LinkText:

This is also one of the ways to identify the element. But by using this locator we can not locate all kind of elements. By using this we can identify only the links available on the web page. A link is an anchor tag on a web page. Here we need to use all the link text to identify the element.

Sample HTML Code:

<a href="Register.html">Register</a>

The above code will indicate a link on the web page. If I want to click/interact that link we can use the below code.

Selenium Code:

driver.findElement(By.linkText("Register"));

Partial LinkText:

This is an extension to the previous one. If you are not sure of the entire link text or want to use only part of the link text, you can use this locating mechanism to identify the link element. If more than an element containing the part of the text equal then you can identify more elements using this locator like tagName.

Sample HTML Code:

<a href="Register.html">Register</a>

The above code will indicate a link on the web page. If I want to click/interact that link we can use the below code.

Selenium Code:

driver.findElement(By.partialLinkText("Regi"));

XPath:

XPath (XML Path Language), is a query language for selecting nodes from an XML document. The XPath language is based on a tree representation of the XML document, and provides the ability to navigate around the tree, selecting nodes by a variety of criteria.

XML contain one or more elements/tags/nodes, an element may contain content/data or may contain other elements as child nodes. Each element should have starting tag and ending tag. The element content will reside in between these two tags. Apart from the content each tag may have attributes. These attributes will give extra information about the element. We can locate any kind of element using XPath.

Can find more information at XPath in Selenium WebDriver

CSS Selector:   

This is also similar to XPath. Here also we will use different kind of ways to identify an element. But this is slightly faster than the XPath. We can locate any kind of element using Css Selector.

Can find more information at CSS Selector in Selenium WebDriver

Please watch the YouTube video for this blog for better understanding.

The post Selenium WebDriver Locators appeared first on Selenium Webdriver Appium Complete Tutorial.