测试驱动的面向对象软件开发PDF电子书下载

第一部分　简介 2

第1章　测试驱动开发的要点 2

1.1　软件开发是一个学习过程 2

1.2　反馈是基本工具 2

1.3　支持变化的实践 3

1.4　测试驱动开发简介 4

1.5　大局 5

1.6　用户场景测试 6

1.7　测试的级别 6

1.8　外部品质与内部品质 7

第2章　测试驱动开发与对象 9

2.1　对象之网 9

2.2　值与对象 9

2.3　对象通信 10

2.4　吩咐，不要问 11

2.5　但有时要问 12

2.6　对协作的对象执行单元测试 13

2.7　用模拟对象支持TDD 13

第3章　工具介绍 15

3.1 如果您已了解这些框架，可以跳过本章 15

3.2　JUnit 4简介 15

3.2.1　测试用例 15

3.2.2　断言 16

3.2.3　预期异常 16

3.2.4　测试装置 16

3.2.5　测试执行者 17

3.3　Hamcrest匹配器和assertThat（） 17

3.4　jMock2：模拟对象 18

第二部分　测试驱动开发过程第4章　启动测试驱动循环 22

4.1　简介 22

4.2　先测试一个可行走的骨架 22

4.3　决定行走的骨架的形状 23

4.4　创建反馈源 25

4.5　尽早暴露不确定性 25

第5章　保持测试驱动循环 27

5.1　简介 27

5.2　每个特征都从一个验收测试开始 27

5.3　分离测量进度的测试和捕捉回归错误的测试 28

5.4　从最简单的成功场景开始测试 28

5.5　编写您愿意读的测试 29

5.6　看着测试失败 29

5.7　从输入开发到输出开发 29

5.8　针对行为进行单元测试，而非针对方法 30

5.9　聆听测试 30

5.10　调整循环 31

第6章　面向对象风格 32

6.1　简介 32

6.2　为可维护性而设计 32

6.3　内部与同级的比较 34

6.4　没有“与”、“或”、“但是” 35

6.5　对象同级构造型 35

6.6　组合比它的部分之和更简单 36

6.7　上下文无关性 37

6.8 正确地隐藏信息 38

6.9　固执己见的观点 38

第7章　实现面向对象设计 39

7.1　先写测试怎样有助于设计 39

7.2　通信比分类更重要 39

7.3　值类型 40

7.4　对象来自何处 41

7.4.1　分解 41

7.4.2　萌芽 42

7.4.3　打包 43

7.5　利用接口确定关系 43

7.6　接口也要重构 44

7.7　组合对象以描述系统行为 44

7.8　迈向更高层的编程 45

7.9　关于类 46

第8章　基于第三方代码构建 47

8.1　简介 47

8.2　只模拟您拥有的类型 47

8.2.1　不要模拟您不能修改的类型 47

8.2.2　编写一个适配层 48

8.3　在集成测试中模拟应用对象 48

第三部分　工作的例子 50

第9章　委托开发一个拍卖狙击者 50

9.1　从头开始 50

9.2　与一次拍卖通信 52

9.2.1　拍卖协议 52

9.2.2　XMPP消息 53

9.3　安全实现目标 53

9.4　这不是真的 54

第10章　可行走的骨架 55

10.1　从壁橱中取出骨架 55

10.2　我们的第一个测试 55

10.3　一些初始选择 57

10.3.1　用户场景测试 58

10.3.2　准备开始 59

第11章　通过第一个测试 60

11.1　构建测试的装配 60

11.1.1　应用执行者 60

11.1.2　伪造的拍卖 62

11.1.3　消息代理 64

11.2　测试失败和通过 65

11.2.1　第一个用户界面 65

11.2.2　显示狙击者状态 66

11.2.3　连接到拍卖 67

11.2.4　从拍卖接收回应 68

11.3　必需的最小实现 70

第12章　准备竞拍 71

12.1　对市场的介绍 71

12.2　针对竞拍的测试 71

12.2.1　从测试开始 71

12.2.2　扩展伪造的拍卖 72

12.2.3　令人吃惊的失败 75

12.2.4　由外至内开发 76

12.2.5　对细节的无限关注 76

12.3　AuctionMessageTranslator类 77

12.3.1　提取出一个新类 77

12.3.2　第一个单元测试 77

12.3.3　完成用户界面循环 80

12.3.4　我们实现了什么 81

12.4　解析价格消息 81

12.4.1　引入消息事件类型 81

12.4.2　第二个测试 81

12.4.3　发现进一步的工作 83

12.5　完成工作 83

第13章　狙击者发出竞拍出价 84

13.1 引入AuctionSniper 84

13.1.1　一个新类及其依赖关系 84

13.1.2　关注、关注、关注 86

13.2　发送竞拍出价 86

13.2.1　Auction接口 86

13.2.2　AuctionSniper发出竞拍出价 87

13.2.3　利用AuctionSniper成功竞拍 88

13.2.4　用户场景测试通过了 90

13.3　整理实现 90

13.3.1　提取出XMPPAuction 90

13.3.2　提取用户界面 91

13.3.3　整理翻译者类 92

13.4　延迟决定 94

13.5　自然发生的设计 94

第14章　狙击者赢得拍卖 95

14.1　先写一个失败的测试 95

14.2　谁知道竞拍者 96

14.3　狙击者还有话要说 98

14.4　狙击者需要某种状态 99

14.5　狙击者获胜 101

14.6　取得稳定的进展 102

第15章　迈向真正的用户界面 103

15.1　更现实的实现 103

15.1.1　接下来我们该做什么 103

15.1.2　替换JLabel 104

15.1.3　还是很丑 105

15.2　显示价格细节 105

15.2.1　先写一个失败的测试 105

15.2.2　狙击者送出状态 106

15.2.3　展现竞拍狙击者 108

15.3　简化狙击者事件 111

15.3.1　跟着感觉走 111

15.3.2　重新确定sniperBidding（）的目标 112

15.3.3　填人数字 113

15.4　更进一步 114

15.4.1　转换胜利和失败 114

15.4.2　修整表模型 116

15.4.3　面向对象的列 117

15.4.4　缩短事件路径 117

15.5　最后润色 119

15.5.1　针对列标题的测试 119

15.5.2　实现TableModel 119

15.5.3　目前已足够 120

15.6　短评 121

15.6.1　单一职责 121

15.6.2　软件微创手术 121

15.6.3　程序员过敏症 121

15.6.4　庆贺思维转变 121

15.6.5　这不是唯一的解决方案 122

第16章　狙击多项物品 123

16.1　针对多项物品的测试 123

16.1.1　两件物品的故事 123

16.1.2　ApplicationRunner类 124

16.1.3　偏离主题，改进失败信息 125

16.1.4　重新设计Main的结构 125

16.1.5　扩展表模型 127

16.2　通过用户界面添加物品 129

16.2.1　更简单的设计 129

16.2.2　更新测试 130

16.2.3　添加一个动作条 131

16.2.4　设计时刻 131

16.2.5　另一层次的测试 132

16.2.6 实现UserRequestListener 133

16.3　短评 134

16.3.1　取得稳定的进展 134

16.3.2　TDD的秘密 134

16.3.3　发布它 134

第17章　分解Main 136

17.1　发现角色 136

17.2　提取Chat 136

17.2.1　分离Chat 136

17.2.2　封装Chat 138

17.2.3　编写一个新测试 139

17.3　提取Connection 139

17.4　提取出SnipersTableModel 141

17.4.1　狙击启动者类SniperLauncher 141

17.4.2　狙击组合 142

17.5　短评 144

17.5.1　增量式架构 144

17.5.2　三点不动 145

17.5.3　动态设计的同时也进行静态设计 145

17.5.4　对notToBeGCd的另一种修复方法 146

第18章　填充细节 147

18.1　更有用的应用 147

18.2　适可而止 147

18.2.1　引入落后状态 147

18.2.2　第一个失败的测试 148

18.2.3　输入停止价格 149

18.2.4　传送停止价格 150

18.2.5　约束AuctionSniper 151

18.3　短评 153

18.3.1　增量式设计用户界面 153

18.3.2　其他建模技术也有用 153

18.3.3　领域类型比字符串好 153

第19章　处理失败 154

19.1　如果它不能工作 154

19.2　检测失败 155

19.3　显示失败 156

19.4　断开狙击者 157

19.5　记录失败 158

19.5.1　填充测试 159

19.5.2　翻译者中的失败报告 159

19.5.3　生成日志消息 160

19.5.4　完成这次开发循环 161

19.6　短评 162

19.6.1 “切香肠的逆过程”式开发 162

19.6.2　用一些小方法来表达意图 163

19.6.3　日志也是一项功能 163

第四部分　可持续的测试驱动开发第20章　聆听测试 166

20.1　简介 166

20.2　我需要模拟一个不能替换的对象 166

20.2.1　单例是依赖关系 166

20.2.2　从过程到对象 167

20.2.3　隐式依赖也是依赖 169

20.3　记日志是一项功能 169

20.3.1　通知而不是记日志 170

20.3.2　但这种想法很疯狂 170

20.4　模拟具体的类 171

20.5　不要模拟值类型 172

20.6　膨胀的构造方法 173

20.7　令人困惑的对象 174

20.8　太多依赖关系 175

20.9　太多预期 176

20.10　测试会告诉我们什么 178

第21章　测试可读性 180

21.1　简介 180

21.2　测试名称描述功能 181

21.3　规范的测试结构 182

21.4　精简测试代码 184

21.4.1　用结构来解释 184

21.4.2　利用结构来共享 184

21.4.3　强调正面 185

21.4.4　代理给从属对象 185

21.5　断言和预期 185

21.6　具体值和变量 186

第22章　构造复杂的测试数据 187

22.1　简介 187

22.2　测试数据建造者 187

22.3　创建一些类似的对象 189

22.4　组合建造者 190

22.5　利用工厂方法强调领域模型 190

22.6　从使用的角度消除重复 191

22.6.1　首先，消除重复 191

22.6.2　然后，让游戏升级 192

22.7　沟通第一 193

第23章　测试诊断 194

23.1　要的就是失败 194

23.2 小、专注、良好命名的测试 194

23.3　解释性断言消息 195

23.4　利用匹配器对象来突出细节 195

23.5 自描述的值 195

23.6　明显的预装值 196

23.7　跟踪者对象 196

23.8　明确断言预期得到满足 197

23.9　诊断是一级功能 197

第24章　测试的灵活性 198

24.1　简介 198

24.2　针对信息测试，而非针对表示方法 199

24.3　准确断言 200

24.4　准确预期 201

24.4.1　准确的参数匹配 201

24.4.2　允许和预期 201

24.4.3　忽略不相关的对象 202

24.4.4　调用次序 203

24.4.5　jMock States的威力 205

24.4.6　更为自由的预期 206

24.5 “豚鼠”对象 206

第五部分　高级主题 210

第25章　测试持久性 210

25.1　简介 210

25.2　隔离影响持久状态的那些测试 211

25.3　明确测试的事务边界 212

25.4　测试一个执行持久操作的对象 213

25.5　测试对象能够持久 216

25.5.1　来回转换持久对象 216

25.5.2　来回转换相关的实体 218

25.6　但数据库测试很慢 218

第26章　单元测试与线程 219

26.1　简介 219

26.2　分离功能和并发策略 220

26.2.1　并发地搜索拍卖 220

26.2.2　引入Executor 220

26.2.3　实现AuctionSearch 221

26.3　对同步进行单元测试 223

26.3.1　针对AuctionSearch的压力测试 223

26.3.2　两次修复竞争条件 225

26.4　对被动对象进行压力测试 226

26.5　同步测试线程和后台的多线程 227

26.6　单元压力测试的局限性 228

第27章　测试异步代码 229

27.1　简介 229

27.2　取样或监听 230

27.3　两种实现 231

27.3.1　捕获通知 231

27.3.2　轮询变更 233

27.3.3　超时 234

27.3.4　改进探测类 234

27.4　轻易成功的测试 235

27.5　错过更新 236

27.6　测试没有效果的活动 237

27.7　区分同步和断言 237

27.8　事件源外部化 238

后记　模拟对象简史 239

附录A　jMock2速查手册 243

附录B 编写Hamcrest Matcher 250

参考文献 252