What is game test

What is Test Driven Development?

Test-Driven-Development (TDD) for high-quality code.

Test-Driven-Development (TDD) has become increasingly popular in recent years. Many programmers have tried this technique but failed and concluded that TDD is not worth the effort it takes. Some programmers think that this is good practice in theory, but that there is never enough time to really take advantage of TDD. And others think it's basically a waste of time.
Nevertheless, the potential is enormous, we will clear up the misunderstandings.

If you think so too, you may not understand what TDD really is. In this article we will show the basics of Test Driven Development while addressing common misconceptions about TDD technology.

What is test-driven development?

Test-driven development is an evolutionary development approach. With this method, you first define a test and then write code to take that test. The main goal of TDD is specification, not validation. In other words, Test Driven Development is a way to think through the requirements or your design before you write the function code. TDD is therefore both an important agile requirement and an agile design technique. Test-driven development as a programming technique aims to write clean code that works.

How does test-driven development work compared to other development methods?

Let's say you are a web developer. You just completed a small role. Do you think it is sufficient to test this function simply by manually interacting with the browser? It is not enough just to rely on tests that are carried out manually by developers. Unfortunately, this means that some of the code is not good enough.

There are three rules for test-driven development:

  • You are not allowed to write production code unless you want it to pass a flawed unit test.
  • You are not allowed to write more of a unit test than enough to make a mistake. Compilation errors are errors.
  • You are not allowed to write more production code than necessary to pass the one failed unit test.

These rules are simple, but many programmers often violate one or more of them. Can you write a small project that strictly follows these rules? These rules define the mechanics of TDD, but they are definitely not all there is to know. Often the process of using test-driven development is also described as the red / green / refactor cycle.

Red phase

In the red phase you have to write a test about a behavior that you want to implement afterwards. A misunderstanding often arises here: "First I write a class and a method (but not an implementation), then I write a test to test this class method". This is wrong.

In the red phase you are acting like a demanding user who wants to use the code that is being written in the simplest possible way. You need to write a test that uses a piece of code as if it were already implemented. Forget about implementation! If you're thinking about how you're going to write the serial code at this stage, you're doing it wrong!

Rather, in this phase you focus on writing a clean interface for future users. This is the phase in which you determine how your code will be used by customers.

This first rule is the most important, and it is the rule that distinguishes TDD from the widely used classic, regular tests. You first write a test so that you can then write production code. You're not writing a test to test your code.

At this stage, you need to make decisions about how the code will be used. You are basing yourself on what you really need at the moment, not what you think might be needed.

Here's another mistake: don't write a bunch of functions / classes that you think might be needed. Focus on the feature you are implementing and what is really needed. Writing something that the function doesn't require is over-engineering.

Green phase

This is usually the easiest phase, as this is where you write (production) code.

Here's another big mistake: instead of writing enough code to pass the red test, you're writing all the algorithms. As you do this, you are probably thinking about what the best performing implementation is. No way!

In this phase, you have to act like a programmer with a simple task: write a straightforward solution that will pass the test. In this phase you can violate best practices and even duplicate code.

The test-driven development offers two further possibilities: a task list and the refactor phase.

The refactor phase is used to clean up the code. The task list is used to write down the steps that are required to complete the function that you have implemented. It also contains doubts or problems that you discover during the process. This task list changes during programming and is ideally empty at the end of the work.

Refactor phase

In the refactor phase you can change the code to make it better. What "better" means is up to you. But there is one thing necessary: ​​You have to remove the code duplication.
In this phase you play the role of a picky programmer who wants to fix / refactor the code to bring it to a professional level. In the red phase you show the users your skills. But in the refactor phase you show your skills to the programmers who will read your implementation.

Advantages and disadvantages of test-driven development

Many programmers complain about the time required for test-driven development. What actually takes a lot of time is learning / mastering TDD and understanding how to set up and use a test environment. If you are familiar with the test tools and TDD technology, it doesn't actually take a lot more time than classic development methods. On the contrary, it helps to keep a project as simple as possible and even tends to save time.

How can I use test-driven development when developing?

In order to use test-driven development during development, you have to adhere to the scheme presented above. Then you need to create at least as many tests as it takes to write all of the production code. If the tests are passed, refactoring is much easier and safer for the code to be tested.
Test-driven development helps with agile programming, but it is definitely not a substitute for the analysis / design phase.

Conclusion

Test-driven development is a development technique that requires you to write a test first before you can write new function code. TDD is used by software developers for application source code development and database development. Test-Driven-Development should be seen as a complement to Agile Model Driven Development. Both can and should be used together. Test-Driven-Development does not replace traditional testing, but defines a proven way to ensure an effective unit test. A side effect of this is that the resulting tests are working examples for calling the code and thus provide a working specification for the code.