TDD has cycles of red, green, refactor. This has neither been refactored nor tested. You can tell by the duplication and the fact that it can’t pass all test cases.
If this looks like TDD to you, I’m sorry that is your experience. Good results with TDD are not guaranteed, you still have to be a strong developer and think through the solution.
As the existing reply stated, there are only ever finitely many tests.
My issue with TDD is that it pretends to drive the final implementation with tests, but what is really driving the implementation is the monkey at the keyboard thinking, “testing for evenness should be done with the modulo operation,” not exhaustive tests.
The monkey at the keyboard thinking is what software development is. When faced with a failing test, you make it pass as simply as possible, and then you summon all your computer science / programming experience to refactor the code into something more elegant and maintainable.
In this case that is using math to check if the input is divisible by two without a remainder. If you don’t know how that works, you’re going to have a bad time, like the picture in this post.
TDD doesn’t promise to drive the final implementation at the unit level, but it does document how the class under test behaves and how to use it.
When faced with a failing test, you make it pass as simply as possible, and then you summon all your computer science / programming experience to refactor the code into something more elegant and maintainable.
Why bother making it pass “as simply as possible” instead of summoning all that experience to write something that don’t know is stupid?
TDD doesn’t promise to drive the final implementation at the unit level
What exactly does it drive, then? Apart from writing more test code than application code, with attendant burdens when refactoring or making other changes.
The rhythm of TDD is to first write a failing test. That starts driving the design of your production code. To do that you need to invoke a function/method with arguments that responds with an expected answer.
At that point you’ve started naming things, designing the interface of the unit being tested, and you’ve provided at least one example.
Let’s say you need a method like isEven(int number): Boolean. I’d start with asserting 2 is even in my first test case.
To pass that, I can jump to number % 2 == 0. Or, I can just return true. Either way gets me to a passing test, but I prefer the latter because it enables me to write another failing test.
Now I am forced to write a test for odd input, so I assert 3 is not even. This test fails, because it currently just returns true. Now I must implement a solution that handles even and odd inputs correctly; I know modulus is the answer, so I use it now. Now both tests pass.
Then I think about other interesting cases: 0, negative ints, integer max/min, etc. I write tests for each of them, the modulus operator holds up. Great. Any refactoring to do? Nope. It’s a one-liner.
The whole process for this function would only add a few minutes of development, since the implementation is trivial. The test runtime should take milliseconds or less, and now there is documentation for the next developer that comes along. They can see what I considered (and what I didn’t), and how to use it.
Tests should make changing your system easier and safer, if they don’t it is typically a sign things are being tested at the wrong level. That’s outside the scope of this lemmy interaction.
Either way gets me to a passing test, but I prefer the latter because it enables me to write another failing test.
But you could just write that failing test up front. TDD encourages you to pretend to know less than you do (you know that testing evenness requires more than one test, and you know the implementation requires more than some if-statements), but no-one has ever made a convincing argument to me that you get anything out of this pretence.
Tests should make changing your system easier and safer, if they don’t it is typically a sign things are being tested at the wrong level
TDD is about writing (a lot of) unit tests, which are at a low-level. Because they are a low-level design-tool, they test the low-level design. Any non-trivial change affects the low-level design of a component, because changes tend to affect code at a certain level and most of those below it to some degree.
In a world where this needs to be solved with TDD there are a few approaches.
If you were pair programming, your pair could always create a new failing test with the current implementation.
Realistically I would want tests for the interesting cases like zero, positive even, negative even, and the odds.
Another approach would be property based testing. One could create sequence generators that randomly generate even or odd numbers and tests the function with those known sequences. I don’t typically use this approach, but it would be a good fit here.
Really in pair programming, your pair would get sick of your crap if you were writing code like this, remind you of all the work you need to get done this week, and you’d end up using modulus and move on quickly.
If you were pair programming, your pair could always create a new failing test with the current implementation.
But I’m not pair programming. And you can’t always create a new failing test because int is a finite type. There are only about 4 billion cases to handle.
Which might take a while to type up manually, but that’s why we have meta-programming: Code that generates code. (In C++ you could even use templates, but you might run into compiler recursion limits.)
More to the point, the risk with TDD is that all development is driven by failing test cases, so a naive approach will end up “overfitting”, producing exactly the code required to make a particular set of tests pass and nothing more. “It can’t pass all test cases”? It doesn’t have to. For TDD, it only needs to pass the tests that have actually been written. You can’t test all combinations of all inputs.
(Also, if you changed this function to use modulus, it would handle more cases than before, which is a change in behavior. You’re not supposed to do that when refactoring; refactoring should preserve semantics.)
TDD has cycles of red, green, refactor. This has neither been refactored nor tested. You can tell by the duplication and the fact that it can’t pass all test cases.
If this looks like TDD to you, I’m sorry that is your experience. Good results with TDD are not guaranteed, you still have to be a strong developer and think through the solution.
As the existing reply stated, there are only ever finitely many tests.
My issue with TDD is that it pretends to drive the final implementation with tests, but what is really driving the implementation is the monkey at the keyboard thinking, “testing for evenness should be done with the modulo operation,” not exhaustive tests.
The monkey at the keyboard thinking is what software development is. When faced with a failing test, you make it pass as simply as possible, and then you summon all your computer science / programming experience to refactor the code into something more elegant and maintainable.
In this case that is using math to check if the input is divisible by two without a remainder. If you don’t know how that works, you’re going to have a bad time, like the picture in this post.
TDD doesn’t promise to drive the final implementation at the unit level, but it does document how the class under test behaves and how to use it.
Why bother making it pass “as simply as possible” instead of summoning all that experience to write something that don’t know is stupid?
What exactly does it drive, then? Apart from writing more test code than application code, with attendant burdens when refactoring or making other changes.
The rhythm of TDD is to first write a failing test. That starts driving the design of your production code. To do that you need to invoke a function/method with arguments that responds with an expected answer.
At that point you’ve started naming things, designing the interface of the unit being tested, and you’ve provided at least one example.
Let’s say you need a method like
isEven(int number): Boolean. I’d start with asserting 2 is even in my first test case.To pass that, I can jump to
number % 2 == 0. Or, I can just returntrue. Either way gets me to a passing test, but I prefer the latter because it enables me to write another failing test.Now I am forced to write a test for odd input, so I assert 3 is not even. This test fails, because it currently just returns
true. Now I must implement a solution that handles even and odd inputs correctly; I know modulus is the answer, so I use it now. Now both tests pass.Then I think about other interesting cases: 0, negative ints, integer max/min, etc. I write tests for each of them, the modulus operator holds up. Great. Any refactoring to do? Nope. It’s a one-liner.
The whole process for this function would only add a few minutes of development, since the implementation is trivial. The test runtime should take milliseconds or less, and now there is documentation for the next developer that comes along. They can see what I considered (and what I didn’t), and how to use it.
Tests should make changing your system easier and safer, if they don’t it is typically a sign things are being tested at the wrong level. That’s outside the scope of this lemmy interaction.
But you could just write that failing test up front. TDD encourages you to pretend to know less than you do (you know that testing evenness requires more than one test, and you know the implementation requires more than some if-statements), but no-one has ever made a convincing argument to me that you get anything out of this pretence.
TDD is about writing (a lot of) unit tests, which are at a low-level. Because they are a low-level design-tool, they test the low-level design. Any non-trivial change affects the low-level design of a component, because changes tend to affect code at a certain level and most of those below it to some degree.
When you say “it can’t pass all test cases”, what do you imagine the tests look like?
https://lemmy.zip/post/43980283/20194352
In a world where this needs to be solved with TDD there are a few approaches.
If you were pair programming, your pair could always create a new failing test with the current implementation.
Realistically I would want tests for the interesting cases like zero, positive even, negative even, and the odds.
Another approach would be property based testing. One could create sequence generators that randomly generate even or odd numbers and tests the function with those known sequences. I don’t typically use this approach, but it would be a good fit here.
Really in pair programming, your pair would get sick of your crap if you were writing code like this, remind you of all the work you need to get done this week, and you’d end up using modulus and move on quickly.
But I’m not pair programming. And you can’t always create a new failing test because
intis a finite type. There are only about 4 billion cases to handle.Which might take a while to type up manually, but that’s why we have meta-programming: Code that generates code. (In C++ you could even use templates, but you might run into compiler recursion limits.)
More to the point, the risk with TDD is that all development is driven by failing test cases, so a naive approach will end up “overfitting”, producing exactly the code required to make a particular set of tests pass and nothing more. “It can’t pass all test cases”? It doesn’t have to. For TDD, it only needs to pass the tests that have actually been written. You can’t test all combinations of all inputs.
(Also, if you changed this function to use modulus, it would handle more cases than before, which is a change in behavior. You’re not supposed to do that when refactoring; refactoring should preserve semantics.)
Read the article about property based testing. It is the middle ground between what you are describing and practicality.
I often pair with myself, which sounds silly but you can write failing tests by yourself, it just isn’t as fun.
But where’s the fun in that?
There are so many better
for obfuscationways of checking for oddness!(a & 1) > 0 a.toString()[a.toString().length()-1] - '1' == 0 iseven(a)?(1==0):(1!=0)