TextUITester.java

import java.io.OutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.IOException;
import java.util.Scanner;

/**
 * This class can be used to test text based user interactions by 1) specifying a String of text
 * input (that will be fed to System.in as if entered by the user), and then 2) capturing the output
 * printed to System.out and System.err in String form so that it can be compared to the expect
 * output.
 * 
 * @date 2024.09
 */
public class TextUITester {

  /**
   * This main method demonstrates the use of a TextUITester object to check the behavior of the
   * following run method.
   * 
   * @param args from the commandline are not used in this example
   */
  public static void main(String[] args) {

    // 1. Create a new TextUITester object for each test, and
    // pass the text that you'd like to simulate a user typing
    // as only argument. It's IMPORTANT that this be created
    // before you create an Scanner objects reading from System.in
    TextUITester tester = new TextUITester("apple\n3.14\nq\n");

    // 2. Create a Scanner, and run then code that you want to test here:
    run(); // (this code reads from System.in and writes to System.out)

    // Note hat you cannot see output printed by your program between the
    // constructor call above and the checkOutput call below. This is
    // is useful for your final tests. For debugging purposes you can
    // pass an extra false argument to the TextUITester's constructor to
    // be able to see what is happening while the test is running: for
    // debugging purposes.

    // 3. Check whether the output printed to System.out is correct
    String output = tester.checkOutput();
    if (output.startsWith("Welcome to the run program.") && output.contains("apple4.14"))
      System.out.println("Test passed.");
    else
      System.out.println("Test FAILED.");
  }

  /**
   * This is the code being tested by the main method above. It 1) prints out a welcome message, 2)
   * reads a String, a double, and a character from System.in, and then 3) prints out the string, 4)
   * if the char is a lowercase q, it prints out a number that is one larger than the entered double
   * value.
   */
  public static void run() {
    // Note: AVOID instantiating more than one Scanner reading from
    // System.in, as this leads to undefined behavior!
    Scanner in = new Scanner(System.in);
    System.out.println("Welcome to the run program.");
    System.out.println("Enter a string, a double, and then q to quit: ");
    String s = in.nextLine();
    double d = in.nextDouble();
    in.nextLine(); // read newline after double
    char c = in.nextLine().charAt(0);
    if (c == 'q')
      System.out.println(s + (d + 1.0));
    in.close();
  }

  // Below is the code that actually implements the redirection of System.in
  // and System.out. You are welcome to ignore this code: focusing instead
  // on how the constructor and checkOutput() method are used in the example
  // above.

  // save initial stream references
  private PrintStream saveSystemOut;
  private PrintStream saveSystemErr;
  private InputStream saveSystemIn;
  // streams to use in place of those standard ones
  private ByteArrayOutputStream redirectedOut;
  private ByteArrayOutputStream redirectedErr;

  private boolean hideOutput;

  /**
   * Creates a new test object with the specified string of simulated user input text. The output
   * printed to System.out will be hidden, if true is passed for the second argument. This can be
   * helpful to change while debugging a failing test.
   * 
   * @param programInput the String of text that you want to simulate being typed in by the user.
   * @param hideOutput   determines whether this test's output is hidden from System.out while the
   *                     test is running.
   */
  public TextUITester(String programInput, boolean hideOutput) {
    // backup standard io before redirecting for tests
    this.saveSystemOut = System.out;
    this.saveSystemErr = System.err;
    this.saveSystemIn = System.in;
    this.hideOutput = hideOutput;

    // create alternative location to write output, and to read input from
    this.redirectedOut = new ByteArrayOutputStream();
    if (hideOutput) {
      System.setOut(new PrintStream(this.redirectedOut));
    } else {
      this.saveSystemOut.println("TextUITester's capture starts:");
      System.setOut(new PrintStream(new SplitStream(this.saveSystemOut, this.redirectedOut)));
    }
    this.redirectedErr = new ByteArrayOutputStream();
    if (hideOutput) {
      System.setErr(new PrintStream(this.redirectedErr));
    } else {
      System.setErr(new PrintStream(new SplitStream(this.saveSystemErr, this.redirectedErr)));
    }
    System.setIn(new ByteArrayInputStream(programInput.getBytes()));
  }


  public TextUITester(String programInput) {
    this(programInput, true);
  }

  /**
   * Call this method after running your test code to check whether the expected text was printed
   * out to System.out and System.err. Calling this method will also un-redirect standard io, so
   * that the console can be used as normal again.
   * 
   * @return captured text that was printed to System.out and System.err durring test.
   */
  public String checkOutput() {
    try {
      String programOutput = redirectedOut.toString() + redirectedErr.toString();
      return programOutput;
    } finally {
      // restore standard io to their pre-test states
      if (!this.hideOutput)
        this.saveSystemOut.println("TextUITester's capture ends.");
      System.out.close();
      System.setOut(saveSystemOut);
      System.err.close();
      System.setErr(saveSystemErr);
      System.setIn(saveSystemIn);
    }
  }

  /**
   * This helper class splits the output stream that System.out is directed to so that it can both
   * be captured and displayed (for debugging purposes) at the same time.
   */
  private static class SplitStream extends OutputStream {
    private OutputStream left;
    private OutputStream right;

    public SplitStream(OutputStream left, OutputStream right) {
      this.left = left;
      this.right = right;
    }

    public void write(byte[] bytes) throws IOException {
      this.left.write(bytes);
      this.right.write(bytes);
    }

    public void write(byte[] bytes, int offset, int length) throws IOException {
      this.left.write(bytes, offset, length);
      this.right.write(bytes, offset, length);
    }

    public void write(int oneByte) throws IOException {
      left.write(oneByte);
      right.write(oneByte);
    }
  }
}