The Morality of Error Checking

So, I'm working on this set of classes that generate Java code. In the process, I discover that I have a bunch of private methods on a class and I choose to factor them out into a new class that looks like this:

package glaze.tool;

public class Formatter {
   private String text = "";
   private String indentation = "";

   public void newLine() {
      newLine("");
   }

   public void newLine(String lineText) {
      newText("\n" + indentation + lineText);
   }

   public void newText(String newText) {
      text += newText;
   }

   public void indent() {
      indentation += "\t";
   }

   public void outdent() {
      assert indentation.length() > 0;
      indentation = indentation.substring(1);
   }

   public String getText() {
      return text;
   }
}

The thing that irks me is the outdent() method. I know that the "right" thing is to drop the assertion and add a throw for something like an IllegalStateException and catch it up higher. But, the thing is, I know all of the callers of Formatter, and they all have tests. The outdent() method will never be called when we haven't indented.

In the end, I decided to do this:

   public void outdent() {
       if(indentation.length() > 0)
           indentation = indentation.substring(1);
   }

And the behavior is documented with a test:

   public void testOutdentWithNoIndentIsaNoOp() {
       formatter.newLine("one");
       formatter.outdent();
       formatter.newLine("two");
       assertEquals("\none\ntwo", formatter.getText());
   }

I changed the meaning of outdent so that the expected behavior is to do nothing when there is no indentation. Was it a good choice? I think so. It worked well in context. But, I think that it is something that people could debate about for days.

Error detection and recovery is something that we like to pontificate upon the industry, but I don't think there is any one-size fits all solution. In some situations, you are better off failing fast, and in others silent acceptance is okay.



!commentForm