SDET Interview Questions
SDET Interview Questions
© Copyright by Interviewbit
Contents
19. Given the urgency with which a crucial hotfix must be deployed - What kind of
testing technique would you use if you were in charge of the project?
20. What do you understand about fuzz testing? What are the types of bugs
detected by fuzz testing?
21. What do you understand about a test script? Differentiate between test case and
test script.
22. Differentiate between walkthrough and inspection.
23. What do you understand about white box testing and black box testing?
Differentiate between them.
What is SDET?
In testing, an SDET (So ware Development Engineer in Test) is an IT expert who can
operate equally well in development and testing. SDETs are involved in every step of
the so ware development and testing process. The knowledge of SDET professionals
is entirely focused on so ware testing and development process testability,
robustness, and performance. They can also participate as a contributor or reviewer
in the development of production so ware designs. Currently, businesses are looking
for a professional who can assist with so ware development. At the same time, he
should be in charge of evaluating the so ware that has been produced. That is why
hiring SDET is beneficial to them because they can work on high-performance code
or testing framework creation.
Microso was the first to do so, but other companies are now taking notice, and
they're seeking someone who is an expert in SDET to help them with the whole
development of their product, as well as the testing design that must be carried out
for that specific development. The company can use the same resource for two
critical jobs that will always be profitable.
In this article, we have covered the most frequently asked interview questions for the
profile of So ware Development Engineer in Test (SDET). For a So ware
Development Engineer in Test (SDET), it is essential to be thorough with the
principles of so ware testing as well.
A tester tests
so ware or
SDET refers to a tester who is also a coder. systems a er
they have been
developed.
A tester is
unaware of the
SDET is well-versed in the areas of design,
so ware's
implementation, and testing.
design and
implementation.
A tester has a
limited
SDET is well-versed in so ware requirements
understanding
and other related topics.
of so ware
requirements.
In the so ware
development life
SDET is involved at every stage of the so ware cycle, testers
development life cycle. play a less role
and have fewer
obligations.
Ad-hoc testing is done on any portion of the application at random and does not
follow any standardized testing procedures. The primary goal of this testing is to
detect problems through random inspection. Error Guessing, a so ware testing
approach, can be used to perform ad hoc testing. People with adequate familiarity
with the system can "predict" the most likely source of errors, which is known as
error guessing. This testing does not necessitate any paperwork, planning, or
procedure. Because this testing seeks to detect faults through a random technique,
defects will not be mapped to test cases if there is no documentation. This means
that reproducing errors can be difficult at times because there are no test processes
or requirements associated with them.
TITLE - A good title is simple, concise, and provides a description of the bug to
the developer. It should include the bug's categorization, the app component
where the bug happened (e.g. Cart, UI, etc. ), and the activity or conditions in
which the bug occurred. A clear title makes it easier for the developer to find the
report and distinguishes duplicate reports, making problem triaging much
easier.
SEVERITY AND PRIORITY - The severity of an issue is determined by its severity.
The severity levels and definitions vary amongst programme developers, and
even more so between developers, testers, and end-users who are unaware of
these distinctions. The standard categorization is as follows:
Critical/Blocker: This category is reserved for faults that render the
application useless or result in significant data loss.
High: When a bug affects a major feature and there is no workaround or the
remedy that is provided is extremely complicated.
Medium: The bug affects a minor or significant feature, but there is a
simple enough fix to avoid major discomfort.
Low: This is for defects that have a modest impact on the user experience,
such as minor visual bugs.
DESCRIPTION -This is a concise summary of the bug, including how and when it
occurred. This section should contain additional information than the title, such
as the frequency with which the bug happens if it is an intermittent error and the
situations that appear to trigger it. It contains information about how the bug is
impacting the application.
ENVIRONMENT - Apps can behave in a variety of ways depending on their
surroundings. This section should contain all of the information about the app's
environment setup and settings.
REPRO STEPS - This should include the bare essentials for reproducing the bug.
The steps should ideally be short, easy, and accessible to anybody. The goal is for
the developer to be able to reproduce the error on their end in order to figure
out what's wrong. A bug report without repro steps is useless and wastes time
and effort that could be better spent resolving more complete reports; make
sure to convey this to your testers and in a way that your end-users understand.
ACTUAL RESULT - This is what the tester or user saw as a result or output.
EXPECTED RESULT - This is the anticipated or planned consequence or output.
ATTACHMENTS - Attachments can assist the developer find the problem faster; a
screenshot of the problem can explain a lot, especially when the problem is
visual. Logs and other incredibly useful attachments can at the very least put the
6. What are the do’s and don'ts for a good bug report?
Following are the do’s for a good bug report :
When you're finished, read your report. Make sure it's clear, concise, and simple
to understand.
Don't allow any opportunity for ambiguity by being as clear as possible.
Do test the problem a few times to see if there are any superfluous procedures.
Include any workarounds or additional procedures you've discovered that cause
the problem to behave differently in your report.
Check to see if the bug has previously been reported. If it has, please leave a
comment on the bug with your information.
Do reply to requests for further information from developers.
Following are the don’ts for a good bug report :
DO NOT submit a report that contains more than one bug. When there are
numerous bugs in the report, keeping track of their progress and dependencies
becomes difficult.
DO NOT be judgmental or accusatory. Bugs are unavoidable, yet they aren't
always simple to fix.
DO NOT try to figure out what's causing the bug. Stick to the facts to avoid
sending the developer on a wild goose hunt.
Anything that isn't a bug should be posted. Developers appreciate hearing from
you, but sending information to the wrong channel will just block their workflow
and cause delays.
Priority Severity
10. What do you understand about beta testing? What are the
different types of beta testing?
Alpha testing is
frequently done by Clients who are not employees of
testers who are inside the company undertake beta
employees of the testing.
company.
Alpha testing
Beta testing does not necessitate
necessitates the use
the use of a testing setting or
of a lab or a testing
laboratory.
environment.
Xray - Xray is a full-featured tool that exists inside Jira and works flawlessly with
it. Its mission is to assist businesses in improving the quality of their products
through efficient and effective testing.
The practice of
The process of determining a
determining how a system
system's performance, which
behaves when several
includes speed and reliability
people access it at the
under changing loads, is known
same time is known as
as performance testing.
load testing.
Because the product necessitated starting automation from the ground up, you
had plenty of time to consider and design an appropriate automation
framework, opting for a language/technology that the majority of people were
familiar with in order to avoid introducing a new tool and instead leverage
existing knowledge.
You began by automating the most basic functional scenarios, which were
referred to as P1 scenarios (without which no release could go through).
You also considered using automated test tools like JMETER, LoadRunner, and
others to test the system's performance and scalability.
You considered automating the application's security features as outlined in the
OWASP Security guidelines.
For early feedback and other reasons, you included automated tests into the
build workflow.
What types of test strategies can you conceive of and how do you plan to
implement them?
What kind of coverage would you provide in the event of a hotfix?
How would you test the hotfix a er it's been deployed? etc.
If you can relate to the problem, you can use real-life circumstances to answer such
questions. You should also explain that you would not be willing to deliver any code
to production without proper testing.
When it comes to essential fixes, you should always collaborate with the developer to
figure out what areas they might affect and set up a non-production environment to
test the change. It's also worth noting that you'll continue to monitor the fix (using
monitoring tools, dashboards, logs, and so on) a er it's been deployed to look for any
anomalous behaviour in the production environment and ensure that the fix hasn't
had any negative consequences.
20. What do you understand about fuzz testing? What are the
types of bugs detected by fuzz testing?
Fuzz Testing is a so ware testing technique that utilizes erroneous, unexpected, or
random data as input and then looks for exceptions like crashes and memory leaks.
It's a type of automated testing that's used to define system testing techniques that
use a randomized or dispersed approach. During fuzz testing, a system or so ware
program may have a variety of data input problems or glitches.
Following are the different phases of Fuzz Testing:
Identify the Target System: The system or so ware application that will be
tested is identified. The target system is the name given to that system. The
testing team determines the target system.
Identify Inputs: Once the target system is determined, random inputs are
generated for testing purposes. The system or so ware application is tested
using these random test scenarios as inputs.
Generate Fuzzed Data: A er receiving unexpected and invalid inputs, these
invalid and unexpected inputs are turned to fuzzed data. Fuzzed data is
essentially random data that has been transformed into fuzzy logic.
Use fuzzed data to run the test: The fuzzed data testing process is now being
used. Basically, the code of the programme or so ware is executed in this
portion by providing random input, i.e. fuzzed data.
Monitor System Behavior: A er the system or so ware application has
completed its execution, check for any crashes or other anomalies, such as
potential memory leaks. The random input is used to test the system's
behaviour.
Log Flaws: In the final phase, defects are detected and rectified in order to
produce a higher-quality system or so ware program.
In the automation
In a manual testing environment, testing environment,
Test Cases are employed. Test Script is
employed.
It is carried out in
It's done by hand. accordance with the
scripting format.
The following table lists the differences between walkthrough and inspection -
Walkthrough Inspection
The inspection is
conducted by a group of
The developer of the product people from several
takes the lead throughout the departments. The tour is
walkthrough. usually attended by
members of the same
project team.
Overview, little or no
preparation, little or no Overview, preparation,
preparation examination (real inspection, rework, and
walkthrough meeting), rework, follow-up are all part of the
and follow up are all part of the inspection process.
walkthrough process.
23. What do you understand about white box testing and black
box testing? Differentiate between them.
Black Box Testing: The customer's statement of requirements is the most
common source of black-box testing. It's a different kind of manual testing. It's a
so ware testing technique that looks at the so ware's functionality without
knowing anything about its internal structure or coding. It does not necessitate
any so ware programming knowledge. All test cases are created with the input
and output of a certain function in mind. The test engineer examines the
programme against the specifications, detects any faults or errors, and returns it
to the development team.
White Box Testing: The term "clear box," "white box," or "transparent box"
refers to the capacity to see into the inner workings of so ware through its
outside shell. It is carried out by developers, a er which the so ware is handed
to the testing team for black-box testing. The fundamental goal of white-box
testing is to examine the infrastructure of an application. It is carried out at a
lower level, as unit testing and integration testing are included. It necessitates
programming skills because it primarily focuses on a program's or so ware's
code structure, routes, conditions, and branches. The main purpose of white-
box testing is to concentrate on the flow of inputs and outputs via the so ware
while also ensuring its security.
The following table lists the differences between black box and white box testing:
It is also known as
Functional testing, data-driven
structural testing, clear
testing, and closed-box testing are
box testing, code-
all terms used to describe Black
based testing, and
Box Testing.
transparent testing.
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a = 1, b = 2;
cout << "Before Swapping : a = " << a << " and b = " << b << "\n";
a = a + b; // storing the sum of a and b in a
b = a - b; // storing the value of the original a in b
a = a - b; // storing the value of the original b in a
cout << "After Swapping : a = " << a << " and b = " << b << "\n";
}
Output :
Explanation :
In the above code, we first stored the sum of both the numbers in the first variable.
Then, we store the original value of the first variable in the second variable by
subtracting the second variable from the sum. Similarly we change the value for the
second variable as well. Thus, we swapped the two numbers without using a third
variable.
Approach 2 :
To swap two variables, use the bitwise XOR operator. When two integers x and y are
XORed, the result is a number with all bits set to 1 wherever the bits of x and y differ.
For instance, the XOR of 10 (in Binary 1010) and 5 (in Binary 0101) is 1111, while the
XOR of 7 (0111) and 5 (0101) is 1111. (0010). We can then xor the resultant XORed with
the other number to swap the values. Considering the above example, when we xor
1111 with 0101 we get 1010.
Code :
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a = 1, b = 2;
cout << "Before Swapping : a = " << a << " and b = " << b << "\n";
a = a ^ b; // storing the xor of a and b in a
b = a ^ b; // storing the value of the original a in b
a = a ^ b; // storing the value of the original b in a
cout << "After Swapping : a = " << a << " and b = " << b << "\n";
}
Output :
Explanation :
In the above code, we first stored the xor of both the numbers in the first variable.
Then, we store the original value of the first variable in the second variable by XORing
the second variable with the sum. Similarly, we change the value for the second
variable as well. Thus, we swapped the two numbers without using a third variable.
1234
Output:
4321
Approach:
We follow a greedy approach. We start extracting each digit from the original
number from the end and keep on adding it at the end of the new number, thereby
reversing the given number.
Code:
#include <bits/stdc++.h>
using namespace std;
//function to find the reverse of the given input
int reverseNumber(int original_number)
{
int new_number = 0;
while (original_number > 0) {
new_number = new_number * 10 + original_number % 10; // extracting the last digi
original_number = original_number / 10;
}
return new_number;
}
int main()
{
int original_number = 1234;
cout << "The original number is " << original_number << "\n";
cout << "The reversed number is " << reverseNumber(original_number) << "\n";
return 0;
}
Output :
Explanation :
In the above code, the function reverseNumber takes the input of an integer number
and returns the reverse of the number. We extract each digit from the end and
append it to the new number.
“[()]{}{[()()]()}”
Output :
Balanced
Input:
[[
Output:
Not Balanced
Approach:
We create a character stack and now look through the expression string. If the
current character is a beginning bracket ('(', ", or '['), stack it. If the current character
is a closing bracket (') or " or ']'), pop from the stack; if the popped character is the
matching starting bracket, all is well; otherwise, the brackets are unbalanced. If some
starting brackets remain in the stack a er traversal, the stack is said to be
"unbalanced."
Code:
#include <bits/stdc++.h>
using namespace std;
switch (str[i]) {
case ')':
top_element = char_stack.top();
char_stack.pop();
if (top_element == '{' || top_element == '[')
return false;
break;
case '}':
top_element = char_stack.top();
char_stack.pop();
if (top_element == '(' || top_element == '[')
return false;
break;
case ']':
top_element = char_stack.top();
char_stack.pop();
if (top_element == '(' || top_element == '{')
return false;
break;
}
}
int main()
{
i "[]{}()"
Page 44 © Copyright by Interviewbit
SDET Interview Questions
Output :
Balanced
Explanation:
In the above code, we create a function checkBalancedExpression which takes the
input of an expression string and checks whether the string is balanced or not. We
start traversing the expression. Whenever we encounter an opening bracket, we push
it in the stack. In the case of a closing bracket, we first check if the stack is empty or
not. If it is empty, we directly return false otherwise, we check if the top element has
the corresponding opening bracket or not.
Output:
120
In practically all interviews, factorial is one of the most frequently asked questions
(including developer interviews) Developer interviews place a greater emphasis on
programming concepts such as dynamic programming, recursion, and so on,
whereas So ware Development Engineer in Test interviews place a greater emphasis
on handling edge scenarios such as max values, min values, negative values, and so
on, and approach/efficiency becomes secondary.
The following recursive formula can be used to calculate factorial.
n! = n * (n-1)!
n! = 1 if n = 0 or n = 1
Code:
#include <bits/stdc++.h>
using namespace std;
int main()
{
int number = 5;
if(number < 0)
{
cout << "Negative numbers do not have factorial" << "\n";
return 0;
}
cout << "Factorial of " << number << " is " << findFactorial(number) << “\n”;
return 0;
}
Output:
Factorial of 5 is 120
Explanation:
In the above code, the function findFactorial finds the factorial of a given input
number. Before making the function call, we check if the given number is negative.
Negative numbers do not have a factorial and so we must display appropriate
messages for it.
Output:
12, 3, 9
Explanation:
The array contains a triplet (12, 3 and 9) whose sum is 24.
Input:
Output:
5, 3, 1
Explanation:
There is a triplet (5, 3 and 1) present in the array whose sum is 9.
Approach:
The algorithm's performance can be increased by sorting the array. The two-pointer
technique is used in this effective method. Fix the first element of the triplet by
traversing the array. Find if there is a pair whose total equals x – array[i] using the Two
Pointers technique. Because the two pointers approach takes linear time, it is
preferable to a nested loop.
Code:
#include <bits/stdc++.h>
using namespace std;
//Fixing the first element one by one and finding the other two elements
for (int i = 0; i < arr_size - 2; i++) {
// Start two index variables from opposite corners of the array and move them to
low = i + 1; // index of the first element in the remaining elements
int main()
{
int arr[] = { 12, 3, 4, 1, 6, 9 };
int sum = 24;
int arr_size = sizeof(arr) / sizeof(arr[0]);
return 0;
}
Output:
Explanation:
In the above code, the function findTriplet takes the input of an array, the size of the
array and the sum required. First of all, we sort the array given. We traverse the array
elements and fix the first element of the triplet in each iteration. We use a two-
pointer approach and find the remaining two elements of the triplet, if it is possible
with the given array.
Useful Resources:
QA Interview Questions
Automation Testing Interview Questions
API Testing Interview Questions
Selenium Interview Questions
So ware Development Engineer: Career Guide
Css Interview Questions Laravel Interview Questions Asp Net Interview Questions