没有合适的资源?快使用搜索试试~ 我知道了~
首页测试驱动开发 Test-Driven Development
Clean code that works - now. This is the seeming contradiction that lies behind much of the pain of programming. Test-driven development replies to this contradiction with a paradox-test the program before you write it. A new idea? Not at all. Since the dawn of computing, programmers have been specifying the inputs and outputs before programming precisely. Test-driven development takes this age-old idea, mixes it with modern languages and programming environments, and cooks up a tasty stew guaranteed to satisfy your appetite for clean code that works-now.
资源详情
资源评论
资源推荐

I l
@ve RuBoard
•
Table of Contents
Test-Driven Development By Example
By
Kent Beck
Publisher
: Addison Wesley
Pub Date
: November 08, 2002
ISBN
: 0-321-14653-0
Pages
: 240
Clean code that works - now. This is the seeming contradiction that lies behind much of the pain of
programming. Test-driven development replies to this contradiction with a paradox-test the program
before you write it.
A new idea? Not at all. Since the dawn of computing, programmers have been specifying the inputs
and outputs before programming precisely. Test-driven development takes this age-old idea, mixes it
with modern languages and programming environments, and cooks up a tasty stew guaranteed to
satisfy your appetite for clean code that works-now.
Developers face complex programming challenges every day, yet they are not always readily prepared
to determine the best solution. More often than not, such difficult projects generate a great deal of
stress and bad code. To garner the strength and courage needed to surmount seemingly Herculean
tasks, programmers should look to test-driven development (TDD), a proven set of techniques that
encourage simple designs and test suites that inspire confidence.
By driving development with automated tests and then eliminating duplication, any developer can
write reliable, bug-free code no matter what its level of complexity. Moreover, TDD encourages
programmers to learn quickly, communicate more clearly, and seek out constructive feedback.
Readers will learn to:
Solve complicated tasks, beginning with the simple and proceeding to the more complex.
Write automated tests before coding.
Grow a design organically by refactoring to add design decisions one at a time.
Create tests for more complicated logic, including reflection and exceptions.
Use patterns to decide what tests to write.
Create tests using xUnit, the architecture at the heart of many programmer-oriented testing
tools.

I l
@ve RuBoard
•
Table of Contents
Test-Driven Development By Example
By
Kent Beck
Publisher
: Addison Wesley
Pub Date
: November 08, 2002
ISBN
: 0-321-14653-0
Pages
: 240
Clean code that works - now. This is the seeming contradiction that lies behind much of the pain of
programming. Test-driven development replies to this contradiction with a paradox-test the program
before you write it.
A new idea? Not at all. Since the dawn of computing, programmers have been specifying the inputs
and outputs before programming precisely. Test-driven development takes this age-old idea, mixes it
with modern languages and programming environments, and cooks up a tasty stew guaranteed to
satisfy your appetite for clean code that works-now.
Developers face complex programming challenges every day, yet they are not always readily prepared
to determine the best solution. More often than not, such difficult projects generate a great deal of
stress and bad code. To garner the strength and courage needed to surmount seemingly Herculean
tasks, programmers should look to test-driven development (TDD), a proven set of techniques that
encourage simple designs and test suites that inspire confidence.
By driving development with automated tests and then eliminating duplication, any developer can
write reliable, bug-free code no matter what its level of complexity. Moreover, TDD encourages
programmers to learn quickly, communicate more clearly, and seek out constructive feedback.
Readers will learn to:
Solve complicated tasks, beginning with the simple and proceeding to the more complex.
Write automated tests before coding.
Grow a design organically by refactoring to add design decisions one at a time.
Create tests for more complicated logic, including reflection and exceptions.
Use patterns to decide what tests to write.
Create tests using xUnit, the architecture at the heart of many programmer-oriented testing
tools.
This book follows two TDD projects from start to finish, illustrating techniques programmers can use
to easily and dramatically increase the quality of their work. The examples are followed by references
to the featured TDD patterns and refactorings. With its emphasis on agile methods and fast
development strategies,
Test-Driven Development
is sure to inspire readers to embrace these under-
utilized but powerful techniques.
I l
@ve RuBoard

I l
@ve RuBoard
•
Table of Contents
Test-Driven Development By Example
By
Kent Beck
Publisher
: Addison Wesley
Pub Date
: November 08, 2002
ISBN
: 0-321-14653-0
Pages
: 240
Clean code that works - now. This is the seeming contradiction that lies behind much of the pain of
programming. Test-driven development replies to this contradiction with a paradox-test the program
before you write it.
A new idea? Not at all. Since the dawn of computing, programmers have been specifying the inputs
and outputs before programming precisely. Test-driven development takes this age-old idea, mixes it
with modern languages and programming environments, and cooks up a tasty stew guaranteed to
satisfy your appetite for clean code that works-now.
Developers face complex programming challenges every day, yet they are not always readily prepared
to determine the best solution. More often than not, such difficult projects generate a great deal of
stress and bad code. To garner the strength and courage needed to surmount seemingly Herculean
tasks, programmers should look to test-driven development (TDD), a proven set of techniques that
encourage simple designs and test suites that inspire confidence.
By driving development with automated tests and then eliminating duplication, any developer can
write reliable, bug-free code no matter what its level of complexity. Moreover, TDD encourages
programmers to learn quickly, communicate more clearly, and seek out constructive feedback.
Readers will learn to:
Solve complicated tasks, beginning with the simple and proceeding to the more complex.
Write automated tests before coding.
Grow a design organically by refactoring to add design decisions one at a time.
Create tests for more complicated logic, including reflection and exceptions.
Use patterns to decide what tests to write.
Create tests using xUnit, the architecture at the heart of many programmer-oriented testing
tools.
I l
@ve RuBoard
•
Table of Contents
Test-Driven Development By Example
By
Kent Beck
Publisher
: Addison Wesley
Pub Date
: November 08, 2002
ISBN
: 0-321-14653-0
Pages
: 240
Copyright
Preface
Courage
Acknowledgments
Introduction
Part I. The Money Example
Chapter 1. Multi-Currency Money
Chapter 2. Degenerate Objects
Chapter 3. Equality for All
Chapter 4. Privacy
Chapter 5. Franc-ly Speaking
Chapter 6. Equality for All, Redux
Chapter 7. Apples and Oranges
Chapter 8. Makin' Objects
Chapter 9. Times We're Livin' In
Chapter 10. Interesting Times
Chapter 11. The Root of All Evil
Chapter 12. Addition, Finally
Chapter 13. Make It
Chapter 14. Change
Chapter 15. Mixed Currencies
Chapter 16. Abstraction, Finally
Chapter 17. Money Retrospective
What's Next?
Metaphor
JUnit Usage
Code Metrics
Process
Test Quality

I l
@ve RuBoard
•
Table of Contents
Test-Driven Development By Example
By
Kent Beck
Publisher
: Addison Wesley
Pub Date
: November 08, 2002
ISBN
: 0-321-14653-0
Pages
: 240
Clean code that works - now. This is the seeming contradiction that lies behind much of the pain of
programming. Test-driven development replies to this contradiction with a paradox-test the program
before you write it.
A new idea? Not at all. Since the dawn of computing, programmers have been specifying the inputs
and outputs before programming precisely. Test-driven development takes this age-old idea, mixes it
with modern languages and programming environments, and cooks up a tasty stew guaranteed to
satisfy your appetite for clean code that works-now.
Developers face complex programming challenges every day, yet they are not always readily prepared
to determine the best solution. More often than not, such difficult projects generate a great deal of
stress and bad code. To garner the strength and courage needed to surmount seemingly Herculean
tasks, programmers should look to test-driven development (TDD), a proven set of techniques that
encourage simple designs and test suites that inspire confidence.
By driving development with automated tests and then eliminating duplication, any developer can
write reliable, bug-free code no matter what its level of complexity. Moreover, TDD encourages
programmers to learn quickly, communicate more clearly, and seek out constructive feedback.
Readers will learn to:
Solve complicated tasks, beginning with the simple and proceeding to the more complex.
Write automated tests before coding.
Grow a design organically by refactoring to add design decisions one at a time.
Create tests for more complicated logic, including reflection and exceptions.
Use patterns to decide what tests to write.
Create tests using xUnit, the architecture at the heart of many programmer-oriented testing
tools.
One Last Review
Part II. The xUnit Example
Chapter 18. First Steps to xUnit
Chapter 19. Set the Table
Chapter 20. Cleaning Up After
Chapter 21. Counting
Chapter 22. Dealing with Failure
Chapter 23. How Suite It Is
Chapter 24. xUnit Retrospective
Part III. Patterns for Test-Driven Development
Chapter 25. Test-Driven Development Patterns
Test
(noun)
Isolated Test
Test List
Test First
Assert First
Test Data
Evident Data
Chapter 26. Red Bar Patterns
One Step Test
Starter Test
Explanation Test
Learning Test
Another Test
Regression Test
Break
Do Over
Cheap Desk, Nice Chair
Chapter 27. Testing Patterns
Child Test
Mock Object
Self Shunt
Log String
Crash Test Dummy
Broken Test
Clean Check-in
Chapter 28. Green Bar Patterns
Fake It ('Til You Make It)
Triangulate
Obvious Implementation
One to Many
Chapter 29. xUnit Patterns
Assertion
Fixture
External Fixture
Test Method
Exception Test
All Tests

I l
@ve RuBoard
•
Table of Contents
Test-Driven Development By Example
By
Kent Beck
Publisher
: Addison Wesley
Pub Date
: November 08, 2002
ISBN
: 0-321-14653-0
Pages
: 240
Clean code that works - now. This is the seeming contradiction that lies behind much of the pain of
programming. Test-driven development replies to this contradiction with a paradox-test the program
before you write it.
A new idea? Not at all. Since the dawn of computing, programmers have been specifying the inputs
and outputs before programming precisely. Test-driven development takes this age-old idea, mixes it
with modern languages and programming environments, and cooks up a tasty stew guaranteed to
satisfy your appetite for clean code that works-now.
Developers face complex programming challenges every day, yet they are not always readily prepared
to determine the best solution. More often than not, such difficult projects generate a great deal of
stress and bad code. To garner the strength and courage needed to surmount seemingly Herculean
tasks, programmers should look to test-driven development (TDD), a proven set of techniques that
encourage simple designs and test suites that inspire confidence.
By driving development with automated tests and then eliminating duplication, any developer can
write reliable, bug-free code no matter what its level of complexity. Moreover, TDD encourages
programmers to learn quickly, communicate more clearly, and seek out constructive feedback.
Readers will learn to:
Solve complicated tasks, beginning with the simple and proceeding to the more complex.
Write automated tests before coding.
Grow a design organically by refactoring to add design decisions one at a time.
Create tests for more complicated logic, including reflection and exceptions.
Use patterns to decide what tests to write.
Create tests using xUnit, the architecture at the heart of many programmer-oriented testing
tools.
Chapter 30. Design Patterns
Command
Value Object
Null Object
Template Method
Pluggable Object
Pluggable Selector
Factory Method
Imposter
Composite
Collecting Parameter
Singleton
Chapter 31. Refactoring
Reconcile Differences
Isolate Change
Migrate Data
Extract Method
Inline Method
Extract Interface
Move Method
Method Object
Add Parameter
Method Parameter to Constructor Parameter
Chapter 32. Mastering TDD
How large should your steps be?
What don't you have to test?
How do you know if you have good tests?
How does TDD lead to frameworks?
How much feedback do you need?
When should you delete tests?
How do the programming language and environment influence TDD?
Can you test drive enormous systems?
Can you drive development with application-level tests?
How do you switch to TDD midstream?
Who is TDD intended for?
Is TDD sensitive to initial conditions?
How does TDD relate to patterns?
Why does TDD work?
What's with the name?
How does TDD relate to the practices of Extreme Programming?
Darach's Challenge
Appendix I. Influence Diagrams
Feedback
Appendix II. Fibonacci
Afterword
I l
@ve RuBoard
剩余217页未读,继续阅读













安全验证
文档复制为VIP权益,开通VIP直接复制

评论1