DEV Community: Madhu0212

Real-Time Manual Testing Interview Questions

Madhu0212 — Mon, 25 Sep 2023 05:41:49 +0000

The realm of testing encompasses a wide variety of aspects and this is what makes it so fascinating. As soon as you develop a software application, it goes through several stages of testing, which are all integral to its success. Depending on the requirements, tests can be functional or non-functional. Testing can be performed in two ways, either manually by executing test cases as stated in the written test plan or automated by using frameworks such as Selenium WebDriver.

Even though agile software development increasingly demands test automation, manual testing cannot be avoided. A manual test refers to a process in which a Quality Assurance specialist manually tests a software application in order to detect bugs. Any test strategy should include manual testing since it helps QAs gain a deeper understanding of the end user's perspective.

The most important metric in manual testing is user experience, as it is carried out by a human instead of an automated test framework. Manual testing can be a good way to determine how well web elements render, whether an application is easily navigable, and other aesthetic aspects relevant to end users.

Here, we will outline and discuss the most commonly asked real-time interview questions on manual testing provided by practitioners in the field of Manual Testing. This article will also provide readers with a better understanding of why manual testing can never be completely avoided.

Real-Time Manual Testing Interview Questions

Q1. How should test cases be written?

Sol: Here are the best practices for writing test cases:

Create test cases from the end user's perspective.
Test steps should be written in a way that anyone can easily follow.
Create reusable test cases.
Set a priority for the task.
Include a test case description, test data, expected result, preconditions, and postconditions.
The invalid test cases should be written along with the valid test cases.
Ensure proper naming conventions are followed.
Regularly review and update the test cases.

Q2. When should manual testing be preferred over automation testing?

Sol: In many cases, manual testing is more suitable than automation testing, such as:

Projects with a short deadline: Although automated tests are designed to save time and resources, they require effort and resources to design and maintain. In the case of a small promotional website, manual testing can be more efficient than automated testing.
Exploratory Test: It is important for a tester to possess knowledge, analytical skills, logical skills, creativity, experience, and intuition for this type of testing. It is therefore important for exploratory testing to involve human involvement.
Ad-hoc Testing: Ad-hoc testing does not follow a specific approach. An ad-hoc testing method is completely unplanned and relies completely on the knowledge and insight of the tester. Manual testing can be used to achieve this.
Usability Testing: In usability testing, the tester determines whether a product or software is user-friendly, efficient, or convenient for end users. Since human observation is the most important factor, manual testing seems the most appropriate method.

Q3. Is there a way to test software if it is so buggy that it cannot be tried at all?

Sol: Many times, testers encounter a bug that cannot be fixed. The best course of action is for testers to report any bugs or blocking-type problems that appear at the beginning, concentrating on critical bugs. Managers should be informed and provided with proof of the problem, as this type of issue can result in serious issues such as inadequate integration testing or insufficient unit testing, improper build, poor design, release procedures, etc.

Q4. When the requirements have not been frozen, how should a product be tested?

Sol: For some products, a requirement stack may not be available. Identifying unexpected functionality in an application may take some effort, and it would indicate deeper issues. It is advisable to remove functionality if it is not necessary for the application's purpose. Alternatively, create a test plan based on the assumptions you have made about the product. It is important, however, that all assumptions in the test plan are well documented.

Q5. How do you handle the situation when an organization is growing too fast to allow for fixed testing processes? In such cases, what should be done?

Sol: This is an increasingly common problem in the software industry, especially with the introduction of new technologies in product development. A simple solution to this problem would be to:

Invest in good and skilled employees.
Maintain an intense focus on the customer while 'ruthlessly prioritizing' quality issues.
There should be a clear understanding among all employees of what "quality" means to the end user.

Q6. How do you decide whether automated testing is better than manual testing?

Sol: In the following circumstances, automated testing is more appropriate than manual testing:

Periodic testing is required.
Standard runtime environments are required for testing.
Tests involve repetitive steps.
The testing phase must be completed within a shorter timeframe.
In situations where a large amount of code needs to be tested repeatedly.
All executions require reports.

Q7. Is automation testing capable of replacing manual testing?

Sol: Neither automation testing nor manual testing can replace the other. Even if automated tests are good, you can't automate everything. Software development relies heavily on manual tests, which are useful whenever automation is not possible. Each method of testing, whether automated or manual, has its own strengths and weaknesses. By conducting manual tests, we can gain a better understanding of the entire problem and be more flexible in exploring other angles of tests. Meanwhile, automated testing saves time in the long run by automating a large number of surface-level tests quickly.

Q8. In manual testing, what role does documentation play?

Sol: To achieve effective software testing, documentation is essential. Detailed information such as requirements specifications, designs, business rules, configurations, code changes, test plans, bug reports, test cases, user manuals, and more should all be documented. Having the test cases documented will enable you to estimate the amount of testing effort that will be needed, along with coverage and tracking requirements. The following artifacts make up software testing documentation:

Test Plan
Test Scenario
Test Case
Traceability Matrix

Q9. Describe the concept of test closure.

Sol: The Test Closure document summarizes all the tests that were performed during the software development life cycle, as well as gives a detailed analysis of the bugs that were fixed and errors that were discovered. Among the information included in this memo are the aggregate number of experiments, the total number of experiments executed, the number of imperfections settled, discovered, and rejected, as well as the number of bugs not settled.

Q10. What method will you use to determine when the testing should be stopped?

Sol: It can be challenging to determine when to stop testing. The complexity of many modern software applications and the interdependency of their environments make it impossible to test them thoroughly. Among the factors to consider when deciding to stop testing are:

The deadlines (such as the release date, the testing deadline, etc.)
Test cases passed with a certain percentage.
The testing budget has run out.
The code coverage or functionality coverage reaches a specified point.
Bug rates drop below a certain threshold.
Upon completion of Beta or Alpha testing.

Q11. Can you explain black box testing and the various approaches it uses?

Sol: Known also as specification-based testing, black-box testing analyzes software/application functionality without knowing much about its internal structure or design. It is designed to verify that the system works properly and meets the user's needs as a whole. There are various black-box testing techniques, including:

Equivalence Partitioning
Use Case Testing
Decision Table-Based Technique
Boundary Value Analysis
Cause-effect Graphing

Q12. Can you explain what experience-based testing is?

Sol: As the name implies, experience-based testing is all about discovering, investigating, and learning from the experience. As a tester, you constantly study and analyze the product, and accordingly develop test strategies and test cases based on your experience, traits, and skills. Among the various techniques used for experience-based testing are:

Exploratory Testing
Error Guessing

Conclusion

Let's wrap it up, folks! Having covered the majority of the ‘Manual Testing Interview Questions, we have come to the end of this article. After you have read all these manual testing interview questions, you will have a clear idea of what most candidates will face during the interview. Therefore, we suggest you go through all those questions and try to answer them as much as you can.

Having prior knowledge of various manual testing or software testing concepts is highly recommended. Most of these manual testing interview questions focus on fundamental concepts, such as testing case development, black-box testing, and error guessing.

Longest Increasing Subsequence in Python

Madhu0212 — Thu, 17 Aug 2023 14:10:05 +0000

The Longest Increasing Subsequence (LIS) problem is a well-known problem in computer science and is used to find the longest subsequence of a given sequence in which the elements are in sorted order, from lowest to highest. In other words, it is the problem of finding a subsequence of a given sequence in which the subsequence's elements are sorted in increasing order, and in which the subsequence is as long as possible.

For example, consider the sequence [3, 10, 2, 1, 20]. A possible longest increasing subsequence of this sequence is [3, 10, 20], which has length 3.

The LIS problem has a number of important applications, including data compression, gene sequence analysis, and natural language processing. It is a classic problem that has been studied extensively and has several efficient algorithms for solving it.

In this blog, we will discuss two approaches for solving the LIS problem: a recursive approach and a dynamic programming (DP) approach. We will also implement these solutions in Python and compare the time complexity of the two approaches.

Understanding the LIS problem with an example

To understand the LIS problem better, let's consider the following example. Suppose we are given the sequence [5, 6, 7, 1, 2, 8]. The longest increasing subsequence of this sequence is [1, 2, 8], which has length 3.To find the longest increasing subsequence, we can follow a step-by-step approach as follows:

Begin by considering the first element of the sequence, which is 5. There is no increasing subsequence starting with 5, so we move on to the next element.
Consider the second element of the sequence, which is 6. There is no increasing subsequence starting with 6 either, so we move on to the next element.
Consider the third element of the sequence, which is 7. There is no increasing subsequence starting with 7 either, so we move on to the next element.
Consider the fourth element of the sequence, which is 1. There is an increasing subsequence starting with 1, which is [1].
Consider the fifth element of the sequence, which is 2. There is an increasing subsequence starting with 2, which is [2].
Consider the sixth element of the sequence, which is 8. There is an increasing subsequence starting with 8, which is [8].

Now, we need to find the longest increasing subsequence that includes elements from the entire sequence. We can do this by combining the increasing subsequences that we found in the previous steps. The longest increasing subsequence is [1, 2, 8], which has length 3.

This is one way to solve the LIS problem. In the following sections, we will discuss two more efficient approaches for solving the LIS problem: a recursive approach and a dynamic programming approach.

Recursive approach to solving the LIS problem

One way to solve the LIS problem is by using a recursive approach. In this approach, we try to find the longest increasing subsequence for each element of the sequence, and then return the longest of these subsequences.

To do this, we can define a recursive function lis(arr, n) that takes in a sequence arr and an integer n, which represents the length of the sequence. The function returns the length of the longest increasing subsequence ending at index n.

The function can be implemented as follows:

def lis(arr, n):
  if n == 0:
    return 1
  max_ending_here = 1
  for i in range(n):
    res = lis(arr, i)
    if arr[i] < arr[n] and res + 1 > max_ending_here:
      max_ending_here = res + 1
  return max_ending_here

Let's understand how this function works. The base case of the function is when n is equal to 0, in which case we return 1. This is because a single element is always a valid increasing subsequence.

For the recursive case, we consider each element i from 0 to n-1. For each element, we calculate the length of the longest increasing subsequence ending at index i by calling the lis function recursively. If the element at index i is less than the element at index n and the length of the subsequence ending at index i plus 1 is greater than the maximum ending here, we update the maximum ending here to be the length of the subsequence ending at index i plus 1.

Finally, we return the maximum ending here as the length of the longest increasing subsequence ending at index n.

To find the longest increasing subsequence of the entire sequence, we can call the lis function with the length of the sequence as the second argument. For example, to find the longest increasing subsequence of the sequence [5, 6, 7, 1, 2, 8], we can call lis([5, 6, 7, 1, 2, 8], 5), which will return the length of the longest increasing subsequence ending at index 5, which is 3.

This recursive approach is simple to implement, but it has a time complexity of O(2^n), which is not very efficient for large sequences. In the next section, we will discuss a more efficient approach called dynamic programming, which has a time complexity of O(n^2).

Dynamic Programming approach to solving the LIS problem

The dynamic programming (DP) approach to solving the LIS problem involves breaking the problem down into smaller subproblems and storing the solutions to these subproblems in a table. This allows us to avoid recalculating the solutions to subproblems and reduces the overall time complexity of the solution.

To implement the DP approach, we can define a function lis(arr, n) that takes in a sequence arr and an integer n, which represents the length of the sequence. The function returns the length of the longest increasing subsequence ending at index n.

The function can be implemented as follows:

def lis(arr, n):
  dp = [1] * n
  for i in range(1, n):
    for j in range(i):
      if arr[i] > arr[j] and dp[i] < dp[j] + 1:
        dp[i] = dp[j] + 1
  return max(dp)

Let's understand how this function works. We start by initializing a list dp with n elements, all set to 1. This list will store the lengths of the longest increasing subsequences ending at each index.

Next, we iterate over the elements of the sequence, starting from the second element (index 1). For each element, we iterate over the elements before it (from 0 to i-1). If the element at the current index i is greater than the element at index j and the length of the longest increasing subsequence ending at index i is less than the length of the longest increasing subsequence ending at index j plus 1, we update the value at index i in the dp list to be the length of the longest increasing subsequence ending at index j plus 1.

Finally, we return the maximum value in the dp list, which is the length of the longest increasing subsequence ending at any index.

To find the longest increasing subsequence of the entire sequence, we can call the lis function with the length of the sequence as the second argument. For example, to find the longest increasing subsequence of the sequence [5, 6, 7, 1, 2, 8], we can call lis([5, 6, 7, 1, 2, 8], 6), which will return the length of the longest increasing subsequence ending at any index, which is 3.

The time complexity of this DP approach is O(n^2), which is much more efficient than the recursive approach for large sequences.

Implementing the LIS solution in Python

Here is the complete Python code for implementing the LIS solution using the dynamic programming approach:

def lis(arr, n):
  dp = [1] * n
  for i in range(1, n):
    for j in range(i):
      if arr[i] > arr[j] and dp[i] < dp[j] + 1:
        dp[i] = dp[j] + 1
  return max(dp)

# Test the function
arr = [5, 6, 7, 1, 2, 8]
n = len(arr)
print(lis(arr, n))  # Output: 3

This code first defines the lis function, which takes in a sequence arr and an integer n and returns the length of the longest increasing subsequence ending at any index. The function uses the DP approach, as described in the previous section.

Next, the code tests the function by calling it with the sequence [5, 6, 7, 1, 2, 8] and the length of the sequence as the arguments. The output is 3, which is the correct length of the longest increasing subsequence of the given sequence. You can try the function with other sequences as well to test its correctness.

Comparison of the time complexity of the recursive and DP approaches

The time complexity of the recursive approach to solving the LIS problem is O(2^n), while the time complexity of the dynamic programming (DP) approach is O(n^2). This means that the DP approach is much more efficient for large sequences, as it has a lower time complexity.

To understand why the DP approach has a lower time complexity, let's consider an example. Suppose we are given the sequence [5, 6, 7, 1, 2, 8] and we want to find the length of the longest increasing subsequence.

Using the recursive approach, we need to consider every possible subsequence and check if it is increasing. This involves a lot of recursive calls, and the number of calls grows exponentially with the size of the sequence. For a sequence of length n, the number of recursive calls is 2^n, which is why the time complexity of the recursive approach is O(2^n).

On the other hand, using the DP approach, we can store the solutions to subproblems in a table and avoid recalculating them. This reduces the number of calculations we need to do, and the time complexity becomes O(n^2), which is much more efficient for large sequences.

In general, the DP approach is preferred over the recursive approach for solving problems that involve overlapping subproblems, as it is more efficient in terms of time complexity. However, the recursive approach may be easier to implement and may be preferred in some cases.

Applications of the LIS problem in real-world scenarios

The Longest Increasing Subsequence (LIS) problem has a number of important applications in real-world scenarios. Some of the applications of the LIS problem are:

Data compression: The LIS problem can be used to compress data by finding the longest increasing subsequence of a sequence of data and storing only the subsequence instead of the entire sequence. This can save storage space and reduce the time required to transmit or process the data.
Gene sequence analysis: The LIS problem can be used to analyze gene sequences and find patterns in the data. For example, it can be used to find the longest increasing subsequences of gene expression data, which can help identify genes that are related to certain traits or conditions.
Natural language processing: The LIS problem can be used in natural language processing (NLP) tasks, such as machine translation and text summarization. For example, it can be used to find the longest increasing subsequences of words in a sentence, which can help identify the main ideas or themes in the text.
Scheduling: The LIS problem can be used in scheduling tasks, such as scheduling jobs or classes. For example, it can be used to find the longest increasing subsequence of time slots that are available for scheduling, which can help identify the best time slots to schedule tasks.

Overall, the LIS problem has many important applications in a variety of fields, including computer science, biology, and natural language processing.

Conclusion

In this blog, we discussed the Longest Increasing Subsequence (LIS) problem, which is the problem of finding the longest subsequence of a given sequence in which the elements are in sorted order, from lowest to highest. We also discussed two approaches for solving the LIS problem a recursive approach and a dynamic programming (DP) approach. We implemented these solutions in Python and compared the time complexity of the two approaches.

We also discussed the applications of the LIS problem in real-world scenarios, such as data compression, gene sequence analysis, and natural language processing.

To learn more about the LIS problem, you can refer to the following resources:

Wikipedia page on the LIS problem: https://en.wikipedia.org/wiki/Longest_increasing_subsequence
Cormen et al. (2009). Introduction to Algorithms, Third Edition. MIT Press. Chapter 15: Dynamic Programming. (Chapter 15 covers the LIS problem in detail)