测试驱动开发Test-DrivenDevelopment - CSDN文库

5星 · 超过95%的资源需积分: 16 156 浏览量更新于2023-03-03 评论收藏 9.42MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

资源详情

资源评论

资源推荐

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页未读，继续阅读

评论1

ye_9th

2012-12-19

我经理专门推荐看的文档。文档清晰，谢谢分享

ruoshuirulan

粉丝: 0
资源: 1

会员权益专享

图片转文字

全年可省5，000元立即开通

最新资源

资源上传下载、课程学习等过程中有任何疑问或建议，欢迎提出宝贵意见哦~我们会及时处理！点击此处反馈