Selenium Online Training By Quontra Solutions USA: Selenium learning for beginners

Showing posts with label Selenium learning for beginners. Show all posts

Tuesday, 5 August 2014

Manual and Automated Testing

There are mainly two broad types of software testing – Manual Testing and Automated Testing.
Manual Testing
Manual Testing involves testing the software without any automation script or any tool. Testers check the application or software by taking up the role of an end user. They try to find out if there is any unexpected behavior or failure in the application. Test Management can be taken care of by using test plans and test cases.

Automation testing

Automation testing process involves testing with the help of automation scripts and executing the scripts to run the application with the help of some automation tool. Once the script is ready then these tests can run quickly and efficiently.
Since the cost of automated testing is in the form of efforts and time required to create the scripts, not all tests can be converted to automated test. There should be a valid reason to pay that cost.
Reasons for Automation
1. Regression testing to confirm that new changes have not affected the application adversely. It considers already existing test cases for execution. This is an efficient process when we need to provide feedback to the developer immediately.
2. The test cases need to be iterated multiple number of times often with varying datasets to cover multiple workflow paths.
3. When we require support for agile methodologies.
4. Customized reports are required for monitoring.

Getting Started with Automated Testing

Once the need for automated testing has been established, it involves creation of relevant test scripts. Test script creation can be done only by a skilled testers having knowledge of testing, the suite of tools as well functionality under development. Such resources are costly and their time is a premium. Considering this fact, it is often not possible to budget the automation of all tests. Some of the major decision points while identifying cases for testing automation are
1. System modules where requirements do not change frequently
2. Ample time is at hand to describe a test via scripts
3. The application/software module is critical enough to justify the upfront cost of automation
4. After functional testing we want to do performance testing with multiple virtual users using the same test script.
With the scope of automation decided, next step is to pick the testing tool. The following checklist can help with the selection.
1. The tool should be able to easy to work with. It should execute test cases in unattended manner. It should provide interface to write scripts, efficient IDE and ease of test execution.
2. The tool should provide support to various technologies. It should support testing using different browsers, languages, and types of applications.
3. It should integrate with a software that does Application Lifecycle Management so that it can be used for running automated Build Verification Tests as well as the reports can be integrated with other reports created by ALM software

Comparison Between Selenium and QTP

Platform Support
-Language Support
Selenium uses Selenese, a high-level, cross platform language to write Selenium commands which is a domain specific language. There are 3 basic categories for the commands – named actions, accessors and assertions. To write tests there are a lot of programming languages like C#, Java, Perl, PHP, Python or Ruby.
QTP scripts can be written with VBScript which is a high-level language with support to everything except polymorphism and inheritance.
- Support for various application types
Selenium supports only Web applications.
QTP supports almost any kind of applications.
Selenium scores fewer points in this regard as it supports only web application. QTP supports almost all kinds of applications

- Support for various browsers
Selenium supports all versions of IE, Firefox, Safari and Opera and a few more browsers.
QTP supports IE & Firefox. But both do not provide full cross browser support.
Selenium is the clear winner in this respect
- Support for Data Driven Testing
Selenium IDE supports xml data source using user extensions.
Data Driven testing is implemented as Excel workbook that can be accessed by QTP. There are 2 types of data sheet global and local. Global sheet is a single one which can be accessed from every action in a test. There can even be a local data sheet associated with every action.
- Exception Handling
Selenium IDE does not support error handling particularly unexpected errors (as it supports only HTML language). Selenium RC will provide support for it (it supports languages with .NET, Java, Perl, Python, PHP, Ruby).
QTP provides VBScript with the help of which we can use On Error statements.
- Validations or Assertions
Selenium assertions can be used in 3 modes assert, verify and waitFor. When an “assert” fails, the test is aborted. When a “verify” (Soft Assertions) fails, the test will continue execution, logging the failure. This facility can be used with TestNg framework. The “waitFor” commands wait for some condition to become true. They will succeed immediately if the condition is already true. However, they will fail and halt the test if the condition does not become true within the current timeout period.
For QTP there are checkpoints: to verify application under test. These are of 10 types – Standard, Table, Image, Bitmap, Database, Text, Text Area, Page, Accessibility, and XML. A checkpoint is a verification point that compares the current value with the expected value. If the current and expected value match it generates a PASS status otherwise FAIL status.
- Support for Objects
Object properties are not supported by Selenium. Selenium objects can be managed by using UI element user extensions. QTP comes with in-built object repository.
QTP objects have user friendly names.
Integration with Application Lifecycle Management and going beyond
- ALM Integration
Selenium being an Open Source software can be integrated with other Open Source products for Application Lifecycle Management like QMetry. This in turn can provide platform for software development lifecycle platform in the form of Atlassian Jira (project tracking tool), FogBugz or Bugzilla (bug tracking tool).
QTP being a part of Quality Centre it supports requirement traceability matrix. QTP integrates seamlessly with QC. Test management and mapping the manual testing process with automation becomes a lot easier with this integration
QC is still not complete life cycle management tool. It does not provide support for efforts management, build management or support to different process templates. It supports only test management, bug management and requirement management.
- Going beyond
Selenium being Open Source a lot of plugins available. Selenium IDE has plug-ins for customization, for adding new functionality to API, changing existing functionality.
QTP provided plug-ins for ActiveX controls, web application and VB objects. Other than these plug-ins for other objects like Microsoft .NET, multimedia plug-ins and Windows Mobile are also available. These QTP plugins available at an additional cost.
Each of the tools keeps on adding features as per need. Selenium being open source there are a lot of plug-ins.

Selenium WebDriver Training

What is Selenium Webdriver?

Webdriver is known to be the latest version of Selenium i.e. Selenium 2.x. More powerful than the primitive Selenium rc 1.x and comes with lots and lots of libraries and new features to work with. It’s not mandatory to know Selenium RC to work with Webdriver. You can directly learn webdriver and start working on it. There is no need of selenium server if you are working with Webdriver API

What makes it different from Selenium RC?

More object oriented as compare to Selenium RC.
Has wider range of APIs
Interacts natively with browser where as Selenium RC is Javascript based.
Can test Iphone and Andriod based application which is not supported by Selenium RC.
Implements HTMLUnit driver which makes test execution really fast.
Unlike Selenium RC there is no server in Webdriver.
Supports almost all lastest web browsers where as Selenium RC does not works on latest versions on Firefox and IE.

WebDriver Architecture

Element Identification using Selenium WebDriver: Questions and Answers

1: What is the method used to launch URL using Selenium WebDriver?
Answer: In Firefox, we can set the homepage as the required URL as shown in the code below. This will launch the URL set in homepage on launching the driver.
FirefoxProfile profile = new FirefoxProfile();
profile.setPreference(“browser.startup.homepage”,“http://www.google.com”);
//We will provide the profile used as argument for Firefox Driver.
WebDriver driver = new FirefoxDriver(profile);
In case, we do not want to use profile, we can use the get method to launch the URL.
WebDriver driver = new FirefoxDriver();
driver.get(“https://www.google.com”);
2: What is the difference between findElement and findelements method in Selenium?
Answer: To locate an element in the page, we use findElement method whereas findElements gives the collection of web elements in the Page.
Syntax for findElement is:
WebElement tableinfo = driver.findElement(By.className(“tableClsName”));
This will give the first element in the page with className as “tableClsName”. Now once the element is recognized, we can perform action on the WebElement. Suppose the element is a button, we can click on the button as shown below:
Tableinfo.click();
Suppose the WebElement is an input box, we can insert data in the input box as shown below:
Tableinfo.SendKeys(“This is a test”);
Syntax for findElements is:
List<WebElement> tabledata = tableinfo.findElements(By.tagName(“td”));
This will give collection of all elements in the page with className as “td”.
We can further work on the collection of the object and extract the required information or perform actions on the required webElement as shown below:
List<WebElement> tabledata = tableinfo.findElements(By.tagName(“td”));
for (int iCnt = 0;i<tabledata.size();iCnt++)
{
String strData = tabledata.get(iCnt).getText() ;
If(strData.contentEquals(“this is the row”))
{
System.out.println(“Web Element Found”)
iCnt = tabledata.size()-1;
}
}
3: What are the value ways to identify an object in Selenium WebDriver?
Answer: Below are the various locators by which elements can be identified in Selenium WebDriver:
1. Id: Identifies WebElement by the ‘Id’ attribute.
2. ClassName: Identifies webelement by the ‘class’ attribute.
3. cssSelector: identifies element based on the css of the webElement.
4. linkText: Identifies element by the actual text of the link. Text should match exactly with the link text.
5. Name: Identifies webelement by the ‘name’ attribute.
6. partiallinkText: Identifies element by the actual text of the link. The link is identified on partial match of text.
7. tagName: Identifies an object by the tagName of the webElement.
8. xpath: Identifies an object by the xpath of the object.

Selenium IDE: Interview Questions with Answers

1: Explain the various features provided by Selenium IDE?
Answer: The layout of Selenium IDE is divided into following four areas:
1. MenuBar – Following are the menu options available in Selenium IDE:
a. File – Allows creating new test case, test suite, open existing test case, test suite, exporting tests to other formats.
b. Edit – Allows editing existing test steps, and adding new commands and comments.
c. Actions – Allows to record, play a test, execute command, toggle breakpoint and set entry point.
d. Options – Allows the changing of settings including set the timeout value for commands and specifying the format used for saving test cases.
e.  Help – provides documentation for selenium IDE.
   2.  Toolbar – Provides buttons to manage test execution including test execution and test execution.
   3.  Test Case Pane – Test Case Pane shows the list of test case on the left and test steps in table or
source pane on the right. We can add/modify commands, target and value in the table for the test.
    4.  Log/Reference/UI-Element/Rollup Pane – This pane helps us to view logs of execution, reference explaining the selected command. We can also set to filter logs for info, warning, error and debug in this window.
2: Explain what are the various items available from file menu
Answer: From the File Menu, We can perform various tasks
a. Create New Test Case.
b. Create new Test Suite.
c. Save test cases and test suites.

Export Test cases/test suites to various formats. E.g : Ruby/Python/java/c# with WebDriver or RC.
Open existing test cases and test suites.

d. Rename a test case.
3: Can the script prepared in Selenium IDE be used with webdriver/Remote control?
Answer: Yes, the script created in Selenium IDE can be exported to WebDriver/Remote Control in the languages java/c#/python/ruby that can be run using junit(java), RSpec(ruby), nUnit.
4: My Application is running slowly, can I change the default timeout value of recorder command?
Answer: We can reset the default timeout value for recorded command from Options Menu. By default the timeout is set as 30000 ms. In options, we can also define the recording settings and order of locator preference for object identification.
5: What is the short cut key to create a new test in Selenium IDE?
Answer: The shortcut key to create a new test in Selenium IDE is Ctrl + N.
Some other useful shortcut keys in Selenium are:
Open a test – Ctrl + O : Save a test – Ctrl + S : Add test to test suite : Ctrl + D.
6: What is the use of Select and find button in target in Selenium IDE?
Answer: On clicking on select, we can add the locator of an element in the page. Click on Select and click on an element in the page, the locator for the element will be added in the target. Find helps us to verify object exists in the page and highlights the object in the page if exists, else error is displayed in the log.

Activities in Testing Process

Testing Process includes following activities that should be followed sincerely for proper testing.
1. Test Planning

Before beginning with testing, we need to define test plan based on which we perform testing for the rest of testing life cycle. We should develop a test plan based on following key points to be considered in testing life cycle.

Test Objectives should be measurable, prioritized, and should be signed off between stakeholders before moving forward with test planning. Acceptance Criteria should also be defined during objective settings to validate if the test objective has been accompanied.
Test Matrix should be defined on how to test the test objectives and to validate all the requirements are covered in testing.
Test Schedule should be defined, how milestones in testing will be covered and timeframe in which milestones will be delivered
Budgeting and resources planing should be defined.
Testing material including environment ans software/availability should be defined.
Training required for testing should be defined.

2. Test Control Activities

Once Test plan is created and signed off by stakeholder, Activities in test plan should be compared with actual and any deviation from the projected plan should be reported to stakeholders as risk.

3. Test Analysis

In this phase, test objectives defined in test planning are converted into test scenarios and test cases.Below are the main task in this phase:

Reviewing the test artifacts like business requirements, design, and test objectives.
Identifying and prioritizing test scenarios and test cases based on business requirements.
Identification of test data for execution of test conditions
Test environment availability

4. Test implementation

Below are activities in test implementation

Developing and prioritizing test cases with test steps
Preparation of test data for execution of test scripts.
Environment set up for testing.
Development of automation test harness.
Preparation of test suites for regression, smoke testing, and execution of similar tests in batch.

5. Test Execution and Reporting

Execution of test scripts either manual or automated.
Reporting defects found during test script execution.
Regression testing and retesting of fixed defects.
Reporting of test execution status to stakeholders.

6. Exit criteria

Evaluating Testing status against the exit criteria specified in test planning.
Test Status should validate that all acceptance criteria are verified.

7. Test Closure Activities

Delivering all the planned test artifacts to the client. For e.g : Automated Test Scripts,test scripts, test data for further reuse.
Handover of artifacts and knowledge transfer to maintenance team
Analysis of lesson learnt during testing process.

Selenium Remote Control

Selenium Remote Control (RC)

Overview

While Selenium IDE may seem a productive and efficient tool for writing test-cases, it lacks many essential features of a testing tool:
- Conditional statements
- Loops
- Logging
- Exception handling
- Reporting
- Test fixtures and data-driven tests
- Test dependencies
- Taking screenshots
Selenium RC is the answer to a more powerful test-suite for your applications.
It follows a client/server model allowing client libraries to execute tests on a browser controlled by the server.

Selenium Server

Selenium server is the program that drives the browser
It embeds Selenium Core framework and injects it into the browser
It communicates with the running test client and drives the browser
Client tests sends commands that the server interpretes in order to drive the browser
The server sends back results to the client
Client and server communicates via HTTP GETs and POSTs so you can easily plug into
Server is configurable at startup via command-line options. use java -jar selenium-server.jar -h to see the list of options

Client libraries

Client libraries provides the API to program tests and execute them on the server
Each implementation provides access to all Selenium commands
Supported API implementation exists in:
- Java (also accessible via Groovy)
- .Net
- PHP
- Python
- Perl
- Ruby

Locators In Selenium

Locators
Selenium uses what is called locators to find and match the elements of your page that it needs to interact with. There are 8 locators strategies included in Selenium:

Identifier
Id
Name
Link
DOM
XPath
CSS
UI-element

Identifier
Works with the ID and name attributes of your html tags. Let’s consider the following example:
<html>
<body>
<form id=”login”>
<input name=”username” type=”text”/>
<input name=”password” type=”password”/>
<input name=”submit” type=”submit” value=”Continue!”/>
</form>
</body>
</html>
Valid locators for this snippet are :

identifier=login
identifier=username
submit

Id
The Id strategy looks for an element in the page having an id attribute corresponding to the specified pattern. <label id=”my_id” /> will be matched by a locator like id=my_id or just my_id
Name
Like the Id strategy, but on the name attribute. You can also specify a filter to refine your locator. Currently, there are two filter types :

Value : matches elements with a name attribute and where the value follows a pattern. The following example illustrates the interest of filters :

<html>
<body>
<div id=”pancakes”>
<button type=”button” name=”pancake” value=”Blueberry”>Blueberry</button>
<button type=”button” name=”pancake” value=”Banana”>Banana</button>
<button type=”button” name=”pancake” value=”Strawberry”>Strawberry</button>
</div>
</body>

</html>
Link
This strategy is intended to select links only and selects the anchor element containing the specified text: link=The text of the link
DOM
The DOM strategy works by locating elements that matches the javascript expression refering to an element in the DOM of the page.

dom=document.div['pancakes'].button[0]
document.div[0].button[2]
dom=function foo() { return document.getElementById(“pancakes”); }; foo();

XPath
While DOM is the recognized standard for navigation through an HTML element tree, XPath is the standard navigation tool for XML; and an HTML document is also an XML document (xHTML). XPath is used everywhere where there is XML. Valid XPath locators can be:

xpath=//button[@value="Blueberry"]: matches the Blueberry button
//div[@id="pancakes"]/button[0]: same thing

CSS
The CSS locator strategy uses CSS selectors to find the elements in the page. Selenium supports CSS 1 through 3 selectors syntax excepted CSS3 namespaces

Commands In Selenium

Commands

The Selenium API defines dozens of commands that can be categorized into the following:

Actions
Accessors
Assertions

Actions

Actions are commands that change the state of the application like clicking links or buttons, select an option in a <select> or type a character sequence in a given textbox.
Actions are available in different flavors. For instance, click(locator) will trigger a click on an element locator but you can also find:
- clickAndWait(locator) command which will trigger a click and stop the test until the browser has finished loading a new page.
- clickAt(locator, offset) command that also triggers a click but takes another argument: a X and Y tuple that offset the actual clicking location by X and Y pixels.
- A combination of the above : clickAtAndWait(locator,offset) that combines the specification of an offset for the click location and waits for a new page to load.
test with actions

?

type id=search Donuts near my home

?
- type modifies the state of the application (it modifies a test field) and so is considered as an action
Accessors
- Accessors inspect the state of the application and store values in variables.
- For instance, storeCookies(variableName) stores all the cookies in use in the current page in the variable variableName.
- To use stored variables, the syntax is ${variablename} (or storedVars['variableName'] if in a JavaScript context):
  
  Test with variables
  
  store my_search_string searchString
  
  ?
  
  type id=search ${searchString}
  
  ?
  
  and if in a JavaScript code section:
```
if (storedVars['variableName'] == '') {
  ...
}
```
Assertions
- Assertions are also able to inspect the current page but:
  
  They are made to return a boolean value
  
  This boolean represents the conformity of the element to a desired pattern
  
  Usually, the pattern represents the state of an element.
- Assertions come into 3 flavors:
  
  assert : if assertion fails, test is aborted and marked as failed : assertTitle(pattern) will fail if the title of the page doesnot correspond to the pattern argument.
  
  verify : if a verification fails, the test doesnot stop but a trace will be printed in the log.
  
  waitFor : these commands pause the test until a condition is satisfied or a timeout is reached.

Thursday, 10 July 2014

Selenium Online Training by Quontra Solutions

We are pleased to supply a lot of information and a dozen of free hands-on tutorials. All the available tutorials are surrounded with screenshots and downloadable code samples. This blog is created and will be maintained by Quontra Solutions. Quontra solutions Trainers have many years of experience in automated testing. Quontra Solutions is particularly interested in web technology and new programming languages. We are always trying to find a way to transfer knowledge to Students who are interested in the automated testing of software.
A variety of topics will be covered on this blog. Starting with recording tests with Selenium IDE and locating web elements and furthermore the use of design patterns and performance measurement to create a robust testing framework.
Selenium Tutorial using C# and NUnit
In this tutorial we are going to learn how to create your first test script using the language that most commonly used, c#. Since most languages are semantically the same, if you do not use c# it shouldn’t be too difficult to translate the tutorial into your language of choice. You have to download Nunit and at least Visual Studio Express c# edition to complete this tutorial. They are free to download and use.

Follow steps 1-4 of Selenium Remote Control HTML Suite Tutorial. This will get the Selenium Remote Control Running.
In Visual Studio let’s create a new project. You will have to create a new class library by going New> New Solution> Class Library and call it TheAutomatedTester
Add a reference to the NUnit Framework by rightclicking on the solution and clicking add reference. Click on the browse tab and navigate to <%nunithome%>\bin and select nunit.framework.dll . This allows you now to create your first NUnit test.
Now in the *.cs file put the code below into it. The code below will call Selenium Remote and say that it needs an instance on Firefox Chrome.

[TestFixture]
public class TheAutomatedTester
{
private ISelenium selenium;
private StringBuilder verificationErrors;
[SetUp]
public void SetupTest()
{
selenium = new DefaultSelenium(“localhost”, 4444, “*chrome”, “http://localhost”);
selenium.Start();
verificationErrors = new StringBuilder();
}

Now Lets create a test:

[Test]
public void AutomatedTester_Test()
{
selenium.Open(“/index.htm”);
selenium.Click(“buttonName”);
selenium.WaitForPageToLoad(“30000″);
}

The code above would open the page index.htm for the root of your local web server then click on a button and wait for a page to load. If you want to see how to the other commands look I would suggest creating your command in Selenium IDE and then converting them to c# using the Options > Format commands.

Once your test has run you will need to clean up Selenium object. The best way to do this is to create a teardown function in your test. It should look like something like the code below.

[TearDown]
public void TeardownTest()
{
try
{
selenium.Stop();
}
catch (Exception)
{// Ignore errors if unable to close the browser
}
Assert.AreEqual(“”, verificationErrors.ToString());
}

If you make sure that your code has this teardown then you will be able to reuse the Selenium Remote Control.

Now compile the code into a DLL and Open it with NUnit. When you click the Run button in NUnit it will run your Selenium Test.

If you would like to make your test data driven put all the code to pull the data in the SetUp

Friday, 4 July 2014

Selenium Interview Questions

Below are the few commonly asked Selenium Interview Questions
What is Selenium?
Selenium is a suite of tools for browser automation. It is composed of “IDE”, a recording and play back mechanism, “WebDriver” and remote control “RC” which provides APIs for browser automation in variety of languages and “Grid”, which allows many tests using APIs to be run in parallel. The recorded tests can be imported in most languages like html, Java , .net , perl , ruby etc. The exported test can be run in any browser and any platform using selenium remote control “RC”
What are the components of selenium ?
Selenium IDE – Plugin to Firefox to record and play test in Firefox and also export tests in different languages. The most appealing format is the html test case which seems to be based on fit html
Selenium RC- Allows playing of exported test in different platform/OS
Selenium Grid – Allows to control lots of selenium machines(you typically don’t need this only for load test -and hence may ignore it).
What are the capabilities of Selenium WebDriver or Google WebDriver or Selenium 2.0?
Capabilities of Selenium WebDriver or Google WebDriver or Selenium 2.0 are:
One should use WebDriver when requiring improved support for

Mult-browser testing including improved functionality for browsers not well-supported by Selenium-1.0.
Handling multiple frames, multiple browser windows, pop-ups, and alerts.
Page navigation.
Drag-and-drop.
AJAX-based UI elements.

Which are the browsers supported by Selenium RC?
Browsers supported by Selenium RC are:

Firefox
Mock
Firefoxproxy
pifirefox
iexploreproxy
iexplore
firefox3
Safari proxy
Google chrome
conqueror
firefox2
safari
piiexplore
firefoxchrome
Opera
iehta

What are the Operating Systems supported by Selenium?
Operating Systems supported by Selenium are:
Selenium IDE
Works in Firefox 2+ Start browser, run tests Run tests
Operating Systems Supported:

Windows
OS X
Linux
Solaris
Others whichever supports Firefox 2+

Selenium Remote Control:
Used for starting browser and run tests
Operating Systems Supported:

Windows,
OS X
Linux
Solaris
Others

Selenium Core:
Used for running tests
Operating Systems Supported:

Windows
OS X
Linux
Solaris
Others

What is the difference between assert and Verify Commands?
There are two mechanisms for validating elements that are available on the application under test. The first is assert: this allows the test to check if the element is on the page. If it is not available, then the test will stop on the step that failed. The second is verify: this also allows the test to check whether the element is on the page, but if it isn’t, then the test will carry on executing.
What is the price of Selenium license per server?
Selenium is open source software, released under the Apache 2.0 license and can be downloaded and used without charge.
How much does Selenium license cost per client machine?
Selenium is open source software, released under the Apache 2.0 license and can be downloaded and used without charge.
Where to download Selenium?
Selenium can be downloaded and installed for free from seleniumhq.org

Selenium Tutorial using C# and NUnit

Follow steps 1-4 of Selenium Remote Control HTML Suite Tutorial. This will get the Selenium Remote Control Running.
In Visual Studio let’s create a new project. You will have to create a new class library by going New> New Solution> Class Library and call it TheAutomatedTester
Add a reference to the NUnit Framework by rightclicking on the solution and clicking add reference. Click on the browse tab and navigate to <%nunithome%>\bin and select nunit.framework.dll . This allows you now to create your first NUnit test.
Now in the *.cs file put the code below into it. The code below will call Selenium Remote and say that it needs an instance on Firefox Chrome.

[TestFixture]
public class TheAutomatedTester
{
private ISelenium selenium;
private StringBuilder verificationErrors;
[SetUp]
public void SetupTest()
{
selenium = new DefaultSelenium(“localhost”, 4444, “*chrome”, “http://localhost”);
selenium.Start();
verificationErrors = new StringBuilder();
}

Now Lets create a test:

[Test]
public void AutomatedTester_Test()
{
selenium.Open(“/index.htm”);
selenium.Click(“buttonName”);
selenium.WaitForPageToLoad(“30000″);
}

Once your test has run you will need to clean up Selenium object. The best way to do this is to create a teardown function in your test. It should look like something like the code below.

[TearDown]
public void TeardownTest()
{
try
{
selenium.Stop();
}
catch (Exception)
{// Ignore errors if unable to close the browser
}
Assert.AreEqual(“”, verificationErrors.ToString());
}