.net c# pdf viewer : Acrobat merge pdf control SDK utility azure wpf winforms visual studio KentBeck_TDD_byexample5-part45

Test-driven development
51 of 133 
Addition, Finally 
It’s a new day, and our to-do list is getting a little cluttered, so we’ll copy the pending 
items to a fresh list: 
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
(I like physically copying to-do items to a new list. If there are lots of little items, I 
tend to just take care of them rather than copy them. Little stuff that otherwise might 
build up gets taken care of just because I’m lazy. Play to your strengths.) 
I’m not sure how to write the story of the whole addition, so we’ll start with a simpler 
example— $5 + $5 = $10. 
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 + $5 = $
10
public
public voidd testSimpleAddi
t
ion() { 
Money sum=
 Money.dollar(5)
.plus(Money.dollar(5))
;
assertEquals(Money.dollar(10)
,
 sum)
;
We could fake the implementation by just return “Mone y.dollar(10)”, but the 
implementation seems obvious. We’ll try: 
Money
Money  
Money plus(Money addend) { 
return
return nneww Money(amount 
+
 addend.amount
,
 currency)
;
(In general, I will begin speeding up the implementations to save trees and keep your 
interest. Where the design isn’t obvious I will still fake the implementation and 
refactor. I hope you will see through this how TDD gives you control over the size of 
steps.) 
Having said that I was going to go much faster, I will immediately go much slower, 
not in getting the tests working, but in writing the test itself. There are times and tests 
that call for careful thought. How are we going to represent multi-currency arithmetic? 
This is one of those times for careful thought. 
The most difficult design constraint is that we would like most of the code in the 
system to be unaware that it is (potentially) dealing with multiple currencies. One 
possible strategy is to immediately convert all money values into a reference currency 
(I’ll let you guess which reference currency American imperialist pig programmers 
generally choose). However, this doesn’t allow exchange rates to vary easily. 
Instead we would like a solution that lets us conveniently represent multiple exchange 
rates, and still allows most arithmetic-like expressions to look like, well, arithmetic. 
Objects to the rescue. When the object you have doesn’t behave like you want, make 
another object with the same external protocol (an Imposter), but a different 
implementation. 
Acrobat merge pdf - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
acrobat merge pdf; append pdf
Acrobat merge pdf - 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
adding pdf pages together; best pdf combiner
Test-driven development
52 of 133 
This probably sounds a bit like magic. How do you know to think of creating an 
imposter here? I won’t kid you— — there is no formula for flashes of design insight. 
Ward came up with the “trick” a decade ago and I haven’t seen it independently 
duplicated yet, so it must be a pretty tricky trick. TDD can’t guarantee that you will 
have flashes of insight at the right moment. However, confidence-giving tests and 
carefully factored code give you preparation for insight, and preparation for applying 
that insight when it comes. 
The solution is to create an object that acts like a Money, but represents the sum of 
two Moneys. I’ve tried several different metaphors to explain this idea. One is to treat 
the sum like a Wallet— you can have several different notes of different 
denominations and currencies in the same wallet. 
Another metaphor is “expressions”, as in “(2 + 3) * 5”, or in our case “($2 + 3 CHF) * 
5”. A Money is the atomic form of an expression. Operations result in Expressions, 
one of which will be a Sum. Once the operation (like adding up the value of a 
portfolio) is complete, the resulting Expression can be reduced back a single currency 
given a set of exchange rates. 
Applying this metaphor to our test, we know what we end up with: 
public
public voidd testSimpleAddi
t
ion() { 
… 
assertEquals(Money.dollar(10)
,
 reduced)
;
The reduced Expression is created by applying exchange rates to an Expression. What 
in the real world applies exchange rates? A bank. We would like to be able to write: 
public
public voidd testSimpleAddi
t
ion() { 
… 
Money reduced=
 bank.reduce(sum,
 "USD")
;
assertEquals(Money.dollar(10)
,
 reduced)
;
(It’s a little weird to be mixing the “bank” metaphor and the “expression” metaphor. 
We’ll get the whole story told, and then we’ll see what we can do about literary 
value.) 
The Bank in our simple example doesn’t really need to do anything. As long as we 
have an object we’re okay: 
public
public voidd testSimpleAddi
t
ion() { 
… 
Bank bank=
 neww Bank()
;
Money reduced=
 bank.reduce(sum,
 "USD")
;
assertEquals(Money.dollar(10)
,
 reduced)
;
The sum of two Moneys should be an Expression: 
.NET PDF Document Viewing, Annotation, Conversion & Processing
Merge, split PDF files. Insert, delete PDF pages. Edit, update, delete PDF annotations from PDF file. Print. Support for all the print modes in Acrobat PDF.
batch pdf merger online; pdf merger online
C# PDF Converter Library SDK to convert PDF to other file formats
manipulate & convert standard PDF documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat.
build pdf from multiple files; reader combine pdf
Test-driven development
53 of 133 
public
public voidd testSimpleAddi
t
ion() { 
… 
Expression sum=
 five.plus(five)
;
Bank bank=
 neww Bank()
;
Money reduced=
 bank.reduce(sum,
 "USD")
;
assertEquals(Money.dollar(10)
,
 reduced)
;
At least we know for sure how to get five dollars: 
public
public voidd testSimpleAddi
t
ion() { 
Money five=
 Money.dollar(5)
;
Expression sum=
 five.plus(five)
;
Bank bank=
 neww Bank()
;
Money reduced=
 bank.reduce(sum,
 "USD")
;
assertEquals(Money.dollar(10)
,
 reduced)
;
How do we get this to compile? We need an interface Expression (we could have a 
class, but an interface is even lighter weight): 
Expression
Expression  
interface
interface Expression 
Money.plus() needs to return an Expression: 
Money
Money  
Expression plus(Money addend) { 
return
return nneww Money(amount 
+
 addend.amount
,
 currency)
;
Which means that Money has to implement Expression (which is easy, since there are 
no operations yet): 
Money
Money  
class
class Money 
implements
implements Expression 
We need an empty Bank class: 
Bank
Bank  
class
class Bank 
Which stubs out reduce(): 
Bank
Bank  
Money reduce(Expression source,
 String to) { 
return
return null
null;
Now it compiles, and fails miserably. Hooray! Progress! We can easily fake the 
implementation, though: 
Bank
Bank  
Money reduce(Expression source,
 String to) { 
return
return Money.dollar(10)
;
We’re back to a green bar, and ready to refactor. First, reviewing, we: 
C# powerpoint - PowerPoint Conversion & Rendering in C#.NET
documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. PowerPoint to PDF Conversion.
merge pdf online; combine pdf online
C# Windows Viewer - Image and Document Conversion & Rendering in
standard image and document in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Convert to PDF.
acrobat reader merge pdf files; best pdf merger
Test-driven development
54 of 133 
· Reduced a big test to a smaller test that represented progress ($5 + 10 CHF to 
$5 + $5) 
· Thought carefully about the possible metaphors for our computation 
· Re-wrote our previous test based on our new metaphor 
· Got the test to compile quickly 
· Made it run 
· Looked forward with a bit of trepidation to the refactoring necessary to make 
the implementation real 
C# Word - Word Conversion in C#.NET
Word documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Word to PDF Conversion.
append pdf files reader; acrobat combine pdf files
VB.NET PDF: How to Create Watermark on PDF Document within
logo) on any desired PDF page. And with our PDF Watermark Creator, users need no external application plugin, like Adobe Acrobat.
batch pdf merger; pdf combine files online
Test-driven development
55 of 133 
Make It 
We can’t mark our test for $5 + $5 done until we’ve removed all the duplication. We 
don’t have code duplication, but we do have data duplication. The $10 in the fake 
implementation: 
Bank
Bank  
Money reduce(Expression source,
 String to) { 
return
return Money.dollar(10)
Money.dollar(10)
;
is really the same as the “$5 + $5” in the test:  
public
public voidd testSimpleAddi
t
ion() { 
Money five=
 Money.dollar(5)
;
Expression sum=
 five.plus(five)
 five.plus(five)
;
Bank bank=
 neww Bank()
;
Money reduced=
 bank.reduce(sum,
 "USD")
;
assertEquals(Money.dollar(10)
,
 reduced)
;
Before when we’ve had a fake implementation, it’s been obvious how to work 
backwards to the real implementation. It’s just been a matter of replacing constants 
with variables. This time, though, it’s not obvious to me how to work backwards. So, 
even though it feels a little speculative, we’ll work forwards. 
First, Money.plus() needs to return a real Expression, a Sum, not just a Money 
(perhaps later we’ll optimize the special case of adding two identical currencies, but 
that’s later.) 
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 + $5 = $
10
Re
t
urn Money from $5 + $5 
The sum of two Moneys should be a Sum: 
public
public voidd testPlusReturnsSum() { 
Money five=
 Money.dollar(5)
;
Expression resul
t
=
 five.plus(five)
;
Sum sum=
 (Sum) resul
t
;
assertEquals(five,
 sum.augend)
;
assertEquals(five,
 sum.addend)
;
(Did you know that the first argument to addition is called the “augend”? I didn’t until 
I was writing this. Geek joy.) 
The test above is not one I would expect to live a long time. It is deeply concerned 
with the implementation of our operation, not its externally visible behavior. However, 
if we make it work, we expect we’ve moved one step closer to our goal. 
To get it to compile, all we need is a Sum class with two fields, augend and addend: 
C# Excel - Excel Conversion & Rendering in C#.NET
Excel documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Excel to PDF Conversion.
batch merge pdf; add pdf files together
VB.NET PowerPoint: VB Code to Draw and Create Annotation on PPT
as a kind of compensation for limitations (other documents are compatible, including PDF, TIFF, MS on slide with no more plug-ins needed like Acrobat or Adobe
add pdf files together reader; scan multiple pages into one pdf
Test-driven development
56 of 133 
Summ  
class
class Sum { 
Money augend;
Money addend;
This gives us a ClassCastException, because Money.plus() is returning a Money, not a 
Sum: 
Money
Money  
Expression plus(Money addend) { 
return
return nneww Sum(thhiiss,
 addend)
;
Sum needs a constructor: 
Summ  
Sum(Money augend,
 Money addend) { 
And Sum needs to be a kind of Expression: 
Summ  
class
class Sum 
implements
implements Expression 
Now the system compiles again, but the test is still failing, this time because the Sum 
constructor is not setting the fields (we could fake the implementation by initializing 
the fields, but I said I’d start going faster): 
Summ  
Sum(Money augend,
 Money addend) { 
thhiiss.augend=
 augend;
thiiss.addend=
 addend;
Now Bank.reduce() is being passed a Sum. If the currencies in the Sum are all the 
same, and the target currency is also the same, the result should be a Money whose 
amount is the sum of the amounts: 
public
public voidd testReduceSum() { 
Expression sum=
 neww Sum(Money.dollar(3)
,
 Money.dollar(4))
;
Bank bank=
 neww Bank()
;
Money resul
t
=
 bank.reduce(sum,
 "USD")
;
assertEquals(Money.dollar(7)
,
 resul
t)
;
I carefully chose parameters that would break the existing test. When we reduce a 
Sum, the result (under these simplified circumstances) should be a Money whose 
amount is the sum of the amounts of the two Moneys and whose currency is the 
currency to which we are reducing. 
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
It can be used standalone. JPEG to PDF Converter is able to convert image files to PDF directly without the software Adobe Acrobat Reader for conversion.
reader combine pdf pages; all jpg to one pdf converter
PDF to WORD Converter | Convert PDF to Word, Convert Word to PDF
PDF to Word Converter has accurate output, and PDF to Word Converter doesn't need the support of Adobe Acrobat & Microsoft Word.
c# merge pdf files; pdf mail merge plug in
Test-driven development
57 of 133 
Bank
Bank  
Money reduce(Expression source,
 String to) { 
Sum sum=
 (Sum) source;
int
int amount
=
 sum.augend.amount 
+
 sum.addend.amount
;
return
return nneww Money(amount
,
 to)
;
This is immediately ugly on two counts: 
· The cast. This code should work with any Expression. 
· The public fields, and two levels of references at that 
Easy enough to fix. First, we can move the body of the method to Sum and get rid of 
some of the visible fields. We are “sure” we will need the Bank as a parameter in the 
future, but this pure, simple refactoring, so we leave it out (actually, just now I put it in 
because I “knew” I would need it — — shame, shame on me.) 
Bank
Bank  
Money reduce(Expression source,
 String to) { 
Sum sum=
 (Sum) source;
return
return sum.reduce(to)
;
Summ  
public
public Money reduce(String to) { 
int
int amount
=
 augend.amount 
+
 addend.amount
;
return
return nneww Money(amount
,
 to)
;
(Which brings up the point of how we are going to implement, er… test, 
Bank.reduce() when the argument is a Money.) 
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 + $5 = $
10
Re
t
urn Money from $5 + $5 
Bank.reduce(Money) 
Let’s write that test, since the bar is green and there is nothing else obvious to do with the 
code above: 
Test-driven development
58 of 133 
public
public voidd testReduceMoney() { 
Bank bank=
 neww Bank()
;
Money resul
t
=
 bank.reduce(Money.dollar(1)
,
 "USD")
;
assertEquals(Money.dollar(1)
,
 resul
t)
;
Bank
Bank  
Money reduce(Expression source,
 String to) { 
if (source 
instanceof Money) return (Money) source;
if (source 
instanceof Money) return (Money) source;
Sum sum=
 (Sum) source;
return
return sum.reduce(to)
;
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 + $5 = $
10
Re
t
urn Money from $5 + $5 
Bank.reduce(Money) 
Reduce Money 
wit
h con
v
er
si
on 
Ugly, ugly, ugly. However, we now have a green bar, and refactoring is possible. Any 
time you are checking classes explicitly, you should be using polymorphism instead. 
Since Sum implements reduce(String), if Money implemented it, too, we could then add 
it to the Expression interface. 
Bank
Bank  
Money reduce(Expression source,
 String to) { 
iff (source 
instanceof
instanceof Money) return
return (Money) source.reduce(to)
;
Sum sum=
 (Sum) source;
return
return sum.reduce(to)
;
Money
Money  
public
public Money reduce(String to) { 
return
return tthiss;
If we add reduce(String) to the Expression interface: 
Expression
Expression  
Money reduce(String to)
;
We can eliminate all those ugly casts and class checks: 
Test-driven development
59 of 133 
Bank
Bank  
Money reduce(Expression source,
 String to) { 
return
return source.reduce(to)
;
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 + $5 = $
10
Re
t
urn Money from $5 + $5 
Bank.reduce(Money)
Reduce Money 
wit
h con
v
er
si
on 
I’m not entirely happy with the name of the method being the same in Expression and in 
Bank, but having different parameter types. I’ve never found a satisfactory general 
solution to this problem in Java. In languages with keyword parameters, communicating 
the difference between Bank.reduce(Expression, String) and Expression.reduce(String) is 
well supported by the language syntax. With positional parameters, it’s not so easy to 
make the code speak for you about how the two are different. 
T
o do
:
$5 + 
10
CHF = $
10
i
f CHF
:
USD 
is
2
:1
$5 + $5 = $
10
Re
t
urn Money from $5 + $5 
Bank.reduce(Money)
Reduce Money 
wit
h con
v
er
si
on 
Reduce(Bank, S
t
r
i
ng) 
vs
reduce(S
t
r
i
ng) 
Next we’ll actually exchange one currency for another. First, reviewing, we: 
· Didn’t mark a test as done because the duplication had not been eliminated 
· Worked forwards instead of backwards to realize the implementation 
· Wrote a test to force the creation of an object we expected to need later (Sum) 
· Started implementing faster (the Sum constructor) 
· Implemented code with casts in one place, then moved the code where it 
belonged once the test were running 
· Introduced polymorphism to eliminate explicit class checking 
Test-driven development
60 of 133 
Change 
Change is worth embracing (especially if you have a book out with “embrace change” 
in the title). Here, though, we are thinking about a much simpler form of change— we 
have 2 francs and we want a dollar. That sounds like a test case already: 
public
public voidd testReduceMoneyDifferentCurrency() { 
Bank bank=
 neww Bank()
;
bank.addRate("CHF",
 "USD",
 2)
;
Money resul
t
=
 bank.reduce(Money.
franc(2)
,
 "USD")
;
assertEquals(Money.dollar(1)
,
 resul
t)
;
When I go from francs to dollars, I divide by two (we’re still studiously ignoring all 
those nasty numerical problems.) We can make the bar green in one piece of ugliness: 
Money
Money  
public
public Money reduce(String to) { 
int
int rate 
=
 (currency.equals("CHF") & to.equals("USD")) 
? 2 
:
 1;
return
return nneww Money(amount / rate,
 to)
;
Now, suddenly, Money knows about exchange rates. Yuck. The Bank should be the 
only place we care about exchange rates. We’ll have to pass the Bank as a parameter 
to Expression.reduce() (see, we knew we would need it, and we were right. In the 
words of the grandfather in The Princess Bride, “You’re very clever…”) First the 
caller: 
Bank
Bank  
Money reduce(Expression source,
 String to) { 
return
return source.reduce(tthhiss,
 to)
;
Then the implementors: 
Documents you may be interested
Documents you may be interested