001: package U2.T2;
002:
003: import java.io.*;
004: import java.util.*;
005: import U2.T2.Msg.*;
006:
007: // import U2.T2.Obj.* ;
008:
009: /**
010: * An implementation of {@link U2.T2.BaseDomain BaseDomain}, providing
011: * values for primitive types, enumeration types, and String. This
012: * domain is finite.
013: *
014: * <p>The exact values in the domain: see source code.
015: *
016: * <p> This class also exports its subdomains, e.g. the subdomain of
017: * integers, String, etc.
018: *
019: * @see U2.T2.BaseDomain
020: */
021: public class BaseDomain0 extends BaseDomain {
022:
023: private HashMap<Class, ArrayList<Serializable>> domain;
024: private Random rnd;
025:
026: /**
027: * Construct a domain of integers values (like 0,1,-1, etc). This
028: * domain is included in the default base domain.
029: */
030: public ArrayList<Serializable> IntegerDomain_1() {
031: ArrayList<Serializable> dom = new ArrayList<Serializable>();
032: dom.add(0);
033: dom.add(1);
034: dom.add(-1);
035: dom.add(2);
036: dom.add(10);
037: dom.add(-2);
038: dom.add(-10);
039: dom.add(9999);
040: dom.add(-9999);
041: dom.add(1900);
042: dom.add(2000);
043: dom.add(4);
044: dom.add(28);
045: dom.add(29);
046: dom.add(Integer.MAX_VALUE);
047: dom.add(Integer.MIN_VALUE);
048: return dom;
049: }
050:
051: /**
052: * Construct a domain of strings (like "","bob", "1234",
053: * etc). This domain is included in the default base domain.
054: */
055: public ArrayList<Serializable> StringDomain_1() {
056: ArrayList<Serializable> dom = new ArrayList<Serializable>();
057: dom.add("");
058: dom.add("bob");
059: dom.add("Ans");
060: dom.add("tigeR");
061: dom.add("biRd");
062: dom.add("friday blue");
063: dom.add("friday blue");
064: dom.add("friday \n blue");
065: dom.add("fri@$& \n &^#( blue");
066: dom.add("1234");
067: dom.add("~!@#$%^&*()_-+<>?,.:;'[]{}`");
068: dom.add("a2 h$ k@");
069: dom.add("\n");
070: dom.add("\t");
071: dom.add("\"hello\"");
072: dom.add("\"");
073: dom.add("\"\"");
074: return dom;
075: }
076:
077: public ArrayList<Serializable> BoolDomain() {
078: ArrayList<Serializable> dom = new ArrayList<Serializable>();
079: dom.add(true);
080: dom.add(false);
081: return dom;
082: }
083:
084: public ArrayList<Serializable> ByteDomain_1() {
085: ArrayList<Serializable> dom = new ArrayList<Serializable>();
086: dom.add((byte) 0);
087: dom.add((byte) 1);
088: dom.add((byte) -1);
089: dom.add((byte) 2);
090: dom.add((byte) 10);
091: dom.add((byte) -2);
092: dom.add((byte) -10);
093: dom.add((byte) 127);
094: dom.add(Byte.MAX_VALUE);
095: dom.add(Byte.MIN_VALUE);
096: return dom;
097: }
098:
099: public ArrayList<Serializable> LongDomain_1() {
100: ArrayList<Serializable> dom = new ArrayList<Serializable>();
101: dom.add(0L);
102: dom.add(1L);
103: dom.add(-1L);
104: dom.add(2L);
105: dom.add(10L);
106: dom.add(-2L);
107: dom.add(-10L);
108: dom.add(9999L);
109: dom.add(-9999L);
110: dom.add(1999999999999999999L);
111: dom.add(-1999999999999999999L);
112: dom.add(Long.MAX_VALUE);
113: dom.add(Long.MIN_VALUE);
114: return dom;
115: }
116:
117: public ArrayList<Serializable> CharDomain_1() {
118: ArrayList<Serializable> dom = new ArrayList<Serializable>();
119: dom.add('a');
120: dom.add('b');
121: dom.add('z');
122: dom.add('0');
123: dom.add('9');
124: dom.add('@');
125: dom.add('\\');
126: dom.add('\'');
127: dom.add('/');
128: dom.add('\"');
129: dom.add('\n');
130: dom.add('\u0000');
131: dom.add('\uABCD');
132: dom.add('\uFFFF');
133: return dom;
134: }
135:
136: public ArrayList<Serializable> FloatDomain_1() {
137: ArrayList<Serializable> dom = new ArrayList<Serializable>();
138: dom.add(0.0f);
139: dom.add(1.0f);
140: dom.add(-1.0f);
141: dom.add(1.0f / 3.0f);
142: dom.add(1.0e20f);
143: dom.add(-1.0e20f);
144: dom.add(10.00000001f);
145: dom.add(-10.00000001f);
146: dom.add(Float.MAX_VALUE);
147: dom.add(Float.MIN_VALUE);
148: return dom;
149: }
150:
151: public ArrayList<Serializable> DoubleDomain_1() {
152: ArrayList<Serializable> dom = new ArrayList<Serializable>();
153: dom.add(0.0);
154: dom.add(1.0);
155: dom.add(-1.0);
156: dom.add(1.0 / 3.0);
157: dom.add(1.0e20);
158: dom.add(-1.0e20);
159: dom.add(10.00000001);
160: dom.add(-10.00000001);
161: dom.add(Double.MAX_VALUE);
162: dom.add(Double.MIN_VALUE);
163: return dom;
164: }
165:
166: /**
167: * Construct a default base domain.
168: */
169: public BaseDomain0() {
170: domain = new HashMap<Class, ArrayList<Serializable>>();
171: rnd = new Random();
172:
173: ArrayList intdomain = IntegerDomain_1();
174: domain.put((new Integer(0)).getClass(), intdomain);
175: domain.put(Integer.TYPE, intdomain);
176:
177: ArrayList booldomain = BoolDomain();
178: domain.put((new Boolean(true)).getClass(), booldomain);
179: domain.put(Boolean.TYPE, booldomain);
180:
181: ArrayList bytedomain = ByteDomain_1();
182: domain.put((new Byte((byte) 0)).getClass(), bytedomain);
183: domain.put(Byte.TYPE, bytedomain);
184:
185: ArrayList longdomain = LongDomain_1();
186: domain.put((new Long(0L)).getClass(), longdomain);
187: domain.put(Long.TYPE, longdomain);
188:
189: ArrayList chardomain = CharDomain_1();
190: domain.put((new Character('0')).getClass(), chardomain);
191: domain.put(Character.TYPE, chardomain);
192:
193: ArrayList floatdomain = FloatDomain_1();
194: domain.put((new Float(0f)).getClass(), floatdomain);
195: domain.put(Float.TYPE, floatdomain);
196:
197: ArrayList doubledomain = DoubleDomain_1();
198: domain.put((new Double(0.0)).getClass(), doubledomain);
199: domain.put(Double.TYPE, doubledomain);
200:
201: domain.put(("").getClass(), StringDomain_1());
202: }
203:
204: /**
205: * @see U2.T2.BaseDomain#rndGET
206: */
207: public Object[] rndGET(Class C) {
208:
209: if (C.isEnum() && !domain.containsKey(C)) {
210:
211: // add values of C to the base domain:
212: Object[] enumvals = C.getEnumConstants();
213: ArrayList dom = new ArrayList();
214: for (int i = 0; i < enumvals.length; i++)
215: dom.add(enumvals[i]);
216: domain.put(C, dom);
217: // then draw one randomly:
218: if (enumvals.length > 0) {
219: Object[] r = new Object[1];
220: r[0] = enumvals[rnd.nextInt(enumvals.length)];
221: return r;
222: }
223: }
224:
225: if (!domain.containsKey(C))
226: return null;
227:
228: ArrayList dom = domain.get(C);
229: if (dom.isEmpty())
230: return null;
231: Object[] r = new Object[1];
232:
233: r[0] = dom.get(rnd.nextInt(dom.size()));
234: return r;
235: }
236:
237: // just used for testing below:
238: private Object rndGet(Class C) {
239: Object[] r = rndGET(C);
240: if (r == null)
241: return null;
242: else
243: return r[0];
244: }
245:
246: /**
247: * Just for testing the class.
248: */
249: public static void main(String[] args) {
250:
251: BaseDomain0 base = new BaseDomain0();
252: System.out.println(base.rndGet(Integer.TYPE));
253: System.out.println(base.rndGet(Integer.TYPE));
254: System.out.println(base.rndGet((new Integer(0)).getClass()));
255: System.out.println(base.rndGet((new Integer(0)).getClass()));
256:
257: try {
258: System.out.println(base.rndGet(Class
259: .forName("java.lang.Integer")));
260: } catch (Exception e) {
261: System.out.println("ouch!");
262: }
263:
264: System.out.println(base.rndGet("".getClass()));
265: System.out.println(base.rndGet("".getClass()));
266:
267: }
268:
269: }
|