Foundations of Software Testing

ISBN-10: 8131716600

ISBN-13: 9788131716601

Edition: 2007

Authors: Aditya P. Mathur

List price: $74.99
30 day, 100% satisfaction guarantee

If an item you ordered from TextbookRush does not meet your expectations due to an error on our part, simply fill out a return request and then return it by mail within 30 days of ordering it for a full refund of item cost.

Learn more about our returns policy


Basic Approach For undergraduate/graduate students of Computer Science and Computer Engineering and for professionals involved in software development and testing. This book presents sound engineering approaches for test generation, selection, minimization, assessment, and enhancement. Using numerous examples, it offers a lucid description of a wide range of simple to complex techniques for a variety of testing-related tasks. Features Mathematical approach followed to describe a wide range of simple to complex techniques for test generation. Detailed treatment of topics such as test generation from finite state models, combinatorial designs and test selection and minimization for regression testing. Test adequacy assessment using criteria mandated by the FAA and other agencies; data-flow based adequacy and mutation-based adequacy which are the most powerful of the available test adequacy criteria. Step-by-step algorithms to generate tests. Comparative analyses of commercially available testing tools to facilitate tool selection. Table of Contents Part I: PRELIMINARIES 1. Basics of Software Testing Part II: TEST GENERATION 2. Test Generation from Requirements 3. Test Generation from Finite-State Models 4. Test Generation from Combinatorial Designs 5. Test Selection, Minimization and Prioritization for Regression Testing Part III: TEST ADEQUACY ASSESSMENT AND ENHANCEMENT 6. Test-Adequacy: Assessment Using Control Flow and Data Flow 7. Test Adequacy Assessment Using Program Mutation Author Bio(s) Aditya P. Mathur is Professor, and Head, Department of Computer Science, Purdue University, West Lafayette, USA. In this book he brings over 30 years of experience in teaching, researching and consulting in software engineering.
what's this?
Rush Rewards U
Members Receive:
You have reached 400 XP and carrot coins. That is the daily max!
Study Briefs

Limited time offer: Get the first one free! (?)

All the information you need in one place! Each Study Brief is a summary of one specific subject; facts, figures, and explanations to help you learn faster.

Add to cart
Study Briefs
Periodic Table Online content $4.95 $1.99
Add to cart
Study Briefs
SQL Online content $4.95 $1.99
Add to cart
Study Briefs
MS Excel® 2010 Online content $4.95 $1.99
Add to cart
Study Briefs
MS Word® 2010 Online content $4.95 $1.99
Customers also bought

Book details

List price: $74.99
Copyright year: 2007
Publisher: Addison Wesley Professional
Publication date: 4/7/2008
Binding: Hardcover
Pages: 689
Size: 7.50" wide x 9.75" long x 1.75" tall
Weight: 3.586
Language: English

Aditya P Mathur is Professor, and Head, Department of Computer Science, Purdue University, West Lafayette, USA. In this book he brings over 30 years of experience in teaching, researching and consulting in software engineering.

Basics of Software Testing
Humans, errors, and testing
Errors, faults, and failures
Test automation
Developer and tester as two roles
Software quality
Quality attributes
Requirements, behavior, and correctiness
Input domain and program correctness
Valid and invalid inputs
Correctness versus reliability
Program use and the operational profile
Testing and debugging
Preparing a test plan
Constructing test data
Executing the program
Specifying program behavior
Assessing the correctness of program behavior
Construction of oracles
Test metrics
Organizational metrics
Project metrics
Process metrics
Product metrics: Generic
Product metrics: OO software
Progress monitoring and trends
Static and dynamic metrics
Software and hardware testing
Testing and verification
Defect management
Execution history
Test-generation strategies
Static testing
Use of static code analysis tools in static testing
Software complexity and static testing
Model-based testing and model checking
Control-flow graph
Basic block
Flow graph: Definition and pictorial representation
Dominators and postdominators
Program-dependence graph
Data dependence
Control dependence
Strings, languages, and regular expressions
Types of testing
Classifier C1: Source of test generation
Classifier C2: Life cycle phase
Classifier C3: Goal-directed testing
Classifier C4: Artifact under test
Classifier C5: Test process models
The saturation effect
Confidence and true reliability
Saturation region
False sense of confidence
Reducing [Delta]
Impact on test process
Bibliographic Notes
Test Generation
Test Generation from Requirements
The test-selection problem
Equivalence partitioning
Faults targeted
Relations and equivalence partitioning
Equivalence classes for variables
Unidimensional versus multidimensional partitioning
A systematic procedure for equivalence partitioning
Test selection based on equivalence classes
GUI design and equivalence classes
Boundary-value analysis
Category-partition method
Steps in the category-partition method
Cause-effect graphing
Notation used in cause-effect graphing
Creating cause-effect graphs
Decision table from cause-effect graph
Heuristics to avoid combinatorial explosion
Test generation from a decision table
Test generation from predicates
Predicates and boolean expressions
Fault model for predicate testing
Predicate constraints
Predicate-testing criteria
Generating BOR-, BRO-, and BRE-adequate tests
Cause-effect graphs and predicate testing
Fault propagation
Predicate testing in practice
Bibliographic Notes
Test Generation from Finite-State Models
Software design and testing
Finite-state machines
Excitation using an input sequence
Tabular representation
Properties of FSM
Conformance testing
Reset inputs
The testing problem
A fault model
Mutants of FSMs
Fault coverage
Characterization set
Construction of the k-equivalence partitions
Deriving the characterization set
Identification sets
The w-method
Maximum number of states
Computation of the transition cover set
Constructing Z
Deriving a test set
Testing using the W-method
The error-detection process
The partial w-method
Testing using the Wp-method for m = n
Testing using the Wp-method for m > n
The UIO-sequence method
UIO sequences
Core and noncore behavior
Generation of UIO sequences
Distinguishing signatures
Test generation
Test optimization
Fault detection
Automata theoretic versus control-flow-based techniques
Comparing automata-theoretic methods
Bibliographic Notes
Test Generation from Combinatorial Designs
Combinatorial designs
Test configuration and test set
Modeling the input and configuration spaces
A combinatorial test-design process
Fault model
Fault vectors
Latin squares
Mutually orthogonal latin squares
Pairwise design: binary factors
Pairwise design: multivalued factors
Shortcomings of using MOLS for test design
Orthogonal arrays
Mixed-level orthogonal arrays
Covering and mixed-level covering arrays
Covering arrays
Mixed-level covering arrays
Arrays of strength >2
Generating covering arrays
Bibliographic Notes
Test Selection, Minimizations, and Priaritization for Regression Testing
What is regression testing?
Regression-test process
Test revalidation, selection, minimization, and prioritization
Test setup
Test sequencing
Test execution
Output comparison
RTS: the problem
Selecting regression tests
Test all
Random selection
Selecting modification-traversing tests
Test minimization
Test prioritization
Test selection using execution trace
Obtaining the execution trace
Selecting regression tests
Handling function calls
Handling changes in declarations
Test selection using dynamic slicing
Dynamic slicing
Computation of dynamic slices
Selecting tests
Potential dependence
Computing the relevant slice
Addition and deletion of statements
Identifying variables for slicing
Reduced dynamic-dependence graph
Scalability of test-selection algorithms
Test minimization
The set-cover problem
A procedure for test minimization
Test prioritization
Tools for regression testing
Bibliographic Notes
Test Adequacy Assessment and Enhancement
Test Adequacy: Assessment using Control Flow and Data Flow
Test adequacy: basics
What is test adequacy?
Measurement of test adequacy
Test enhancement using measurements of adequacy
Infeasibility and test adequacy
Error detection and test enhancement
Single and multiple executions
Adequacy criteria based on control flow
Statement and block coverage
Conditions and decisions
Decision coverage
Condition coverage
Condition/decision coverage
Multiple condition coverage
Linear code sequence and jump (LCSAJ) coverage
Modified condition/decision coverage
MC/DC-adequate tests for compound conditions
Definition of MC/DC coverage
Minimal MC/DC tests
Error detection and MC/DC adequacy
Short-circuit evaluation and infeasibility
Tracing test cases to requirements
Data-flow concepts
Definitions and uses
c-use and p-use
Global and local definitions and uses
Data-flow graph
Def-clear paths
Def-use pairs
Def-use chains
A little optimization
Data contexts and ordered data contexts
Adequacy criteria based on data flow
c-use coverage
p-use coverage
all-uses coverage
k-dr chain coverage
Using the k-dr chain coverage
Infeasible c-uses and p-uses
Context coverage
Control flow versus data flow
The subsumes relation
Structural and functional testing
Scalability of coverage measurement
Bibliographic Notes
Test-Adequacy Assessment Using Program Mutation
Mutation and mutants
First-order and higher-order mutants
Syntax and semantics of mutants
Strong and weak mutations
Why mutate?
Test assessment using mutation
A procedure for test-adequacy assessment
Alternate procedures for test-adequacy assessment
Distinguished versus killed mutants
Conditions for distinguishing a mutant
Mutation operators
Operator types
Language dependence of mutation operators
Design of mutation operators
Goodness criteria for mutation operators
Founding principles of mutation testing
The competent programmer hypothesis
The coupling effect
Equivalent mutants
Fault detection using mutation
Types of mutants
Mutation operators for C
What is not mutated?
Execution sequence
Effect of an execution sequence
Global and local identifier sets
Global and local reference sets
Mutating program constants
Mutating operators
Mutating statements
Mutating program variables
Mutation operators for java
Traditional mutation operators
Polymorphism and dynamic binding
Method overloading
Java-specific mutation operators
Mutation operators for fortran 77, C, and java: a comparison
Tools for mutation testing
Mutation testing within budget
Prioritizing functions to be mutated
Selecting a subset of mutation operators
Bibliographic Notes
Subject Index
Name Index
Free shipping on orders over $35*

*A minimum purchase of $35 is required. Shipping is provided via FedEx SmartPost® and FedEx Express Saver®. Average delivery time is 1 – 5 business days, but is not guaranteed in that timeframe. Also allow 1 - 2 days for processing. Free shipping is eligible only in the continental United States and excludes Hawaii, Alaska and Puerto Rico. FedEx service marks used by permission."Marketplace" orders are not eligible for free or discounted shipping.

Learn more about the TextbookRush Marketplace.