Study guide
10.3 Choosing Useful Test Cases: Boundaries, Partitions, Coverage, and Regression
Praxis Computer Science 5652
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Praxis 5652 Exam Overview and ETS Pseudocode
1.1 Praxis 5652 Test Facts, Scoring, and Registration 1.2 Official ETS Pseudocode Notation and Tracing Strategy
2 Chapter 2: Impacts of Computing: Innovation, Access, and Effects
2.1 Computing for Creativity, Problem Solving, Communication, and Innovation 2.2 Equal Access, the Digital Divide, and Accessibility 2.3 Beneficial and Harmful Effects of Computing Innovations
3 Chapter 3: Impacts of Computing: Intellectual Property, Ethics, Privacy, and Security
3.1 Intellectual Property: Copyright, Open Source, and Creative Commons 3.2 Ethical and Unethical Computing Practices and Their Implications 3.3 Privacy, Security, Data Collection, and Local vs. Cloud Storage
4 Chapter 4: Algorithms and Computational Thinking: Abstraction, Decomposition, Number Bases, and Representation
4.1 Abstraction and Abstraction Hierarchies 4.2 Decomposition, Pattern Recognition, and Developing Algorithms 4.3 Number Bases: Binary, Octal, Decimal, and Hexadecimal 4.4 Algorithm Formats: Natural Language, Flowcharts, Pseudocode, and Tracing
5 Chapter 5: Algorithms: Efficiency, Limits of Computing, and Randomization
5.1 Algorithm Efficiency: Linear, Quadratic, Exponential, and Logarithmic Growth 5.2 Limits of Computing: Unsolvable Problems, Intractability, and Heuristics 5.3 Randomization, Random vs. Pseudorandom Numbers, and Scaling to a Range
6 Chapter 6: Algorithms: Searching, Sorting, and Recursion
6.1 Searching Algorithms: Linear Search and Binary Search 6.2 Sorting Algorithms: Tracing, Comparisons, Correctness, and Efficiency 6.3 Recursion: Base Cases, Tracing, Errors, and Iterative Equivalents
7 Chapter 7: Programming: Variables, Data Types, Strings, and Expressions
7.1 Variables, Data Types, and Type Conversion 7.2 Strings and String Operations 7.3 Operators, Precedence, Expressions, and Formulas 7.4 Boolean Expressions, Truth Tables, and Boolean Algebra
8 Chapter 8: Programming: Selection, Iteration, and Writing Code
8.1 Sequence and Selection: if, else, Chained and Nested Conditions 8.2 Iteration: for, while, do … while, and repeat … until Loops 8.3 Reading, Completing, and Modifying Code
9 Chapter 9: Programming: Procedures, Arrays, and Data Structures
9.1 Procedures, Parameters, Return Values, Nested Calls, and Scope 9.2 Arrays, Lists, and Two-Dimensional Arrays 9.3 Stacks, Queues, and Dictionaries (Maps)
10 Chapter 10: Programming: Correctness, Errors, Testing, and Code Quality
10.1 Program Correctness: Preconditions, Postconditions, Invariants, and Testing vs. Proof 10.2 Error Types and Debugging Techniques 10.3 Choosing Useful Test Cases: Boundaries, Partitions, Coverage, and Regression 10.4 Extensibility, Modifiability, and Reusability: Constants and Parameterization 10.5 Documentation, Code Reviews, Peer Feedback, and End-User Feedback
11 Chapter 11: Programming: Events, Usability, Input Validation, and APIs
11.1 Event-Driven Programming, Asynchronous Events, and Concurrency 11.2 Usability, Meaningful Error Messages, and Input Validation vs. Verification 11.3 Libraries and APIs: Reading Definitions, Making Calls, and Weighing Trade-offs
12 Chapter 12: Programming: Languages, Tools, Paradigms, and Object-Oriented Design
12.1 Low- and High-Level Languages, Compilers and Interpreters, and IDEs 12.2 Programming Paradigms: Procedural, Object-Oriented, and Others 12.3 Classes, Objects, Instance Variables, Methods, and Encapsulation 12.4 Inheritance, Polymorphism, and Overloading vs. Overriding
13 Chapter 13: Data: Bits, Encoding, Compression, and Encryption
13.1 Bits and Bytes: Why Binary, Storage Calculations, and Signed Integers 13.2 Encoding Text, Images, and Sound 13.3 Lossless and Lossy Compression: Run-Length Encoding, Huffman Coding, and Media Formats 13.4 Encoding vs. Encryption, Symmetric and Public-Key Encryption, and Their Trade-offs
14 Chapter 14: Data: Analysis Tools, Simulation, Storage, and Collection
14.1 Analyzing Data with Spreadsheets: Cleaning, Transforming, and Visualizing 14.2 Simulation and Modeling 14.3 Files, Databases, and Storage Requirements: Scale, Redundancy, and Backup 14.4 Collecting, Aggregating, and Generating Data: Public Data Sets, Surveys, Sensors, and Crowdsourcing
15 Chapter 15: Computing Systems: Hardware, Operating Systems, and Computing Environments
15.1 Hardware Components and the Fetch–Decode–Execute Cycle 15.2 Operating Systems, Software Components, and Resource Issues 15.3 Embedded Systems, the Internet of Things, and Types of Computing Systems 15.4 Local, Network, and Cloud Computing and Storage; How Binary Data Are Stored
16 Chapter 16: Networks, the Internet, the Web, and Cybersecurity
16.1 Network Types and Wired and Wireless Communication 16.2 Network Hardware and Layered Network Models (OSI and TCP/IP) 16.3 Network Performance: Bandwidth, Latency, Load, and Estimating Needs 16.4 How the Internet Works: Protocols, IP Addressing, DNS, URLs, and Reliability 16.5 The Web: HTTP, HTML and Markup Languages, Browsers, Servers, and Clients 16.6 Cybersecurity: The Five Pillars, Strong Passwords, Security Strategies, and Trade-offs
10.3 Choosing Useful Test Cases: Boundaries, Partitions, Coverage, and Regression
Key Takeaways Explain This Topic AI
A useful test case has a specific input and a known expected output, and it targets a situation likely to reveal a defect.
Equivalence partitioning divides inputs into groups the code should treat the same way and tests one value from each group, including invalid groups.
Boundary value analysis tests values at, just below, and just above each boundary, because off-by-one errors cluster there.
To show that code fails, choose an input that sends execution down the suspect path and whose correct answer differs from what the code produces.
Regression testing reruns existing tests after a change to confirm that nothing that used to work is now broken.
Last updated: September 2026
What this competency asks
Under debugging and testing, ETS asks you to identify which test cases are most useful for given code . ETS's sample question shows a segment meant to store the largest of three numbers, a, b, and c, in max . It asks which set of values demonstrates that the segment does not work . The correct choice sends execution into the one branch that forgets to assign max . This section gives you a method for such questions.
What makes a test case useful
A test case is an input together with its expected output . A test is useful when it could reveal a defect that other tests would miss. Ten tests that all follow the same path through the code add little over one.
Equivalence partitioning
Divide the possible inputs into partitions , groups the program should treat the same way, and test one representative from each, including invalid partitions.
Example: a ticket price is $5 for ages 0–12, $10 for ages 13–64, and $6 for ages 65 and up. Negative ages are invalid.
- Partition Representative Expected
- Invalid (below 0) −4 Error message
- Child (0–12) 7 $5
- Adult (13–64) 30 $10
- Senior (65 and up) 80 $6
- Boundary value analysis
Defects cluster at the edges of partitions, where < and ≤ are easy to confuse. For each boundary, test the value at it, just below it, and just above it.
For a rule that accepts 12 ≤ age ≤ 17, the boundary tests are 11, 12, 13, 16, 17, 18 . If the code wrongly used age < 17 , the test with 17 fails immediately. Middle values like 14 and 15 would pass either version, so they cannot catch this bug.
Finding the input that exposes a bug
Method:
Read the code and find the suspect path : a branch that does not assign something, a boundary comparison, or an unusual case.
Choose an input that reaches that path.
Confirm that the correct answer differs from what the code actually produces.
- Example: // intended: return true if year is a leap year
- boolean isLeap ( int year )
- if ( year % 4 == 0 )
- return true
- else
- return false
- end if
- end isLeap
The full rule: a year is a leap year if it is divisible by 4, except century years, which must be divisible by 400. Consider these tests:
Year Code returns Correct Reveals bug?
- 2024 true true No
- 2023 false false No
- 2000 true true (divisible by 400) No
- 1900 true false Yes
Only 1900 exposes the missing century rule. A test must both reach the faulty logic and have a different correct answer . The year 2000 reaches the century case, but the code happens to return the correct answer anyway.
Coverage: exercising the code itself
White-box testing chooses inputs by looking at the code. Black-box testing chooses them from the specification alone.
- Coverage goal Requirement
- Statement coverage Every statement runs at least once
- Branch coverage Every condition evaluates to both true and false at least once, so every branch runs
- Path coverage Every possible route through the code runs (often impractical with loops)
Branch coverage is stronger than statement coverage. An if with no else can have every statement covered by a single true case, while the false case, which might be the buggy one, is never tried.
- Special cases worth a test
- Empty input: an empty array or empty string
- One element
- Equal values, such as ties when finding a maximum, or duplicates in a sort
- Extremes: 0, negative numbers, and the largest expected values
- Already sorted and reverse-sorted data for sorting code
- Invalid input, such as text where a number is expected, to test validation (Section 11.2)
- Levels of testing
- Level What is tested Example
- Unit One procedure or class by itself Test isLeap with many years
Integration Modules working together Does the date parser pass correct years to isLeap ?
System The complete program against its requirements Can a user book a February 29 appointment in a leap year?
- Acceptance Whether the users' needs are met Teachers try the scheduling tool
- Regression Rerunning earlier tests after a change After fixing isLeap , rerun every date test
Regression testing matters because fixes can break other things. Automated test suites make it cheap to rerun every test after every change.
Writing expected results first
Decide the expected output before running the test, from the specification or a hand calculation. A test with no expected result can only show that a program runs, not that it is right. Teachers can model this habit by having students write test tables before they write code.