Types of Software Testing

Different Types of Software Testing: In the Agile software development process, the Developer and testers work together in an intentioned to deliver a quality product to the customer. Here a Developer developed a product based on the requirement of the customer.

Still, the testers are playing an important role because when you plan for a quality product to the consumer, then that application or software should go through the various testing process.

When the application reaches to testers for testing, that time, testers need to test the application with various levels of testing for releasing a quality product. As per the purposes, there are different levels of testing, and in each level of testing, we are conducting a different type of testing.

Different Types of Software Testing

Software testing in general refers to the activities that examine program behavior and compare it with specific expectations. That comparison is used to find an overall level of conformance, while a test suite may refer to the collection of tests conducted on a software product or system together. Software testing can be considered as several process phases:

Unit Testing: At this point, we are looking at the purpose of unit testing is to test the smallest (understandable) code elements. These tests are written before coding and verify that each unit of source code performs its required function correctly when executed.

Functional testing: Functional testing is where we test the business functionalities against specific requirements and use cases.

Integration Testing: Integration tests are executed in this phase to test business functionalities against each other. This is also called Alpha Testing or sometimes white box testing as well as Black box testing.

Usability Testing: This is a testing technique to find out whether the system meets user needs and expectations. To accomplish such a goal, it is necessary that users are represented at all phases of development and testing.

Non-functional testing: Non-functional testing, in contrast to functional testing, is sometimes known as cross-cutting concerns because it checks properties that span across multiple areas of the software. Non-functional requirements are not limited to performance (e.g., response time and throughput), capacity (e.g., scalability), and security – they might also include usability and reliability.

Smoke testing: Smoke testing involves running an automated test suite on the build to verify that software can start correctly. This is typically implemented as a check for basic functionality like making sure that all components are present, connectivity exists between clients and servers, and that data from the previous run can be recovered. It’s sometimes called Sanity Testing. Fire-and-forget testing is also known as smoke testing.

Acceptance Testing: Acceptance testing is performed by users/customers or representatives of users/customers to determine whether a system satisfies their business requirements. It is performed only at the end of development when all functional and non-functional tests have been executed by the developers.

Stress Testing: Stress testing is a form of load testing that chooses higher than normal values for one or more input parameters to determine the point at which a system breaks or performs poorly, (e.g., an online transaction site may discover its payment processing system can handle 10 users but only 1 user at a time before performance degrades).

Manual testing: This is a type of software testing that needs manual effort to execute the test cases for any application. A human being will have to monitor and evaluate the behavior of software during execution. Examples include exploratory testing, functional testing, usability testing, and smoke testing.

Automated Testing: This is a type of software testing which is performed using special scripts as well as tools to carry out the same. Automation plays an important role in reducing the rework, and also helps in achieving high test coverage which leads to higher efficiency.

Black box testing: Black box testing is a software testing technique in which the internal structure of the software being tested, as well as its implementation details, are not known to the tester.

Load Testing: This is a type of software testing that is performed to determine the behavior of a system or component under particular workload conditions. The main objective is to measure the performance and stability of the system when it handles a large number of users simultaneously, which is generally not possible for any manual testing.

Glass box testing: Glass box testing is a software test design technique in which internal implementation details, such as the code structure and control flow, of an application are taken into account to determine how it functions. Testers choose inputs based on their knowledge of the program and its construction, rather than trying various random inputs or following a recipe-based approach.

White box testing: White box testing is a type of software test design technique that takes into consideration the internal logic of the program code rather than just its outward behavior. It also lets you create tests in such a way that they can be run automatically, allowing for large-scale regression analysis and minimizing human error.

Hybrid Testing: Hybrid testing is a combination of the different software testing types, where multiple approaches are used to perform specific types of tests. This includes the use of both manual and automated tools or techniques for executing tests in an effective manner.

Specification-based testing: This is a type of black-box testing in which the tester will be checking that all functionalities have been implemented correctly, based on the requirements and specifications.

Structure-based testing: Structure-based testing is a white-box type of software testing that tests the internal structure of an application by applying various techniques such as state transition, decision table, and control flow analysis.

State-based testing: State-based testing (SBT) is a test design technique that applies a set of predefined criteria to check the correct behavior of the application. It is a black-box type of test, which checks that the program works correctly for all possible input values (states) and gets correct output values.

Control flow testing: Control Flow testing refers to structural software testing that will cover the program’s logic expressed through control flow statements in its source code. All branches and loop variants are verified to be within the expected limits.

Gray box testing: Gray box testing is a combination of black box and white box testing methods, which aims to find defects in the module boundary. The information about internal design (white box) is used when planning test cases while the actual test itself is performed using the external knowledge only (black box). It requires that testers have some knowledge of programming languages and the developer’s environment.

Component testing: Component testing is a type of white-box testing that will check for defects in individual software components. This includes both the internal functionality and external interfaces, so it can be executed at any level of integration

User acceptance testing: User Acceptance Testing (UAT) usually refers to the process performed by users at the end of the development phase, as part of Quality Assurance activities, to check whether the software meets all their requirements and if it is ready for deployment.

Compatibility testing: Compatibility Testing refers to the process of ensuring that a product or service will work with various combinations of hardware, operating systems, network configurations, etc., and supports key business functionality. It can be performed at any stage in the development and deployment life cycle but is often conducted as a final test before product or service release.

Configuration testing: Configuration Testing refers to the process of checking that the software implementation matches the requirements in terms of quality attributes like performance, reliability, security, availability, etc., and meets all its inherent constraints. It may be performed at any stage during the Software Development Life Cycle and is a recommended practice to be performed at the end of each phase.

Reliability testing: Reliability Testing refers to the process that confirms specified reliability requirements are met, and describes how much system failure is acceptable in the course of normal operation. It can be performed at any stage during software development or maintenance, but it is usually conducted as a final test before product release.

Module testing: Module Testing is a software testing process performed on individual units of source code, often called modules, classes, or functions. Modules are tested in a separate environment from the remainder of the system to verify that they work as anticipated without interfering with any other parts of the system.

Big bang Integration Testing: Big Bang Integration testing refers to the process of integrating all the previously-tested components (modules) together and validating a completely integrated system at one stage. The objective of Big Bang integration testing is to ensure that the application meets its requirements and delivers the expected functionality in an integrated form.

Top-down Integration Testing: Top-down Integration Testing emphasizes the integration of software components in a hierarchical manner, working from higher-level components to lower levels. This testing approach is started with the highest level modules and then gradually moves on to other components until the lowest levels are covered.

Bottom-up Integration Testing: Bottom-up Integration Testing focuses on the integration of layers, which are being developed from lower to higher levels. It starts with individual components and integration of these components at lower level modules until finally, the highest-level modules are integrated

Alpha testing: Alpha Testing refers to the process of software testing where a product is released internally for use by selected customers in order to identify bugs or other problems.

Beta testing: Beta Testing refers to the process of software testing that involves delivering a release candidate to an external group of customers (the beta test team), which tests it under real-world conditions, such as different computer configurations and usage patterns.

Regression testing: Regression Testing refers to the process of executing previously-tested parts of an application or system in order to verify that changes have not compromised the originally tested functionality of the software. It is a type of error diagnosis used during maintenance in which the causes of failures are retested for.

Hybrid Integration Testing:  Hybrid Integration Testing is a combination of top-down and bottom-up integration testing approaches in which elements are integrated from both levels, starting from the highest modules to lower ones. This approach can be used for components, interfaces, or features that are developed at both module level as well as integration level

Endurance Testing: Endurance Testing refers to the process of executing a program in a variety of environments (e.g., different memory areas, error conditions, operating systems) and identifying the maximum stress that the software can handle without failure or loss of required functionality.

Sanity testing: Sanity Testing refers to an informal type of functional testing performed by non-technical users (such as business users). It typically consists of a variety of tests that can be run quickly. Software may be sanity tested before any other formal testing is performed since it can identify many basic errors in the software’s user interface and documentation. It does not assure all requirements are met but shows that they do not make the software completely unusable

Gamma Testing: Gamma Testing refers to the process of software testing where a product is released internally for use by the in-house staff. Gamma testing can be an extension of alpha or beta testing.

Boundary value analysis testing:  Boundary Value Analysis Testing (BVA) refers to a black-box software testing technique used to test the functional behavior of boundary values, i.e., extreme or outlying input data (e.g., 0 or 1, −1 or +1). It helps in minimizing the number of tests for individual parameters and reducing the overall execution time of the tests.

Equivalence class partitioning testing: Equivalence Class Partitioning (ECP) is a popular black box software testing technique that basically divides input domains to identify different equivalence classes from which test cases can be derived for execution. This approach considers inputs in conjunction with their properties as well as their relationship with the system outcomes.

Good-case/bad-case testing: Good-Case / Bad-Case Testing is a software testing technique used in exploratory testing as well as for functional and non-functional testing. This approach generates an exhaustive set of test cases from the complete set of combinations of inputs (or preconditions). The purpose is to find the most extreme combination of input that makes bugs appear.

Functions-based testing: Functions-Based Testing is an explicit software testing technique used to describe the expected behavior of a function/module as well as to verify whether it performs correctly or not. It describes test cases for each functionality in the form of success predicates, conditions and failures.

Decision tables testing:  Decision tables are a type of data structure used in software testing. They consist of expressions representing decision rules and their possible outcomes, organized in rows and columns. This approach is particularly useful for covering complex IF-THEN statements as well as identifying key scenarios that need to be tested.

Cause-effect graph testing: Cause-Effect Graph Testing is a top-down software testing technique used to model the inputs and outputs of a system as well as the process flow in which they operate. It evaluates whether each possible path through the modeled system has been tested or not, by traversing through it using cause-effect relationships

State transition testing:  State Transition Testing is a black box software testing technique used to cover complex state diagrams by applying a sequence of states, operators and inputs whose results are compared with the expected results

Exhaustive Testing: Exhaustive Testing is a top-down software testing technique that tests all possible combinations of input data. It is used for finding errors, especially in code with complex decision structures or I/O operations.

Early Testing:  Early Testing is a software testing technique that helps in detecting defects early – at the time of design or construction – so that corrections can be implemented earlier, and thus reduce development costs and increase quality.

Use case testing:  Use Case Testing is a form of black box software testing in which the test cases are derived from the functional requirements expressed as use cases.

Input domain testing: Input Domain Testing is a white-box technique used to determine if all possible inputs to an object have been tested for each combination of data and precondition, and if not, produce test cases to verify them. It is an analysis-driven testing technique that helps in generating a comprehensive set of test cases involving valid and invalid values, boundary values, etc. from the input domain space for each function or unit under test.

Scenario testing: Scenario Testing is an exploratory software testing technique used to derive extremely valuable information about a product under test, its performance and the executing environment by systematically varying parameters specified in the requirements and observing results. It specifies user inputs from different perspectives for stress-testing scenarios.

Top-down testing: Top-Down Testing is a white box type of software testing that starts with the top level of requirements, then works down into lower levels. The objective is to thoroughly test and verify an application at every level before proceeding to deeper levels of detail. Intermediate products or modules not directly called in by a program current in the test are therefore never considered for testing.

Wizard-based Testing: Wizard-Based Testing is a software testing technique used to test how well the application is able to follow the standard interactive build-a-wizard process. This approach is particularly useful for building up several tests that will be created later by applying different values and combinations of inputs at each step.

Documentation testing: Documentation Testing is a software testing technique used to test the user manuals, tutorials, and other documentation. It verifies whether users of an application or system can easily understand the use of that application or system by referring to the associated procedures, instructions, and help sections.

Statement coverage testing: Statement Coverage Testing is a white box software testing technique used to determine whether each program statement in the source code has been executed at least once by actually executing the program or through interrogation.

Decision coverage testing/branch coverage testing: Decision Coverage Testing is a white box software testing technique used to measure the quality of test cases by determining if each decision statement has been executed at least once.

Path testing:  Path Testing is a white box software testing technique used for finding errors in programs that use decision statements to control program flow.

Mutation testing:  Mutation Testing is a software testing technique that involves modifying existing, working program source code and/or binary code of a program under test.

Patch testing: Patch Testing is a software testing technique where modifications to source code are applied to the original version in order to exercise control points that have been identified as being likely bugs. This process is intended to identify the source of bugs and enhance the reliability of the system under test.

Loop testing:  Loop Testing is a software testing technique used to verify that the loop structure of a program has been correctly implemented.

Soak testing: Soak Testing is a software testing technique used at the end of a test phase or release, to determine whether systems or applications have been stable over an extended period of time.

Stability testing:  Stability Testing is a software testing technique used to determine whether a system or application continues to operate within its normal parameters, without failure, after subjecting it to extreme inputs.

Volume testing:  Volume Testing is a software testing technique used to stress application software by subjecting it to volumes of data or transactions that are larger than expected.

Breakdown testing: Breakdown Testing is a type of ad-hoc software testing in which the program logic is explored with an emphasis on coverage. It starts with simple inputs and then adds variables, compares outputs, and generally tries to break the program in various ways.

Hotspot testing: Hotspot Testing is a software quality assurance technique used to check the functional, performance or reliability aspects of programs and/or components of programs that are most heavily used.

Robustness testing: Robustness testing is a type of software testing which checks the ability of a program to perform correctly in situations where it may be subject to unexpected or incorrect inputs.

Scratch-testing: Scratch Testing (or scratch-and-check) is a technique used in Software Quality Assurance (SQA), whereby production code is tested by a single person or a small group of people.

Vulnerability testing:  Vulnerability testing is a type of software testing, which attempts to discover security weaknesses in a software program or system.

Adhoc testing:  Ad Hoc Testing/Spontaneous testing is a software testing method whereby test cases are designed, developed and executed without the aid of formal test design techniques or procedures, often in an effort to avoid issues created by over-reliance on such techniques.

Retesting:   Retesting is a software testing technique used to confirm whether previously fixed defects have been restored and that no new defects were introduced (negative testing).

Dynamic testing:  Dynamic Testing is a software testing technique used to simulate the behavior of an integrated system by evaluating individual modules.

Architecture-based testing: Architecture-Based Testing is a process where you test your design at architectural levels. Unit testing, Integration testing, and System testing can all be done at this level.

Model-based testing: Model-Based Testing is a software testing technique that is used to test whether a functional behavior of an application or system matches its specified requirements.

Ambient testing: Testing that involves testing an entire environment; things like processes, networks, and hardware. The idea is that it’s difficult to know what the real world might throw at your software, therefore you need to run it in a real environment where you can see how it performs.

Race condition testing: Race Condition Testing is an approach to software quality assurance that attempts to demonstrate, or actually produce, timing errors caused by the race between events happening on a computer system.

Static testing:  Static testing is a software quality assurance technique used to examine the source code of software for defects, security issues, and other problems in the program logic.

Monkey testing:  Monkey Testing is a software testing technique in which software is tested by randomly hitting keys, usually simulating an end-user.

Gorilla testing: Gorilla Testing is a black box software testing technique that uses an automated tool to quickly run through as many paths of the application as possible looking for specific data.

Accessibility testing:   Accessibility Testing is a software testing technique used to evaluate the accessibility of the computer application under test (AUT). Also known as website accessibility testing.

Localization testing: Localization Testing is the process of evaluating a localized product to determine if it meets all requirements for cultural appropriateness and linguistic correctness.

Scalability testing: Scalability Testing is the process of evaluating how well a system performs under increasing load. It determines whether or not it can continue running without degradation in performance, or breaking altogether

Globalization testing: Globalization Testing is the process of evaluating a global product to determine if it meets all requirements and design objectives for local culture, local business practices, language and international standards.

Interoperability testing: Interoperability Testing is the testing of software interfaces with other hardware or software products. This type of testing verifies that systems work properly together in a heterogeneous environment.

Fault injection testing: Fault Injection Testing is used to determine how faults behave when an application is executed. The purpose of fault injection testing is to identify the effects of faults for example in safety-critical systems.

Security testing: Security Testing or Penetration Testing is a method used by software manufacturers, testers and specialists to expose security flaws in computer programs and their respective software environment.

Crash testing: Crash Testing involves the act of purposely causing a program to fail. The purpose is to investigate the cause of failure and find ways to eliminate or reduce them from occurring again

Internationalization testing: Internationalization testing is the process of evaluating a product or service for readiness for localization. Internationalization testing ensures that software can handle cultural sensitivities related to different languages, writing systems and date/time formats.

Positive Testing: Positive Testing is a software testing technique that assumes the existence of bugs and tests if the application functions properly given these assumptions. If an error occurs, then there might be a bug in the program.

Negative Testing: Negative Testing is a software testing technique that assumes all is working well, and programs are designed to make sure they continue to work correctly. Negative testing tries to break the product and reports if, and where, any failure occurs.

Penetration testing: Penetration Testing is the process of evaluating a computer system or network to assess its security. The primary purpose of penetration testing is to find and report ways an attacker might penetrate, or gain entry into a target environment (e.g., combat zone).

Database testing: Database Testing is an automated testing process that involves the use of a database to test software. This is done by attempting to break into the database and exposing its vulnerabilities or deleting important data from it.

Bucket Testing: Bucket Testing is a software testing technique that involves sifting through source code and comments to find test input values. Bucket tests are used when there is little or no documentation available for the object being tested, but it can be assumed that constructor parameters and function arguments will fall into specific sets of valid values (e.g., day of the week, month, time, etc.).

A/B testing: A/B testing is a software testing technique in which two variants, A and B, are compared against each other. Variant A serves as the control while variant B is modified for improved performance. This type of testing is also known as “Split Testing” when performed on websites to measure the effectiveness of redesigns.

Split testing: Split Testing or A/B testing is a software testing technique in which two variants, A and B, are compared against each other. Variant A serves as the control while variant B is modified for improved performance. This type of testing is also known as “A/B testing.”

Standardized Testing: Standardized Testing is an automatic software testing technique that involves the use of a software testing tool to automatically execute predefined test scripts. Standardized tests are typically designed by experts, validated and stored in databases for easy and fast access.

Interface Testing: Interface Testing is a software testing technique that involves testing the interaction between two or more components. The focus here is on testing how well various system elements (e.g., operating systems, databases, network devices) interact with one another.

Interoperability Testing: Interoperability Testing is a software testing technique used to ensure that different applications and services can exchange information and operate together. This testing identifies discrepancies in both the way that applications communicate with one another and their implementation of specific protocols or data formats.

Concurrency testing: Concurrency Testing is a software testing technique that involves evaluating how well the software performs when multiple users are attempting to access it concurrently.

Performance testing: Performance Testing is a software testing technique used for measuring and evaluating how well an application performs under load or during peak usage periods. This type of testing can be performed manually, but is often automated using specialized performance testing tools.

Fuzz testing: Fuzz Testing, also known as Fuzzing or Fuzz logic testing, is a software testing technique that involves providing invalid, unexpected and random data to the inputs of a program. By doing this, you can expose bugs in the program that may not normally occur under normal input.

GUI Testing: GUI Testing is a software testing technique that involves evaluating a program’s Graphical User Interface (GUI) for usability, accessibility, and functionality. While GUI testing can be performed manually, many organizations use automated GUI testing tools to perform this task more efficiently.

API testing: API testing, also known as Application Programming Interface (API) verification or API validation, is a software testing technique used to evaluate an application’s adherence to its published programming interface. The goal here is to verify that the program will function properly when the user interacts with it using its exposed programming interface.

Service Testing: Service Testing is a software testing technique used to evaluate a software application’s overall compliance with the pre-defined service level agreements (SLAs). The goal of this type is to ensure that the organization providing the service will meet or exceed its SLA commitments.

System Testing: System Testing is a software testing technique used to evaluate an application’s compliance with pre-determined operational and functional requirements. The goal of this type is to ensure that the application is behaving as designed and will work properly in a production-like setting.

Agile testing: Agile Testing is a software testing methodology that emphasizes creativity and collaboration. This type of testing focuses on validating the functionality and usability of an application as early in the development lifecycle as possible.

End to end testing: End to end testing is a software testing technique that involves exercising the entire system, from beginning to end, in order to identify any deficiencies (bugs) that may be present.

Escape Testing: Escape Testing is a type of software testing used in security engineering; this method is specifically designed for finding defects that can compromise the security properties of an application.

Exploratory Testing: Exploratory Testing is a software testing approach used by testers during the development process in order to find bugs and expose issues early in the lifecycle.

Recovery testing: Recovery Testing is a software testing technique that evaluates the effectiveness of an organization’s incident response plan. The goal here is to ensure that the appropriate staff have all of the available resources they need in order to respond to and remediate any security incidents that may occur.

Risk-based testing: Risk-based Testing is a technique specifically designed to help organizations reduce their exposure to common risk factors. This type of testing is often used as part of the overall Risk Management process.

Installation testing: Installation Testing is a type of software testing that determines whether or not an application can be installed and uninstalled without encountering any issues.

Formal Testing: Formal Testing is a software testing technique used to determine whether or not an application meets the pre-defined functional and nonfunctional requirements. The goal of this type of testing is to ensure that the system will perform as required by the business or customer.

Pilot testing: Pilot Testing is a type of software testing that involves testing the application or system under test in a production-like environment. This allows for the team to identify and resolve issues prior to releasing the product into production.

Backend testing: Backend testing is a software testing technique that exercises the system’s backend by simulating user requests. The goal of this type includes validating the functionality and performance of the servers and services being used by an application.

Cross-browser testing: Cross-browser testing is a type of software testing used to determine whether or not an application’s functionality still works properly in the presence of cross browser discrepancies.

Browser compatibility testing: Browser compatibility testing is a type of software testing that attempts to determine whether or not an application or system functions properly across various browsers and/or operating systems.

Forward compatibility testing: Forward compatibility testing is a software testing technique used to ensure that changes made to an application do not cause errors or defects when future versions of the same software are in use.

Backward compatibility testing: Backward compatibility testing is a software testing technique that determines whether or not an application is compatible with older versions of the same system.

Mobile device testing: Mobile Device Testing is a type of software testing that focuses on validating the performance of applications on mobile devices. This includes simulating various network environments and the interaction between clients, servers, and operatingsystems.

Mobile testing: Mobile Testing is a software testing process used to evaluate the functionality of applications on mobile devices. This method can also be used when determining whether or not an application’s specific features are supported by specific mobile device models and/or operating systems.

Mobile app testing: Mobile App Testing is a type of software testing that determines whetheror not an application is compatible with mobile devices.

Downward compatibility testing: Downward Compatibility Testing is a software testing technique used to determine whether or not older versions of an application still work in the presence of newer, different versions.

Compliance testing: Compliance Testing is a software testing technique that focuses on determining whether or not an application’s performance remains consistent with the various compliance standards set forth by governing bodies such as HIPAA, PCI-DSS, CJIS and others.

Conformance testing: Conformance Testing is a software testing technique used to determine whether or not an application adheres to the various standards set forth by governing bodies such as HIPAA, PCI-DSS, CJIS and others.

UI testing: UI Testing is a software testing technique used to determine whether or not an application’s user interface remains effective in the presence of technical or security issues.

Destructive testing: Destructive Testing is a software testing technique used to determine whether or not an application’s performance degrades in the presence of certain activities/conditions.

Data-driven testing: Data-Driven Testing is a software testing technique that evaluates the output produced by different inputs, and compares it with the expected results. This type of programmatic testcan be automated to enable regression testing.

Automated software testing: Automated Software Testing is a software testing technique that uses specialized software and/or hardware to test an application automatically without human intervention.

Dependency testing: Dependency Testing is a software testing technique that evaluates the effects of addressing certain parts (components, objects, etc.) of an application separately to determine whether or not a system’s functionality remains intact.

Scenario-based testing: Scenario-Based Testing is a software testing technique used to determine how well an application performs in certain scenarios and/or conditions. This method can be used for both functional testing and non-functionaltesting.

Crowdsourced testing: Crowdsourced Testing is a software testing technique in which an organization uses its own employees, or multiple outside entities to determine whether or not an application’s performance remains consistent.

ETL testing: ETL Testing is a software testing technique used to determine whether or not data can be added, changed, and/or removed from an application’s database by means of an ETL tool. This type of software testing is often associated with data migration projects.

Data warehouse testing: Data Warehousing is a software testing technique used to determine whether or not data can be added, changed, and/or removed from an application’s database by means of a Data Warehouse Management System (DWMS). This type of software testing is often associated with data migration projects.

Failover testing: Failover Testing is a software testing technique used to determine whether or not an application’s performance remains consistent following the failure of a single component.

All pair testing: All Pair Testing is a software testing technique used to determine whether or not an application’s performance remains consistent following the failure of multiple components.

Pairwise Testing: Pairwise Testing is a software testing technique used to determine whether or not an application’s performance remains consistent following the failure of multiple components.

Functional data-driven testing: Functional data-driven testing is a type of software testing that uses automation to identify and find errors in the functional behavior of a system or component. It is usually done through test cases where testers enter code or input information into the system, which will then produce an output based on the inputted values. The output is then compared against the expected value to determine if there are any discrepancies. This process can be automated with tools like Selenium and Cucumber.