DEV Community: Jayachandran V

What is significance of the python virtual environment? Give some examples in support of your answer

Jayachandran V — Thu, 13 Jun 2024 18:24:52 +0000

The short answer is this:
A directory with a particular file structure. It has a bin subdirectory that includes links to a Python interpreter as well as subdirectories that hold packages installed in the specific (venv). virtual environment’s are Python’s way of separating dependencies between projects. therefore, the Ruby's bundler or Javascript's npm come with its features built in, python package manager pip, does not.

The Python have few common use cases for a virtual environment:

You’re developing multiple projects that depend on different versions of the same packages, or you have a project that must be isolated from certain packages because of a namespace collision. This is the most standard use case.
You’re working in a Python environment where you can’t modify the site-packages directory. This may be because you’re working in a highly controlled environment, such as managed hosting, or on a server where the choice of interpreter (or packages used in it) can’t be changed because of production requirements.
You want to experiment with a specific combination of packages under highly controlled circumstances, for instance to test cross-compatibility or backward compatibility.
You want to run a “baseline” version of the Python interpreter on a system with no third-party packages, and only install third-party packages for each individual project as needed.
Nothing says you can’t simply unpack a Python library into a subfolder of a project and use it that way. Likewise, you could download a standalone copy of the Python interpreter, unpack it into a folder, and use it to run scripts and packages devoted to it.

But managing such cobbled-together projects soon becomes difficult. It only seems easier to do that at first. Working with packages that have binary components, or that rely on elaborate third-party dependencies, can be a nightmare. Worse, reproducing such a setup on someone else’s machine, or on a new machine you manage, is tricky.

Benefits:

You can have multiple environments, with multiple sets of packages, without conflicts among them. This way, different projects’ requirements can be satisfied at the same time.
You can easily release your project with its own dependent modules.

Examples:
Here are two ways you can create Python virtual environments.

Virtualenv:
It is a tool used to create isolated Python environments. It creates a folder which contains all the necessary executables to use the packages that a Python project would need.
you can install it with pip: pip install virtualenv

Verify the installation of following command: virtualenv --version

We can create Virtual environment in Visual studio code can do this when the Python extension is enabled and pycharm ide in both windows and Linux platform. Many Python IDEs will automatically detect and activate a virtual environment if one is found in the current project directory. Visual Studio Code, Opening a terminal inside Visual Studio Code will automatically activate the selected virtual environment. PyCharm automatically creates a virtual environment for each new project.

Activate the Python virtual environment

Before you can use this virtual environment, you need to explicitly activate it. Activation makes the virtual environment the default Python interpreter for the duration of a shell session.

You’ll need to use different syntax for activating the virtual environment depending on which operating system and command shell you’re using.

On Unix or MacOS, using the bash shell: source /path/to/venv/bin/activate
On Unix or MacOS, using the csh shell: source /path/to/venv/bin/activate.csh
On Unix or MacOS, using the fish shell: source /path/to/venv/bin/activate.fish
On Windows using the Command Prompt: path\to\venv\Scripts\activate.bat
On Windows using PowerShell: path\to\venv\Scripts\Activate.ps1

Install Packages
You can install packages one by one, or by setting a requirements.txt file for your project.

pip install some-package
pip install -r requirements.txt
If you want to create a requirements.txt file from the already installed packages, run the following command:

pip freeze > requirements.txt
The file will contain the list of all the packages installed in the current environment, and their respective versions. This will help you release your project with its own dependent modules.

Deactivate an Environment
If you are done working with the virtual environment you can deactivate it with:

deactivate
This puts you back to the system’s default Python interpreter with all its installed libraries.

Delete an Environment
Simply delete the environment folder.

Describe the Python Selenium architecture in detail?

Jayachandran V — Thu, 13 Jun 2024 18:15:50 +0000

Python Selenium Architecture:

The architecture of Selenium with Python involves multiple components working together to automate browser interactions with web browsers. Here is a detailed description of the Python Selenium architecture. Selenium is an open source framework that has been designed for the automation testing for web applications. It is a flexible testing tool that allows the automation tester to write testing scripts in Selenium and in various programming languages such as Python, Java, etc., Detailed description of the key elements in the Python Selenium architecture given below:

1.Selenium Webdriver:

At the core of the architecture is the Selenium WebDriver, which is responsible for interacting with web browsers. It provides a set of APIs (Application Programming Interfaces) that allows communication between Python scripts and the web browser.

The WebDriver acts as a bridge between the testing framework (Python) and the browser, enabling the automation of browser actions.

Selenium Webdriver comprises of four major components:

Selenium client libraries:

JSON wire protocol:

Webdrivers:

Operating system browsers:

Python script:

The automation scripts are written in Python and utilize the Selenium WebDriver APIs. These scripts define the sequence of actions to be performed on the web browser, such as opening a webpage, clicking elements, filling forms, and extracting data.

Python serves as the programming language for creating and executing the automation scripts.

Browser driver:

Each web browser (e.g., Chrome, Firefox, Edge) requires a specific driver to establish a connection with the Selenium WebDriver. These drivers act as intermediaries, translating WebDriver commands into browser-specific actions. For example, ChromeDriver is used with the Chrome browser, and GeckoDriver is used with Firefox.

4.JSON Wire protocol:

The JSON Wire Protocol is a RESTful web service protocol that enables communication between the Selenium WebDriver and the browser driver. It defines a standardized way to exchange data and commands, allowing for cross-browser compatibility.

Web Browser:

The web browser is the application being automated. Selenium supports various browsers, and the automation scripts define interactions with the browser, such as opening URLs, interacting with elements, and navigating between pages.

Here’s a simplified flow of how these components interact during a typical Selenium automation process:

The Python script sends commands to the Selenium WebDriver.
The WebDriver communicates with the browser driver using the JSON Wire Protocol.
The browser driver translates the WebDriver commands into actions performed by the browser.
The browser executes the actions and sends the results back to the WebDriver.
The Python script receives the results and continues with the automation flow.
It’s important to note that Selenium WebDriver and the browser driver must be compatible in terms of versions and functionality to ensure seamless communication.

The Python Selenium architecture allows for the automation of web browser interactions, making it a powerful tool for web testing, scraping, and other automation tasks. The flexibility of Selenium, combined with the simplicity of Python scripting, makes it a popular choice for developers and testers in the automation space.

Significance of python virtual environment:

The Python Virtual Environment (often referred to as “virtualenv” or “venv”) is a crucial tool for managing dependencies in Python projects. It provides an isolated environment where you can install and manage packages independently of the global Python installation.

Isolation of Dependencies: Virtual environments create isolated spaces for Python projects. Each project can have its own virtual environment, preventing conflicts between different projects that might require different package versions.

Dependency Management: It allows you to manage dependencies for each project independently. You can install specific versions of packages without affecting the global Python environment.

Version Compatibility: Virtual environments help ensure that a project works with specific versions of packages. This is crucial for maintaining version compatibility and avoiding unexpected issues.

Clean Project Setup: It keeps the project directory clean by containing all dependencies within a specific folder. This makes it easier to share or transfer projects without including unnecessary global dependencies.

Ease of Deployment: Virtual environments simplify the deployment process.

Testing and Development Isolation: Virtual environments enable developers and testers to work in isolated environments. Changes made to one project’s dependencies do not impact others, promoting a clean and controlled development and testing environment.

The significance of Python Virtual Environments lies in their ability to provide isolation, manage dependencies, ensure version compatibility, maintain a clean project setup, simplify deployment, and support controlled testing and development environments. These benefits contribute to more reliable and reproducible Python projects.

Example:

Let’s you have two projects, Project A and Project B, and they both require different versions of a particular library, “mylibrary.” Without virtual environments, you might run into conflicts. However, with virtual environments, you can create individual environments for each project: For Project A:
Create a virtual environment for Project A.
Install “mylibrary” version 1.0.
Project A executes with this specific version of “mylibrary.”

For Project B:
Create a virtual environment for Project B.
Install “mylibrary” version 2.0.
Project B executes with this specific version of “mylibrary.”

This way, Project A and Project B can coexist on the same system without interfering with each other’s dependencies.

What is Selenium? Why do we use Selenium for automation?

Jayachandran V — Sun, 09 Jun 2024 21:25:09 +0000

 Selenium is a automation tool used for web application testing. It is a popular open source testing tool. Selenium enables testers to write automated tests in various programming languages to test the functionality of web applications. It can be run in many different browsers and operating systems. It can be used to test the functionality of web applications on various browsers and operating systems. Selenium Software Testing is a great way to automate your web application testing.

Components of Selenium

Selenium is a collection that consists of three major components:

Selenium IDE: Selenium IDE is a Firefox add-on that enables testers to record and playback the recorded automated tests. Selenium IDE is easy to use and lets you create and run automated tests quickly. Selenium IDE Chrome also includes a built-in debugger that enables you to troubleshoot your tests. To use Selenium IDE, you first need to install the Selenium add-on for Firefox or Chrome. You can then open Selenium IDE by clicking on the "Selenium" icon in the Firefox or Chrome toolbar.

Once the Selenium IDE is open, then you can start recording your tests by clicking on the "Record" button. Selenium will then begin recording all of your actions as you perform them in the browser. To stop the test recording, click on the "Stop" button. You can then playback your tests by clicking on the "Play" button. Selenium will then replay all of the actions that you recorded.

Selenium WebDriver: The Selenium WebDriver is an open-source tool used for automating web browser interaction from a user perspective. With it, you can write tests that simulate user interactions with a web application. It is available for many different programming languages, such as Java, C#, Python, and Perl.

WebDriver provides a powerful and flexible test automation framework that enables you to create automated tests for your web applications easily. It also includes several over-the-top features, such as automatically discovering elements on a web page and capturing screenshots of your tests.

Selenium Grid: The Selenium Grid distributes your tests across multiple machines or virtual machines (VMs). Selenium Grid enables you to test parallelly on various devices or VMs, allowing you to scale your test automation quickly. Selenium Grid is a crucial part of the overall Selenium testing suite and will enable you to execute your automated tests much faster. The Selenium Server is a part of Selenium Grid that can be installed locally on your device or hosted on a separate system/server.

Using Selenium for automation:
Testing is a vital part of the development cycle and is essential for ensuring the quality and stability of your applications. By performing application testing, you can find and fix bugs in your code before they have a chance to cause problems for your users. Additionally, application testing can help you verify that your application is working correctly on different browsers and operating systems.

Testing is performed in several ways, including manual, automated, and performance testing. Automated testing is a popular approach for performing application testing, as it enables you to test your applications quickly and efficiently. Selenium Testing is a popular tool for automated testing, as it allows you to write tests in various programming languages and run them on many different browsers and operating systems.

Benefits of Selenium Testing:

Efficient and accurate web application testing.
The ability to test your web application on multiple browsers and operating systems.
The ability to run more than one test at the same time.

You can significantly reduce your time to test your web application with a selenium grid. And by using a selenium grid, you can ensure that your web application is fully functional before releasing it to users. Therefore, if you want to improve your web application testing, consider using the selenium grid. Its one of the best ways to automate your web application testing.

The important things to keep in mind while writing Selenium tests.

The goal of our selenium test is to find the bugs in your web application.
your selenium test should be concise.
You should only use the selenium web driver when you are sure about how to use the tools and scripts

Once you have written your selenium test, you can run them on different browsers and operating systems. To do this, you will need to use a selenium grid. A selenium grid is a server that enables you to run multiple selenium tests simultaneously on different browsers and operating systems.

There are different types of Selenium tests that you can write. The most common types of selenium tests are

Unit Tests
Functional Tests
Integration Tests
Regression Tests
End-to-End Tests

Unit Tests

Unit Tests are the simplest type of Selenium tests. A Unit Test verifies that a single unit of code behaves as expected.

When writing a Unit Test, you should first create a test case. A test case is a set of instructions that tests a particular feature or function of your code. To create a test case, you will need to:

Define the expected outcome of the test.
Verify that the code under test behaves as expected.

Once your test case is written, you can run it using the WebDriver. Open your browser and go to the page where your test is located. Then, enter your test case into the browser's address bar and press "Enter." Your Unit Test should automatically run, and you will be able to see if the code under test behaved as expected.

Functional Test

Functional Tests are similar to Unit Tests, but they test the functionality f an entire web application. When writing a Functional Test, you should always keep in mind the following:

The goal of your Functional Test is to find bugs in all the functional components of your web application.
Your Functional Test should be concise but have to be written for each functional module of your app.
You should only use the WebDriver functional tests when all your components are passed from the development stage.

When writing a Functional Test, you will first need to identify the different areas of your web application that you want to test. Once you have selected these areas, you can create a test case for each one. Once your test cases are written, you can run them using the WebDriver. Open your browser and go to the page where your tests are located. Then, enter your test case into the browser's address bar and press "Enter." Your Functional Test should automatically run, and you will be able to see if the code under test behaved as expected.

Integration Tests

Integration Tests are used to test the integration between different parts of your web application. When writing an Integration Test, you should always keep in mind the following:

The goal of Integration Testing in Selenium is to find bugs in your web application that arise from integrating multiple components.
Your Integration Test should be short, and it should verify that all individual components work properly when integrated.

Regression Tests

Usually, regression suites include a huge number of test cases and it takes time and effort to execute them manually every time when a code change has been introduced. Hence almost every organization looks after automating regression test cases to reduce the time and effort. Choosing the right automation framework/ tool completely depends upon the application, technology used, testing requirements, and skill sets required for performing automation testing. It helps in automating functional and regression test cases that reduce the manual testing effort.

Automation completely depends on the framework that you choose to develop, and there is no such tool dedicated to performing only regression testing. The automation framework you select should be designed such that it supports regression testing effectively.

You can develop the regression suite for automation and keep adding new test scripts/test cases as and when required. Selenium Framework contains many reusable modules/functions that make it easy to maintain the existing code or add any new code.

End-to-End Tests
End-to-End Tests are used to test an entire web application from start to finish. When writing an end-to-end test, you should always keep in mind the following:

The goal of your End-to-End Test is to find bugs in your web application that arise as a result of the correlation between multiple components.
Your End-to-End Test should be concise, and it should verify that all individual components work properly when integrated.

Once your test cases are written, you can run them using the WebDriver. Open your browser and go to the page where your tests are located. Then, enter your test case into the browser's address bar and press "Enter." Your End-to-End Test should automatically run, and you will be able to see if the code under test behaved as expected.

Limitations of Selenium WebDriver
Although Selenium is one of the best tools for automating your tests on multiple devices, it still has limitations. Some of them are mentioned below:

WebDriver cannot interact with flash or Java applets.
WebDriver is not capable of handling complex animations.
WebDriver cannot recognize text inside images.
WebDriver has some difficulty dealing with dynamically generated pages.
WebDriver can be difficult to use when testing web applications that use Ajax or ReactJS.

Advantages of Selenium Automation Testing

Language Agnostic:
Selenium WebDriver offers native bindings for JavaScript, Python, Java, C#, and Ruby, eliminating the need to learn a new programming language solely for testing. While Selenium has its syntax, having proficiency in one of these languages proves beneficial.
Cross-Browser Compatibility:
Selenium communicates with browsers through drivers and is adaptable to different browser versions. With the appropriate driver, Selenium seamlessly supports significant browsers like Chrome, Firefox, Safari, Edge, and Opera.
Cross-Platform Compatibility:
Extending its versatility, Selenium is cross-platform compatible, allowing test creation on one platform and execution on another. It effortlessly functions across Windows, Mac OS, and various Linux distributions.
Community Support:
As an open-source tool with a substantial history, Selenium boasts a strong community. This support extends beyond regular updates and upgrades to encompass comprehensive documentation and a wealth of learning resources.
Integrations with Third Parties:
Selenium excels in integrations, providing the flexibility to extend functionality through third-party plugins. Users can leverage existing plugins or create custom ones to enhance Selenium's capabilities.
Parallel Test Execution:
Selenium supports parallel test execution across multiple machines, facilitated by Selenium Grid. This feature enables users to conduct tests simultaneously on various browsers and platforms, centralizing the management of browser configurations.

Drawbacks of Selenium Automation Testing

High Test Maintenance
No Build-in Capabilities
No Reliable Tech Support
Learning Curve

Difference between Functional Testing and Non Functional Testing? Give Some Examples

Jayachandran V — Fri, 22 Mar 2024 12:43:31 +0000

Functional Testing and Non functional testing

This type of testing verifies whether the specified functional requirements are met and the non functional testing used to test non-functional things

_Functional Testing Non functional testing
_
User View: Hacker View:

Can the user do this? Are Vulnerabilities in
the network infrastructure
operating system or
database system?

Does the feature work? Can the client(browser
etc.,) be manipulated?

Does the software meets the Is the server code robust?
users expectations?

At a component level Overall System

**Functional testing Vs Non functional Testing**

Mandatory Non Mandatory

Usually easy to define Usually more difficult to
define

It has been done before It will be done after
non functional testing functional testing completes

It is also called Behavioral Focus on the performance of
testing and focus on the the testing
underlying application

It can be done manually It is hard to do manually. It
through test cases can be usually need already existing
automated once application applications to measure and
is stable test application performance

Types of Functional testing Types of Non functional
includes Unit testing, Smoke testing includes volume
testing, Integration testing, testing, Load testing, stress
Regression testing, system testing, Recovery testing,
testing, User acceptance Scalability testing, Security
testing testing

Test data can be prepared Test data can be prepared
using the business or using the performance
functional requirements of requirements of the
the application application

Testing tool used for Testing tools used for non
functional testing includes functional testing includes
UFT(previously QTP), Jmeter, LoadRunner, Webload,
selenium, Ranorex, telerik Neoload, Loadcomplete
test studio, Micro focus,
sahi, testcomplete, IBM
rational

Example Test case: Example Test case: __

Test whether the user can Time required to load the
able to login to the application homepage

1) Authentication of user whenever 1) Emails should be sent
he/she logs into the system. with a latency of no greater
than 12hours from such an
activity.
2) System shutdown in case 2)The processing of each
of a cyber attack. request should be done
within 10 seconds
3) A Verification email is 3) The site should load in

sent to user whenever he/she 3seconds when the number
registers for the first time of simultaneous users are
on some software system. > 10000

Testing Techniques with Proper Examples: 1.Boundary value Analysis 2.Decision Table Testing 3.Use Case Testing 4.LCSAJ Testing

Jayachandran V — Fri, 22 Mar 2024 08:43:44 +0000

Software Testing has some techniques that can help you to design better test cases. Since exhaustive testing is not possible; Manual Testing Techniques help reduce the number of test cases to be executed while increasing test coverage. They help to identify the test conditions of software application otherwise difficult to recognize.

Software Testing is one of the important aspects of the development of software. Without proper testing, the software developed can be a big failure. Various Software Testing Techniques are available to carry out testing in a systematic way.

Boundary Value Analysis

Boundary value analysis is the process of testing between the extreme ends or boundaries between partitions of the input value.
Boundary value analysis is based on testing at the boundaries between the partitions. It includes maximum, minimum, inside or outside boundaries, typical values and error values.

It is generally seen that a large number of errors occur at the boundaries of the defined input values rather than the center. It is also known as BVA and gives a selection of test cases which exercise bounding values.

This technique focuses on boundaries as a greater number of errors occur at the boundaries of the input domain. For example, the programmer chooses < rather than =< which would lead to defects.

This black box testing technique complements equivalence partitioning. This software testing technique base on the principle that, if a system works well for these particular values then it will work perfectly well for all values which comes between the two boundary values.

Guidelines for Boundary Value analysis

If an input condition is restricted between values A and B, then the test cases should be designed with values A and B as well as values which are above and below A and B.

If an input condition is a large number of values, the test case should be developed which need to exercise the minimum and maximum numbers. Here, values above and below the minimum and maximum values are also tested. Apply guidelines 1 & 2 to get output conditions. It gives an output which reflects the minimum and the maximum values expected. It also tests the below or above values.

Input Values to be tested
Range (Between A & B) A-1, A, A+1,B,B+1,B-1

Number of Values Minimum Number, Minimum
number-1, Maximum number,
Maximum number+1

For Example:

Check the salary of a employee whose salary is maximum 15000 and minimum 10000

Boundary value specification will be:
{9999,10000,15000,15001}

Test Case

Test data Expected Result

9999 False
10000 True
15000 True
15001 False

Decision Table Testing

Decision table testing is also called as Cause-effect graphing. It uses different input conditions (cause) and their system results (output/effect) in a graph which is further converted into a tabular form. This technique provides a comprehensive representation of conditions and their actions therefore of cause and their effects.

Steps:

Causes (input conditions) & effects (actions) are listed for a module and a cause-effect graph is developed.
The graph is converted to a decision table.
The decision table is then converted to test cases.

Example:

If X stays at Y place. X has to pay rent to stay in Y house. If X does not have money to pay, then will have to leave the house.

Causes:
C1 – X stays at Y place.
C2 – X has money to pay rent.

Effects:
E1 – X can stay at Y place.
E2 – X has to leave the house.

Use Case Testing

Use Case represents the different ways in which the system can be used by the users. The use case divides the system behavior into scenarios, such that each scenario performs some useful action from the users point of view.

Each scenario may involve a single message or multiple message exchanges between the user and the system to complete itself.

Representation of Use cases:

A use case is represented with actors and systems. The actor represents the user. The system represents the use case.

Use Case Testing:

Use Case testing is a technique wherein the use cases identify all the test cases that cover the complete system.

Example:

When a new user tries to create an account on a travels website.

Main Success Scenario Step Description
A: Actor 1 A:Enters mobile no
S: System
2 S: Verifies mobile number &
asks to put OTP

3 A: Receives OTP and fill it
on the site.
4 S: Verifies OTP and asks to
put password

5 A: Puts the password
6 S: Verifies the password

7 A:clicks on sign up to
create a account

Extensions 2a Incorrect mobile number
A:clicks on sign up to
2b create a account
S: Displays message That
user already exists
4a Incorrect OTP
S: Asks to enter valid OTP
4b correct OTP
S:accepts & asks to provide
password
6a Password does not match the
criteria
S: Displays message
“Incorrect Password”

In first a positive scenario that carries end-to-end testing is tested. Therefore, complete scenario of creating an account is tested. Afterward, negative testing starts therefore if the mobile number is incorrect, the user will get a message for the same.

Once the user provides a correct mobile number, the system will send OTP to the users mobile number and the user will have to provide the same on the OTP field of the signup screen.

In case of incorrect OTP, the system asks to provide the correct OTP. Once correct OTP is provided, the system asks to fill the password, and the password should match the criteria defined and else it asks to fill the password again. Once the correct password is provided the system creates the users account by clicking sign up.

LCSAJ Testing

What is LCSAJ Testing?

The LCSAJ testing stands for "Linear Code Sequence and Jump".
this method requires access to the source code, and presents results with reference to that source code. This method of testing is an White box testing technique to identify the code coverage, Which begins at the start of the program or branch and ends at the end of the program or the branch.

LCSAJ is a program unit composed of textual code sequence that terminates in a jump to the beginning of another code sequence and jump.

LCSAJ characteristics:

100% LCSAJ means 100% statement Coverage
100% LCSAJ means 100% Branch Coverage
100% procedure or function call coverage
100% multiple condition coverage

Execution of sequential programs that contain conditions proceeds in pairs consisting of a sequence of statements executed one after the other and its termination by a jump to the next such pair.

An LCSAJ is represented as a triple X,Y,Z where X and Y are respective to the locations of the first and the last statements and Z is the location to which the statement at Y jumps. This generally we follow not with this movement indirectly through modified condition testing will add it certain specific industries or applications that report to have this, so this is a software
analysis method basically used to identify structural units in code under test. Its primary use is with dynamic software analysis top help answer the question how much testing is enough?

That means basically it will have an analysis of how much is tested?

In terms of dynamic software behavior or analysis, dynamic software analysis is used to measure the quality and efficacy of software test data, where the quantification is performed in terms of structural units of the code under test that is based on the structural unit and its behavior or the functionality the dynamic software analysis is used so it used to measure the quality
identification of the software test data. When used to quantify the structural units exercised the given set of test data, dynamic analysis is also referred to as coverage analysis. So when we are done with the dynamic analysis we will also come up with the coverage analysis, so that is how this is done basically to drive how much of the testing based on the test data is needed is what is been derived for the linear code sequence and jump testing.

Is basically an software code path fragment consisting of a sequence of code that means a linear code sequence followed by a control code jump in consist of the free items basically start of the linear sequence of executable segments at end of the sequence and target line in which the control flow is transferred at this end of this, suppose function 1, 2 I am just mentioning in
numbers like which one in number of function laws are executed by the fragments are there in the function. so what do we do with the LCSAJ basically how much are you test for this is what is going to
tell that is its basically code path, code path fragment I may test1, I may test 2, I may test some by randomly N 20 may be N. so that means consisting of sequence of code it is called linear code
sequence. And jumping to the different linear it is called jump control flow jump basically so what do we do.

Do you have a code path fragment?

Consistent of sequence of code linear code sequence followed by a control flow jump so we start with this and then we will have a control flow jump and basically the jump could be achieved with a following three types that is start, then end you know that we need to have end for the function in law and the target line. That means with the help of this target line how we have jumped to the end basically. That mean the target line each control flow is transferred at the end of the sequence, so with the help of this will basically used where we have numerous functionality having expected output and similar sort of inputs you have some of the functions so that is how you use the LCSAJ method. So in the continuation of this basically LCSAJ method will have the TER which is called the test effective ratio. So what is test effective ratio? It is number of statement executed by number of effective statements, number of control flow branches executed by total number of control flow branches they have number of LCSAJ executed by total number of LCSAJ.

Altogether you can have a TER that is effectiveness ratio how much of the code we have sequenced and jump in terms of
testing. So accordingly we will have this sort of testing and coverage also will take care of this, coverage or metrics are used to botch and hours testing has been achieved the most terrific metrics is proportion of statements test effective ratio1 TER1, is called as number of statements executed by total number of executive statements. Higher level coverage metrics can also be generated in particular thing.

The next level of TER control flow branches is in to whatever admission are branches that we have seen before you are right total number of control flow branches how much is there? So whether we are able to test it or we are able to free value the metrics, so this TER will give basically in the sequences whatever we have done, so TER 3 number of number of executive statements divided by total number of LCSAJ. So this metrics that is for the hierarchy whereby when the TER1 100% has been achieved it follow that TER2 should be 100% then TER 1 should be 100%, so I used to have TER1 as to be 100% so that the number of LCSAJ are executed by the total number of series become 100%. So this is been traditionally very old method so both the TER1 & 2 get results for 70 and the third results for the later 70. And the requirements actually for the TER1 100% was the level and used to be called TER and then they define TER1, TER2, TER3 like this levels of testing based mention based on the safety and embedded software they will have a definitions of the embedded software levels.

Later they have a MCDC modified condition decision coverage that we have studied in the numerous slides. So it was added 1992 higher levels of TER 3 100 has been mandatory for many other projects including aero space telephone and banking. So where there is a mandated TER3 should be 100% liners force sequence and jump is 100% mandatory when practical problem of using TER3 is that many LCSAJ can never be executed due to the conferencing condition they may contain.

We know that we have different jumps sequence that is start of the linear sequence of executive statement. And the target line to which control flow is transferred at the end of the executive statement, so it is basically it is the units in the map that executed all of them to subjective but it is mandatory.

It has oversight of that integer it counts 0 in what it does is while the count is less than iterations that means 750 times this block will be executed this value will be execute of some number and modules consume columns and total array will be assigned with 1 implemented if the total of the particular value is greater than maximum code it will assign the ledger count, the count will get
implemented so that up to 750 times it will be executed. Hence it will not be assigned. So with help of this example so there is a LCSAJ triples it is called as I said start fine finish line jump line, so there are eight LCSAJ numbers have been identified and start line is 10 or the first three or then we have the start line of 17 for the next three and then 7th one is 25 and the 8th one is 28. So based on this follows which there are LCSAJ numbers for that and total number of LCSAJ are 28.

The first one in LCSAJ then start line 10 is used and finish line is 17that means 10 is wiped after these values and 17 is the 28 positive last power backing. So within this what are going to
happen like assumed as one LCSAJ similarly we have 10 then 21 and finish line is 17 jump line is 28 that means it is 17 so this is a 10 set and we have 17 11, 12, 13, 14, 15, 16, 17 and the jumped line 28 So likewise we are going to have start line 17 and finish line 21 they draw a table so that is about LCSAJ understanding where the use the TER test effective ratio with help of the LCSAJ is the sequences where the sequence of executable when it starts and it ends and the target line with the control flow is getting targeted, so that is how they are going to test it. And you can see some of the table tasks about started line are the same.
Which is same here 28- 28 is same that is the last one written 0 is the same and the jump line that last program, similarly we have 17-17 the last line is 28. So that is how the key aspects will be
tested in the LCSAJ type of white box testing.

Examples:

int f1(int a, int b)
{
while(a!=b)
{
if(a>b)
a=2*(a-b);
else
b=3*(b-a);
}
return a;
}

LCSAJ Sequence Start sequence End Jump
1 1 3 10
2 9 11 Exit
3 1 5 7
4 7 9 3
5 3 3 9
6 1 6 3
7 1 6 3
8 3 5 7

What is Manual Testing? What are the benefits and drawbacks of Manual testing? Give some Examples in support of answer?

Jayachandran V — Thu, 21 Mar 2024 19:02:05 +0000

Manual Testing is a process to test the software where testers evaluate software or application quality manually. This type of testing method is a olden method to find the bugs, issues and defects in the software application without the help of automated tools or other executing test scripts.

The Manual Testers should has to find the bugs and defects using their creativity ideas and domain knowledge. But, it does require attention to detail and structured testing skills. The tester should play the role of end user where by the most of the application features to ensure correct behavior. These manual testing has to ensure that software applications meet the companies quality standard. The First step in manual testing is to analyze the requirements of software application system under test. This testing has some process given below.

Understanding the Requirements of the software
Test plan Creation
Write the test cases
Conduct the cases
Defect Logging
Defect fix
Reverification

Types of Manual testing

There are different types of manual testing based on how they are performed. We will discuss four common types here:

Functional Testing

Functional testing is a testing type to check the functional requirements and behavior of an application. It involves testing the individual functions and features of the software to ensure that they work correctly and meet the desired specifications. The main goal of functional testing is to validate that the application functions as intended and delivers the expected results. To conduct functional testing, you require full knowledge of functional specifications and input-output data. It further includes compatibility, regression, and integration testing within itself.

Black Box Testing

Black box testing focuses on testing the functionality and behavior of the software without knowing its internal structure, code or implementation details. The tester treats the application as a black box and they evaluate how the software handles various inputs and produces corresponding outputs.

User Acceptance Testing (UAT)

UAT focuses on evaluating the software’s functionality and usability from the end-user perspective. It involves testing the software in a real-world environment with actual users to ensure that it meets their requirements, business needs and expectations.

System Testing

System testing verifies and validates the behavior, functionality and performance of a complete and integrated software system. It is performed after component testing and integration testing ensuring that all system components work together as per expectations and meet the specified user requirements.

Benefits of Manual Testing

Cost Effective
More Flexibility
Useful for small and large projects
Easy to remove and add test cases
Easy for a fresher to implement
No need of Programming Experts
More reliable
Well able to identify underlying user issues
More focus on Complex problems
Lower cost in short term projects
Helpful in User Interface
Suitable for Exploratory, Usability and Ad hoc Testing
In Manual testing user/Tester, interacts more with the Application under test(AUT) then it easy to find defects and Tester can provide suggestions to the development team.

Drawbacks of Manual Testing

Maintaining Manual testers is expensive
Extremely Time consuming
Higher chances of Human Error
Not good for Performance testing
Considerable testing areas left uncovered
Less Accuracy
Executing same tests again and again time taking process
Not suitable for Large scale projects and time bounded projects
Graphical user interface object size difference and color combination etc., is not easy to find out in manual testing.
Actual load and performance is not possible to cover in manual testing for large number of users.
It is Platform dependent
Difficult to reuse
The Running Process is slow

Example of Manual testing

Testing the functioning of Shopping Cart
Validating the order process
Validating the Login page is working properly
Testing the correct data is displayed on the search results page
Testing the functioning of Ticket booking page
Validating the functioning of Online banking page
Validating the functioning of Bill payment page
Validating a Company Website and its product portfolio

End to end testing is the process of testing an entire software application, at the point at which you first open the software to completing all of the function with in it.

What is Software Testing?What we need to know about software testing?What is the relevance of Software testing?

Jayachandran V — Sat, 09 Mar 2024 15:15:39 +0000

Software testing is the process to identify the bugs in software or examining the behavior of the software by testing through verification and validation.

Verification: This process is to ensure that are we building the product right? The software should confirm to its specification.

Validation: This process is to ensure that are we building the product right? The software should do what the user really requires.

The Software testing is done by two methods as Manual and Automation. The main objective of this software testing is to compare the actual results of function results with the expected functionality and to ensure the software and its applications is bug free and ready for use.

The software tester should know the process to evaluate the functionality of a software application. A tester should have the intend to find the developed software meets the specified requirements or not. The tester has to identify the defects and to ensure that the product is defect free in order to provide a quality product.

The Software Company approach the client or Client company approach the Software company. The Software company first appoint the project manager. The project manager appoints the Domain specialists for various departments. The Domain specialist explain the project details and the client can modify or update or delete the project.

The project manager next call the technical designers. They implement the software development through SDLC (Software Development Life Cycle).
The SDLC has development phases given below:

First phase
Planning phase
High Level Design phase
Low Level Design phase
Coding Phase
Unit & Integration phase
System Testing phase
UAT (User Acceptance Testing)
Maintenance

To deliver a quality software product based on client requirements we need to have tested in the software development process. The benefits of the software testing is given below:

Cost effectiveness
Customer Satisfaction
User experience
Security
Product Quality

The Software Testing process is an equally integral part of development and planning.

There are Three types of testing methods:

White-box testing
Black-box testing
Grey-box testing

White-box testing:

The White-box testing is based on applications internal code structure. In white-box testing, an internal perspective of the system, as well as programming skills, are used to design test cases. This testing is usually done at the unit level.

Black-box testing:

Black Box Testing is a software testing method in which testers evaluate the functionality of the software under test without looking at the internal code structure.

Grey-box testing:

Grey box is the combination of both White Box and Black Box Testing. The tester who works on this type of testing needs to have access to design documents. This helps to create better test cases in this process.

The success of a project due to software testing in Software Engineering had some levels of testing.

Testing Levels:

1.Unit Testing
2.Integration Testing
3.System Testing
4.Acceptance Testing

Unit Testing:

Unit Testing is done to check if the individual modules of the source code are working properly. Therefore testing each and every unit of the application separately by the developer in the developers environment. It is Component Testing or AKA Module Testing.

Integration Testing:

Integration Testing is the process of testing the connectivity or data transfer between a couple of unit tested modules. It is String Testing or AKA I&T Testing.

System Testing:

Its a black box testing. Testing the full integrated application is also called as an end to end scenario testing. To ensure that the software works in all intended target systems. Verify thorough testing of every input in the application to check for desired outputs.

Acceptance Testing:

To obtain customer sign-off so that software can be delivered and payments received. 3 Types of Acceptance Testing are Alpha, Beta & Gamma Testing.

In most cases, the following professionals are involved in testing a system within their respective capacities:

1.Software Tester
2.Software Developer
3.Project Lead/Manager
4.End User

Finding bugs in a software is the task of the testers, but at the same time, they are domain experts of the particular software. Developers are only responsible for the specific component or
area that is assigned to them but testers understand the overall workings of the software, what the dependencies are, and the impacts of one module on another module.