We do that for some of the more complex business logic. We wrote libraries, which are used by our tests, and we wrote tests which test the library functions to ensure they provide correct results.

What always worries me is that WE came up with that. It wasn't some higher up, or business unit, or anything. Only because we cared to do our job correctly. If we didn't - nobody would. Nobody is watching the testers (in my experience).

Right,too much coverage is also a bad thing. It leads to having to work on the silly tests every time you change som implementation detail.

Good tests let the insides of the unit change without breaking, as long as the behave the same to the outside world.

Unfortunately, if anyone, I do.

100%. TDD is just not practicably applicable to a lot of scenarios and I wish evangelists were clearer on that detail.

This is the reason I dislike TDD.

The only projects I've ever found interesting in my career was the stuff where nobody had any idea yet how the problem was going to be handled, and you're right that starting with tests is not even possible in this scenario (prototyping is what's really important). Whenever I've written yet another text/email/calling/video Skype clone for yet another cable company, it's possible to start with tests because you already know everything that's going into it.

constantly rewrite both the code and tests as you better understand how you’re going to solve the task while trying

The tests should be decoupled from the "how" though. It's obviously not possible to completely decouple them, but if you're "constantly" rewriting, something is going wrong.

Brilliant talk on that topic (with slight audio problems): https://www.youtube.com/watch?v=EZ05e7EMOLM

TDD doesn't imply that you write all the tests first. It just mean you have to write a test before you write a line of production code.

The idea is to ask yourself "what is the first step I need, where am I going to begin?". You then write a test that validate this first step and fail. Then you write the code to make it pass. Once your done with that, you ask yourself: "what's the next step? ". You, then, repeat the process for that step.

This is a process you are going to do anyway. Might as well take the time to write some test along with it.

The tests help you discover what needs to be written, too. Honestly, I can’t imagine starting to write code unless I have at least a rough concept of what to write.

Maybe I’m being judgemental (I don’t mean to be) but what I am trying to say is that, in my experience, writing tests as you code has usually lead to the best outcomes and often the fastest delivery times.

fun situations can arise when you write , instead of ; For those not in the know, in c++ the comma operator evaluates the left expression, discards the value, then evaluates the right expression and returns the value. if you now have a a situation like this

int i = 0,
printf("some message");

i has a completely different value, since it actually uses the return value of printf instead

Easy solution:

Find all: ;

Replace with: ,

Sure, so say so you have a requirement to add two numbers

You write a test that has two two inputs and the output Run the test and watch it fail, check that the output is what you expect so you know the test is working

At this point you have no implementation and you use this opportunity to confirm that the test will work, by checking it is failing how you expect. If you are pairing sometime I teach that you should call out what you expect, kinda like in American pool. Sometimes the test passed in this case, this is your opportunity to break the test and confirm it will fail (though this is often a sign you did too much work previously, and might need to check if you really are making the smallest possible change)

Do the minimum to correct the problem described by the failing test (you can follow the transformation priority premises here if you are familiar with it)

At this point you have only implemented the simplest possible code, this makes it really easy to spot if there is a problem with it because of some flaw in the test, and you have confirmed the it matches your test

What's more you can confirm all, and only behaviours described in the test are implemented

Look at the code and decide if you can simplify it, do any refactoring

Got to clean the kitchen because if we don't clean the kitchen we will have to clean the garage and we don't want that because it's a bigger job.

repeat

Why this works is that the code is developed in a TDD style forces you to move in smaller steps meaning bugs are shallower when they do occur. You aren't dealing with a 20 complex lines, you are dealing with a return const, or selection, or etc. The scope for the test being wrong is reduced and the amount of implementation is reduced, generally the tests end up more concise and smaller too and the interfaces are user friendly too because you didn't think how do I calculate this, you thought what would be a nice way to call this.

What's more it encourages an example driven approach that leads to developers thinking about the most sensible input data over and over again, and what that should output reducing the chance any one wrongly implemented test wouldn't be picked up by other examples.

TL;DR, the driven word is the key, a test that is illogical will never drive you to the working code