Forem: Thirunavukkarasu arunagiri

Python Virtual Environment

Thirunavukkarasu arunagiri — Thu, 01 Feb 2024 08:10:38 +0000

Python virtual Environment

The Python virtual environment is a crucial tool for managing dependencies and isolating project-specific libraries and configurations. Its significance lies in providing a controlled and self-contained environment for Python projects, which contributes to better project organization, dependency management, and reproducibility. Here are key reasons illustrating the significance of Python virtual environments, supported by examples:

Isolation of Dependencies:

Significance:
Virtual environments isolate project dependencies from the global Python environment, preventing conflicts between different projects that may require different library versions.

Example: Consider a scenario where Project A relies on Library X version 1.0, and Project B depends on Library X version 2.0. Using virtual environments, each project can have its own isolated environment, ensuring compatibility and avoiding version conflicts.

Reproducibility:

Significance:
Virtual environments aid in creating reproducible environments, ensuring that a project can be easily replicated on another machine with the same dependencies and configurations.

Example: A developer working on a team can share the project along with its virtual environment configuration file (e.g., requirements.txt). Colleagues can then recreate the exact environment by installing the specified dependencies, minimizing the chances of compatibility issues.

Simplified Dependency Management:

Significance:
Virtual environments simplify the management of project-specific dependencies by providing a clean environment where packages can be installed and updated without affecting the system-wide Python installation.

Example: An application may require specific versions of libraries. By creating a virtual environment and specifying these versions in a requirements file, developers can easily manage and replicate the required dependencies.

Facilitation of Testing and Development:

Significance:
Virtual environments support testing and development by allowing developers to experiment with different library versions, test new features, or isolate changes without affecting the stability of other projects.

Example: During the development phase, a developer may want to try out a pre-release version of a library. With a virtual environment, they can install and test the new version in isolation, ensuring it does not interfere with other projects using stable releases.

Ease of Deployment:

Significance:
Virtual environments simplify the deployment process by encapsulating the project's dependencies. This facilitates the creation of deployment artifacts that include the necessary dependencies, streamlining the deployment workflow.

Example: When deploying a web application, packaging the project with its virtual environment allows for consistent deployment across various servers or platforms, reducing the likelihood of deployment issues related to missing or incompatible dependencies.

Compatibility Across Platforms:

Significance:
Virtual environments enhance cross-platform compatibility by encapsulating the dependencies needed for a project, making it easier to migrate or share projects across different operating systems.

Example: A developer working on a project on a Windows machine can create a virtual environment, and by sharing the project's requirements file, a colleague using a macOS or Linux machine can recreate the same environment effortlessly.

In summary, the Python virtual environment plays a vital role in managing dependencies, ensuring project isolation, and promoting reproducibility. Examples across various scenarios illustrate its significance in simplifying development, testing, deployment, and collaboration on Python projects.

Python Selenium Architecture

Thirunavukkarasu arunagiri — Thu, 01 Feb 2024 07:49:42 +0000

Python Selenium Architecture

The Python Selenium architecture consists of several components that work together to enable the automation of web browsers. Below is a detailed description of the key elements in the Python Selenium architecture:

Selenium WebDriver:

Description:
The WebDriver is the core component of Selenium that facilitates communication between Python scripts and web browsers. It acts as an intermediary, sending commands to the browser and receiving responses.

Functionality:
Establishes a connection with the browser.
Sends commands for browser interactions (e.g., clicking, typing, navigating).
Retrieves information from the web page (e.g., element attributes, text).

Web Browser Drivers:

Description:
Web browser drivers are executable files specific to each browser (e.g., ChromeDriver for Google Chrome, GeckoDriver for Firefox). They act as intermediaries between the Selenium WebDriver and the respective browsers.

Functionality:
Receives commands from the WebDriver.
Interacts with the browser to execute commands.
Facilitates communication between the WebDriver and the browser.

Selenium Grid (Optional):

Description:
Selenium Grid is an optional component that allows for parallel test execution on multiple machines or browsers simultaneously. It helps distribute the test workload efficiently.

Functionality:
Manages multiple instances of WebDriver on different machines.
Enables parallel execution of tests across various browsers and platforms.

Selenium API:

Description:
The Selenium API provides a set of methods and functions that Python scripts use to interact with the WebDriver. It abstracts the complexity of browser interactions and allows developers to write high-level commands for testing.

Functionality:
Offers methods for navigating through web pages (e.g., opening URLs).
Provides functions for interacting with HTML elements (e.g., locating elements, clicking, typing).
Supports various browser-related actions (e.g., managing cookies, taking screenshots).

Python Script (Test Script):

Description:
The Python script, written by the user, contains the test scenarios and commands to be executed using Selenium. It utilizes the Selenium API to interact with the WebDriver and perform actions on the web browser.

Functionality:
Defines the sequence of actions for testing.
Utilizes Selenium API methods to interact with web elements.
Integrates with testing frameworks (e.g., pytest, unittest) for test organization and execution.

Browser:

Description:
The web browser is the application under test. Selenium interacts with the browser to simulate user actions and verify the behavior of web applications.

Functionality:
Renders web pages.
Executes JavaScript.
Responds to commands from the WebDriver.

Summary:
The typical flow of execution in the Python Selenium architecture involves the Python script sending commands through the Selenium API to the WebDriver. The WebDriver, in turn, communicates with the browser through the browser driver, triggering actions on the web page. The entire process enables automated testing of web applications, ensuring the reliability and functionality of the web-based software.

Selenium and its Automation

Thirunavukkarasu arunagiri — Thu, 01 Feb 2024 07:17:59 +0000

Selenium

Selenium is an open-source framework designed for automating web browsers. It provides a set of tools and libraries that aid in the development of automated testing and web application testing. Selenium supports various programming languages such as Java, Python, C#, Ruby, and others, making it versatile and widely adopted in the field of test automation.

The primary purpose of using Selenium for automation is to streamline and optimize the testing process of web applications. Here are key reasons

why Selenium is commonly employed in automation:

Cross-browser Testing:
Selenium allows testing across different web browsers, ensuring compatibility and consistent behaviour of web applications across platforms such as Chrome, Firefox, Safari, and others. This is crucial for maintaining a reliable user experience.

Platform Independence:
Selenium supports multiple operating systems, including Windows, Linux, and macOS. This enables testers and developers to create automation scripts that can be executed on various platforms, enhancing the flexibility and efficiency of the testing process.

Programming Language Support:
Selenium supports multiple programming languages, providing flexibility for automation engineers to use their preferred language. This adaptability facilitates seamless integration with existing development environments and tools.

Integration with Testing Frameworks:
Selenium can be integrated with various testing frameworks such as JUnit and TestNG. This integration allows for structured test design, parallel execution, and reporting, making the automation process more organized and efficient.

Parallel Execution:
Selenium supports parallel test execution, enabling the simultaneous execution of multiple test cases. This reduces the overall testing time and enhances the speed of the testing process, making it more time-efficient.

Support for Mobile Application Testing:
Selenium has extensions, such as Appium, that extend its capabilities to automate testing of mobile applications on platforms like Android and iOS. This provides a comprehensive solution for both web and mobile application testing.

Dynamic Web Content Handling:
Selenium supports dynamic web content, including AJAX-based applications. This capability allows testers to interact with and validate dynamic elements on web pages, contributing to more realistic and effective testing.

Community Support and Documentation:
Selenium has a large and active community, leading to extensive documentation, forums, and resources. This support network ensures that users can find solutions to common issues, stay updated on best practices, and share knowledge within the community.

In summary, Selenium is widely used for automation due to its versatility, cross-browser and cross-platform compatibility, support for multiple programming languages, integration capabilities, parallel execution, and robust community support. These features collectively contribute to more efficient and reliable web application testing processes.

Manual Testing Cover

Thirunavukkarasu arunagiri — Tue, 31 Oct 2023 11:18:35 +0000

Manual Testing:

Manual testing is a type of software testing in which a human tester, often referred to as a manual tester, executes test cases by interacting with a software application or system to identify and report defects or issues. Manual testing is a fundamental and essential part of the software testing process, especially in the early stages of development.

Human Interaction: Manual testers perform test scenarios by using the software, just as an end-user would. They interact with the user interface, input data, and navigate through the application to validate its functionality.

Exploratory Testing: Manual testing often includes exploratory testing, where testers explore the application without predefined test cases. This approach can help discover unexpected defects.

Test Case Execution: Testers follow predefined test cases, step-by-step instructions, or test scripts to ensure that the software functions as intended.

Ad Hoc Testing: In addition to predefined test cases, manual testers may perform ad hoc testing to identify issues that were not covered in the formal test cases.

Usability Testing: Manual testing is crucial for assessing the software's usability, user experience, and overall look and feel.

Regression Testing: Manual testing is often used for regression testing, where previously tested features are retested to ensure that recent changes or updates have not introduced new defects.

Limited Automation: Manual testing is typically not automated, meaning that human intervention is required for each test cycle. However, some aspects of manual testing, such as defect reporting, can be facilitated by automation.

Exploratory Skills: Manual testers need to have strong exploratory skills, an understanding of the application's requirements, and the ability to think critically to identify potential issues.

Documentation: Manual testers document their findings, including defects, deviations from expected behavior, and suggestions for improvements.

Feedback: Manual testing provides immediate feedback to the development team, allowing them to address issues quickly.

While automated testing has gained popularity for repetitive and regression testing tasks, manual testing remains essential for certain scenarios, such as usability assessment, ad hoc testing, and exploratory testing, where human judgment and intuition are crucial. Manual testing is often seen as complementary to automated testing and is used alongside it to ensure comprehensive testing of software applications.

Manual testing has its own set of benefits and drawbacks. Understanding these can help you make informed decisions about when to use manual testing in your software development and quality assurance processes. Here are some of the key advantages and disadvantages of manual testing:

Advantages of Manual Testing with Examples:

Usability Testing:

Advantage: Manual testing is ideal for evaluating the usability of a mobile app.

Example: When testing a mobile travel booking app, a manual tester can assess the user interface, navigation, and overall user experience to ensure that users can easily search for and book flights and accommodations.

Exploratory Testing:

Advantage: Manual testing is excellent for exploratory testing, allowing testers to uncover unexpected defects.

Example: When testing a new video game, a manual tester can play the game without predefined test cases, discovering issues like game crashes, graphical glitches, or gameplay anomalies that may not have been anticipated.

User Feedback Validation:

Advantage: Manual testing is effective for validating user-reported issues.

Example: In a social media app, if users report issues with posting images, a manual tester can replicate the issue and verify whether it's a real problem, helping the development team address the user's concerns effectively.

Disadvantages of Manual Testing with Perfect Examples:

Labour-Intensive Testing:

Disadvantage: Manual testing can be time-consuming and labour-intensive, especially for large-scale projects.
Example: When testing a complex web application with numerous features, manually testing all possible user interactions and scenarios, such as filling out forms, can be slow and resource-intensive.

Human Error:

Disadvantage: Manual testing is susceptible to human errors that can lead to inaccuracies.
Example: In a financial software application, a manual tester might input incorrect transaction data, resulting in erroneous test results, which can be detrimental to financial operations.

Resource-Intensive:

Disadvantage: Maintaining a dedicated manual testing team can be resource-intensive, particularly for long-term projects.
Example: In a large-scale software development project, maintaining a team of manual testers for an extended period can strain the project budget and resources.

Repetitiveness:

Disadvantage: Manual testing can become monotonous when testers need to repeatedly perform the same actions.
Example: In a mobile gaming app, testers might have to play through the same levels numerous times to identify bugs, which can lead to tester fatigue and potentially result in the oversight of defects.

Limited Test Coverage:

Disadvantage: Manual testing may not cover all possible test scenarios and edge cases, especially when test cases are not comprehensive.
Example: When testing an e-commerce platform, manual testing may focus on common transaction scenarios but may miss less common, yet critical, issues that only occur under specific conditions.

Subjectivity:

Disadvantage: Manual testing results can be influenced by individual tester biases, leading to subjectivity.
Example: When evaluating the visual design of a website, different manual testers may have varying opinions about the colour scheme or layout, making it challenging to establish objective pass/fail criteria.

In practice, a combination of manual and automated testing is often the most effective approach. Manual testing is valuable for certain types of testing, such as exploratory, usability, and ad hoc testing, whereas automated testing is ideal for repetitive and regression testing. Striking the right balance between manual and automated testing is crucial for ensuring software quality while optimizing time and resources.

Functional and Non-Functional testing with examples:

Thirunavukkarasu arunagiri — Mon, 23 Oct 2023 18:59:01 +0000

Functional Testing:

Function testing, also known as functional testing, is a type of software testing that focuses on verifying that a specific function or feature of a software application works correctly according to its specifications. The primary goal of function testing is to ensure that the software performs the functions it was designed to perform and to identify any deviations from expected behaviour.

Here are some key points about function testing:

Objective: It aims to validate that the software functions or features are working as intended and meeting their requirements.

Black-Box Testing: Function testing is typically a black-box testing method, meaning that testers do not need to know the internal code or structure of the software. Testers focus on inputs, outputs, and the behaviour of the system.

Test Cases: Test cases are designed based on the functional specifications and requirements of the software. These test cases encompass various scenarios and use cases to check the software's behaviour under different conditions.

Validation: It ensures that the software functions correctly for valid inputs, produces the expected outputs, and handles erroneous inputs gracefully by providing appropriate error messages or responses.

Test Automation: Function testing can be automated to a significant extent, making it more efficient and repeatable, especially in cases where the software has frequent updates or releases.

Tools: Various testing tools are available for function testing, helping testers create, execute, and manage test cases more effectively.

Here are some of the most common types of functional testing:

Unit Testing: Unit testing involves testing individual components or modules of the software in isolation. The goal is to ensure that each unit (e.g., functions, classes, methods) behaves as expected. Unit tests are typically automated and help identify bugs early in the development process.

Integration Testing: Integration testing verifies that different components or modules of the software work together as a whole. It checks for interactions between units to ensure that data flows correctly, and interfaces between components are functioning as intended.

System Testing: System testing is performed on the complete software system to verify that it meets its specified requirements. It focuses on end-to-end testing and ensures that all integrated components work together seamlessly. System tests often include functionality, performance, security, and other criteria.

Acceptance Testing: Acceptance testing determines whether the software meets the acceptance criteria defined by stakeholders, such as clients or end users. It can be further divided into two types:

User Acceptance Testing (UAT): Conducted by end users to validate that the software satisfies their business needs and works as expected.

Alpha and Beta Testing: These are pre-release tests where the software is tested by a select group of users (alpha) and a wider audience (beta) to identify any issues before the final release.

Smoke Testing: Smoke testing is a preliminary test that checks whether the software build is stable enough for more extensive testing. It focuses on the critical features to ensure that the basic functionality works.

Sanity Testing: Sanity testing is similar to smoke testing but is performed to verify that specific new functionality or bug fixes have been correctly implemented. It's more focused and less comprehensive than smoke testing.

Functional Regression Testing: This type of testing ensures that recent changes or updates to the software haven't introduced new defects or caused regressions in existing functionality. It involves rerunning functional test cases to identify any unexpected side effects.

Compatibility Testing: Compatibility testing checks how the software performs on various platforms, browsers, and devices. It ensures that the software works as expected on a wide range of environments.

Localization Testing: Localization testing verifies that the software functions correctly when adapted for different languages, regions, and cultures. It ensures that the user interface, date formats, currencies, and other aspects are culturally appropriate.

Globalization Testing: Globalization testing is broader than localization testing. It checks whether the software can be adapted for various cultures and regions without code changes. It focuses on the overall design and architecture.

Accessibility Testing: Accessibility testing assesses whether the software is accessible to people with disabilities. It ensures that the application is usable by individuals with various impairments, such as vision, hearing, or motor disabilities.

Security Testing: Security testing evaluates the software's ability to protect data, maintain the confidentiality and integrity of information, and resist unauthorized access or attacks. It includes various tests like penetration testing, vulnerability scanning, and more.

Here's an example of functional testing for a simple e-commerce website:

Scenario: Functional Testing of the "Add to Cart" Feature

Test Objective: To verify that users can successfully add products to their shopping cart.

Test Steps:

Open the Website: Open the e-commerce website and navigate to the homepage.

Search for a Product: Use the website's search bar to find a specific product (e.g., "Smartphone").

Select a Product: Click on a product from the search results to view its details.

Add to Cart: Click the "Add to Cart" button on the product details page.

Verify Cart Icon: Check if the cart icon in the top right corner of the website updates to show the number "1" (indicating that one item is in the cart).

View Cart: Click on the cart icon to view the shopping cart.

Verify Added Product: In the shopping cart, verify that the selected product is displayed with the correct name, price, and quantity (which should be "1").

Proceed to Checkout: Click the "Proceed to Checkout" or "Checkout" button.

Enter Shipping Information: Fill in the shipping information fields on the checkout page.

Select Payment Method: Choose a payment method (e.g., credit card, PayPal) from the available options.

Submit Order: Click the "Submit Order" or "Place Order" button.

Verify Order Confirmation: After completing the order, verify that a confirmation page or message appears, confirming the successful placement of the order.

Expected Results:

At each step, the corresponding action should work without errors.
The cart icon should update to "1" after adding a product.
The product in the shopping cart should match the product details, and the quantity should be "1."
The checkout process should proceed without any issues.
An order confirmation should be displayed at the end.

Pass Scenario:

The test is considered to have passed if all the steps are executed without any errors or deviations from expected behaviour, and the final order confirmation is displayed.

Fail Scenario:

The test is considered to have failed if any of the steps encounter issues, such as not being able to add a product to the cart, incorrect information in the shopping cart, errors during the checkout process, or the absence of an order confirmation.

Functional testing helps ensure that essential features of the e-commerce website, like adding products to the cart, work correctly, providing a smooth user experience and preventing potential issues that could negatively impact customers.

Non-Functional Testing:

Non-functional testing, also known as quality attribute testing, is a type of software testing that assesses the non-functional aspects of a software application. Unlike functional testing, which focuses on whether the software functions correctly, non-functional testing evaluates how well the software performs, its reliability, scalability, usability, and other characteristics that do not pertain directly to its functional behaviour.

Non-functional testing is essential to provide a well-rounded view of a software application's quality and performance. These tests help identify issues related to performance, security vulnerabilities, usability problems, and more. They are typically conducted alongside functional testing to ensure a comprehensive evaluation of the software's capabilities and characteristics.

Non-functional testing is critical to ensure that a software application not only meets its intended functionality but also delivers a high-quality user experience.

Here are some common categories of non-functional testing:

Performance Testing: Performance testing evaluates how well the software performs under various conditions, such as high user loads, heavy data volume, and stress. Types of performance testing include:

Load Testing: Measures the software's performance under expected user loads.

Stress Testing: Determines the software's stability and robustness under extreme conditions.

Scalability Testing: Assesses the application's ability to scale with increased user loads.

Reliability Testing: This type of testing checks the software's ability to perform consistently and reliably over time. It involves testing for fault tolerance, failure recovery, and error handling.

Usability Testing: Usability testing assesses how user-friendly the software is and whether it meets the needs and expectations of its intended users. It includes aspects like user interface design, navigation, accessibility, and overall user experience.

Security Testing: Security testing focuses on identifying vulnerabilities and weaknesses in the software's security measures. It includes tests like penetration testing, vulnerability assessment, and authentication testing.

Compatibility Testing: Compatibility testing ensures that the software works correctly on various platforms, browsers, and devices. It addresses issues related to operating system compatibility, browser compatibility, and mobile device compatibility.

Scalability Testing: Scalability testing assesses the software's ability to handle increasing workloads and data volume while maintaining performance and responsiveness.

Maintainability Testing: Maintainability testing evaluates how easy it is to maintain and update the software. It assesses factors like code readability, modularity, and the ease of making changes.

Backup and Recovery Testing: This type of testing assesses the ability of the software to back up data and recover from data loss or system failures.

*Here's an example of non-functional testing *

Performance testing:

Scenario: Performance Testing of an E-commerce Website

Test Objective: To evaluate the performance of an e-commerce website when subjected to different types of load and stress conditions.

Test Types:

Load Testing: This type of performance testing assesses the website's response time and behaviour under expected load conditions. Here's how load testing might be conducted:

Test 1 - Normal Load: Simulate a normal user load on the website by having a certain number of users browse products, add items to their carts, and proceed to checkout. Measure response times and ensure the website handles this load without performance issues.

Test 2 - Peak Load: Simulate a peak user load, perhaps during a festive sale day, to see how the website responds. Measure response times, verify that the server doesn't crash, and monitor resource utilization.

Stress Testing: Stress testing evaluates the website's behaviour under extreme conditions to determine its breaking point.
For example:

Test 3 - Stress Load: Gradually increase the user load until the system reaches its breaking point. Observe how the system behaves when it's overloaded, including error handling and recovery.

Scalability Testing: Scalability testing assesses the system's ability to scale and handle increased loads gracefully:

Test 4 - Scalability: Start with a small load and gradually increase it. Observe how the system scales, whether additional resources are allocated, and whether performance remains acceptable as the load grows.

Expected Results.

In normal load conditions, the website should respond quickly, with acceptable response times.
During peak load, the response times may increase slightly, but the system should remain responsive and not crash.
Under stress load, the system may show signs of slowing down, but it should not crash or produce critical errors.
During scalability testing, the system should effectively allocate resources to handle increased load without performance degradation.

Pass Criteria:

The website should meet the expected results without severe performance degradation or system failures. It should gracefully handle different load levels, demonstrating its scalability and robustness.

Fail Criteria:

The test fails if the website crashes, becomes unresponsive, or produces critical errors under any of the test scenarios.
Performance testing, in this case, is a crucial non-functional test to ensure that the e-commerce website can handle different levels of load, including peak load and stress conditions, without compromising user experience or system stability. This testing helps identify performance and provides insights into system behaviour under varying loads.

Different Techniques of Software Testing

Thirunavukkarasu arunagiri — Tue, 17 Oct 2023 22:54:03 +0000

Boundary value analysis:

Boundary value analysis is a one of software testing technique which to get test cases around the boundary conditions of given input. It helps to reduce the errors or defects that might occur at or near the edges of the valid input ranges. This technique is especially useful in testing scenarios where the software's behaviour may change drastically near the boundaries.

The primary idea behind boundary value analysis is to test the minimum and maximum values, as well as values just above and below these boundaries. By doing so, you can reduce the issues related to boundary conditions.

For example:
In the Username tab minimum 6 characters and maximum 15 character should be there,

Minimum value:
6 --> valid positive test
Maximum value:
15 --> valid positive test
Minimum value-1 :
5 --> Invalid negative test
Maximum value+1:
16 --> Invalid negative test
Between:
8 or 10 or 13 --> valid test
Zero value:
0 --> Invalid test

Decision table testing

Decision table testing is a black-box testing technique used to test systems that have complex business rules or logic. It helps in identifying combinations of inputs that should be tested to ensure proper system behaviour. Decision tables are particularly useful when there are multiple conditions and inputs that can result in different outcomes.

A decision table consists of conditions, actions, and rules. Conditions represent the various factors or inputs that influence the system's behaviour, actions specify what the system should do under different conditions, and rules define the relationships between conditions and corresponding actions.

For Example:
Consider a book shop and discount on book purchase for customers (Regular/Premium)

Decision Table:
Customer Type Number of Books Discount Percentage
Regular Less than 5 0%
Regular 5 to 10 5%
Regular More than 10 10%
Premium Less than 5 5%
Premium 5 to 10 10%
Premium More than 10 10%

In this decision table, we have two conditions (Customer Type and Number of Books) and one action (Discount Percentage). The conditions can take on various values, and the table outlines the relationship between them.

Now, let's create test cases based on this decision table:

Test case 1: Customer Type = Regular, Number of Books = 3
Expected Action: Apply a 0% discount

Test case 2: Customer Type = Premium, Number of Books = 8
Expected Action: Apply a 10% discount

Test case 3: Customer Type = Regular, Number of Books = 15
Expected Action: Apply a 10% discount

Test case 4: Customer Type = Premium, Number of Books = 2
Expected Action: 5% discount

Use case testing

Use case testing is a software testing technique that focuses on testing the interactions and flows of a system or application based on its use cases. A use case represents a specific functionality or feature that a system provides to its users. Testing based on use cases helps ensure that the software meets the functional requirements and user expectations.

For Example:
Consider an online shopping application with various use cases, "Checkout page" for this example.

Test Case 1: Successful Checkout

1.Login as a registered user.
2.Add items to the shopping cart.
3.Click on the "Checkout" button.
4.Confirm cart contents.
5.Select a shipping address.
6.Choose a payment method (e.g., credit card).
7.Process the payment.
8.Verify that the order summary is displayed.
9.Verify that the order is saved in the user's order history.

Test Case 2: Unsuccessful Checkout

1.Login as a registered user.
2.Add items to the shopping cart.
3.Click on the "Checkout" button.
4.Confirm cart contents.
5.Select a shipping address.
6.Choose a payment method (e.g., a fake or invalid credit card).
7.Verify that an error message is displayed.
8.Allow the user to retry the payment.

Test Case 3: Cancelling Checkout

1.Login as a registered user.
2.Add items to the shopping cart.
3.Click on the "Checkout" button.
4.Cancel the checkout process during any step.
5.Verify that the cart is not processed as an order.

LCSAJ Testing

Linear code sequence and jump testing is a white box testing and structural method. Which works in a control flow way. Executing the sequence and jump with different conditions.

This helps in reducing the error related with control flow by Conditions, Loops and branching logic scenarios.

For Example:
School joining children age limit is 3 and above.

age = input()
if age < 3;
print ("No admission")
else;
print ("Good for admission")

Test case:1 (not satisfy the condition)
Age below 3 - No admission

Test case:2 (satisfy the condition)
Age above 3 - Good for admission

Test case:3 (satisfy the condition with exact value)
Age 3 - Good for admission

Software Testing

Thirunavukkarasu arunagiri — Mon, 16 Oct 2023 12:15:37 +0000

Software testing is a critical and important process in the software development. It involves evaluating a software/product to identity the defects in them and fixing those.

The main goals of software testing are verifying the software/product to meet the clients expectation and to try for the Zero error (no software/product is 100% error free). There are different types of software testing --> Functional testing as Unit testing, integration testing, System testing, Regression testing, UI testing and User acceptance testing and Non-functional testing --> security testing, performance testing, usability testing and scalability testing.

These are handled with process flow as Requirement analysis, Test planning, Test cases, Test environment creation, Bug tracking and Documentation.

The relevance of testing are in development and maintenance of software with the following reasons,

Quality assurance - identifying the defects and fixing them to ensure the software performs as expected.

User expectation fulfilment - Satisfying the user with software as friendly and good to use with no errors.

Risk based testing - to identify the risks in the product and cover them with a plan.

Cost effective - to find the defects in early stages and fix before it reaches the user and affect the cost/failure.

Process improvement - It improves the process in the company and improves the developers with performance

Maintenance & Documentation - The maintenance of the software mainly relays on the documentation by the developers and testers. It makes the people to refer and resolve things early and good.