Test Module Lead

Fuzz testing is a software testing technique in which a large amount of random data, called fuzz, is provided as input to the application simply to detect or discover security loopholes and coding errors in the software application. It is more useful for bigger projects but it only detects a serious fault or defect. It is simply used to check the vulnerability of software and gives more effective results when used with beta testing, black box testing, etc.

Agile testing is basically a software testing process that uses agile methodologies i.e., follow test-first design paradigm. It evaluates the software from the customer's point of view. It does not require any development team to complete coding for starting QA, instead of testing and coding can go hand in hand. Features are tested as they are developed. Some of its advantages include: 

1) Boosts the performance as it allows all the testers and developers to work together 
2) Features are tested as they are developed 
3) Ensure successful delivery of the high-grade product 
4) Saves time and money 
5) Flexible and highly adaptable to changes 
6) Improves product quality and allows developers to release software as early as possible

We may execute a single test from a set of tests in the Cucumber framework using the tags idea. This is found in the TestRunner file's @CucumberOptions section. With the use of the @t keyword, we may tag a scenario in the feature file. A scenario can have one or more tags within the feature file. We can separate test scenarios with the assistance of tagging. We must pass the value within the tags argument to execute a selected test in Cucumber, and we must pass the <~tagname> value within the tags parameter to exclude a test from running.

Cucumber is unconcerned about the names of your step definition files or the order in which you place them. Instead of maintaining all steps in a single file, we can create steps.rb file for each major action/feature. This is referred to as grouping.

Open-source testing tools, Selenium and Cucumber are both used for functional testing. However, there are some distinctions between them.

Here are some key distinctions between Selenium and Cucumber:

1) Cucumber is a behavior-driven development automation tool that may be used with Selenium. Selenium is a web browser automation tool for web projects (or Appium).

2) Cucumber is used for acceptance testing, while Selenium is used for automated UI testing.

3) Technical teams (SDETs/programmers) favour Selenium, while non-technical teams often choose Cucumber (business stakeholders and testers).

4) Cucumber isn't required for Selenium to work. Cucumber's step-definition implementation is based on Selenium or Appium.

5) The script creation with Selenium is complicated, whereas Cucumber is straightforward.

There are majorly three steps in the working of BDD. They are as follows:-

1) Behaviour Description: We list down the features of our application first in the feature file.

2) Making the Step Definition file: The mapping between each step of the scenario defined in the feature file and a code of the function to be executed is stored in the steps definition file.

3) Testing and running: We run the test cases to check if we pass. In general, a lot of failures are observed before achieving the final code.

Protractor is an open-source automated testing framework that allows you to perform end-to-end testing of your web applications. It’s built on top of WebDriverJS. Protractor is developed by Google and is especially used for testing Angular applications. 

Protractor runs the tests against the web application by running it in real web browsers. It also interacts with the application like an end-user would, e.g. clicking buttons, links, filling forms, etc., and verifying the result with the expected outcome.

Since Protractor is based on the Selenium WebDriver, it’s easy to perform cross-browser testing. It provides a simple API compared to Selenium, so the learning curve is not too steep. Developers can quickly get familiar with it and start writing the end-to-end UI tests. You can also take snapshots and compare them using Protractor. It also allows you to run parallel test cases on different machines.

It’s not possible to automate the testing of CAPTCHA. That is the goal behind any good CAPTCHA strategy. By definition, a computer can’t automate it. If it could, then it’s not a good challenge that you can use in your application.

However, if you need to test an application that uses CAPTCHA, you have to work with the development team to build a workaround or a back door that allows the automated test to bypass the CAPTCHA challenge. It’s important to restrict this workaround only in the test environment and not release it to production.

Here are some of the features to look for when selecting an automation tool:

i) Test Environment support, 
ii) Ease of use,
iii) Debugging features,
iv) Testing capabilities for various elements,
v) UI element identification features,
vi) Should allow database testing.,
vii) Should support multiple frameworks.

Algorithm : 
1) Define a string.
2) Define an array freq with the same size of the string.
3) Two loops will be used to count the frequency of each character. Outer loop will be used to select a character and initialize element at corresponding index in array freq with 1.
4) Inner loop will compare the selected character with rest of the characters present in the string.
5) If a match found, increment element in freq by 1 and set the duplicates of selected character by '0' to mark them as visited.
6) Finally, display the character and their corresponding frequencies by iterating through the array freq.

TC : O(N)
SC : O(1)

Pseudo Code : 

public class Frequency 
{ 
public static void main(String[] args) { 
String str = "CodingNinjas"; 
int[] freq = new int[str.length()]; 
int i, j; 


char string[] = str.toCharArray(); 

for(i = 0; i freq[i] = 1; 
for(j = i+1; j if(string[i] == string[j]) { 
freq[i]++; 

//Set string[j] to 0 to avoid printing visited character 
string[j] = '0'; 
} 
} 
} 


System.out.println("Characters and their corresponding frequencies"); 
for(i = 0; i if(string[i] != ' ' && string[i] != '0') 
System.out.println(string[i] + "-" + freq[i]); 
} 
} 
}

Tip 1 : The cross questioning can go intense some time, think before you speak.

Tip 2 : Be open minded and answer whatever you are thinking, in these rounds I feel it is important to have opinion.

Tip 3 : Context of questions can be switched, pay attention to the details. It is okay to ask questions in these round, like what are the projects currently the company is investing, which team you are mentoring. How all is the work environment etc.

Tip 4 : Since everybody in the interview panel is from tech background, here too you can expect some technical questions. No coding in most of the cases but some discussions over the design can surely happen.

If you get this question, it's an opportunity to choose the most compelling information to share that is not obvious from
your resume.

Example :

Strength -> I believe that my greatest strength is the ability to solve problems quickly and efficiently, which makes me
unique from others.

Ability to handle Pressure -> I enjoy working under pressure because I believe it helps me grow and become more
efficient.

Tip : Emphasize why you were inspired to apply for the job. You can also explain that you are willing to invest a great
deal of energy if hired.

These are generally very open ended questions and are asked to test how quick wit a candidate is. So there is
nothing to worry about if you have a good command over your communication skills and you are able to propagate
your thoughts well to the interviewer.