c# mvc website pdf file in stored in byte array display in browser : Delete page in pdf software SDK project winforms windows html UWP The%20Art%20of%20Unit%20Testing%20with%20Examples%20in%20.NET%20(Manning%202009)29-part1061

Alternatives to designing for testability
This is where designing for testability starts to melt down a bit. Some-
times you  can’t  work  around  security  or patent  issues.  You have  to 
change what you do or compromise on the way you do it.
A.3.4 Sometimes you can’t
Sometimes there are political or other reasons for the design to be done 
a  specific  way,  and  you  can’t change  or  refactor  it.  Sometimes you 
don’t have the time to refactor your design, or the design is too fragile 
to refactor. This is another case where designing for testability breaks 
down—when you can’t or won’t do it.
Now that we’ve gone through some pros and cons, it’s time to consider 
some alternatives to designing for testability.
It’s interesting to look outside the box at other languages to see other 
ways of working. 
In dynamic languages such as Ruby or Smalltalk, the code is inherently 
testable because you can replace anything and everything dynamically 
at runtime. In such a language, you can design the way you want without 
having to worry about testability. You don’t need an interface in order to 
replace something, and you don’t need to make something public to 
override it. You can even change the behavior of core types dynamically, 
and no one will yell at you or tell you that you can’t compile.
In a world where everything is testable, do you still design for testabil-
ity? The answer is, of course, “no.” In that sort of world, you’re free to 
choose your own design. 
Consider  a  .NET-related  analogy  that  shows  how  using  tools  can 
change the way you think about problems, and sometimes make big 
problems a non-issue. In a world where memory is managed for you, 
do you still design for memory management? Mostly, “no” would be 
the answer. People working in languages where memory isn’t managed 
for them (C++, for example) need to worry about and design for mem-
ory optimization and collection, or the application will suffer. 
A.4 Alternatives to designing for testability
Delete page in pdf - remove PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provides Users with Mature Document Manipulating Function for Deleting PDF Pages
delete pdf pages android; delete pdf pages reader
Delete page in pdf - 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
add and delete pages in pdf; delete page on pdf file
APPENDIX A        Design and testability
In the same way, by following testable object-oriented design princi-
ples,  you  might  get  testable  designs  as  a  byproduct,  but  testability 
should not be a goal in your design. It’s just there to solve a specific 
problem. If a tool comes along that solves the testability problem for 
you, there will be no need to design specifically for testability. There 
are other merits to such designs, but using them should be a choice and 
not a fact of life.
The  main  problems  with  nontestable  designs  is  their  inability  to 
replace dependencies at runtime. That’s why we need to create inter-
faces, make methods virtual, and do many other related things. There 
are  tools  that  can  help  replace  dependencies  in  .NET  code  without 
needing to refactor it for testability. One such tool is Typemock Isola-
tor  (www.Typemock.com),  a  commercial  tool  with  an  open  source 
Does the fact that a  tool  like Isolator  exists mean we  don’t need to 
design for testability? In a way, yes. It rids us of the need to think of 
testability as a design goal. There are great things about the OO pat-
terns  Bob  Martin  presents, and they  should be used not because of 
testability, but because  they seem  right  in a design sense. They  can 
make code  easier to  maintain, easier to  read,  and  easier  to develop, 
even if testability is no longer an issue.
In  this  appendix,  we  looked  at  the  idea  of  designing  for  testability: 
what it involves in terms of design techniques, its pros and cons, and 
alternatives to doing it. There are no easy answers, but the questions 
are interesting. The future of unit testing will depend on how people 
approach such issues, and on what tools are available as alternatives.
Testable designs usually only matter in static languages, such as C# or 
VB.NET, where testability depends on proactive design choices that 
allow things to  be  replaced. Designing for  testability matters less in 
more dynamic languages, where things are much more 
testable by default
In such languages, most things are easily replaceable, regardless of the 
project design.
A.5 Summary
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 page from pdf file; delete pdf pages in preview
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# .NET, how to
delete pages of pdf preview; delete pages from pdf without acrobat
Testable  designs  have  virtual  methods,  nonsealed  classes,  interfaces, 
and a clear separation of concerns. They have fewer static classes and 
methods,  and  many  more instances of  logic  classes.  In fact, testable 
designs are what SOLID design principles have stood for. Perhaps it’s 
time that the end goal should not be testability, but good design instead.
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
PDF: Insert PDF Page. VB.NET PDF - How to Insert a New Page to PDF in VB.NET. Easy to Use VB.NET APIs to Add a New Blank Page to PDF Document in VB.NET Program.
cut pages from pdf; add and remove pages from pdf file online
C# PDF remove image library: remove, delete images from PDF in C#.
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
copy pages from pdf to new pdf; cut pages from pdf online
Appendix B
Extra tools and frameworks
his book would not be complete without an overview of some tools and 
basic techniques you can use while writing code. From database testing to 
UI testing and web testing, this appendix lists tools you should consider. 
Some  of  them  are  used  for  integration  testing,  and  some  allow  unit 
testing. I’ll also mention some that I think are good for beginners. 
The tools and techniques listed below are arranged in the following cate-
Isolation frameworks
Test frameworks
Dependency injection and IoC containers
Database testing
Web testing
UI testing
Thread-related testing
Acceptance testing
An updated version of the following list can be found on the book’s wiki 
site: ArtOfUnitTesting.com. 
Let’s begin.
Mock or isolation frameworks are the bread and butter of advanced unit-
testing scenarios. There are many to choose from, and that’s a great thing: 
B.1  Isolation frameworks
VB.NET PDF delete text library: delete, remove text from PDF file
VB.NET: Delete a Character in PDF Page. It demonstrates how to delete a character in the first page of sample PDF file with the location of (123F, 187F).
delete pages from a pdf in preview; delete pages on pdf online
VB.NET PDF remove image library: remove, delete images from PDF in
C# File: Split PDF; C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# Read: PDF Text Extract; Delete image objects in selected PDF page in ASPX webpage.
cut pages from pdf reader; acrobat export pages from pdf
Isolation frameworks
Rhino Mocks
Typemock Isolator
Here is a short description of each framework.
B.1.1 Moq
Moq is an open source  newcomer to  the world of  mocking  and  has 
adopted an API that tries to be both simple to learn and easy to use. 
The API also follows  the arrange-act-assert style  (as  opposed to the 
record-and-replay model) and relies heavily on .NET 3.5 features, such 
as lambdas and extension methods. If you’re planning on working with 
.NET 3.5 exclusively, this is a relatively pain-free learning curve, but 
you need to feel comfortable with using lambdas. 
In terms of features, it has fewer than most other mock frameworks, 
which also means it’s simpler to learn.
You can get Moq at http://code.google.com/p/moq/.
B.1.2 Rhino Mocks
Rhino Mocks is a widely used open source framework for mocks and 
stubs. It’s also the framework used throughout this book for examples, 
and it’s discussed more in chapter 5. 
Rhino Mocks is loaded with features and has recently moved to using 
the new arrange-act-assert syntax.
You can get Rhino Mocks at  
B.1.3 Typemock Isolator
Typemock Isolator is a powerful commercial isolation framework that 
tries to remove the terms “mocks” and “stubs” from its vocabulary in 
favor of a more simple and terse API. 
C# PDF delete text Library: delete, remove text from PDF file in
C#.NET Sample Code: Delete Text from Specified PDF Page. The following demo code will show how to delete text in specified PDF page. // Open a document.
acrobat extract pages from pdf; delete blank page from pdf
C# PDF metadata Library: add, remove, update PDF metadata in C#.
Allow C# Developers to Read, Add, Edit, Update and Delete PDF Metadata in .NET Project. Remove and delete metadata from PDF file.
delete page from pdf reader; delete page pdf acrobat reader
APPENDIX B        Extra tools and frameworks
Isolator differs from the other frameworks by allowing  you to 
components from their dependencies regardless of how the system is 
designed (although it supports all  the features the other frameworks 
have). This makes it ideal for people who are getting into unit testing 
and want an incremental approach to learning. Because it doesn’t force 
you to design for testability, you can learn to write tests correctly and 
then move on to learning better design, without having to mix the two 
Full disclosure: While writing this book, I’ve also been working at 
You can get Typemock Isolator at www.typemock.com
B.1.4 NMock
NMock is an  open source  mocking framework that  started  out  as  a 
direct port of jMock. It used to be the de facto mocking framework 
until Rhino Mocks took its place in the open source world. The main 
reason it was dethroned is that it did not offer strong typing of method 
names. (You had to  use strings to  define  expectations  on  methods.) 
Lately,  it  has  been  getting  back  into development,  and the  new  2.0 
release marks a nice change in the API. It remains to be seen how well 
it will do against the current competition.
You can get NMock at www.NMock.org.
B.1.5 NUnit.Mocks
NUnit.Mocks is an ultra-small open source mocking framework that 
comes built into NUnit as a separate DLL. It initially started life as an 
aid for testing NUnit internally, and NUnit’s authors still discourage 
people from using it in their own projects, because it may “disappear” 
in the future. 
NUnit.Mocks is one of the simplest frameworks to learn with, but I 
don’t recommend using it for anything other than a learning tool. 
You can get NUnit.Mocks as part of the installation of NUnit at  
Test frameworks
The test frameworks  are the bases from which we start  writing our 
tests. Like mock frameworks, there are many to choose from, and this 
competition has brought lots of innovation with it. Here are some of 
the available frameworks:
Microsoft’s Unit Testing Framework
Let’s look at each in turn.
B.2.1 Microsoft’s Unit Testing Framework
Microsoft’s Unit Testing Framework (also known as MSTest) comes 
bundled with any version of Visual Studio .NET 2008 professional or 
above. It includes basic features that are similar to NUnit, but it runs a lit-
tle slower. The upcoming versions of Visual Studio (2010) will add a lot 
of power to this framework, but you can use it today as easily as NUnit.
One big problem with this framework is that it’s not as easily extensi-
ble as the other testing frameworks. To see how cumbersome it is to 
add a simple attribute, see the discussion of YUnit on MSDN at http://
One big plus for this framework is that it’s integrated into the Visual 
Studio Team System tool suite and provides good reporting, coverage, 
and build automation out of the box. If your company uses Team Sys-
tem, I highly suggest using MSTest as your test framework because of 
the good integration possibilities.
You can get MSTest with Visual Studio.
B.2.2 NUnit
NUnit is currently the de facto test framework for unit test developers 
in .NET. It’s open source and is in almost ubiquitous use among those 
B.2 Test frameworks
APPENDIX B        Extra tools and frameworks
who do unit testing. I cover NUnit deeply in chapter 2. NUnit is easily 
extensible and has a large user base and forums. I’d recommend it to 
anyone starting out with unit testing in .NET. I still use it today.
You can get NUnit at http://nunit.com .
B.2.3 MbUnit
MbUnit is fully open source, and the “mb” stands for “model-based” 
testing. It started out as a competitor to NUnit but soon zoomed past 
NUnit in terms of features and abilities. 
MbUnit is easily extensible and supports lots of interesting test attri-
butes, such as Repeat and Timeout. MbUnit has its own UI and con-
sole runners that also support running tests written in NUnit. If you’re 
looking for something more in your current test framework, MbUnit is 
a good step up from NUnit. I almost never have to use such features 
myself, but if you’re mixing integration testing and unit testing with the 
same framework, MbUnit is a good fit.
You can get MbUnit at www.mbunit.com.
B.2.4 Gallio
Gallio is an open source platform for running tests written in most (if 
not all) unit test frameworks in .NET, from NUnit to MSTest. Gallio is 
also extensible, and you can create your own custom test runner using 
it. It has plugins for Visual Studio .NET, which can highlight coding 
errors relating to tests and other things. It’s still not in very popular 
use, but it’s built by the same people who maintain MbUnit, and it’s a 
fully working, robust product that seems  to have been in an endless 
beta cycle for the past year or so. 
You can get Gallio at www.gallio.org.
B.2.5 xUnit
xUnit is an open source test framework, developed in cooperation with 
one of the original authors of NUnit, Jim Newkirk. It’s a minimalist 
and elegant test framework that tries to get back to basics by having 
fewer features, not more, than the other frameworks, and by support-
ing different names on its attributes. 
IoC containers
What is so radically  different about  it? It  has no setup  or teardown 
methods, for one. You have to use the constructor and a dispose method 
on the test class. Another big difference is in how easy it is to extend. 
Because xUnit reads so differently from the other frameworks, it takes 
a while to get used to it if you’re coming from a framework like NUnit 
or MbUnit. If you’ve never used any test framework before, xUnit is 
easy to grasp and use, and it’s robust enough to be used in a real project.
For more information and download see www.codeplex.com/xunit.
B.2.6 Pex
Pex  (short for  program  exploration)  is an intelligent  assistant to the 
programmer. From a parameterized unit test, it automatically produces 
a traditional unit test suite with high code coverage. In addition, it sug-
gests to the programmer how to fix the bugs.
With Pex, you can create special tests that have parameters in them, 
and put special attributes on those tests. The Pex engine will generate 
new tests that you can later run as part of your test suite. It’s great for 
finding corner cases and edge conditions that aren’t handled properly 
in your code. You should use Pex in addition to a regular test frame-
work, such as NUnit or MbUnit.
You can get Pex at http://research.microsoft.com/projects/pex/.
IoC  (Inversion  Of  Control)  containers  can  be  used  to  improve  the 
architectural  qualities  of  an  object-oriented  system  by  reducing  the 
mechanical costs of good design techniques (such as using constructor 
parameters, managing object lifetimes, and so on). 
Containers  can  enable  looser  coupling  between  classes  and  their 
dependencies, improve the testability of a class structure, and provide 
generic  flexibility  mechanisms.  Used  judiciously,  containers  can 
greatly enhance the opportunities for code reuse by minimizing direct 
coupling between classes and  configuration mechanisms (such as by 
using interfaces).
B.3 IoC containers
APPENDIX B        Extra tools and frameworks
We’ll look at the following tools:
Microsoft Unity
Castle Windsor
Autofac (Auto Factory)
Common Service Locator Library
Microsoft Managed Extensibility Framework
Let’s look briefly at each of these frameworks.
B.3.1 StructureMap
StructureMap  is  an  open  source  container  framework  that  has  one 
clear differentiator from the others. Its API is very fluent and tries to 
mimic natural language and generic constructs as much as possible. 
StuctureMap has a relatively small user base, and the current documen-
tation on it is lacking, but it contains some powerful features, such as a 
built-in automocking container (a container that can create stubs auto-
matically when requested to by the test), powerful lifetime management, 
XML-free configuration, integration with ASP.NET, and more.
You can get StructureMap at http://structuremap.sourceforge.net.
B.3.2 Microsoft Unity 
Unity is a latecomer to the DI container field, but it provides a simple 
and minimal approach that can be easily learned and used by begin-
ners. Advanced users may find it lacking, but it certainly answers my 
80-20 rule: it provides 80 percent of the features you look for most of 
the time. 
Unity is open source by Microsoft, and it has good documentation. I’d 
recommend it as a starting point for working with containers.
You can get Unity at www.codeplex.com/unity.
Documents you may be interested
Documents you may be interested