Test-driven development
31 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
5 CHF 
*
2 = 
10
CHF
Do
ll
ar/Franc dup
li
ca
ti
on 
Common equa
ls
Reviewing, we: 
· Couldn’t tackle a big test, so we invented a small test that represented progress 
· Wrote the test by shamelessly duplicating and editing 
· Even worse, made the test work by copying and editing model code wholesale 
· Promised ourselves we wouldn’t go home until the duplication was gone 
Pdf merge documents - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
pdf combine files online; reader create pdf multiple files
Pdf merge documents - 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
acrobat merge pdf; acrobat combine pdf files
Test-driven development
32 of 133 
Equality for All, Redux 
There is a fabulous sequence in Wallace Stegner’s Crossing to Safety where he 
describes a character’s workshop. Every item is perfectly in place, the floor is spotless, 
all is order and cleanliness. The character, however, has never made anything. 
“Preparing has been his life’s work. He prepares, then he cleans up.” (This is also the 
book that sent me audibly blubbering in business class on a trans-Atlantic 747, so 
please read it with caution.) 
We have avoided this trap in the last chapter. We actually got a new test case working. 
However, we sinned mightily so we could do it quickly. Now it is time to clean up. 
One possibility is to make one of our classes extend the other. I tried it, and it hardly 
saves any code at all. Instead, we are going to find a common superclass for the two 
classes (I tried this already, too, and it works out great, although it will take a while.) 
Add a picture here 
What if we had a Money class to capture the common equals code? We can start 
small: 
Money
Money  
class
class Money 
All the tests still run (not that we could possibly have broken anything, but that’s a 
good time to run the tests anyway.) 
If Dollar extends Money, that can’t possibly break anything. 
Dollar
Dollar  
class
class Dollar ex
tends
ex
tends Money { 
private
private 
int
int amount
;
Can it? No, the tests still all run. Now we can move the “amount” instance variable up 
to Money: 
Money
Money  
class
class Money { 
protected 
int 
protected 
int amount
;
amount
;
Dollar
Dollar  
class
class Dollar ex
tends
ex
tends Money { 
The visibility has to change from private to protected so the subclass can still see it. (If 
we’d wanted to go even slower we could have declared the field in Money in one step, 
and then removed it from Dollar in a second step. I’m feeling bold.) 
Now we can work on getting the equals() code ready to move up. First we change the 
declaration of the temporary variable: 
C# XDoc.HTML5 Viewer- Supported File Formats
FREE TRIAL: HOW TO: XDoc.HTML5 Viewer for C#▶: C# ASP.NET: View documents; C# ASP.NET PDF to HTML; C#: Convert PDF to Jpeg; C# File: Compress PDF; C# File: Merge
c# combine pdf; pdf merger online
C# Word - Merge Word Documents in C#.NET
C# Word - Merge Word Documents in C#.NET. Provide C# Demo Codes for Merging and Appending Word Document. Overview. RasterEdge C#.NET
pdf mail merge; add pdf together
Test-driven development
33 of 133 
Dollar
Dollar  
public
public boolean
boolean equals(Object object) { 
Money dollar=
 (Dollar) object
;
Money dollar=
 (Dollar) object
;
return
return amount 
==
 dollar.amount
;
All the tests still run. Now we change the cast: 
Dollar
Dollar  
public
public boolean
boolean equals(Object object) { 
Money dollar=
 (Money) object
;
Money dollar=
 (Money) object
;
return
return amount 
==
 dollar.amount
;
To be communicative, we should also change the name of the temporary variable: 
Dollar
Dollar  
public
public boolean
boolean equals(Object object) { 
Money money
money=
 (Money) object
;
return
return amount 
==
 money
money.amount
;
Now we can move it from Dollar to Money: 
Money
Money  
public
public boolean
boolean equals(Object object) { 
Money money=
 (Money) object
;
return
return amount 
==
 money.amount
;
Now we need to eliminate Franc.equals(). First we notice that the tests for equality 
don’t cover comparing Francs to Francs. Our sins in copying code are catching up 
with us. Before we change the code, we’ll write the tests that should have been there 
in the first place. 
You will often be TDDing in code that doesn’t have adequate tests (at least for the 
next decade or so). When you don’t have enough tests, you are bound to come across 
refactorings that aren’t supported by tests. You could make a refactoring mistake and 
the tests would all still run. What do you do? 
As here, write the tests you wish you had. If you don’t, you will eventually break 
something while refactoring. Then you’ll get bad feelings about refactoring and stop 
doing it so much. Then your design will deteriorate. You’ll be fired. Your dog will 
leave you. Your teeth will go bad. So, to keep your teeth healthy, retroactively test 
before refactoring. 
Fortunately, here the tests are easy to write. We just copy the tests for Dollar: 
public void testEquality() { 
assertTrue(new Dollar(5).equals(new Dollar(5))); 
assertFalse(new Dollar(5).equals(new Dollar(6))); 
assertTrue(new Franc(5).equals(new Franc(5))); 
assertFalse(new Franc(5).equals(new Franc(6))); 
More duplication, two lines more! We’ll atone for these sins, too. 
C# PowerPoint - Merge PowerPoint Documents in C#.NET
C# PowerPoint - Merge PowerPoint Documents in C#.NET. Provide C# Demo Codes for Merging and Appending PowerPoint Document. Overview.
pdf merge; pdf merger
C# PDF Print Library: Print PDF documents in C#.net, ASP.NET
FREE TRIAL: HOW TO: XDoc.HTML5 Viewer for C#▶: C# ASP.NET: View documents; C# ASP.NET PDF to HTML; C#: Convert PDF to Jpeg; C# File: Compress PDF; C# File: Merge
scan multiple pages into one pdf; reader merge pdf
Test-driven development
34 of 133 
Tests in place, we can have Franc extend Money: 
Franc
Franc  
class
class Franc ex
tends
ex
tends Money { 
private
private 
int
int amount
;
We can delete Franc’s field “amount” in favor of the one in Money:  
Franc
Franc  
class
class Franc ex
tends
ex
tends Money { 
Franc.equals() is almost the same as Money.equal(). If we make them precisely the 
same, we can delete the implementation in Franc without changing the meaning of the 
program. First we change the declaration of the temporary variable: 
Franc
Franc  
public
public boolean
boolean equals(Object object) { 
Money franc=
 (Franc) object
;
return
return amount 
==
 franc
.amount
;
Then we change the cast: 
Franc
Franc  
public
public boolean
boolean equals(Object object) { 
Money franc=
 (Money) object
;
return
return amount 
==
 franc
.amount
;
Do we really have to change the name of the temporary variable to match the 
superclass? I’ll leave it up to your conscience… Okay, we’l
l do it: 
Franc
Franc  
public
public boolean
boolean equals(Object object) { 
Money money=
 (Money) object
;
return
return amount 
==
 money.amount
;
Now there is no difference between Franc.equals() and Money.equals(), so we delete 
the redundant implementation in Franc. And run the tests. They run. 
What happens when we compare Francs and Dollars? We’ll get to that in the next 
chapter. Reviewing what we did here, we: 
· Stepwise moved common code from one class (Dollar) to a superclass 
(Money) 
· Made a second class (Franc) also a subclass 
· Reconciled two implementations (equals()) before eliminating the redundant 
one 
VB.NET PDF Print Library: Print PDF documents in vb.net, ASP.NET
FREE TRIAL: HOW TO: XDoc.HTML5 Viewer for C#▶: C# ASP.NET: View documents; C# ASP.NET PDF to HTML; C#: Convert PDF to Jpeg; C# File: Compress PDF; C# File: Merge
batch pdf merger; pdf merge documents
XDoc.HTML5 Viewer for .NET, Zero Footprint AJAX Document Image
controls, PDF document, image to pdf files and components for capturing, viewing, processing, converting, compressing and stroing images, documents and more.
batch combine pdf; build pdf from multiple files
Test-driven development
35 of 133 
Apples and Oranges 
The thought struck us at the end of the last chapter— what happens when we compare 
Francs and Dollars? We dutifully turned our dreadful thought into an item on our to-
do list. But we just can’t get it out of our heads. What does happen? 
public void testEquality() { 
assertTrue(new Dollar(5).equals(new Dollar(5))); 
assertFalse(new Dollar(5).equals(new Dollar(6))); 
assertTrue(new Franc(5).equals(new Franc(5))); 
assertFalse(new Franc(5).equals(new Franc(6))); 
assertFalse(new Franc(5).equals(new Dollar(5))); 
It fails. Dollars are Francs. Before you Swiss shoppers get all excited, let’s try to fix 
the code. The equality code needs to check that it isn’t comparing Dollars and Francs. 
We can do this right now by comparing the class of the two objects— two Moneys are 
equal only if their amounts and classes are equal. 
Money
Money  
public
public boolean
boolean equals(Object object) { 
Money money 
=
 (Money) object
;
return
return amount 
==
 money.amount && getClass()
.equals(money.getClass())
;
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
Do
ll
ar/Franc dup
li
ca
ti
on 
Common equa
ls
Common 
ti
me
s
Franc
s
!
= Do
ll
ar
s
Using classes like this in model code is a bit smelly. We would like to use a criteria 
that made sense in the domain of finance, not the domain of Java objects. However, 
we don’t currently have anything like a currency, and this doesn’t seem like sufficient 
reason to introduce one, so this will have to do for the moment. 
C# PDF: C#.NET PDF Document Merging & Splitting Control SDK
file. C#.NET APIs to Combine Two or More PDF Documents. void String destn); C#.NET Sample Codes to Merge Multiple PDF Files. public void
all jpg to one pdf converter; how to combine pdf files
VB.NET PDF: Use VB.NET Code to Merge and Split PDF Documents
VB.NET PDF - How to Merge and Split PDF. How to Merge and Split PDF Documents by Using VB.NET Code. Visual C#. VB.NET. Home > .NET Imaging
pdf combine; acrobat combine pdf
Test-driven development
36 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
5 CHF 
*
2 = 
10
CHF
Do
ll
ar/Franc dup
li
ca
ti
on 
Common equa
ls
Common 
ti
me
s
Franc
s
!
= Do
ll
ar
s
Currency? 
Now we really need to get rid of the common times() code, so we can get to mixed 
currency arithmetic. Before we do, though, we can review our grand accomplishments 
of this chapter: 
· Took an objection that was bothering us and turned it into a test 
· Made the test run a reasonable, but not perfect way (getClass()) 
· Decided not to introduce more design until we had a better motivation 
Test-driven development
37 of 133 
Makin’ Objects 
The two implementations of times() are remarkably similar: 
Franc
Franc  
Franc t
imes(
int
int mul
t
iplier) { 
return
return nneww Franc(amount * mul
t
iplier)
;
Dollar
Dollar  
Dollar t
imes(
int
int mul
t
iplier) { 
return
return nneww Dollar(amount * mul
t
iplier)
;
We can take a step towards reconciling them by making them both return a Money: 
Franc
Franc  
Money t
imes(
int
int mul
t
iplier) { 
return
return nneww Franc(amount * mul
t
iplier)
;
Dollar
Dollar  
Money t
imes(
int
int mul
t
iplier) { 
return
return nneww Dollar(amount * mul
t
iplier)
;
The next step forward is not obvious. The two subclasses of Money aren’t doing 
enough work to justify their existence, so we would like to eliminate them. However, 
we can’t do it with one big step, because that wouldn’t make a very effective 
demonstration of TDD. 
Okay, we would be one step closer to eliminating the subclasses if there were fewer 
references to the subclasses directly. We can introduce a Factory Method in Money 
that returns a Dollar. We would use it like this: 
public
public voidd testMul
t
iplicat
ion() { 
Dollar five 
=
 Money.dollar(5)
;
Money.dollar(5)
;
assertEquals(new Dollar(10)
,
 five.
t
imes(2))
;
assertEquals(new Dollar(15)
,
 five.
t
imes(3))
;
The implementation creates and returns a Dollar: 
Money
Money  
stat
ic
stat
ic Dollar dollar(
int
int amount) { 
return
return nneww Dollar(amount)
;
But we want references to Dollars to disappear, so we need to change the declaration 
in the test: 
Test-driven development
38 of 133 
public
public voidd testMul
t
iplicat
ion() { 
Money
Money five 
=
 Money.dollar(5)
;
assertEquals(new Dollar(10)
,
 five.
t
imes(2))
;
assertEquals(new Dollar(15)
,
 five.
t
imes(3))
;
Our compiler politely informs us that times() is not defined for Money. We aren’t 
ready to implement it just yet, so we make Money abstract (I suppose we should have 
done that to begin with, shouldn’t we?) and declare Money.times(): 
Money
Money  
abstract
abstract class Money 
abstract 
abstract Money
Money  t
imes(
t
imes(
int 
int mmul
t
iplier)
;
ul
t
iplier)
;
Now we can change the declaration of the factory method: 
Money
Money  
stat
ic
stat
ic Money
Money dollar(
int
int amount) { 
return
return nneww Dollar(amount)
;
The tests all run, so at least we haven’t broken anything. We can now use our factory 
method everywhere in the tests: 
public
public voidd testMul
t
iplicat
ion() { 
Money five 
=
 Money.dollar(5)
;
assertEquals(Money.dollar
Money.dollar(10)
,
 five.
t
imes(2))
;
assertEquals(Money.dollar
Money.dollar(15)
,
 five.
t
imes(3))
;
public
public voidd testEquali
ty() { 
assert
True(Money.dollar
Money.dollar(5)
.equals(Money.dollar
Money.dollar(5)))
;
assertFalse(Money.dollar
Money.dollar(5)
.equals(Money.dollar
Money.dollar(6)))
;
assert
True(nneeww Franc(5)
.equals(neeww Franc(5)))
;
assertFalse(nneww Franc(5)
.equals(nneww Franc(6)))
;
assertFalse(nneww Franc(5)
.equals(Money.dollar
Money.dollar(5)))
;
We are now in a slightly better position than before. No client code knows that there is 
a subclass called Dollar. By de-coupling the tests from the existence of the subclasses, 
we have given ourselves freedom to change inheritance without affecting any model 
code. 
Before we go blindly changing the testFrancMultiplication, we notice that it isn’t 
testing any logic that isn’t tested by the test for Dollar multiplication. If we delete the 
test, will we lose any confidence in the code? Still a little, so we leave it there. But it’s 
suspicious. 
Test-driven development
39 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
5 CHF 
*
2 = 
10
CHF
Do
ll
ar/Franc dup
li
ca
ti
on 
Common equa
ls
Common 
ti
me
s
Franc
s
!
= Do
ll
ar
s
Currency? 
De
l
e
t
t
e
st
FrancMu
lti
p
li
ca
ti
on? 
public void testEquality() { 
assertTrue(Money.dollar(5).equals(Money.dollar(5))); 
assertFalse(Money.dollar(5).equals(Money.dollar(6))); 
assertTrue(Money.franc(5).equals(Money.franc(5))); 
assertFalse(Money.franc(5).equals(Money.franc(6))); 
assertFalse(Money.franc(5).equals(Money.dollar(5))); 
public void testFrancMultiplication() { 
Money five = Money.franc(5); 
assertEquals(Money.franc(10), five.times(2)); 
assertEquals(Money.franc(15), five.times(3)); 
The implementation is just like Money.dollar(): 
Money
Money  
stat
ic
stat
ic Money franc(
int
int amount) { 
return
return nneww Franc(amount)
;
We’ll get rid of the duplication of times() next. For now, reviewing, we: 
· Took a step towards eliminating duplication by reconciling the signatures of 
two variants of the same method (times()) 
· Moved at least a declaration of the method to the common superclass 
· Decoupled test code from the existence of concrete subclasses by introducing 
factory methods 
· Noticed that when the subclasses disappear some tests will be redundant, but 
took no action 
Test-driven development
40 of 133 
Times We’re Livin’ In  
What is there on our list that might help us eliminate those pesky useless subclasses? 
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
Do
ll
ar/Franc dup
li
ca
ti
on 
Common equa
ls
Common 
ti
me
s
Franc
s
!
= Do
ll
ar
s
Currency? 
De
l
e
t
t
e
st
FrancMu
lti
p
li
ca
ti
on? 
What about currency? What would happen if we introduced the notion of currency? 
How do we want to implement currencies at the moment? I blew it, again. Before the 
ruler comes out, I’ll rephrase. How do we want to test for currencies at the moment? 
There. Knuckles saved. For the moment. 
We may want to have complicated objects representing currencies, with flyweight 
factories to ensure we create no more objects than we really need. However, for the 
moment Strings will do: 
public
public voidd testCurrency() { 
assertEquals("USD",
 Money.dollar(1)
.
currency())
;
assertEquals("CHF",
 Money.
franc(1)
.
currency())
;
First we declare currency() in Money: 
Money
Money  
abstract
abstract String currency()
;
Then we implement it in both subclasses: 
Franc
Franc  
String currency() { 
return
return return
return "CHF";
Dollar
Dollar  
String currency() { 
return
return return
return "USD";
We want the same implementation to suffice for both classes. We could store the 
currency in an instance variable and just return the variable. (I’ll start going a little 
Documents you may be interested
Documents you may be interested