KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jgap > impl > MapGeneTest


1 /*
2  * This file is part of JGAP.
3  *
4  * JGAP offers a dual license model containing the LGPL as well as the MPL.
5  *
6  * For licencing information please see the file license.txt included with JGAP
7  * or have a look at the top of class org.jgap.Chromosome which representatively
8  * includes the JGAP license policy applicable for any file delivered with JGAP.
9  */

10 package org.jgap.impl;
11
12 import java.util.*;
13 import org.jgap.*;
14 import junit.framework.*;
15
16 /**
17  * Tests the MapGene class
18  *
19  * @author Klaus Meffert
20  * @since 2.4
21  */

22 public class MapGeneTest
23     extends JGAPTestCase {
24   /** String containing the CVS revision. Read out via reflection!*/
25   private final static String JavaDoc CVS_REVISION = "$Revision: 1.14 $";
26
27   public static Test suite() {
28     TestSuite suite = new TestSuite(MapGeneTest.class);
29     return suite;
30   }
31
32   public void testConstruct_0()
33       throws Exception JavaDoc {
34     Gene gene = new MapGene(conf);
35     assertNotNull(privateAccessor.getField(gene, "m_geneMap"));
36   }
37
38   public void testConstruct_1()
39       throws Exception JavaDoc {
40     Map map = new HashMap();
41     map.put(new Integer JavaDoc(2), new Integer JavaDoc(3));
42     MapGene gene = new MapGene(conf, map);
43     Map geneMap = (Map) privateAccessor.getField(gene, "m_geneMap");
44     assertNotNull(geneMap);
45     assertEquals(new Integer JavaDoc(3), geneMap.get(new Integer JavaDoc(2)));
46     assertEquals(1, geneMap.size());
47   }
48
49   public void testConstruct_2()
50       throws Exception JavaDoc {
51     try {
52       new MapGene(conf, null);
53       fail();
54     }
55     catch (IllegalArgumentException JavaDoc iex) {
56       ; //this is OK
57
}
58   }
59
60   /**
61    * @throws Exception
62    *
63    * @author Klaus Meffert
64    * @since 3.1
65    */

66   public void testConstruct_3()
67       throws Exception JavaDoc {
68     Genotype.setStaticConfiguration(conf);
69     Gene gene = new MapGene();
70     assertSame(conf, gene.getConfiguration());
71   }
72
73   public void testToString_0()
74       throws Exception JavaDoc {
75     MapGene gene = new MapGene(conf);
76     assertEquals("[null]", gene.toString());
77   }
78
79   public void testToString_1()
80       throws Exception JavaDoc {
81     MapGene gene = new MapGene(conf);
82     gene.addAllele(new Integer JavaDoc(102));
83     assertEquals("[(102,102)]", gene.toString());
84   }
85
86   public void testToString_2()
87       throws Exception JavaDoc {
88     MapGene gene = new MapGene(conf);
89     gene.addAllele(new Integer JavaDoc(3), new Integer JavaDoc(102));
90     gene.addAllele(new Integer JavaDoc(7), new Integer JavaDoc( -55));
91     assertEquals("[(3,102),(7,-55)]", gene.toString());
92   }
93
94   public void testToString_3()
95       throws Exception JavaDoc {
96     MapGene gene = new MapGene(conf);
97     gene.addAllele(new Double JavaDoc(3), new Integer JavaDoc(102));
98     gene.addAllele(new Double JavaDoc(7), new Integer JavaDoc( -55));
99     assertEquals("[(3.0,102),(7.0,-55)]", gene.toString());
100   }
101
102   /**
103    * Using different types as keys. Order of adding alleles not important!
104    * @throws Exception
105    *
106    * @author Klaus Meffert
107    * @since 2.4
108    */

109   public void testToString_4()
110       throws Exception JavaDoc {
111     MapGene gene = new MapGene(conf);
112     gene.addAllele(new Integer JavaDoc(3), new Double JavaDoc(102));
113     gene.addAllele(new Double JavaDoc(7), new Integer JavaDoc( -55));
114     assertEquals("[(7.0,-55),(3,102.0)]", gene.toString());
115   }
116
117   /**
118    * Using different types as keys. Order of adding alleles not important!
119    * @throws Exception
120    *
121    * @author Klaus Meffert
122    * @since 2.4
123    */

124   public void testToString_5()
125       throws Exception JavaDoc {
126     MapGene gene = new MapGene(conf);
127     gene.addAllele(new Double JavaDoc(7), new Integer JavaDoc( -55));
128     gene.addAllele(new Integer JavaDoc(3), new Double JavaDoc(102));
129     assertEquals("[(7.0,-55),(3,102.0)]", gene.toString());
130   }
131
132   public void testGetAllele_0()
133       throws Exception JavaDoc {
134     MapGene gene = new MapGene(conf);
135     gene.addAllele(1);
136     gene.addAllele(7);
137     gene.addAllele( -5);
138     gene.addAllele(3);
139     gene.setAllele(new Integer JavaDoc(1));
140     assertEquals(new Integer JavaDoc(1), gene.getAllele());
141     gene.setAllele(new Integer JavaDoc(3));
142     assertEquals(new Integer JavaDoc(3), gene.getAllele());
143     gene.setAllele(new Integer JavaDoc( -5));
144     assertEquals(new Integer JavaDoc( -5), gene.getAllele());
145     gene.setAllele(new Integer JavaDoc(7));
146     assertEquals(new Integer JavaDoc(7), gene.getAllele());
147     try {
148       gene.setAllele(new Integer JavaDoc(2));
149       fail();
150     }
151     catch (IllegalArgumentException JavaDoc iex) {
152       ; //this is OK
153
}
154   }
155
156   public void testEquals_0()
157       throws Exception JavaDoc {
158     Gene gene1 = new MapGene(conf);
159     Gene gene2 = new MapGene(conf);
160     assertTrue(gene1.equals(gene2));
161     assertTrue(gene2.equals(gene1));
162   }
163
164   public void testEquals_1()
165       throws Exception JavaDoc {
166     Gene gene1 = new MapGene(conf);
167     assertFalse(gene1.equals(null));
168   }
169
170   public void testEquals_2()
171       throws Exception JavaDoc {
172     Map alleles = new HashMap();
173     alleles.put(new Integer JavaDoc(1), new Integer JavaDoc(1));
174     Gene gene1 = new MapGene(conf, alleles);
175     assertFalse(gene1.equals(new BooleanGene(conf)));
176   }
177
178   public void testEquals_3()
179       throws Exception JavaDoc {
180     Gene gene1 = new MapGene(conf);
181     assertFalse(gene1.equals(new Vector()));
182   }
183
184   public void testEquals_4()
185       throws Exception JavaDoc {
186     Map alleles = new HashMap();
187     alleles.put(new Integer JavaDoc(1), new Integer JavaDoc(1));
188     Gene gene1 = new MapGene(conf, alleles);
189     Gene gene2 = new MapGene(conf, alleles);
190     assertTrue(gene1.equals(gene2));
191     assertTrue(gene2.equals(gene1));
192   }
193
194   public void testEquals_4_2()
195       throws Exception JavaDoc {
196     Map alleles1 = new HashMap();
197     alleles1.put(new Integer JavaDoc(1), new Integer JavaDoc(1));
198     Gene gene1 = new MapGene(conf, alleles1);
199     Map alleles2 = new HashMap();
200     alleles1.put(new Integer JavaDoc(2), new Integer JavaDoc(3));
201     Gene gene2 = new MapGene(conf, alleles2);
202     assertFalse(gene1.equals(gene2));
203     assertFalse(gene2.equals(gene1));
204   }
205
206   public void testEquals_5()
207       throws Exception JavaDoc {
208     Gene gene1 = new MapGene(conf);
209     Gene gene2 = new DoubleGene(conf, 1, 99);
210     assertFalse(gene1.equals(gene2));
211     assertFalse(gene2.equals(gene1));
212   }
213
214   /**
215    * Set Allele to null, no exception should occur
216    * @throws Exception
217    */

218   public void testSetAllele_0()
219       throws Exception JavaDoc {
220     MapGene gene1 = new MapGene(conf);
221     gene1.setAllele(null);
222   }
223
224   public void testSetAllele_1()
225       throws Exception JavaDoc {
226     MapGene gene1 = new MapGene(conf);
227     gene1.setAllele("22");
228   }
229
230   public void testSetAllele_2()
231       throws Exception JavaDoc {
232     Gene gene = new MapGene(conf);
233     gene.setAllele(new Integer JavaDoc(101));
234   }
235
236   /**
237    * @throws Exception
238    * @since 2.5
239    */

240   public void testNewGene_0()
241       throws Exception JavaDoc {
242     MapGene gene1 = new MapGene(conf);
243     gene1.setAllele(new Integer JavaDoc(4711));
244     Object JavaDoc value1 = privateAccessor.getField(gene1, "m_value");
245     MapGene gene2 = (MapGene) gene1.newGene();
246     Object JavaDoc value2 = privateAccessor.getField(gene2, "m_value");
247     Map geneMap = (Map) privateAccessor.getField(gene2, "m_geneMap");
248     assertEquals(value1, value2);
249     assertEquals(0, geneMap.size());
250     assertEquals(gene1, gene2);
251   }
252
253   /**
254    * @throws Exception
255    * @since 2.5
256    */

257   public void testNewGene_1()
258       throws Exception JavaDoc {
259     MapGene gene1 = new MapGene(conf);
260     MapGene gene2 = (MapGene) gene1.newGene();
261     assertEquals(gene1, gene2);
262   }
263
264   /**
265    * @throws Exception
266    * @since 2.5
267    */

268   public void testNewGene_2()
269       throws Exception JavaDoc {
270     Map alleles = new Hashtable();
271     for (int i = 0; i < 40; i++) {
272       alleles.put(new Integer JavaDoc(i), new Integer JavaDoc(i));
273     }
274     MapGene gene1 = new MapGene(conf, alleles);
275     MapGene gene2 = (MapGene) gene1.newGene();
276     assertTrue(gene1.equals(gene2));
277   }
278
279   public void testCleanup()
280       throws Exception JavaDoc {
281     //cleanup should do nothing!
282
Gene gene = new MapGene(conf);
283     gene.setAllele("Hello");
284     Gene copy = gene.newGene();
285     gene.cleanup();
286     assertEquals(copy, gene);
287   }
288
289   /**
290    *
291    * @throws Exception
292    * @author Klaus Meffert
293    * @since 2.5
294    */

295   public void testPersistentRepresentation_0()
296       throws Exception JavaDoc {
297     Map alleles = new HashMap();
298     for (int i = -3; i < 45; i = i + 2) {
299       alleles.put(new Integer JavaDoc(i), new Integer JavaDoc(i));
300     }
301     Gene gene1 = new MapGene(conf, alleles);
302     gene1.setAllele(new Integer JavaDoc(17));
303     String JavaDoc pres1 = gene1.getPersistentRepresentation();
304     Gene gene2 = new MapGene(conf);
305     gene2.setValueFromPersistentRepresentation(pres1);
306     String JavaDoc pres2 = gene2.getPersistentRepresentation();
307     // Compare genes itself, not string representation as the latter does not
308
// have a well-defined order of elements.
309
Gene gene3 = new MapGene(conf);
310     gene3.setValueFromPersistentRepresentation(pres2);
311     assertEquals(gene1, gene3);
312     assertEquals(gene2, gene3);
313   }
314
315   /**
316    * Should be possible without exception
317    * @throws Exception
318    *
319    * @author Klaus Meffert
320    * @since 2.5
321    */

322   public void testPersistentRepresentation_1()
323       throws Exception JavaDoc {
324     Gene gene1 = new MapGene(conf);
325     gene1.setAllele(new Integer JavaDoc(45));
326     gene1.setValueFromPersistentRepresentation(null);
327   }
328
329   /**
330    * @throws Exception
331    *
332    * @author Klaus Meffert
333    * @since 2.2
334    */

335   public void testPersistentRepresentation_2()
336       throws Exception JavaDoc {
337     MapGene gene1 = new MapGene(conf);
338     gene1.setAllele(new Integer JavaDoc(45));
339     gene1.setValueFromPersistentRepresentation("6"
340                                                +
341                                                MapGene.
342                                                PERSISTENT_FIELD_DELIMITER
343                                                +
344         "(java.lang.Integer,0,java.lang.Double,1.0d),"
345                                                +
346         "(java.lang.Integer,2,java.lang.Double,3.0d),"
347                                                +
348         "(java.lang.Integer,4,java.lang.Double,5.0d)");
349     assertEquals(6, ( (Integer JavaDoc) gene1.getAllele()).intValue());
350     assertEquals(3, ( (Map) privateAccessor.getField(gene1,
351         "m_geneMap")).size());
352   }
353
354   /**
355    * @throws Exception
356    *
357    * @author Klaus Meffert
358    * @since 3.0
359    */

360   public void testPersistentRepresentation_3()
361       throws Exception JavaDoc {
362     Gene gene1 = new MapGene(conf);
363     gene1.setAllele(new Integer JavaDoc(45));
364     gene1.setValueFromPersistentRepresentation("null"
365                                                + MapGene.
366                                                PERSISTENT_FIELD_DELIMITER
367                                                + "(java.lang.Integer,0,java.lang.Double,1.0d),"
368                                                + "(java.lang.Double, 2,java.lang.Double,3.0d),"
369                                                + "(java.lang.Double,4,java.lang.Double,5.0d)");
370     assertNull(gene1.getAllele());
371     assertEquals(3, ( (Map) privateAccessor.getField(gene1,
372         "m_geneMap")).size());
373   }
374
375   /**
376    * @throws Exception
377    *
378    * @author Klaus Meffert
379    * @since 3.0
380    */

381   public void testPersistentRepresentation_4()
382       throws Exception JavaDoc {
383     Gene gene1 = new MapGene(conf);
384     gene1.setAllele(new Integer JavaDoc(45));
385     try {
386       gene1.setValueFromPersistentRepresentation("null"
387                                                  + MapGene.
388                                                  PERSISTENT_FIELD_DELIMITER
389                                                  + "(0,1.0d),1");
390       fail();
391     }
392     catch (IllegalStateException JavaDoc uex) {
393       ; //this is OK
394
}
395   }
396
397   /**
398    * Possible without exception.
399    *
400    * @throws Exception
401    *
402    * @author Klaus Meffert
403    * @since 3.0
404    */

405   public void testPersistentRepresentation_5()
406       throws Exception JavaDoc {
407     Gene gene1 = new MapGene(conf);
408     gene1.setAllele(new Integer JavaDoc(45));
409     gene1.setValueFromPersistentRepresentation("null"
410                                                +
411                                                MapGene.PERSISTENT_FIELD_DELIMITER
412                                                +
413         "(java.lang.Double,0,java.lang.Double,1.0d),");
414   }
415
416   /**
417    * @throws Exception
418    *
419    * @author Klaus Meffert
420    * @since 2.5
421    */

422   public void testPersistentRepresentation_6()
423       throws Exception JavaDoc {
424     Map alleles = new HashMap();
425     for (int i = -49; i < -3; i++) {
426       alleles.put(new Integer JavaDoc(i), new Integer JavaDoc(i + 1));
427     }
428     Gene gene1 = new MapGene(conf, alleles);
429     gene1.setAllele(new Integer JavaDoc( -23));
430     String JavaDoc pres1 = gene1.getPersistentRepresentation();
431     Gene gene2 = new MapGene(conf);
432     gene2.setValueFromPersistentRepresentation(pres1);
433     String JavaDoc pres2 = gene2.getPersistentRepresentation();
434     // Compare genes itself, not string representation as the latter does not
435
// have a well-defined order of elements.
436
Gene gene3 = new MapGene(conf);
437     gene3.setValueFromPersistentRepresentation(pres2);
438     assertEquals(gene1, gene3);
439     assertEquals(gene2, gene3);
440   }
441
442   /**
443    * @throws Exception
444    *
445    * @author Klaus Meffert
446    * @since 3.0
447    */

448   public void testCompareTo_0()
449       throws Exception JavaDoc {
450     MapGene gene1 = new MapGene(conf);
451     gene1.addAllele(new Integer JavaDoc(58), new Integer JavaDoc(1));
452     MapGene gene2 = new MapGene(conf);
453     gene2.addAllele(new Integer JavaDoc(59), new Integer JavaDoc(2));
454     assertEquals( -1, gene1.compareTo(gene2));
455     assertEquals(1, gene2.compareTo(gene1));
456   }
457
458   /**
459    * @throws Exception
460    *
461    * @author Klaus Meffert
462    * @since 3.0
463    */

464   public void testCompareTo_1()
465       throws Exception JavaDoc {
466     MapGene gene1 = new MapGene(conf);
467     gene1.addAllele(new Integer JavaDoc(58), new Integer JavaDoc(1));
468     MapGene gene2 = new MapGene(conf);
469     gene2.addAllele(new Integer JavaDoc(58), new Integer JavaDoc(1));
470     assertEquals(0, gene1.compareTo(gene2));
471   }
472
473   /**
474    * @throws Exception
475    *
476    * @author Klaus Meffert
477    * @since 3.0
478    */

479   public void testCompareTo_2()
480       throws Exception JavaDoc {
481     MapGene gene1 = new MapGene(conf);
482     gene1.addAllele(new Integer JavaDoc(58), null);
483     MapGene gene2 = new MapGene(conf);
484     gene2.addAllele(new Integer JavaDoc(58), new Integer JavaDoc(1));
485     assertEquals( -1, gene1.compareTo(gene2));
486     assertEquals(1, gene2.compareTo(gene1));
487   }
488
489   /**
490    * @throws Exception
491    *
492    * @author Klaus Meffert
493    * @since 3.0
494    */

495   public void testCompareTo_3()
496       throws Exception JavaDoc {
497     MapGene gene1 = new MapGene(conf);
498     gene1.addAllele(new Integer JavaDoc(58), new Integer JavaDoc(1));
499     gene1.addAllele(new Integer JavaDoc(77), new Integer JavaDoc(1));
500     gene1.addAllele(new Integer JavaDoc(62), new Integer JavaDoc(1));
501     MapGene gene2 = new MapGene(conf);
502     gene2.addAllele(new Integer JavaDoc(58), new Integer JavaDoc(1));
503     gene2.addAllele(new Integer JavaDoc(62), new Integer JavaDoc(1));
504     gene2.addAllele(new Integer JavaDoc(77), new Integer JavaDoc(1));
505     assertEquals(0, gene1.compareTo(gene2));
506   }
507
508   /**
509    * @throws Exception
510    *
511    * @author Klaus Meffert
512    * @since 3.0
513    */

514   public void testRemoveAlleles_0()
515       throws Exception JavaDoc {
516     MapGene gene1 = new MapGene(conf);
517     Object JavaDoc key = new Integer JavaDoc(58);
518     gene1.addAllele(key, null);
519     assertEquals(1, gene1.getAlleles().size());
520     gene1.removeAlleles(key);
521     assertEquals(0, gene1.getAlleles().size());
522   }
523
524   /**
525    * @throws Exception
526    *
527    * @author Klaus Meffert
528    * @since 3.0
529    */

530   public void testRemoveAlleles_1()
531       throws Exception JavaDoc {
532     MapGene gene1 = new MapGene(conf);
533     Object JavaDoc key = new Integer JavaDoc(58);
534     gene1.addAllele(key, new Double JavaDoc(5));
535     assertEquals(1, gene1.getAlleles().size());
536     gene1.removeAlleles(new Integer JavaDoc(33));
537     assertEquals(1, gene1.getAlleles().size());
538   }
539
540   /**@todo add test for applyMutation*/
541 // public void testApplyMutation_1()
542
// throws Exception {
543
// DefaultConfiguration config = new DefaultConfiguration();
544
// config.setRandomGenerator(new RandomGeneratorForTest(15));
545
// Genotype.setConfiguration(config);
546
// IntegerGene gene = new IntegerGene(0, 100);
547
// gene.setAllele(new Integer(50));
548
// gene.applyMutation(0, 0.5d);
549
// assertEquals(Math.round(50 + (100 - 0) * 0.5d), gene.intValue());
550
// }
551

552   /**
553    * @throws Exception
554    */

555   public void testSetToRandomValue_0()
556       throws Exception JavaDoc {
557     Gene gene = new MapGene(conf);
558     gene.setToRandomValue(new RandomGeneratorForTest(3));
559     assertEquals(new Integer JavaDoc(3), gene.getAllele());
560   }
561
562   public void testSetToRandomValue_1()
563       throws Exception JavaDoc {
564     MapGene gene = new MapGene(conf);
565     gene.addAllele(new Integer JavaDoc(2), new Integer JavaDoc(3));
566     gene.setToRandomValue(new StockRandomGenerator());
567     assertEquals(new Integer JavaDoc(2), gene.getAlleles().keySet().iterator().next());
568     assertEquals(new Integer JavaDoc(3), gene.getAlleles().values().iterator().next());
569   }
570 }
571
Popular Tags