Manual Software Testing Training Part-3

Recap of Previous Session and Introduction to Today's Topics

Overview of V Model

• The session begins with a recap of the previous discussion on the V model, focusing on verification and validation.

• Static testing is defined as reviewing documentation (requirements, design documents), while dynamic testing involves validating software by providing inputs and observing outputs.

Verification vs. Validation

• Verification checks if processes are followed correctly through techniques like reviews, walkthroughs, and inspections.

• Validation ensures that the software meets customer requirements through various testing methods including unit testing, integration testing, system testing, and user acceptance testing.

Static vs. Dynamic Testing Techniques

Static Testing Techniques

• Three main static testing techniques are identified: review, walkthrough, and inspection.

Dynamic Testing Techniques

• Dynamic testing techniques include unit testing, integration testing, system testing, and user acceptance testing.

In-depth Discussion on Review Techniques

What is a Review?

• A review involves reading a document to ensure its correctness and completeness regarding specified content.

Types of Reviews

• Different types of reviews include:

• Requirements Review: Ensures all customer requirements are captured accurately.

• Design Review: Focuses on design documents which may include diagrams or pictures representing software architecture.

Code Review and Walkthrough Techniques

Code Review Process

• Code review involves one developer returning code to another for evaluation, ensuring adherence to coding standards.

• Test plan reviews are conducted by testers to assess the completeness and correctness of testing documents, including test cases and defect reports.

• The primary focus of reviews is on documentation accuracy, ensuring that all content is complete and correctly articulated.

• Reviews can be performed by any team member—developers, testers, or managers—highlighting a collaborative approach.

Understanding Walkthroughs

• A walkthrough is an informal review process focused on documents where there are no specific plans or scheduled meetings.

• Informal reviews lack structure; they can occur spontaneously without prior arrangements or invitations.

• During a walkthrough, the document's author reads through it with peers present to facilitate understanding and discussion.

• At least two people should be involved in a walkthrough: the author (referred to as "other") and one or more peers who listen and engage in discussion.

Key Differences Between Review Types

• Unlike formal reviews that require planning and minutes of meeting documentation, walkthroughs do not necessitate such formality.

• In traditional reviews, typically only the author checks for correctness; however, walkthroughs involve multiple participants discussing the document collaboratively.

Inspection Technique in Static Testing

Overview of Inspections

• Inspections are more formal than walkthroughs; they require pre-planning and scheduling with team members invited via email.

Inspection Roles in Software Testing

Understanding the Roles: Reader, Writer, and Moderator

• The inspection process involves three key roles: reader, writer, and moderator. Each plays a crucial part in ensuring effective document review.

• The reader is typically the author of the document being inspected. Their role is to read and present the content for discussion.

• The writer takes notes during the inspection meeting, documenting questions and clarifications raised by team members regarding the document.

• The moderator acts as a facilitator or mediator during the meeting, organizing discussions and ensuring that all voices are heard.

• Inspections are formal meetings involving various stakeholders such as developers, QA testers, and project managers to ensure comprehensive feedback.

Static vs. Dynamic Testing Techniques

Static Testing Techniques

• Static testing focuses on reviewing documentation to verify correctness. It can be conducted through methods like reviews, walkthroughs, or inspections.

• Inspections are more formal compared to reviews and walkthroughs; they require scheduled meetings with all relevant parties involved.

Dynamic Testing Techniques

• Dynamic testing includes unit testing, integration testing, system testing, and user acceptance testing (UAT), focusing on actual software functionality after coding is complete.

• During unit testing, developers test individual code components for correctness before integration into larger systems.

• In integration testing, multiple modules are combined to check data flow between them for proper communication.

Quality Assurance (QA), Quality Control (QC), and Quality Engineering (QE)

Comparing QA and QC

• QA refers to processes aimed at ensuring quality throughout development while QC involves actual software testing activities.

• QA encompasses three pillars: people, processes, and products—highlighting that effective teams must follow structured processes to produce quality outcomes.

Importance of Processes in Software Development

Understanding QA and QC in Software Development

The Role of QA in the Software Development Process

• QA (Quality Assurance) is a process-oriented role that defines and oversees the software development process, ensuring adherence to established protocols.

• QA involves high-level management, overseeing the entire software development lifecycle (SDLC), from requirements gathering to product release.

• QA's involvement spans all stages of development, focusing on how processes are followed by team members throughout the project.

Distinction Between QA and QC

• While QA is focused on defining processes, QC (Quality Control) specifically pertains to testing the software during its testing phase.

• QC personnel are primarily testers who verify if the software meets customer requirements through actual testing activities.

Focus Areas of QA vs. QC

• The primary goal of QA is to build quality into products by establishing effective processes; whereas QC focuses on testing for quality post-development.

• Both roles aim for quality but differ in approach: QA builds quality through process adherence while QC tests for existing quality issues.

Prevention vs. Detection

• A key difference lies in their objectives: QA aims to prevent defects by ensuring proper process execution, while QC detects defects during testing phases.

• By following defined processes correctly, potential future defects can be minimized or avoided altogether as part of preventive measures.

Involvement Throughout Development

• QA remains involved throughout all phases of development—requirements, design, coding, testing, deployment—ensuring comprehensive oversight.

Understanding QA, QC, and QE in Software Development

Differences Between QA and QC

• The primary goal of software development is to deliver a quality product to the customer. Focus should be on product quality rather than solely on the processes followed.

• Quality Assurance (QA) is process-oriented, while Quality Control (QC) is product-oriented. QA encompasses the entire Software Development Life Cycle (SDLC), whereas QC focuses specifically on testing phases.

• QA involves defining processes throughout all phases of SDLC, while QC personnel are primarily engaged in testing activities. This distinction highlights that QC is a subset of QA.

• QA aims to build quality into products proactively, whereas QC detects defects during testing. Thus, QA prevents issues while QC identifies them post-development.

• Understanding these differences is crucial for interviews as they reflect fundamental concepts in software quality management.

Introduction to Quality Engineering (QE)

• Recently introduced terms include Quality Engineering (QE), which builds upon traditional QA and QC practices by incorporating advanced methodologies.

• QE represents an evolution from QC; it emphasizes automation and coding skills among testers who perform both manual and automated testing.

• Unlike traditional testers under QC, those in QE write code for automated tests, thus integrating programming with testing responsibilities.

• The distinction between software engineers and quality engineers lies in their focus: developers create software through coding, while quality engineers write code specifically for testing purposes.

• QE roles often involve automation testers who contribute to writing test scripts or frameworks alongside traditional testing tasks.

Levels of Software Testing

• The discussion transitions to levels of software testing within the SDLC framework. Key levels include:

• Unit Testing: Tests individual components for functionality after completion.

• Integration Testing: Assesses interactions between integrated units or systems.

• System Testing: Evaluates the complete system's compliance with specified requirements.

• User Acceptance Testing (UAT): Validates the end-to-end business flow from a user's perspective before deployment.

Understanding Software Testing Levels

Unit Testing

• Definition: Unit testing involves testing small modules or components of an application, typically conducted by developers at the code level.

• Process: It is the first level of testing that occurs as soon as coding begins, focusing on individual units or components.

• Components: A unit can be a single feature within a larger software application, such as login functionality in Gmail.

• White Box Technique: Unit testing is classified as a white box testing technique since it requires knowledge of the internal logic and structure of the code being tested.

Integration Testing

• Definition: Integration testing checks data flow and communication between multiple units or modules combined into a single unit.

• Purpose: This level ensures that different parts of the application work together according to customer requirements.

System Testing

• Overview: System testing evaluates the overall functionality of an application to ensure it meets specified requirements.

• Scope: It tests whether each requirement mentioned in the software specifications is functioning correctly.

User Acceptance Testing (UAT)

• Final Stage: UAT occurs after system testing, where testers and users validate that the software meets their needs before final deployment.

Techniques Used in Unit Testing

• Testing Techniques:

• Basis Path Testing

• Control Structure Testing (includes conditional coverage and loop coverage)

• Mutation Testing

Understanding Conditional and Loop Coverage in Programming

Conditional Coverage

• The speaker introduces the concept of conditional coverage using a simple example of finding the largest of two numbers, where a is 10 and b is 20.

• The developer tests conditions by checking if a is greater than b. In this case, since 10 is not greater than 20, the condition evaluates to false, indicating that b is larger.

• If values are switched (e.g., a = 20 and b = 10), the condition becomes true, leading to the output that a is the largest. This illustrates how outputs depend on condition evaluations.

• The importance of verifying both positive and negative inputs for conditions in programming is emphasized as part of conditional coverage testing.

• Developers often write numerous programs with multiple conditions; thus, all conditions must be verified through various data sets.

Loop Coverage

• The speaker transitions to loop coverage, explaining its necessity when repeating statements in programming through loops.

• An example demonstrates printing numbers from 1 to 5 using a loop instead of writing multiple print statements for each number individually.

• A loop structure (while i <= max) allows for repeated execution based on a defined condition. This reduces redundancy in code writing.

• As long as the loop's condition remains true (e.g., starting from 1 up to a maximum value), it will continue executing until it reaches an endpoint (when i exceeds max).

• Loop coverage testing ensures that all iterations execute correctly within specified ranges and verifies whether all expected outputs are produced.

Mutation Testing

Understanding Unit and Integration Testing

Unit Testing Overview

• The speaker introduces a simple login code example, illustrating how user credentials are validated. If the username is "scott" and the password is "password123", access is granted; otherwise, it is denied.

• Mutation testing involves testing the code with various inputs to ensure all conditions are evaluated correctly. For instance, using valid usernames with invalid passwords will trigger different outcomes.

• The concept of mutation testing is explained as a method of repeatedly testing code with diverse data sets to verify its functionality. This technique falls under unique unit testing methods used by developers.

• Developers utilize automation tools like JUnit for conducting unit tests efficiently. Understanding unit testing principles and processes is essential for grasping broader software testing concepts.

• The focus shifts towards system testing, indicating that while unit testing is important, the primary emphasis will be on understanding system-level tests in subsequent discussions.

Transition to Integration Testing

• The speaker transitions to integration testing, emphasizing its significance as a next level of software evaluation after unit tests have been completed.

What Is Integration Testing?

• Integration testing occurs between two or more modules within an application. It assesses how these modules interact and communicate with each other during operation.

• A module represents a specific functionality within software (e.g., login or email composition in Gmail). Each module serves distinct purposes but must work together seamlessly in an application context.

• Examples from applications like Gmail and banking systems illustrate how multiple modules (login, sending money, checking balance) interact during integration tests to ensure proper functionality across features.

Conducting Integration Testing

• To perform integration testing effectively, at least two modules must be integrated first. This process checks data communication between them—ensuring outputs from one module serve as inputs for another.

• The flow of data between integrated modules is crucial; successful output from one module should lead into another's input without errors or miscommunication during integration tests.

Techniques in Integration Testing

• Integration testing can be approached from both developer and tester perspectives. Developers may write code for individual modules before integrating them for functional assessment at the code level.

Integration Testing from Developer and Tester Perspectives

Developer's Approach to Integration Testing

• Developers write code for various functionalities such as login, mailbox operations, and email deletion. They integrate these modules and execute them sequentially to ensure proper functionality.

• After executing the first module successfully, they check if actions like deleting an email reflect correctly in the application (e.g., moving emails to the deleted section). This process is termed integration testing from a developer's perspective.

• This type of testing is categorized as white box testing since it involves examining the internal workings of the code rather than just its outputs.

Tester's Approach to Integration Testing

• Testers focus on user interface (UI) aspects instead of writing code. They verify functionalities through UI elements like username and password fields during integration testing.

• The process includes validating successful logins with correct credentials, checking for existing emails in the mailbox, and ensuring that deleted emails are moved appropriately within the application.

• Both developers and testers conduct integration tests but at different levels: developers test at the code level while testers validate at the application/UI level. This distinction highlights their respective roles in ensuring software quality.

Key Concepts of Integration Testing

• Integration testing focuses on verifying data flow between multiple modules within an application, ensuring that they communicate effectively after being integrated together. This can be done by both developers (code level) and testers (UI level).

• There are two main types of integration testing: incremental integration testing and non-incremental integration testing; however, incremental is more commonly used in practice due to its structured approach to adding modules one at a time.

Incremental Integration Testing Explained

Definition

• Incremental integration testing involves adding modules incrementally while continuously checking data flow between them, rather than integrating all modules simultaneously. Each new module is tested for communication with previously integrated ones before proceeding further.

Approaches

1. Top-down Approach:

• In this method, higher-level modules are tested first while lower-level modules are simulated or stubbed out until they are ready for full implementation.

2. Bottom-up Approach:

• Conversely, this approach starts with lower-level modules which are fully implemented first before integrating higher-level ones.

Incremental Integration Testing: Top-Down and Bottom-Up Approaches

Understanding Module Relationships

• The integration of a new module should be structured as a child of the existing model, ensuring hierarchical relationships in the system.

• Using Gmail as an example, composing an email is identified as a parent module, while sent items serve as its child module.

Top-Down Approach

• In incremental integration testing using the top-down approach, data communication between parent and child modules is verified to ensure proper functionality.

• New modules added must always function as children of existing models; for instance, if deleted items are added later, they become children of the previous model.

Key Characteristics of Top-Down Approach

• The process involves incrementally adding modules and testing data flow to confirm that each new addition is a child module.

• This method emphasizes understanding through relatable examples like composing emails before checking sent items.

Transitioning to Bottom-Up Approach

• The bottom-up approach also focuses on incremental integration but requires that newly added modules act as parents to existing ones.

• For example, if module A exists, integrating another module B above it makes B the parent model.

Testing Methodology in Bottom-Up Approach

• Testing begins with verifying lower-level (child) modules first before integrating higher-level (parent) models for comprehensive validation.

• Both approaches necessitate combining modules for effective testing; independent testing is not viable since one relies on the other’s functionality.

Summary of Integration Approaches

• Both top-down and bottom-up approaches involve incremental additions and focus on ensuring correct data flow between models but differ in their hierarchical structure.

Integration Testing Approaches

Incremental vs Non-Incremental Integration Testing

• The process of adding modules incrementally allows for testing data flow between them, utilizing either a top-down or bottom-up approach.

• Non-incremental integration testing involves integrating all modules at once, which can lead to challenges in identifying defects due to the lack of incremental checks.

• A significant drawback of non-incremental testing is the potential to miss data flow issues between modules, making it harder to pinpoint where defects originate.

• Identifying the root cause of defects becomes complicated when all modules are integrated simultaneously, leading to difficulties in debugging.

• Incremental integration testing is preferred due to its structured approach and reduced risk of missing critical module interactions.

Types of Integration Testing

• There are two main types: incremental and non-incremental integration testing; incremental can be further divided into top-down, bottom-up, and sandwich approaches.

• Non-incremental integration is less favored because it combines all models at once without gradual verification.

System Testing Overview

Importance and Process of System Testing

• System testing is a comprehensive evaluation that typically requires multiple sessions due to its complexity and depth.

• This phase focuses on verifying overall application functionality against customer requirements rather than code specifics.

Functional Features Assessment

• Testers assess whether specific functionalities requested by customers are present and operate correctly within the software application.

• Examples include features like messaging capabilities in applications such as WhatsApp, highlighting the importance of functional validation.

Black Box Testing Technique

• System testing employs a black box technique where testers do not interact with the underlying code but focus on user interface (UI) functionality instead.

Requirement Understanding

• Thorough understanding of customer requirements is crucial for effective system testing; this includes reviewing documentation provided by clients and developers before proceeding with tests.

• System testing follows component and integration tests; it cannot commence until these prior levels have been completed successfully.

Focus Areas in System Testing

Understanding System Testing

Overview of System Testing Categories

• The four main categories of system testing include user interface testing, functional testing, non-functional testing, and usability testing. Each category encompasses various types of tests that will be elaborated on in future sessions.

• It is crucial to understand the type of testing required before conducting it. This theoretical understanding lays the groundwork for practical application.

• The focus is on identifying different types of tests and determining where testers will be involved in the process.

User Interface Testing

• User interface (UI) testing evaluates the application's UI elements, such as image alignment, logo display, and functionality of text boxes and dropdown menus. It also assesses the overall look and feel including colors and fonts.

• Testers check if all navigation flows work correctly within the application’s UI to ensure a seamless user experience.

Functional Testing

• Functional testing focuses on verifying specific functionalities within an application. For example, in a banking app, this includes login processes, balance checks, money transfers, report generation, and checkbook requests.

• Various subtypes under functional testing include input domain testing, error handling testing, and database testing which will be discussed in upcoming sessions.

Non-Functional Testing

• Non-functional testing covers aspects like security, performance (speed), installation compatibility among others. These tests are conducted after confirming that core functionalities are stable.

• Performance testing specifically measures how well an application responds under varying loads from users accessing it simultaneously.

• Different types of non-functional tests include load testing, stress testing, volume testing, and security assessments which require specialized environments not typically available to standard functional testers.

Usability Testing

• Usability testing ensures that user manuals accompanying software products provide clear instructions on usage. This includes installation steps and operational guidance for users.

• The focus is on verifying whether these manuals contain proper content that aids users effectively while using the software product.

• Additionally, usability involves assessing help menus integrated into applications to determine their effectiveness in assisting users with product-related queries.

Conclusion: Importance of System Testing

User Acceptance Testing: The Final Level of Software Testing

Overview of User Acceptance Testing (UAT)

• User Acceptance Testing (UAT) is the final level of software testing conducted after system testing. It is performed by customers or end-users to verify that the software meets their requirements before acceptance.

• UAT includes various phases such as alpha and beta testing, where users test the software in different environments to ensure functionality and satisfaction with the product.

• Alpha testing occurs in a development or testing environment, where users return to the company to conduct tests on the software before it is released for broader use.

• Beta testing follows alpha testing, allowing users to install and test the software in their own environments, providing feedback before full production deployment.

• The session concludes with an overview of four levels of software testing: unit testing, integration testing, system testing, and user acceptance testing.

Future Discussions on System Testing