25-Comp-B11 Advanced Software Design · December 2018
Question 6 of 28: Test Cases Developable Before vs. After Implementation
Nivaar worked solution (AI-drafted; not reviewed by a licensed engineer)
Notes on this paper
17-Comp-B11 Advanced Software Design — National Exams, December 2018. 3 hours, closed book exam with up to 2 aid sheets allowed (written on both sides), no calculator permitted. The paper is organized into five parts, and candidates were instructed to answer any five (5) questions in Part I, any three (3) in Part II, any four (4) in Part III, any two (2) in Part IV, and any five (5) in Part V — only the first questions answered, in each part, as they appear in the answer book are marked. All questions carry equal weight, so the 19 questions actually marked (5+3+4+2+5 of 28) each count for 100/19 ≈ 5.26% of the paper. All 28 questions are answered below for completeness.
Reference texts: Sommerville, Software Engineering (10th ed., Pearson) — software processes, requirements engineering, design principles, dependability; Pressman, Software Engineering: A Practitioner's Approach (9th ed.) — supplementary process and quality coverage; Gamma, Helm, Johnson & Vlissides (GoF), Design Patterns: Elements of Reusable Object-Oriented Software — creational/structural/behavioural pattern catalogue and the "program to an interface, not an implementation" / "favor object composition over class inheritance" principles; Sebesta, Concepts of Programming Languages (12th ed.) — polymorphism, dynamic binding, inheritance and language-level object semantics; Bertrand Meyer, Object-Oriented Software Construction — design by contract, preconditions/postconditions/invariants; Barbara Liskov's 1987 substitutability paper for Question 11; Karl Wiegers, Software Requirements (3rd ed.) — the functional/quality/process/implementation/business requirements taxonomy of Question 2; Kruchten, The Rational Unified Process: An Introduction, for Question 1; Myers, The Art of Software Testing, for Questions 6 and 28.
PART I — General Principles (answer any 5 of 7)
Question 6: Test Cases Developable Before vs. After Implementation (Part I)
Developable before coding: black-box (specification-based) test cases. Any test case derived purely from the SPECIFICATION — equivalence partitioning, boundary value analysis (Question 28), use-case/acceptance scenarios — needs only the requirements/design documentation to write, since it treats the software as an unopened box whose expected input/output behaviour is already fully described by the spec. Writing these before implementation begins is standard practice (test-first / test-driven development takes this to its extreme, writing the test before a single line of the production code): it forces requirements ambiguities to surface early, and it lets test writing proceed in parallel with implementation rather than after it.
Developable only after coding: white-box (structural) test cases. Test cases that target specific internal structure — statement/branch/path coverage, a specific loop-boundary condition, a particular internal data structure's edge case — require knowledge of the ACTUAL code (its control-flow graph, its internal variables) to construct, since the goal is to exercise a specific line, branch, or path that only exists once the code is written. Unit tests aimed at 100% branch coverage of a specific method cannot be finalized until that method's actual branching structure exists.
Consequence for planning. Because black-box tests are spec-derived, a project can and should design its black-box/acceptance test suite during requirements/design, well before a single class is coded — this both validates the specification itself (an untestable requirement is usually an ambiguous one) and shortens the critical path, since white-box tests are the only category that must wait for code to exist.
