package test16;
   
   import java.io.PrintStream;
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.LinkedList;
   import java.util.List;
   
   import junit.ParamSetTestCase;
  import junit.framework.Test;
  import junit.framework.TestSuite;
  import net.sourceforge.jparam.JParam;
  import net.sourceforge.jparam.JParamException;
  import net.sourceforge.jparam.paramset.Param;
  import net.sourceforge.jparam.paramset.ioParam;
  import net.sourceforge.jparam.typename.TypeNameRegistry;
  
  public class test16 {
  
  	public static Test suite() {
  		TestSuite suite = new TestSuite("Test for test16");
  		//$JUnit-BEGIN$
  		suite.addTestSuite(t1.class);
  		suite.addTestSuite(t2.class);
  		//$JUnit-END$
  		return suite;
  	}
  
  	public static class Pair {
  		public Object o1, o2;
  
  		public Pair(Object o1, Object o2) {
  			this.o1 = o1;
  			this.o2 = o2;
  		}
  	}
  
  	public static class Gooseberry {
  		int n;
  
  		public Gooseberry() {
  		}
  
  		public Gooseberry(int i) {
  			n = i;
  		}
  
  		int num() {
  			return n;
  		}
  	};
  
  	public static class Goose {
  		int n;
  
  		public Goose() {
  		}
  
  		public Goose(int i) {
  			n = i;
  		}
  
  		public Goose(Gooseberry d) {
  			n = d.num() * 2;
  		}
  
  		int num() {
  			return n;
  		}
  
  		public int hashCode() {
  			return 0;
  		}
  
  		public boolean equals(Object obj) {
  			return (obj instanceof Goose) && (((Goose) obj).n == n);
  		}
  	};
  
  	public static class Bottle {
  		String message;
  
  		public Bottle() {
  			this("No message");
  		}
  
  		public Bottle(int i) {
  			this("" + i);
  		}
  
  		public Bottle(String message) {
  			this.message = message;
  		}
  	}
  
  	public static class Serializers {
  		public static void serialize(Pair pair, PrintStream out)
  				throws JParamException {
  			Class o1Type = pair.o1.getClass();
 			Class o2Type = pair.o2.getClass();
 			TypeNameRegistry tnr = TypeNameRegistry.getInstance();
 			String o1TypeName = tnr.getJParamTypeName(o1Type);
 			String o2TypeName = tnr.getJParamTypeName(o2Type);
 
 			out.print("pair");
 			if ((o1TypeName != null) && (o2TypeName != null)) {
 				out.print("<" + o1TypeName + "," + o2TypeName + ">");
 			}
 			out.print("(");
 			JParam.writeObject(pair.o1, out);
 			out.print(",");
 			JParam.writeObject(pair.o2, out);
 			out.print(")");
 		}
 
 		public static List output(Goose goose) {
 			List subObjects = new LinkedList();
 			subObjects.add(new Integer(goose.n));
 			return subObjects;
 		}
 
 		public static List output(Bottle bottle) {
 			List subObjects = new LinkedList();
 			subObjects.add(bottle.message);
 			return subObjects;
 		}
 	}
 
 	public static class test16_base extends ParamSetTestCase {
 		String[] inputStrings;
 
 		protected void setUp() throws Exception {
 			super.setUp();
 			JParam.registerClass("pair", Pair.class);
 			JParam.registerClass("goose", Goose.class);
 			JParam.registerClass("gooseberry", Gooseberry.class);
 			JParam.registerClass("bottle", Bottle.class);
 			JParam.registerHelperClass(Serializers.class);
 			JParam.registerConstant("groucho", new Goose(15));
 
 			DEBUG = true;
 		}
 
 		/*
 		 * map <goose,bottle> bot_map; map <goose,bottle*> bot_ptr_map; map
 		 * <goose,const bottle*> bot_cptr_map;
 		 *  
 		 */
 		public Param[] getInitParams() throws Exception {
 			return new Param[] { new ioParam("p", Pair.class),
 					new ioParam("v", ArrayList.class),
 					new ioParam("vp", ArrayList.class),
 					new ioParam("vcp", ArrayList.class),
 					new ioParam("l", LinkedList.class),
 					new ioParam("lp", LinkedList.class),
 					new ioParam("lcp", LinkedList.class),
 					new ioParam("str_map", HashMap.class),
 					new ioParam("bot_map", HashMap.class),
 					new ioParam("bot_ptr_map", HashMap.class),
 					new ioParam("bot_cptr_map", HashMap.class), };
 		}
 
 		public String[] getInput() {
 			return inputStrings;
 		}
 
 		public Object[] getExpectedParameterValues() {
 			//return new Param[]{a, b, c, d};
 			return null;
 		}
 	}
 
 	public static class t1 extends test16_base {
 		public t1() {
 			inputStrings = new String[] { "p=pair<goose,double>(groucho,3.1) "
 					+ "v=[goose(0), goose(3), goose(4)] "
 					+ "vp=[1, groucho] "
 					+ "vcp=[goose(0), goose(5)] "
 					+ "l=goose(1), goose(2), goose(3) "
 					+ "lp=goose(0), goose(4) ,goose(5) "
 					+ "lcp=[goose(11)] "
 					+ "str_map={ groucho => one, goose(5) => two} "
 					+ "bot_map={ goose(0) => bottle(three) } "
 					+ "bot_ptr_map= { goose(4) => bottle(4), goose(5) => bottle(5) } "
 					+ "bot_cptr_map = {goose(6)=>bottle(6), goose(7)=>bottle(7)}" };
 		}
 	};
 
 	public static class t2 extends test16_base {
 		public t2() {
 			inputStrings = new String[] { "p=pair<goose,double>(groucho,3.1) "
 					+ "v=vector<goose>(3,goose(3)) "
 					+ "vp=vector<goose*>(1,goose(1)) "
 					+ "vcp=vector<const goose*>(0,0) "
 					+ "l=list<goose>(0,0) "
 					+ "lp=list<goose*>(3,NULL) "
 					+ "lcp=list<const goose*>(4,goose(1)) "
 					+ "str_map=map<goose,string>({ groucho => one, goose(5) => two}) "
 					+ "bot_map={} "
 					+ "bot_ptr_map= { goose(4) => bottle(NULL), goose(5) => bottle(NULL) } "
 					+ "bot_cptr_map = {goose(6)=>bottle(6), goose(7)=>bottle(7)}" };
 		}
 	};
 
 }