Forem: sankaran m

Python Selenium Architecture and Python Virtual Environment

sankaran m — Tue, 26 Mar 2024 15:32:00 +0000

1)Python Selenium Architecture:

The architecture of Python Selenium revolves around several key compounds that interact to automate web browser actions. Let's delve into the details of each component:

Selenium WebDriver:

      At the core of the architecture lies selenium WebDriver, which serves as the interface between Python code and the web browser. WebDriver communicates with browser's native automation support to perform various action such as clicking element, filling forms , navigating between pages, and extracting data. WebDriver provides bindings for different programming language, including Python, enabling developers to write automation script in Python.

Python Programming Language:

      Python server as the scripting language for Selenium automation. Developers utilize Python's rich set of libraries and features to write concise and readable automation scripts. Python's simplicity, readability, and extensive community support make it an ideal choice foe selenium automation, allowing developers to quickly prototype and maintain automation scripts.

Selenium Server(Optional):

      In some cases, selenium automation may involve executing tests remotely on different machines or browsers. Selenium server acts as a hub that facilitates communication between the WebDriver and browser instances running on remote machines. While Selenium server is not always required, it becomes essential for distributed testing scenarios, such as running tests in parallel using Selenium Grid.

Browser Drivers:

      Each web browser(e.g., Chrome, Firefox, Safari) requires a specific driver to interact with Selenium WebDriver. These drivers act as intermediaries, translating WebDriver commends into browser-specific actions. For example, the Chrome Driver is used to automate interacts interactions with the Google Chrome browser, while the Gecko Driver is used for Firefox. Developers need to install the appropriate browser driver and ensure compatibility with selenium WebDriver Version being used.

Element Locators:

      To interact with element on a web page(e.g., buttons, text fields, links), Selenium relies on locators to identify these element uniquely. Commonly used locators includes IDs, class names, CSS selectors, XPath expressions, and tag names. Selenium provides methods to find elements using these locators, allowing developers to perform actions such as clicking, typing, and verifying element properties.

Test Frame Works and Reporting Tools:

      In real-world automation projects, developers often integrate Selenium with test frameworks like py test, unit test, or behave to organize and execute test cases efficient. Additionally, reporting tools such as Allure or HTML Test Runner are  employed to generate detailed test reports with metrics, logs, and screenshots, facilitating result analysis and debugging.

Page Object Model(POM):

      To enhance code maintainability and readability, developers frequently adopt the Page Object Model(POM) design pattern.

POM involves creating separate classes representing web pages or components, encapsulating the page's elements and actions within methods. This abstraction promotes code reusability, reduces duplication, and simplifies test maintenance.

In summary, the Python Selenium architecture encompasses WebDriver, Python programming language, browser drivers, element locators, optional Selenium server, test frameworks, reporting tools, and design patterns like POM. Understanding this architecture is crucial for effectively automating web browser interactions and building robust test suites.

2)Significance of Python Virtual Environment:

Python virtual environment play a significant role in isolating project dependencies and managing package versions, thereby ensuring a clean and consistent development environment. Here's why Python virtual environments are essential and some examples illustrating their significance:

 - **Dependency Isolation:**

         Virtual environments create isolated environments for each project, preventing conflicts between different projects' dependencies. For instance, Project A may require a specific version of a library incompatible with the version required by Project B. By using virtual environments, developers can maintain separate environments for each project, avoiding dependency clashes and ensuring project-specific requirements are met.

 - **Package Management:**

         Virtual environments allows developers to install, upgrades, and remove packages without affecting the system-wide Python installation or other projects. This flexibility enables experimentation with different package versions and facilitates project-specific configurations. For example, a developer working on a web scraping project may need specific versions of Beautiful Soup and requests libraries. Using a virtual environment, they can install these dependencies without altering the global Python environment.

 - **Version Control:**

         Including a virtual environment in version control repositories ensures that all team members work with the same environment configuration. This promotes consistency across development, testing, and deployment environment, reducing compatibility issues and ensuring reproducibility. For instance, when collaborating on a Django web application, developers can share the project's virtual environment configuration via requirement.txt or Pip file, ensuring everyone has the necessary dependencies installed.

 - **Deployment Consistency:**

         Virtual environments streamline the deployment process by allowing developers to package the project along with its dependencies into a self-contained unit. This ensures that the deployed application runs in a consistent environment regardless of the host system's configuration. For example, deploying a Flask web application on a production on a production server involves creating a virtual environment containing the application and its dependencies, guaranteeing a consistent runtime environment. 

 -** Easy of Cleanup:**

         Virtual environments make its easy to clean up project-specific dependencies once a project is completed or on longer needed. Developers can simply delete the Virtual environment directory, eliminating all project-related packages and ensuring a clean system state. This simplifies maintenance and reduces clutter on the development machine.

In conclusion:

      Python virtual environments offer numerous benefits, including dependency isolation, package management, version control, deployment consistency, and ease of cleanup. By leveraging virtual environment, developers can create self-contained and reproducible development environments, fostering collaboration, ensuring compatibility, and simplifying project management.

SELENIUM

sankaran m — Sun, 24 Mar 2024 18:29:24 +0000

Selenium is a powerful open-source framework primarily used for automating web browsers. It provides a set of tools and libraries that enable developers and testers to automate web application across different browsers and platforms. Selenium is widely adopted in the software industry due to its flexibility, extensibility, and robustness.

At its core, selenium consists of several components:

Selenium IDM(Integrated Development Environment):
This is a browser plugin used for recording and playback of user interactions with the browser. It allows testers to quickly create test cases by recording their actions, making it an ideal tool for beginners and for creating simple automation scripts. However, Selenium IDM o limited in functionality compared to other Selenium tools and is mostly used for prototyping and quick testing.
Selenium WebDriver:
WebDriver is the most powerful component of Selenium. It provides a programming interface to create and execute test scripts in various programming languages such as Java, Python, C#, and Ruby. WebDriver interacts directly with the web browser, simulating user actions like clicking buttons, entering text, navigating pages, and validating page content. This level of control allows testers to perform complex testing scenarios and execute tests across different browsers and operating system.
Selenium Grid:

Selenium Grid is a distributed testing tool used to run Selenium tests i parallel across multiple machines and browser simultaneously. It allows for scalability and efficient test execution, reducing the overall test execution time. Selenium Grid is particularly useful for large-scale testing efforts, where executing test across multiple environment and configuration is necessary.

Now, *why do we use Selenium for automation?
*

Cross-Browser Compatibility Testing:
One of the primary reasons for using for using Selenium is to ensure that web application work consistently across different browsers such as chrome, Firefox, Safari, and Internet Explorer. Selenium WebDriver provides support for all major browser, allowing testers to write test scripts once and execute them across multiple browser without modification. This helps in development cycle, improving the overall quality of the application.
Regression Testing:
In software development, as new features are added and existing feature are modified, it's essential to ensure that these changes do not introduce any unintended side effects or regression in the application. Regression testing involves re-running previously executed test cases to validate that the application still behaves as expected after changes. Selenium enables automation of regression testing by allowing testers to create reusable test scripts that can be executed repeatedly, saving time and effort compared to manual testing.
Faster Time To Market:
Automating repetitive tasks such as regression testing, smoke testing, and cross-browser testing with selenium significantly reduces the time required for manual testing. Automated tests can be executed much faster and more frequently than manual tests, enabling faster feedback cycles and accelerating the overall development process. this leads to shorter release cycles and faster time-to-market for software products.
Improved Test Coverage:
With Selenium, testers can create comprehensive test suites covering various aspects of the application, including functional testing, UI testing, integration testing, and performance testing. By automating these tests, teams can achieve higher test coverage and unc
over more defects early in the developments process, thereby improving the overall quality and reliability of the software.
Cost Savings:
While there is an initial investment in setting up selenium automation infrastructure and writing test scripts the long-term benefits in terms of time and cost savings are significant. Automated testing reduce the need for manual intervention, allowing organizations to allocate resources more efficiently and focus on higher-value tasks such as exploratory testing and test case design.

In conclusion,
Selenium is a versatile and powerful automation framework used for testing web application. its ability to automate repetitive Tasks, ensure cross-browser compatibility, accelerate testing cycles, and improve test coverage makes it an indispensable tool for software development teams striving to deliver high-quailty application efficiently and cost-effectively.

SELENIUM

sankaran m — Sat, 03 Feb 2024 08:25:59 +0000

SELENIUM is a suite of tools designed to automate web browsers. it provides a way for developers and testers to script interactions with web browsers and automate various tasks, such as filling forms, clicking buttons, navigating b/w pages, and extracting data.

Key aspects of selenium include:

WEB BROWSER AUTOMATION: Selenium allows you to automate the interactions with a web browser. it supports various browsers like Chrome, Firefox, Safari, and Internet Explorer.
CROSS-BROWSER TESTING: one significant use of selenium is in cross-browser testing. it ensures that a web application works correctly across different browsers and their versions.
_TESTING FRAMEWORK INTEGRATION: _selenium can be integrated with testing frameworks like JUnit and Test-NG, making it suitable functional and regression testing.
PROGRAMMING LANGUAGE SUPPORT: selenium supports multiple programming languages such as Java, Python, C#, Ruby, and JavaScript. this provides flexibility, allowing developers and testers to use the language they are most comfortable with.
OPEN SOURCE: Selenium is an open-source tool, which means it is freely available for use and can be customized according to specific project requirements.
PARALLEL TEST EXECUTION: selenium supports parallel test execution, which can significantly reduce the time required for test suites to run.
SUPPORT FOR HEADLESS BROWSING: selenium can perform browser automation without launching a visible browser window. This is useful for scenarios where UI visibility is not essential, such as in server environments.
COMMUNITY SUPPORT: being widely used and open source, selenium has a large and active community, this community support is valuable for troubleshooting issues, finding solution, and staying updated with the latest features.

AT its core selenium allows users to automate interaction with web browsers enabling the emulation of user action such as filling forms clicking buttons navigating b/w pages and extracting data. one of its key advantages is its compatibility with various browser

cross-browser testing is a critical use cases selenium it addresses the challenges posed by the diversity platforms an essential aspect of quality assurances, multiple browsers, developers can identify and fix issues related to browser-specific behavior, ensuring a seamless user experience for all visitors this ability to ensure compatibility across different browsers makes selenium an invaluable tool for web developers and testers.

Selenium seamlessly integrates with popular testing frameworks like JUnit and Test-NG, making it suitable for both functional and regression testing. this integration allows for the creation of comprehensive test suites, facilitating the automated execution of tests and the identification of potential issues during the development lifecycle. the result is improved software quality, faster release cycles, and more reliable web applications.

Another key feature of selenium is its support for multiple programming language including java, python, c#, ruby, and JavaScript. this flexibility allows developers and testers to choose the language they are most comfortable with making selenium accessible to a broader audience. the ability to work with familiar programming languages enhances productivity and accelerates the adoption of selenium within development and testing teams.

In summary, selenium is widely used for automation because it provides a versatile and powerful framework for automating web browser interactions. it is particularly beneficial for testing web development and testing processes.

MANUAL TESTING, BENEFITS and DRAWBACKS

sankaran m — Tue, 10 Oct 2023 17:33:14 +0000

Manual testing is a fundamental software testing approach where testers, often referred to as quality assurance (QA) professionals or testers, manual execute test cases without the aid of automation tools. it involves a human tester following predefined test cases, interacting with the software application, and observing its behavior to identify defects or issues. manual testing plays a crucial role in the software development life cycle (SDLC) and is used alongside automated testing to ensure the quality and reliability of software products.

Benefits of Manual Testing:

**Exploratory Testing**: Manual testing allows testers to use their creativity and intuition to explore the application's functionality and find unanticipated defects. Testers can mimic real-world user behavior, making it easier to identify usability issues and edge cases.

** Example** :imagine testing an e-commerce website. An manual testing might explore different paths for making a purchase, intentionally trying various combinations of products, shipping addresses, and payment methods to uncover potential issues.

**

Early Detection of Usability and User Experience issues
**: Manual testers can provide valuable feedback on the user interface (UI), layout, and overall user experience. They can spot design inconsistencies, awkward navigation, and accessibility issues that might not be easily detected through automated testing.

** Example **: While testing a mobile app, a manual tester might notice that a button is too small to tap comfortably on smaller devices, leading to a recommendation for UL improvements.

*> Adaptability to Frequent Changes *
: in agile development environments, where requirements and features often change rapidly, manual testing is more flexible than automated testing. Testers can quickly update and execute test cases in response to changing project needs.

Example

: in a sprint-based development model, new features may be added or modified regularly. Manual testers can adapt their test cases and test plans accordingly to ensure adequate coverage.

> Cost -Effective for small Project
: For small-scale projects or projects with limited budgets, manual testing can be more cost-effective than developing and maintaining automated test scripts, the initial investment in automation can be substantial, and it may not always be justified for short-term or one -off projects.

** Example** : A simple brochure website for a local business may not require automated testing, as it can be thoroughly tested manually without incurring the additional cost of automation.

**

Complex Scenarios and Non-Functional Testing
** : Manual Testing is often used for scenarios that are difficult to automate, such as testing complex business logic, security vulnerabilities, and performance testing under various conditions.

Example
: penetration testing, where testers attempt to exploit security vulnerabilities in an application, requires manual intervention to assess real-world security risks.

Human Error
**: Manual testing is susceptible to human errors, including oversight, fatigue, and inconsistency in test execution. Testers may miss defects, misinterpret requirements, or make mistakes in test data preparation.

**Example** : A manual tester might overlook a critical security vulnerability or fail to follow a specific test case due to tiredness or distraction.

Resource-Intensive
**: Manual testing can be time - consuming and resource - intensive, especially for large and complex applications. Testers musters must repeat same tests for different builds, increasing the chances of redundancy.

*Example *: in a software project with frequent code changes tester may need to retest the same functionality repeatedly, consuming valuable time and resources.

Limited Test Coverage
**: Manual testing can struggle to achieve comprehensive test coverage, as it relies on the tester's ability to write effective test cases and explore all possible scenarios.

** Example** : in a software projects with a tight deadline, testers
might prioritize the most critical functionality, leaving less important features or edge cases untested.

**

Inefficiency for Repetitive Tasks
**: Tasks that require repetitive and time -consuming action, such as regression testing, can be inefficient when performed manually. Automation is more suitable for these scenarios.

**Example** : Regression testing involves retesting existing features after code changes. Manually executing the same test cases for each new build can be tedious and error-prone.

Limited Scalability
: Manual testing may not scale well for projects with frequent releases, continuous integration, or a need for parallel testing across multiple environments.

** Example :** in a DevOps pipeline with multiple deployments per day, manual testing may become a bottleneck, slowing down the release process.

In conclusion,
_ manual testing remains a critical aspect of software testing, offering flexibility, adoptability, and the human touch required for certain types of testing. it is particularly effective for exploratory testing, early usability feedback, and scenarios where automation is impractical or cost - prohibitive. However, it has its drawbacks such as the potential for human error, resource intensiveness, and limited test coverage. To maximize the benefits of manual testing, organizations often use it in combination with automated testing to testing to strike a balance b/w thorough coverage and efficiency in the software development process.

BENEFITS_OF_MANUAL_TESTING_/_DRAWBACKS

sankaran m — Tue, 26 Sep 2023 17:20:43 +0000

Manual Testing

   * White box
   * Black box
      *   Functional Testing 
                 * Unit testing
                 * Integrating testing
                       * Incremental testing 
                                  * Top-down
                                  * Bottom-up
                       * Non-Incremental testing
                  * System testing 
       * Non-Functional testing 
                 *  Performance testing
                            * Load testing
                            * Stress testing
                            * Scalability testing
                            * Stability testing
                 *  Usability testing
                 *  Compatibility testing 
   * Grey box

MANUAL TESTING :

Manual testing is software testing technique where execute test cases and verify the application's functionality without the use of automated testing tools or scripts. Here are some key benefits and drawbacks of manual testing:

Benefits of manual testing:

** 1.Human Insight:**
          Testers can apply their domain knowledge and intuition to identify potential issues that automated tests might miss.

** 2.Exploratory Testing:**
          Manual testing allows for exploratory testing, where testers actively explore the application to find unexpected defected.

** 3.Cost-Effective For Small Projects:**
          For small-scale projects or those with frequently changing requirements, setting up automated tests may be more time-consuming and costly than manual testing.

 ** 4.Early Testing:**
          Manual testing can begin even before the software is fully development cycle, helping to uncover defers early in the development cycle.

** Drawbacks of manual testing:**
** 1.Labor-Intensive:**
Manual testing can be time-consuming and
labor-intensive, especially for repetitive tasks.

  ** 2.Subjectivity:**
            Test results can be influenced by the tester's subjectivity, lending to inconsistent results.

  **3.Not Suitable For Repetitive Testing:**
            For regression testing or scenarios requiring the same tests to be run frequently, manual testing can be inefficient.

 ** 4.Limited Scalability:**
            It's challenging to scale manual testing for large and complex application or when frequent testing is needed.

 ** 5.Lack Of Test Coverage: **
            Manual testing might not cover all possible test cases due to human limitations.

example:

User interface Testing:

        Manual testers assess the user interface for usability, visual consistency, and user experience, ensuring it meets design requirements.

Usability Testing :
Testing interact with the software as end -user to evaluate its user-friendliness and identify areas for improvement.

Exploratory Testing:

      Testers explore the application without predefined test cases, aiming to discover defects that automated tests might overlook.

AD HOC Testing :
testers perform unplanned testing to catch issues in real - world scenarios.

Compatibility Testing :
Checking the Software's compatibility with various browsers, devices, or operating system manually to ensure a consistent user experience.

Test Case Design:
Manual testing involves the creation of detailed test cases, which outline the steps to be taken and the expected results. testers meticulously design these test cases to ensure comprehensive coverage.

Exploratory Testing :
This approach involves testers using their creativity and domain knowledge to discover defects that may not be covered by scripted testers cases. it's particularly valuable for finding unexpected issues.

User Acceptance Testing(UAT):
UAT is often performed manually by end-users or business stakeholders to ensure the software meets their requirements and expectations before deployment.

Edge case Testing :
Testers can focus on testing edge cases, such as extreme input or unusual scenarios, to uncover vulnerabilities that automated tests might not consider,

Usability Assessment:

           Beyond functional testing, manual testing assesses the software's overall usability, including factor like intuitiveness, accessibility, user satisfaction.

Feedback loop:
Manual testers can provide immediate feedback to developers about defects, allowing for quicker fixer and improvements.

Adaptability :
Manual testers can adapt quickly to changing requirements or evolving project conditions, making them valuable in agile development environments.

Pair Testing:

        Two testers can collaborate in pair testing, where one person executes the tests while the other observes, leading to more thorough testing.

Test Data Setup :
Testers often manually prepare test data and ensure the test environment is configured correctly.

Localization Testing :
Manual testing essential for verifying that software is culturally and linguistically appropriate for specific regions or languages.

Accessibility Testing:
Manual testers can evaluate the software's accessibility by checking if it meets accessibility standards and is usable by individuals with disabilities.

Security Testing:
While automated tools are useful for certain security tests, manual testers can perform in depth security assessments, such as penetration testing and code review.

User Story Validation:
Manual testers can validates that user stories or requirements are correctly implemented, aligning the software with the intended functionality.

Regression Testing:
While Automation is often preferred for regression testing, manual regression testing can be used when automation is not feasible or when quick checks are needed.

User Feedback Incorporation :
Testers can incorporate user feedback into their testing process, helping to prioritize and address issues that matter most to users.

In Summary
,
manual testing provides human insights, is cost -effective for certain scenarios, and is suitable for early testing, However, it is labor-intensive, subjective, and less efficient for repetitive tasks compared to automates testing. it's essential to strike a balance b/w manual and automated.

FUNCTIONAL_NON-FUNCTIONAL_TESTING.

sankaran m — Tue, 26 Sep 2023 15:08:53 +0000

**Functional Testing **

Functional testing is a type of software testing that focuses on verifying that a software application to its specified requirements. it involves testing the software's functionality by providing input and checking whether the output matches the expected results. function testing testing helps ensure that the software perform its intended tasks accurately.

there are various methods and levels of functional testing
,

unit testing
integration test
system testing
user acceptance testing

Each serving a specific purpose in the software development lifecycle.

Allowing for corrections before the software is released to users.

Purpose:
Functional testing evaluates whether the software functions correctly as per the specified requirement and user expectation.

Focus:
It focuses on verifying the functional aspects of the application, such as its features, capabilities and interactions.

Unit Testing:
This checks individual units or components of the software, like functions or methods, to ensure they produce the expected outputs for given inputs.

Integration Testing:
It examines the interactions between different modules or components to ensure they work together as intended.

System Testing:
This tests the entire software system to validate that it meet the specified requirements.

User Acceptance Testing(UAT):
Performed by end-users to ensure the software meets their
needs and is ready for production use.

Scope:
Functional testing primarily addresses the "what" of the software. It verifies whether the software accomplishes specific tasks and functions outlined in the requirement.

Test Cases:
Functional testing uses test cases that are typically derived from functional specifications or user stories. These test cases describe expected inputs, actions, and outputs.

EXPAMPLES :

Regression Testing:
Ensures that new code changes or updates do not negatively impact existing functionality.

Smoke Testing:
A quick check to verify that essential functions are working before more extensive testing.

NON_FUNCTIONAL_TESTING

Purpose:
Non-Functional testing assesses the qualities of the software that are not related to specific functions but are crucial for its performance and user experience.

*Focus *:
it focuses on aspects like performance, reliability, security, usability, and scalability.

EXAMPLES:

Performance Testing:
This checks how the software performs under various conditions, such as load testing to evaluate its performance under heavy user loads.

Security Testing :
it examines the application's security measures to identify vulnerabilities and ensure data protection.

Usability Testing :
This assesses the user-friendliness of the software, including aspects like navigation, user interface design, and accessibility.

Reliability Testing:
it verifies the software's stability and its ability to function consistently over time.

Scalability Testing:
This Tests how well the software can handle increased workloads or growing datasets.

*scope : *
Non-functional testing deals with the "how" of thew software. it assesses how well the software performs, its quality attributes, its behavior under various conditions.

*Test Criteria: *
Non-Functional Testing often employs criteria and metrics to assess attributes such as response times, security levels or user satisfaction. these are not always as straightforward as functional test cases.

EXAMPLES:

load testing :
Determines how the application performs under heavy concurrent user loads.

penetration testing :
Evaluates the security of the software by attempting to exploit vulnerabilities.

Compatibility Testing:
Checks how the software behaves across different devices, browsers, or operating system.

Resilience Testing:
Assesses the software's ability to recover from failures or adverse conditions.

In summary, functional testing ensures that the software performs its intended functions correctly, while non-functional testing focuses on the broader qualities that impact user experience and system performance, Both types of testing are essential to deliver a high-quality software product.

Description of Testing Techiques

sankaran m — Tue, 19 Sep 2023 18:41:43 +0000

1, BOUNDARY VALUE ANALYSIS

Description : Boundary value analysis(bva) is a testing techiques that fouses on testing values at the edges or boundaries of input domians, it's especially useful fro idetifiying errors or issuess that may occur near the bounderiess of acceptable input ranges.
ex : 4consider a software appliction that acctects user ages b/w 18 & 65 as valid, in this case:
boundary values for valid input :18 & 65
boundary values for invalid input :17(below boundary)&65(above the upper boundary)
Testing Approach : you would test the application using these boundary values to ensures it behaves correctly, For instance, verify that a user of 18 can register successfully while a user age 17 receives an error message get.

2, DECISION TABLE TESTING

Description : Decision Table Testing is a systematic techqiue used to test combination of input condition (decision condition) and their corresponding action. it's particularly useful when there are multiple input condtion that can result in different outcomes.
ex : consider a banking application where a user's eligibility for a loan depends on their credit score, income, and employment status, you can create a decision atble like this

credit score --- income --- employment status --- Eligibility

Good High Employed Eligible
Good High Unemployed Ineligible
Fair High Employed Ineligible

Test Approach :Test various combination of input values(e.g, Good credit score, High income, and emplyed)to verify that the applicationcorrectly determines loan eligible based on the decision table.

3, USE CASE TESTING

 Description : Use testing involves testing a software application based on it's defined use cases or user scenarios.each use case represents a specific intereaction b/w the user and the system

ex : in an e-commerce system, a sue case could be "user adds an item to the shopping cart" thiis use case would includes steps lie selecting a product, specifing quantity, and clicking "add card"

Test Approach : to preform use case testing you would execute each use case with differant variant and input to ensure that the application behaves as expected in varsious scenariors

4, LCSAJ TESTING(LINEAR CODE SEQUENCE AND JUMP)

Description : LCSAJ Testing fouces on testing different execution paths in code by considering linear sequence of statements and jumps(e.g, condition statements , oops, and functon calls)code paths are tested
ex : suppose you have a fuction thats calculates statements to handle edge  case(e.g, when the input is 0 or -neg) and recrsive calls for + positive numbers.
Test Approach : in LCSAJ Testing you'd design test cases to cover all possible execution paths through the code. this wpuld incue testing with inputs like 0, positive integers, and negative integers to ensure that all code branches are exercised

these testing techiques are valuable tools foe systematically validating the behavior and functionality of software applictions, helping to uncover defects and the software meets it's requirments.

Software testing

sankaran m — Tue, 19 Sep 2023 17:51:56 +0000

software testing :
Is a critical and systematic process of evaluating a software application,
software testing involves various activities, Including desiging test cases, executing them comparing actual results to expected result and reporting defrects when discrepancies are found. like KEY aspects of software testing inculde

Validation
Verification
Error Detection
Risk Mitigation
Quality Assurance
Continuous Improvement

*We need to know about Software Testing *
to effectivey understand software testing, it's important to be aware of several key aspects and priciples
make a plan like this
testing types,testing levels,testing life cycle(for rountine),test automation, metrics and repoting, test environments, documentation,communictaion, once you completed this to ensure everyone is alingned on testin goals and results

The Relevances of Software Testing.
The Relevances of software testing is profound and extends across various dimension
1, Quality Assurance
2, Customer Satisfaction
3, Cost Savings
4, Risk Mitigation
5, Compliance and Security
6, Enhanced Reputation
7, Continuous Improvement
8, Decision Support
9, Legal protection
making it an indispenable part of the software development process.