Test-driven development
21 of 133 
Dollar
Dollar  
Dollar(
int
int amount) { 
thiiss.amount
=
 amount
;
we can use it in times(): 
Dollar
Dollar  
void
void t
imes(
int
int mul
t
iplier) { 
amount
=
 amount * 2
;
The value of the parameter “mult iplier” is 2, so we can substitute the parameter for the 
constant: 
Dollar
Dollar  
void
void t
imes(
int
int mul
t
iplier) { 
amount
=
 amount * mul
t
iplier;
To demonstrate our thorough-going knowledge of Java syntax, we will want to use the 
“*=” operator (which does, it must  be said, reduce duplication): 
Dollar
Dollar  
void
void t
imes(
int
int mul
t
iplier) { 
amount *=
 mul
t
iplier;
We can now mark off the first test as done: 
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 
*
2 = $
10
Make “amoun
t
” pr
iv
a
t
Do
ll
ar 
si
de-effec
ts
Money round
i
ng? 
Next we’ll take care of those strange side effects. First, though, let’s review. We:  
· Made a list of the tests we knew we needed to have working 
· Told a story with a snippet of code about how we wanted to view one 
operation 
· Ignored the details of JUnit for the moment 
· Made the test compile with stubs 
· Made the test run by committing horrible sins 
· Gradually generalized the working code, replacing constants with variables 
· Added items to our to-do list rather than addressing them all at once 
Pdf merger - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
reader combine pdf pages; merge pdf online
Pdf merger - VB.NET PDF File Merge Library: Merge, append PDF files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Guide and Sample Codes to Merge PDF Documents in .NET Project
reader create pdf multiple files; all jpg to one pdf converter
Test-driven development
22 of 133 
Degenerate Objects 
We got one test working, but in the process we noticed something strange— when we 
perform an operation on a Dollar, the Dollar changes. I would like to be able to write: 
public
public voidd testMul
t
iplicat
ion() { 
Dollar five=
 neww Dollar(5)
;
five.
t
imes(2)
;
assertEquals(10
,
 five.amount)
;
five.
t
imes(3)
;
assertEquals(15
,
 five.amount)
;
I can’t imagine a clean way to get this test working. After the first call to times(), five 
isn’t five any more, it’s really ten. If, however, we return a new object from times(),  
we can multiply our original five bucks all day and never have it change. We are 
changing the interface of Dollar when we make this change, so we have to change the 
test. That’s okay. Our guesses about the right interface are no more likely to be perfect 
than our guesses about the right implementation. 
public
public voidd testMul
t
iplicat
ion() { 
Dollar five=
 neww Dollar(5)
;
Dollar product
=
 five.
t
imes(2)
;
assertEquals(10
,
 product
.amount)
;
product
=
 five.
t
imes(3)
;
assertEquals(15
,
 product
.amount)
;
The new test won’t compile until we change the declaration of Dollar.times(): 
Dollar
Dollar  
Dollar t
imes(
int
int mul
t
iplier) { 
amount *=
 mul
t
iplier;
return
return null
null;
Now the test compiles, but it doesn’t run. Progress! Making it run requires that we 
return a new Dollar with the correct amount: 
Dollar
Dollar  
Dollar t
imes(
int
int mul
t
iplier) { 
return
return nneww Dollar(amount * mul
t
iplier)
;
In the last chapter when we made a test work we started with a bogus implementation 
and gradually made it real. Here, we typed in what we thought was the right 
implementation and prayed while the tests ran (short prayers, to be sure, because 
running the test takes a few milliseconds.) Because we got lucky and the test ran, we 
can cross off another item: 
C# PDF: C#.NET PDF Document Merging & Splitting Control SDK
In order to help you have a quicker and better understanding of this C#.NET PDF merger & splitter control SDK, we will illustrate the PDF document merging and
asp.net merge pdf files; pdf split and merge
C# Word: .NET Merger & Splitter Control to Merge & Split MS Word
to form a larger Word file or how to divide source MS Word file into several smaller documents, RasterEdge designs this C#.NET MS Word merger & splitter
how to combine pdf files; pdf combine two pages into one
Test-driven development
23 of 133 
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 
*
2 = $
10
Make “amoun
t
” pr
iv
a
t
Do
ll
ar 
si
de
-
effec
ts
?
Money round
i
ng? 
These are two of the three strategies for quickly getting to green: 
· Fake It— — return a constant and gradually replace constants with variables until 
you have the real code 
· Obvious Implementation— type in the real implementation 
When I use TDD in practice, I commonly shift between these two modes of 
implementation. When everything is going smoothly and I know what to type, I put in 
obvious implementation after obvious implementation (running the tests all the time to 
ensure that what’s obvious to me is still obvious to the computer). As soon as I get an 
unexpected red bar, I back up, shift to faking implementations, and refactor to the right 
code. When my confidence is back, I go back to obvious implementations. 
There is a third style of driving development, triangulation, which we will demonstrate 
in the next chapter. However, to review, we: 
· Translated a design objection (side effects) into a test case that failed because 
of the objection 
· Got the code to compile quickly with a stub implementation 
· Made the test work by typing in what seemed like the right code 
The translation of a feeling (disgust at side effects) into a test (multiply the same 
Dollar twice) is a common theme of TDD. The longer I do this, the better able I am to 
translate my aesthetic judgements into tests. When I can do this, my design 
discussions become much more interesting. First we can talk about whether the system 
should work like this or like that. Once we decide on the correct behavior, we can talk 
about the best way of achieving that behavior. We can speculate about truth and 
beauty all we want over beers, but while we are programming we can leave airy-fairy 
discussions behind and talk cases. 
VB.NET TIFF: .NET TIFF Merger SDK to Combine TIFF Files
A 2: Yes, this VB.NET TIFF merger SDK allows developers to achieve We are dedicated to provide powerful & profession imaging controls, PDF document, image to
reader combine pdf; scan multiple pages into one pdf
VB.NET Word: Merge Multiple Word Files & Split Word Document
Word processing and editing controls, this VB.NET Word merger and splitter are dedicated to provide powerful & profession imaging controls, PDF document, image
append pdf; acrobat merge pdf
Test-driven development
24 of 133 
Equality for All 
If I have an integer and I add 1 to it, I don’t expect the original integer to change, I 
expect to use the new value. Objects usually don’t behave that way. If I have a 
Contract and I add one to its coverage, the Contract’s coverage should change (yes, 
yes, subject to all sorts of interesting business rules which do not concern us here.) 
We can use objects as values, as we are using our Dollar now. The pattern for this is 
Value Object. One of the constraints on Value Objects is that the values of the 
instance variables of the object never change once they have been set in the 
constructor. 
There is one huge advantage to using value objects— you don’t have to worry about 
aliasing problems. Say I have one Check and I set its amount to $5, and then I set 
another Check’s amount to the same $5. Some of the nastiest bugs in my career have 
come when changing the first Check’s value inadvertently changed the second 
Check’s value. This is aliasing. 
When you have value objects, you don’t have to worry about aliasing. If I have $5, I 
am guaranteed that it will always and forever be $5. If someone wants $7, they have to 
make an entirely new object. 
One implication of Value Object is all operations must return a new object, as we saw 
in the previous chapter. Another implication is that value objects should implement 
equals(), since one $5 is pretty much as good as another: 
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 
*
2 = $
10
Make “amoun
t
” pr
iv
a
t
Do
ll
ar 
si
de
-
effec
ts
?
Money round
i
ng? 
Equa
ls
() 
If you use Dollars as the key to a hash table, you have to implement hashCode() if you 
implement equals(). We’ll put that in the list, too, and get to it when it’s a problem.  
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 
*
2 = $
10
Make “amoun
t
” pr
iv
a
t
Do
ll
ar 
si
de
-
effec
ts
?
Money round
i
ng? 
Equa
ls
() 
Ha
s
hCode() 
You aren’t thinking about the implementation of equals(), are you? Good. Me neither. 
After snapping the back of my hand with a ruler, I’m thinking about how to test 
equality. First, $5 should equal $5: 
public void testEquality() { 
assertTrue(new Dollar(5).equals(new Dollar(5))); 
The bar turns obligingly red. The fake implementation is to just return true: 
C# PowerPoint: C# Codes to Combine & Split PowerPoint Documents
of RasterEdge .NET Imaging SDK is some like PowerPoint file merger in its are dedicated to provide powerful & profession imaging controls, PDF document, tiff
best pdf combiner; append pdf files reader
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
C# PDF Page Processing: Merge PDF Files - C#.NET PDF document merger APIs for combining two different PDF documents into one large PDF file.
pdf merger online; reader merge pdf
Test-driven development
25 of 133 
Dollar
Dollar  
public
public boolean
boolean equals(Object object) { 
return
return true
true;
You and I both know that “true” is really “5 == 5” which is really “amount
== 5” 
which is really “amount == dollar.amount”. If I went through these steps, though, I 
wouldn’t be able to demonstrate the third and most conservative implementation 
strategy, triangulation. 
If two receiving stations at a known distance from each other can both measure the 
direction of a radio signal, there is enough information to calculate the range and 
bearing of the signal (if you remember more trigonometry than I do, anyway.) This 
calculation is called triangulation. 
By analogy, when we triangulate, we only generalize code when we have two more 
more examples. We briefly ignore the duplication between test and model code. When 
the second example demands a more general solution, then and only then do we 
generalize. 
So, to triangulate we need a second example. How about $5 != $6?  
public void testEquality() { 
assertTrue(new Dollar(5).equals(new Dollar(5))); 
assertFalse(new Dollar(5).equals(new Dollar(6))); 
Now we need to generalize equality: 
Dollar
Dollar  
public
public boolean
boolean equals(Object object) { 
Dollar dollar=
 (Dollar) object
;
return
return amount 
==
 dollar.amount
;
We could have used triangulation to drive the generalization of times(), also. If we had 
$5 x 2 = $10 and $5 x 3 = $15 we would no longer have been able to return a constant. 
Triangulation feels funny to me. I only use it when I am completely unsure of how to 
refactor. If I can see how to eliminate duplication between code and tests and create 
the general solution, I just do it. Why would I need to write another test to give me 
permission to write what I probably could have written the first time? 
However, when the design thoughts just aren’t coming, triangulation gives you a 
chance to think about the problem from a slightly different direction. What axes of 
variability are you trying to support in your design? Make some of the them vary and 
the answer may become clearer. 
So, equality is done for the moment. (What about comparing with null and comparing 
with other objects? Add those to the list.) 
VB.NET TIFF: Merge and Split TIFF Documents with RasterEdge .NET
Besides TIFF document merger and splitter, RasterEdge still provides other market-leading to provide powerful & profession imaging controls, PDF document, tiff
combine pdfs online; apple merge pdf
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
here is what you are looking for - RasterEdge VB.NET PPT Document Merger and Splitter Note: If you want to see more PDF processing functions in VB.NET, please
add pdf files together online; build pdf from multiple files
Test-driven development
26 of 133 
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 
*
= $
10
Make “amoun
t
” pr
iv
a
t
Do
ll
ar 
si
de
-
effec
ts
?
Money round
i
ng? 
Equa
ls
()
Ha
s
hCode() 
Equa
l
nu
ll
Equa
l
ob
j
ec
t
Now that we have equality, we can directly compare Dollars to Dollars. That will let 
us make amount private, as all good instance variables should be. Reviewing the 
above, though, we: 
· Noticed that our design pattern (Value Object) implied an operation 
· Tested for that operation 
· Implemented it simply 
· Didn’t refactor immediately, but instead tested further 
· Refactored to capture the two cases at once 
Test-driven development
27 of 133 
Privacy 
Now that we have defined equality, we can use it to make out tests more “speaking”. 
Conceptually, the operation Dollar.times() should return a Dollar whose value is the 
value of the receiver times the multiplier. Our test doesn’t exactly say that: 
public void testMultiplication() { 
Dollar five= new Dollar(5); 
Dollar product= five.times(2); 
assertEquals(10, product.amount); 
product= five.times(3); 
assertEquals(15, product.amount); 
We can rewrite the first assertion to compare Dollars to Dollars. 
public void testMultiplication() { 
Dollar five= new Dollar(5); 
Dollar product= five.times(2); 
assertEquals(new Dollar(10), product); 
product= five.times(3); 
assertEquals(15, product.amount); 
That looks better, so we rewrite the second assertion, too: 
public void testMultiplication() { 
Dollar five= new Dollar(5); 
Dollar product= five.times(2); 
assertEquals(new Dollar(10), product); 
product= five.times(3); 
assertEquals(new Dollar(15), product); 
Now the temporary variable “pr r oduct” isn’t helping much, so we can inline it:  
public void testMultiplication() { 
Dollar five= new Dollar(5); 
assertEquals(new Dollar(10), five.times(2)); 
assertEquals(new Dollar(15), five.times(3)); 
This test speaks to us more clearly, as if it were an assertion of truth, not a sequence of 
operations. 
With these changes to the test, Dollar is now the only class using its “amount” 
instance variable, so we can make it private: 
Dollar
Dollar  
private
private 
int
int amount
;
And we can cross another item off the list: 
Test-driven development
28 of 133 
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 
*
2 = $
10
Make “amoun
t
” pr
iv
a
t
e
Do
ll
ar 
si
de
-
effec
ts
?
Money round
i
ng? 
Equa
ls
()
Ha
s
hCode() 
Equa
l
nu
ll
Equa
l
ob
j
ec
t
Notice that we have opened ourselves up to a risk. If the test for equality fails to 
accurately check that equality is working, the test for multiplication could also fail to 
accurately check that multiplication is working. That is a risk you actively manage in 
TDD. We aren’t striving for perfection. By saying everything two ways, as both code 
and tests, we hope to reduce our defects enough to move forward with confidence. 
From time to time our reasoning will fail us and a defect will slip through. When that 
happens, we learn our lesson about the test we should have written and move on. The 
rest of the time we go forward boldly under our bravely flapping green bar (my bar 
doesn’t actually flap, but one can dream.) 
Reviewing, we: 
· Used functionality just developed to improve a test 
· Noticed that if two tests fail at once we’re sunk 
· Proceeded in spite of the risk 
· Used new functionality in the object under test to reduce coupling between the 
tests and the code 
Test-driven development
29 of 133 
Franc-ly Speaking 
How are we going to approach the first test on that list?  
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 
*
2 = $
10
Make “amoun
t
” pr
i
v
a
t
e
Do
ll
ar 
si
de
-
effec
ts
?
Money round
i
ng? 
Equa
ls
()
Ha
s
hCode() 
Equa
l
nu
ll
Equa
l
ob
j
ec
t
That’s the test that’s most interesting. It still seems to be a big leap. I’m not sure I can 
write a test that I can implement in one little step. A pre-requisite seems to be having 
an object like Dollar, but to represent Francs. If we can get Francs working like 
Dollars work now, we’ll be closer to being able to write and run the mixed addition 
test. 
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 
*
2 = $
10
Make “amoun
t
” pr
iv
a
t
e
Do
ll
ar 
si
de
-
effec
ts
?
Money round
i
ng? 
Equa
ls
()
Ha
s
hCode() 
Equa
l
nu
ll
Equa
l
ob
j
ec
t
5 CHF 
*
2 = 
10
CHF 
We can copy and edit the Dollar test: 
public void testFrancMultiplication() { 
Franc five= new Franc(5); 
assertEquals(new Franc(10), five.times(2)); 
assertEquals(new Franc(15), five.times(3)); 
(Aren’t you glad we simplified the test in the last chapter? That made our job here 
easier. Isn’t it amazing how often things work out like this in books? I didn’t actually 
plan it that way this time, but I won’t make promises for the future.) 
What short step will get us to a green bar? Copying the Dollar code and replacing 
“Dollar” with “Franc”.
Stop. Hold on. I can hear the aesthetically inclined among you sneering and spitting. 
Copy and paste reuse? The death of abstraction? The killer of clean design? 
If you’re upset, take a cleansing breath. In…hold…out. There. Now, our cycle has 
different phases (they go by quickly, often in seconds, but they are phases.): 
1. Write a test 
2. Make it compile 
Test-driven development
30 of 133 
3. Make it run 
4. Remove duplication 
The different phases have different purposes. They call for different styles of solution, 
different aesthetic viewpoints. The first three phases need to go by quickly, so we get 
to a known state with the new functionality. You can commit any number of sins to 
get there, because speed trumps design, just for that brief moment. 
Now I’m worried. I’ve given you a license to abandon all the principles of good 
design. Off you go to your teams— “Kent says all that design stuff doesn’t matter.” 
Halt. The cycle is not complete. A three legged horse can’t gallop. The first three steps 
of the cycle won’t work without the fourth. Good design at good times. Make it run, 
make it right. 
There, I feel better. Now I’m sure you won’t show anyone except your part ner your 
code until you’ve removed the duplication. Where were we? Ah, yes. Violating all the 
tenets of good design in the interest of speed (penance for our sin will occupy the next 
several chapters.) 
Franc
Franc  
class
class Franc { 
private
private 
int
int amount
;
Franc(
int
int amount) { 
thiiss.amount
=
 amount
;
Franc t
imes(
int
int mul
t
iplier) { 
return
return nneww Franc(amount * mul
t
iplier)
;
public
public boolean
boolean equals(Object object) { 
Franc franc=
 (Franc) object
;
return
return amount 
==
 franc
.amount
;
Because the step to running code was so short, we were even able to skip the “make it 
compile” step.  
Now we have duplication galore, and we have to eliminate it before writing our next 
test. We’ll start by generalizing equals(). However, we can cross off an item, even 
though we have to add two more: 
Documents you may be interested
Documents you may be interested