Question

多年来我注意到，我倾向于编写一个充满代码的屏幕，然后进行测试以确保它能够做到应有的效果。

这种技术的一些好处是

语法错误是新代码的结果，     所以你不必远远地找到原因。

设置临时条件很便宜，可以让你测试其他条件     if语句的子句，因此您可以确保收到错误消息，     当它们便宜的测试时，等等。

您如何编码？
这样做会带来什么好处？

编辑：像我的大多数问题一样，我真的没有充分确定上下文。我并不是在谈论单元测试级别的粒度。我指的是在实现时确保本地代码完全符合我的意图。

Answer 1

我想说我在编写相应的代码之前总是写一个单元测试来传递它，但我会撒谎。

Answer 2

我倾向于编码，直到我有一些应该产生明确定义的可观察行为的东西。通常，这是一个单独的公共API函数，有时是完整的类。这也鼓励我将问题分解为具有明确定义的可观察行为的小函数。我的大部分功能都比全屏小。如果一个函数太复杂而无法测试，那么它无论如何都可能从其他角度设计得很糟糕。

Answer 3

就个人而言，我发现在实际编写测试之前，我倾向于编写明显的Interfaces并拖入实用程序资源（无论是C＃库，CSS，等等）。

我认为狂热与经验之间存在平衡。

Answer 4

这可能听起来很傻，但我通常在每次“处理任务”后测试我写的代码。意思是，如果我打开一个文件，我会测试例程。如果我连接到数据库并提取单个记录，我会测试该例程。或者有时我会编写一个测试，只是练习一个类的所有方法，看看它们是否有效。

我认为我没有使用硬规则或快速规则，但主要是当我编写代码来执行任务时，我会测试“验证”它会执行它应该执行的操作。

Answer 5

与我一样多。有时这意味着几百行，特别是当我将一个大型系统添加到现有框架时，当应用程序甚至没有它的某些部分时就会运行。

我想我会尽可能遵循测试原则。显然，这并不意味着写一个循环的中途，但是当我完成循环后，我会在继续之前尝试一下。自上次测试以来您的更改越少，就越容易找出导致错误情况的更改内容。：）

Answer 6

我通常会按照您的描述进行操作，但在测试之前我没有写完整页。我发现，如果我编写一些代码然后编写测试，我通常必须重构代码以使其更易于测试。这看起来有点浪费，所以在编写单元测试之前，我只需要几行代码。我发现我越来越接近严格遵守TDD。

Answer 7

由于您没有提及您编码的语言环境......

当我在Smalltalk工作时，在我输入时在编辑器中检查语法，并且每当我接受一个方法时，这都不是问题。（对于那些不了解Smalltalk的人：它不是基于文件的，而是面向对象的;这意味着您可以一次一个地添加方法对象到类对象，并且系统按原样编译它们“在编辑中接受。

对于算法或不需要大框架/设置的小方法，我添加了一些注释来测试该方法，并且可以通过单击执行。还有一个测试运行器来提取所有这些并将它们作为单元测试运行。对于更大的东西，TestCase类会针对每一种方法进行更新，并且会不时地点击测试运行按钮，让我处于红灯状态。

所以我想说，每10行左右进行一次测试。我承认，这样做需要一个高度反应性和增量的IDE - 否则，它不能这么容易地完成，我会在测试之前恢复大致写一个字母大小的代码页。我不认为可编辑性是“测试”，因此句法正确性不计算在内。

编辑：为了您的娱乐，这里是Collection类的一个具体示例：
对于那些不了解smalltalk的人：
引用的字符串是评论;
+/-是创建测量值的操作员;
/创造分数;
{...}是数组创建;
最后的测试用例可以在编辑器中直接执行（所谓的doIt）。

sum
    "sum up all elements.
     This is implemented using a variant of the normal inject:into: pattern. 
     The reason for this is that it is not known whether we are dealing with number
     (i.e. if 0 is a good initial value for the sum). 
     Consider a collection of measurement or physical objects, 0 would be the unitless 
     value and would not be appropriate to add with the unit-ed objects."

    | sum sample |

    sample := self anElement.
    sum := self inject: sample into: [:accum :each | accum + each].
    ^ sum - sample.

    "
     TestCase should: [ { } sum ] raise:Error.
     TestCase should: [ ''  sum ] raise:Error.

     TestCase assert: ( { 1 } sum = 1 ).
     TestCase assert: ( { 1. 2. 3. 4. } sum = 10 ).
     TestCase assert: ( (1 to:10) sum = 55 ).
     TestCase assert: ( 'abc' asByteArray sum = 294 ).

     TestCase assert: ( { 10 +/- 2.
                          20 +/- 4.
                         100 +/- 10 } sum = (130 +/- 16) ).

     TestCase assert: ( { (1 / 9).
                          (1 / 7).
                        } sum = (16 / 63) ).
    "

Answer 8

我不使用TDD，而是首先构建有效的测试存根，这将成为实际的应用程序。

例如，在WinForms应用程序中，我首先构建按钮并测试它们。然后，当我构建类时，我测试UI的类调用类的方法。

然后，如果我要将实际的工作放到后台工作器中，我在其中没有任何内容构建它，并测试Start / Progress / Complete处理程序全部触发，并由类来处理创造了BGW。

然后我开始将功能放入方法中，因此已经有了经过测试的测试工具。我必须为此构建一个单独的线束非常罕见，因为每个增量都很小，并且在添加下一级复杂度之前进行测试。

这样做的好处是，我不必同时考虑太多的复杂性，如果没有基础已经经过充分测试的基础，那么很少会增加。

我从未发现单元测试存在任何问题 - 我真正想要的是自动测试的水平高于此。

Answer 9

取决于项目的规模/规模。如果它是一个简短的程序（编译和运行很简单），我会提前测试它，并且通常在我添加任何新功能时。这让我能够快速捕捉到大多数错误。

在一个大型项目（公司规模）中，我会像这样隔离测试我的作品，如果可以的话。否则，请注意对每日构建的测试。

简而言之，尽可能经常测试，只要编译/运行时间不长，你就考虑进行办公剑术！

Answer 10

我倾向于测试程序的每个功能。不是每个功能，而是一系列形成功能的功能。这样做的好处是我没有很多开销来测试每个函数，而是在彼此之后进行测试。

Answer 11

我现在所从事的项目应该首先进行单元测试然后进行开发，而且大多数情况下都是如此，但有时编写测试的人和实现的人并不总是在同一页面上。

所以我喜欢使用单元测试来检查所需方法的主要功能，然后让实现代码的人编写几个单元测试来检查代码的各个边缘。

Answer 12

我越老，在运行/测试之前编写的代码就越少。

在某种程度上，这是技术进步的结果：我开始在COBOL编码表上编写代码，每周两次当穿孔女孩进来时，将其转换为穿孔卡片。我通常甚至不会尝试编译新的程序直到它基本完成并经过桌面检查，通常是几千行和几周。

现在，当我在游戏中时，我在测试之前没有编写任何代码，我在编码之前编写了一个测试。我很弱，并不总是确定如何编写测试，所以有时候我告诉自己我只是这样做是务实的。令人惊讶的是，经常会出现一个坏主意：我作为TDD的结果编写的代码往往更容易测试，更容易修改，而且大多比后来测试的代码更好。

但那只是我，YMMV。

Answer 13

通常，只要我完成一个函数，我就编译它，切换到REPL，并用一些临时组成的数据（也是边缘情况）测试它。有时（通常比我更喜欢）需要一些调试周期（编辑 - 编译 - 测试）才能获得所需的行为。当然，如果您可以将函数单独编译到提供REPL的运行运行库中，那么这种开发风格才是可行的，否则您将花费太多时间等待完整编译。我使用SBCL和SLIME。

Answer 14

我尝试第一次将代码运行为单元测试。

有时我会先编写测试，有时候我会先编写方法/类。

我喜欢感觉良好关于我的自己，
  所以我喜欢给自己积极的一面   反馈经常，
  所以我试着   “证明”一种新方法在我写完之后。

在测试之前，您倾向于编写多少代码？

14 个答案: