create and print pdf in asp.net mvc : Vb.net convert pdf to tiff SDK Library project winforms asp.net html UWP KentBeck_TDD_byexample12-part1755

Test-driven development
121 of 133 
java.lang.
Securi
t
java.lang.
Securi
tyManager
yManager  
public stat
ic 
public stat
ic Securi
tyManager getSecuri
tyManager() { 
return securi
ty 
!=
 null
 ? securi
ty 
:
 new LaxSecuri
ty()
;
return securi
ty 
!=
 null
 ? securi
ty 
:
 new LaxSecuri
ty()
;
Now we don’t have to worry about someone forgetting to check for null. The original 
code cleans up considerably: 
java.io.File
java.io.File  
ppublic boolean 
ublic boolean setReadOnly() { 
Securi
tyManager securi
ty 
=
 System.getSecuri
tyManager()
;
securi
ty.
checkWri
te(path)
;
return 
return fs.setReadOnly(thiss)
;
Erich Gamma and I once got in an argument at an OOPSLA tutorial about whether a 
Null Object was appropriate somewhere in JHotDraw. I was ahead on points when he 
pointed out the cost of introducing the Null Object was around 10 lines of code, for 
which we would get to eliminate 1 conditional. I hate those late round TKOs. 
Command 
Template Method 
Composite 
Pluggable Object 
Collecting Parameter 
How do you collect the results of an operation that is spread over several objects? Add 
a parameter to the operation in which the results will be collected. 
A simple example is the java.io.Externalizable interface. The writeExternal method 
writes an object and all the objects it references. Since the objects all have to 
cooperate loosely to get written out, the method is passed a parameter, an 
ObjectOutput, as the collecting parameter: 
java.io.Ex
ternalizable
java.io.Ex
ternalizable  
public 
interf
public 
interface 
ace Ex
ternalizable ex
tends 
ex
tends 
java.io.
Serializable { 
void 
void wri
teEx
ternal
(ObjectOutput out) throws 
throws IOExcept
ion;
Vb.net convert pdf to tiff - SDK Library project: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
Vb.net convert pdf to tiff - SDK Library project: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
122 of 133 
Value Object 
How do you design objects that will be widely shared, but for whom identity is 
unimportant? Set their state when they are created and never change it. Operations on 
the object always return a new object. 
Objects are wonderful. I can say that here, can’t I? Objects are a great way to organize 
logic for later understanding and growth. However, there is one little problem (okay, 
more than one, but this one will do for now.) 
Suppose I (an object) have a Rectangle. I compute some value based on the Rectangle, 
like its area. Later, someone politely asks me for my Rectangle, and I, not wanting to 
appear uncooperative, give it to them. Moments later, lo and behold, the Rectangle has 
been changed behind my back. The area I computed earlier is out of date, and there is 
no way for me to know. 
This is the classic aliasing problem. If two objects share a reference to a third, if one 
object changes the referred object, the other object better not rely on the state of the 
shared object. 
There are several ways out of the aliasing problem. One solution is never to give out 
the objects that you rely on, but instead to always make copies. This can get expensive 
in time and space, and ignores those times when you want to share changes to a shared 
object. Another solution is Observer, where you explicit register with objects on which 
you rely and expect to be notified when they change. Observer can make control flows 
difficult to follow, and the logic for setting up and removing the dependencies gets 
ugly. 
Another solution is to treat the object as less than an object. Objects have state that 
change over time. We can, if we choose, eliminate the “that change ov er time”. If I 
have an object and I know it won’t change, I can pass around references to it all I 
want, knowing that aliasing won’t be a problem. There can be no hidden changes to a 
shared object if there are no changes. 
I remember puzzling over Integers when I was first learning Smalltalk. If I change bit 
2 to a 1, why don’t all 2’s become 6’s?   
:=
 2
.
:=
 a.
:=
 a bi
t
A
t
:
 2 put
:
 1.
=>
 6 
=>
 2 
Because Integers are really values masquerading as objects. In Smalltalk this is 
literally true of small integers, and simulated in the case of integers that don’t fit in a 
single machine word. When I set that bit, what I get back is a new object with the bit 
set, not the old one with the bit changed. 
When implementing a Value Object, every operation has to return a fresh object, 
leaving the original unchanged. Users have to be aware they are using a Value Object 
and store the result (as in the example above.) All of these object allocations can 
create performance problems, which should be handled like all performance problems, 
SDK Library project:VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Free library for .NET framework. Why do we need to convert PDF document to HTML webpage using VB.NET programming code? Convert PDF to HTML in VB.NET Demo Code.
www.rasteredge.com
SDK Library project:VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
Create PDF from PowerPoint; VB.NET: Create PDF from Tiff; VB.NET: Convert PDF to Word; VB.NET: Convert PDF to Tiff; VB.NET: Convert PDF
www.rasteredge.com
Test-driven development
123 of 133 
when you have realistic data sets, realistic usage patterns, profiling data, and 
complaints about performance. 
I have a tendency to use Value Object whenever I have a situation that looks like 
algebra— geometric shapes being intersected and unioned, unit values where units are 
carried around with a number, symbolic arithmetic. Any time Value Object makes the 
least sense I try it, because it makes reading and debugging so much easier. 
All Value Objects have to implement equality (and in many languages by implication 
they have to implement hashing.) If I have this Contract and that Contract and they 
aren’t the same object, then they are different, not equal. However, if I have this five 
francs and that five francs, it doesn’t matter if they are  the same five francs, five francs 
are five francs and they should be equal. 
Imposter 
Refactoring 
There is a brief description of how to accomplish each refactoring in small steps. More 
importantly, each refactoring discusses why you might want to use it. 
In TDD we use “refactoring” in an interesting way. Usually, a refactoring cannot 
change the semantics of the program under any circumstances. In TDD, the 
circumstances we care about are the tests that are already passing. So, for example, we 
can replace constants with variables in TDD can call this operation, in good 
conscience, a refactoring, because it doesn’t change the set of tests that pass. The only 
circumstance under which semantics are preserved may actually be our one test case. 
Any other test case that was passing would fail. However, we don’t have those tests 
yet, so we don’t worry about them.  
This kind of weird “refactoring with respect to tests” places a burden on you to have 
enough tests that as far as you know, a refactoring with respect to the tests is the same 
as a refactoring with respect to all possible tests, at least by the time you’re done. It’s 
no excuse to say, “I knew there was a problem, but the tests all passed so I checked the 
code in.” Write more tests.  
Reconcile Differences 
How do you unify two similar looking pieces of code? Gradually bring them closer. 
Unify them only when they are absolutely identical. 
Refactoring can be a nerve wracking experience. The easy ones are obvious. If I 
extract a method, as long as I do it mechanically correctly, there is very little chance of 
changing the system’s behavior. Some refactorings push you to examine the control 
flows and data values carefully. A long chain of reasoning leads you to believe that the 
change you are about to make won’t change  any answers. Those are the refactorings 
that enhance your hairline. 
SDK Library project:VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
VB.NET PDF - Convert PDF to MS Office Word in VB.NET. VB.NET Tutorial for How to Convert PDF to Word (.docx) Document in VB.NET. Best
www.rasteredge.com
SDK Library project:VB.NET PDF Convert to SVG SDK: Convert PDF to SVG files in vb.net
Create PDF from PowerPoint; VB.NET: Create PDF from Tiff; VB.NET: Convert PDF to Word; VB.NET: Convert PDF to Tiff; VB.NET: Convert PDF
www.rasteredge.com
Test-driven development
124 of 134 
Such a leap of faith refactoring is exactly what we’re trying to avoid with our strategy 
of small steps and concrete feedback. While you can’t always avoid leapy 
refactorings, you can reduce their incidence. 
For example, suppose we have code in two subclasses that we think does exactly the 
same thing: 
I’m having trouble finding an example 
We could just write a method in the superclass that we think implements the same 
algorithm. That would be a big step. However, if the two methods were exactly the 
same, we could put the method in the superclass without any worries. 
The same general strategy works for all refactorings— if you want to make a big 
change, think about how the last step of the change could be trivial, then work 
backwards. For example, if you want to remove several subclasses, the trivial last step 
is if a subclass contains nothing. Then the subclass can be replaced by the superclass 
without changing the behavior of the system. One by one, empty out the subclasses 
and, when they are empty, replace references to them by references to the superclass. 
Isolate Change 
How do you change one part of a multi-part method or object? First, isolate the part 
that has to change. 
If you want to be absolutely sure you aren't changing anything accidentally (not that 
you'll be right always), before you change it, make a place for it. We saw an example 
in working with Money. The conversion code said: 
return new Note(source.amount / rate,
 currency) 
We wanted to change rate lookup. First we extracted the access to the instance 
variable rate into its own method: 
return new Note(source.amount / findRate()
,
 currency) 
private 
int findRate() { 
return rate;
Now we can work on findRate() in isolation, without having to worry about affecting 
the parts of convert() that have nothing to do with rate lookup. 
The picture that comes to my mind is surgery, where all of the patient except the part 
to be operated on is draped. The draping leaves the surgeon with only a fixed set of 
variables. Now, we could have long arguments over whether this abstraction of a 
person to a lower left quadrant abdomen leads to good health care, but at the moment 
of surgery, I'm kind of glad the surgeon can focus. 
You may find that once you've isolated the change and then made the change, that the 
result is so trivial that you can undo the isolation. If we found that really all we needed 
was to return the instance variable in findRate(), we should consider inlining 
findRate() everywhere it is used and deleting it. Don't make these changes 
automatically, however. Balance the cost of an additional method with the value of 
having an additional concept explicit in the code. 
SDK Library project:VB.NET PDF Convert to Text SDK: Convert PDF to txt files in vb.net
Convert PDF to Text in VB.NET Demo Code. following RasterEdge text to PDF converter SDK dlls into your VB.NET project assemblies; RasterEdge.XDoc.PDF.dll.
www.rasteredge.com
SDK Library project:VB.NET PDF- HTML5 PDF Viewer for VB.NET Project
from PDF, VB.NET convert PDF to Jpeg, VB.NET compress PDF, VB.NET print PDF, VB.NET merge PDF files, VB.NET view PDF online, VB.NET convert PDF to tiff, VB.NET
www.rasteredge.com
Test-driven development
125 of 134 
Some possible ways to Isolate Change are Extract Method (the most common), Extract 
Object, and Method Object. 
Migrate Data 
How do you move from one representation? Temporarily duplicate the data. 
How
Here is the internal-to-external version: 
1.  Add an instance variable in the new format 
2.  Set the new format variable everywhere you set the old format 
3.  Use the new format variable everywhere you use the old format 
4.  Delete the old format 
5.  Change the external interface to reflect the new format 
Sometimes, though, you want to change the API first. Then you should: 
1.  Add a parameter in the new format 
2.  Translate from the new format parameter to the old format internal representation 
3.  Delete the old format parameter 
4.  Replace uses of the old format with the new format 
5.  Delete the old format 
Why
One to Many creates a data migration problem every time. Suppose we wanted to 
implement TestSuite using One to Many. We would start with: 
def testSui
te(self)
:
sui
te=
TestSui
te() 
sui
te.add(WasRun("testMethod")) 
sui
te.run(self
.resul
t) 
assert("1 run,
 0 failed" 
==
 self
.resul
t
.summary()) 
Which is implemented (in the “One” part of One to Many) by:  
class 
TestSui
te:
def add(self
,
 test)
:
self
.
test
=
 test 
def run(self
,
 resul
t)
:
self
.
test
.run(resul
t) 
Now we begin duplicating data. First we initialize the collection of tests: 
TestSui
te
TestSui
te  
def __ini
t__(self)
:
self
.
tests=
 [] 
Everywhere “test” is set, we add to the collection, too:  
SDK Library project:VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
from PDF, VB.NET convert PDF to Jpeg, VB.NET compress PDF, VB.NET print PDF, VB.NET merge PDF files, VB.NET view PDF online, VB.NET convert PDF to tiff, VB.NET
www.rasteredge.com
SDK Library project:VB.NET Create PDF from Word Library to convert docx, doc to PDF in
from PDF, VB.NET convert PDF to Jpeg, VB.NET compress PDF, VB.NET print PDF, VB.NET merge PDF files, VB.NET view PDF online, VB.NET convert PDF to tiff, VB.NET
www.rasteredge.com
Test-driven development
126 of 134 
TestSui
te
TestSui
te  
def add(self
,
 test)
:
self
.
test
=
 test 
self
.
tests.append(test)
self
.
tests.append(test)  
Now we use the list of tests instead of the single test. For purposes of the current test 
cases this is a refactoring (it preserves semantics) because there is only ever one 
element in the collection. 
TestSui
te
TestSui
te  
def run(self
,
 resul
t)
:
for test 
in self
.
tests:
for test 
in self
.
tests:
test
.run(resul
t)
test
.run(resul
t) 
We delete the now-unused instance variable “test”:  
TestSui
te
TestSui
te  
def add(self
,
 test)
:
self
.
tests.append(test) 
You can also use stepwise data migration when moving between equivalent formats 
with different protocols, as in moving from Java’s Vector/Enumerator to 
Collection/Iterator. Would this make a better example, since the above example is 
duplicated elsewhere in the text? 
Extract Method 
Inline Method 
Extract Interface 
Move Method 
Method Object 
How do you represent a complicated method that requires several parameters and local 
variables? Make an object out of the method. 
How
1.  Create an object with the same parameters as the method.  
2.  Make the local variables also instance variables of the object.  
3.  Create one method called "run()", whose body is the same as the body of the 
original method.  
4.  In the original method, create a new object and invoke run(). 
Test-driven development
127 of 134 
Why
Method Objects are useful in preparation for adding a whole new kind of logic to the 
system. For example, you might have several methods involved in computing the cash 
flow from component cash flows. When you want to start computing the net present 
value of the cash flows, you can first create a Method Object out of the first style of 
computation. Then you can write the new style of computation with its own, smaller-
scale, tests. Then plugging in the new style will be a single step. 
Method Objects are also good for simplifying code that doesn’t yield to Extract 
Method. Sometimes you’ll find a block of code that has a bunch of temporary 
variables and parameters, and every time you try to extract a piece of it you have to 
carry along five or six temps and parameters. The resulting extracted method doesn’t 
look any better than the original code, because the method signature is so long. 
Creating a Method Object gives you a new namespace in which you can extract 
methods without having to pass anything. 
Add Parameter 
How do you add a parameter to a method?  
How
1.  If the method is in an interface, add the parameter to the interface first   
2.  Use the compiler errors to tell you what other code you need to change 
Why
Adding a parameter is often an extension step. You got the first test case running 
without needing the parameter, but in this new circumstance you have to take more 
information into account in order to compute correctly. 
Adding a parameter can also be part of migrating from one data representation to 
another. First you add the parameter, then you delete all uses of the old parameter, 
then you delete the old parameter. 
Method Parameter to Constructor Parameter 
How do you move a parameter from a method or methods to the constructor?  
How
1.  Add a parameter to the constructor 
2.  Add an instance variable with the same name as the parameter 
3.  Set the variable in the constructor 
4.  One by one, convert references to “parameter” to “this.parameter”  
5.  When no more references exist to the parameter, delete the parameter from the 
method and all caller 
6.  Remove the now-superfluous “this.”  from references 
7.  Rename the variable correctly 
Test-driven development
128 of 135 
Why
If you pass the same parameter to several different methods in the same object, you 
can simplify the API by passing the parameter once (eliminating duplication). You can 
run this refactoring in reverse if you find that an instance variable is only used in one 
method. 
Test-driven development
129 of 135 
Mastering TDD 
I hope to raise questions here for you to ponder as you integrate TDD into your own 
practice. Some of the questions are small, and some are large. 
How large should your steps be? 
There are really two questions lurking here: 
·  How much ground should each test cover? 
·  How many intermediate stages should you go through as you refactor? 
You could write the tests so they each encouraged the addition of a single line of logic 
and a handful of refactorings. You could write the tests so they each encouraged the 
addition of hundreds of lines of logic and hours of refactoring. Which should you do? 
Part of the answer is that you should be able to do either. The tendency of TDDers 
over time is clear, though— smaller steps. However, folks are experimenting with 
driving development from application-level tests, either alone or in conjunction with 
the programmer-level tests we’ve been writing.  
At first when you refactor, you should be prepared to take lots of little tiny steps. 
Manual refactoring is prone to error, and the more errors you make and only catch 
later, the less likely you are to refactor. Once you’ve done a refactoring 20 times by 
hand in little tiny steps, experiment with leaving out some of the steps. 
Automated refactoring accelerates refactoring enormously. What would have taken 
you 20 manual steps now becomes a single menu item. An order of magnitude change 
in quantity generally constitute a change in quality, and this is true of automated 
refactoring. When you know you are supported by an excellent tool, you become 
much more aggressive in your refactorings, trying many more experiments to see how 
the code wants to be structured. 
The Refactoring Browser for Smalltalk is as I write still the best refactoring tool 
available. Java refactoring support is appearing in many Java IDEs, and refactoring 
support is sure to spread quickly to other languages and environments. 
How much feedback do you need? 
How many tests should you write? Here’s a simple problem — — given three integers 
representing the length of the sides of a triangle, return: 
·  1 if the triangle is equilateral 
·  2 if the triangle is isoceles 
·  3 if the triangle is scalene 
and throw an exception if the triangle is not well formed. 
Test-driven development
130 of 135 
Go ahead, try the problem (my Smalltalk solution is listed at the end of this question). 
I wrote 6 tests (kind of like Name That Tune, “I can code tha t problem in four tests.” 
“Code that problem.”) Bob Binder, in his comprehensive book Testing Object-
Oriented Software, wrote 65 for the same problem. You’ll have to decide, from 
experience and reflection, about how many tests you want to write. 
I think about Mean Time Between Failure (MTBF) when I think about how many tests 
to write. For example, Smalltalk integers act like integers, not like a 32-bit counter, so 
it doesn’t make sense to test MAXINT. Well, there is a MAXINT, but it has to do with 
how much memory you have. Do I need to write a test that fills up memory with 
extremely large integers? How will that affect the MTBF of my program? If I’m never 
going to get anywhere close to that size of triangle, my program is not measurably 
more robust with such a test than without it.  
Whether a test makes sense to write depends on how carefully you measure MTBF. If 
you are trying to get from an MTBF of 10 years to an MTBF of 100 years in your 
pacemaker, it probably makes sense, unless you can demonstrate in some other way 
that you never get triangles that large. 
TDD’s view of testing is pragmatic. The tests are a means to an end, the end being 
code in which we have great confidence. If our knowledge of the implementation 
gives us confidence in the absence of a test, we will not write that test. Black box 
testing, where we deliberately choose to ignore the implementation, has some 
advantages. By ignoring the code, it demonstrates a different value system— the tests 
are valuable alone. It’s an appropriate attitude to take in some circumstances. 
However, it is different than TDD. 
Documents you may be interested
Documents you may be interested