c# mvc website pdf file in stored in byte array display in browser : Copy pages from pdf to word Library software class asp.net winforms wpf ajax The%20Art%20of%20Unit%20Testing%20with%20Examples%20in%20.NET%20(Manning%202009)27-part1059

Writing integration tests before refactoring
245
Next, we wrote an integration test that showed that, once the compo-
nent was reading the file, it contained no attribute in memory with the 
name we were trying to add. We proved that the feature was missing, 
and we now had a test that would pass once we added the new attri-
bute to the XML file and correctly wrote to it from the component.
Once we wrote the code that saved and loaded the extra attribute, we 
ran the three integration  tests (two tests for the original base imple-
mentation,  and a new one  that tried to  read  the new attribute). All 
three passed, so we knew that we hadn’t broken existing functionality 
while adding the new functionality. 
As you can see, the process is relatively simple:
Add one or more integration tests (no mocks or stubs) to the system 
to prove the original system works as needed.
Refactor or add a failing test for the feature you’re trying to add to 
the system.
Refactor and change the system in small chunks, and run the inte-
gration tests as often as you can, to see if you break something.
Sometimes, integration tests may seem easier to write than unit tests, 
because you don’t need to mess with dependency injection. But making 
those tests run on your local system may prove annoying or time-con-
suming because  you  have to make sure  every little thing the system 
needs is in place.
The trick is to work on the parts of the system that you need to fix or 
add features to. Don’t focus on the other parts. That way, the system 
grows in the right places, leaving other bridges to be crossed when you 
get to them.
As you continue adding more and more tests, you can refactor the sys-
tem and add more unit tests to it, growing it into a more maintainable 
and testable system. This takes time (sometimes months and months), 
but it’s worth it.
Did I mention that you need to have good tools? Let’s look at some of 
my favorites.
Copy pages from pdf to word - remove PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provides Users with Mature Document Manipulating Function for Deleting PDF Pages
add remove pages from pdf; copy page from pdf
Copy pages from pdf to word - VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Visual Basic Sample Codes to Delete PDF Document Page in .NET
copy pages from pdf to another pdf; cut pages out of pdf online
246
CHAPTER 9    Working with legacy code
Here are a few tips on tools that can give you a head start if you’re 
doing any testing on existing code in .NET:
Isolate dependencies easily with Typemock Isolator.
Find testability problems with Depender.
Use JMockit for Java legacy code.
Use Vise while refactoring your Java code.
Use FitNesse for acceptance tests before you refactor.
Read Michael Feathers’ book on legacy code.
Use NDepend to investigate your production code.
Use ReSharper to navigate and refactor your production code more 
easily.
Detect duplicate code (and bugs) with Simian.
Detect threading issues with Typemock Racer.
Let’s look at each of these in a little more detail.
9.4.1 Isolate dependencies easily with Typemock Isolator
Typemock Isolator was introduced in chapter 5, and it’s the only com-
mercial-grade isolation framework (which means it  allows  stubs and 
mocks) of the frameworks currently on the market. It’s also different 
from the other frameworks in that it’s the only one that allows you to 
create stubs and mocks of dependencies in production  code  without 
needing to refactor it at all, saving valuable time in bringing a compo-
nent under test.
NOTE
Full disclosure: While writing this book, I also worked as a devel-
oper at Typemock on a different product. I also helped to design the 
API in Isolator 5.0. 
In its latest version (5.2 at the time of writing this book), Isolator uses 
the term “fake” and removes completely the words “mock” and “stub” 
from the API. Using the new  framework, you can “fake” interfaces, 
sealed and static types, nonvirtual methods, and static methods. This 
9.4 Important tools for legacy code unit testing
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
Ability to copy selected PDF pages and paste The portable document format, known as PDF document, is a widely-used form of file that allows users to
delete a page from a pdf; delete pdf pages in reader
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
VB.NET: Copy and Paste PDF Pages. VB.NET programming example below will show you how to copy pages from a PDF file and paste into another one.
delete page from pdf online; delete pages in pdf reader
Important tools for legacy code unit testing
247
means you don’t need to worry about changing the design (which you 
may not have time for, or perhaps can’t for testability reasons). You 
can  start  testing  almost  immediately.  There’s  also  a  free  version  of 
Typemock  Isolator for open  source  projects,  so you can feel  free  to 
download this product and try it on your own. 
Listing 9.1 shows a couple of examples of using the new Isolator API 
to fake instances of classes.
Listing 9.1  Faking static methods and creating fake classes with Isolator
[Test]
public void FakeAStaticMethod()
{
Isolate
.WhenCalled(()=>MyClass.SomeStaticMethod())
.WillThrowException(new Exception());
}
[Test]
public void FakeAPrivateMethodOnAClassWithAPrivateConstructor()
{
ClassWithPrivateConstructor c = 
Isolate.Fake.Instance<ClassWithPrivateConstructor>();
Isolate.NonPublic
.WhenCalled(c,"SomePrivateMethod").WillReturn(3);
}
As you can see, the API is simple and clear, and uses generics and dele-
gates to return fake values. There’s also an API specifically dedicated 
for VB.NET that has a more VB-centric syntax. In both APIs, you don’t 
need to change anything in the design of your classes under test to make 
these tests work, because Isolator uses the specialized 
extended reflection
(or 
profiler APIs
) of the .NET Common Language Runtime to perform its 
actions. This gives it much more power than other frameworks.
Isolator  is  a  great framework  if you want  to  start testing,  you  have 
existing code bases, and you want a bridge that can help make the hard 
stuff  more  agile.  There  are  more  examples  and  downloads  at 
www.Typemock.com.
C# Word - Extract or Copy Pages from Word File in C#.NET
C#.NET PDF file & pages edit, C#.NET PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB
delete pages of pdf online; cut pages out of pdf file
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
NET code. All PDF pages can be converted to separate Word files within a short time in VB.NET class application. In addition, texts
delete pages from pdf in reader; add and remove pages from a pdf
248
CHAPTER 9    Working with legacy code
Figure 9.5 Depender is 
simple and easy to use.
9.4.2 Find testability problems with Depender
Depender is a free tool I’ve created that can analyze .NET assemblies 
for their types and methods, and can help determine possible testability 
problems in methods (static methods, for example). It displays a simple 
report for an assembly or a method, as shown in figure 9.5.
You  can  download  Depender  from  my  blog: http://weblogs.asp.net/
rosherove/archive/2008/07/05/introducing-depender-testability-prob-
lem-finder.aspx.
9.4.3 Use JMockit for Java legacy code
JMockit is an open source project that uses the Java instrumentation 
APIs to do some  of the  same things that Typemock Isolator does in 
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
PDF ›› C# PDF: Extract PDF Image. How to C#: Extract Image from PDF Document. Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document.
delete page numbers in pdf; delete pages pdf document
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Page: Insert PDF Pages. |. Home ›› XDoc.PDF ›› VB.NET PDF: Insert PDF Page. Add and Insert Multiple PDF Pages to PDF Document Using VB.
delete page from pdf; delete page in pdf document
Important tools for legacy code unit testing
249
.NET. You don’t need to change the design of your existing project to 
isolate your components from their dependencies. 
JMockit  uses  a  swap  approach.  First, you  create a manually  coded 
class that will replace the class that acts as a dependency to your com-
ponent  under test  (say  you  code  a  FakeDatabase  class to  replace  a 
Database class). Then you use JMockit to swap calls from the original 
class to your own fake class. You can also redefine a class’s methods by 
defining them again as anonymous methods inside the test.
Listing 9.2 shows a sample of a test that uses JMockit.
Listing 9.2  Using JMockit to swap class implementations
public class ServiceATest extends TestCase   {
private boolean serviceMethodCalled;
public static class MockDatabase      {
static int findMethodCallCount;
static int saveMethodCallCount;
public static void save(Object o)    {
assertNotNull(o);
saveMethodCallCount++;
}
public static List find(String ql, Object arg1)   {
assertNotNull(ql);
assertNotNull(arg1);
findMethodCallCount++;
return Collections.EMPTY_LIST;
}
}
protected void setUp() throws Exception  {
super.setUp();
MockDatabase.findMethodCallCount = 0;
MockDatabase.saveMethodCallCount = 0;
Mockit.redefineMethods(Database.class, 
MockDatabase.class);
}
public void testDoBusinessOperationXyz() throws Exception  {
final BigDecimal total = new BigDecimal("125.40");
The magic 
happens here
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
VB.NET PDF - Extract Image from PDF Document in VB.NET. Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document in VB.NET Project.
delete pages from a pdf; delete pages from a pdf online
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Convert multiple pages Word to fillable and editable PDF documents in both .NET WinForms and ASP.NET. Able to get word count in PDF pages.
delete pages pdf file; delete pages from pdf reader
250
CHAPTER 9    Working with legacy code
Mockit.redefineMethods(ServiceB.class, 
new Object() 
{
public BigDecimal computeTotal(List items)
{
assertNotNull(items);
serviceMethodCalled = true;
return total;
}
});
EntityX data = new EntityX(5, "abc", "5453-1");
new ServiceA().doBusinessOperationXyz(data);
assertEquals(total, data.getTotal());
assertTrue(serviceMethodCalled);
assertEquals(1, MockDatabase.findMethodCallCount);
assertEquals(1, MockDatabase.saveMethodCallCount);
}
}
JMockit is a good place to start when testing Java legacy code.
9.4.4 Use Vise while refactoring your Java code
Michael Feathers wrote an interesting tool for Java that allows you to 
verify that you aren’t messing up the values that may change in your 
method while refactoring it. For example, if your method changes an 
array of values, you want to make sure that as you refactor you don’t 
screw up a value in the array. 
Listing 9.3 shows an example of using the 
Vise.grip()
method for such 
a purpose.
Listing 9.3  Using Vise in Java code to verify values aren’t changed while refactoring
import vise.tool.*;
public class RPRequest {
...
public int process(int level, RPPacket packet) {
The magic 
happens here
Important tools for legacy code unit testing
251
if  (...) {
if (...) {
...
} else {
...
bar_args[1] += list.size();
Vise.grip(bar_args[1]);     
packet.add(new Subpacket(list, arrivalTime));
if (packet.calcSize() > 2)
bar_args[1] += 2; 
Vise.grip(bar_args[1]);   
}
} else {
int reqLine = -1;
bar_args[0] = packet.calcSize(reqLine);
Vise.grip(bar_args[0]);
...
}
}
}
NOTE
The  code  in  listing  9.3  is  copied  with  permission  from http://
www.artima.com/weblogs/viewpost.jsp?thread=171323.
Vise forces you to add lines to your production code, and it’s there to 
support refactoring of the code. There’s no such tool for .NET, but it 
should be pretty easy to write one. Every time you call the 
Vise.grip()
method, it checks whether the value of the  passed-in variable is still 
what it’s supposed to be. It’s like adding an internal assert to your code, 
with a simple syntax. Vise can also report on all “gripped” items and 
their current values.
You can read about and download Vise free from Michael Feathers’ 
blog: http://www.artima.com/weblogs/viewpost.jsp?thread=171323.
9.4.5 Use FitNesse for acceptance tests before you refactor
It’s a good idea to add integration tests to your code before you start 
refactoring it. FitNesse is one tool that helps create a suite of integra-
tion- and acceptance-style tests. FitNesse allows you to write integra-
Grips  
an object
Grips  
an object
252
CHAPTER 9    Working with legacy code
tion-style tests (in Java or .NET) against your application, and then 
change or add to them easily without needing to write code. 
Using the FitNesse framework involves three steps: 
1
Create code adapter classes (called 
fixtures
) that can wrap your pro-
duction code and represent actions that a user might take against it. 
For example,  if  it  were a  banking  application,  you  might  have  a 
bankingAdapter
class that has withdraw and deposit methods. 
2
Create HTML tables using a special syntax that the FitNesse engine 
recognizes and parses. These tables will hold the values that will be 
run during the tests. You write these tables in pages in a specialized 
wiki website that runs the FitNesse engine underneath, so that your 
test suite is represented to the outside world by a specialized web-
site. Each page with a table (which you can see in any web browser) 
is editable like a regular wiki page, and each has a special “execute 
tests” button. These tables are then parsed by the testing runtime 
and translated into test runs.
3
Click the Execute Tests button on one of the wiki pages. That but-
ton invokes the FitNesse engine with the parameters in the table. 
Eventually,  the  engine  calls your  specialized  wrapper classes  that 
invoke the target application and asserts on return values from your 
wrapper classes.
Important tools for legacy code unit testing
253
Figure 9.6 shows an example FitNesse table in a browser.
You can learn more about FitNesse at http://fitnesse.org/. For .NET 
integration with FitNesse, go to http://fitnesse.org/FitNesse.DotNet.
9.4.6 Read Michael Feathers’ book on legacy code
Working Effectively with Legacy Code
, by Michael Feathers, is the only book I 
know  that  deals  with  the  issues  you’ll  encounter  with  legacy  code 
(other than this chapter). It shows many refactoring techniques and 
gotchas in depth that this book doesn’t attempt to cover. It’s worth its 
weight in gold. Go get it. 
9.4.7 Use NDepend to investigate your production code
NDepend is a relatively new commercial analyzer tool for .NET that 
can  create  visual  representations  of  many  aspects  of  your  compiled 
assemblies,  such  as  dependency  trees,  code  complexity,  changes 
between the different versions of the same assembly, and more. The pos-
sibilities of this tool are huge, and I recommend you learn how to use it.
NDepend’s most powerful feature is a special query language (called 
CQL) you can use against the structure of your code to find out vari-
Figure 9.6 Using  
FitNesse for integration 
254
CHAPTER 9    Working with legacy code
ous component metrics. For example, you could easily create a query 
that reports on all components that have a private constructor.
You can get NDepend from http://www.ndepend.com .
9.4.8 Use ReSharper to navigate and refactor production code
ReSharper is one of the best productivity-related plugins for VS.NET. 
In  addition  to  powerful  automated  refactoring  abilities  (much  more 
powerful than the ones built into Visual Studio 2008), it’s known for its 
navigation features. When jumping into an existing project, ReSharper 
can easily navigate the code base with shortcuts that allow you to jump 
from any point in the solution to any other point that might be related 
to it. 
Here are some examples of possible navigations:
When in a class or method declaration, you can jump to any inheri-
tors of that class or method, or jump up to the base implementation 
of the current member or class, if one exists.
You can find all uses of a given variable (highlighted in the current 
editor).
You can find all uses of a common interface or a class that imple-
ments it.
These and many other shortcuts make it much less painful to navigate 
and understand the structure of existing code.
ReSharper works on both VB.NET and C# code. You can download a 
trial version at www.jetbrains.com
9.4.9 Detect duplicate code (and bugs) with Simian
Let’s say you found a bug in your code, and you want to make sure that 
bug was not duplicated somewhere else. With Simian, it’s easy to track 
down code duplication and figure out how much work you have ahead 
of you, as well as refactoring to remove duplication. Simian is a com-
mercial product that works on .NET, Java, C++, and other languages.
You can get Simian here:  
http://www.redhillconsulting.com.au/products/simian/.
Documents you may be interested
Documents you may be interested