It is the process of analyzing any given piece of software to determine if it meets shareholders’ needs as well as detecting defects, and ascertaining the item’s overall quality by measuring its performance, features, quality, utility, and completeness. Bottom line, it’s quality control.

Quality control is the process of running a program to determine if it has any defects, as well as making sure that the software meets all of the requirements put forth by the stakeholders. Quality assurance is a process-oriented approach that focuses on making sure that the methods, techniques, and processes used to create quality deliverables are applied correctly.

Automation testing is a software testing strategy in which a tester programmatically runs the tests using a tool or a framework instead of manually going through the test cases and executing them one by one.

1. Unit tests: These are written by software developers and test a unit of code in isolation.
2. Integration tests: These test how well different software components work with each other.
3. Regression tests: Verify that the new code didn’t break any existing functionality.
4. Performance tests: Ensure that the software won’t crash and perform reasonably under heavy load or stringent conditions.
5. UI tests: Ensure that the software uses a consistent user experience and no visual or graphical elements on the screen are broken.

A test is a good candidate for automation under the following conditions.

• The test is repeatable.
• The feature under the test doesn’t change its behavior frequently.
• It’s time-consuming for a human tester.
• The test involves complicated calculations.
• The test ensures the previous functionality didn’t break after a new change.

Hire QA is hiring for the position of Mobile App Automation Engineers for our clients.

• Location: Hyderabad / Bengaluru / Pune
• Experience: 3-6 Years
• Skills Required: Appium, Selenium WD, Java/Python, POM, TestNG / BDD Cucumber, ExtentReport, Git, Jenkins

Strong knowledge and experience in

• Immediate joiner with strong experience in mobile app automation using Appium and Java.
• Strong experience in Selenium WD, POM, TestNG/BDD Cucumber, ExtentReport, Git, Jenkins.
• Experience or knowledge in automation framework design or improvisation.

Hire QA is hiring for the position of Selenium plus Functional API Test Engineers for our clients.

• Location: Hyderabad / Bengaluru / Pune
• Experience: 3-6 Years
• Skills Required: Selenium WebDriver, JAVA, TestNG/BDD Cucumber, POM, Maven, Extent Reports, Jenkins, Postman

Strong knowledge and experience in

• SDLC Models, Agile Methology.
• Requirement analysis, test case design, test case execution.
• Identify, record and track bugs to closure.
• Test Strategy and Test Planning.
• Estimate, prioritize, plan and coordinate testing activities.
• Perform feasibility study for test automation.
• Designing and building Selenium Test Automation Frameworks (Hybrid & CUCUMBER).
• API / Web Services Testing using Postman.
• Configuring and scheduling jobs in Jenkins.

Performance testing is a specific type of testing that determines a system’s responsiveness to a particular workload in a particular context.
It also allows to verify and validate non-functional attributes such as scalability, reliability, availability, and resource usage.

It is essential to test to verify that the product or software built behave s as expected by the customer, meets or exceeds the expectations.
Personal information shared by the end-user is secured while using the product, application, or services. The features provided in the application perform as per expectation and requirement.
The product has no serious anomalies.
By testing an application, any deviation from expected behavior can be identified and reported to the stakeholders.

Testing is a process of running an application to identify any defects that breaks the functionality, Features provided in software offer results as expected, System securely display output as quickly as possible. Software features should display same output and behave as expected every repeated instance of running it.
The software can be tested manually by testers or can run automatically using a script and follow steps that tester execute to test the application.

Quality of a product or service can be defined as a level of reliability that meets or exceeds expectations of end-user. For Example, the taste of Amul ice cream or any of the dairy products available in the market produced by Amul is reliable for the quality, new products introduced in market also exceed the expectation.

Following are important artifacts essential for testing any software application
Test strategy is high-level document that defines test approach for the software, what features are essential to test (objective of testing), how to test (methodology), Types of testing to be carried out, and execution of tests.
Test plan decides which tests are for manual testing and which one is for automated testing (distribution of testing task), Who will test what(test schedule), and when to start testing and end testing (duration within which testing should complete)
Test cases are scenarios with steps to be carried out, mapped to requirements with the expected output, to be carried out during testing of an application with status for each scenario, based on the actual result. Test cases can be executed manually or converted into scripts to be executed with the help of tools like selenium or QTP.
Test Data is the valid values that are fed to an application as inputs while running an application in order to test it. It is mandatory to design valid test data as per the scenario that results in expected output. In case the actual output differs from the expected output, the deviation is reported as a bug in the defect management system.
Test Environment is a system configured that mimic or match to system specifications at the client, in order to run software on this system to verify how the system at client be have for the tests and use cases.

1. In order to test, a tester should first understand –
2. The requirements and output expected by using a software application and from software requirement document approved by the customer and project owner.
3. How software works, domain knowledge (software used in specific discipline or field such as e-commerce, Banking, Insurance, Enterprise Resources planning, Gaming, Education or training, or Search – based application)
4. Whether the software is desktop based or web based
5. What are the features and its functionality,
6. How many input forms to be filled in, what are the input fields and their valid values,
7. How user interface elements like text field, radio button, checkbox, drop -down list, buttons and their types (submit, reset, cancel) functions.
8. What to expect in an output form.
9. Working of computer, types of networks.
10. In case of desktop application, what technology is used in developing a software How to install the software?
11. What technology is used in building user interface? (HTML, XHTML, JSP, ASP, JavaScript, VBScript, JQuery)
12. Where reference data gets stored, where data for analysis will be uploaded and then processed What database type is used to store data?

Desktop applications are those software that can be installed on standalone machine called as client machine (desktop or laptop). These software use native resources of standalone machine such as network, CPU, memory and storage, in order to perform specific task for which they are designed for.
Desktop applications are designed to run on standalone machine, by single user. Multiple users can access the printer, scanners if they are LAN connected with desktop applications.
Some Examples of desktop application are Windows file explorer – to access files stored on hard drive of local machine, Microsoft’s office applications such as word, excel, PowerPoint to write and access documents, generate tabular reports on finance and design presentations, Web browsers to access websites and searching information on the internet.

Desktop applications are feature-based applications, where users should be proficient in operating such applications, understand its features, accessing the menu, submenu. Software’s features can be tested with Graphical user interface tests, end to end testing, and functional testing. Non – functional testing will depend on stand-alone machine’s limited resources such as CPU, memory, storage, accessing files, or use features like printer/scanner if desktop applications are connected in local network.

Web-based application need web server in order to host them, visitors need internet connection and need a browser to access the web site, and internally web sites process user requests and send responses via hyper Text Transfer Protocol (HTTP). Multiple users can access same feature of web application at same time simultaneously.
Examples of web-based application are e-commerce portals for online purchase of products of our choice (amazon.com, Flipkart, bookmyshow.com), websites of most of the companies, universities, search engines (google.com, altavista.com).

Web-based applications require browsers such as (Internet Explorer, Chrome, Firefox, Safari, Opera), and a reliable internet connection to explore. Web-based applications can be tested for functionality testing for any invalid page redirects, broken links, page not displaying.
Working of web elements such as input field, drop-down list, checkbox, radio button, submit button. verify for valid input data entered, methods used while data submits, compatibility tests for browsers used, performance to test latency (time taken to access pages), delay in opening next pages or output, and Security testing for verifying login for authentication.

• Anomalies are something that deviates from normal, standard or expected. Based on different situations anomalies are termed as listed below :-
• Error – When the developer identifies mistakes in his code, he says Error for the anomaly.
• Defect – When Tester discovers and reports the anomaly, he says Defect to the anomaly.
• Bug – When the reported defect is accepted by the developer, it is called Bug.
• Failure – When software build does not meet requirements, it is called a failure by the product owner.
• Wrong – when there is a deviation from specification or requirements not understood, the anomaly is termed as wrong
• Missing – when a feature is missing after the software is deployed at the client site, it is said features are missing.
• Extra – when the developer produces the feature more than the requirement, it is calle d an extra feature. It will be termed as an anomaly as you are giving what is not asked for

• Arithmetic defects – are numerical data related defects, like not displaying decimal points in case of banking, scientific, or e-commerce sites, these defects occur due to mistakes from the developer side.
• Logical defects – are due to not understanding business logic for the required output , like if age >=18 you will get driving license, in case developer reverses the condition, even with age equal to or greater than 18, you won’t get a license, but will get for age less than 18 years, that adversely affect real -time situation.
• Syntax defects – occur if the condition required is not applied properly by developer, like in software that corrects grammar in sentence, say to locate vowels in sentence i.e. word beginning with a, e, i, o, and u characters, will be a vowel, and should proceed with letter ‘an’. If developer forgets to enforce this condition, vowel can’t be found or corrected if ‘an’ is not preceding it.
• Multithreading defects – multithreading is an ability of CPU to execute multiple tasks simultaneously. If developer cannot able to produce such ability programmatically, then application cannot execute multitasking, such as downloading an image in web page and rendering it on screen.
• Interface defects – If developer cannot maintain order in which data flow should follow or page displayed after current displayed page, then it is called interface related defect.
• Performance defects – If latency (delay in displaying page) is too high, if server crashes during multiuser access, these are Examples of performance defect. This can affect adver sely and user will not return back to website.

It is expected while testing a software, tester should reveal all the defects and deviations from requirements, while running an application such that it should break. Tester should understand domain knowledge, able to design actual scenarios, conditions that are not thought of and not handled by developer, able to configure specifications and preconditions to verify how appli cation performs. Have analytical knowledge and logical thinking; think out of box while testing software.

Unit testing is primary test level, one way is static testing, where code is verified for syntax, rules followed by organization which is conducted by developer, second way is dynamic testing where small snippet of code is debug (tested) with sample test data to validate the output. Various tools for unit testing are JUnit, Hansel, and Testing are used to verify code coverage.

When application build is released after bugs fixed from the developer, and or changes due to additional requirement, the testing carried out is called sanity test, to verify that bugs are fixed, still functionality is in place, and no new bugs or defects are observed. In case while running sanity tests, bugs still exists, testers can reject the build.

When software build is released, tester conducts primary tests like all the menus and submenus are clickable, and display the corresponding page, tester make sure that mod ules and feature are present in application, and there is absence of ‘Page Not found’ message while accessing any page, Forms and Pages have all usable web elements and display stable pages.

Example, drop down list in all the input form does not display it ems for user to select, due to any reason, this if found during the smoke test, then tester will stop testing and can reject the build by informing the short coming to development team.

Tester use testing experience, while testing an application, explores the features and learn about how the application works, during testing, he makes note of how the application be have s, and such tests are called exploratory testing. The requirement document is absent, and testers are exposed to the application first time, without any test cases created.

Integration testing is the second level of testing after unit testing, where different modules are combined together and then tested for verifying that data flow in sync between the modules and there is no a broken page or failed functionality.
Example –During integration testing, IRCTC site can be checked where after searching train, booking seats in particular train, when payment gateway, which is integrated into application found not working.

System testing is the third level of testing after integration testing, where the application under test is tested for an end to end functionality, to confirm that it works as desired.
Example – matrimonial portal can be tested from registration, searching candidate, receiving contact details and meet or fix appointments with prospects.

Interface testing is a verifying communication and data transfer between two different systems, where interface can be API or web services.
Example – Booking air tickets using ticketing portals like goibibo.com, where ticket is booked using web service of the airlines showing flight time, destinations, availability of seats and fare to travel to destination from starting point.

Regression testing is conducted on the build after bugs are fixed build, to validate that code change to fix bug has not adversely affected functionality and there should not be another defect.

Alpha testing is a type of acceptance testing, where testers are employees of an organization who has built the application, these tests are conducted to verify that all the issues found have been resolved and have not reoccurred, before releasing to the client.

Beta testing is tests conducted at the client’s site after application is deployed and handed over to client. These tests include usability, functionality, and reliability of application.

Performance testing falls under non-functional testing type, where latency (speed or delay in accessing or loading a page), responsiveness and stability of application, network, stress or load tests are carried out to check efficiency/performance of application.

Load testing is one form of non-functional testing, in which behavior of application is observed when itis exposed to load.
Example, verifying behavior of Netflix portal during movie streaming by viewers between evening 7 pm to 9 pm in any time zone.

This non-functional testing is conducted by subjecting an application to overload in order to verify till how long system is sustaining to the stress, hence the name – Stress testing.
Example – during amazon festive season sale, subjected to overload when users multifold times than expected will access the portal and book a newly arrived mobile, there by website server may fail to handle such a heavy load.

Security testing is a testing of an application against malpractice from hacker, how effective protective software like firewall or antivirus installed are in data protection, and vulnerabilities of login system by sql injection.

Software or an application is tested without executing code, such as Code Review, coverage that business logic is properly taken care is called Static testing. Variable declared but not used in code, undefined variables, unreachable code, syntax violations and code structure approved in organization.
Tools like code compare, coverity, parasoft are used for s tatic code analysis

For dynamic testing, application should have compiled code and executed in order to run application, various parameters such as CPU, memory, latency or time taken for output, are analyzed and recorded. Valid input values are prepared and expected output values are listed as requirement.
Main test types included in dynamic testing are functional and non-functional testing. test level included in dynamic testing are Unit, integration, system and acceptance testing.

Compatibility testing are conducted to verify that software runs on various environments, operating systems without any conflicts. Compatibility of an application is tested across different Hardware configuration, operating systems like Ubuntu, Linux, windows, MacOS, Network, Browsers like firefox, chrome, opera, safari, various devices like desktop pc, laptop pc, mobile, etc.

Reliability testing is carried out in order to confirm that software display reliable output that is same irrespective of test environment, operating system, browser etc.

Compliance testing is a non-functional test that validates that the software designed meets all the prescribed standards as described in requirement document. for Example Vehicles in North America are made according to Canadian Environmental Protection Act 1999 (CEPA 1999), under this act Environment Canada has an authority to regulate emission from on-road engines

Localization tests verify that application can be used in specific region. The test includes user interface, language, currency format, date and time format for that specific continent or country having particular language dominance.
Example, In case software developed specific for middle east, language will be Arabic, currency being riyal and dirham for united arab emirates. date format in Saudi Arabia is dd/mm/yyyy.

Test case is set of instructions and steps to be followed to validate particular feature should fulfill requirement specified in software requirement document. test cases can be derived from requirement traceability matrix, which is derived from requirement document.

Test case template should have details common across test case such as test case created by, tested by, tested on, module name tested with their details. Test case template should contain columns as listed and explained below :-
Test case id – unique identification of test case
Requirement Traceability Matrix id – test case scenarios or condition mapped with RTM id. Test
scenario – short description of what should be tested eg. user should able to log in
Pre Requisite – assumption for test to carry out, such as application log in page is already displayed in browser or desktop.
Test steps – steps to follow in order to test the scenario, manually or using scri pt automatically
Test data used – valid test data created specific to the scenario eg. username – admin and password test123 to be used
Expected Result – what is expected from the feature being tested e.g. welcome page with menus of other features should be displayed after user successfully logged in to the application.
Actual Result- what is actual output or result after testing application, this is to be filled in by tester

Status –If there is difference between actual and expected result test will fail, else test will pass
Remarks – In case test fails, bug report details can be mentioned here

Use case describes how person utilizes system or process to achieve his goal. it helps to assess entire process, which part of the process is error prone. Main elements of use case are Actor, System and Goal. Stakeholders, preconditions, and triggers are additional element s of the use case.

main elements of use case are Actor, System and Goal.
Actor in Use case – is an end user, single or group of people, interacting with a process
System is the process required to reach final outcome.
Goal is successful user outcome.

Test scenario is functionality or feature that can be tested. It also provides high level idea of what need to be tested, in order to create scenario we need set of test case s where we can understand features of application and any short comings of application.

positive test cases ensure that using valid data, application performs required output as expected or not. With positive test case, tester decides that feature provided works if provided with valid test data.

Negative test cases are performed to try break the system, by providing invalid data, or following path not proposed, main intension here is to uncover hidden defects, that are otherwise remain in the software.

Behavior driven testing focuses more on user behavior in certain conditions (say how printing a document in case he receives a message for “page area out of margin” =- how will he reacts…, normally) rather than technical functionality of software.

Acceptance testing is final level in software testing, where purpose of test is to anal yze if software features are in compliance with business requirement, and can we deliver to the client, does all features functions as expected, and with the features can we deploy software on production environment

Vulnerability testing are assessment of software and underlined infrastructure, to reveal security loopholes or risks that are critical present in software due to which some loss should be incurred.
Example – some application requires end user’s email address as username as log in credential,registering email can offer a risk of receiving unsolicited mails.

When we test application without worrying or having knowledge about details of implementation, how internal code structure applied to software to achieve required output. it is called black box testing. This type of testing is carried out mainly by testers. Some of the testing techniques for black box testing are Equivalence Partitioning, Boundary Value Analysis, and Cause Effect Testing.

When internal implementation and internal code structure are known to the tester, while testing an application, it is called white box testing. White box testing involves code veri fication for security holes, poorly structured code process path, data flow of inputs in code, conditional loop, testing of statement, object, and functions in each code class. Some of the testing techniques for white box testing are Statement Coverage, Branch Coverage, Decision, Condition, Control flow and Data flow testing.

When tester has partial knowledge of internal working and features of an application. Grey box testing is conducted to find defects due to code structure, improper functionality and missing condition in the feature. Various techniques used in grey box testing are Matrix testing, regression testing, orthogonal array testing, pattern testing.

In Software Development Life Cycle, there are mainly four testing levels –starting from Unit testing, followed by Integration testing, System testing, and finally user Acceptance testing.

When testers testing of various modules that are linked together in order to accomplish features expected to accomplish. Testing modules in combination are called integration tests.
Example – After log in to Amazon portal, user can view his orders history, pending orders, Amazon wallet details, Prime videos streamed from where he can re order already procured item using his wallet balance amount as well as check video or movies already streamed. Integration tests require tester to check log in details of a user, that has placed orders and has purchased from amazon in past, also should be a prime member to avail facility like music, movie and free of charge deliveries.

Top Down Approach of testing is breaking down complex module into smaller portions till it becomes easy for assessment.
Example – Top management forms rules for organization, middle level management and lower level employees has to follow the rules enforced.

Stubs are the called programs that temporarily replace the missing modules, help in testing integration testing, where flow of data is takes place from Top to down approach.

Bottom Up Approach of testing is combining smaller modules which are easy to test, into larger single complex module.
Example – Small group of students assess the situation or problem, find solution to resolve it. The solution is discussed with teachers and then applied to other groups, and on successful outcome, becomes appeal to higher management, who can make it implementation

Test Drivers are calling modules that are temporary replacement of upper level module that are not yet integrated. Drivers fill the gap of absence of modules to verify flow of data to higher level modules.

GUI ie. Graphical User interface, relates to frame or screen displayed to end user as an interface that makes them easier to access an application or software. In case of desktop application, Microsoft office or paint opens up user interface when paint.exe file gets executed, In case of web based application, all the portals that opens index.html page where user can check all general information about the website, and has login and signup links, allowing new user to register and existing user to log in.

Functional testing is test working of web elements; drop down, buttons, check box or radio button, and features of an application. Functional testing is categorized into various types such as unit test, integration tests, GUI tests, localization tests, usability tests, regression tests, system tests.
Example: on clicking print button, a pop menu should display showing existing page and print configuration window, with print button. On clicking on print button, contents such as text, images or spreadsheets on selected page should be sent for printing.

Nonfunctional testing deals with testing parameters other than features of an application, these include performance, reliability, security, integrity, scalability, portability, etc.
Example: In case of desktop software say calculator, how quickly it displays an output, for multiplication of four digit numerals. In web based application, how quickly an image is rendered on the webpage, or if site is available 24×7 or is subjected to frequent maintenance, making it non-available to end users.

Requirement traceability matrix (RTM) is a document that maps test cases with the requirements discussed in software requirement document. RTM is a single document that make sure that all the requirements are mapped and are covered and has test cases corresponding to the requirement.

Defect traceability matrix is a document that maps defects if any with corresponding test cases, this document helps to trace defects, test cases and requirements thereby gives an idea of whether defects have been resolved or not, if resolved and build is received, then test cases selected for regression tests corresponding to this defect and some integration test cases to make sure defect has been
resolved.

Following are few techniques used in test case design :-
i) Equivalence Partitioning
ii) Boundary Value Analysis
iii) Decision Table
iv) State Transition
v) ErrorGuessing

Test Scenario- In order to get a driving license the age of applicant should be between 18 to 49 years.
There will be 3 (three) partition where tester should check possibility

i) If applicant’s age is less than or equal to 17 years – Invalid
ii) If applicant’s age is between 18 to 49 years. – Valid
iii) If applicant’s age is greater than or equal to 50 – Invalid
So there will be 3 possible scenarios where only one valid group of applicant having age is between 18 to 49 years, will get driving license.

Test Scenario- In order to get a driver’s license, the age range should be between 18 to 49 years.
Boundary values to be verified here is
First Boundary value
Minimum age – 1 i.e. 18-1 = 17 years – invalid age
Second Boundary value
Minimum i.e. 18 years, minimum +1 i.e. 19 years, maximum -1 i.e. 48 years, and maximum i.e. 49 years (18, 19, 48, 49) – Valid values for age criteria.
Third Boundary value
Maximum +1 = 50 years – invalid age

Scenario – You want to buy headphone and have budget Rs.1000
You have following buying options
i) Vijay Sales
ii) Reliance Digital
iii) Chroma
iv) Amazon
Based on Answers to the following queries, we will be able to decide
Where should we buy headphone from
Can take trials before purchase
Have EMI options
Accepts Credit Cards
Accepts Cash on Delivery
Do they have return policy
Have Item in your budget?

When tester finds a defect while testing application, he will confirm deviation with expected result, registers defect (bug) in bug management tool like Bugzilla or JIRA. Bug status will be ‘New’, If defect is not agreed by product team or developer, its status will become ‘Rejected’.
When developer agrees with the defect in application, when assigned to developer, bug status will be ‘Open’, If Developer does not agree to the defect; its status will be ‘Deferred’.
‘Open’ bugs when resolved by developer its status becomes ‘Fixed’, once the bugs are fixed and build is retested for regression testing, defect is verified, i f defect is not resolved, bug will be ‘Reopen’, which will be reassigned to the developer for fixing. if defect is resolved and confirmed by tester then Bug status will be ‘Closed’.

Severity of bug is an extreme level of damage like financial loss, company’s reputation and loss of life, due to presence of the bug. Example such as if point of sales machine does not function as expected, and does not dispense bill, thereby customer may not pay the amount for the purchases, in such situation, the defect due to which bills are not displaying amount of purchase, is termed as severe test case, as due to such defect, there will be huge financial loss. Further say, infrared machine that used for removing decay in the teeth malfunction and damages the jaw of patient, it may result into loss of life.
Defect severity are categorized into following levels
Blocker – Due to this defect type, it becomes impossible to further run the application, there for the name – Blocker
Critical – There are some workarounds to accomplish the task, e.g. pdf format of file type is not downloaded, whereas word type is possible.
Major – some error may lead to understanding the title or content by end user, e.g. software display s title and content in English, but does not display some of the title in Arabic language, but display it in English only.
Minor – there are some defects which has very minor impact on functionality of application, e.g. missing space between words, commas are missed in sentences.
Low –These defects does not impact at all, however if fixed it will be aesthetically pleasing, eg. Size of button, form border go out of screen and need to scroll in order to view the content.

Priority gives a need of urgency to fix or resolve the defect, Example can be if a reputed pen manufactures company while printing the pen model or company name will wrong spellings, then such bugs should be fixed on priority basis.
Defect priority are categorized into following levels
Urgent – this must be fixed immediately e.g. payment gateway pages not displaying, or conformance of order processed not sent via email or sms, or transaction records not printed in account details in banking software.
High – this should be resolved in subsequent releases, e.g. presentation or video does not have company logo or has written content, but does not have voice that narrates above content.
Medium – should be fixed based on the level of severity- eg. Error occurring while user updates his mobile number, while communication has options such as his email and mobile.
Low – May or may not be fixed e.g. spelling or grammar mistake in introductory page of portal, as long as meaning is conveyed to the audience.

Quality assurance (QA) is targeted for avoiding defect, whereas quality control (QC) is aimed at identify defect and fix these defects. QA is process focused whereas QC is end product focused. Quality Assurance team usually in manufacturing industry gathers certification related to quality of raw materials used, machineries used in processing the end product and final product. Whereas Quality Control team is software testers inspects by running or analyzing steps followed in products and services to make sure that it is working fine as per expected standards.

Inspection is an observation where a site is expected to perform or follow standards as compliance obligations, whereas audit is a process of checking if obligations are met or not. Inspections are simple, quantitative and help create actions, whereas audits are complex, qualitative and forms recommendations.

It is a analysis to observe deviation between actual performance and expected performance. Basis of assessment is an improvement in actual performance, whether new hardware, or additional storage capacity or memory improvement or line of code that does not consume processing power, but quickly display output.

It is important for test managers to keep an account of test procedures followed, test plan, test methodology, justification of number of test cases required to be conducted manually in order to verify complete feature coverage, and why these manual test case not able to be carried out using script, automatically, and finally after executing said number of tests both manua l and automatically, how many defects have been captured. There are various test management tools that help manager with reports on what is optimum effort put in testing and what is final outcome. These tools have built-in test ware management; test scheduling, test tracking, incident management, and test reporting.

Based on the level of maturity model i.e. implementation of various processes of software life cycle, adherence of procedures even during critical and crisis situation is called test maturity model

Based on Capability Maturity Model (CMM), software development organization’s level are decided. There are five levels
Level 1 – there is an ad hoc testing, chaotic work culture and no adherence to process during time of crisis, they always use new and undocumented repeat process during software life cycle.
Level 2 – The processes are defined and same steps are repeated during each new p roject.
Level 3 – There is standard business process in each of the defined processes followed without any alterations.
Level 4 – The mapping of the processes are managed accordance with agreed upon metrics.
Level 5 – there is regular and frequent process optimization and improvement during process management

There is a measure of process capability calculated using specification limits and standard deviation of the process, which is Cp index. Most companies require Process Cp = 1.33 or greater.

The term used in short is CAPA, stands for Corrective Action Preventive Action.
Corrective Action Preventive Action (CAPA) is a process which
investigates and solves problems,
identifies causes,
takes corrective action and
Prevents recurrence of the root causes.
Example – when we fall sick, we seek medical attention, and health care specialist offer us remedy and relief, but what if we do not get relief or do not recover. We ask for corrective actions and we think of preventive action as well.

Software Testing Life Cycle (STLC) is a sequence of activities performed by testers such as
Requirement & Analysis – Understanding the client’s requirement and what actually requires, How to test the requirements,
Test Planning – what should be tested in an application, How and who will test the application
Test Case Design – test scenarios, mapping with requirement traceability matrix, test case creation, and test data used
Test Environment Setup – what hardware and software need to install or configure to build test environment.
Test Execution – running the application in order to verify features as per test case designed, reporting bugs, track the bugs and regression test till it gets resolved.
Test Closure – Creation of test reports, total bugs pending, critical bugs if any, justification for releasing application to client.

Document approved by customers and project owners that describe, what is expected from the software to perform, how many features and functionality, what is requirement ( what to verify/validate). In short, Software requirement specification document has a purpose for software to be built, description of software to accomplish and requirement in specific required to fulfill using the software.

In order to understand features and their functionality we refer requirement document (SRS). In order to understand overview of data flow, integration between systems, we should refer design document, For understanding documentation on code, algorithms, interfaces and APIs used in software technical documents or process documentation containing UML diagrams, How end user will use the software we can find from user manual, and finally how to install the software can be found from installation guide of the software.

Regression testing is the testing of an application that verifies that there is no adverse effect of the changes made due to defect fix or change request to other areas of application. regression testing involves test cases other than those that are related to defect or change as per client request, but it also tests features that directly or indirectly connected with the feature that was rectified by developer against the defect raised, such as integration tests, test case related to web components and their functions along with those involved directly with defect raised. Regression testing is usually car ried out using automated scripts by selecting test cases and re executing the scripts to run those test cases.
Retesting is a testing to make sure that previously failed test cases due to defect are passed and the defect has been resolved. The test cases involved in retesting focus only on the failed test cases due to the defect or the scenarios or steps followed result in failed functionality. It is better to carry out manual testing in case of retesting to make sure that defect has actually been resolved.

Selection of test cases for regression testing for the build received from release, should based on following scenario priority for testing those test cases that were failed due to defect, on testing if they are passed. All integration tests, boundary value scenarios, testing functionality of components related to defect, end to end tests that involve change request or resolved test cas es after release,
should be considered for regression.

System testing is a test level after unit tests and integration tests in software testing life cycle, where application as a whole is tested end to end for functional as well as non -functional requirements. It is performed after integration testing. Usability, performance, scalability and secu rity testing are involved.
Integration testing is testing of interconnected units and their interfaces, the data flow between these units and to make sure that feature is working as per expected. it is carried out after unit testing.
Various test approach like top down, bottom up or hybrid integration are carried out during testing.

• Test plan document should include following details
• Features to be tested
• Features not to be tested
• Approach like should we test manually, automated scripts, test techniques (white,black or grey box)
• Criteria for Failed tests / pass tests
• What condition for suspending test activities
• Test environment such as hardware, software, network etc.
• Man hours estimated while testing
• specific training required, Risks involved, any assumptions or dependencies

Tests that are carried out while exploring an application, and learning about the business requirements are called exploratory testing. These tests are carried out by manual testers without referring to any test cases or test scripts. Exploratory tests are carried out by experienced Software testers based on their previous testing expertise thereby test cases are designed during test execution. Test steps carried out should be noted In case of any defect found during exploratory testing, as there is no test cases and test steps written to carry out exploratory testing.

Software Peer Review is a detailed examination of low level and high level design documents by one or more individuals working on the project to find and resolve errors or defects in application during early stages of SDLC.
Code Review – review of code by peer developer will ensure that functionality is met with as expected; there are no memory leaks or dead code which is not utilized while coding.
Pair Programming – Is a process where same portion of code is developed by pair of developers individually and then most efficient code is finalized.
Software Management Review – The project head verifies project progress, status of plans and their status, infrastructure allocation to test and develop the application during management review.
Software Audit Reviews is an independent examination of product, process, assessment with compliance to specifications.

Software Testing Metrics is a quantitative measure that helps in estimating progress, quality and well being of software testing efforts. This helps in improving efficiency and effectiveness of software testing processes.

Test entire application – It is virtually impossible to test and verify entire application with each and every scenario. Even one of the seven principles of software testing says, “Exhaustive Testing is Not Possible”.
Relationship with developers: Tester’s responsibility to check for any defects in the software and how to break an application, it becomes tough to keep amicable relations hip with developers
Regression testing: In every build released from developer, tester has to check entire application for end to end functionality every time along with resolved defect and components or units that are integrated that may get affected due to change request or resolved defect.
Testing always under time constraint: All the stack holders keep an eye on how the built has came out, testers has to quickly start testing the build with sanity test, smoke test and regression tests as send their observations as soon as possible.
Which tests to execute first? – Based on available timeline, and complexity of modules, test lead has to distribute testing like user interface or feature testing using script automatically and regression and integration tests manually. Non functional testing using tools like load runner, API testing using Postman or REST assured. Regression tests using selenium and mobile testing using Appium.
Understanding the requirements: There should be a walkthrough and review of software, domain knowledge, how to test features etc. is mandatory for each member of tester.
Decision to stop the testing: Testing manager should explain testers when should testing be stopped, based on what critical bugs should get resolved, any blockers affecting feature pending by developers.

Main objective for using bug tracking tool is to deliver high quality software product by keeping track of defect discovered and track these defects till it gets resolved, Improve Return on Investment (ROI) by reducing cost of development, when quality product is developed, so that it will have more reliable quality product, satisfied customers with long loyalty. Product and Project team can keep a track of detect Issues Earlier and understand defect trends in ongoin g software development.
Better Communication, Teamwork and connectivity amongst stack holders about software quality.

Website usability testing is to measure and understand how web visitor would experience navigating website to verify its features, accomplish their tasks and any pain points in doing so.

Pesticide paradox is a principle wherein same set of test case if executed again and again over interval of time, then these test cases are not capable of identifying any new defects in the system. in order to overcome this effect, the set of test cases are regularly reviewed and revised to make them effective.

V model is a SDLC methodology where software development instead of moving downwards like waterfall model, moves downwards and then back upwards in V shape, starting with requirement analysis, system design, module design, unit testing, integration testing, system testing, user acceptance testing.

Client Server application is distributed on at least two systems, Client and Server where client has visual pages like input forms, validation for valid data before sending requests to server and output pages as response from server. Server has all business logic, database storage where request received from client machines are responded back after processing through logic and database tables, procedures. Client Server applications require LAN connection and Database Drivers so that they are connected whenever request is sent forresponse. SomeExamples areATM machine, Banking software, and Stock Trading etc.
Web application are built in one server with all front end files, back end and processing logic placed on single web server, various technologies such as HTML or ASP with JavaScript or JS libraries are used for front end design, whereas back end storage and processing is done on server in class files and DB procedures and tables. web application are accessed using web browser, hence it require internet in
addition to web application files placed on web server. Examples of web applications are Amazon, Flipkart and Snapdeal online portal, Gmail, Saavn online music streaming services

: In case of White box testing it is mandatory to know internals of software applications, such as structure, program functions, and implementation of how data flows between components. The tests covers white box testing are unit testing and integration testing. These tests are performed by developers, and it is mandatory to know programming and implementation knowledge, the test is based on design document provided by design team. Various testing techniques used in White box testing are Statement Coverage, Branch coverage, decision coverage, path coverage.
Black box testing does not need any understanding about internal structure of application, the tests coveres black box testing are system and acceptance testing, testing is based on requirement document received from product team. Various testing techniques used in Black box testing are Equivalence partitioning, Boundary value analysis, Decision table testing, and Error Guessing.

Authentication is verify logged in user’s genuineness, in real world you were required to show photo identity documents such as Aadhar card, Driving license, PAN card or Passport in order to receive documents addressed to you from courier, know your account ba lance at your bank.
whereas authorization is verifies what module access rights the logged in user has. real life Examples are You are allowed to explore feature of an application based on your trial period, once you become registered user by paying the registration fees, you can access more features of the software.

In addition to functionality and feature testing, we should test browser compatibility, security tests for authentication and authorization rights, latency – how long it takes to load a web page, or request to come back as a response, load testing based on number of users logged in during peak hours, and scalability testing.

The criteria and conditions are specified in exit document that guides us on when testing should be stopped. When most of blockers and critical bugs have been resolved and application has performance in acceptable limits, we can stop testing. This is however based on some risk that have to be undertaken and time limit.

Cookies are small text files that contain web visitor information such as websites explored, pages visited, visitor’s ip address to identify already visited user. There are various types of cookies,
Session cookies – user navigating websites actively, once they leave particular site, session cookie disappears.
Tracking cookies – are used to keep record of multiple visits that was made to same particular web site.
Authentication cookies – whether a a valid registered user has logged in again and if so with what name?

This one is a tricky question; interviewer wants to know firsthand information from you about your weakness in handling difficult or crisis situation. Answering this question like what is your weakness – you need to keep yourself specific and not to lament problem or difficulties or show any kind of annoyance or hatred for particular stack holder or reporting manager, colleague or developer or some process. You can explain situation however, but should end your statement expla ining how you were successful in controlling the situation.

There are a situation where testing a new build is allotted a bare minimum time, or you are given several tasks or projects to look into. In such case, where you cannot able to completely cover all the scenarios of testing, you can focus on main functionality and features released and check if any critical or blocking defect should not be present in an application during regression tests. Usability, functionality, security, performance are few testing that should be carried out either using scripts automatically or test manually.

Software Quality Assurance (SQA) is a set of activities that validates that the software being designed or built, meets desired quality measures and specifications. Test Assurance team has tasks like auditing and training the stack holders about standards for quality that software should satisfy as per user expectations.

A defect report should inform description about the defect.
Which version or build of software release being tested during which defect occurred.
Which is the module name, how to access this module (path), what were the steps carried out What was the functionality affected, how severe you think the defect is.
Name of the tester who discovered the defect, name of the developer to whom defect has been assigned.
Test case affected mapped to requirement specification document ids and number of test cases that may not be tested due to the defect.

Big Bang test type is an integration tests where multiple modules are being tested simultaneously which may get affected due to change request or defect if any. This helps exploring software with end to end functionality and gives tester an idea about features included and
functionality carried out using the software.

Traceability Matrix & Coverage Matrix is a document that is mapped with software requirement documents and test case or scenarios all in single document. The purpose of such document will ensure that the entire requirements have been covered by test cases and there is no feature or functionality that has been left unchecked.

User Acceptance Test (UAT) is a final test by end user or client’s representative before software is handed over to production environment. It is an end to end functionality testing and verify that proposed features have been included in the software. User Acceptance test are essential as end user will test and verify the application, to make sure tha t the developer has incorporated the features and functionality expected by end user in the software. In addition change requests asked for have been properly incorporated by developers.

HotFix is a workaround which can be some sort of configuration change in order to resolve an issue that could occur in running application or server, with minimum downtime.

Entry criteria are written document without referring to which one cannot begin any of the SDLC phases. In order to begin SDLC phase Requirement document and complete flow diagram of the application as well as Test Plan should be ready and available. An exit criterion is the detailed document that decides moving from current phase of SDLC to the next phase. In order to exit SDLC phases test cases should be written and reviewed, test data has been identified and ready to use, scripts for automate the execution of test cases must be ready.

In order to verify email address, the front end tester should consider foll owing criteria:-
Email address may contain alphanumeric characters as initial portion, special character allowed are dot (.), underscore (_), in initial portion, there should only be single @ symbol separating local part and domain.
Domain name may end separating dot (.) with net, org, com and edu as well as country specific characters eg. In for india, ca for canada.

Mistake in company logo on a product, does not impact its functionality or working , as well as buying or selling activities of product, the defect has low severity. But, this defect will impact greatly brand identity and impact how user will interact or may take as duplicate product, hence such defect is of high priority.

A/B testing is comparing two version of same product, for difference in user experience, performance and any changes that are evident during tests. E.g. comparison of features of microsoft’s word 95 and word 97.

When requirements are specific to test cases, such that code can be improved or defect in code can be fixed in order to meet with the requirements, such kind of development is known as test driven development. The test cases are designed around various scenarios to cover the expected requirements.

Based on testing experience, testers design their test cases or scenarios, such method or tests which are exploratory in nature, in order to locate defect in software, are called error guessing.

Mutation testing is white box testing usually conducted in unit testing level, by changing few statements in source code and validate using debugger. Objective of mutation testing is to assess test case quality based on fault-based test strategy that fails mutant code while debugging.

Ad-hoc is an informal test that can be carried out without referring to requirement specification documents for the application being tested. Ad-hoc tests primarily tests negative scenarios.
Exploratory is formal tests are carried out by experienced Software testers based on their previous testing expertise thereby test cases are designed during test execution.
There is no test case or scenario created during exploratory testing.
While exploratory tests, both positive as well as negative tests should be tested thoroughly.

HTTP is short for Hypertext Transfer Protocol, when you enter http:// in your browser, you inform browser to allow connection via http protocol which is TCP (transmission control protocol), in order to send and receive data packets over the web.
HTTPS is short for Hypertext Transfer Protocol Secure, when you enter http:// in your browser, you inform browser to allow connection via http protocol over secured connection encrypted by transport layer security

Retesting is required to verify that the test cases failed in previous release, are passed after the defects are fixed.
Regression is mandatory to verify all relative or dependent modules and integration tests that are intact even after defect is fixed or after change request.
You need to retest the portion of application where defect was fixed. This may be a portion of tests in regression testing. Experience says, it is safe to do regression after retest ing as to make sure that other portions of software are intact and not affected after defect fix.

Web server is an infrastructure that uses hypertext transfer protocol to respond client request s over internet. Its main function is to store, process and deliver web pages requested to web site visitors. In addition web server also supports Simple Mail Transfer Protocol (SMTP) and File Transfer Protocol (FTP) protocols for email, file transfer and storage. Microsoft Internet Information Services (IIS) and Apache Tomcat are some Examples of a web server.

When various systems are internally connected with each other and can access or exc hange information as well as process one system with another system as interface. Real Life Example is ATM machines, if you have account in State Bank of India of any branch and you have SBI debit card. You need to withdraw cash immediately, you have ICICI bank ATM machine near you. You insert SBI debit card in ICICI bank ATM machine, you enter your credential, the system will internally access SBI server and verify your authentication details along with account balance. When you request the amount to be withdrawn, ICICI bank ATM machine will dispense the cash requested for. with amount remaining in your SBI account. Another Example is you can access and use all banking related functionality from different branch of SBI bank across India.

The software build is application compiled and integrated in order to get tested by software testers.
Release is deploying software with new version deployed to the customer, it has additional features that were absent in previous release, and change request requested by customers using previous release.

Production server is a server used to host website contents such as front end pages, css files, javascript files, backend tables, sql files, procedures etc. integrated and deployed so that end users can access them through their website address using browser and internet, or download on their mobile for using the features of application.

Recovery testing is to test how quick the application is recovered after it has gone through system crash or hardware failure. Tester can change interface, protocol, firmware, hardware, and software configurations as close as the actual conditions. Recovery tests after hardware restored will be tested for getting application again coming back and start running as before. The expense and risk to carry out recovery testing may be substantial and prohibitive for smaller startup companies.

The requirement should be feasible, completely explained in requirement specification document. There should be single requirement, easily read and understood by non-technical people, should not contain definitions, reasons for need of requirement. The requirement should not have any guess work or any confusion (e.g. for how long, 50% or more) should not conflict with other requirements, must include same terminology across document, Can be achieved with existing technologies, met within the schedule.

Accessibility testing is a subset of usability testing, is a process of testing an amount of ease of using the application by disabled individuals. Based on the type of disability various tests are carried out on software to check accessibility features designed specifically for disabled either manually or automatically using tools.
The objective of accessibility testing is listed below
To make sure that application or software can be used by a disabled individual with ease,
To verify that the software is in compliance with the laws formed over requirements for accessing
software by disabled individuals.
To make sure that there is no legal action against the software provider in the future.

Screen Readers like JAWS, NVDA, VoiceOver, Window-Eyes, and Digital voice recorders of brands like EVISTR, OLYMPUS WS-852, Zoom, Tascam and SONY can be integrated with software to add accessibility feature for disabled individuals.
To learn more about accessibility testing visit https://www.qafox.com/importance -of-accessibilitytesting-for-disabled/.

Smoke à Sanity à Integration à System à Functional à Retesting à Regression

Installation testing is to verify that the application has been successfully installed on environment as per the steps and order of installation listed in installation guide and is working as user acceptance tests and expected as requirement document. During every build deployed by software testers on test servers installation testing is carried out. The steps written in installation guide for different operating system can be verified and application is run to check that installation is successful

There are various scenarios like additional load of uploaded files for processing, logged in users, time taken to receive response back due to which bug are reproduced at client side (production environment) and not in the test environment.

The steps or scenario carried out to reproduce defect at test environment but the same steps carried out at development server if does not produce defect. It may happen that there can be some files missing at test environment, code changes at development server due to update on build. Tester has to reproduce the defect carefully conducting steps at development server and advice developer to fix the defect.

Migration testing validates migration of application from old system to new system wi th data integrity, no loss of data, and minimal downtime, with functional and non-functional aspects are met post migration. Pre migration, migration and post migration tests are phases of migration test. In addition backward compatibility and rollback tes ts are executed along with.

A CAPTCHA is a type of challenge–response test used in computing to determine whether or not the user is human. e.g. of captcha are sum of two digits, selection of charact ers containing symbols, numerals, and alphabets which are distorted for user to identify and write in text field provided.
Selection of pictures that contain some of the images asked for. The pages where sensitive user information may get revealed CAPTCHA can be installed, They prevent hackers from performing attacks where they try to break into an account by guessing every possible password combination, and they can also prevent fraudulent sweepstakes entries or illegitimate contest votes.

Many websites have changed their privacy policies after the law and the recent developments of user data breaches in the tech industry. This will help make the users understand what data are collected using cookies and what happens to it after they are collected.

Latent Defect is a hidden defect in software still unknown to end user until particular task or operation is not performed by running the application. this type of defect are difficult to identify, pass through all testing, remains hidden even after production, occurs only in certain scenario, can surface after release of the product.

Fault masking is a technique wherein one defect prevents the detection of another. there are many features that may have defects but remain hidden until these feature are utilized. For eg. In case of login page, developer has provided option to log in with email address and mobile number, until user logs in with valid credentials, the defect as below, wherein forgot password when registered mobile number is entered OTP is not received on mobile (unhandled task by developer), remains un noticed. This is known as fault masking.

Latent defect is a failure that is still hidden as the set of condition were never met that can uncover a defect.
Masked defect is a defect that has not yet caused because another defect has prevented the area of code from being executed so that masked defect can be found.
When set of condition or scenario are executed, latent defect will be discovered. Masked defect can be found once the defect preventing to execute area of application is resolved.

Fuzz testing is an automatic test technique where invalid, random and unexpected data is sent as an input that may result into exceptions like crash, memory leaks or fails to build -in code assertions.
Fuzz testing tools for web security testing are Burp Suite, Peach Fuzzer, Spike Proxy.

• Once tester finds a defect in an application, he should complete following steps in order to register the defect.
• Verify and validate the steps followed and try reproducing the defect.
• Repeat the test steps and ensure that the defect occurs repeatedly.
• Attach screenshots, backend server logs and/or database logs,
• Understand the requirement and analyze the deviation from expected output for the scenario.
• Include the scenario or test case in case, the scenario tested is not covered.
• Report the bug in bug tracking system like Bugzilla or JIRA,
• Analyze the defect and rank it based on its severity.

It is essential to work in team environment for software development industries. Team members may face challenges amongst their colleagues while communicating, exchanging their views, mentoring or allocating the work. Team member conflicts are common while delivering tasks in high pressure environment.
To resolve conflict amongst team members as a test lead you should talk individually to each person and note their concerns.
Find a solution to the common problems raised by team members.
Arrange a team meeting, reveal the solution and ask people to co-operate.

Charles Proxy testing is a testing for decrypting web traffic on computers and mobile devices. It is a cross platform HTTP debugging proxy server application that enables user to view HTTP, HTTPS, and enabled TCP port traffic from and to local computer or mobile device. In addition, it also records requests and responses along with HTTP headers and metadata (e.g. cookies, caching and encoding information) during web traffic.

• There can be various mistakes that may create issues in project delivery.
• Assigning incompetent resource to manage the project.
• Lack of resources and skills.
• Doing everything myself approach instead of distribution of work as per resource and their skills Lack.
• of proper communication and failure to pass the message across the stack holders.
• Project initiation or start up is poorly managed.
• uncertain or unclear objective of project and processes.
• Wrong Estimation of time and budget.
• Failure to manage scope described in project.
• Over micro managing of projects like police and enforcing the pressure in order to achieve the tasks.
• Daily or weekly meets amongst team to update and understand the progress. Not following the Processes.
• These are few of the mistakes that may result in delays in project delivery and there by losing the project.

Risk based testing starts with accessing risks related to complexity of logic, business criticality, defect prone areas in application, frequency of use of sensitive computation of application features. This involves priority of testing those areas of an software that involve critical features and functionalities that are likely to fail. Such type of testing involves experienced testers that have understanding of possible risks involved in mission critical applications.
Positive impact of risk based testing are opportunity to learn and improve business sustainability when you test application based on the risks involved negative impact of risk based testing are threat of customer dissatisfaction, impact of overall project cost due to detailed testing, bad or negative user experience, and possible loss of customers.

Decision table testing are used to validate system behavior with different input combinations.
Best Example of such tests can be login to the application where there are two input values, namely username and password and possible output can either be an error with not allowing to enter in application or allowed to enter the welcome page.
scenario 1 – username and password both can be wrong, resulting in error
scenario 2 – username can be correct, but password could be wrong, resulting in error
Scenario 3 – username can be wrong, but password could be right, resulting in error.
Scenario 4 – username and password both can be right and valid, allowing user to the welcome page.

Test scenario can be a description of test objective, tester can accomplish by testing an application in multiple ways to ensure that the scenario has been covered with satisfaction.
Test case is summary of test scenario with steps or procedure to carry out with test data to the application in order to validate that the application behave s as expected, or reproducing the defect by following the steps written in test case, there by validate that the actual result deviate from expected result.
Test script is steps in order to mimic test case to validate applicatio n’s behavior as expected or behaves differently to locate defect.

Defect triage is process of analyzing defect priority based on factors such as severity, risk, and time required to fix /resolve the defect. During defect triage meet, stack holders discuss and decide the priority of fixing the defects.

Software complexity – making developer difficult to understand requirement, or how to design the desiredoutput.
Miscommunication between product team and customer in knowing the exact requirement.
Programming errors during runtime or compile time of code base during integration process.
Timeline pressure that limits unit testing of all possible scenarios on design codes or programs.
Change in requirements by customer that can introduce defect in already running application code.

Error Guessing – It is a test case design technique in which testers have to imagine the defects that might occur and write test cases to represent them.
Error Seeding – It is the process of adding known bugs in a program for tracking the rate of detection & removal. It also helps to estimate the number of faults remaining in the program.

In some situations, reporting failures can be a delicate process. Perhaps a deve loper spent a lot of time on some code which does not exactly meet specifications. QA engineers need to be able to stand up for what they know is right.

The correct Answer is NO. All test cases need to be run, and making assumptions frequently leads to issues down the road, because as a Software quality tester it is your duty to cover all the scenarios for the application for test coverage. It may happen that in case some area of test uncovered may contain error at client side, and you can fall on your face by not testing that area.

The meaning of validation is to confirm if application or system designed is in compliance with the client’s requirements and its feature functions as desired and thereby meets goals and needs of end user. In short it is to verify the software build is right product.

The meaning of verification is to confirm that the designed product delivers and satisfies all the functionalities expected to fulfill as expected by end user. In short it is to test whether the product build is right (functions as expected)?

Software testing activities can be stopped based on following factors – How many Test case execution completed and bugs occurred fixed during the regression testing Based on the Testing deadline decided in test plan by project manager Mean Time between Failures (MTBF) rate if reduced and is within the acceptable rate.
Code Coverage Ratio can be calculated based on various tests like statement coverage, branch coverage etc.

Testing shows presence of defects – testing any software will uncover defects in it Early
Testing is essential and will help to detect defect in the initial stage of development.
Exhaustive testing is not possible – It is not possible to check each and every condition and criteria of application.
Testing is context Dependent – Different domains are tested differently, thus testing is purely based on the context of the domain or application.
Defect clustering – 80% of the problems are found in 20% of the modules.
Pesticide paradox – the set of test cases needs to be regularly reviewed and revised.
Absence of Error is fallacy as it will be impossible to imagine software without a defect.

Defect Density is number of confirmed defects identified in software/module during a development period divided by the size of the software. It is calculated as defect count/size of the release, where size of release is total line of code in release.
e.g. if module1 has 25 bugs, module2 has 15 bugs, and module3 has 50 bugs, total number of code per modules are module1 has 1250 LOC (lines of code), module2 has 2575 LOC , and module3 has 7500 LOC, then Total bugs = 25+15+50 = 90, and size = 1250+2575+7500 = 11325, Defect density will be = 90/11325 = 0.00794 defects/loc = 7.94 defects/Kloc.

Age of Defect is the difference of time from date when defect was detected till the date defect was fixed or a current date if defect is still open (not resolv ed).

The Design software gets stuck or hangs often when enter key have been pressed to review the final draft. This is defect of high priority and high severity and should be resolved and corrected as such product cannot be shipped to client.

If a Company name is misspelled on the home page of web portal, is an Example of high priority to be fixed as it may impact company reputation or may represent as fake product with misspel led company name. However other functionality in the web portal will function perfectly.

A printer printing multiple copies instead of single copy has a high severity as the customer will experience wastage, due to printing task still pending. This can be fixed in next release of the product.

The Example of Low priority and low severity can be Spelling, Grammatical, punctuation marks not properly placed, and such mistakes in product labels.

Interviewer wants to know, how do you react real time scenario when there is a de livery and acceptance testing is on the way, what tests will you take on priority? The Answer to this question will depend on how did you work and perform under pressure environment. The most critical feature that was not working and have been send with a defect, It is mandatory to check if the critical and major bugs have been resolved or not, The regression tests should be carried out and integration tests that validates feature, end to end testing should be carried out. Based on the test results, we can decide to release the build or not.

Native application refers to the development of a mobile application for a single platform only. The application is built using computer programming languages ​​and tools that are explicit to a single platform. For example, you can develop a native Android application using Java or Kotlin and select Swift and Objective-C for iOS applications.
Native mobile apps don’t run in the browser, unlike websites and web applications. You’ll need to download them from specific app stores like the Apple App Store and Google Play. Once installed, you can easily access any application just by tapping its icon on your device screen.

Benefits :
o Native Apps live on the device and are accessed through icons on the device home screen.
o They can take full advantage of all the device features — they can use the camera, the GPS, the accelerometer, the compass, the list of contacts, and so on. They can also incorporate gestures (either standard operatingsystem gestures or new, and app-defined gestures).
o Native apps can use the device’s notification system and can work offline.
o Publishers can make use of push-notifications, alerting users every time a new piece of content is published or when their attention is required.
o Native Apps maintain UI design of each operating system, thus they offer the best user experience. For example, a Native App can have a left-aligned header in Android and a center-aligned header in iOS.
o Redistribution is easy, as it is found in app store.

Disadvantages :
o High cost for building the app : Native apps developed for one platform will not run on another platform. An App built for Android will not run on iOS. We need to build a different App altogether for iOS. Because of this reason, we need to maintain multiple versions of the App.
o Even though you might publish native Apps, you’ll want to keep the mobile website well maintained, as mobile brings more traffic. So maintenance is higher.

A hybrid app is one that is written with the same technology used for websites and mobile web implementations, and that is hosted or runs inside a native container on a mobile device.

Benefits :
o Developing a Hybrid App is cheaper than developing a Native App. It can be built for cross-platforms, i.e., reduced cost for App development.
o Maintenance is simple, as there are not many versions to be maintained.
o It can take advantage of a few features available in the device.
o It can be found in the App Store, which makes the distribution easy.
o It has a browser embedded within the app only.

Disadvantages :
o Graphics are less accustomed with the operating system as compared to Native Apps.
o Hybrid Apps are slower than Native Apps.

Web apps are not real applications; they are actually websites that open in your smartphone with the help of a web browser. Mobile websites have the broadest audience of all the primary types of applications.

Benefits :
o Easy access.
o Easy Development: Developing responsive design and restructuring the content to be properly displayed on a smaller screen/hardware will make any desktop website mobile friendly.
o Easy update: Just update in one location and all the users automatically have access to the latest version of the site.
o No installation required, as compared to native or hybrid app.

Disadvantages :
o Mobile websites cannot use some of the features. For example, access to the file system and local resources isn’t available in websites.
o Many existing websites don’t support offline capabilities.
o Users won’t have the app’s icon on their home screen as a constant reminder. The website needs to be opened in a web browser only.
o While native and hybrid apps appear on the App Store and Google Play, web apps won’t. So redistribution is not that sensible.

By testing on virtual machines, developers and testers can monitor how the software is performing on a specific device. Compared to real device testing, virtual testing mimics real devices and creates a virtual mobile device on a computer. The two types of programs used for virtual testing devices are emulators and simulators. Even though these terms are used interchangeably, each type comes with different capabilities and limitations. 

What are Emulators? 

Emulation is the process of enabling a computer system (the host) to mimic the hardware and software features of another target device (the guest). Emulators are essentially used as “substitutes”, which replaces the original device for real use. 

• Emulator’s Capabilities: The emulator provides virtual device instances with near-native capabilities and extended controls to adjust the target/mobile device’s physical sensors, battery state, geolocation, and more.
• Emulator’s Limitations: In most cases, the near-native capabilities of an emulator include significant performance overhead due to binary translation. For Android apps and website testing, virtual mobile device emulators can be unreliable since they run slower than real Android devices. Because emulators cannot fully mimic real-world conditions, the testing results won’t be accurate for final releases. 

What are Simulators? 

Simulation is the process of modeling an environment to mimic the behavior and configuration of another target device. Compared to emulation, a simulator is used for “analysis and study”. By using a simulator, you create a virtual environment that mimics the target device from the real world. Ultimately, the simulation process shows you how the device would work in the real environment. However, a simulator doesn’t exactly follow the activity of the real environment.

• Simulator’s Capabilities: An iOS simulator sits on top of your operating system and mimics the iOS by running your app inside it. You can view this simulation in an iPhone or iPad window. Machine-language translation isn’t involved, so the iOS simulator is faster than the Android emulator. 
• Simulator’s Limitations: Unfortunately, the iOS simulator can only be used on a macOS platform. This is because the simulator relies on Apple’s native Cocoa API to handle the GUI, runtime, and more. Compared to Android emulators, simulators cannot mimic battery states or cellular interrupts as well. 

Functional Testing :-
Functional testing is the most basic test for any application to ensure that it is working as per the defined requirements.

Compatibility Testing :-
The purpose of a mobile app compatibility test, is to ensure an app’s key functions behave as expected on a specific device, platform and OS version.

Localization Testing :-
Nowadays, most of the apps are designed for global use and it is very important to care about regional trails like languages, time zones, etc.

Laboratory Testing :-
Laboratory testing, usually carried out by network carriers, is done by simulating the complete wireless network. This test is performed to find out any glitches when a mobile application uses voice and/or data connection to perform some functions.

Performance Testing :-
Mobile performance test covers client application performance, server performance, and network performance.

Stress Testing :-
Stress testing is a must to find exceptions, hangs, and deadlocks that may go unnoticed during functional and user interface testing.

Security Testing :-
Vulnerabilities to hacking, authentication, and authorization policies, data security, session management and other security standards should be verified as a part of mobile app security testing. Applications should encrypt user name and passwords when authenticating the user over a network.
One way to test security related scenarios is to route your mobile’s data through a proxy server like OWASP Zed Attack Proxy and look for vulnerabilities.

Memory Leakage Testing :-
Mobile devices have very limited memory as compared to other computers, and mobile operating systems have a default behavior to terminate applications that are using excessive memory and causing a poor user experience.
Memory testing is exceptionally important for mobile applications to ensure that each application maintains optimized memory usage throughout the user journey. It is recommended that we conduct memory testing on the actual target device, since the system architecture is different from an emulator to an actual device.

Power Consumption Testing :-
There are several types of batteries used in different mobile devices (i.e. nickel cadmium/lithium ion/ Nickel metal hybrid). While we focus on power consumption testing, we are required to measure the state of the battery at each activity level. It will give us a better understanding of power consumption by an individual application.
Power Consumption test can be done manually; also there are some free tools available in the market such as Trepn Profiler, Power Tutor, and Nokia Energy Profiler. These are applications which can display the real-time power consumption on a smartphone or tablet.

Interrupt Testing :-
An application, while functioning, may face several interruptions like incoming calls or network coverage outage and recovery. This can again be distinguished for:
 Incoming and Outgoing SMS and MMS
 Incoming and Outgoing calls
 Incoming Notifications
 Battery Removal
 Cable Insertion and Removal for data transfer

Usability Testing :-
Usability testing evaluates the application based on the following three criteria for the target audience:
 Efficiency: The accuracy and completeness with which specified users can achieve specified goals in a particular environment.
 Effectiveness: The resources expended in relation to the accuracy and completeness of goals achieved.
 Satisfaction: The comfort and acceptability of the work system to its users and other people affected by its use.

Installation Testing :-
Installation testing verifies that the installation process goes smoothly without the user having to face any difficulty.

Uninstallation Testing :-
The basics of uninstallation testing can be summarized in one line as “Uninstallation should sweep out data related to the App in just one go”.

Updates Testing :-
We need to be very much cautious about mobile app updates. People frequently complain about applications not working satisfactorily after an update. So it is very important that under the update testing, we qualify that the App will work as it was working previously.
In a nutshell, it should not break anything. Mobile application updates can take place in two ways – Automatic update and Manual update.

API stands for Application Programming Interface. It is a software interface that enables two applications to communicate and exchange data with each other. It is a set of functions that can be executed by another software program.

Let us now understand how an API works. When you use an application on your smartphone, the application connects to the Internet. It sends data to a server. The server will retrieve that data, interpret it, and perform the required actions. Then it sends it back to your phone. The application interprets that data and provides you with the information in a readable way without exposing the internal details.

API is a part of integration testing to check whether the API meets expectations in terms of functionality, reliability, performance, and security of applications.
Unit testing: To test the functionality of individual operation
Functional testing: To test the functionality of broader scenarios by using a block of unit test results tested together
Load testing: To test the functionality and performance under load
Runtime/Error Detection: To monitor an application to identify problems such as exceptions and resource leaks
Security testing: To ensure that the implementation of the API is secure from external threats
UI testing: It is performed as part of end-to-end integration tests to make sure every aspect of the user interface functions as expected
Interoperability and WS Compliance testing: Interoperability and WS Compliance Testing is a type of testing that applies to SOAP APIs. Interoperability between SOAP APIs is checked by ensuring conformance to the Web Services Interoperability profiles. WS-* compliance is tested to ensure standards such as WS-Addressing, WS-Discovery, WS-Federation, WS-Policy, WS-Security, and WS-Trust are properly implemented and utilized
Penetration testing: To find vulnerabilities of an application from attackers
Fuzz testing: To test the API by forcibly input into the system in order to attempt a forced crash

API protocols facilitate a standardized exchange of information. They provide a collection of defined rules that specifies the accepted data types and commands. Below are some of the common protocols used in API testing:

• HTTP
• JSON-RPC
• REST
• SOAP
• JMS
• UDDI
• XML-RPC

Some of the popular API testing tools for 2022 are:

• SoapUI
• PostMan
• Karate DSL
• Rest Assured
• Alertsite API monitoring
• Apigee
• Assertible

1. Test for Core Functionality

API testing allows accessing the application without the UI (User Interface). The core functionality of the application is tested before the GUI tests. It helps in identifying the minor issue which can become bigger during the GUI testing.

2. Time Effective

API Testing does not need GUI to be ready. It can be performed earlier in the development cycle. API testing is less time-consuming than GUI testing. API tests offer test results quickly. They significantly accelerate development workflows. This helps in speeding up the feedback loop and identifying issues faster.

3. Reduced Cost

API testing requires less code and provides better and faster test coverage compare to GUI test automation. You can identify issues at an early stage. It is easier and comparatively inexpensive to fix the issue at the early stages. This reduces the cost of the testing project.

4. Language-Independent

The data in API testing is exchanged data using XML or JSON. These transfer modes are completely language-independent. It means that you can select any core language when using automated testing services for the application.

5. Easy Integration with GUI

API testing allows highly integrable tests. This is useful if you plan to perform functional GUI tests after API testing. For example, simple integration will allow for the creation of new users within the application before the start of a GUI test.

SOAP stands for Simple Object Access Protocol. It is an XML-based protocol for exchanging information between computers. It is a communication protocol for communicating through the Internet. SOAP is platform-independent and language-independent and can be used for broadcasting a message.

REST stands for Representational State Transfer. REST API is an API that conforms to the principles of the REST architectural style. It allows for interaction with RESTful web services. This is why REST APIs are sometimes referred to as RESTful APIs.

It is an architectural style that follows six constraints – Uniform Interface, Client-Server, Layered System, Stateless, Cacheable, Code on Demand. REST is not restricted to XML. It permits different data formats such as Plain text, XML, HTML, and JSON. It requires less bandwidth.

All Web services are APIs but not all APIs are Web services.
Web services might not contain all the specifications and cannot perform all the tasks that APIs would perform.
A Web service uses only three styles of use: SOAP, REST and XML-RPC for communication whereas API may be exposed to in multiple ways.
A Web service always needs a network to operate while APIs don’t need a network for operation.

Test for Core Functionality: API testing provides access to the application without a user interface. The core and code-level of functionalities of the application will be tested and evaluated early before the GUI tests. This will help detect the minor issues which can become bigger during the GUI testing.
Time Effective: API testing usually is less time consuming than functional GUI testing. The web elements in GUI testing must be polled, which makes the testing process slower. Particularly, API test automation requires less code so it can provide better and faster test coverage compared to GUI test automation. These will result in the cost saving for the testing project.
Language-Independent: In API testing, data is exchanged using XML or JSON. These transfer modes are completely language-independent, allowing users to select any code language when adopting automation testing services for the project.
Easy Integration with GUI: API tests enable highly integrable tests, which is particularly useful if you want to perform functional GUI tests after API testing. For instance, simple integration would allow new user accounts to be created within the application before a GUI test started.

• Accuracy of data
• Schema validation
• HTTP status codes
• Data type, validations, order and completeness
• Authorization checks
• Implementation of response timeout
• Error codes in case API returns, and
• Non-functional testing like performance and security testing

API testing is now preferred over GUI testing and is considered as most suitable because:

It verifies all the functional paths of the system under test very effectively.
It provides the most stable interface.
It is easier to maintain and provides fast feedback.

A Web service is a web application that can communicate with other web-based applications over a network.
Web service implementation allows two web applications developed in different languages to interact with each other using a standardized medium like XML, SOAP, HTTP etc.

As web services are based on open standards like XML, HTTP so these are operating system independent.
Likewise, web services are programming language independent, a java application can consume a PHP web service.
Web services can be published over the internet to be consumed by other web applications.
The consumer of web service is loosely coupled with the web service, so the web service can update or change their underlying logic without affecting the consumer.

Client-Server – Client and server are separated by a uniform interface and are not concerned with each other’s internal logic
Stateless – Each client request is independent and contains all the necessary information required to get executed. No client data is saved at the server.
Cacheable – Client should have the ability to cache the responses
Layered System – A layered system having multiple layers wherein each layer communicates with adjacent layer only
Uniform Interface – A uniform interface design requires each component within the service to share a single and uniform architecture
Code on Demand – This constraint is optional. It extends client-side execution of code transfer of executable scripts like javascript from the server.

REST architecture treats any content as a resource, which can be either text files, HTML pages, images, videos or dynamic business information.
REST Server gives access to resources and modifies them, where each resource is identified by URIs/ global IDs.

REST uses different representations to define a resource like text, JSON, and XML. XML and JSON are the most popular representations of resources.

RESTful web services use the HTTP protocol as a medium of communication between the client and the server.

RESTful web services use the HTTP protocol as a communication tool between the client and the server. The technique that when the client sends a message in the form of an HTTP Request, the server sends back the HTTP reply is called Messaging. These messages comprise message data and metadata, that is, information on the message itself.

An HTTP request contains five key elements:

An action showing HTTP methods like GET, PUT, POST, DELETE.
Uniform Resource Identifier (URI), which is the identifier for the resource on the server.
HTTP Version, which indicates HTTP version, for example-HTTP v1.1.
Request Header, which carries metadata (as key-value pairs) for the HTTP Request message. Metadata could be a client (or browser) type, format supported by the client, format of a message body format, cache settings, and so on.
Request Body, which indicates the message content or resource representation.

GET is only used to request data from a specified resource. Get requests can be cached and bookmarked. It remains in the browser history and haS length restrictions. GET requests should never be used when dealing with sensitive data.
POST is used to send data to a server to create/update a resource. POST requests are never cached and bookmarked and do not remain in the browser history.
PUT replaces all current representations of the target resource with the request payload.
DELETE removes the specified resource.
OPTIONS is used to describe the communication options for the target resource.
HEAD asks for a response identical to that of a GET request, but without the response body.

PUT and POST operation are quite similar, except the terms of the result generated by them.

PUT operation is idempotent, so you can cache the response while the responses to POST operation are not cacheable, and if you retry the request N times, you will end up having N resources with N different URIs created on server.

GET /device-management/devices : Get all devices
POST /device-management/devices : Create a new device

GET /device-management/devices/{id} : Get the device information identified by “id”
PUT /device-management/devices/{id} : Update the device information identified by “id”
DELETE /device-management/devices/{id} : Delete device by “id”

The OPTIONS Method lists down all the operations of a web service supports. It creates read-only requests to the server.

URI stands for Uniform Resource Identifier. It is a string of characters designed for unambiguous identification of resources and extensibility via the URI scheme.

The purpose of a URI is to locate a resource(s) on the server hosting of the web service.

A URI’s format is :////.

The “payload” is the data you are interested in transporting. This is differentiated from the things that wrap the data for transport like the HTTP/S Request/Response headers, authentication, etc.

appends data to the service URL. But, its size shouldn’t exceed the maximum URL length. However, doesn’t have any such limit.

So, theoretically, a user can pass unlimited data as the payload to POST method. But, if we consider a real use case, then sending POST with large payload will consume more bandwidth. It’ll take more time and present performance challenges to your server. Hence, a user should take action accordingly.

Caching is just the practice of storing data in temporarily and retrieving data from a high-performance store (usually memory) either explicitly or implicitly.

When a caching mechanism is in place, it helps improve delivery speed by storing a copy of the asset you requested and later accessing the cached copy instead of the original.

Use the SOAP API to create, retrieve, update or delete records, like accounts, leads, and user-defined objects. With more than 20 different calls, you can also use the SOAP API to manage passwords, perform searches, etc. by using the SOAP API in any language that supports web services.

When using SOAP, users often see the firewall security mechanism as the biggest obstacle. This block all the ports leaving few like HTTP port 80 and the HTTP port used by SOAP that bypasses the firewall. The technical complaint against SOAP is that it mixes the specification for message transport with the specification for message structure.

It is a common XML document that contains the elements as a SOAP message

Envelope: It is an obligatory root element that translates the XML document and defines the beginning and end of the message.

Header: It is an optional item which contains information about the message being sent.

Body: It contains the XML data comprising the message being sent.

Fault: It provides the information on errors that occurred while during message processing.

• SOAP is both platform and language independent.
• SOAP separates the encoding and communications protocol from the runtime environment.
• Web service can retrieve or receive a SOAP user data from a remote service, and the source’s platform information is completely independent of each other.
• Everything can generate XML, from Perl scripts through C++ code to J2EE app servers.
• It uses XML to send and receive messages.
• It uses standard internet HTTP protocol.
• SOAP runs over HTTP; it eliminates firewall problems. When protocol HTTP is used as the protocol binding, an RPC call will be automatically assigned to an HTTP request, and the RPC response will be assigned to an HTTP reply.
• Compared to RMI, CORBA and DCOM, SOAP is very easy to use.
• SOAP acts as a protocol to move information in a distributed and decentralized environment.
• SOAP is independent of the transport protocol and can be used to coordinate different protocols.

• SOAP is typically significantly slower than other types of middleware standards, including CORBA, because SOAP uses a detailed XML format. A complete understanding of the performance limitations before building applications around SOAP is hence required.
• SOAP is usually limited to pooling and not to event notifications when HTTP is used for the transport. In addition, only one client can use the services of one server in typical situations.
• If HTTP is used as the transport protocol, firewall latency usually occurs since the firewall analyzes the HTTP transport. This is because HTTP is also leveraged for Web browsing, and so many firewalls do not understand the difference between using HTTP within a web browser and using HTTP within SOAP.
• SOAP has different support levels, depending on the supported programming language. For instance, SOAP supported in Python and PHP is not as powerful as it is in Java and .NET

Postman is a free HTTP client-based software application and a collaboration platform for API development. It is mainly used to perform API testing. It is a very popular API client which facilitates developers and provides a platform to design, build, share, test, and document APIs. Postman supports testing of HTTP requests by utilizing GUI (Graphical User Interface), which later we can execute and validate the responses.

The Postman tool also facilitates us to send HTTP/s requests to a service and get their responses. We can ensure that the service is up and running by using this.

• It is free: Postman is free software that we can use for API testing. It is free to download and use for teams of any size.
• It is easy to use: Postman is an easy-to-use software tool. We can send HTTP requests of various types (such as GET, POST, PUT, PATCH, etc.). We have to download it, and we can send our first request in minutes. It also gives us the ability to save environments for future use.
• Community & Support: It has a huge community forum for customer support and extensive documentation.
• It is extensible: Postman facilitates us customizing it according to our needs with the Postman API.
• APIs Support: It facilitates us to make any API call (REST, SOAP, or plain HTTP) and easily inspect even the largest responses. It also helps manage the end-to-end lifecycle of the API – starting from design to mocking to testing and finally maintaining the APIs.
• Runtime Services: Postman provides Runtime Services that help us manage API collections, environments, work-spaces, and different examples.
• Integration: Postman facilitates us to easily integrate test suites into our preferred CI/CD tools and services, such as Jenkins with Newman (command-line collection runner).

• API Key
• Oauth 1.0
• Oauth 2.0
• Bearer Token
• Basic auth
• Digest auth
• Hawk Authentication
• AWS Signature
• NTLM Authentication

In Postman, a collection is used to group similar requests. It systematically arranges the requests into folders.

• Status/Response Code – These are response codes issued by a server to a client’s request. For example, 404 means Page Not Found, and 200 means Response is OK.
• HTTP Version – describes HTTP version, for example-HTTP v1.1.
• Response Header – Includes information for the HTTP response message. For example, Content-type, Content-length, date, status and server type.
• Response Body – It contains the data that was requested by a client to server.

• GET
• POST
• PUT
• PATCH
• COPY
• DELETE
• HEAD
• OPTIONS
• LINK
• UNLINK
• PURGE
• LOCK
• UNLOCK
• PROPFIND
• VIEW

HTTP methods: It is a set of request methods used to perform needed action for a given resource (GET, PUT, POST, and DELETE).
Uniform Resource Identifier (URI): It is a kind of address that describes the resource.
HTTP Version: It specifies the version of the HTTP. For example HTTP v1.1
Request Headers: It specifies the content type and content length of the request. For example: Content-type: application/ JSON, Content-Length: 511
Payload: It is used to specify the Request Body that includes message content.

Postman accepts authorization credentials in Base64 encoding only. This is inbuilt in Postman, or else you can refer to a third-party website to convert the credentials in base64. The Base64 authorization credentials are generally used because they transmit the data into a textual form and send it in an easier form, such as HTML form data.

In Postman, the term environment is a set of key-value pairs. You can create multiple environments in Postman and switch among them quickly by pressing a button. There are 2 types of environment, global and local.

In Postman, if 2 variables have the same name (one being local, the other global), then the higher priority is of the local variable. The local variable will overwrite the global variable.

We can log the variable values in the console by using the following command:

console.log(pm.variables.get(“variable_name”));  

The Postman monitor is used for running collections. Collections run till the specified time defined by the users. It requires the users to be logged in, and the users share the Monitor reports over an email on a daily or monthly basis.

A workspace is a collaborative environment for users to develop and test APIs. In the same way, a team workspace is a workspace that is shared by the whole team working on the same collections of requests. Usually, it is time-consuming and hard to share the collections through external drives or other sharing; the team workspace synchronizes and collaborates all the team’s work in one place.

Query Params or Query Parameters are used for sorting or filtering the resources. On the other hand, Path Variables are used for identifying specific resources.
Path params are part of the url where as query parameters are added after the ? mark symbol and separated from other query parameters by & symbol.

PathParam example
GET http://base-url/students/{roll-number}

QueryParam example
GET http://base-url/students?grade=10

The Postman Collection runner is used to perform Data-driven testing. It runs a group of API requests for multiple iterations with different data sets.

In Postman, Basic Auth is an authorization technique provided for HTTP user agents like web browsers to enter username and password. After entering the username and password, it gets associated with the request.

Yes, we can import local variables in Postman Monitors, but it is not allowed to import global variables in Postman Monitors.

• Postman cannot process 1000+ API requests.
• In the case of huge projects, it isn’t easy to manage the collections and requests.
• Postman is not suitable for managing the workspace in the form of code. This is because there would be a lot of code duplication for dynamic API requests.

In POST methods, the binary form is designed to send data easily in a format it is impossible to enter data manually. This is mainly used when sending large files like images, CSV files, etc., in the POST request. The binary representation is one of the easiest representations used for sending complex data with the request.

The Postman cloud is a common repository of companies to access Postman collections. That is why we use it when we are working in a company. We can save the work instantly in the Postman cloud after logging in. It facilitates the team members to access data/collections from anywhere.

The digest auth or digest authorization is one of the authorization techniques provided by Postman. This technique lets the clients send the request first to the API and get responses from the server, including a number that can be used only once a real value and 401 unauthorized responses. After that, the client can send back an encrypted data array with both username and password and the data received from the server earlier. Now, the server uses this data to generate an encrypted data string and compares this with what was sent for authenticating the request.

The status code 201 means created when you have successfully created a resource using POST or PUT request. It returns a link to a newly created resource using the location header.

The status code 304 means NOT MODIFIED. It is used to minimize the network bandwidth usage in conditional GET requests. The response body should be empty. Headers should have a date, and location, etc.

In Postman, the 301 status code is used to specify that the page has been permanently redirected from one website page to another. It tells the search engine that the old page is outdated, and the search engine has to index the new page URL.

Global Variables: Global variables allow data access between different collections, requests, and scripts. They are available throughout the workspace.
Local Variables: Local variables are the temporary variables that can be accessed only within the scope of requests scripts. Depending on the requirements, these variables are either scoped to a single request or single collection. These variables are not available once the script execution is completed.
Environment Variables: The Environment variables allow us to tailor the requests about different development environments such as local testing, stage testing, or prod testing.
Collection Variables: The Collection variables are independent of the environment and scoped to be available for all the requests present within the collection.
Data Variables: The Data variables come from external JSON or CSV files and define the datasets required to run the collection in Collection Runner or Newman

We can use the different forms of data content types as defined by the W3C committee. They’ve defined multiple formats for sending the data over the Network Layer. These include form-data, x-www-form-urlencoded, and raw data. By default, we can send data in simple text/ASCII format by using the x-www-form-urlencoded format.

However, using the x-www-form-urlencoded data type has a data limit. As such, we can use form-data for sending large binary or non-ASCII text to the server.

The raw data type sends any plain text or JSON to the server, as the name suggests. It supports multiple content types, and Postman will send the raw data without any modifications, unlike with the other data types.

We can use the raw data type to send any type of data in the request body. This also includes sending the Javascript functions that could be executed on the server side. We can send the scripts under the Javascript option. The raw data type also supports markup languages, such as HTML and XML. This can be helpful when there’s no logic at the front end and we need to consume the whole HTML/XML page.

Yes, it is possible to reuse the authentication token for multiple requests. We can achieve it by creating a collection and adding all the requests having the same authentication token to that collection and then assigning the auth token to the same collection. We can apply it to the individual requests by selecting the “Inherit auth from parent” option in the Authorization tab.

The pre-request scripts at the compilation level are executed first in a collection run.

We can access a Postman variable by entering the variable name as {{var}}.

We can use the Newman tool to run Postman collections in Jenkins.

200 (OK): Status code 200 specifies that the request was correct.
201 (Created): Status code 201 specifies that the value wrapped with the request has been created in the database. Here, it is obvious that the request was correct.
204 (No Content): Status code 204 specifies that the request was correct and received, but there is no content to send. It means there is no response to send to the client by the server.
400 (Bad Request): Status code 400 specifies a bad request. A bad request means that the syntax of the request was incorrect. It appears when we have sent the wrong parameters along with the request URL or in the request’s body.
401 (Unauthorized request): Status code 401 specifies an unauthorized request. An unauthorized request is a request for which you are not authorized. This status code appears when we are not authorized to access the server or enter the wrong credentials.
404 (Not Found): Status code 404 specifies that the server was connected, but it could not find what was requested. It simply means “request not found”. This status code normally appears when we request a web page not available on the server.

Postman provides a space known as Scratch Pad. The Scratch Pad facilitates us to work without being connected to Postman servers and also provides the flexibility to utilize some of the features of Postman offline. These features include collection creation, creating requests, and the ability to send requests. The Scratch Pads are stored locally, and once logged in; the work is saved into the workspace.

We can iterate a request 100 times in Postman using Collection Runner.

Some examples of the JS libraries available in Postman are Lodash, Moment, GUID, etc.

GUID is an acronym that stands for Global Unique Identifier. It is a set of hexadecimal digits separated by hyphens and solves the purpose of uniqueness.

In Postman, it is used to generate and send a random value to APIs.

Example:

{
“id”: “{{$guid}}”,
}

const customerId = Math.floor((Math.random() * 100 + 1));
pm.globals.set(“customerId”, customerId);

Java Runtime Environment contains Java Virtual machine, libraries and other components to run applets and applications written in Java.
JVM + libraries+other components= JRE

Java virtual machine helps run java bytecodes. when .java file are compiled using javac compiler into .class file. These .class file contain bytecode understood by Java virtual machine.

Java Development Kit (JDK) contains JRE and compile rs and debuggers for developing applets and applications.

JVM help run java byte codes created by compiling .java files into .class files.
JRE contains JVM (Java Virtual Machine), libraries and other components t o run Java applets and applications.
JDK contains JRE, compilers and debugger (development environment for applications using Java programming language).

(Java Runtime Environment) JRE contains Java Virtual Machine (JVM) + Java packages (util, math, lang, awt, etc) + runtime libraries You need to install JRE on your machine in order to run Java applications or applets.
Java compiler Javac converts .java file into .class files which contain bytecode, (Java Virtual Machine) JVM converts bytecode into machine language. JVM is platform dependent, there are different JVM for different OS, Bytecode converted into machine language for particular machine, executes depending on its kernel. Without JVM you cannot run Java Applications.

Both compilers and interpreters are used to convert program written in high level language into machine code understood by computers.
Interpreter converts program one statement at a time, takes less time in analyzing source code, slower than compiler, there is no intermediate object formed, hence memory efficient.
Compilers scans entire program and then converts it as a whole into machine language, takes more time analyzing source code, however it is faster than interpreter, generates intermediate object code hence takes more memory.
Programming languages like JavaScript, Python and Ruby use interpreters.
Programming languages like C, C++ and Java use compilers.

Java doesn’t support multiple inheritance in classes because of “Diamond Problem”.
However multiple inheritance is supported in interfaces. An interface can extend multiple interfaces because they just declare the methods and implementation will be present in the implementing class. So there is no issue of diamond problem with interfaces.

Java is not said to be pure object oriented because it support primitive types such as int, byte, short, long etc. I believe it brings simplicity to the language while writing our code.
Obviously java could have wrapper objects for the primitive types but just for the representation, they would not have provided any benefit.
As we know, for all the primitive types we have wrapper classes such as Integer, Long etc that provides some additional methods.

PATH is an environment variable used by operating system to locate the executables. That’s why when we install Java or want any executable to be found by OS, we need to add the directory location in the PATH variable.
Classpath is specific to java and used by java executables to locate class files. We can provide the classpath location while running java application and it can be a directory, ZIP files, JAR files etc.

main() method is the entry point of any standalone java application. The syntax of main method is public static void main(String args[]).
main method is public and static so that java can access it without initializing the class. The input parameter is an array of String through which we can pass runtime arguments to the java program.

When we have more than one method with same name in a single class but the argument are different, then it is called as method overloading.
Overriding concept comes in picture with inheritance when we have two methods with same signature, one in parent class and another in child class. We can use @Override annotation in the child class overridden method to make sure if parent class method is changed, so as child class.

Yes, we can have multiple methods with name “main” in a single class. However if we run the class, java runtime environment will look for main method with syntax as public static void main(String args[]).

We can’t have more than one public class in a single java source file. A single source file can have multiple classes that are not public.

Java package is the mechanism to organize the java classes by grouping them. The grouping logic can be based on functionality or modules based. A java class fully classified name contains package and class name. For example, java.lang.Object is the fully classified
name of Object class that is part of java.lang package.
java.lang package is imported by default and we don’t need to import any class from this package explicitly.

Java provides access control through public, private and protected access modifier keywords. When none of these are used, it’s called default access modifier.
A java class can only have public or default access modifier.

final keyword is used with Class to make sure no other class can extend it, for example String class is final and we can’t extend it.
We can use final keyword with methods to make sure child classes can’t override it.
final keyword can be used with variables to make sure that it can be assigned only once.
However the state of the variable can be changed, for example we can assign a final variable to an object only once but the object variables can change later on.
Java interface variables are by default final and static.

static keyword can be used with class level variables to make it global i.e all the objects will share the same variable.
static keyword can be used with methods also. A static method can access only static variables of class and invoke only static methods of the class.

finally block is used with try-catch to put the code that you want to get executed always, even if any exception is thrown by the try-catch block. finally block is mostly used to release resources created in the try block.
finalize() is a special method in Object class that we can override in our classes. This method get’s called by garbage collector when the object is getting garbage collected. This method is usually overridden to release system resources when object is garbage collected.

We can’t declare a top-level class as static however an inner class can be declared as static.
If inner class is declared as static, it’s called static nested class. Static nested class is same as any other top-level class and is nested for only packaging convenience.

If we have to use any static variable or method from other class, usually we import the class and then use the method/variable with class name.
import java.lang.Math;
//inside class
double test = Math.PI * 5;
We can do the same thing by importing the static method or variable only and then use it in the class as if it belongs to it.
import static java.lang.Math.PI;
//no need to refer class now
double test = PI * 5;
Use of static import can cause confusion, so it’s better to avoid it. Overuse of static import can make your program unreadable and unmaintainable.

Java 7 one of the improvement was multi-catch block where we can catch multiple exceptions in a single catch block. This makes are code shorter and cleaner when every catch block has similar code.
If a catch block handles multiple exception, you can separate them using a pipe (|) and in this case exception parameter (ex) is final, so you can’t change it

Java static block is the group of statements that gets executed when the class is loaded into memory by Java ClassLoader. It is used to initialize static variables of the class. Mostly it’s used to create static resources when class is loaded.

Interfaces are core part of java programming language and used a lot not only in JDK but also java design patterns, most of the frameworks and tools. Interfaces provide a way to achieve abstraction in java and used to define the contract for the subclasses to implement.
Interfaces are good for starting point to define Type and create top level hierarchy in our code. Since a java class can implements multiple interfaces, it’s better to use interfaces as super class in most of the cases.

Abstract classes are used in java to create a class with some default method implementation for subclasses. An abstract class can have abstract method without body and it can have methods with implementation also.
abstract keyword is used to create an abstract class. Abstract classes can’t be instantiated and mostly used to provide base for sub-classes to extend and implement the abstract methods and override or use the implemented methods in abstract class.

• abstract keyword is used to create abstract class whereas interface is the keyword for interfaces.
• Abstract classes can have method implementations whereas interfaces can’t.
• A class can extend only one abstract class but it can implement multiple interfaces.
• We can run abstract class if it has main() method whereas we can’t run an interface.

Interfaces don’t implement another interface, they extend it. Since interfaces can’t have method implementations, there is no issue of diamond problem. That’s why we have multiple inheritance in interfaces i.e an interface can extend multiple interfaces.

A marker interface is an empty interface without any method but used to force some functionality in implementing classes by Java. Some of the well known marker interfaces are Serializable and Cloneable.

Enum was introduced in Java 1.5 as a new type whose fields consists of fixed set of constants. For example, in Java we can create Direction as enum with fixed fields as EAST, WEST, NORTH, SOUTH.
enum is the keyword to create an enum type and similar to class. Enum constants are implicitly static and final.

Java Annotations provide information about the code and they have no direct effect on the code they annotate. Annotations are introduced in Java 5. Annotation is metadata about the program embedded in the program itself. It can be parsed by the annotation parsing tool or
by compiler. We can also specify annotation availability to either compile time only or till runtime also. Java Built-in annotations are @Override, @Deprecated and @SuppressWarnings.

Java ternary operator is the only conditional operator that takes three operands. It’s a one liner replacement for if-then-else statement and used a lot in java programming. We can use ternary operator if-else conditions or even switch conditions using nested ternary operators.

super keyword can be used to access super class method when you have overridden the method in the child class.
We can use super keyword to invoke super class constructor in child class constructor but in this case it should be the first statement in the constructor method.

We can use break statement to terminate for, while, or do-while loop. We can use break statement in switch statement to exit the switch case. You can see the example of break statement at java break. We can use break with label to terminate the nested loops.
The continue statement skips the current iteration of a for, while or do-while loop. We can use continue statement with label to skip the current iteration of outermost loop

this keyword provides reference to the current object and it’s mostly used to make sure that object variables are used, not the local variables having same name.

classTest

{

    inta;

    intb;

    // Parameterized constructor

    Test(inta, intb)

    {

        this.a = a;

        this.b = b;

    }

    voiddisplay()

    {

        //Displaying value of variables a and b

        System.out.println("a = "+ a + "  b = "+ b);

    }

    publicstaticvoidmain(String[] args)

    {

        Test object = newTest(10, 20);

        object.display();

    }

}

No argument constructor of a class is known as default constructor. When we don’t define any constructor for the class, java compiler automatically creates the default no-args constructor for the class. If there are other constructors defined, then compiler won’t create
default constructor for us.

Yes, we can have try-finally statement and hence avoiding catch block.

Garbage Collection is the process of looking at heap memory, identifying which objects are in use and which are not, and deleting the unused objects. In Java, process of deallocating memory is handled automatically by the garbage collector.
We can run the garbage collector with code Runtime.getRuntime().gc() or use utility method System.gc().

Java System Class is one of the core classes. One of the easiest way to log information for debugging is System.out.print() method.
System class is final so that we can’t subclass and override it’s behavior through inheritance. System class doesn’t provide any public constructors, so we can’t instantiate this class and that’s why all of it’s methods are static.
Some of the utility methods of System class are for array copy, get current time, reading environment variables.

• Pass by value: The method parameter values are copied to another variable and then the copied object is passed to the method. The method uses the copy.
• Pass by reference: An alias or reference to the actual parameter is passed to the method. The method accesses the actual parameter.

Often, the confusion around these terms is a result of the concept of the object reference in Java. Technically, Java is always pass by value, because even though a variable might hold a reference to an object, that object reference is a value that represents the object’s location in memory. Object references are therefore passed by value.

Both reference data types and primitive data types are passed by value. 

Heap memory is used by all the parts of the application whereas stack memory is used only by one thread of execution.
 Whenever an object is created, it’s always stored in the Heap space and stack memory contains the reference to it.

Stack memory only contains local primitive variables and reference variables to objects in heap space.
 Memory management in stack is done in LIFO manner whereas it’s more complex in Heap memory because it’s used globally.

String is a Class in java and defined in java.lang package. It’s not a primitive data type like int and long. String class represents character Strings. String is used in almost all the Java applications and there are some interesting facts we should know about String. String is
immutable and final in Java and JVM uses String Pool to store all the String objects.
Some other interesting things about String is the way we can instantiate a String object using double quotes and overloading of “+” operator for concatenation.

We can create String object using new operator like any normal java class or we can use double quotes to create a String object. There are several constructors available in String class to get String from char array, byte array, StringBuffer and StringBuilder.
String str = new String(“abc”);
String str1 = “abc”;
When we create a String using double quotes, JVM looks in the String pool to find if any other String is stored with same value. If found, it just returns the reference to that String object else it creates a new String object with given value and stores it in the String pool.
When we use new operator, JVM creates the String object but don’t store it into the String Pool. We can use intern() method to store the String object into String pool or return the reference if there is already a String with equal value present in the pool.

A String is said to be Palindrome if its value is same when reversed. For example “aba” is a Palindrome String.
String class doesn’t provide any method to reverse the String but StringBuffer and StringBuilder class has reverse method that we can use to check if String is palindrome or not.
private static boolean isPalindrome(String str) {
if (str == null)
return false;
StringBuilder strBuilder = new StringBuilder(str);
strBuilder.reverse();
return strBuilder.toString().equals(str);
}

We can use replaceAll method to replace all the occurance of a String with another String. The important point to note is that it accepts String as argument, so we will use Character class to create String and use it to replace all the characters with empty String.
private static String removeChar(String str, char c) {
if (str == null)
return null;
return str.replaceAll(Character.toString(c), “”);
}

We can use String class toUpperCase and toLowerCase methods to get the String in all upper case or lower case. These methods have a variant that accepts Locale argument and use that locale rules to convert String to upper or lower case.

Below are 5 ways to compare two Strings in Java:

1. Using user-defined function : Define a function to compare values with following conditions :
   • if (string1 > string2) it returns a positive value.
   • if both the strings are equal lexicographically
     i.e.(string1 == string2) it returns 0.
   • if (string1 < string2) it returns a negative value.
2. Using String.equals()
   • str1.equals(str2);
3. Using String.equalsIgnoreCase()
   • str2.equalsIgnoreCase(str1);
4. Using Objects.equals() : Objects.equals(Object a, Object b)
   • Objects.equals(string1, string2);
5. Using String.compareTo()
   • int str1.compareTo(String str2);

This is a tricky question because String is a sequence of characters, so we can’t convert it to a single character. We can use use charAt method to get the character at given index or we can use toCharArray() method to convert String to character array.

import java.util.Arrays;

public class StringChar {

public static void main(String[] args) {
    String st = "This is great";

    char[] chars = st.toCharArray();
    System.out.println(Arrays.toString(chars));
}

}

Output

[T, h, i, s, , i, s, , g, r, e, a, t]

We can use String getBytes() method to convert String to byte array and we can use String constructor new String(byte[] arr) to convert byte array to String.

package com.javaprogramto.arrays.bytearray;

public class StrintToByteArrayExample {

public static void main(String[] args) {

    // creating string
    String string = "javaprogrmto.com";

    // string to byte array
    byte[] array1 = string.getBytes();

    // printing byte array
    for (int i = 0; i < array1.length; i++) {
        System.out.print(" " + array1[i]);
    }
}

}

Output:

106 97 118 97 112 114 111 103 114 109 116 111 46 99 111 109

This is a tricky question used to check your knowledge of current Java developments. Java 7 extended the capability of switch case to use Strings also, earlier java versions doesn’t support this.
If you are implementing conditional flow for Strings, you can use if-else conditions and you can use switch case if you are using Java 7 or higher versions.

public class Demo {
public static void main(String[] args) {
String department = “AKD05”;
switch(department) {
case “AKD01”:
System.out.println(“Finance”);
break;
case “AKD02”:
System.out.println(“Sales”);
break;
case “AKD03”:
System.out.println(“Production”);
break;
case “AKD04”:
System.out.println(“Marketing”);
break;
case “AKD05”:
System.out.println(“Operations”);
break;
default:
System.out.println(“None!”);
}
}
}

Output

Operations

// Java program to print all the permutations
// of the given string
public class GFG {

// Function to print all the permutations of str
static void printPermutn(String str, String ans)
{

    // If string is empty
    if (str.length() == 0) {
        System.out.print(ans + " ");
        return;
    }

    for (int i = 0; i < str.length(); i++) {

        // ith character of str
        char ch = str.charAt(i);

        // Rest of the string after excluding
        // the ith character
        String ros = str.substring(0, i) +
                    str.substring(i + 1);

        // Recursive call
        printPermutn(ros, ans + ch);
    }
}

// Driver code
public static void main(String[] args)
{
    String s = "abb";
    printPermutn(s, "");
}

}

Output

abb abb bab bba bab bba

// program to check if the string is palindrome or not

function checkPalindrome(string) {

    // find the length of a string
    const len = string.length;

    // loop through half of the string
    for (let i = 0; i < len / 2; i++) {

        // check if first and last string are same
        if (string[i] !== string[len - 1 - i]) {
            return 'It is not a palindrome';
        }
    }
    return 'It is a palindrome';
}

// take input
const string = prompt('Enter a string: ');

// call the function
const value = checkPalindrome(string);

console.log(value);

anana
radar

Output

String is immutable and final in java, so whenever we do String manipulation, it creates a new String. String manipulations are resource consuming, so java provides two utility classes for String manipulations – StringBuffer and StringBuilder.
StringBuffer and StringBuilder are mutable classes. StringBuffer operations are threadsafe and synchronized where StringBuilder operations are not thread-safe. So when multiple threads are working on same String, we should use StringBuffer but in single threaded environment we should use StringBuilder.
StringBuilder performance is fast than StringBuffer because of no overhead of synchronization.

• There are several benefits of String because it’s immutable and final. String Pool is possible because String is immutable in java.
• It increases security because any hacker can’t change its value and it’s used for storing sensitive information such as database username, password etc.
• Since String is immutable, it’s safe to use in multi-threading and we don’t need any synchronization.
• Strings are used in java classloader and immutability provides security that correct class is getting loaded by Classloader.

// Java program to demonstrate working of split(regex, limit) with small limit.

publicclassGFG {

    // Main driver method

    publicstaticvoidmain(String args[])

    {

        // Custom input string

        String str = "geekss@for@geekss";

        String[] arrOfStr = str.split("@", 2);

        for(String a : arrOfStr)

            System.out.println(a);

    }

}

String is immutable in java and stored in String pool. Once it’s created it stays in the pool until unless garbage collected, so even though we are done with password it’s available in memory for longer duration and there is no way to avoid it. It’s a security risk because anyone having access to memory dump can find the password as clear text.
If we use char array to store password, we can set it to blank once we are done with it. So we can control for how long it’s available in memory that avoids the security threat with String.

There are two ways to check if two Strings are equal or not – using “==” operator or using equals method. When we use “==” operator, it checks for value of String as well as reference but in our programming, most of the time we are checking equality of String for value only. So we should use equals method to check if two Strings are equal or not.
There is another function equalsIgnoreCase that we can use to ignore case.
String s1 = “abc”;
String s2 = “abc”;
String s3= new String(“abc”);
System.out.println(“s1 == s2 ? “+(s1==s2)); //true
System.out.println(“s1 == s3 ? “+(s1==s3)); //false
System.out.println(“s1 equals s3 ? “+(s1.equals(s3))); //true

As the name suggests, String Pool is a pool of Strings stored in Java heap memory. We know that String is special class in java and we can create String object using new operator as well as providing values in double quotes.

When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String
object is returned.
This method always return a String that has the same contents as this string, but is guaranteed to be from a pool of unique strings.

Strings are immutable, so we can’t change its value in program. Hence it’s thread-safe and can be safely used in multi-threaded environment.

Since String is immutable, its hashcode is cached at the time of creation and it doesn’t need to be calculated again. This makes it a great candidate for key in a Map and its processing is fast than other HashMap key objects. This is why String is mostly used Object as
HashMap keys.

Collection is the root of the collection hierarchy. A collection represents a group of objects known as its elements. The Java platform doesn’t provide any direct implementations of this interface.
Set is a collection that cannot contain duplicate elements. This interface models the mathematical set abstraction and is used to represent sets, such as the deck of cards.
List is an ordered collection and can contain duplicate elements. You can access any element from its index. List is more like array with dynamic length.
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value.

In Java, an Iterator is one of the Java cursors. Java Iterator is an interface that is practiced in order to iterate over a collection of Java object components entirety one by one.
The Java Iterator is also known as the universal cursor of Java as it is appropriate for all the classes of the Collection framework. The Java Iterator also helps in the operations like READ and REMOVE.
Java Iterator Methods
The following figure perfectly displays the class diagram of the Java Iterator interface. It contains a total of four methods that are:

hasNext()
next()
remove()
forEachRemaining()

import java.io.*;  

import java.util.*;  

    

public class JavaIteratorExample {  

    public static void main(String[] args)  

    {  

        ArrayList cityNames = new ArrayList();  

       cityNames.add(“Delhi”);  

        cityNames.add(“Mumbai”);  

        cityNames.add(“Kolkata”);  

        cityNames.add(“Chandigarh”);  

        cityNames.add(“Noida”);  

            // Iterator to iterate the cityNames  

        Iterator iterator = cityNames.iterator();  

            System.out.println(“CityNames elements : “);  

    

        while (iterator.hasNext())  

            System.out.print(iterator.next() + ” “);  

            System.out.println();  

    }  

}  

Enumeration is twice as fast as Iterator and uses very less memory. Enumeration is very basic and fits to basic needs. But Iterator is much safer as compared to Enumeration because it always denies other threads to modify the collection object which is being iterated by it.
Iterator takes the place of Enumeration in the Java Collections Framework. Iterators allow the caller to remove elements from the underlying collection that is not possible with Enumeration. Iterator method names have been improved to make its functionality clear.

• We can use Iterator to traverse Set and List collections whereas ListIterator can be used with Lists only.
• Iterator can traverse in forward direction only whereas ListIterator can be used to traverse in both the directions.
• ListIterator inherits from Iterator interface and comes with extra functionalities like adding an element, replacing an element, getting index position for previous and next elements.

HashMap and Hashtable both implements Map interface and looks similar, however there are following difference between HashMap and Hashtable.

• HashMap allows null key and values whereas Hashtable doesn’t allow null key andvalues.
• Hashtable is synchronized but HashMap is not synchronized. So HashMap is better for single threaded environment, Hashtable is suitable for multi-threaded environment.
• LinkedHashMap was introduced in Java 1.4 as a subclass of HashMap, so incase you want iteration order, you can easily switch from HashMap to LinkedHashMap but that is not the case with Hashtable whose iteration order is unpredictable.
• HashMap provides Set of keys to iterate and hence it’s fail-fast but Hashtable provides Enumeration of keys that doesn’t support this feature.
• Hashtable is considered to be legacy class and if you are looking for modifications of Map while iterating, you should use ConcurrentHashMap.

For inserting, deleting, and locating elements in a Map, the HashMap offers the best alternative. If, however, you need to traverse the keys in a sorted order, then TreeMap is your better alternative. Depending upon the size of your collection, it may be faster to add elements to a HashMap, then convert the map to a TreeMap for sorted key traversal.

ArrayList and Vector are similar classes in many ways.

• Both are index based and backed up by an array internally.
• Both maintains the order of insertion and we can get the elements in the order of insertion.
• The iterator implementations of ArrayList and Vector both are fail-fast by design.
• ArrayList and Vector both allows null values and random access to element using index number.

These are the differences between ArrayList and Vector.

• Vector is synchronized whereas ArrayList is not synchronized. However if you are looking for modification of list while iterating, you should use CopyOnWriteArrayList.
• ArrayList is faster than Vector because it doesn’t have any overhead because of synchronization.
• ArrayList is more versatile because we can get synchronized list or read-only list from it easily using Collections utility class

• Arrays can contain primitive or Objects whereas ArrayList can contain only Objects.
• Arrays are fixed size whereas ArrayList size is dynamic.
• Arrays doesn’t provide a lot of features like ArrayList, such as addAll, removeAll, iterator etc.

Although ArrayList is the obvious choice when we work on list, there are few times when array are good to use.

• If the size of list is fixed and mostly used to store and traverse them.
• For list of primitive data types, although Collections use autoboxing to reduce the coding effort but still it makes them slow when working on fixed size primitive data types.
• If you are working on fixed multi-dimensional situation, using [][] is far more easier than List<List>

ArrayList and LinkedList both implement List interface but there are some differences between them:

• ArrayList is an index based data structure backed by Array, so it provides random access to its elements with performance as O(1) but LinkedList stores data as list of nodes where every node is linked to its previous and next node. So even though there is a method to get the element using index, internally it traverse from start to reach at the index node and then return the element, so performance is O(n) that is slower than ArrayList.
• Insertion, addition or removal of an element is faster in LinkedList compared to ArrayList because there is no concept of resizing array or updating index when element is added in middle.
• LinkedList consumes more memory than ArrayList because every node in LinkedList stores reference of previous and next elements.

Vector, Hashtable, Properties and Stack are synchronized classes, so they are thread-safe and can be used in multi-threaded environment. Java 1.5 Concurrent API included some collection classes that allows modification of collection while iteration because they work on the clone of the collection, so they are safe to use in multi-threaded environment.

Both Queue and Stack are used to store data before processing them. java.util.Queue is an interface whose implementation classes are present in java concurrent package. Queue allows retrieval of element in First-In-First-Out (FIFO) order but it’s not always the case.
There is also Deque interface that allows elements to be retrieved from both end of the queue.
Stack is similar to queue except that it allows elements to be retrieved in Last-In-First-Out (LIFO) order.
Stack is a class that extends Vector whereas Queue is an interface.

java.util.Collections is a utility class consists exclusively of static methods that operate on or return collections. It contains polymorphic algorithms that operate on collections, “wrappers”, which return a new collection backed by a specified collection, and a few other
odds and ends.
This class contains methods for collection framework algorithms, such as binary search, sorting, shuffling, reverse etc.

Comparable	Comparator
1) Comparable provides a single sorting sequence. In other words, we can sort the collection on the basis of a single element such as id, name, and price.	The Comparator provides multiple sorting sequences. In other words, we can sort the collection on the basis of multiple elements such as id, name, and price etc.
2) Comparable affects the original class, i.e., the actual class is modified.	Comparator doesn’t affect the original class, i.e., the actual class is not modified.
3) Comparable provides compareTo() method to sort elements.	Comparator provides compare() method to sort elements.
4) Comparable is present in java.lang package.	A Comparator is present in the java.util package.
5) We can sort the list elements of Comparable type by Collections.sort(List) method.	We can sort the list elements of Comparator type by Collections.sort(List, Comparator) method.

If we need to sort an array of Objects, we can use Arrays.sort(). If we need to sort a list of objects, we can use Collections.sort(). Both these classes have overloaded sort() methods for natural sorting (using Comparable) or sorting based on criteria (using Comparator).
Collections internally uses Arrays sorting method, so both of them have same performance except that Collections take sometime to convert list to array.

Exception is an error event that can happen during the execution of a program and disrupts its normal flow. Exception can arise from different kind of situations such as wrong data entered by user, hardware failure, network connection failure etc.
Whenever any error occurs while executing a java statement, an exception object is created and then JRE tries to find exception handler to handle the exception. If suitable exception handler is found then the exception object is passed to the handler code to process the exception, known as catching the exception. If no handler is found then application throws the exception to runtime environment and JRE terminates the program.
Java Exception handling framework is used to handle runtime errors only, compile time errors are not handled by exception handling framework.

• throw: Sometimes we explicitly want to create exception object and then throw it to halt the normal processing of the program. throw keyword is used to throw exception to the runtime to handle it.
• throws: When we are throwing any checked exception in a method and not handling it, then we need to use throws keyword in method signature to let caller program know the exceptions that might be thrown by the method. The caller method might handle these exceptions or propagate it to its caller method using throws keyword. We can provide multiple exceptions in the throws clause and it can be used with main() method also.
• try-catch: We use try-catch block for exception handling in our code. try is the start of the block and catch is at the end of try block to handle the exceptions. We can have multiple catch blocks with a try and trycatch block can be nested also. catch block requires a parameter that should be of type Exception.
• finally: finally block is optional and can be used only with try-catch block. Since exception halts the process of execution, we might have some resources open that will not get closed, so we can use finally block. Finally block gets executed always, whether exception occurrs or not.

Java Exceptions are hierarchical and inheritance is used to categorize different types of exceptions. Throwable is the parent class of Java Exceptions Hierarchy and it has two child objects – Error and Exception. Exceptions are further divided into checked exceptions and runtime exception.
Errors are exceptional scenarios that are out of scope of application and it’s not possible to anticipate and recover from them, for example hardware failure, JVM crash or out of memory error.
Checked Exceptions are exceptional scenarios that we can anticipate in a program and try to recover from it, for example fileNotFoundException. We should catch this exception and provide useful message to user and log it properly for debugging purpose. Exception is the parent class of all CheckedExceptions.
Runtime Exceptions are caused by bad programming, for example trying to retrieve an element from the Array. We should check the length of array first before trying to retrieve the element otherwise it might throw ArrayIndexOutOfBoundException at runtime. RuntimeException is the parent class of all runtime exceptions.

Exception and all of its subclasses doesn’t provide any specific methods and all of the methods are defined in the base class Throwable.

String getMessage() – This method returns the message String of Throwable and the message can be provided while creating the exception through it’s constructor.

String getLocalizedMessage() – This method is provided so that subclasses can override it to provide locale specific message to the calling program. Throwable class implementation of this method simply use getMessage() method to return the exception message.

synchronized Throwable getCause() – This method returns the cause of the exception or null id the cause is unknown.

String toString() – This method returns the information about Throwable in String format, the returned String contains the name of Throwable class and localized message.

void printStackTrace() – This method prints the stack trace information to the standard error stream, this method is overloaded and we can pass PrintStream or PrintWriter as argument to write the stack trace information to the file or stream.

• Checked Exceptions should be handled in the code using try-catch block or else main() method should use throws keyword to let JRE know about these exception that might be thrown from the program. Unchecked Exceptions are not required to be handled in the program or to mention them in throws clause.
• Exception is the super class of all checked exceptions whereas RuntimeException is the super class of all unchecked exceptions.
• Checked exceptions are error scenarios that are not caused by program, for example FileNotFoundException in reading a file that is not present, whereas Unchecked exceptions are mostly caused by poor programming, for example NullPointerException when invoking a method on an object reference without making sure that it’s not null.

throws keyword is used with method signature to declare the exceptions that the method might throw whereas throw keyword is used to disrupt the flow of program and handing over the exception object to runtime to handle it.

We can extend Exception class or any of its subclasses to create our custom exception class. The custom exception class can have its own variables and methods that we can use to pass error codes or other exception related information to the exception handler.

package com.journaldev.exceptions;
import java.io.IOException;
public class MyException extends IOException {
 private static final long serialVersionUID = 4664456874499611218L;
 
 private String errorCode="Unknown_Exception";
 
 public MyException(String message, String errorCode){
 super(message);
 this.errorCode=errorCode;
 }
 
 public String getErrorCode(){
 return this.errorCode;
 }
}

OutOfMemoryError in Java is a subclass of java.lang.VirtualMachineError and it’s thrown by JVM when it ran out of heap memory. We can fix this error by providing more memory to run the java application through java options.

$>java MyProgram -Xms1024m -Xmx1024m -XX:PermSize=64M -XX:MaxPermSize=256m

• Exception in thread main java.lang.UnsupportedClassVersionError: This exception comes when your java class is compiled from another JDK version and you are trying to run it from another java version.
• Exception in thread main java.lang.NoClassDefFoundError: There are two variants of this exception. The first one is where you provide the class full name with .class extension. The second scenario is when Class is not found.
• Exception in thread main java.lang.NoSuchMethodError: main: This exception comes when you are trying to run a class that doesn’t have main method.
• Exception in thread “main” java.lang.ArithmeticException: Whenever any exception is thrown from main method, it prints the exception is console. The first part explains that exception is thrown from main method, second part prints the exception class name and then after a colon, it prints the exception message.

• final and finally are keywords in java whereas finalize is a method.
• final keyword can be used with class variables so that they can’t be reassigned, with class to avoid extending by classes and with methods to avoid overriding by subclasses, finally keyword is used with try-catch block to provide statements that will always gets executed even if some exception arises, usually finally is used to close resources. finalize() method is executed by Garbage Collector before the object is destroyed, it’s great way to make sure all the global resources are closed.
• Out of the three, only finally is related to java exception handling.

When exception is thrown by main() method, Java Runtime terminates the program and print the exception message and stack trace in system console.

We can have an empty catch block but it’s the example of worst programming. We should never have empty catch block because if the exception is caught by that block, we will have no information about the exception and it wil be a nightmare to debug it. There should be at least a logging statement to log the exception details in console or log files.

TestNG(NG for Next Generation) is a testing framework that can be integrated with selenium or any other automation tool to provide multiple capabilities like assertions, reporting, parallel test execution, etc

• TestNG provides different assertions that help in checking the expected and actual results.
• It provides parallel execution of test methods.
• We can define the dependency of one test method over others in TestNG.
• Also, we can assign priority to test methods in Selenium.
• It permits the grouping of test methods into test groups.
• It allows data-driven testing using @DataProvider annotation.
• It gives inherent support for reporting.
• It has support for parameterizing test cases using @Parameters annotation

Selenium is an automation tool using which we can automate web-based applications. In order to add testing capabilities in the Test Automation suites – Selenium is clubbed with TestNG. With TestNG, we can have different features in our automation suite like different types of assertions, reporting, parallel execution, and parameterization, etc.
In short, for doing Automation Testing, Selenium helps with ‘automation’ and TestNG helps with ‘testing’ capabilities.

The testng.xml file is used for configuring the whole test suite. In testng.xml file, we can create a test suite, create test groups, mark tests for parallel execution, add listeners, and pass parameters to test scripts. We can also use this testng.xml file for triggering the test suite from
the command prompt/terminal or Jenkins.

Using groups attribute in TestNG, we can assign the test methods to different groups.

//Test method belonging to sanity suite only
@Test(groups = {“sanitySuite”})
public void testMethod1() {
//Test logic
}
//Test method belonging to both sanity and regression suite
@Test(groups = {“sanitySuite”, “regressionSuite”})
public void testMethod2() {
//Test logic
}

Using the exclude tag in testng.xml file, we can exclude a particular test method from getting executed.

@Test – @Test annotation marks a method as a test method.
@BeforeSuite – The annotated method will run only once before all tests in this suite have run.
@AfterSuite – The annotated method will run only once after all tests in this suite have run.
@BeforeClass – The annotated method will run only once before the first test method in the current class is invoked.
@AfterClass – The annotated method will run only once after all the test methods in the current class have been run.
@BeforeTest – The annotated method will run before any test method belonging to the classes inside the tag is run.
@AfterTest – The annotated method will run after all the test methods belonging to the classes inside the tag have run.
@BeforeMethod – The annotated method will run before each test method marked by @Test annotation.
@AfterMethod – The annotated method will run after each test method marked by @Test annotation.
@DataProvider – The @DataProvider annotation is used to pass test data to the test method.
The test method will run as per the number of rows of data passed via the data provider method.

The test methods in TestNG follow the Suite->Test->Class->Method sequence combined with the Before annotations->Test annotations->After annotations sequence. So, the order of execution is-

@BeforeSuite
@BeforeTest
@BeforeClass
@BeforeMethod
@Test
@AfterMethod
@AfterClass
@AfterTest
@AfterSuite

assertEquals(String actual, String expected, String message) and other overloaded data types in parameter
assertNotEquals(double data1, double data2, String message) and other overloaded data types in parameter
assertFalse(boolean condition, String message)
assertTrue(boolean condition, String message)
assertNotNull(Object object)
fail(boolean condition, String message)
true(String message

By setting the “enabled” attribute as false, we can disable a test method from running.

//In case of a test method
@Test(enabled = false)
public void testMethod1() {
//Test logic
}
//In case of test method belonging to a group
@Test(groups = {“NegativeTests”}, enabled = false)
public void testMethod2() {
//Test logic
}

Using dependsOnMethods parameter inside @Test annotation in TestNG we can make one test method run only after the successful execution of the dependent test method.
@Test(dependsOnMethods = { “preTests” })

We can define the priority of test cases using the “priority” parameter in @Test annotation. The tests with lower priority value will get executed first.

Example-
@Test(priority=1)

The default priority of a test when not specified is integer value 0. So, if we have one test case with priority 1 and one without any priority then the test without any priority value will get executed first (as default value will be 0 and tests with lower priority are executed first).

Using invocationCount parameter and setting its value to an integer value, makes the test method to run n number of times in a loop.
@Test(invocationCount = 10)
public void invocationCountTest(){
//Test logic
}

The threadPoolSize attribute specifies the number of threads to be assigned to the test method. This is used in conjunction with invocationCount attribute. The number of threads will get divided with the number of iterations of the test method specified in the invocationCount attribute.

@Test(threadPoolSize = 5, invocationCount = 10)
public void threadPoolTest(){
//Test logic
}

Soft assertions (SoftAssert) allows us to have multiple assertions within a test method, even when an assertion fails the test method continues with the remaining test execution. The result of all the assertions can be collated at the end using softAssert.assertAll() method.

@Test
public void softAssertionTest(){
SoftAssert softAssert= new SoftAssert();
//Assertion failing
softAssert.fail();
System.out.println(“Failing”);
//Assertion passing
softAssert.assertEquals(1, 1);
System.out.println(“Passing”);
//Collates test results and marks them pass or fail
softAssert.assertAll();
}

Here, even though the first assertion fails still the test will continue with execution and print the message below the second assertion.
Hard assertions on the other hand are the usual assertions provided by TestNG. In case of hard assertion in case of any failure, the test execution stops, preventing the execution of any further steps within the test method.

We can use the timeOut attribute of @Test annotation. The value assigned to this timeOut attribute will act as an upperbound, if test doesn’t get executed within this time frame then it will fail with timeOut exception.

@Test(timeOut = 1000)
public void timeOutTest() throws InterruptedException {
//Sleep for 2sec so that test will fail
Thread.sleep(2000);
System.out.println(“Will throw Timeout exception!”);
}

Using SkipException, we can conditionally skip a test case. On throwing the skipException, the test method is marked as skipped in the test execution report and any statement after throwing the exception will not get executed.

@Test
public void testMethod(){
if(conditionToCheckForSkippingTest)
throw new SkipException(“Skipping the test”);
//test logic
}

Using “alwaysRun” attribute of @Test annotation, we can make sure the test method will run even if the test methods or groups on which it depends fail or get skipped.

@Test
public void parentTest() {
Assert.fail(“Failed test”);
}
@Test(dependsOnMethods={“parentTest”}, alwaysRun=true)
public void dependentTest() {
System.out.println(“Running even if parent test failed”);
}

Here, even though the parentTest failed, the dependentTest will not get skipped instead it will executed because of “alwaysRun=true”. In case, we remove the “alwaysRun=true” attribute from @Test then the report will show one failure and one skipped test, without trying to run the dependentTest method.

Using @Parameter annotation and ‘parameter’ tag in testng.xml we can pass parameters to test scripts.
Sample testng.xml –
Sample test script

public class TestFile {
@Test
@Parameters(“sampleParamName”)
public void parameterTest(String paramValue) {
System.out.println(“Value of sampleParamName is – ” + sampleParamName); }

Using @DataProvider we can create a data-driven framework in which data is passed to the associated test method and multiple iterations of the test run for the different test data values passed from the @DataProvider method. The method annotated with @DataProvider annotation return a 2D array of object.

//Data provider returning 2D array of 3*2 matrix
@DataProvider(name = “dataProvider1”)
public Object[][] dataProviderMethod1() {
return new Object[][] {{“kuldeep”,”rana”}, {“k1″,”r1”},{“k2″,”r2”}};
}
//This method is bound to the above data provider returning 2D array of 3*2 matrix
//The test case will run 3 times with different set of values
@Test(dataProvider = “dataProvider1”)
public void sampleTest(String s1, String s2) {
System.out.println(s1 + ” ” + s2);
}

TestNG provides us different kinds of listeners using which we can perform some action in case an event gets triggered. Usually, testNG listeners are used for configuring reports and logging. One of the most widely used listeners in testNG is ITestListener interface. It has
methods like onTestSuccess, onTestFailure, onTestSkipped etc. We need to implement this interface creating a listener class of our own. After that using the @Listener annotation we can use specify that for a particular test class our customized listener class should be used.

@Listeners(PackageName.CustomizedListenerClassName.class)
public class TestClass {
WebDriver driver= new FirefoxDriver();@Test
public void testMethod(){
//test logic
}
}

@Factory annotation helps in the dynamic execution of test cases. Using @Factory annotation we can pass parameters to the whole test class at run time. The parameters passed can be used by one or more test methods of that class.
Example – there are two classes TestClass and the TestFactory class. Because of the @Factory annotation, the test methods in class TestClass will run twice with the data “k1” and “k2”.

public class TestClass{
private String str;
//Constructor
public TestClass(String str) {
this.str = str;
}
@Test
public void TestMethod() {
System.out.println(str);
}
}

==========================
public class TestFactory{
//The test methods in class TestClass will run twice with data “k1” and “k2”
@Factory
public Object[] factoryMethod() {
return new Object[] { new TestClass(“K1”), new TestClass(“k2”) };
}
}

@Factory method creates instances of test class and run all the test methods in that class with a different set of data.
Whereas, @DataProvider is bound to individual test methods and run the specific methods multiple times.

In order to run the tests in parallel just add these two key-value pairs inside the suite tag of the testng.xml file
parallel=”{methods/tests/classes}”
thread-count=”{number of thread you want to run simultaneously}”

Cucumber is a testing framework which supports Behavior Driven Development (BDD). It lets us define application behavior in plain meaningful English text using a simple grammar defined by a language called Gherkin. Cucumber itself is written in Ruby, but it can be used to “test” code written in Ruby or other languages including but not limited to Java, C# and Python.

TDD is an iterative development process. Each iteration starts with a set of tests written for a new piece of functionality. These tests are supposed to fail during the start of iteration as there will be no application code corresponding to the tests. In the next phase of the iteration, Application code is written with an intention to pass all the tests written earlier in the iteration. Once the application code is ready tests are run.

• Unit test proves that the code actually works
• Can drive the design of the program
• Refactoring allows improving the design of the code
• Low-Level regression test suite
• Test first reduce the cost of the bugs

As Gherkin is a structured language it follows some syntax let us first see a simple scenario described in gherkin.

Feature: Search feature for users
This feature is very important because it will allow users to filter products

Scenario: When a user searches, without spelling mistake, for a product name present in inventory. All the products with similar name should be displayed

Given User is on the main page of www.myshopingsite.com
When User searches for laptops
Then search page should be updated with the lists of laptops

• cobertura-2.1.1
• cucumber-core-1.2.5
• cucumber-java-1.2.5
• cucumber-junit-1.2.5
• cucumber-jvm-deps-1.0.5
• cucumber-reporting-3.10.0
• gherkin-2.12.2
• junit-4.12
• mockito-all-2.0.2-beta

This is a file where you will describe your tests in Descriptive language (Like English).
A feature file can contain a scenario or can contain many scenarios in a single feature file but it usually contains a list of scenarios.

Feature: Login Action

Scenario: Successful Login with Valid Credentials
Given User is on Home Page
When User Navigate to LogIn Page
And User enters UserName and Password
Then Message displayed Login Successfully

Scenario: Successful LogOut
When User LogOut from the Application
Then Message displayed LogOut Successfully

package cucumberTest;

import org.junit.runner.RunWith;
import cucumber.api.CucumberOptions;
import cucumber.api.junit.Cucumber;

@RunWith(Cucumber.class)
@CucumberOptions(
                features = ""Feature""
                ,glue={""stepDefinition""}
                )

public class TestRunner {

}

Feature : Feature defines the logical test functionality you will test in this feature file.
Feature: LogIn Action Test

Or

Feature: LogIn Action Test
Description: This feature will test a LogIn and LogOut functionality

Or

Feature: LogIn Action Test
This feature will test a LogIn and LogOut functionality

Background : Background keyword is used to define steps that are common to all the tests in the feature file.
Scenario: Each Feature will contain a number of tests to test the feature. Each test is called a Scenario and is described using the Scenario: keyword.
Given : Given defines a precondition to the test.
When : When keyword defines the test action that will be executed.
Then : Then keyword defines the Outcome of previous steps.
And : And keyword is used to add conditions to your steps.
But : But keyword is used to add negative type comments.
* : This keyword is very special. This keyword defies the whole purpose of having Given, When, Then and all the other keywords. Basically Cucumber doesn’t care about what Keyword you use to define test steps, all it cares about what code it needs to execute for each step. That code is called a step definition
——————————————————–
Feature: LogIn Action Test
Description: This feature will test a LogIn and LogOut functionality

Scenario: Successful Login with Valid Credentials
* User is on Home Page
* User Navigate to LogIn Page
* User enters UserName and Password
* Message displayed Login Successfully

Step Definition is a java method in a class with an annotation above it.
An annotation followed by the pattern is used to link the Step Definition to all the matching Steps, and the code is what Cucumber will execute when it sees a Gherkin Step.
Cucumber finds the Step Definition file with the help of the Glue code in Cucumber Options.

Create a new Class file in the ‘stepDefinition‘ package and name it as ‘Test_Steps‘, by right click on the Package and select New > Class

@Given("^User is on Home Page$")
        public void user_is_on_Home_Page() throws Throwable {
                driver = new FirefoxDriver();
        driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
        driver.get("https://www.store.demoqa.com");
                }

@CucumberOptions are like property files or settings for your test.

dryRun: true (checks if all steps have step definition)
features: set the path of feature files
glue: set the path of step definition files
tags: what tags in the feature files should be executed
monochrome: true (Display the console output in much readable way
format: what all report format to use
strict: true (will fail if there are undefined or pending steps)

package cucumberTest;

import org.junit.runner.RunWith;
import cucumber.api.CucumberOptions;
import cucumber.api.junit.Cucumber;

@RunWith(Cucumber.class)
@CucumberOptions(
                features = ""Feature""
                ,glue={""stepDefinition""}
                ,dryRun=true
                ,monochrome = false
                ,format = {""pretty"", ""html:target/Destination""} )
                )

public class TestRunner {

}

Feature: Login Action

Scenario: Successful Login with Valid Credentials
Given User is on Home Page
When User Navigate to LogIn Page
And User enters “testuser_1” and “Test@123”
Then Message displayed Login Successfully

---------------------------------------------------------------------------
@When("^User enters \"(.*)\" and \"(.*)\"$")
public void user_enters_UserName_and_Password(String username, String password) throws Throwable {
driver.findElement(By.id("log")).sendKeys(username);
driver.findElement(By.id("pwd")).sendKeys(password);
driver.findElement(By.id("login")).click();
}
-----------------------------------------------------------------------------
@When(“^User enters \”([^\”]*)\” and \”([^\”]*)\”$”)

Feature: Login Action

Scenario: Successful Login with Valid Credentials
        Given User is on Home Page
        When User Navigate to LogIn Page
        And User enters ""testuser_1"" and ""Test@123""
        Then Message displayed Login Successfully

---------------------------------------------------------------------------
        @When(""^User enters \""(.*)\"" and \""(.*)\""$"")
        public void user_enters_UserName_and_Password(String username, String password) throws Throwable {
                driver.findElement(By.id(""log"")).sendKeys(username);          
            driver.findElement(By.id(""pwd"")).sendKeys(password);
            driver.findElement(By.id(""login"")).click();
        }
-----------------------------------------------------------------------------
@When(“^User enters \”([^\”]*)\” and \”([^\”]*)\”$”)

Scenario Outline:

This uses Example keyword to define the test data for the Scenario.
This works for the whole test.
Cucumber automatically run the complete test the number of times equal to the number of data in the Test Set.

Data Table:
No keyword is used to define the test data.
This works only for the single step, below which it is defined.
A separate code needs to understand the test data and then it can be run single or multiple times but again just for the single step, not for the complete test.

Scenario: Successful Login with Valid Credentials
 Given User is on Home Page
 When User Navigate to LogIn Page
 And User enters Credentials to LogIn
    | testuser_1 | Test@153 |
 Then Message displayed Login Successfully
--------------------------------------------------------------------------------
@And(""^User enters Credentials to LogIn$"")
        public void user_enters_testuser__and_Test(DataTable usercredentials) throws Throwable {

                //Write the code to handle Data Table
                List<List> data = usercredentials.raw();

                //This is to get the first data of the set (First Row + First Column)
                driver.findElement(By.id(""log"")).sendKeys(data.get(0).get(0)); 

                //This is to get the first data of the set (First Row + Second Column)
            driver.findElement(By.id(""pwd"")).sendKeys(data.get(0).get(1));

            driver.findElement(By.id(""login"")).click();
        }

Data Tables in Cucumber,  we pass Username & Password without Header, due to which the test was not much readable.

Scenario: Successful Login with Valid Credentials
        Given User is on Home Page
        When User Navigate to LogIn Page
        And User enters Credentials to LogIn
        | Username   | Password |
        | testuser_1 | Test@153 |
        Then Message displayed Login Successfully
----------------------------------------------------------------------------------
@When(""^User enters Credentials to LogIn$"")
        public void user_enters_testuser_and_Test(DataTable usercredentials) throws Throwable {

                //Write the code to handle Data Table
                List<Map> data = usercredentials.asMaps(String.class,String.class);
                driver.findElement(By.id(""log"")).sendKeys(data.get(0).get(""Username"")); 
                driver.findElement(By.id(""pwd"")).sendKeys(data.get(0).get(""Password""));
                driver.findElement(By.id(""login"")).click();
           }

=================================================================================
@When(""^User enters Credentials to LogIn$"")
        public void user_enters_testuser_and_Test(DataTable usercredentials) throws Throwable {

                //Write the code to handle Data Table
                for (Map data : usercredentials.asMaps(String.class, String.class)) {
                        driver.findElement(By.id(""log"")).sendKeys(data.get(""Username"")); 
                    driver.findElement(By.id(""pwd"")).sendKeys(data.get(""Password""));
                    driver.findElement(By.id(""login"")).click();
                        }

        }

We can define each scenario with a useful tag. Later, in the runner file, we can decide which specific tag (and so as the scenario(s)) we want Cucumber to execute. Tag starts with “@”. After “@” you can have any relevant text to define your tag like @SmokeTests just above the scenarios you like to mark. Then to target these tagged scenarios just specify the tags names in the CucumberOptions as tags = {“@SmokeTests”}.

@FunctionalTest
Feature: ECommerce Application

@SmokeTest @RegressionTest
Scenario: Successful Login
Given This is a blank test

@RegressionTest
Scenario: UnSuccessful Login
Given This is a blank test

package cucumberTest;

import org.junit.runner.RunWith;
import cucumber.api.CucumberOptions;
import cucumber.api.junit.Cucumber;

@RunWith(Cucumber.class)
@CucumberOptions(
                features = ""Feature""
                ,glue={""stepDefinition""}
                ,dryRun=true
                ,monochrome = false
                ,format = {""pretty"", ""html:target/Destination""} )
                ,tags={""smokeTest""}
                )

public class TestRunner {

}

Execute all tests tagged as @SmokeTest OR @RegressionTest :	tags = {"SmokeTest,RegressionTest"}
Execute all tests tagged as @SmokeTest AND @RegressionTest :	tags = {"SmokeTest", "RegressionTest"}
Execute all tests of the feature tagged as @FunctionalTests but skip scenarios tagged as @SmokeTest :	tags = {"FunctionalTest","~SmokeTest"}

Cucumber supports hooks, which are blocks of code that run before or after each scenario. You can define them anywhere in your project or step definition layers, using the methods @Before and @After. Cucumber Hooks allows us to better manage the code workflow and helps us to reduce the code redundancy.

This prerequisite can be anything from:

Starting a webdriver
Setting up DB connections
Setting up test data
Setting up browser cookies
Navigating to certain page
or anything before the test
In the same way, there are always after steps as well of the tests like:

Killing the webdriver
Closing DB connections
Clearing the test data
Clearing browser cookies
Logging out from the application
Printing reports or logs
Taking screenshots on error
or anything after the test

package utilities;
import cucumber.api.java.After;
import cucumber.api.java.Before;

public class Hooks {
	
	@Before
    public void beforeScenario(){
        System.out.println(""This will run before the Scenario"");
    }	
	
	@After
    public void afterScenario(){
        System.out.println(""This will run after the Scenario"");
    }
}

Feature: Test Tagged Hooks

@First
Scenario: This is First Scenario
Given this is the first step
When this is the second step
Then this is the third step

@Second
Scenario: This is Second Scenario
Given this is the first step
When this is the second step
Then this is the third step

@Third
Scenario: This is Third Scenario
Given this is the first step
When this is the second step
Then this is the third step

"package utilities;

import cucumber.api.java.After;
import cucumber.api.java.Before;

public class Hooks {

	@Before
    public void beforeScenario(){
        System.out.println(""This will run before the every Scenario"");
    }

	@After
    public void afterScenario(){
        System.out.println(""This will run after the every Scenario"");
    }

	@Before(""@First"")
    public void beforeFirst(){
        System.out.println(""This will run only before the First Scenario"");
    }	

	@Before(""@Second"")
    public void beforeSecond(){
        System.out.println(""This will run only before the Second Scenario"");
    }	

	@Before(""@Third"")
    public void beforeThird(){
        System.out.println(""This will run only before the Third Scenario"");
    }

	@After(""@First"")
    public void afterFirst(){
        System.out.println(""This will run only after the First Scenario"");   
    }	

	@After(""@Second"")
    public void afterSecond(){
        System.out.println(""This will run only after the Second Scenario"");   
    }	

	@After(""@Third"")
    public void afterThird(){
        System.out.println(""This will run only after the Third Scenario"");   
    }	
}"

@Before(order = int) : This runs in increment order, means value 0 would run first and 1 would be after 0.
@After(order = int) : This runs in decrements order, means apposite of @Before. Value 1 would run first and 0 would be after 1.

import cucumber.api.java.en.Given;
import cucumber.api.java.en.Before;
public class PriorityTest {

@Given ("^User navigates to Reorder page$")
public void navigate_reorder () {
      System.out.println ("Reorder page is navigated");
    }
@Before (order = 2)
    public void precondition1 () {
        System.out.println ("The precondition1 is to be executed");
    } 
@Before (order = 1)
    public void precondition2 () {
        System.out.println ("The precondition2 is to be executed");
    } 
}

Background in Cucumber is used to define a step or series of steps that are common to all the tests in the feature file.
A Background is much like a scenario containing a number of steps. But it runs before each and every scenario were for a feature in which it is defined.

Feature: Test Background Feature
Description: The purpose of this feature is to test the Background keyword

Background: User is Logged In
Given I navigate to the login page
When I submit username and password
Then I should be logged in

Scenario: Search a product and add the first product to the User basket
Given User search for Lenovo Laptop
When Add the first laptop that appears in the search result to the basket
Then User basket should display with added item

Scenario: Navigate to a product and add the same to the User basket
Given User navigate for Lenovo Laptop
When Add the laptop to the basket
Then User basket should display with added item

Profile in cucumber allows a way to define a group of tests in a feature file to run a selected group instead of executing all the commands while testing a feature. Cucumber profiles allow running step definitions and features.

Use the command below to run the cucumber profile. 

Cucumber features -p

We can add comments in the Cucumber code. The comments are incorporated in code mostly for documentation and not for including program logic. It makes the code easier to apprehend and to debug the errors. Also, comments can be put at any point in the code.

Inside the feature file, the comments are added after the (#) symbol and the step definition contains comments after the (//) symbol.

Feature file with comments.

• Feature: Customer verification
• # Scenario with customer
• Scenario: Verify customer details
• Given User navigates to Customer Information Page

import cucumber.api.java.en.Given;
public class CustomerInformation {
 
@Given ("^User navigates to Customer Information Page$")
//method to map @Given scenario in feature file
public void navigate_to_customerInformation () {
      System.out.println ("Customer Information Page is navigated");
    }
}

We can use regular expressions in the Cucumber framework inside the step definition file. The regular expression can be used to combine two or more similar steps in the feature file within a test method in the step definition file. Also, the regular expression is used for data parameterization in Cucumber as the Feature New User Registration in the feature file described previously.

Feature file implementation.

• Feature: Student Study Schedule
• Description: Verify student study schedule
• Scenario: Verify hours spent on science subjects
• Given Student studies Chemistry on Tuesday
• Given Student studies Mathematics on Tuesday
• Given Student has thirty minutes recess

import cucumber.api.java.en.Given;
public class StudentSchedule {
 
@Given ("^Student studies ([^\"]*) on Tuesday$")
public void student_Tuesday_schedule (String subject) {
       if (subject.equals ("Chemistry")){
              System.out.println ("Student studies Chemistry on Tuesday");
        } else {
               System.out.println ("Student studies Mathematics on Tuesday");
         }
    }
@Given ("^Student has thirty minutes recess$")
public void student_recess () {
      System.out.println ("Student recess time is thirty minutes");
    }
}

For HTML reports, add html:target/cucumber-reports to the @CucumberOptions plugin option.

@CucumberOptions(
	features = "src/test/resources/functionalTests",
	glue= {"stepDefinitions"},
	plugin = { "pretty", "html:target/cucumber-reports" },
	monochrome = true
)

For JSON reports, add json:target/cucumber-reports/Cucumber.json to the @CucumberOptions plugin option.

@CucumberOptions(
	features = "src/test/resources/functionalTests",
	glue= {"stepDefinitions"},
	plugin = { "pretty", "json:target/cucumber-reports/Cucumber.json" },
	monochrome = true
)

For JUNIT reports, add junit:targe/cucumber-reports/Cucumber.xml to the @CucumberOptions plugin option.

@CucumberOptions(
	features = "src/test/resources/functionalTests",
	glue= {"stepDefinitions"},
	plugin = { "pretty", "junit:target/cucumber-reports/Cucumber.xml" },
	monochrome = true
)

Page Object Model is a design pattern which has become popular in test automation for enhancing test maintenance and reducing code duplication. A page object is an object-oriented class that serves as an interface to a page of your AUT.

Page Object model is an object design pattern in Selenium, where web pages are represented as classes, and the various elements on the page are defined as variables on the class.

Page Object Model is a Design Pattern which has become popular in Selenium Test Automation. Page object model (POM) can be used in any kind of framework such as modular, data-driven, keyword driven, hybrid framework etc.

The Page Factory Class is an extension to the Page Object design pattern. It is used to initialize the elements of the Page Object or instantiate the Page Objects itself. Annotations for elements can also be created (and recommended) as the describing properties may not always be descriptive enough to tell one object from the other.

Page Factory is an inbuilt page object model concept for Selenium Web Driver, but it is much optimized. Page Factory can be used in any kind of framework such as Data Driven, Modular or Keyword Driven. Page Factory gives more focus on how the code is being structured to get the best benefit out of it.

Page Object is a class that represents a web page and hold the functionality and members.

Page Factory is a way to initialize the web elements you want to interact with within the page object when you create an instance of it.

Test Class – In Test Class, we will write an actual selenium test script. Here, we call Page Action and mentioned actions to be
performed on Web Pages. For each page, we can write our own test class for better code readability. We can write test cases in @Test annotation.

In Page Action Class, we can write all web pages action as per the pages and functionality. Under Page Action component, for each page in the application, we have corresponding Page class.

Page Factory class is nothing but Object Repository in other term. For each web page, it has its own Page Object definitions. Each web element should uniquely get identified and should be defined at class level. We will use Find By annotation and will define web element so that we will be able to perform actions on them.

package pageObjects;


import java.util.List;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindAll;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.How;
import org.openqa.selenium.support.PageFactory;

public class CheckoutPage {
	WebDriver driver;
	public CheckoutPage(WebDriver driver) {
	       this.driver = driver;
               PageFactory.initElements(driver, this);
	}
	
	@FindBy(how = How.CSS, using = "#billing_first_name") 
	private WebElement txtbx_FirstName;

       public void enter_Name(String name) {
		txtbx_FirstName.sendKeys(name);
	}
}

@FindBy – It is used to locate web elements using different locators strategies.
@FindBy(how = How.ID, using = “userName”)
WebElement username;

@FindBys – To locate a web element with more than one search criteria, you can use @FindBys annotation. This annotation locates the web element by using the AND condition on the search criteria.
@FindBys({
@FindBy(class=”classname”),
@FindBy(id=”idname”)
})
WebElement name;

@FindAll – The @FindAll annotation locates the web element using more than one criteria, given that at least one criteria match. Contrary to @FindBys, it uses an OR conditional relationship between the multiple @FindBy.

@FindAll({
@FindBy(id=”btn”, //doesn’t match
@FindBy(name=”submit”), //Matches
@FindBy(class=”submitclass”) //doesn’t match
})
WebElement submitButton;

@CacheLookUp – The @CacheLookUp annotation is very useful when you are referring to the same web element multiple times. Using @CacheLookUp, we can store the web elements in cache memory right after reading for the first time. It fastens our execution and the code, need not look up for the element on the web page and directly references it from memory.
The @CacheLookUp can be prefixed with any of the annotations discussed above, i.e., @FindBy, @FindBys & @FindAll.

@CacheLookUp
@FindBys({
@FindBy(class=”checkbox-class”),
@FindBy(id=”checkbox-id”)
})

WebElement chkBox;

When we use “initElements” method of PageFactory, all page objects of Page Object class are initialized. It does not mean webdriver locates all web elements of page and store it.

Webdriver will locate element only when page object(Web element) is being used or you can say when any action like click etc are performed on web element and it will through noSuchElementException if web element is not found.

Exceptions are faults or disruptions that occur during the execution of a program/application. Exception handling is crucial for maintaining the natural or normal flow of the application. Selenium exceptions can be broadly categorized into two types: Checked and Unchecked
Exceptions.
Checked exceptions are handled during the coding process itself. Unchecked exceptions occur during run-time and can have a much greater impact on the application flow. We have compiled some of the most common selenium exceptions along with the various ways to
handle them.

Most Common Selenium Exceptions

• NoSuchWindowException
• NoSuchFrameException
• NoSuchElementException
• NoAlertPresentException
• InvalidSelectorException
• TimeoutException
• ElementNotVisibleException
• ElementNotSelectableException
• NoSuchSessionException
• StaleElementReferenceException

Selenium is an open source umbrella project for a range of tools and libraries aimed at supporting browser automation. It provides a playback tool for authoring functional tests across most modern web browsers, without the need to learn a test scripting language.

Most programmers and developers who build website applications and wish to test them every now and then use Selenium. One of the biggest advantages of Selenium, which has made it so popular, is its flexibility. Any individual who creates web programs can use Selenium to test the code and applications. Further, professionals can debug and perform visual regression tests as per the requirements of the website or code.

Automation testing is a Software testing method or technique to test any application and compare the actual result with the expected result. This can be achieved by designing test scripts using any relevant automation testing tool. Now a days Automation is vastly used to automate repetitive tasks and other testing tasks which are difficult to perform manually.

In manual testing test cases are executed manually without any proper support from relevant tools. However, for automated testing, test cases are executed with the assistance of one or more appropriate tools. Automation Testing is also more reliable as there is less chances of human error. In manual testing we have to run test cases manually every time based on our need, hence it is time consuming. However, in
automation testing once scripts are ready we can run the test cases any number of time with different combination of data with minimal time.

Selenium IDE, a Firefox add-on that you can only use in creating relatively simple test cases and test suites.
Selenium Remote Control, also known as Selenium 1, which is the first Selenium tool that allowed users to use programming languages in creating complex tests.
WebDriver, the newer breakthrough that allows your test scripts to communicate directly to the browser, thereby controlling it from the OS level.
Selenium Grid is also a tool that is used with Selenium RC to execute parallel tests across different browsers and operating systems.

• Selenium is open source and free software and hence there is no licensing cost for its usage.
• Scripting can be done in most of the widely used programming languages like Java, C#, Ruby, Perl, PHP and Python
• Automation using selenium can be done in many OS platform like MS Windows, Macintosh and Linux
• It supports most of the popular browsers like Chrome, FireFox, Internet Explorer, Opera and Safari.
• Selenium Grid helps in parallel and distributed testing
• It uses less Hardware resources

• Selenium does not provide desktop application automation support.
• Web Services – REST or SOAP cannot be automated using selenium.
• Selenium WebDriver requires programming language requirement for script creation.
• No vendor support for tool compared to commercial tools like HP UFT
• As there is no object repository concept in Selenium, maintainability of objects becomes difficult
• For performing common tasks required in automation like logging, reading-writing to external files we have to rely on external libraries

• Faster than other tools of Selenium suite (IDE, RC)
• Control the browser by programming
• Supports Data driven Testing and Cross browser testing
• Supports Parallel test execution with the help of either JUnit or TestNG

The locator can be termed as an address that identifies a web element uniquely within the webpage. Locators are the HTML properties of a web element.

• ID – driver.findElement(By.id(“IdName”))
• Name – driver.findElement(By.name(“Name”))
• Class Name – driver.findElement(By.className(“Element Class”))
• Tag Name – driver.findElement(By.tagName(“HTML Tag Name”))
• Link Text – driver.findElement(By.linkText(“LinkText”))
• Partial Link Text – driver.findElement(By.partialLinkText(“partialLinkText”))
• CSS Selector – driver.findElement(By.cssSelector(“value”))
• XPath – driver.findElement(By.xpath(“XPath”))

driver – Object/Instance of WebDriver
findElement – WebDriver method
By – Pre-defined Class in Selenium
id – Element locater/attribute
IdName – Locator value

Basic Xpath – XPath expression select nodes or list of nodes on the basis of attributes like ID , Name, Classname, etc. from the XML document.
Contains() – Contains() is a method used in XPath expression. It is used when the value of any attribute changes dynamically.
Using OR & AND – In OR expression, two conditions are used, whether 1st condition OR 2nd condition should be true. It is also applicable if any one condition is true or maybe both. Means any one condition should be true to find the element.
Starts-with() – It is used to identify an element, when we are familiar with the attributes value (starting with the specified text) of an element
Text() – This mechanism is used to locate an element based on the text available on a webpage.
Following – By using this we could select everything on the web page after the closing tag of the current node.
Ancestor – The ancestor axis selects all ancestors element (grandparent, parent, etc.) of the current node.
Child – Selects all children elements of the current node.
Preceding – Selects all nodes that appear before the current node in the document, except ancestors, attribute nodes and namespace nodes.
Following-sibling – Select the following siblings of the context node. Siblings are at the same level of the current node.
Parent – Selects the parent of the current node.
position() – Selects the element out of all input element present depending on the position number provided

Xpath Symbols
//tagname[@attribute-name=’value1′]
//*[@attribute-name=’value1′]

Xpath Generation using different other methods
Xpath=//*[contains(@type,'sub')]
Xpath=//*[@type='submit' OR @name='btnReset']
Xpath=//input[@type='submit' and @name='btnLogin']
Xpath=//label[starts-with(@id,'message')]
Xpath=//td[text()=‘textname']
Xpath=//*[@type='text']//following::input
Xpath=//*[text()=‘textvalue']//ancestor::div
Xpath=//*[@id=‘idname']/child::li
Xpath=//*[@type=‘typename']//preceding::input
Xpath=//*[@type=' typename ']//following-sibling::input
Xpath=//*[@id=' idname']//parent::div

Absolute Xpath: It uses Complete path from the Root Element to the desire element.
Example: /HTML/body/div/div[@id=’Email’]

Relative Xpath: You can simply start by referencing the element you want and go from there. Always Relative Xpaths are preferred as they are not the complete paths from the Root element. … So Always use Relative Xpaths in your Automation.
Example: //span[@class=’Email’]

/ -> Selects from the root node
// ->Selects nodes in the document from the current node that match the selection no matter where they are

CSS can be generated using different methods:
css=
css=
css=; 
Example: input[type=submit]
css=tag.class[attribute=value]

Starts with (^): css=
End with (^): css=
Contains (*): css=

Example: css=input[id*='id']

Using Multiple Symbols: 
css = tagname[attribute1='value1'][attribute2='value2']

You can use “submit” method on element to submit a form after all mandatory information filled.
Example: element.submit();

find element(): It finds the first element within the current page using the given “locating mechanism”. It returns a single WebElement. It is the responsibility of developers and testers to make sure that web elements are uniquely identifiable using certain properties such as ID or name.
Syntax: WebElement userid = driver.findElement(By.id(“Id Value”));

findElements() : Using the given “locating mechanism” it will find all the elements within the current page. It returns a list of web elements. It returns an empty list if there are no elements found using the given locator strategy and locator value.
Syntax: List elementName = driver.findElements(By.LocatorStrategy(“LocatorValue”));

TypeKeys() will trigger JavaScript event in most of the cases whereas .type() won’t. Type key populates the value attribute using JavaScript whereas .typekeys() emulates like actual user typing

Assert: Assert allows to check whether an element is on the page or not. The test will stop on the step failed, if the asserted element is not available. In other words, the test will terminated at the point where check fails.
Verify: Verify command will check whether the element is on the page, if it is not then the test will carry on executing. In verification, all the commands are going to run guaranteed even if any of test

To click on specific part of element, you would need to use clickAT command. ClickAt command accepts element locator and x, y co-ordinates as arguments- clickAt (locator, cordString)

driver.findElement(By.xpath(“xpath”)).sendKeys(Keys.ENTER);

The Implicit Wait in Selenium is used to tell the web driver to wait for a certain amount of time before it throws a “No Such Element Exception”. The default setting is 0. Once we set the time, the web driver will wait for the element for that time before throwing an exception.

Selenium Web Driver has borrowed the idea of implicit waits from Watir.

Before Selenium 4 –

driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
Now we will see this as deprecated @Deprecated WebDriver.Timeouts implicitlyWait(long time, TimeUnit unit);

After Selenium 4 –

driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));

The Explicit Wait in Selenium is used to tell the Web Driver to wait for certain conditions (Expected Conditions) or maximum time exceeded before throwing “ElementNotVisibleException” exception. It is an intelligent kind of wait, but it can be applied only for specified elements. It gives better options than implicit wait as it waits for dynamically loaded Ajax elements.

Once we declare explicit wait we have to use “ExpectedConditions” or we can configure how frequently we want to check the condition using Fluent Wait. These days while implementing we are using Thread.Sleep() generally it is not recommended to use.

Before Selenium 4 –

//Old syntax
WebDriverWait wait = new WebDriverWait(driver,10);
wait.until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector(“.classlocator”)));

After Selenium 4 –

//Selenium 4 syntax
WebDriverWait wait = new WebDriverWait(driver,Duration.ofSeconds(10));
wait.until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector(“.classlocator”)));

The Fluent Wait in Selenium is used to define maximum time for the web driver to wait for a condition, as well as the frequency with which we want to check the condition before throwing an “ElementNotVisibleException” exception. It checks for the web element at regular intervals until the object is found or timeout happens.

Frequency: Setting up a repeat cycle with the time frame to verify/check the condition at the regular interval of time.

FluentWait wait = new FluentWait(driver);
.withTimeout(30, TimeUnit.SECONDS)
.pollingEvery(5, TimeUnit.SECONDS)
.ignoring(NoSuchElementException.class);
WebElement element = wait.until(new Function<WebDriver, WebElement) {    
    public WebElement apply(WebDriver driver) {    
        return driver.findElement(By.id("element"));    
    }
});

findElement () will return only single WebElement and if that element is not located or we use some wrong selector then it will throw NoSuchElement exception.

findElements() – FindElements in Selenium command takes in By object as the parameter and returns a list of web elements. It returns an empty list if there are no elements found using the given locator strategy and locator value.

WebElement demos=driver.findElement(By.xpath(""//*[@id='menu-top']/li[1]/a""));

List links=driver.findElements(By.xpath("".//*[@id='menu-top']/li""));

• Datadriven framework: In this framework, the test data is separated and kept outside the Test Scripts, while test case logic resides in Test Scripts. Test data is read from the external files ( Excel Files) and are loaded into the variables inside the Test Script. Variables are used for both for input values and for verification values.
• Keyworddriven framework: The keyword driven frameworks requires the development of data tables and keywords, independent of the test automation. In a keyword driven test, the functionality of the application under test is documented in a table as well as step by step instructions for each test.

To work with Basic Authentication pop-up (which is a browser dialogue window), you just need to send the user name and password along with the application URL.

#1 (Chrome & Firefox)
By passing user credentials in URL. Its simple, append your username and password with the URL.

e.g., http://Username:Password@SiteURL

http://rajkumar:myPassword@www.hireqa.co.in

#2 (IE)
First create AutoIt script as below and save it as basicauth.au3

To pass user name and password
WinWaitActive(""Windows Security"")
Send(""admin"")
Send(""{TAB}"")
Send(""admin"")
Send(""{ENTER}"")
--------------------------------------------------
try {
                        Runtime.getRuntime().exec(""E:/basicauth.exe"");
                } catch (Exception e) {
                        e.printStackTrace();
                }

WebDriverManager class in Selenium:

• automates the management of WebDriver binaries.
• downloads the appropriate driver binaries, if not already present, into the local cache.
• downloads the latest version of the browser binary, unless otherwise specified.
• Eliminates the need to store driver binaries locally. We also need not maintain various versions of the binary driver files for different browsers.

WebDriverManager.chromedriver().setup();
driver = new ChromeDriver();

ChromeOptions chromeOptions = new ChromeOptions();
WebDriverManager.chromedriver().driverVersion(“85.0.4183.38”).setup();
WebDriverManager.chromedriver().browserVersion(“83.0.4103”).setup();
WebDriver driver = new ChromeDriver(chromeOptions);

"WebDriverManager.chromedriver().architecture(io.github.bonigarcia.wdm.Architecture.X32).setup();

Alternatively, we can also use arch32() or arch64() methods to specify binary types.

chromedriver().arch32().setup();
chromedriver().arch64().setup();"

If your organization has a proxy server, you need to specify proxy server details like server name or IP address, username, and password to the WebDriverManager. Otherwise, it may raise/ cause errors like io.github.bonigarcia.wdm.WebDriverManagerException: java.net.UnknownHostException: chromedriver.storage.googleapis.com.

WebDriverManager.chromedriver()
                 .version(“83.0.0”)
                 .arch32()
                 .proxy(“proxyhostname:80”)
                 .proxyUser(“username”)
                 .proxyPass(“password”)
.setup();

A proxy acts as an intermediary between clients sending requests and server responding. The primary use of a proxy is to maintain privacy and encapsulation between multiple interactive systems.

A proxy can also add another layer of security on the web by acting as a firewall between Client and web servers. This is especially used when the websites that clients use have to be labeled as allowed or blocked based on the website content.

package HireQADemo;
import java.io.IOException;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class AlertsDemo {
    public static void main(String args[]) throws IOException {
        System.setProperty(""webdriver.chrome.driver"", ""D:\\Data_Personal\\Software\\chromedriver_win32\\chromedriver.exe"");;
        WebDriver driver = new ChromeDriver();
        driver.get(""http://hireqa.co.in/test/basic_auth.php"");
        // Handling Username alert
        driver.switchTo().alert().sendKeys(""HireQA"");
        driver.switchTo().alert().accept();
        // Handling Password alert
        driver.switchTo().alert().sendKeys(""HireQA"");
        driver.switchTo().alert().accept();
    }
}

In Selenium Webdriver Session ID is a unique number that is assigned to your web driver by server . Webdriver uses this session Id to interact with browser launched by them. So a browser window (eg Chrome) launched by a specific driver (chrome driver) will have a unique sessionId.

Since Eclipse is freeware tool so sometime it does not work as per your requirement and some point still point to old location in this case we can clean our project
When you face any inconsistency with Eclipse then clean your project or restart eclipse.
Step 1- Open Eclipse and Click on Project and Click on Clean
Step 2- Now you will get two options- You can select based on your choice
Clean all projects- This will clean the entire project on project explorer

1- Open Eclipse > Click on Window > Click on Preferences.
2- Click on General > Click on Appearance > Click on Color and Fonts > in right side Click on Basic.
3- Once you click on Basics > Now Select Text font and Click on Edit button.

java.lang.IllegalStateException: The path to the driver executable must be set by the webdriver.chrome.driver system property;

System.setProperty(“webdriver.chrome.driver”, “path of the exe file\\chromedriver.exe”);
// Initialize browser
WebDriver driver=new ChromeDriver();

The term Gecko stands for a Web Browser engine that is inbuilt within Mozilla Firefox browser. Gecko driver acts as a proxy between Web Driver enabled clients(Eclipse, Netbeans, etc.) and Mozilla Firefox browser. In short, Gecko driver acts as a link between Selenium Web Driver tests and Mozilla Firefox browser.

Selenium uses W3C Webdriver protocol to send requests to GeckoDriver, which translates them into a protocol named Marionette. Firefox will understand the commands transmitted in the form of Marionette protocol and executes them.

System.setProperty(“webdriver.gecko.driver”, driverPath);
DesiredCapabilities capabilities = DesiredCapabilities.firefox();
capabilities.setCapability(“marionette”,true);
driver= new FirefoxDriver(capabilities);

or
FirefoxOptions options = new FirefoxOptions();
options.setLegacy(true);

1 :- WebDriver is an Interface(interface have only function prototype) in which by default all the method (public ,static)has to declared.
2:- WebDriver handles all activity which is related to Browser.

FireFoxDriver is a Class who has implemented all the method of WebDriver Interface.

1. SearchContext is the super most interface in selenium, which is extended by another interface called WebDriver.
2. All the abstract methods of SearchContext and WebDriver interfaces are implemented in RemoteWebDriver class.
3. All the browser related classes such as FirefoxDriver, ChromeDriver etc., extends the RemoteWebdriver class.
4. All the abstract methods of both the interfaces are implemented in RemoteWebDriver class which is extended by browser classes such as Firefox Driver, Chrome Driver etc.

We cannot write our code like this because we cannot create Object of an Interface. WebDriver is an interface.

WebDriver is an interface and all the methods which are declared in Webdriver interface are implemented by respective driver class.
But if we do upcasting,we can run the scripts in any browser .i.e running the same automation scripts in different browsers to achieve Runtime Polymorphism.

WebDriver is an interface, driver is a reference variable, FirefoxDriver() is a Constructor, new is a keyword, and new FirefoxDriver() is an Object.

1. Selenium Remote Webdriver: It is an class that is used to execute the browser automation and to execute assessments in a distributed environment or on a remote computing device. In other words, It is a class that implements the WebDriver interface and this action is performed on the remote server. There are different driver classes for a browser such as ChromeDriver, FirefoxDriver, etc.
2. Selenium Webdriver: It helps you to interact with browsers directly with the help of some automation scripts which includes a starting point, various variables with their binding values, and the source code. It is used to give support to various platforms, and its execution is little faster as compared to that of Selenium IDE or RC. It provides multiple client libraries which can be used in different programming languages like Python, C, Java, etc. which is used to build automation for the Selenium test.

Using id – #
Using class name – .
Using attribute – tagname[attribute=’value’]
Using multiple attribute – tagname[attribute1=’value’][attribute2=’value’]
Contains – * – tagname[attribute*=’value’]
Starts with – ^ – tagname[attribute^=’value’]
Ends with – $ – tagname[attribute$=’value’]

XPath starts-with() is a function used for finding the web element whose attribute value gets changed on refresh or by other dynamic operations on the webpage. In this method, the starting text of the attribute is matched to find the element whose attribute value changes dynamically.

Xpath=//label[starts-with(@id,’message’)]

The XPath text() function is a built-in function of selenium webdriver which is used to locate elements based on text of a web element. It helps to find the exact text elements and it locates the elements within the set of text nodes.

Xpath=//td[text()=’UserID’]

XPath Contains() is a method which is used to find the value of those attribute which changes dynamically. For example, login information.

XPath=//tagname[contains(@attribute, 'value')]

XPath ends-with() method checks the ending text of an attribute and finds elements whose attribute changes dynamically on refresh. It has the following syntax as follows:

XPath= //tagname[ends-with(@attribute, 'value')]

By using clear() method
WebDriver driver = new FirefoxDriver();
driver.get(“https://www.gmail.com”);
driver.findElement(By.xpath(“xpath_of_element1”)).sendKeys(“Software Testing Material Website”);
driver.findElement(By.xpath(“xpath_of_element1”)).clear();

isDisplayed()

WebElement radioBtn = driver.findElement (By.id(“gender-male”));

radioBtn.isDisplayed // this returns a Boolean value, if it returns true then said radio button is present on the webpage or it returns False.

isEnabled()

radioBtn.isEnabled() // this returns a Boolean value, if it returns true then said radio button is enabled on the webpage or it returns False

isSelected()

radioBtn.isSelected() // this returns a Boolean value, if it returns true then said radio button is selected or it returns False

Selenium already provides Select class that has some predefined method which help is a lot while working with Dropdown.

WebElement month_dropdown=driver.findElement(By.id(“month”));
Select month=new Select(month_dropdown);
month.selectByIndex(4);
month.selectByValue(“5”);
month.selectByVisibleText("Aug");

Select month=new Select(month_dropdown);
WebElement first_value=month.getFirstSelectedOption();
String value=first_value.getText();

WebElement month_dropdown=driver.findElement(By.id(""month""));
Select month=new Select(month_dropdown);
List dropdown=month.getOptions();
for(int i=0;i<dropdown.size();i++){
String drop_down_values=dropdown.get(i).getText();
System.out.println(""dropdown values are ""+drop_down_values);
}

The bootstrap dropdown is enhanced part of dropdown where you will deal with UL and LI tag of HTML.

List list = driver.findElementsByXPath(""//ul[@class='dropdown-menu']//li/a"");
// We are using enhanced for loop to get the elements
for (WebElement ele : list)
{
// for every elements it will print the name using innerHTML
System.out.println(""Values "" + ele.getAttribute(""innerHTML""));
// Here we will verify if link (item) is equal to Java Script
if (ele.getAttribute(""innerHTML"").contains(""JavaScript"")) {
// if yes then click on link (iteam)
ele.click();
// break the loop or come out of loop
break;
}

if(dropdown.isMultiple())
{sysout(""multiple option is allowed"")}

Returns TRUE if the drop-down element allows multiple selections at a time; FALSE if otherwise.

dropdown.deSelectAll();

We use click() method in Selenium to click on the hyperlink
driver.findElement(By.linkText(“Software Testing Material Website”)).click();

An exception is thrown. We need to pass HTTP protocol within driver.get() method.

Alternative method to driver.get(“url”) method is driver.navigate.to(“url”)

driver.get(): To open an URL and it will wait till the whole page gets loaded
driver.navigate.to(): To navigate to an URL and It will not wait till the whole page gets loaded

driver.navigate().forward();
driver.navigate().back();
driver.navigate().refresh();
driver.navigate().to(“url”);

Action Class in Selenium is a built-in feature provided by the selenium for handling keyboard and mouse events. It includes various operations such as multiple events clicking by control key, drag and drop events and many more.

clickAndHold() – Clicks (without releasing) at the current mouse location.
contextClick()– Performs a context-click at the current mouse location. (Right Click Mouse Action)
doubleClick() Performs a double-click at the current mouse location.
dragAndDrop(source, target) – Performs click-and-hold at the location of the source element, moves to the location of the target element, then releases the mouse.
dragAndDropBy(source, x-offset, y-offset) – Performs click-and-hold at the location of the source element, moves by a given offset, then releases the mouse.
keyDown(modifier_key) – Performs a modifier key press. Does not release the modifier key – subsequent interactions may assume it’s kept pressed.
modifier_key – any of the modifier keys (Keys.ALT, Keys.SHIFT, or Keys.CONTROL)
keyUp(modifier _key) – Performs a key release.
moveByOffset(x-offset, y-offset) – Moves the mouse from its current position (or 0,0) by the given offset.
moveToElement(toElement) – Moves the mouse to the middle of the element.
release() – Releases the depressed left mouse button at the current mouse location
sendKeys(onElement, charsequence) – Sends a series of keystrokes onto the element.

WebElement ele = driver.findElement(By.xpath(“xpath”));
//Create object ‘action’ of an Actions class
Actions action = new Actions(driver);
//Mouseover on an element
action.moveToElement(ele).perform();

Actions builder = new Actions(driver);
Action seriesOfActions = builder
	.moveToElement(txtUsername)
	.click()
	.keyDown(txtUsername, Keys.SHIFT)
	.sendKeys(txtUsername, ""hello"")
	.keyUp(txtUsername, Keys.SHIFT)
	.doubleClick(txtUsername)
	.contextClick()
	.build();
	
seriesOfActions.perform() ;

Actions action = new Actions(driver);
action.clickAndHold(slider).moveByOffset(50,0).release();

Move To Element:
Actions builder=new Actions(driver);
WebElement ele=driver.findElement(By.xpath("".//*[@id='autosuggest']/ul/li[2]/a""));
builder.moveToElement(ele).build().perform();
builder.click(ele).build().perform();

Right Click on Element:
Actions act=new Actions(driver);
act.contextClick(driver.findElement(By.linkText(“Gujarati”))).perform();

Key Down:
Actions act=new Actions(driver);
act.contextClick(driver.findElement(By.linkText(""Gujarati""))).sendKeys(Keys.ARROW_DOWN).sendKeys(Keys.ARROW_DOWN).sendKeys(Keys.ENTER).build().perform();

Approach 1:
Actions act=new Actions(driver);
// find element which we need to drag
WebElement drag=driver.findElement(By.xpath("".//*[@id='draggable']""));
// find element which we need to drop
WebElement drop=driver.findElement(By.xpath("".//*[@id='droppable']""));
// this will drag element to destination
act.dragAndDrop(drag, drop).build().perform();

Approach 2:
Actions act=new Actions(driver);
// find element which we need to drag
WebElement source=driver.findElement(By.xpath(""(//span[text()='Thrillers'])[1]""));
WebElement destination=driver.findElement(By.xpath(""(//span[text()='History'])[2]""));
// it will click and hold the triller box and move to element will move cursor to history in another box and then release
act.clickAndHold(source).pause(2000).moveToElement(destination).release().build().perform();

Scenario 1: Tooltip is implemented using the ""title"" attribute
WebElement github = driver.findElement(By.xpath("".//*[@class='soc-ico show-round']/a[4]""));        
//get the value of the ""title"" attribute of the github icon                
String actualTooltip = github.getAttribute(""title"");        

Scenario 2: Tooltip is implemented using a jQuery plugin.

String expectedTooltip = ""What's new in 3.2"";                                        
        driver.get(baseUrl);                                        
                        
        WebElement download = driver.findElement(By.xpath("".//*[@id='download_now']""));                                                        
        Actions builder = new Actions (driver);                                                        

        builder.clickAndHold().moveToElement(download);                                        
        builder.moveToElement(download).build().perform();         
        
        WebElement toolTipElement = driver.findElement(By.xpath("".//*[@class='box']/div/a""));                                                        
        String actualTooltip = toolTipElement.getText();                        
        
        System.out.println(""Actual Title of Tool Tip  ""+actualTooltip);                                                        
        if(actualTooltip.equals(expectedTooltip)) {                                                        
            System.out.println(""Test Case Passed"");                                        
        }        

Web-Based alert and Java Script alerts are same so do not get confused.
Alert Interface has some methods-
1- accept()- Will click on the ok button when an alert comes.
2- dismiss()- Will click on cancel button when an alert comes.

//Captured Alert Text (Actual Text)
String actualAlertMessage = driver.switchTo().alert().getText();

//Accept the alert (Click OK)
driver.switchTo().alert().accept();

//Accept the alert (Click Cancel)
driver.switchTo().alert().dismiss();

//Send “Hire QA” to Alert’s text box
driver.switchTo().alert().sendKeys(“Hire QA”);

iFrame is a HTML document embedded inside an HTML document. iFrame is defined by an tag in HTML. With this tag, you can identify an iFrame while inspecting the HTML tree.

To Switch between iFrames we have to use the driver’s switchTo().frame command.
We can use the switchTo().frame() in three ways:

• switchTo.frame(int frameNumber): Pass the frame index and driver will switch to that frame.
• switchTo.frame(string frameName): Pass the frame element Name or ID and driver will switch to that frame.
• switchTo.frame(WebElement frameElement): Pass the frame web element and driver will switch to that frame.

//Switch by frame name
driver.switchTo().frame(“iframe1”);

//Switch by frame ID
driver.switchTo().frame(“IF1”);

//First find the element using any of locator stratedgy
WebElement iframeElement = driver.findElement(By.id(“IF1”));

//switch to frame by using frame element
driver.switchTo().frame(iframeElement);

//Switch back to the main window
driver.switchTo().defaultContent();

// It will return the parent window name as a String
String parent=driver.getWindowHandle();
// This will return the number of windows opened by Webdriver and will return Set of St//rings
Sets1=driver.getWindowHandles();
// Now we will iterate using Iterator
Iterator I1= s1.iterator();
while(I1.hasNext())
{
 
   String child_window=I1.next();
 
// Here we will compare if parent window is not equal to child window then we will close
if(!parent.equals(child_window))
{
driver.switchTo().window(child_window);
System.out.println(driver.switchTo().window(child_window).getTitle());
driver.close();
}
 
}
// once all pop up closed now switch to parent window
driver.switchTo().window(parent);
 
}
}

//No.of Columns
List col = wd.findElements(By.xpath(“.//*[@id=\”leftcontainer\”]/table/thead/tr/th”));
System.out.println(“No of cols are : ” +col.size());

//No.of rows
List rows = wd.findElements(By.xpath(“.//*[@id=’leftcontainer’]/table/tbody/tr/td[1]”));
System.out.println(“No of rows are : ” + rows.size());

Fetch 3rd row and 2nd cell data
———————————————-
//To find third row of table
WebElement tableRow = baseTable.findElement(By.xpath(“//*[@id=\”leftcontainer\”]/table/tbody/tr[3]”));
String rowtext = tableRow.getText();
System.out.println(“Third row of table : “+rowtext);

//to get 3rd row’s 2nd column data
WebElement cellIneed = tableRow.findElement(By.xpath(“//*[@id=\”leftcontainer\”]/table/tbody/tr[3]/td[2]”));
String valueIneed = cellIneed.getText();
System.out.println(“Cell value is : ” + valueIneed);

//No. of Columns
	        List  col = wd.findElements(By.xpath("".//*[@id='leftcontainer']/table/thead/tr/th""));
	        System.out.println(""Total No of columns are : "" +col.size());


//No.of rows
	        List  rows = wd.findElements(By.xpath ("".//*[@id='leftcontainer']/table/tbody/tr/td[1]""));
	        System.out.println(""Total No of rows are : "" + rows.size());
	        for (int i =1;ir)
	             {    
	                r=m;
	             }
	        }
	        System.out.println(""Maximum current price is : ""+ r);

Desired Capabilities are needed because every Testing scenario should be executed on some specific testing environment. The testing environment can be a web browser, Mobile device, mobile emulator, mobile simulator, etc. The Desired Capabilities Class helps us to tell the webdriver, which environment we are going to use in our test script.

//it is used to define IE capability 
 DesiredCapabilities capabilities = DesiredCapabilities.internetExplorer();
  
capabilities.setCapability(CapabilityType.BROWSER_NAME, "IE");
capabilities.setCapability(InternetExplorerDriver.INTRODUCE_FLAKINESS_BY_IGNORING_SECURITY_DOMAINS,true);


System.setProperty("webdriver.ie.driver", "C:\\IEDriverServer.exe");
  
 //it is used to initialize the IE driver
 WebDriver driver = new InternetExplorerDriver(capabilities);

ChromeOptions is a class that can be used to manipulate capabilities specific to ChromeDriver. For instance, you can disable Chrome extensions with:

ChromeOptions options = new ChromeOptions()
options.addArgument(“disable-extensions”);
ChromeDriver driver = new ChromeDriver(options);

DesiredCapabilities can also be used to manipulate a ChromeDriver session. To change individual web driver properties, DesiredCapabilities class provides key-value pairs.

But, ChromeOptions supports limited clients whereas DesiredCapabilities supports a vast number of clients. ChromeOptions is supported by Java and other languages. DesiredCapabilities is available in Java, but its use is deprecated. When working with a client library, like Selenium Ruby Client, the ChromeOption class will not be available and DesiredCapabilities will have to be used.

DesiredCapabilities are commonly used with Selenium Grid, for parallel execution of test cases on different browsers. However, one can use both DesiredCapabilities and ChromeOptions using merge:

DesiredCapabilities capabilities = new DesiredCapabilities();
options = new ChromeOptions();
options.merge(capabilities);
driver = new ChromeDriver(options);

driver.get(""http://www.google.co.in/"");
List links=driver.findElements(By.tagName(""a""));
System.out.println(""Total links are ""+links.size());
for(int i=0;i<links.size();i++)
{
WebElement ele= links.get(i);
String url=ele.getAttribute(""href"");
verifyLinkActive(url);
----------------------------------------------
public static void verifyLinkActive(String linkUrl)
        {
        try 
        {
           URL url = new URL(linkUrl);
           
           HttpURLConnection httpURLConnect=(HttpURLConnection)url.openConnection();
           
           httpURLConnect.setConnectTimeout(3000);
           
           httpURLConnect.connect();
           
           if(httpURLConnect.getResponseCode()==200)
           {
               System.out.println(linkUrl+"" - ""+httpURLConnect.getResponseMessage());
            }
          if(httpURLConnect.getResponseCode()==HttpURLConnection.HTTP_NOT_FOUND)  
           {
               System.out.println(linkUrl+"" - ""+httpURLConnect.getResponseMessage() + "" - ""+ HttpURLConnection.HTTP_NOT_FOUND);
            }
        } catch (Exception e) {
           
        }
    } 

During test execution, the Selenium WebDriver has to interact with the browser all the time to execute given commands. At the time of execution, it is also possible that, before current execution completes, someone else starts execution of another script, in the same machine and in the same type of browser.
In such situation, we need a mechanism by which our two different executions should not overlap with each other. This can be achieved using Session Handling in Selenium.

To work with Basic Authentication pop-up (which is a browser dialogue window), you just need to send the user name and password along with the application URL.

#1 (Chrome & Firefox)
By passing user credentials in URL. Its simple, append your username and password with the URL.

e.g., http://Username:Password@SiteURL

http://rajkumar:myPassword@www.softwaretestingmaterial.com

#2 (IE)
First create AutoIt script as below and save it as basicauth.au3

To pass user name and password
WinWaitActive(“Windows Security”)
Send(“admin”)
Send(“{TAB}”)
Send(“admin”)
Send(“{ENTER}”)
————————————————–
try {
Runtime.getRuntime().exec(“G:/basicauth.exe”);
} catch (Exception e) {
e.printStackTrace();
}