See CodeUnitTestFirst (We should merge TestingFirst and CodeUnitTestFirst ''Disagree, since that is a long discussion and this is a short case study. Maybe renaming to CodeUnitTestFirstExamples?'') Write the tests for a class *before* the implementations. For example, suppose I want to write a class to get a not yet existing file. I'd start with a simple test: public class F''''''ileGetterTest{ private F''''''ileGetter fileGetter; private File file; // public void testGetFile(){ fileGetter = new F''''''ileGetter(); file = fileGetter.getFile(); assertTrue(file != null); } } The simplest possible small bit of funcionality... give mre a file, any file will do. Now, write a stub implementation: public class F''''''ileGetter{ public File getFile(){ return null; } } And run the test. It fails. Excellent. Why, you ask? This proves that the test works, or at least that it doesn't give a false negative. Okay, fill in the implementation. public class F''''''ileGetter{ public File getFile(){ '''return new File();''' } } And run the test. Okay, it passes, but it's still not really useful... okay, write another small test. public class F''''''ileGetterTest{ private F''''''ileGetter fileGetter; private File file; // public void testGetFile(){ fileGetter = new F''''''ileGetter(); file = fileGetter.getFile(); assertTrue(file != null); '''assertTrue(!file.isDirectory());''' } } And run the test. It fails... public class F''''''ileGetter{ public File getFile(){ '''return new File("somenicefilename.txt");''' } } And it passes, and is kindof useful, it indeed gets a valid file... but is it unique? Well, let's find out public class F''''''ileGetterTest{ private F''''''ileGetter fileGetter; // public void testGetFile(){ fileGetter = new F''''''ileGetter(); File file = fileGetter.getFile(); assertTrue(file != null); assertTrue(!file.isDirectory()); // '''File anotherFile = fileGetter.getFile();''' '''assertTrue(!file.equals(anotherFile));''' } } And it fails (seeing a pattern here?) Hmm... is this really what we want? What happens if somebody requests a file, but never uses it? Oops, nevermind... DoTheSimplestThingThatCouldPossiblyWork: so what if they never use it. We're only worrying about getting a unique file at this point. Okay, the implementation, now starting to get useful: public class F''''''ileGetter{ '''private int index = 0;''' // public File getFile(){ '''index++;''' '''return new File("somenicefilename" + index + ".txt");''' } } Okay, tests passed. Next, we'll we still haven't checked if the file already exists or not... on with the test: public class F''''''ileGetterTest{ private F''''''ileGetter fileGetter; // public void testGetFile(){ fileGetter = new F''''''ileGetter(); File file = fileGetter.getFile(); assertTrue(file != null); assertTrue(!file.isDirectory()); // File anotherFile = fileGetter.getFile(); assertTrue(!file.equals(anotherFile)); } // '''public void testGetExistingFile(){''' '''fileGetter = new F''''''ileGetter();''' '''File testFile = fileGetter.getFile();''' // '''fileGetter = new F''''''ileGetter();''' '''testFile.createNewFile();''' '''assertTrue(!testFile.equals( fileGetter.getFile() ));''' '''}''' } And... it fails. public class F''''''ileGetter{ private int index = 0; // '''public File getFile(){''' '''File nextFile;''' '''do{''' '''nextFile = getNextFile();''' '''}while(nextFile.exists());''' '''return nextFile;''' '''}''' // public File '''getNextFile()'''{ index++; return new File("somenicefilename" + index + ".txt"); } } And, the tests pass, it pretty much does what it's supposed to do, anything else that should be tested? Well, we're assuming that a every F''''''ileGetter instance will always return the same non existing file, so we should put in a test to let us know if that assumption ever becomes wrong. Any other assumptions discovered should be guarded in the same way. public class F''''''ileGetterTest{ private F''''''ileGetter fileGetter; // public void testGetFile(){ fileGetter = new F''''''ileGetter(); File file = fileGetter.getFile(); assertTrue(file != null); assertTrue(!file.isDirectory()); // File anotherFile = fileGetter.getFile(); assertTrue(!file.equals(anotherFile)); } // public void testGetExistingFile(){ fileGetter = new F''''''ileGetter(); File testFile = fileGetter.getFile(); // fileGetter = new F''''''ileGetter(); testFile.createNewFile(); assertTrue(!testFile.equals( fileGetter.getFile() )); } // '''public void testDeterministicBehaviour(){''' '''fileGetter = new F''''''ileGetter();''' '''File testFile = fileGetter.getFile();''' // '''fileGetter = new F''''''ileGetter();''' '''assertEquals(testFile, fileGetter.getFile());''' '''}''' } Tests pass, okay! Any refactoring? Well, parts of each test should be refactored into a setup method, and the 'somenicefilename' bit could probably be dumped... we really don't need it according to the simple story above. So, we end up with something like this: public class F''''''ileGetterTest{ private F''''''ileGetter fileGetter; private File testFile; // protected void setUp(){ super.setUp(); fileGetter = new F''''''ileGetter(); testFile = fileGetter.getFile(); } // public void testGetFile(){ assertTrue(testFile != null); assertTrue(!testFile.isDirectory()); // File anotherFile = fileGetter.getFile(); assertTrue(!testFile.equals(anotherFile)); } // public void testGetExistingFile(){ fileGetter = new F''''''ileGetter(); testFile.createNewFile(); assertTrue(!testFile.equals( fileGetter.getFile() )); } // public void testDeterministicBehaviour(){ fileGetter = new F''''''ileGetter(); assertEquals(testFile, fileGetter.getFile()); } } public class F''''''ileGetter{ private int index = 0; private File nextFile; // public File getFile(){ do{ setNextFile() }while(nextFile.exists()); return nextFile; } // public void setNextFile(){ index++; testFile = new File(index + ".tmp"); } } And we're left with a class which does exactly what we want it to, and a set of tests which will tell us if anything happens to change that. ----