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

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