c# mvc website pdf file in stored in byte array display in browser : Delete a page from a pdf file SDK application service wpf windows html dnn The%20Art%20of%20Unit%20Testing%20with%20Examples%20in%20.NET%20(Manning%202009)3-part1062

Unit testing—the classic definition
5
1.1.1 The importance of writing “good” unit tests 
Most people who try to unit-test their code either give up at some point 
or don’t actually perform unit tests. Instead, they either rely on system 
and integration tests to be performed much later in the product lifecycle 
or they resort to manually testing the code via custom test applications 
or by using the end product they’re developing to invoke their code. 
There’s no point in writing a bad unit test, unless you’re learning how 
to  write  a  good  one and these are  your  first steps  into this  field.  If 
you’re going to write a unit test badly without realizing it, you may as 
well not write it at all, and save yourself the trouble it will cause down 
the road with maintainability and time schedules. By defining what a 
good unit test is, we can make sure we don’t start off with the wrong 
notion of what we’re trying to write.
To succeed in this delicate art of unit testing, it’s essential that you not 
only have a 
technical definition
of what unit tests are, but that you describe 
the 
properties
of a good unit test. To understand what a good unit test is, 
we need to look at what developers do when they’re testing something. 
How do you make sure that the code works today? 
1.1.2 We’ve all written unit tests (sort of)
You may be surprised to learn this, but  you’ve already implemented 
some types of unit testing on your own. Have you ever met a developer 
who has not tested his code before handing it over? Well, neither have I.
You  might  have  used  a  console  application  that  called  the  various 
methods of  a class  or component, or perhaps some specially created 
WinForm or WebForm UI (user interface) that checked the function-
ality of that class or component, or maybe even manual tests run by 
performing various actions  within the real application’s UI. The end 
result is that you’ve made certain, to a degree, that the code works well 
enough to pass it on to someone else. 
Figure 1.1  shows how  most  developers test their code. The UI may 
change, but the pattern is usually the same: using a manual external 
tool to check something repeatedly, or running the application in full 
and checking its behavior manually. 
Delete a page from a pdf file - remove PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provides Users with Mature Document Manipulating Function for Deleting PDF Pages
delete pages from pdf preview; delete page in pdf
Delete a page from a pdf file - 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
delete a page from a pdf online; delete pages from pdf
6
CHAPTER 1    The basics of unit testing
Figure 1.1 In classic testing, developers 
use a GUI (graphical user interface) to  
trigger an action on the class they want  
to test. Then they check the results.
These tests may have been useful, and they may come close to the clas-
sic definition of a unit test, but they’re far from how we’ll define a 
good 
unit test
in  this book.  That  brings us  to the  first  and most  important 
question a developer has to face when defining the qualities of a good 
unit test: what is a unit test, and what is not. 
A unit test 
should
have the following properties: 
It should be automated and repeatable.
It should be easy to implement.
Once it’s written, it should remain for future use.
Anyone should be able to run it.
It should run at the push of a button.
It should run quickly.
Many people confuse the act of testing their software with the concept 
of a unit test. To start off, ask yourself the following questions about 
the tests you’ve written up to now:
Can  I  run  and get  results from  a  unit  test  I  wrote  two weeks  or 
months or years ago?
1.2 Properties of a good unit test
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
C# File: Merge PDF; C# File: Split PDF; C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# Read: PDF Text Extract; C# Read: PDF
delete a page from a pdf in preview; delete page pdf
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
your PDF document is unnecessary, you may want to delete this page adding a page into PDF document, deleting unnecessary page from PDF file and changing
delete a page from a pdf acrobat; delete pdf pages acrobat
run and get the results from unit tests I 
’ve written in no more than a few min-
ve written at the push of a button?
n no more than a few minutes?
of these questions, there’s a high proba-
nting isn’t a unit test. It’s definitely 
some
as a unit test, but it has drawbacks com-
u answer “yes” to all of those questions.
you might ask. You’ve done 
integration 
C# PDF Page Insert Library: insert pages into PDF file in C#.net
page processing functions, such as how to merge PDF document files by C# code, how to rotate PDF document page, how to delete PDF page using C#
delete blank pages from pdf file; delete page in pdf document
C# PDF File Split Library: Split, seperate PDF into multiple files
Besides, in the process of splitting PDF document, developers can also remove certain PDF page from target PDF file using C#.NET PDF page deletion API.
delete page in pdf file; delete pdf pages ipad
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Since images are usually or large size, images size reducing can help to reduce PDF file size effectively. Delete unimportant contents Embedded page thumbnails.
delete pages on pdf; cut pages from pdf online
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
using RasterEdge.XDoc.PDF; Add and Insert a Page to PDF File Using VB. doc2.Save( outPutFilePath). Add and Insert Blank Page to PDF File Using VB.
delete page pdf online; add or remove pages from pdf
ware, whereas a unit test usually exercises and tests only a single unit
in isolation.
The questions from the beginning of section 1.2 can help you recognize 
some of the drawbacks of integration testing. Let’s look at them and try 
to define the qualities we’re looking for in a good unit test.
Drawbacks of integration tests compared to automated unit tests
Let’s apply the questions from section 1.2 to integration tests, and con-
sider what we want to achieve with real-world unit tests: 
Can I run and get results from the test I wrote two weeks or months 
or years ago?
If you can’t do that, how would you know whether you broke a fea-
ture that you created two weeks ago? Code changes regularly during 
the life of an application, and if you can’t (or won’t) run tests for all 
the previous  working  features  after changing  your  code,  you  just 
might break it without knowing. I call this “accidental bugging,” and 
it seems to occur a lot near the end of a software project, when devel-
opers are under pressure to fix existing bugs. Sometimes they intro-
duce new bugs inadvertently as they solve the old ones. Wouldn’t it 
be great to know that you broke something within three minutes of 
breaking it? We’ll see how that can be done later in this book.
Good tests should be easily executed in their original form, not man-
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Since images are usually or large size, images size reducing can help to reduce PDF file size effectively. Delete unimportant contents Embedded page thumbnails.
delete pages on pdf file; delete pages from pdf without acrobat
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
document file, and choose to create a new PDF file in .NET NET document imaging toolkit, also offers other advanced PDF document page processing and
delete page pdf acrobat reader; delete a page in a pdf file
Few things are scarier than not knowing whether the application still 
works, especially when you didn’t write that code. If you knew you 
weren’t breaking anything, you’d be much less afraid of taking on 
code you’re less  familiar with because you have  that safety net of 
unit tests. 
Good tests can be accessed and run by anyone.
TION
Legacy code
is defined by Wikipedia as “source code that relates to a no-
longer supported or manufactured operating system or other computer 
technology,” but many shops refer to any older version of the applica-
tion currently under maintenance as legacy code. It often refers to code 
that’s hard to work with, hard to test, and usually even hard to read. 
A  client  of  mine  once  defined  legacy  code  in  a down-to-earth way: 
“code that works.” Many people like to  define legacy  code as “code 
that  has  no  tests.”  The  book 
Working  Effectively  with Legacy Code
Michael Feathers uses this as an official definition of legacy code, and 
it’s a definition to be considered while reading this book.
Can I run all the tests in no more than a few minutes?
If you can’t run your tests quickly (seconds are better than minutes), 
you’ll run them less often (daily, or even weekly or monthly in some 
places). The problem is that, when you change code, you want to get 
feedback  as  early  as  possible  to  see  if  you  broke  something.  The 
more time between running the tests, the more changes you make to 
the system, and the (many) more places to search for bugs when you 
Good tests should be easily executed in their original form, not man-
ually.
Can I write a basic test in no more than a few minutes?
One of the easiest ways to spot an integration test is that it takes time 
to prepare correctly and to implement, not just to execute. It takes 
time to  figure  out how to  write  it  because  of  all  the  internal and 
sometimes external dependencies. (A database may be considered an 
external dependency.) If you’re not automating the test, dependen-
cies are less of  a  problem, but  you’re  losing all the benefits  of an 
automated test. The harder it is to write a test, the less likely you are 
to write more tests, or to focus on anything other than the “big stuff” 
that you’re worried about. One of the strengths of unit tests is that 
they tend to test every little thing that might break, not only the big 
stuff. People are often surprised at how many bugs they can find in 
code they thought was simple and bug free. 
When you concentrate only on the big tests, the logic 
coverage
your tests have is smaller. Many parts of the core logic in the code 
aren’t tested (even though you may be covering more components), 
and there may be many bugs that you haven’t considered. 
Good tests against the system should be easy and quick to write. 
From what we’ve seen so far about what a unit test is not, and what fea-
tures need to be present for testing to be useful, we can now start to 
This definition sure looks like a tall order, particularly considering how 
many developers I’ve seen implementing unit tests poorly. It makes us 
take a hard look at the way we, as developers, have implemented test-
ing up until now, compared to how we’d like to implement it. (“Trust-
worthy,  readable,  and  maintainable”  tests  are  discussed  in  depth  in 
chapter 7.)
TION 
Logical code
is any piece of code that has some sort of logic in it, small as 
it may be. It’s logical code if it has one or more of the following: an IF 
statement, a loop, switch or case statements, calculations, or any other 
type of decision-making code. 
Properties  (getters/setters  in  Java)  are  good  examples  of  code  that 
usually doesn’t contain any logic, and so doesn’t require testing. But 
watch out: once you add any check inside the property, you’ll want to 
make sure that logic is being tested. 
In the next section, we’ll take a look at a simple unit test done entirely 
in code, without using any unit-testing framework. (We’ll look at unit-
testing frameworks in chapter 2.)
It’s possible to write an automated unit test without using a test frame-
work. In fact, as they have gotten more into the habit of automating 
A simple unit test example
Listing 1.1  A simple parser class to test
public class SimpleParser
{
public int ParseAndSum(string numbers)
{
if(numbers.Length==0)
{
return 0;
}
if(!numbers.Contains(","))
{
return int.Parse(numbers);
}
else
{
throw new InvalidOperationException(
"I can only handle 0 or 1 numbers for now!");
}
}
}
We can create a simple console application project that has a reference 
to the assembly containing this class, and we can write a 
SimplePar-
serTests
method as shown in listing 1.2. The test method invokes the 
production  class
(the class to  be  tested)  and  then checks  the  returned 
value. If it’s not what’s expected, it writes to the console. It also catches 
any exception and writes it to the console.
Listing 1.2  A simple coded method that tests the 
SimpleParser
class
class SimpleParserTests
{
public static void TestReturnsZeroWhenEmptyString()
{
try
{
SimpleParser p = new SimpleParser();
int result = p.ParseAndSum(string.Empty);
if(result!=0)
{
14
CHAPTER 1    The basics of unit testing
Console.WriteLine(
@"***SimpleParserTests.TestReturnsZeroWhenEmptyString: 
-------
Parse and sum should have returned 0 on an empty string");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
Next,  we can  invoke  the  tests  we’ve written by using a simple 
Main
method run inside a console application in this project, as seen in listing 
1.3.  The 
Main
method  is  used  here  as  a  simple  test  runner,  which 
invokes the  tests  one  by  one, letting  them  write  out  to the  console. 
Because it’s an executable, this can be run without human intervention 
(assuming the tests don’t pop up any interactive user dialogs).
Listing 1.3  Running coded tests via a simple console application
public static void Main(string[] args)
{
try
{
SimpleParserTests.TestReturnsZeroWhenEmptyString();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
It’s the test method’s responsibility to catch any exceptions that occur 
and write them to the console, so that they don’t interfere with the run-
ning of subsequent methods. We can then add more method calls into 
the 
Main
method as we add more and more tests to the project. Each 
test is responsible for writing the problem output (if there’s a problem) 
to the console screen.
Documents you may be interested
Documents you may be interested