Index

A

• abstract data types (ADT)
  • about / Motivation
• accessor methods
  • about / Component dependencies
• annotated expectations
  • about / Annotated expectations
• assertions
  • writing, with AssertJ / Writing fluently readable assertions with AssertJ
  • chains, employing / Employing assertion chains
  • own asserts, creating / Creating your own asserts
• AssertJ
  • URL / Choosing the ingredients

B

• basic stubbing
  • about / Basic stubbing
• behavior
  • verifying, with mock / Verifying behavior with mocks
• built-in assertion
  • about / Working with the JUnit built-in assert approach
  • basics / Understanding the basics
  • file session storage, reviewing / Reviewing the file session storage
  • storage behavior, verifying / Verifying the storage behavior
  • assertion helpers, used for improving readability / Improving readability with assertion helpers

C

• closures
  • exceptions, capturing with / Capturing exceptions with closures
• code coverage
  • reports, integrating / Integrating code coverage reports
  • enlarging / Enlarging on code coverage
  • reporting, automating / Automating reporting
• collaborators
  • about / Component dependencies
• collaborators, treating
  • about / Treating collaborators
  • fail fast / Fail fast
  • stubbing, of exceptional behavior / The stubbing of exceptional behavior
• component
  • versus data classes / Component dependencies
• component dependencies
  • about / Component dependencies
• Continuous Integration (CLI)
  • automated build, setting up / Setting up an automated CI build
  • about / What is continuous integration?
  • practices / Principles and practices
  • principles / Principles and practices
  • build, creating / Creating your own build
• create method / Setting up the fixture
• custom rule solutions
  • about / Employing custom solutions
  • system settings, working with / Working with system settings
  • tests, ignoring conditionally / Ignoring tests conditionally

D

• data classes
  • versus component / Component dependencies
• dataset tests, writing
  • about / Writing dataset tests
  • parameterized tests, using / Using parameterized tests
  • glue code, reducing with JUnitParams / Reducing glue code with JUnitParams
  • test descriptions, expressiveness increasing with Burst / Increasing the expressiveness of test descriptions with Burst
• decomposing, requisites
  • about / Decomposing requirements
  • separating concerns / Separating concerns
  • component dependencies / Component dependencies
• DOCs
  • responsibilities, delegating to / Delegating responsibilities to DOCs
• dummy
  • about / Placeholder dummies

E

• Eclipse
  • URL / Choosing the ingredients
• example app
  • about / Introducing the example app
• exceptions
  • verifying, with ExpectedException rule / Verification with the ExpectedException rule
  • capturing, with closures / Capturing exceptions with closures
• ExpectedException rule
  • exceptions, verifying with / Verification with the ExpectedException rule

F

• fail statement
  • using / Using the fail statement
• fake
  • about / Fake it till you make it

G

• GitHub
  • URL / Creating your own build
• GitHub repository
  • URL / Choosing the ingredients

H

• Hamcrest
  • URL / Choosing the ingredients
• Hamcrest matchers
  • applying, to test assertions / Creating flexible expressions of intent with Hamcrest
  • matcher expressions used / Using matcher expressions
  • custom matchers, writing / Writing custom matchers
• happy path
  • about / Start with the happy path
  • corner cases / Conclude with corner cases, After the war

I

• indirect input
  • about / Indirect input and output
  • providing, with stub / Providing indirect input with stubs
  • verifying / Indirect output verification
• indirect output
  • about / Indirect input and output
• interactions
  • recording, with spies / Recording interactions with spies
• isolation
  • about / Component dependencies, Understanding isolation

J

• JaCoCo
  • URL / Choosing the ingredients
• JUnit
  • URL / Choosing the ingredients
  • built-in assertion / Working with the JUnit built-in assert approach
• JUnitParams
  • URL / Choosing the ingredients
  • used, for reducing glue code / Reducing glue code with JUnitParams
• JUnit rules
  • about / Understanding rules, What are JUnit rules?
  • own rules, writing / Writing your own rule
  • fixture, configuring with annotations / Configuring the fixture with annotations
  • advanced concepts / Working with advanced concepts
  • class rules, using / Using ClassRules
  • execution, ordering / The ordering of rule execution

L

• Liskov Substitution Principle
  • about / Motivation

M

• matcher expressions
  • using / Using matcher expressions
• Maven
  • URL / Choosing the ingredients
• Maven Central Repository
  • URL / Choosing the ingredients
• mock
  • used, for verifying behavior / Verifying behavior with mocks
  • about / Verifying behavior with mocks
• mock frameworks
  • used, for increasing efficiency / Increasing efficiency with mock frameworks, The promised land?
• Mockito
  • URL / Choosing the ingredients

P

• parameterized tests
  • using / Using parameterized tests
• patterns, testing
  • about / Testing patterns
  • fail statement used / Using the fail statement
  • annotated expectations / Annotated expectations
  • exceptions, verifying with ExpectedException rule / Verification with the ExpectedException rule
  • exceptions, capturing with closures / Capturing exceptions with closures
• placeholder dummies
  • about / Placeholder dummies
• Project Object Model (POM) / Creating your own build

R

• references / Chapter 1, Chapter 3, Chapter 7, Chapter 8
• responsibilities
  • delelgating, to DOCs / Delegating responsibilities to DOCs
• runners
  • architecture / Understanding the architecture, What are runners good for?
  • methods, implementing / Looking at the big picture
  • extension, writing / Writing your own extension
• runners, custom
  • about / Using custom runners
  • suite, furnishing with test cases / Furnishing a suite with test cases
  • suites, structuring into categories / Structuring suites into categories
  • suites, populating automatically / Populating suites automatically
  • test doubles, creating with annotations / How about creating test doubles with annotations?

S

• sample
  • ingredients, selecting / Choosing the ingredients
  • code, organizing / Organizing your code
• sample application
  • about / Wrapping up the sample application
  • architecture, refining / Refining the architecture
  • concerns, separating into modules / Separating concerns into modules
• self-testing / Principles and practices
• spies
  • interactions, recording with / Recording interactions with spies
• standard widget toolkit [SWT]
  • about / The test helper class
• starter
  • serving / Serving the starter
• stub
  • indirect input, providing with / Providing indirect input with stubs
  • about / Providing indirect input with stubs
• system under test (SUT) / Using a common test structure
  • about / Delegating responsibilities to DOCs

T

• table, setting
  • about / Setting the table
• test doubles
  • unit isolation, performing with / Unit isolation with test doubles
  • working with / Working with test doubles
• test helper class
  • about / The test helper class
• test helper object
  • about / The test helper object
• test helpers
  • using / Using test helpers, Motivation

U

• unit isolation
  • performing, with test doubles / Unit isolation with test doubles
• unit tests
  • about / Why you should busy yourself with unit tests, Understanding the nature of a unit test
  • defect rate, reducing / Reducing the defect rate
  • code quality, improving / Improving the code quality
  • development pace, increasing / Increasing the development pace
  • specification density, enhancing / Enhancing the specification density
  • confidence and courage, boosting / Boosting confidence and courage
  • first test, writing / Writing the first test
  • results, evaluating / Evaluating test results
  • tests, writing first / Writing tests first
  • prefix / Test prefix
  • behavior expressing patterns / Behavior-expressing patterns
  • name, reducing to essentials / Reducing names to the essentials
• unit tests, names
  • searching / Getting the test names right
• unit tests, phases
  • about / The four phases of a unit test
  • common test structure, using / Using a common test structure
  • fixture, setting up / Setting up the fixture
  • Timeline instance / What goes up must come down
  • verification / Verification

X

• Xiliary GitHub repository
  • URL / Improving the code quality