3

Why we always do:

WebDriver driver = new ChromeDriver();

Not this:

ChromeDriver driver= new ChromeDriver();

Any special reason, except object size ?

6

We generally do it this way because usually we want to be able to run our tests on multiple browsers. If we declare the driver as a specific driver type, we are then anchored to only that driver. This is not a problem if you only ever need to test on say Chrome for example. But what if you later want your tests to also be able to work with IE, Opera, Firefox, etc.?

These are extended classes of the WebDriver interface.

If your main tests and other classes define the commonly shared driver as simply WebDriver instead of specifically being tied to ChromeDriver, then the same tests can be run without change to the test code itself simply by initializing the shared driver object with a different driver extended class.

4

Absolutely right, Good explanation provided by @Bill Hileman, I was already upvoted it.

In addition to clear this doubt you need to understand What is WebDriver and ChromeDriver/Firefoxdriver.

ChromeDriver driver= new ChromeDriver();

With the use of above line, The script works perfectly on chrome browser but things are getting complicated in future if I want run my same script on Firefox or IE or some different browser.

How can we modify the same script to work for multiple browsers (Selenium Grid) instead of having a script for each browsers like ChromeDriver, FirefoxDriver, IEDriver?

Why can WebDriver be used instead of FirefoxDriver and ChromeDriver?

Because, in comparison with FirefoxDriver() and ChromeDriver() which are classes so objects can be created for them, WebDriver is an interface.

An interface is just a template that is implemented by a class. It specifies what fields and methods the class should have but without providing more details.
The classes that implement the interface will provide the methods implementations.

So WebDriver is an interface and FirefoxDriver and ChromeDriver classes that implement the WebDriver interface.

Keep in mind, Just method declarations and no method implementations.

What about FirefoxDriver()?

FirefoxDriver()/ChromeDriver() is not really implementing the WebDriver interface.

It is inheriting instead from the RemoteDriver class which implements the WebDriver interface.

Below is some content of the RemoteDriver class:

public class RemoteWebDriver implements WebDriver, JavascriptExecutor,FindsById, FindsByClassName, FindsByLinkText, FindsByName, FindsByCssSelector, FindsByTagName, FindsByXPath,
HasInputDevices, HasCapabilities, TakesScreenshot {

private static final Logger logger = Logger.getLogger(RemoteWebDriver.class.getName());
private Level level = Level.FINE;

private ErrorHandler errorHandler = new ErrorHandler();
private CommandExecutor executor;
private Capabilities capabilities;
private SessionId sessionId;
private FileDetector fileDetector = new UselessFileDetector();
private ExecuteMethod executeMethod;

public void get(String url) {
execute(DriverCommand.GET, ImmutableMap.of("url", url));
}

public String getTitle() {
Response response = execute(DriverCommand.GET_TITLE);
Object value = response.getValue();
return value == null ? "" : value.toString();
}

public String getCurrentUrl() {
Response response = execute(DriverCommand.GET_CURRENT_URL);
if (response == null || response.getValue() == null) {
throw new WebDriverException("Remote browser did not respond to getCurrentUrl");
} else {
return response.getValue().toString();
}
}

Lots of method implementations are available in RemoteDriver.

This is why, we could not create the WebDriver object, because WebDriver is an interface and not a class.

It is possible to create an object for an interface and instantiate it using any of the classes that implements the interface.

like this: WebDriver driver = new FirefoxDriver(); OR

WebDriver driver = new ChromeDriver();

By using above code, your scripts are now flexible and can use any WebDriver object which is required to invoke particular browser.

Here reference variable of type WebDriver allows us to assign the driver object to different browser specific drivers. Thus allowing multi-browser testing by assigning the driver object to any of the desired browser.

0

This is what is called Polymorphism. Either you are using your first or second code line the object size will remain the same because ChromeDriver object is being placed in memory in both the cases.

The pattern you're talking about is worth using if you are going to pass that driver to some functionality that can work with the only WebDriver implementations (and knows nothing about more specific implementations like ChromeDriver) or if your code supports several browsers and does some tricky initialisation of the particular browser type (and hence using some particular WebDriver implementation).

You should also remember that in the case of WebDriver driver = new ChromeDriver(); you would not be able to invoke the methods of ChomeDriver unless you use the explicit type casting because there are no Chrome-specific methods described in WebDriver. Due to the same reason you would not be able to pass your driver to any method that expects any specific browser implementation without a direct type casting. Below is the example of available methods for a simple WebDriver and for ChromeDriver. It can be seen that ChromeDriver has a lot more available methods than WebDriver defines.

enter image description here

Nevertheless since ChromeDriver implements WebDriver interface it can be used in Selenium framework thanks to polymorphism conception.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.