Test Driven Development (TDD)

Correct Answer: Stop and write a failing unit test before modifying the code.

The best answer is 'Stop and write a failing unit test before modifying the code.' According to the First Law of Test-Driven Development (TDD), we must first write a failing test before we write any code. This ensures we are not just coding aimlessly, but are guiding our code design with specific requirements and goals based on the tests. Now let's consider why the other answers are not correct. 'Directly make changes in the production code.' is not advisable without writing a test first, as this defeats the purpose of TDD and can introduce errors. 'Write a passing unit test and then change the code.' would be a breach of TDD principles, as a test should initially fail to verify that it is testing the correct conditions. 'Ask your project manager for guidance and ignore the need for a test.' is clearly incorrect because ignoring the need for tests can lead to unverified and potentially incorrect code.

Correct Answer: He should write a failing unit test before making changes to the existing code.

The Third Law of Test-Driven Development (TDD) states, 'You may not write any production code until you have first written a failing unit test.' So, in accordance with this rule, before making changes to the existing code, John should write a failing unit test. This ensures that the unit test is correctly detecting a flaw before it is fixed. Now, let's look at the other choices. 'He should go ahead and make changes to the existing code.'- This contradict the fundamental rules of TDD. 'He should ignore the Third Law of TDD and experiment freely.' - This would undermine the systematic method of TDD, potentially leading to uncontrolled issues. 'He should think about writing a unit test, but can go ahead and change the code without it.' - This approach may lead to unpredicted issues and it isn't align with the TDD principles.

Correct Answer: No, you should not proceed with new code. Make the current test pass before moving on.

The second law of Test-Driven Development (TDD) states that 'You are not allowed to write any more of a unit test than is sufficient to fail and not compiling is failing'. This means that the failed test should be made to pass before writing new code. The other answers are incorrect because they conflict with this law. Specifically, writing new code regardless of the failed test or writing several tests before starting the coding contradicts the principles of TDD. Also, the assumption that writing the 'Employee' class will automatically satisfy the test conditions is not guaranteed, and hence it is a wrong approach as well.