Software Testing for Engineers Part 1

Northeastern University via Coursera

Go to class Write review

Details

Go to class

Provider

Coursera
Pricing

Paid Course
Languages

English
Certificate

Certificate Available
Effort

22 hours
Sessions

Self-Paced
Level

Intermediate
Subtitles

English

Found in

Overview

Google, IBM & Meta Certificates — All 10,000+ Courses at 40% Off

One annual plan covers every course and certificate on Coursera. 40% off for a limited time.

Get Full Access

This course covers the principles and processes of validation, verification, and integration for software, and software-intensive systems, including cyber-physical systems. The topics include test automation, testing metrics, test coverage, integration testing, state space exploration for cyber-physical systems, software assurance, and software reliability. Students in this course will learn the principles, tools, applications, and processes that efficiently integrate software elements to meet customer requirements and needs.

Syllabus

Introduction and Motivation

In this module, you will explore the fundamental drivers behind modern software testing practices and understand why testing has evolved from a simple debugging activity into a critical discipline. You will examine how software's pervasiveness across critical infrastructure, financial systems, and safety-critical applications has transformed user expectations and market dynamics, making software failures both intolerable and potentially catastrophic. You will also learn the distinction between verification, validation and the different types of software failures.

Testing Processes and Automation

In this module, you will explore the organizational structure and processes that support effective software testing in modern development environments. You will examine the distinct roles various stakeholders play in testing—from developers conducting unit tests to QA professionals orchestrating comprehensive test strategies—and understand how these roles contribute to software quality. This module introduces other concepts, such as test-driven development and regression testing. This module also includes your first lab, where you gain experience with unit testing using Junit.

Fundamentals of Test Coverage

In this module, you will learn to measure and evaluate test coverage using both black box and white box testing techniques, examining software from the perspective of external behavior as well as internal code structure. Through equivalence testing and boundary value analysis, you will discover how to strategically partition infinite input spaces into manageable test cases that provide meaningful coverage. The module will guide you through the advantages and limitations of both black box and white box approaches, helping you understand when each method is most appropriate and how they complement each other in comprehensive testing strategies. By the end of this module, you will be able to identify equivalence classes, select boundary values, and evaluate test coverage using line-based, decision-based, and method-based metrics.

Control Flow Graphs

In this module, you will explore Control Flow Graphs (CFGs), a powerful white box testing technique that allows you to analyze the internal structure of your code to design comprehensive test cases. While previous modules focused on black box strategies like equivalence partitioning and boundary testing, CFGs shift your attention inward—transforming source code into visual graph representations that reveal all possible execution paths through a program. You'll learn to construct CFGs by systematically labeling statements and decisions, then use these graphs to identify feasible test paths, analyze coverage, and evaluate the thoroughness of your testing strategy. This approach is particularly valuable when working with complex code structures where the number of potential paths can be infinite, requiring you to apply strategic path selection criteria to ensure effective test coverage. By the end of this module, you'll be equipped to bridge the gap between theoretical testing concepts and practical implementation through hands-on work with industry-standard coverage tools.

State Machine Based Coverage

In this module, you will explore state machine-based testing, a powerful approach that allows you to formally model and test the behavior of software systems. You'll begin by reviewing UML State Machine fundamentals, learning how to construct state machines using basic elements like states, transitions, events, and actions, then progress to advanced modeling features, including guard conditions, entry/exit actions, do activities, nested states, history states, and concurrency. Once you've mastered state machine modeling, we shift to focus on leveraging these models as testing tools—learning how to apply state machine coverage metrics such as state coverage, transition coverage, and path coverage to measure the thoroughness of your test suites. Finally, you'll explore how to classify faults in state-based systems using eight distinct categories, helping you systematically identify whether discrepancies arise from implementation errors, specification problems, or test design issues. By the end of this module, you'll be equipped to create formal behavioral models that can drive comprehensive, measurable testing strategies.

Use Case and Scenario Based Coverage

In this module, you will explore use case- and scenario-based testing, learning how to leverage requirements-level models to drive comprehensive test coverage strategies. You'll begin by mastering use case modeling fundamentals, understanding how to identify actors, define use cases, and construct use case diagrams that capture the functional requirements of a system from the end user's perspective. You'll learn to work with, include, and extend relationships, define system boundaries, and distinguish between what's inside and outside your system's scope. Moving beyond basic modeling, you'll dive into the elaboration phase where you'll transform high-level use cases into detailed scenarios that document preconditions, postconditions, main flows, and alternative flows—capturing all the ways users interact with your system, including error conditions and exceptions. You'll then learn to convert these detailed textual scenarios into activity diagrams, which provide visual, graph-based representations of complex workflows. Finally, you'll apply graph coverage criteria to these models, using node coverage, edge coverage, and scenario testing to ensure your test suite thoroughly exercises the system's behavior. By the end of this module, you'll understand how to bridge the gap between requirements and testing, using use case models and activity diagrams not just as documentation tools but as powerful frameworks for defining acceptance tests and measuring test completeness.

Logic Based Coverage

In this module, you will explore logic-based testing, a rigorous approach to analyzing and testing the logical expressions embedded throughout your software systems. You'll learn to dissect predicates (expressions that evaluate to boolean values) into their component clauses and understand how logical operators like AND, OR, and NOT combine these clauses into complex decision logic. Starting with basic coverage criteria, you'll master Predicate Coverage, which requires testing each predicate as both true and false, and Clause Coverage, which ensures each individual clause is exercised in both states. You'll discover the limitations of these approaches—notably that Clause Coverage doesn't guarantee Predicate Coverage—leading you to explore Combinatorial Coverage, which tests all possible combinations of clause values but comes with an exponential cost. To address this practical challenge, you'll learn about active (or major) clauses—clauses that actually determine a predicate's value—and advanced coverage criteria that focus testing efforts on these critical elements. By the end of this module, you'll be equipped with a sophisticated toolkit for ensuring thorough testing of the decision logic that drives software behavior, particularly essential in safety-critical systems where regulatory compliance may legally mandate logic coverage.