Java/Development Class/Unit Test

Assert equals: int

 
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.JUnit4TestAdapter;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
public class MainClass{
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(MainClass.class);
  }
  
  @Test public void testCopy() {
    assertEquals(12, 12);
    assertEquals(12L, 12L);
    assertEquals(new Long(12), new Long(12));
  }
}

Assert equals: Long

 
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.JUnit4TestAdapter;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
public class MainClass{
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(MainClass.class);
  }
  
  @Test public void testCopy() {
    assertEquals(12, 12);
    assertEquals(12L, 12L);
    assertEquals(new Long(12), new Long(12));
  }
}

Assertion tool for debugging

 
//: com:bruceeckel:tools:debug:Assert.java
// Assertion tool for debugging.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.

public class Assert {
  private static void perr(String msg) {
    System.err.println(msg);
  }
  public static final void is_true(boolean exp) {
    if(!exp) perr("Assertion failed");
  }
  public static final void is_false(boolean exp) {
    if(exp) perr("Assertion failed");
  }
  public static final void
  is_true(boolean exp, String msg) {
    if(!exp) perr("Assertion failed: " + msg);
  }
  public static final void
  is_false(boolean exp, String msg) {
    if(exp) perr("Assertion failed: " + msg);
  }
} ///:~

Before annotation

 
/*
run:
     [java] JVM args ignored when same JVM is used.
     [java] @BeforeClass: set up onece
     [java] .@Before: set up
     [java] Time: 0.015
     [java] OK (1 test)
*/

import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.JUnit4TestAdapter;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
/**
 * Some simple tests.
 *
 */
public class MainClass{
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  @BeforeClass public static void setUpOnce() {
      System.out.println("@BeforeClass: set up onece");
  }
  
  @Before public void setUp() {
      System.out.println("@Before: set up ");
  }
  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(MainClass.class);
  }
  
  @Test public void testCopy() {
      assertTrue(1 == 1);
  }
  
}

Debug frame

 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
public class DebugWinTest extends JFrame implements ActionListener {
  private JButton aButton = new JButton("button");
  private DebugWin dw = new DebugWin();
  public DebugWinTest() {
    setTitle("DebugWinTest");
    setSize(100, 100);
    addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        System.exit(0);
      }
    });
    JPanel pane = new JPanel();
    pane.add(aButton);
    aButton.addActionListener(this);
    getContentPane().add(pane);
  }
  public void actionPerformed(ActionEvent evt) {
    dw.print("Event = " + evt);
  }
  public static void main(String[] args) {
    JFrame f = new DebugWinTest();
    f.show();
  }
  class DebugWin extends JFrame {
    private JTextArea output = new JTextArea();
    public void print(Object ob) {
      output.append("\n" + ob);
    }
    public DebugWin() {
      setTitle("DebugWin");
      output.setEditable(false);
      output.setText("[DebugWin]");
      getContentPane().add(new JScrollPane(output), "Center");
      setSize(300, 200);
      setLocation(200, 200);
      addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
          setVisible(false);
        }
      });
      show();
    }
  }
}

Demonstration of Design by Contract (DBC) combined with white-box unit testing

 
// : c15:JavaQueue.java
// Demonstration of Design by Contract (DBC) combined
// with white-box unit testing.
// {Depends: junit.jar}
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
import junit.framework.*;
import java.util.*;
public class JavaQueue {
  private Object[] data;
  private int in = 0, // Next available storage space
      out = 0; // Next gettable object
  // Has it wrapped around the circular queue?
  private boolean wrapped = false;
  public static class QueueException extends RuntimeException {
    public QueueException(String why) {
      super(why);
    }
  }
public JavaQueue(int size) {
    data = new Object[size];
    assert invariant(); // Must be true after construction
  }  public boolean empty() {
    return !wrapped && in == out;
  }
  public boolean full() {
    return wrapped && in == out;
  }
public void put(Object item) {
    precondition(item != null, "put() null item");
    precondition(!full(), "put() into full Queue");
    assert invariant();
    data[in++] = item;
    if(in >= data.length) {
      in = 0;
      wrapped = true;
    }
    assert invariant();
  }public Object get() {
    precondition(!empty(), "get() from empty Queue");
    assert invariant();
    Object returnVal = data[out];
    data[out] = null;
    out++;
    if(out >= data.length) {
      out = 0;
      wrapped = false;
    }
    assert postcondition(
      returnVal != null, "Null item in Queue");
    assert invariant();
    return returnVal;
  }  // Design-by-contract support methods:
  private static void precondition(boolean cond, String msg) {
    if (!cond)
      throw new QueueException(msg);
  }
  private static boolean postcondition(boolean cond, String msg) {
    if (!cond)
      throw new QueueException(msg);
    return true;
  }
  private boolean invariant() {
    // Guarantee that no null values are in the
    // region of "data" that holds objects:
    for (int i = out; i != in; i = (i + 1) % data.length)
      if (data[i] == null)
        throw new QueueException("null in queue");
    // Guarantee that only null values are outside the
    // region of "data" that holds objects:
    if (full())
      return true;
    for (int i = in; i != out; i = (i + 1) % data.length)
      if (data[i] != null)
        throw new QueueException("non-null outside of queue range: "
            + dump());
    return true;
  }
  private String dump() {
    return "in = " + in + ", out = " + out + ", full() = " + full()
        + ", empty() = " + empty() + ", queue = " + Arrays.asList(data);
  }
  // JUnit testing.
  // As an inner class, this has access to privates:
  public static class WhiteBoxTest extends TestCase {
    private JavaQueue queue = new JavaQueue(10);
    private int i = 0;
    public WhiteBoxTest(String name) {
      super(name);
      while (i < 5)
        // Preload with some data
        queue.put("" + i++);
    }
    // Support methods:
    private void showFullness() {
      assertTrue(queue.full());
      assertFalse(queue.empty());
      // Dump is private, white-box testing allows access:
      System.out.println(queue.dump());
    }
    private void showEmptiness() {
      assertFalse(queue.full());
      assertTrue(queue.empty());
      System.out.println(queue.dump());
    }
    public void testFull() {
      System.out.println("testFull");
      System.out.println(queue.dump());
      System.out.println(queue.get());
      System.out.println(queue.get());
      while (!queue.full())
        queue.put("" + i++);
      String msg = "";
      try {
        queue.put("");
      } catch (QueueException e) {
        msg = e.getMessage();
        System.out.println(msg);
      }
      assertEquals(msg, "put() into full Queue");
      showFullness();
    }
    public void testEmpty() {
      System.out.println("testEmpty");
      while (!queue.empty())
        System.out.println(queue.get());
      String msg = "";
      try {
        queue.get();
      } catch (QueueException e) {
        msg = e.getMessage();
        System.out.println(msg);
      }
      assertEquals(msg, "get() from empty Queue");
      showEmptiness();
    }
    public void testNullPut() {
      System.out.println("testNullPut");
      String msg = "";
      try {
        queue.put(null);
      } catch (QueueException e) {
        msg = e.getMessage();
        System.out.println(msg);
      }
      assertEquals(msg, "put() null item");
    }
    public void testCircularity() {
      System.out.println("testCircularity");
      while (!queue.full())
        queue.put("" + i++);
      showFullness();
      // White-box testing accesses private field:
      assertTrue(queue.wrapped);
      while (!queue.empty())
        System.out.println(queue.get());
      showEmptiness();
      while (!queue.full())
        queue.put("" + i++);
      showFullness();
      while (!queue.empty())
        System.out.println(queue.get());
      showEmptiness();
    }
  }
  public static void main(String[] args) {
    junit.textui.TestRunner.run(JavaQueue.WhiteBoxTest.class);
  }
} ///:~

Error Handler

 
/*
 * Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
 * All rights reserved. Software written by Ian F. Darwin and others.
 * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
 * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
 * pioneering role in inventing and promulgating (and standardizing) the Java 
 * language and environment is gratefully acknowledged.
 * 
 * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
 * inventing predecessor languages C and C++ is also gratefully acknowledged.
 */
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
/**
 * Contrived program showing how to catch Exceptions that occur on the event
 * dispatching thread. Define the System property "sun.awt.exception.handler" to
 * name a class with a method
 * 
 * <pre>
 * 
 *  public void handle(Throwable t)
 *  
 * </pre>.
 * <p>
 * That really is all you have to do to catch GUI Exceptions. But it may change
 * at any time (hence the name sun.awt...).
 * 
 * @author Ian Darwin.
 */
public class ErrorHandlerTest extends JFrame {
  /**
   * A fairly banal GUI, just to show interaction.
   */
  ErrorHandlerTest() {
    super("GUI");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    Container cp = getContentPane();
    JButton bx = new JButton("Throw!");
    bx.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent evt) {
        throw new IllegalArgumentException("foo");
      }
    });
    cp.add(bx);
    setBounds(200, 200, 200, 100);
  }
  public static void main(String[] args) {
    // Tell AWT to invoke my Handler.
    System.setProperty("sun.awt.exception.handler", "ErrorHandler");
    // Now create and show the GUI.
    new ErrorHandlerTest().setVisible(true);
  }
}
/**
 * This class is usable by AWT to handle exceptions.
 * System.setProperty("sun.awt.exception.handler", "ErrorHandler"); This usage
 * is documented in the source code up to 1.4Beta for
 * java.awt.EventDispatchThread. This class exists in all standard
 * implementations (try "javap java.awt.EventQueueDispatchThread"), but is not
 * public so there"s no javadoc. NOTE: there is a strong admonition that the
 * interface WILL be changed in future.
 * <p>
 * In real life this could be part of your application, and can do almost
 * anything. The error handler itself does not need to import awt, awt.event,
 * swing, or anything else.
 * 
 * @author Ian Darwin
 * @version $Id: ErrorHandler.java,v 1.4 2003/08/24 12:31:03 ian Exp $
 */
class ErrorHandler extends java.lang.Object {
  /**
   * Default constructor must exist (I know it"s the default; this is here in
   * case somebody adds any other constructor).
   */
  public ErrorHandler() {
    System.out.println("CONSTRUCTED");
  }
  public void handle(Throwable t) {
    System.err.println("Hey, I caught it!");
    System.err.println(t.toString());
  }
}

JUnit assertEquals: Float With Delta

 
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.JUnit4TestAdapter;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
public class MainClass{
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(MainClass.class);
  }
  
  @Test public void testCopy() {
        assertEquals("Capacity", 11.991, 11.99, 0.1);
  }
}

JUnit assertEquals With Message

 
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.JUnit4TestAdapter;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
public class MainClass{
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(MainClass.class);
  }
  
  @Test public void testCopy() {
        assertEquals("Size", 12, 13);
  }
}

JUnit assertTrue

 
/*
run:
     [java] JVM args ignored when same JVM is used.
     [java] @BeforeClass: set up onece
     [java] .@Before: set up
     [java] Time: 0.015
     [java] OK (1 test)
*/

import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.JUnit4TestAdapter;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
/**
 * Some simple tests.
 *
 */
public class MainClass{
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  @BeforeClass public static void setUpOnce() {
      System.out.println("@BeforeClass: set up onece");
  }
  
  @Before public void setUp() {
      System.out.println("@Before: set up ");
  }
  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(MainClass.class);
  }
  
  @Test public void testCopy() {
      assertTrue(1 == 1);
  }
  
}

JUnit assertTrue: ObjectArray

 
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.JUnit4TestAdapter;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
public class MainClass{
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(MainClass.class);
  }
  @Test public void arraysNotEqual() {
    assertEquals("message", new Object[] {true, true}, new Object[] {true, false});
  }
}

JUnit BeforeClass

 
/*
run:
     [java] JVM args ignored when same JVM is used.
     [java] @BeforeClass: set up onece
     [java] .@Before: set up
     [java] Time: 0.015
     [java] OK (1 test)
*/

import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.JUnit4TestAdapter;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
/**
 * Some simple tests.
 *
 */
public class MainClass{
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  @BeforeClass public static void setUpOnce() {
      System.out.println("@BeforeClass: set up onece");
  }
  
  @Before public void setUp() {
      System.out.println("@Before: set up ");
  }
  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(MainClass.class);
  }
  
  @Test public void testCopy() {
      assertTrue(1 == 1);
  }
  
}

JUnit Extends TestCase

 
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

public class MainClass extends TestCase{
  public static void main (String[] args) {
    junit.textui.TestRunner.run (suite());
  }
  
  public static junit.framework.Test suite() {
    return new TestSuite(MainClass.class);
  }
  public void testAdd() {
    assertTrue(6 == 6);
  }
  public void testDivideByZero() {
    int zero= 0;
    int result= 8/zero;
  }
  public void testEquals() {
    assertEquals(12, 12);
  }
}

JUnit Ignore

 
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.JUnit4TestAdapter;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
public class MainClass{
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(MainClass.class);
  }
  
  @Ignore("not today") @Test public void capacity() {
    assertTrue(1 == 2);
  }
  
  
  @Test public void testCopy() {
        assertEquals("Capacity", 11.991, 11.99, 0.1);
  }
}

JUnit Test Case With Expected Exception

 
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.JUnit4TestAdapter;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
public class MainClass{
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(MainClass.class);
  }
  
  @Test (expected=IndexOutOfBoundsException.class) public void elementAt() {
    int[] intArray = new int[10];
    
    int i = intArray[20]; // Should throw IndexOutOfBoundsException
  }
}

JUnit Test Setup

 
import junit.extensions.TestSetup;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
public class MainClass extends TestCase {
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  private static TSP tsp;
  public MainClass(String method) {
    super(method);
  }
  // This one takes a few hours...
  public void testLongRunner() {
    assertEquals(2300, tsp.shortestPath(50));
  }
  public void testShortTest() {
    assertEquals(140, tsp.shortestPath(5));
  }
  public void testAnotherShortTest() {
    assertEquals(586, tsp.shortestPath(10));
  }
  public static Test suite() {
    TestSuite suite = new TestSuite();
    // Only include short tests
    suite.addTest(new MainClass("testShortTest"));
    suite.addTest(new MainClass("testAnotherShortTest"));
    TestSetup wrapper = new TestSetup(suite) {
      protected void setUp() {
        oneTimeSetUp();
      }
      protected void tearDown() {
        oneTimeTearDown();
      }
    };
    return wrapper;
  }
  public static void oneTimeSetUp() {
    System.out.println("oneTimeSetUp()");    
    // one-time initialization code goes here...
    tsp = new TSP();
    tsp.loadCities("EasternSeaboard");
  }
  public static void oneTimeTearDown() {
    // one-time cleanup code goes here...
    tsp.releaseCities();
  }
}
class TSP {
  public int shortestPath(int numCities) {
    switch (numCities) {
    case 50:
      return 2300;
    case 5:
      return 140;
    case 10:
      return 586;
    }
    return 0;
  }
  public void loadCities(String name) {
  }
  public void releaseCities() {
  }
}

Random data for test

 
/*
 * Copyright 2005 Joe Walker
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.util.Random;
/**
 * @author Joe Walker [joe at getahead dot ltd dot uk]
 */
public class RandomData
{
    /**
     * @param isUS US numbers look different to UK ones
     * @return A phone number
     */
    public static String getPhoneNumber(boolean isUS)
    {
        String phoneNumber;
        if (isUS)
        {
            // US
            phoneNumber = "+1 (" + random.nextInt(9) + random.nextInt(9) + random.nextInt(9) + ") "
                + random.nextInt(9) + random.nextInt(9) + random.nextInt(9) + " - "
                + random.nextInt(9) + random.nextInt(9) + random.nextInt(9) + random.nextInt(9);
        }
        else
        {
            // UK
            phoneNumber = "+44 (0) 1" + random.nextInt(9) + random.nextInt(9) + random.nextInt(9)
                + " " + random.nextInt(9) + random.nextInt(9) + random.nextInt(9) + random.nextInt(9)
                + random.nextInt(9) + random.nextInt(9);
        }
        return phoneNumber;
    }
    public static String getFirstName()
    {
        return FIRSTNAMES[random.nextInt(FIRSTNAMES.length)];
    }
    public static String getSurname()
    {
        return SURNAMES[random.nextInt(SURNAMES.length)];
    }
    public static String getFullName()
    {
        return getFirstName() + " " + getSurname();
    }
    public static String getAddress()
    {
        String housenum = (random.nextInt(99) + 1) + " ";
        String road1 = ROADS1[random.nextInt(ROADS1.length)];
        String road2 = ROADS2[random.nextInt(ROADS2.length)];
        int townNum = random.nextInt(TOWNS.length);
        String town = TOWNS[townNum];
        return housenum + road1 + " " + road2 + ", " + town;
    }
    public static String[] getAddressAndNumber()
    {
        String[] reply = new String[2];
        String housenum = (random.nextInt(99) + 1) + " ";
        String road1 = ROADS1[random.nextInt(ROADS1.length)];
        String road2 = ROADS2[random.nextInt(ROADS2.length)];
        int townNum = random.nextInt(TOWNS.length);
        String town = TOWNS[townNum];
        reply[0] = housenum + road1 + " " + road2 + ", " + town;
        reply[1] = getPhoneNumber(townNum < 5);
        return reply;
    }
    public static float getSalary()
    {
        return Math.round(10 + 90 * random.nextFloat()) * 1000;
    }
    private static final Random random = new Random();
    private static final String[] FIRSTNAMES =
    {
        "Fred", "Jim", "Shiela", "Jack", "Betty", "Jacob", "Martha", "Kelly",
        "Luke", "Matt", "Gemma", "Joe", "Ben", "Jessie", "Leanne", "Becky",
        "William", "Jo"
    };
    private static final String[] SURNAMES =
    {
        "Sutcliffe", "MacDonald", "Duckworth", "Smith", "Wisner", 
        "Nield", "Turton", "Trelfer", "Wilson", "Johnson", "Daniels",
        "Jones", "Wilkinson", "Wilton"
    };
    private static final String[] ROADS1 =
    {
        "Green", "Red", "Yellow", "Brown", "Blue", "Black", "White",
    };
    private static final String[] ROADS2 =
    {
        "Close", "Drive", "Street", "Avenue", "Crescent", "Road", "Place",
    };
    private static final String[] TOWNS =
    {
        "San Mateo", "San Francisco", "San Diego", "New York", "Atlanta",
        "Sandford", "York", "London", "Coventry", "Exeter", "Knowle",
    };
}

Redirect or reassign some standard descriptors

 
/*
 * Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
 * All rights reserved. Software written by Ian F. Darwin and others.
 * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
 * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
 * pioneering role in inventing and promulgating (and standardizing) the Java 
 * language and environment is gratefully acknowledged.
 * 
 * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
 * inventing predecessor languages C and C++ is also gratefully acknowledged.
 */
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
/**
 * "Redirect" or reassign some standard descriptors.
 * 
 * @author Ian F. Darwin, http://www.darwinsys.ru/
 * @version $Id: Redirect.java,v 1.4 2004/03/06 20:57:56 ian Exp $
 */
public class Redirect {
  public static void main(String[] argv) throws IOException {
    //+
    String LOGFILENAME = "error.log";
    System.setErr(new PrintStream(new FileOutputStream(LOGFILENAME)));
    System.out.println("Please look for errors in " + LOGFILENAME);
    // Now assume this is somebody else"s code; you"ll see it writing to
    // stderr...
    int[] a = new int[5];
    a[10] = 0; // here comes an ArrayIndexOutOfBoundsException
    //-
  }
}

Set JUnit Test case fail information

 
import junit.extensions.TestSetup;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
public class MainClass extends TestCase {

  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }  
  
  public MainClass(String name) {
    super(name);
  }
  public void testPassNullsToConstructor() {
    try {
      Person p = new Person(null, null);
      fail("Expected IllegalArgumentException because both args are null");
    } catch (IllegalArgumentException expected) {
    }
  }
  public void testNullsInName() {
    fail("sample failure");
    Person p = new Person(null, "lastName");
    assertEquals("lastName", p.getFullName());
    p = new Person("Tanner", null);
    assertEquals("Tanner ?", p.getFullName());
  }
  public static void oneTimeSetup() {
    System.out.println("oneTimeSetUp");
  }
  public static void oneTimeTearDown() {
    System.out.println("oneTimeTearDown");
  }
  public static Test suite() {
    TestSetup setup = new TestSetup(new TestSuite(MainClass.class)) {
      protected void setUp() throws Exception {
        oneTimeSetup();
      }
      protected void tearDown() throws Exception {
        oneTimeTearDown();
      }
    };
    return setup;
  }
}
class Person {
  private String firstName;
  private String lastName;
  public Person(String firstName, String lastName) {
    if (firstName == null && lastName == null) {
      throw new IllegalArgumentException("Both names cannot be null");
    }
    this.firstName = firstName;
    this.lastName = lastName;
  }
  public String getFullName() {
    String first = (this.firstName != null) ? this.firstName : "?";
    String last = (this.lastName != null) ? this.lastName : "?";
    return first + " " + last;
  }
  public String getFirstName() {
    return this.firstName;
  }
  public String getLastName() {
    return this.lastName;
  }
}

Simple Debugging

 
// : c15:SimpleDebugging.java
// {ThrowsException}
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
public class SimpleDebugging {
  private static void foo1() {
    System.out.println("In foo1");
    foo2();
  }
  private static void foo2() {
    System.out.println("In foo2");
    foo3();
  }
  private static void foo3() {
    System.out.println("In foo3");
    int j = 1;
    j--;
    int i = 5 / j;
  }
  public static void main(String[] args) {
    foo1();
  }
} ///:~

Simple test with JUnit

 
/*
run:
     [java] JVM args ignored when same JVM is used.
     [java] @BeforeClass: set up onece
     [java] .@Before: set up
     [java] Time: 0.015
     [java] OK (1 test)
*/

import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import junit.framework.JUnit4TestAdapter;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
/**
 * Some simple tests.
 *
 */
public class MainClass{
  public static void main (String... args) {
    junit.textui.TestRunner.run (suite());
  }
  
  @BeforeClass public static void setUpOnce() {
      System.out.println("@BeforeClass: set up onece");
  }
  
  @Before public void setUp() {
      System.out.println("@Before: set up ");
  }
  public static junit.framework.Test suite() {
    return new JUnit4TestAdapter(MainClass.class);
  }
  
  @Test public void testCopy() {
      assertTrue(1 == 1);
  }
  
}

Simple use of JUnit to test ArrayList

 
// : c15:JUnitDemo.java
//Simple use of JUnit to test ArrayList
//{Depends: junit.jar}
//From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
//www.BruceEckel.ru. See copyright notice in CopyRight.txt.
import java.util.*;
import junit.framework.*;
//So we can see the list objects being created,
//and keep track of when they are cleaned up:
class CountedList extends ArrayList {
  private static int counter = 0;
  private int id = counter++;
  public CountedList() {
    System.out.println("CountedList #" + id);
  }
  public int getId() {
    return id;
  }
}
public class JUnitDemo extends TestCase {
  private CountedList list = new CountedList();
  // You can use the constructor instead of setUp():
  public JUnitDemo(String name) {
    super(name);
    for (int i = 0; i < 3; i++)
      list.add("" + i);
  }
  // Thus, setUp() is optional, but is run right
  // before the test:
  protected void setUp() {
    System.out.println("Set up for " + list.getId());
  }
  // tearDown() is also optional, and is called after
  // each test. setUp() and tearDown() can be either
  // protected or public:
  public void tearDown() {
    System.out.println("Tearing down " + list.getId());
  }
  // All tests have method names beginning with "test":
  public void testInsert() {
    System.out.println("Running testInsert()");
    assertEquals(list.size(), 3);
    list.add(1, "Insert");
    assertEquals(list.size(), 4);
    assertEquals(list.get(1), "Insert");
  }
  public void testReplace() {
    System.out.println("Running testReplace()");
    assertEquals(list.size(), 3);
    list.set(1, "Replace");
    assertEquals(list.size(), 3);
    assertEquals(list.get(1), "Replace");
  }
  // A "helper" method to reduce code duplication. As long
  // as the name doesn"t start with "test," it will not
  // be automatically executed by JUnit.
  private void compare(ArrayList lst, String[] strs) {
    Object[] array = lst.toArray();
    assertTrue("Arrays not the same length", array.length == strs.length);
    for (int i = 0; i < array.length; i++)
      assertEquals(strs[i], (String) array[i]);
  }
  public void testOrder() {
    System.out.println("Running testOrder()");
    compare(list, new String[] { "0", "1", "2" });
  }
  public void testRemove() {
    System.out.println("Running testRemove()");
    assertEquals(list.size(), 3);
    list.remove(1);
    assertEquals(list.size(), 2);
    compare(list, new String[] { "0", "2" });
  }
  public void testAddAll() {
    System.out.println("Running testAddAll()");
    list.addAll(Arrays.asList(new Object[] { "An", "African", "Swallow" }));
    assertEquals(list.size(), 6);
    compare(list,
        new String[] { "0", "1", "2", "An", "African", "Swallow" });
  }
  public static void main(String[] args) {
    // Invoke JUnit on the class:
    junit.textui.TestRunner.run(JUnitDemo.class);
  }
} ///:~

Simple utility for testing program output

 
// : com:bruceeckel:simpletest:Test.java
//Simple utility for testing program output. Intercepts
//System.out to print both to the console and a buffer.
//From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
//www.BruceEckel.ru. See copyright notice in CopyRight.txt.
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.regex.Pattern;
public class Alias2 {
  private static Test monitor = new Test();
  private int i;
  public Alias2(int ii) { i = ii; }
  public static void f(Alias2 reference) { reference.i++; }
  public static void main(String[] args) {
    Alias2 x = new Alias2(7);
    System.out.println("x: " + x.i);
    System.out.println("Calling f(x)");
    f(x);
    System.out.println("x: " + x.i);
    monitor.expect(new String[] {
      "x: 7",
      "Calling f(x)",
      "x: 8"
    });
  }
} ///:~
class Test {
  // Bit-shifted so they can be added together:
  public static final int EXACT = 1 << 0, // Lines must match exactly
      AT_LEAST = 1 << 1, // Must be at least these lines
      IGNORE_ORDER = 1 << 2, // Ignore line order
      WAIT = 1 << 3; // Delay until all lines are output
  private String className;
  private TestStream testStream;
  public Test() {
    // Discover the name of the class this
    // object was created within:
    className = new Throwable().getStackTrace()[1].getClassName();
    testStream = new TestStream(className);
  }
  public static List fileToList(String fname) {
    ArrayList list = new ArrayList();
    try {
      BufferedReader in = new BufferedReader(new FileReader(fname));
      try {
        String line;
        while ((line = in.readLine()) != null) {
          if (fname.endsWith(".txt"))
            list.add(line);
          else
            list.add(new TestExpression(line));
        }
      } finally {
        in.close();
      }
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
    return list;
  }
  public static List arrayToList(Object[] array) {
    List l = new ArrayList();
    for (int i = 0; i < array.length; i++) {
      if (array[i] instanceof TestExpression) {
        TestExpression re = (TestExpression) array[i];
        for (int j = 0; j < re.getNumber(); j++)
          l.add(re);
      } else {
        l.add(new TestExpression(array[i].toString()));
      }
    }
    return l;
  }
  public void expect(Object[] exp, int flags) {
    if ((flags & WAIT) != 0)
      while (testStream.numOfLines < exp.length) {
        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    List output = fileToList(className + "Output.txt");
    if ((flags & IGNORE_ORDER) == IGNORE_ORDER)
      OutputVerifier.verifyIgnoreOrder(output, exp);
    else if ((flags & AT_LEAST) == AT_LEAST)
      OutputVerifier.verifyAtLeast(output, arrayToList(exp));
    else
      OutputVerifier.verify(output, arrayToList(exp));
    // Clean up the output file - see c06:Detergent.java
    testStream.openOutputFile();
  }
  public void expect(Object[] expected) {
    expect(expected, EXACT);
  }
  public void expect(Object[] expectFirst, String fname, int flags) {
    List expected = fileToList(fname);
    for (int i = 0; i < expectFirst.length; i++)
      expected.add(i, expectFirst[i]);
    expect(expected.toArray(), flags);
  }
  public void expect(Object[] expectFirst, String fname) {
    expect(expectFirst, fname, EXACT);
  }
  public void expect(String fname) {
    expect(new Object[] {}, fname, EXACT);
  }
} ///:~
class TestExpression implements Comparable {
  private Pattern p;
  private String expression;
  private boolean isRegEx;
  // Default to only one instance of this expression:
  private int duplicates = 1;
  public TestExpression(String s) {
    this.expression = s;
    if (expression.startsWith("%% ")) {
      this.isRegEx = true;
      expression = expression.substring(3);
      this.p = Pattern.rupile(expression);
    }
  }
  // For duplicate instances:
  public TestExpression(String s, int duplicates) {
    this(s);
    this.duplicates = duplicates;
  }
  public String toString() {
    if (isRegEx)
      return p.pattern();
    return expression;
  }
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (isRegEx)
      return (compareTo(obj) == 0);
    return expression.equals(obj.toString());
  }
  public int compareTo(Object obj) {
    if ((isRegEx) && (p.matcher(obj.toString()).matches()))
      return 0;
    return expression.rupareTo(obj.toString());
  }
  public int getNumber() {
    return duplicates;
  }
  public String getExpression() {
    return expression;
  }
  public boolean isRegEx() {
    return isRegEx;
  }
} ///:~
class TestStream extends PrintStream {
  protected int numOfLines;
  private PrintStream console = System.out, err = System.err, fout;
  // To store lines sent to System.out or err
  private InputStream stdin;
  private String className;
  public TestStream(String className) {
    super(System.out, true); // Autoflush
    System.setOut(this);
    System.setErr(this);
    stdin = System.in; // Save to restore in dispose()
    // Replace the default version with one that
    // automatically produces input on demand:
    System.setIn(new BufferedInputStream(new InputStream() {
      char[] input = ("test\n").toCharArray();
      int index = 0;
      public int read() {
        return (int) input[index = (index + 1) % input.length];
      }
    }));
    this.className = className;
    openOutputFile();
  }
  // public PrintStream getConsole() { return console; }
  public void dispose() {
    System.setOut(console);
    System.setErr(err);
    System.setIn(stdin);
  }
  // This will write over an old Output.txt file:
  public void openOutputFile() {
    try {
      fout = new PrintStream(new FileOutputStream(new File(className
          + "Output.txt")));
    } catch (FileNotFoundException e) {
      throw new RuntimeException(e);
    }
  }
  // Override all possible print/println methods to send
  // intercepted console output to both the console and
  // the Output.txt file:
  public void print(boolean x) {
    console.print(x);
    fout.print(x);
  }
  public void println(boolean x) {
    numOfLines++;
    console.println(x);
    fout.println(x);
  }
  public void print(char x) {
    console.print(x);
    fout.print(x);
  }
  public void println(char x) {
    numOfLines++;
    console.println(x);
    fout.println(x);
  }
  public void print(int x) {
    console.print(x);
    fout.print(x);
  }
  public void println(int x) {
    numOfLines++;
    console.println(x);
    fout.println(x);
  }
  public void print(long x) {
    console.print(x);
    fout.print(x);
  }
  public void println(long x) {
    numOfLines++;
    console.println(x);
    fout.println(x);
  }
  public void print(float x) {
    console.print(x);
    fout.print(x);
  }
  public void println(float x) {
    numOfLines++;
    console.println(x);
    fout.println(x);
  }
  public void print(double x) {
    console.print(x);
    fout.print(x);
  }
  public void println(double x) {
    numOfLines++;
    console.println(x);
    fout.println(x);
  }
  public void print(char[] x) {
    console.print(x);
    fout.print(x);
  }
  public void println(char[] x) {
    numOfLines++;
    console.println(x);
    fout.println(x);
  }
  public void print(String x) {
    console.print(x);
    fout.print(x);
  }
  public void println(String x) {
    numOfLines++;
    console.println(x);
    fout.println(x);
  }
  public void print(Object x) {
    console.print(x);
    fout.print(x);
  }
  public void println(Object x) {
    numOfLines++;
    console.println(x);
    fout.println(x);
  }
  public void println() {
    if (false)
      console.print("println");
    numOfLines++;
    console.println();
    fout.println();
  }
  public void write(byte[] buffer, int offset, int length) {
    console.write(buffer, offset, length);
    fout.write(buffer, offset, length);
  }
  public void write(int b) {
    console.write(b);
    fout.write(b);
  }
} ///:~
class OutputVerifier {
  private static void verifyLength(int output, int expected, int compare) {
    if ((compare == Test.EXACT && expected != output)
        || (compare == Test.AT_LEAST && output < expected))
      throw new NumOfLinesException(expected, output);
  }
  public static void verify(List output, List expected) {
    verifyLength(output.size(), expected.size(), Test.EXACT);
    if (!expected.equals(output)) {
      //find the line of mismatch
      ListIterator it1 = expected.listIterator();
      ListIterator it2 = output.listIterator();
      while (it1.hasNext() && it2.hasNext()
          && it1.next().equals(it2.next()))
        ;
      throw new LineMismatchException(it1.nextIndex(), it1.previous()
          .toString(), it2.previous().toString());
    }
  }
  public static void verifyIgnoreOrder(List output, Object[] expected) {
    verifyLength(expected.length, output.size(), Test.EXACT);
    if (!(expected instanceof String[]))
      throw new RuntimeException(
          "IGNORE_ORDER only works with String objects");
    String[] out = new String[output.size()];
    Iterator it = output.iterator();
    for (int i = 0; i < out.length; i++)
      out[i] = it.next().toString();
    Arrays.sort(out);
    Arrays.sort(expected);
    int i = 0;
    if (!Arrays.equals(expected, out)) {
      while (expected[i].equals(out[i])) {
        i++;
      }
      
      
      throw new SimpleTestException(((String) out[i]).rupareTo(expected[i]) < 0 ? "output: <" + out[i] + ">"
          : "expected: <" + expected[i] + ">");
    }
  }
  public static void verifyAtLeast(List output, List expected) {
    verifyLength(output.size(), expected.size(), Test.AT_LEAST);
    if (!output.containsAll(expected)) {
      ListIterator it = expected.listIterator();
      while (output.contains(it.next())) {
      }
      throw new SimpleTestException("expected: <"
          + it.previous().toString() + ">");
    }
  }
} ///:~
class SimpleTestException extends RuntimeException {
  public SimpleTestException(String msg) {
    super(msg);
  }
} ///:~
class NumOfLinesException extends SimpleTestException {
  public NumOfLinesException(int exp, int out) {
    super("Number of lines of output and "
        + "expected output did not match.\n" + "expected: <" + exp
        + ">\n" + "output:   <" + out + "> lines)");
  }
} ///:~
class LineMismatchException extends SimpleTestException {
  public LineMismatchException(int lineNum, String expected, String output) {
    super("line " + lineNum + " of output did not match expected output\n"
        + "expected: <" + expected + ">\n" + "output:   <" + output
        + ">");
  }
} ///:~

Testing class Class

 
// : c10:ToyTest.java
// Testing class Class.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
interface HasBatteries {
}
interface Waterproof {
}
interface Shoots {
}
class Toy {
  // Comment out the following default constructor
  // to see NoSuchMethodError from (*1*)
  Toy() {
  }
  Toy(int i) {
  }
}
class FancyToy extends Toy implements HasBatteries, Waterproof, Shoots {
  FancyToy() {
    super(1);
  }
}
public class ToyTest {
  static void printInfo(Class cc) {
    System.out.println("Class name: " + cc.getName() + " is interface? ["
        + cc.isInterface() + "]");
  }
  public static void main(String[] args) {
    Class c = null;
    try {
      c = Class.forName("FancyToy");
    } catch (ClassNotFoundException e) {
      System.out.println("Can"t find FancyToy");
      System.exit(1);
    }
    printInfo(c);
    Class[] faces = c.getInterfaces();
    for (int i = 0; i < faces.length; i++)
      printInfo(faces[i]);
    Class cy = c.getSuperclass();
    Object o = null;
    try {
      // Requires default constructor:
      o = cy.newInstance(); // (*1*)
    } catch (InstantiationException e) {
      System.out.println("Cannot instantiate");
      System.exit(1);
    } catch (IllegalAccessException e) {
      System.out.println("Cannot access");
      System.exit(1);
    }
    printInfo(o.getClass());
  }
} ///:~

Utilities for debugging

 
/*
 * Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
 * All rights reserved. Software written by Ian F. Darwin and others.
 * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
 * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
 * pioneering role in inventing and promulgating (and standardizing) the Java 
 * language and environment is gratefully acknowledged.
 * 
 * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
 * inventing predecessor languages C and C++ is also gratefully acknowledged.
 */
/**
 * Utilities for debugging
 * 
 * @author Ian Darwin, http://www.darwinsys.ru/
 * @version $Id: Debug.java,v 1.8 2004/01/31 01:26:06 ian Exp $
 */
public class Debug {
  /**
   * Static method to see if a given category of debugging is enabled. Enable
   * by setting e.g., -Ddebug.fileio to debug file I/O operations. For
   * example: <br/>if (Debug.isEnabled("fileio")) <br/>
   * System.out.println("Starting to read file " + fileName);
   */
  public static boolean isEnabled(String category) {
    return System.getProperty("debug." + category) != null;
  }
  /**
   * Static method to println a given message if the given category is enabled
   * for debugging, as reported by isEnabled.
   */
  public static void println(String category, String msg) {
    if (isEnabled(category))
      System.out.println(msg);
  }
  /**
   * Static method to println an arbitrary Objecct if the given category is
   * enabled for debugging, as reported by isEnabled.
   */
  public static void println(String category, Object stuff) {
    println(category, stuff.toString());
  }
}