Return to Answer

The tests are already tested. Tests are by design protected from the bugs, because the testing only detects differences between code and our expectations. If there are problems we have an error. The error could be in the code or with the same probability in tests.

1. There are some techniques that prevents you from adding the same bug in both your code and tests:

2. The client should be different person than the implementer.

3. First write the tests and then the code (like in Test Driven Development).

4. You don't need to test the underlying platform. The tests not only exercise the code written by you, but they run the code from the platform too. While you don't necessary want to catch bugs in the testing platform, is very hard to write code and tests that always hides a bug in the platform, in other words is very hard to have a systematic bug in both your tests/code and in the platform, and the probability is lowered with each test that you create. Even if you would try to do this you would have a very hard task.

5. You could have bugs in tests but usually they are caught easily because the tests are tested by the code developed. Between the code and the tests you have a self enforcement feedback. Both make prediction about how a specific call of an interface should behave. If the response is different you don't necessary have a bug in the code. You could have a bug in the test as well.

The tests are already tested. Tests are by design protected from the bugs, because the testing only detects differences between code and our expectations. If there are problems we have an error. The error could be in the code or in tests.

There are some techniques that prevents you from adding the same bug in both your code and tests:

1. The client should be different person than the implementer.

2. First write the tests and then the code (like in Test Driven Development).

3. You don't need to test the underlying platform. The tests not only exercise the code written by you, but they run the code from the platform too. While you don't necessary want to catch bugs in the testing platform, is very hard to write code and tests that always hides a bug in the platform, in other words is very hard to have a systematic bug in both your tests/code and in the platform, and the probability is lowered with each test that you create. Even if you would try to do this you would have a very hard task.

4. You could have bugs in tests but usually they are caught easily because the tests are tested by the code developed. Between the code and the tests you have a self enforcement feedback. Both make prediction about how a specific call of an interface should behave. If the response is different you don't necessary have a bug in the code. You could have a bug in the test as well.

1. For this problem: If you have an interface to the component a tester is the client of the interface and the developer is the implementer. You have multiple solutions: a) The client should be different person than the implementer. b) You could apply a technique Test Driven Development (TDD) in order to think about the client first and write tests, and after that you add functionality.

2. You don't need to test the underlying platform. The tests not only exercise the code written by you, but they run the code from the platform two. While you don't necessary want to catch bugs in the testing platform, is very hard to write code and tests that always hides a bug in the platform, in other words is very hard to have a systematic bug in both your tests/code and in the platform, and the probability is lowered with each test that you create. Even if you would try to do this you would have a very hard task.

3. While you could have bugs in tests they usually are easy to be caught. Because the tests are tested by the code developed. Between the code and the tests you have a self enforcement feedback. Both make prediction about how a specific call of an interface should behave. If the response is different you don't necessary have a bug in the code. You could have a bug in the test as well.

So, as you can see from my answers this is a non problem. Tests are by design protected from the bugs, because the testing only detects differences between code and our expectations. If there are problems we have an error. The error could be in the code or with the same probability in tests.

The tests are already tested. Tests are by design protected from the bugs, because the testing only detects differences between code and our expectations. If there are problems we have an error. The error could be in the code or with the same probability in tests.

1. There are some techniques that prevents you from adding the same bug in both your code and tests: 

2. The client should be different person than the implementer.

3. First write the tests and then the code (like in Test Driven Development).

4. You don't need to test the underlying platform. The tests not only exercise the code written by you, but they run the code from the platform too. While you don't necessary want to catch bugs in the testing platform, is very hard to write code and tests that always hides a bug in the platform, in other words is very hard to have a systematic bug in both your tests/code and in the platform, and the probability is lowered with each test that you create. Even if you would try to do this you would have a very hard task.

5. You could have bugs in tests but usually they are caught easily because the tests are tested by the code developed. Between the code and the tests you have a self enforcement feedback. Both make prediction about how a specific call of an interface should behave. If the response is different you don't necessary have a bug in the code. You could have a bug in the test as well.

1. For this problem: If you have an interface to the component a tester is the client of the interface and the developer is the implementor. You have multiple solutions: a) The client should be different person than the implementor. b) You could apply a technique Test Driven Development (TDD) in order to think about the client first and write tests, and after that you add functionality.

2. You don't need to test the underlaying platform. The tests not only exercise the code written by you, but they run the code from the platform two. While you don't necessary want to catch bugs in the testing platform, is very hard to write code and tests that always hides a bug in the platform, in other words is very hard to have a systematic bug in both your tests/code and in the platform, and the probability is lowered with each test that you create. Even if you would try to do this you would have a very hard task.

3. While you could have bugs in tests they usually are easy to be catched. Because the tests are tested by the code developed. Between the code and the tests you have a self enforcement feedback. Both make prediction about how a specific call of an interface should behave. If the response is different you don't necessary have a bug in the code. You could have a bug in the test as well.

So, as you can see from my answers this is a non problem. Tests are by design protected from the bugs, because the testing only detects differences between code and our expectations. If there are problems we have an error. The error could be in the code or with the same probability in tests.

1. For this problem: If you have an interface to the component a tester is the client of the interface and the developer is the implementer. You have multiple solutions: a) The client should be different person than the implementer. b) You could apply a technique Test Driven Development (TDD) in order to think about the client first and write tests, and after that you add functionality.

2. You don't need to test the underlying platform. The tests not only exercise the code written by you, but they run the code from the platform two. While you don't necessary want to catch bugs in the testing platform, is very hard to write code and tests that always hides a bug in the platform, in other words is very hard to have a systematic bug in both your tests/code and in the platform, and the probability is lowered with each test that you create. Even if you would try to do this you would have a very hard task.

3. While you could have bugs in tests they usually are easy to be caught. Because the tests are tested by the code developed. Between the code and the tests you have a self enforcement feedback. Both make prediction about how a specific call of an interface should behave. If the response is different you don't necessary have a bug in the code. You could have a bug in the test as well.

So, as you can see from my answers this is a non problem. Tests are by design protected from the bugs, because the testing only detects differences between code and our expectations. If there are problems we have an error. The error could be in the code or with the same probability in tests.