source: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImplTest.java @ 696

Last change on this file since 696 was 696, checked in by pharms, 12 years ago
  • moved some test utilities to dedicated test utilities project
File size: 15.3 KB
Line 
1package de.ugoe.cs.quest.tasktrees.treeimpl;
2
3import static org.junit.Assert.assertEquals;
4import static org.junit.Assert.assertNotNull;
5import static org.junit.Assert.assertNull;
6
7import java.util.HashMap;
8import java.util.Map;
9
10import org.junit.Test;
11
12import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask;
13import de.ugoe.cs.quest.tasktrees.treeifc.IIteration;
14import de.ugoe.cs.quest.tasktrees.treeifc.ISelection;
15import de.ugoe.cs.quest.tasktrees.treeifc.ISequence;
16import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree;
17import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder;
18import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode;
19import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory;
20import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeInfo;
21import de.ugoe.cs.quest.test.DummyGUIElement;
22import de.ugoe.cs.quest.test.DummyInteraction;
23
24/**
25 * TODO comment
26 *
27 * @version $Revision: $ $Date: 02.04.2012$
28 * @author 2012, last modified by $Author: patrick$
29 */
30public class TaskTreeImplTest {
31   
32    /** */
33    private static final int MAX_TREE_DEPTH = 15;
34
35    /** */
36    private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder();
37
38    /** */
39    private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory();
40
41    /**
42     * @throws Exception
43     *
44     */
45    @Test
46    public void testRandomTrees() throws Exception {
47        int noOfTrees = 10;
48        int noOfMaxChildren = 8;
49        int maxDepth = MAX_TREE_DEPTH;
50
51        for (int i = 0; i < noOfTrees; i++) {
52            System.err.println("iteration " + (i + 1) + ":");
53            System.err.println("  creating tree");
54            Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos =
55                new HashMap<ITaskTreeNode, ITaskTreeNodeInfo>();
56            ITaskTreeNode rootNode = createTree(noOfMaxChildren, maxDepth, treeInfos);
57            System.err.println("  creating task tree");
58            ITaskTree taskTree = taskTreeNodeFactory.createTaskTree(rootNode);
59
60            System.err.println("  validating task tree");
61            assertEquals(rootNode, taskTree.getRoot());
62            assertMapsEqual(treeInfos, taskTree.getTaskMap());
63        }
64    }
65
66    /**
67     * TODO: comment
68     *
69     * @param treeInfos
70     * @param taskMap
71     */
72    private void assertMapsEqual(Map<ITaskTreeNode, ITaskTreeNodeInfo> map1,
73                                 Map<ITaskTreeNode, ITaskTreeNodeInfo> map2)
74    {
75        try {
76            if (map1 == null) {
77                assertNull(map2);
78                return;
79            }
80
81            assertEquals(map1.size(), map2.size());
82
83            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : map1.entrySet()) {
84                ITaskTreeNodeInfo value2 = map2.get(entry.getKey());
85                assertNotNull(value2);
86                assertEquals(entry.getValue().getTask(), value2.getTask());
87                assertEquals(entry.getValue().getNoOfOccurencesInTree(),
88                             value2.getNoOfOccurencesInTree());
89            }
90        }
91        catch (AssertionError e) {
92            dumpMap(map1);
93            dumpMap(map2);
94            throw e;
95        }
96    }
97
98    /**
99     * TODO: comment
100     *
101     * @param map2
102     */
103    private void dumpMap(Map<ITaskTreeNode, ITaskTreeNodeInfo> map) {
104        System.err.println();
105
106        if (map == null) {
107            System.err.println("map is null");
108        }
109        else {
110            System.err.println("map:");
111            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : map.entrySet()) {
112                System.err.print("  ");
113                System.err.print(entry.getKey());
114                for (int i = entry.getKey().toString().length(); i < 49; i++) {
115                    System.err.print(" ");
116                }
117                System.err.print(" : ");
118                System.err.println(entry.getValue());
119            }
120        }
121
122        System.err.println();
123    }
124
125    /**
126     * TODO: comment
127     *
128     * @param noOfMaxChildren
129     * @param maxDepth
130     * @param treeInfos
131     * @return
132     */
133    private ITaskTreeNode createTree(int                                   maxNoOfChildren,
134                                     int                                   maxDepth,
135                                     Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
136        throws Exception
137    {
138        /*
139         * for (int i = 0; i < (MAX_TREE_DEPTH + 1 - maxDepth); i++) { System.err.print("  "); }
140         */
141
142        ITaskTreeNode tree;
143
144        // integrating the maximum depth here assures, that either something between 0 and 8 will
145        // be the type, or if the max depth decreases near 0 only event tasks will be created
146        // to finish the tree creation
147        int type = (int) (Math.random() * (Math.min(8, maxDepth)));
148
149        switch (type)
150        {
151            case 0: {
152                // System.err.print("creating new event task ");
153                tree = createNewEventTask(treeInfos);
154                break;
155            }
156            case 1: {
157                // System.err.print("reusing event task ");
158                tree = reuseEventTask(treeInfos);
159                break;
160            }
161            case 2: {
162                // System.err.println("creating new sequence {");
163                tree = createNewSequence(maxNoOfChildren, maxDepth, treeInfos);
164                break;
165            }
166            case 3: {
167                // System.err.println("reusing sequence {");
168                tree = reuseSequence(maxNoOfChildren, maxDepth, treeInfos);
169                break;
170            }
171            case 4: {
172                // System.err.println("creating new selection {");
173                tree = createNewSelection(maxNoOfChildren, maxDepth, treeInfos);
174                break;
175            }
176            case 5: {
177                // System.err.println("reusing selection {");
178                tree = reuseSelection(maxNoOfChildren, maxDepth, treeInfos);
179                break;
180            }
181            case 6: {
182                // System.err.println("creating new iteration {");
183                tree = createNewIteration(maxNoOfChildren, maxDepth, treeInfos);
184                break;
185            }
186            case 7: {
187                // System.err.println("reusing iteration {");
188                tree = reuseIteration(maxNoOfChildren, maxDepth, treeInfos);
189                break;
190            }
191            default: {
192                // System.err.print("creating new event task per default ");
193                tree = createNewEventTask(treeInfos);
194            }
195        }
196
197        /*
198         * if (!(tree instanceof InteractionTask)) { for (int i = 0; i < (MAX_TREE_DEPTH + 1 -
199         * maxDepth); i++) { System.err.print("  "); }
200         *
201         * System.err.print("} "); }
202         *
203         * System.err.println(tree);
204         */
205
206        return tree;
207    }
208
209    /**
210     * TODO: comment
211     *
212     * @param treeInfos
213     * @return
214     */
215    private IEventTask createNewEventTask(Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
216        throws Exception
217    {
218        Thread.sleep(2);
219        long id = System.currentTimeMillis();
220        IEventTask task =
221            taskTreeNodeFactory.createNewEventTask(new DummyInteraction("interaction" + id, 1),
222                                                   new DummyGUIElement("elem" + id));
223
224        treeInfos.put(task, new NodeInfo(task));
225
226        return task;
227    }
228
229    /**
230     * TODO: comment
231     *
232     * @param treeInfos
233     * @return
234     */
235    private IEventTask reuseEventTask(Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
236        throws Exception
237    {
238        int noOfEventTasks = 0;
239
240        for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
241            if (entry.getKey() instanceof IEventTask) {
242                noOfEventTasks++;
243            }
244        }
245
246        if (noOfEventTasks > 0) {
247            noOfEventTasks = (int) (Math.random() * noOfEventTasks);
248
249            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
250                if (entry.getKey() instanceof IEventTask) {
251                    if (--noOfEventTasks <= 0) {
252                        return (IEventTask) entry.getKey();
253                    }
254                }
255            }
256        }
257        else {
258            return createNewEventTask(treeInfos);
259        }
260
261        throw new RuntimeException("this is an implementation error");
262    }
263
264    /**
265     * TODO: comment
266     *
267     * @param treeInfos
268     * @return
269     */
270    private ISequence createNewSequence(int                                   maxNoOfChildren,
271                                        int                                   maxDepth,
272                                        Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
273        throws Exception
274    {
275        ISequence sequence = taskTreeNodeFactory.createNewSequence();
276
277        int noOfChildren = (int) (Math.random() * maxNoOfChildren);
278
279        for (int i = 0; i < noOfChildren; i++) {
280            ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos);
281
282            // through first removing an existing parent it is assured, that a parent is recorded
283            // only once. This is needed, because parent may be reused in a tree as well, but we
284            // always
285            // iterate the whole tree
286            ((NodeInfo) treeInfos.get(child)).removeParent(sequence);
287            ((NodeInfo) treeInfos.get(child)).addParent(sequence);
288            taskTreeBuilder.addChild(sequence, child);
289        }
290
291        treeInfos.put(sequence, new NodeInfo(sequence));
292        return sequence;
293    }
294
295    /**
296     * TODO: comment
297     *
298     * @param treeInfos
299     * @return
300     */
301    private ISequence reuseSequence(int                                   maxNoOfChildren,
302                                    int                                   maxDepth,
303                                    Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
304        throws Exception
305    {
306        int noOfSequences = 0;
307
308        for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
309            if (entry.getKey() instanceof ISequence) {
310                noOfSequences++;
311            }
312        }
313
314        if (noOfSequences > 0) {
315            noOfSequences = (int) (Math.random() * noOfSequences);
316
317            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
318                if (entry.getKey() instanceof ISequence) {
319                    if (--noOfSequences <= 0) {
320                        return (ISequence) entry.getKey();
321                    }
322                }
323            }
324        }
325        else {
326            return createNewSequence(maxNoOfChildren, maxDepth, treeInfos);
327        }
328
329        throw new RuntimeException("this is an implementation error");
330    }
331
332    /**
333     * TODO: comment
334     *
335     * @param treeInfos
336     * @return
337     */
338    private ISelection createNewSelection(int                                   maxNoOfChildren,
339                                          int                                   maxDepth,
340                                          Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
341        throws Exception
342    {
343        ISelection selection = taskTreeNodeFactory.createNewSelection();
344
345        int noOfChildren = (int) (Math.random() * maxNoOfChildren);
346
347        for (int i = 0; i < noOfChildren; i++) {
348            ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos);
349
350            // through first removing an existing parent it is assured, that a parent is recorded
351            // only once. This is needed, because parent may be reused in a tree as well, but we
352            // always
353            // iterate the whole tree
354            ((NodeInfo) treeInfos.get(child)).removeParent(selection);
355            ((NodeInfo) treeInfos.get(child)).addParent(selection);
356            taskTreeBuilder.addChild(selection, child);
357        }
358
359        treeInfos.put(selection, new NodeInfo(selection));
360        return selection;
361    }
362
363    /**
364     * TODO: comment
365     *
366     * @param treeInfos
367     * @return
368     */
369    private ISelection reuseSelection(int                                   maxNoOfChildren,
370                                      int                                   maxDepth,
371                                      Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
372        throws Exception
373    {
374        int noOfSelections = 0;
375
376        for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
377            if (entry.getKey() instanceof ISelection) {
378                noOfSelections++;
379            }
380        }
381
382        if (noOfSelections > 0) {
383            noOfSelections = (int) (Math.random() * noOfSelections);
384
385            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
386                if (entry.getKey() instanceof ISelection) {
387                    if (--noOfSelections <= 0) {
388                        return (ISelection) entry.getKey();
389                    }
390                }
391            }
392        }
393        else {
394            return createNewSelection(maxNoOfChildren, maxDepth, treeInfos);
395        }
396
397        throw new RuntimeException("this is an implementation error");
398    }
399
400    /**
401     * TODO: comment
402     *
403     * @param treeInfos
404     * @return
405     */
406    private IIteration createNewIteration(int                                   maxNoOfChildren,
407                                          int                                   maxDepth,
408                                          Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
409        throws Exception
410    {
411        IIteration iteration = taskTreeNodeFactory.createNewIteration();
412
413        ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos);
414
415        // through first removing an existing parent it is assured, that a parent is recorded
416        // only once. This is needed, because parent may be reused in a tree as well, but we always
417        // iterate the whole tree
418        ((NodeInfo) treeInfos.get(child)).removeParent(iteration);
419        ((NodeInfo) treeInfos.get(child)).addParent(iteration);
420        taskTreeBuilder.setChild(iteration, child);
421
422        treeInfos.put(iteration, new NodeInfo(iteration));
423        return iteration;
424    }
425
426    /**
427     * TODO: comment
428     *
429     * @param treeInfos
430     * @return
431     */
432    private IIteration reuseIteration(int                                   maxNoOfChildren,
433                                      int                                   maxDepth,
434                                      Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
435        throws Exception
436    {
437        int noOfIterations = 0;
438
439        for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
440            if (entry.getKey() instanceof IIteration) {
441                noOfIterations++;
442            }
443        }
444
445        if (noOfIterations > 0) {
446            noOfIterations = (int) (Math.random() * noOfIterations);
447
448            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
449                if (entry.getKey() instanceof IIteration) {
450                    if (--noOfIterations <= 0) {
451                        return (IIteration) entry.getKey();
452                    }
453                }
454            }
455        }
456        else {
457            return createNewIteration(maxNoOfChildren, maxDepth, treeInfos);
458        }
459
460        throw new RuntimeException("this is an implementation error");
461    }
462
463}
Note: See TracBrowser for help on using the repository browser.