Tải bản đầy đủ - 585 (trang)
D.2 The basics: compiling all source code

D.2 The basics: compiling all source code

Tải bản đầy đủ - 585trang

478



APPENDIX D



Running tests with Ant







C



Target for compiling

all source code








debug="on" classpathref="classpath.main" />




debug="on" classpathref="classpath.test" />





Different

compilation

class paths for

production

and test code







This is familiar to those who have seen Ant build scripts. The script in listing D.2

provides the developer with two targets to execute: B clean and C compile. With

Ant installed, typing ant clean on the command prompt deletes all compiled

class files. Typing ant compile compiles all .java source files into the bin directory.

Typing ant clean compile first deletes existing class files and then compiles everything from scratch. And, because the project’s default target is configured as compile, just typing ant is the same as typing ant compile.

But what about running those tests we’re now compiling?



D.3



Adding a target for running tests

JUnit is integrated into Ant through the task. In order to make running

our unit tests part of our build, we need to add a new target to build.xml, which

uses the task. Listing D.3 shows an example of what this new target

might look like.

Listing D.3 build.xml with a test target using Ant’s standard task





Use test target as

default from now on





...



Use property for

output path to

reduce duplication



B











Need everything



in class path



including compiled



test code



APPENDIX D



Running tests with Ant




todir="${junit.data}">


includes="**/Test*.java" />









B



479



Use property for output

path to reduce duplication



C



Collect all classes that

match pattern for execution







Without going to too much detail, the new target in listing D.3 uses the

task to C collect all unit tests from src/test for execution and generates a bunch

of XML files under B the configured reports/junit/data directory. These XML

files describe the test execution environment, which tests were run, and with what

kind of results. Those XML files aren’t user-friendly, though. We need a pretty

report to look at.



D.4



Generating a human-readable report

We can generate a nice, compact HTML report from the output of the

task by using another built-in task, . All it needs to know is where

to find the test results, where we want the report to be generated, and in what format—there are a couple of options.

Listing D.4 presents the necessary modifications to our existing build script for

both running the tests as well as for generating the HTML report.

Listing D.4



build.xml with a target for running tests and generating the report









...





"test" target

coordinates test

and reporting





















480



APPENDIX D



Running tests with Ant







“test” target



coordinates test





execution and



report generation







generates aggre
gated XML in data directory…

includes="TEST-*.xml" />







…and produces HTML report in frames





format under reports/junit/html



That’s it. We now have an Ant build script for compiling our code, running our

unit tests, and producing a pretty report of the results!



resources

Works cited

Alur, Deepak, Dan Malks, and John Crupi. Core J2EE Patterns: Best Practices and Design Strategies.

Prentice-Hall, 2003.

Ambler, Scott W. and Pramodkumar J. Sadalage. Refactoring Databases: Evolutionary Database

Design. Addison-Wesley, 2006.

Cohn, Mike. User Stories Applied: For Agile Software Development. Addison-Wesley, 2004.

Cooper, Alan. The Inmates Are Running the Asylum: Why High Tech Products Drive Us Crazy and How

to Restore the Sanity. Sams, 1999.

Crane, Dave, Bear Bibeault, Jord Sonneveld, Ted Goddard, Chris Gray, Ram Venkataraman, and

Joe Walker. Ajax in Practice. Manning Publications, 2007.

Crane, Dave, Eric Pascarello, and Darren James. Ajax in Action. Manning Publications, 2005.

Cunningham, Ward and Rick Mugridge. Fit for Developing Software: Framework for Integrated Tests.

Addison-Wesley, 2005.

DeMarco, Tom. Slack: Getting Past Burnout, Busywork, and the Myth of Total Efficiency. Broadway,

2001.

DeMarco, Tom and Timothy Lister. Peopleware: Productive Projects and Teams. Dorset House Publishing Company, 1999.

Feathers, Michael. Working Effectively with Legacy Code. Addison-Wesley, 2004.

Fowler, Martin, Kent Beck, John Brant, and William Opdyke. Refactoring: Improving the Design of

Existing Code. Addison-Wesley, 1999.

Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. Design Patterns: Elements of

Reusable Object-Oriented Software. Addison-Wesley, 1995.

Hillenius, Eelco and Martijn Dashorst. Wicket in Action. Manning Publications, 2007.

Kawasaki, Guy. Rules for Revolutionaries: The Capitalist Manifesto for Creating and Marketing New

Products and Services. Collins, 2000.

Kerievsky, Joshua. Refactoring to Patterns. Addison-Wesley, 2004.

Kuchana, Partha. Software Architecture Design Patterns in Java. Auerbach, 2004.



481



482



RESOURCES



Larman, Craig. Agile & Iterative Development: A Manager’s Guide. Addison-Wesley, 2003.

Loughran, Steve and Erik Hatcher. Ant in Action: Java Development with Ant, Second Edition. Manning

Publications, 2007.

Mann, Kito. JavaServer Faces in Action. Manning Publications, 2005.

Manns, Mary Lynn and Linda Rising. Fearless Change: Patterns for Introducing New Ideas. AddisonWesley, 2004.

Rainsberger, J. B. JUnit Recipes: Practical Methods for Programmer Testing. Manning Publications, 2005.

Ship, Howard M. Lewis. Tapestry in Action. Manning Publications, 2004.



Additional resources

Ambler, Scott W. Agile Database Techniques: Effective Strategies for the Agile Software Developer. Wiley,

2003.

Beck, Kent. Test Driven Development: By Example. Addison-Wesley, 2002.

Cohn, Mike. Agile Estimating and Planning. Prentice Hall PTR, 2005.

Duvall, Paul, Steve Matyas, and Andrew Glover. Continuous Integration: Improving Software Quality and

Reducing Risk. Addison-Wesley, 2007.

Goetz, Brian, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, and Doug Lea. Java Concurrency in Practice. Addison-Wesley, 2006.

Meszaros, Gerard. xUnit Test Patterns: Refactoring Test Code. Addison-Wesley, 2007.

Newkirk, James W. and Alexei A. Vorontsov. Test-Driven Development in Microsoft .NET. Microsoft

Press, 2004.

Schwaber, Ken and Mike Beedle. Agile Software Development with SCRUM. Prentice Hall, 2001.



Online resources

All URLs listed here were valid at the time of publishing. No doubt some of these will

change over time.

Agical AB. RMock: Java Mock Object Framework to Use with JUnit. http://rmock.sf.net.

Agile Finland Community. Agile Finland Community Wiki. http://wiki.agilefinland.com.

Apache Community. Apache Ant Community Wiki. http://wiki.apache.org/ant.

———. Apache Ant: A Java-Based Build Tool. http://ant.apache.org.

———. Apache Ant Manual. http://ant.apache.org/manual.

———. Apache Maven: A Java-Based Build Tool. http://maven.apache.org.

———. Continuum: A Continuous Integration Server. http://maven.apache.org/continuum.

———. Jakarta Commons Lang: A Utility Library for the java.util API. http://jakarta.apache.org/

commons/lang.



RESOURCES



483



———. Jakarta Commons VFS: A Virtual File System API for Java. http://jakarta.apache.org/

commons/vfs.

———. Wicket: A Component-Based Web Development Framework for Java. http://wicket.sf.net.

Ashley, Nick, Graham Tackley, and Sam Newman. dbdeploy: A Database Change Management

Tool. http://dbdeploy.com/.

Atlassian Software Systems Pty Ltd. Bamboo: A Continuous Integration Server. http://www.

atlassian.com/software/bamboo.

Atomic Object LLC. System Testing in Ruby. http://atomicobject.com/pages/System+

Testing+in+Ruby.

Bossicard, Vladimir R. PrivateAccessor: A Utility Class for Overriding Access Modifiers in Java.

http://junit-addons.sourceforge.net/junitx/util/PrivateAccessor.html.

Bowler, Mike. GSBase: A JUnit Extension of Test Utilities. http://gsbase.sf.net.

Cenqua. Clover: Code Coverage Analysis Tool for Java. http://www.cenqua.com/clover.

Cunningham, Ward. Fit: Framework for Integrated Test. http://fit.c2.com.

Diehl and Associates. Mckoi Database: A Lightweight, Java-Based Relational Database. http://

mckoi.com/database.

Feathers, Michael. “The ‘Self’-Shunt Unit Testing Pattern.” January 2001. http://www.

objectmentor.com/resources/articles/SelfShunPtrn.pdf.

———. “The Humble Dialog Box.” August 2002. http://www.objectmentor.com/resources/

articles/TheHumbleDialogBox.pdf.

———. “Working Effectively With Legacy Code.” February 2002. http://www.objectmentor.com/

resources/articles/WorkingEffectivelyWithLegacyCode.pdf.

Fowler, Amy. “A Swing Architecture Overview.” http://java.sun.com/products/jfc/tsc/articles/

architecture/.

Fowler, Martin. “Continuous Integration.” May 1, 2006. http://www.martinfowler.com/articles/

continuousIntegration.html.

———. “Mocks Aren’t Stubs.” January 2, 2007. http://www.martinfowler.com/articles/

mocksArentStubs.html.

———. Passive View. July 18, 2006. http://www.martinfowler.com/eaaDev/PassiveScreen.html.

———. Supervising Controller. June 19, 2006. http://www.martinfowler.com/eaaDev/

SupervisingPresenter.html.

Freeman, Steve, Tim Mackinnon, Nat Pryce, Mauro Talevi, and Joe Walnes. JMock: A Dynamic

Mock Object Library for Java. http://www.jmock.org.

hsql Development Group. HSQLDB: A Lightweight, Java-Based Relational Database. http://

www.hsqldb.org.



484



RESOURCES



Hubbard, Charlie and Prashant Dhokte. PrivilegedAccessor: A Utility Class for Overriding Access

Modifiers in Java. http://groups.yahoo.com/group/junit/files/src/PrivilegedAccessor.java

(requires a Yahoo! account).

Jeffries, Ron. “Essential XP: Card, Conversation, Confirmation.” August 30, 2001. http://

www.xprogramming.com/xpmag/expCardConversationConfirmation.htm.

———. List of testing-related software. http://www.xprogramming.com/software.htm.

Koskela, Lasse. Bean Inject: Dependency Injection Framework for Java. http://www.

laughingpanda.org/mediawiki/index.php/Bean_Inject.

———. Introduction to Code Coverage. January 2004. http://www.javaranch.com/newsletter/

200401/IntroToCodeCoverage.html.

———. JspTest: A JUnit Extension for Unit Testing JavaServer Pages. http://sourceforge.net/

projects/jsptest.

Martin, Robert C. “Design Principles and Design Patterns.” January 2000. http://www.

objectmentor.com/resources/articles/Principles_and_Patterns.pdf.

———. “SRP: The Single Responsibility Principle.” February 2002. http://www.

objectmentor.com/resources/articles/srp.pdf.

Meszaros, Gerard. xUnit Test Patterns. http://www.xunitpatterns.com.

Mort Bay Consulting. Jetty: An Embeddable Java EE Web Container. http://jetty.mortbay.com.

Mugridge, Rick. FitLibrary: An Extension Package for Fit and Fitnesse. http://sourceforge.net/

projects/fitlibrary.

NetBeans Community. Jellytools Module: Jemmy Extension for Creating UI Tests for NetBeans

IDE. http://jellytools.netbeans.org.

———. Jemmy: UI Testing Library for Java. http://jemmy.netbeans.org.

Payne, Bob. Agile Toolkit Podcast. Interview with Arlo Belshee at Agile 2005: “Promiscuous Pairing

and the Least Qualified Implementer.” http://media.libsyn.com/media/agiletoolkit/

ArloBelsheeAgile2005.mp3.

Perrotta, Paolo. The Virtual Clock Test Pattern. March 1, 2003. http://www.nusco.org/docs/

virtual_clock.pdf.

Potel, Mike. MVP: Model-View-Presenter, The Taligent Programming Model for C++ and Java.

1996. http://www.arsip.or.id/free_doc/m/mvp/mvp.pdf.

Pragmatic Programmers, LLC. “Tell, Don’t Ask.” http://www.pragmaticprogrammer.com/ppllc/

papers/1998_05.html.

Rothman, Johanna. “What Does It Cost You To Fix A Defect? And Why Should You Care?” 2000.

http://www.jrothman.com/Papers/Costtofixdefect.html.

Ruby on Rails Community wiki. Understanding Migrations. August 1, 2007. http://wiki.

rubyonrails.com/rails/pages/UnderstandingMigrations.



RESOURCES



485



Saff, David, Erich Gamma, Kent Beck, and Erik Meade. JUnit: A Simple Framework for Writing and

Running Automated Tests. http://www.junit.org.

Schuh, Peter and Stephanie Punke. “ObjectMother: Easing Test Object Creation in XP.” 2001.

http://www.agilealliance.org/system/article/file/910/file.pdf.

SourceForge.net. Cobertura: Code Coverage Analysis Tool for Java. http://cobertura.sf.net.

———. CruiseControl: A continuous integration server. http://cruisecontrol.sf.net.

———. DbUnit: A JUnit Extension for Testing Database Code. December 28, 2006. http://

dbunit.sf.net.

———. EMMA: Code Coverage Analysis Tool for Java. http://emma.sf.net.

———. Joda-Time: A Time and Date API to Replace the Standard java.util Classes. http://

joda-time.sourceforge.net.

———. PMD: Static Analysis Tool for Java. http://pmd.sf.net.

———. SUnit: The Mother of All Unit Testing Frameworks. http://sunit.sf.net.

Splint Community. Splint: Static Analysis Tool for C. http://splint.org.

Tammo Freese. EasyMock: A Dynamic Mock Object Library for Java. http://www.easymock.org.

Urban{code}, Inc. AnthillPro: A Continuous Integration Server. http://www.urbancode.com.

World Wide Web Consortium. Logging Control in W3C httpd. July 1995. http://www.w3.org/

Daemon/User/Config/Logging.html#common_logfile_format.

———. XML Path Language (XPath). November 16, 1999. http://www.w3.org/TR/xpath.

Yahoo! Inc. JUnit Group and Online Mailing List. http://groups.yahoo.com/group/junit.



index

A

Abbot 295, 297, 300, 418

ComponentTester utility 297

ComponentTestFixture

class 297

abstract base class 174, 181,

206, 237

for DbUnit-based integration

tests 239

Abstract Factory pattern 127

abstract user interface 356

abstraction 35, 212, 275

between MVC controller and

view 169

keeping uniform level of

87–88

level of 419

level, consistency in

methods 69–70

acceptance 450

exercising the internals 414

acceptance criteria 353

acceptance TDD See acceptance

test-driven development

acceptance test 4, 33, 35, 324,

335, 341, 404, 440

accelerating execution

426–431

adding detail 337

adding new 353

as communication tool 421

as indicator of completion 31

as shared language 33

as specification See tests as

specification



automating 337, 340, 345, 391

automating through UI 417

avoiding turbulent

interfaces 399

brittleness 403

categorization 426

challenge of automating 417

common fixtures

between 431

complexity 425, 431

connecting with system under

test 401

crawling under the skin 404

customer-friendly format 359

dependency between

tests 429

design 403

detail in 332

difference between unit test

and internals-exercising

acceptance test 409

duplication 431

embedding into system under

test 419

end-to-end strategy 401

example of 327, 330

executable, syntax of 339, 341

expressing with concrete

examples 354

focus of 398

for FTP client 416

for programming library 413

for web application 431

generating data set for 433

getting access to

transaction 430



487



heavyweight 409

hooking into service layer 422

identifying 342

implementation

approaches 401–411

implementing 333, 337, 406

implementing against

programming API 416

implementing for complex

systems 425

introduction 327–333

list of 336

maintainability 429

mapping to user-accessible

functionality 403

merging with unit test 413

organizing into test suites 428

owned by customer 329

passing 31

performance 356

properties 328–333

reducing complexity 431

refactoring 404, 425

running against stubbed

system 410

running on simulator 358

side effects 411, 426

structuring 431

stubbing 357–358

subsets of 426

suite 403

targeted at system

internals 408

technology-specific

implications 411–425

timing 337



488



INDEX



acceptance test (continued)

tips 425–433

tools for implementing 338

translating to executable

test 338–339

updating 399

validation of 331

what to test 397–401

when to write 345–346

writing 329, 337,

345, 350, 360

writing with jWebUnit 401

writing with wiki syntax 360

acceptance test-driven

development 4, 7, 10, 31,

98, 324, 327, 341, 401

as team activity 348–351

automating tests 337–341

benefits 351

benefits of 351–355

continuous planning 344–346

cooperative work 353

customer properties 349–350

cycle 334–343

decreasing load 346

defining customer role

348–350

definition of “done” 351–353

frameworks for 37

homegrown tools 362

implementing

functionality 341–343

inside an iteration 343–348

mid-iteration sanity test 346

number of testers 350

picking user story 335–336

process 324

process, understanding

334–348

promoting 446, 463

properties of 324

scripting language–based

frameworks 361

specification by example 354

splitting stories 347

table-based tools 359–361

text-based frameworks 361

tools 359–362

trust and commitment 354

what we’re testing 355–359



whether to stub parts of

system 357

whether to test against

UI 355–357

whether to test business

logic 358

who writes tests with

customer 350

with Fit 365–369

acceptance testing 37, 361

approach to 400

backdoor 411

crawling under the skin

412, 414–415, 419

end-to-end 406, 416–418,

421, 425

exercising the internals

407, 412, 414, 421

framework 37, 359, 365

implementation

approaches 401

strategy 412, 414, 416

strategy, choosing 411

strategy, cost 414

stubbing out the

irrelevant 409

technological

considerations 411

tools 359

access point 212

accessor method 211, 291

accomplishment 438, 442

account manager 12

ActionFixture

372, 379–382, 384

header row 379

ActionListener 304

actor 379

Adobe Photoshop 417

adoption 4, 10, 436

assigning roles 463–464

coaching and

facilitation 461–463

destabilization 464

evangelizing for change

454–457

facilitating 454–465

lowering bar to change

457–458

of Java 200

rewards, delayed 465



sharing information 459–461

training and education 458

Agile 2005 336

Agile Finland 451

agile methods 19, 454, 458

agile software development

7, 31

Agile Toolkit Podcast 336

agility

key ingredient of 7

Ajax 423

alarm system 8

Alexander, Christopher

364, 396

algorithm 58, 77, 85, 101,

116, 223, 378

using to find connecting

line 313

verbosity 313

Alleman, Glen B. 323

alternative implementation 90,

111, 116, 120, 124, 140, 160

alternative implementation

See test double

Alur, Deepak 198

ambiguity 21, 33–34

Ambler, Scott 244

analytic thinking 452

annotation 50, 67, 186, 211

anonymous class 291

anonymous

implementation 139, 316

anonymous inner class 141

Ant See Apache Ant

AntHill 39

antidote 7

anti-pattern 109

Apache Ant 365, 392

build script 391

build script, adding target for

running tests 478–479

build script, compiling source

code 477–478

build script, directory

structure of 476–477

build script, generating

report 479–480

build script, running Fit

with 392

FTP task 393



Tài liệu bạn tìm kiếm đã sẵn sàng tải về

D.2 The basics: compiling all source code

Tải bản đầy đủ ngay(585 tr)

×