create and print pdf in asp.net mvc : How to convert pdf file to tiff for SDK control service wpf web page .net dnn KentBeck_TDD_byexample10-part1753

Test-driven development
101 of 133 
The alternative to Test Data is Realistic Data, where you use data from the real world. 
Realistic Data is useful when: 
·  You are testing real-time systems using traces of external events gathered from 
the actual execution 
·  You are matching the output of the current system with the output of a 
previous system (Parallel Testing) 
·  You are refactoring a simulation and expect precisely the same answers when 
you are finished, particularly if floating point accuracy may be a problem 
Evident Data 
How do you represent the intent of the data? Include expected and actual results in the 
test itself, and try to make their relationship apparent. 
You are writing tests for a reader, not just the computer. Someone in decades to come 
will be asking themselves the question, "What in the heck was this joker thinking 
about?" You'd like to leave as many clues as possible, especially if that frustrated 
reader is going to be you. 
Here's an example. If we convert from one currency to another, we take a 1.5% 
commission on the transaction. If the exchange rate from USD to GBP is 2:1, then if 
we exchange $100, we should get 50 GBP - 1.5% = 49.25 GBP. We could write this 
test like this: 
Exchange bank=
 new Exchange()
.
bank.addRate("USD",
 "GBP",
 STANDARD_RATE)
;
bank.
commission(STANDARD_COMMISSION)
;
Money resul
t
=
 bank.
convert(new Note(100
,
 "USD")
,
 "GBP")
;
assertEquals(new Note(49
.
25
,
 "GBP")
,
 resul
t)
;
or we could try to make the calculation obvious: 
Exchange bank=
 new Exchange()
.
bank.addRate("USD",
 "GBP",
 2)
;
bank.
commission(0
.
0015)
;
Money resul
t
=
 bank.
convert(new Note(100
,
 "USD")
,
 "GBP")
;
assertEquals(new Note(100 / 2 * (1 
-
 0
.
0015)
,
 "GBP")
,
 resul
t)
;
Draw lines from the source data to the assertion data. I can read this test and see the 
connection between the numbers used in the input and the numbers used to calculate 
the expected result. 
One beneficial side effect of Evident Data is that it makes programming easier. Once 
we've written the expression in the assertion, we know what we need to program. 
Somehow we have to get the program to evaluation a division and a multiplication. 
We can even use Fake It Til You Make It to discover where the operations belong 
incrementally. 
Evident Data seems to be an exception to the rule that you don't want magic numbers 
in your code. Why is this? 
How to convert pdf file to tiff for - SDK control service:C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net, ASP.NET MVC, Ajax, WinForms, WPF
Online C# Tutorial for How to Convert PDF File to Tiff Image File
www.rasteredge.com
How to convert pdf file to tiff for - SDK control service:VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.net, ASP.NET MVC, Ajax, WinForms, WPF
Free VB.NET Guide to Render and Convert PDF Document to TIFF
www.rasteredge.com
Test-driven development
102 of 133 
Implementation Strategies 
TDD is not about blindly following a set of rules for how to program. It is about 
intelligently choosing the size of your programming steps and the amount of feedback 
depending on conditions. The patterns in this section are all ways of taking small steps 
forwards. 
Even though I’m in an sharing, caring, “can’t -we-all-just-get-along” mood, it is only 
fair to tell you that programmers practicing TDD consistently report that they take 
smaller and smaller steps over time. Your brain is likely to suffer the same rot if you 
continue. Don’t say I didn’t warn you.  
Fake It (‘Til You Make It)  
What is your first implementation once you have a broken test? Return a constant. 
Once you have the test running, gradually transform the constant into an expression 
using variables. 
A simple example occurred in our implementation of xUnit. 
return "1 run,
 0 failed" 
became: 
return "%d run,
 0 failed" % self
.runCount 
became: 
return "%d run,
 %d failed" % (self
.runCount 
,
 self failureCount) 
Fake It is a bit like driving a piton above your head when you are climbing a rock. 
You haven’t really gotten there yet (the test is there but the code structure is wrong) . 
However, when you do get there, you know you will be safe (the test will still run). 
There are a couple of effects that make Fake It Til You Make It powerful: 
·  Psychological— — Having a green bar is completely different than not having a 
green bar. When the bar is green, you know where you stand. Refactoring from 
there you can do with confidence. 
·  Scope control— — Programmers are good at imagining all sorts of future 
problems. Starting with one concrete example and generalizing from there 
prevents you from prematurely confusing yourself with extraneous concerns. 
You can do a better job of solving the immediate problem because you are 
focused. When you go to implement the next test case, you can focus on that 
one, too, knowing that the previous test is guaranteed to work. 
Does Fake It violate the rule that says you don’t write any code that isn’t needed? I 
don’t think so, because in the refactoring step you are eliminating duplication of data 
between the test case and the code. When I write
2
2
Thanks to Dierk König for the example.  
SDK control service:Online Convert PDF file to Tiff. Best free online PDF Tif
Download Free Trial. Convert a PDF File to Tiff. Just upload your file by clicking on the blue button or drag-and-drop your PDF file into the drop area.
www.rasteredge.com
SDK control service:Online Convert PDF file to Word. Best free online PDF Conversion
Convert a Tiff/Tif File to PDF. Just upload your file by clicking on the blue button or drag-and-drop your Tiff or Tif file into the drop area.
www.rasteredge.com
Test-driven development
103 of 133 
assertEquals(new MyDate("28
.
2
.
02")
,
 new MyDate("1.
3
.
02")
.yesterday())
;
MyDate
MyDate  
public MyDate yesterday() 
return new MyDate("28
.
2
.
02")
;
There is duplication between the test and the code. I can shift it around by writing 
MyDate
MyDate  
public MyDate yesterday() 
return new MyDate(new MyDate("31.1.
02")
.days()
-1)
;
But there is still duplication. However, I can eliminate the data duplication (because 
this = MyDate(“31.1.02”) for the purposes of my test) by writing:  
MyDate
MyDate  
public MyDate yesterday() 
return new MyDate(this.days()
-1)
;
Not everyone is convinced by this bit of sophistry, which is why you can Triangulate, 
at least until you are sick of it. 
When I use Fake It, I’m reminded of long car trips with kids in the back. I write the 
first test, I make it work some ugly way, and then, “Don’t make me stop this car and 
write another test. If I have to pull over, you’ll be sorry.” “Okay, okay, Dad. I’ll clean 
the code up. You don’t have to get all huffy.”  
Triangulate 
How do you most conservatively drive abstraction with tests? Only 
abstract when you have two or more examples. 
Here’s an example. Suppose we want to write a function that will 
return the sum of two integers. We write: 
public void testSum() { 
assertEquals(4
,
 plus(2
,
 2))
;
private 
int plus(
int augend,
int addend) { 
return 4
;
Do we need to have the discussion about unused arguments again? Probably. Sigh…  
If we are triangulating to the right design, we have to write: 
SDK control service:Online Convert Excel to PDF file. Best free online export xlsx
Download Free Trial. Convert a Excel File to PDF. Drag and drop your excel file into the box or click the green button to browse for a file to upload.
www.rasteredge.com
SDK control service:C# Create PDF from Tiff Library to convert tif images to PDF in C#
TIFFDocument doc = new TIFFDocument(inputFilePath); // Convert loaded TIFF file to PDF document. doc.ConvertToDocument(DocumentType.PDF, outputFilePath);
www.rasteredge.com
Test-driven development
104 of 133 
public void testSum() { 
assertEquals(4
,
 plus(2
,
 2))
;
assertEquals(7,
 plus(3
,
4))
;
(We were careful to give the two parameters different values in the second example, 
so we couldn’t self -righteously claim we only needed one parameter.) When we have 
the second example, we can abstract the implementation of plus(): 
private 
int 
private 
int plus(
iint  augend,
int 
int addend) { 
return 
return augend 
+
 addend;
Triangulation is attractive because the rules for it seem so clear. The rules for Fake It, 
where we are relying on our sense of duplication between the test case and the piggy 
implementation to drive abstraction, seem a bit vague and subject to interpretation. 
While they seem simple, the rules for triangulation create an infinite loop. Once we 
have the two assertions and we have abstracted the correct implementation for plus, 
we can delete one of the assertions on the grounds that it is completely redundant with 
the other. If we do that, however, we can simplify the implementation of plus() to just 
return a constant, which requires us to add an assertion. 
I only use triangulation when I’m really, really u nsure about the correct abstraction for 
the calculation. Otherwise I rely on either Obvious Implementation or Fake It.  
Obvious Implementation 
How do you implement simple operations? Just implement them. 
Fake It and Triangulation are teensy-weensy tiny steps. Sometimes you are sure you 
know how to implement an operation. Go ahead.  
For example, would I really use Fake It to implement something as simple as plus()? 
Not usually. I would just type in the obvious implementation. If I noticed I was getting 
surprised by red bars, I would go to smaller steps. 
Keep track of how often you get surprised by red bars using Obvious Implementation. 
You want to maintain that red/green/refactor rhythm. Obvious Implementation is 
second gear. Be prepared to downshift if your brain starts writing checks your fingers 
can’t cash.  
One to Many 
How do you implement an operation that works with collections of objects? 
Implement it without the collections first, then make it work with collections. 
For example, suppose we are writing a function to sum an array of numbers. We can 
start with one: 
SDK control service:C# PDF File Split Library: Split, seperate PDF into multiple files
Application. Best and professional adobe PDF file splitting SDK for Visual Studio .NET. outputOps); Divide PDF File into Two Using C#.
www.rasteredge.com
SDK control service:VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Convert smooth lines to curves. Detect and merge image fragments. Flatten visible layers. VB.NET Demo Code to Optimize An Exist PDF File in Visual C#.NET Project
www.rasteredge.com
Test-driven development
105 of 133 
public void testSum() { 
assertEquals(5
,
 sum(5))
;
private 
int sum(
int value) { 
return value;
(I am implementing sum() in the TestCase class to avoid writing a new class just for 
one method.) 
We want to test sum(new int[] {5, 7}) next. First we add a parameter to sum() taking 
an array of values: 
public void testSum() { 
assertEquals(5
,
 sum(5
,
 new 
int[] {5}))
;
private 
int sum(
int value,
int[] values) { 
return value;
You can look at this step as an example of Isolate Change. Once we add the parameter 
in the test case we are free to change the implementation without affecting the test 
case. 
Now we can use the collection instead of the single value: 
private 
int 
private 
int sum(
int 
int value,
int
int[] values) { 
int 
int sum=
 0
;
for 
for (
int 
int 
i=
 0
;
i<values.length;
i++
sum 
+=
 values[
i
]
;
return 
return sum;
Now we can delete the unused single parameter: 
public void testSum() { 
assertEquals(5
,
 sum(new 
int[] {5}))
;
private 
int sum(
int[] values) { 
int sum=
 0
;
for (
int 
i=
 0
;
i<values.length;
i++
sum 
+=
 values[
i
]
;
return sum;
The previous step is also an example of Isolate Change, where we change the code so 
we can change the test cases without affecting the code. Now we can enrich the test 
case as planned: 
SDK control service:C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
Description: Convert to DOCX/TIFF with specified zoom value and save it zoomValue, The magnification of the original PDF page size. filePath, The output file path
www.rasteredge.com
SDK control service:C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
PDFPage page = (PDFPage)doc.GetPage(0); // Convert the first PDF page to a JPEG file. page.ConvertToImage(ImageType.JPEG, Program.RootPath + "\\Output.jpg");
www.rasteredge.com
Test-driven development
106 of 133 
public void testSum() { 
assertEquals(12
,
 sum(new 
int[] {5
,
 7}))
;
Process 
These patterns are about when you write a test, where you write tests, and when you 
stop. 
One Step Test 
Which test should you pick next from the list? Pick a test that will teach you 
something and that you are confident you can implement. 
Each test should represent one step towards your overall goal. If we are looking at the 
following Test List, which test should we pick next? 
·  P
l
u
s
·  M
i
nu
s
·
Ti
me
s
·  D
ivi
de 
·
P
l
u
s
li
ke
·
Equa
ls
·
Equa
ls
nu
ll
·
Nu
ll
e
x
change
·  E
x
change one currency 
·  E
x
change 
tw
o currenc
i
e
s
·  Cro
ss
ra
t
There is no right answer. What is one step for me, never having implemented these 
objects before, will be one tenth of a step to you, with your vast experience. 
When I look at a Test List, I think, “That’s obvious, that’s obvious, I have no idea, 
obvious, what was I thinking about with that one, ah, this one I can do.” That’s the test 
I implement next. 
If you don’t find any test on the list that represents one step, a dd some new tests that 
would represent progress towards the items there. 
A program grown from tests like this can appear to be written top-down, because you 
can begin with a test that represents a simple case of the entire computation. A 
program grown from tests can also appear to be written bottom-up, because you start 
with small pieces and aggregate them larger and larger.  
Test-driven development
107 of 133 
Neither top-down nor bottom-up really describes the process helpfully. First, a vertical 
metaphor is a simplistic visualization of how programs change over time. “Growth” 
implies a kind of self-similar feedback loop where the environment affects the 
program and the program affects the environment. Second, if we have to have a 
direction in our metaphor, “known -to-unknown” is a helpful de scription. Known-to-
unknown implies that we have some knowledge and experience on which to draw, and 
that we expect to learn in the course of development. Put these two together and we 
have programs growing from known to unknown. 
Starter Test 
Which test should you start with? Start by testing a variant of an operation that doesn't 
do anything. 
The first question you have to ask with a new operation is "Where does it belong?" 
Until you've answered this question, you don't know what to type for the test. In the 
spirit of solving one problem at a time, how can we answer just this question and no 
other? 
If you write a “realistic” test first, you will find yourself solving a bunch of problems 
at once: 
·  Where does the operation belong? 
·  What are the correct inputs? 
·  What is the correct output given those inputs? 
If you begin withAnswering these question a realistic  will leave you too long without 
feedback. Red/green/refactor, red/green/refactor. You want that loop to be minutes. 
You can shorten the loop by choosing inputs and outputs that are trivially easy to 
discover. For example, a poster on the Extreme Programming newsgroup asked about 
how to write a polygon reducer test-first. The input is a mesh of polygons and the 
output is a mesh of polygons that describes precisely the same surface, but with fewer 
polygons. “How can I test -drive this problem since getting a test to work requires 
reading Ph.D. theses?”  
Starter Test provides an answer: 
·  The output should be the same as the input. Some configurations of polygons 
are already normalized, incapable of further reduction. 
·  The input should be as small as possible, like a single polygon, or even an 
empty list of polygons. 
Bing! First test is running. Now for all the rest of the tests on the list. 
One Step Test applies: Pick a Starter Test that will teach you something but that you 
are certain you can get working quickly. If you are implementing something for the 
Nth time, pick a test that will require an operation or two. You will be justifiably 
confident you can get it working. If you are implementing something hairy and 
complicated for the first time, you need a little courage pill immediately. 
Test-driven development
108 of 133 
Explanation Test 
How do you spread the use of automated testing? Ask for and give explanations in 
terms of tests. 
It can be frustrating to be the only TDD on a team. Soon, you will notice fewer 
integration problems and defect reports in tested code, and the designs will be simpler 
and easier to explain. It has even happened before that folks get downright enthusiastic 
about testing, and testing first. 
Beware the enthusiasm of the newly converted. Nothing will stop the spread of TDD 
faster than pushing it in people’s faces. If you’re a manager or leader, you can’t force 
anyone to change the way they work. 
What can you do? A simple start is to start asking for explanations in terms of test 
cases. “Let me see if I understand what you’re saying. For example, if I have a Foo 
like this and a Bar like that then the answer should be 76?” A companion technique is 
to start giving explanations in terms of tests. “Here’s how it works now. When I have 
a Foo like this and a Bar like that, the answer is 76. If I have a Foo like that and a Bar 
like this, though, I would like the answer to be 67.”  
You can do this at higher levels of abstraction. If someone is explaining a sequence 
diagram to you, you can ask for permission to convert it to a more familiar notation. 
Then you type in a test case that contains all the externally visible objects and 
messages in the diagram. 
Another Test 
How do you keep a technical discussion from straying off topic? When a tangential 
idea arises, add a test to the list and go back to the topic. 
I love wandering discussions (you’ve read most of the book now, so you’ve probably 
reached that conclusion yourself). Keeping a conversation strictly on course is a great 
way to stifle brilliant ideas. You hop from here to there to there, and how did we get 
here? who cares, this is cool! 
Some programming is like this. You’re looking for a breakthrough to get you going. 
Most programming, though, is a bit more pedestrian. You have ten things to 
implement and you’ve only implemented three of them. I’m an accomplished 
procrastinator at such times. Retreating to hummingbird conversation is a way of 
avoiding work (and maybe the fear that goes along with it.) 
Whole unproductive days have taught me that at times it’s best to stay on track. When 
I’m feeling this way, new ideas are greeted with respect, but not allowed to divert my 
attention. I write them down on the list, and get back to what I was working on. 
Regression Test 
What's the first thing you do when a defect is reported? Write the smallest possible 
test that fails, and that once it runs, the defect will be repaired. 
Test-driven development
109 of 133 
Regression tests are tests that, with perfect foreknowledge, you would have written 
when coding originally. Every time you have to write a regression test, think about 
how you could have known to write the test in the first place. 
You will also gain value by testing at the level of the whole application. Regression 
tests for the application give your users a chance to speak concretely to you about 
what is wrong and what they expect. Regression tests at the smaller scale are a way for 
you to improve your testing. The defect report will be about a bizarre large negative 
number in a report. The lesson for you is that you need to test for integer rollover 
when you are writing your test list. 
You may have to refactor the system before you can easily isolate the defect. The 
defect in this case was your system’s way of telling you, “Y ou aren’t quite done 
designing me yet.”  
Break 
What do you do when you feel tired or stuck? Take a break. 
Take a drink, take a walk, take a nap. Wash your hands clean of your emotional 
commitment to the decisions you just made and the characters you typed. 
Often, this amount of distance is all it will take to break loose the idea you’ve been 
lacking. You’ll just be standing up when you realize, “I haven’t tried it with the 
parameters reversed!” Take the break anyway. Give yourself a couple of minutes. The 
idea won’t go away.  
If you don’t get “the idea”, review your goals for the session. Are they still realistic or 
should you pick new goals? Is what you were trying to accomplish impossible? If so, 
what are the implications for the team? 
Dave Ungar calls this his Shower Methodology. If you know what to type, type. If you 
don’t know what to type, take a shower. Many teams would be happier, more 
productive, and smell a whole lot better if they took his advice. 
Here is an influence diagram that shows the positive feedback loop at work: 
Fatigue negatively affects judgement which negatively affects fatigue 
You’re getting tired, so you’re less capable of realizing that you’re tired, so you keep 
going and get more tired. 
The way out of this loop is to introduce an additional outside element. 
·  At the scale of hours, keep a water bottle by your keyboard so biology provides 
the motivation for regular breaks. 
·  At the scale of a day, commitments after regular work hours can help you stop 
when you need sleep before progress. 
·  At the scale of a week, weekend commitments help get your conscious, 
energy-sucking thoughts off work. (My wife swears I get my best ideas Friday 
evening.) 
Test-driven development
110 of 133 
·  At the scale of a year, mandatory vacation policies help you refresh yourself 
completely. The French do this right— two contiguous weeks of vacation aren’t 
enough. You spend the first week decompressing, and the second week getting 
ready to go back to work. Therefore three weeks, or better four, are necessary 
for you to be your most effective the rest of the year. 
There is a flip side to taking breaks. Sometimes when faced with a tough problem 
what you need to do is press on, push through it. However, programming culture is so 
infected with macho, “I’ll ruin my health, alienate my family, and kill myself if 
necessary,” spirit that I don’t feel compelled to give any advice along these lines. If 
you find yourself caffeine-addicted and making no progress whatsoever, perhaps you 
shouldn’t take quite so many breaks. In the meantime, take a walk.  
Do Over 
What do you do when you are feeling lost? Throw away the code and start over. 
You’re lost. You’ve taken the break, rinsed your hands in the brook, sounded the 
Tibetan temple bell, and still you’re lost. The code that was going so well an hour ago 
is now a mess, you can’t think of how to get the next test case working, and you’ve 
thought of 20 more tests that you really should implement. 
This has happened to me several times in writing this book. I would get the code a bit 
twisted. “But I have to finish the book. The  children are starving and the bill 
collector’s are pounding on the door.” My gut reaction would be to untwist it just 
enough to move on. After a pause for reflection, starting over always made more 
sense. The one time I pressed on regardless, I had to throw away 25 pages of 
manuscript because it was based on an obviously stupid programming decision. 
My favorite example of Do Over is a story Tim Mackinnon told me. He was 
interviewing someone by the simple expedient of asking her to pair program with him 
for an hour. At the end of the session, they’d implemented several new test cases and 
done some nice refactoring. It was the end of the day, though, and they felt tired when 
they were done, so they discarded their work. 
Switching pair programming partners is a good way to motivate productive Do Overs. 
You’ll try to explain the complicated mess you made for a few minutes when your 
new partner, completely uninvested in the mistakes you’ve made, will gently take the 
keyboard and say, “I’m terribly sorry for being  so dense, but what if we started like 
this…”  
Cheap Desk, Nice Chair 
What physical setup should you use for test-driven development? Get a really nice 
chair, skimping on the rest of the furniture if necessary. 
You can’t program well if your back hurts. Yet,  organizations that will spend a 
hundred thousand dollars a month on a team won’t spend ten thousand dollars on 
decent chairs. 
Documents you may be interested
Documents you may be interested