package junit;
   
   import java.io.ByteArrayOutputStream;
   import java.io.File;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.OutputStream;
   import java.io.PrintStream;
   
  import junit.framework.TestCase;
  import net.sourceforge.jparam.ConstantRegistry;
  import net.sourceforge.jparam.JParam;
  import net.sourceforge.jparam.conversion.ConverterRegistry;
  import net.sourceforge.jparam.conversion.creators.CreatorRegistry;
  import net.sourceforge.jparam.conversion.creators.ObjectCreator;
  import net.sourceforge.jparam.output.SerializerRegistry;
  import net.sourceforge.jparam.paramset.Param;
  import net.sourceforge.jparam.paramset.ParamSet;
  import net.sourceforge.jparam.typename.TypeNameRegistry;
  
  public abstract class ParamSetTestCase extends TestCase {
  	protected boolean DEBUG = false;
  
  	public static String NL = System.getProperty("line.separator");
  
  	public static String N = "\n";
  
  	public static String OUTPUT_END = N + ";" + NL;
  
  	private void resetJParam() {
  		ConstantRegistry.clearSingleton();
  		TypeNameRegistry.clearSingleton();
  		ObjectCreator.clearSingleton();
  		CreatorRegistry.clearSingleton();
  		SerializerRegistry.clearSingleton();
  		ConverterRegistry.clearSingleton();
  		JParam.init();
  	}
  
  	PrintStream oldOut = System.out;
  
  	PrintStream oldErr = System.err;
  
  	ByteArrayOutputStream baos = new ByteArrayOutputStream();
  
  	PrintStream out = new PrintStream(baos);
  
  	PrintStream redirectErr = new PrintStream(new RedirectOutputStream(oldErr,
  			baos), true);
  
  	PrintStream redirectOut = new PrintStream(new RedirectOutputStream(oldOut,
  			baos), true);
  
  	protected ParamSet ps;
  
  	protected void setUp() throws Exception {
  		super.setUp();
  		resetJParam();
  
  		System.setOut(redirectOut);
  		System.setErr(redirectErr);
  		ps = new ParamSet();
  	}
  
  	// override this and return the parameters needed to be initialized into the
  	// ParamSet
  	abstract public Param[] getInitParams() throws Exception;
  
  	abstract public String[] getInput();
  
  	public boolean isOutputNeeded() {
  		return true;
  	}
  
  	// override this in order to do something before input is called
  	public void preInput() {
  	}
  
  	// override this in order to do something before output is called
  	public void preOutput() {
  	}
  
  	// override this in order to do something after output is called
  	public void postOutput() {
  	}
  
  	// if Input is supposed to throw an exception override this
  	public Exception getExpectedInputError() {
  		return null;
  	}
  
  	// if you want the inputed parameters to be verified override this
  	public Object[] getExpectedParameterValues() {
  		return null;
  	}
  
  	// if you want to run the output return the expected string here
  	public String getExpectedOutput() throws Exception {
  		String fullTestName = this.getClass().getName();
 		fullTestName = fullTestName
 				.substring(fullTestName.lastIndexOf('.') + 1);
 
 		String testDir = fullTestName.substring(0, fullTestName.indexOf('$'));
 		String testName = fullTestName.substring(testDir.length() + 1);
 		String testFileName = testDir + File.separator + "output"
 				+ File.separator + testDir + "_" + testName + ".out";
 		InputStream outputFile = getClass().getClassLoader()
 				.getResourceAsStream(testFileName);
 
 		String outputString = null;
 		if (outputFile != null) {
 			try {
 				ByteArrayOutputStream baos = new ByteArrayOutputStream();
 				while (outputFile.available() > 0) {
 					baos.write(outputFile.read());
 				}
 				outputString = baos.toString();
 			} catch (IOException e) {
 				e.printStackTrace();
 			}
 		} else {
 			outputString = "Test output file not found: " + testFileName;
 		}
 		return outputString;
 	}
 
 	public void testParamSet() throws Throwable {
 		try {
 			Exception inputException = null;
 			try {
 				Param[] params = getInitParams();
 				assertNotNull(params);
 
 				for (int i = 0; i < params.length; i++) {
 					ps.addParam(params[i]);
 				}
 
 				String[] inputStrings = getInput();
 				assertNotNull(inputStrings);
 
 				preInput();
 				ps.input(inputStrings);
 			} catch (Exception e) {
 				inputException = e;
 				System.out.println("Got following error - ");
 				System.out.println(e.getMessage());
 				if (DEBUG)
 					e.printStackTrace(System.out);
 			}
 
 			Exception expectedException = getExpectedInputError();
 
 			//			assertFalse((expectedException == null) ^ (inputException ==
 			// null));
 
 			if (expectedException != null) {
 				assertEquals(expectedException.getMessage(), inputException
 						.getMessage());
 			}
 
 			if (isOutputNeeded() && inputException == null) {
 				preOutput();
 				ps.output(System.out);
 				postOutput();
 			}
 
 			String expectedOutput = getExpectedOutput();
 			String actualOutput = baos.toString();
 			actualOutput = dos2Unix(actualOutput);
 			expectedOutput = dos2Unix(expectedOutput);
 			assertEquals(expectedOutput, actualOutput);
 		} catch (Exception e) {
 			oldErr.println(baos.toString());
 			oldErr.println("Unhandled exception performing test: ");
 			e.printStackTrace(oldErr);
 			throw e;
 		} finally {
 			System.setOut(oldOut);
 			System.setErr(oldErr);
 		}
 	}
 
 	private String dos2Unix(String input) {
 		if (input.indexOf('\r') < 0) {
 			return input;
 		}
 
 		StringBuffer res = new StringBuffer();
 		for (int i = 0; i < input.length(); i++) {
 			char c = input.charAt(i);
 			if (c != '\r') {
 				res.append(c);
 			}
 		}
 
 		return res.toString();
 	}
 
 	private class RedirectOutputStream extends OutputStream {
 		OutputStream ps1, ps2;
 
 		public RedirectOutputStream(OutputStream ps1, OutputStream ps2) {
 			this.ps1 = ps1;
 			this.ps2 = ps2;
 		}
 
 		public void write(int b) throws IOException {
 			ps1.write(b);
 			ps2.write(b);
 		}
 
 	}
 }