KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > junit > output > RootNodeChildren


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */

19
20 package org.netbeans.modules.junit.output;
21
22 import java.awt.EventQueue JavaDoc;
23 import java.util.ArrayList JavaDoc;
24 import java.util.Collection JavaDoc;
25 import java.util.Iterator JavaDoc;
26 import java.util.List JavaDoc;
27 import org.openide.nodes.Children;
28 import org.openide.nodes.Node;
29
30 /**
31  *
32  * @author Marian Petras
33  */

34 final class RootNodeChildren extends Children.Array {
35
36     /** */
37     private volatile boolean filtered;
38     /** */
39     private Collection JavaDoc<Report> reports;
40     /** */
41     private volatile int passedSuites;
42     /** */
43     private volatile int failedSuites;
44     /** */
45     private volatile boolean live = false;
46     /** */
47     private String JavaDoc runningSuiteName;
48     /** */
49     private TestsuiteNode runningSuiteNode;
50     
51     /**
52      * Creates a new instance of ReportRootNode
53      */

54     RootNodeChildren(final boolean filtered) {
55         super();
56         this.filtered = filtered;
57     }
58     
59     /**
60      * Displays a node with a message about a test suite running.
61      *
62      * @param suiteName name of the running test suite,
63      * or {@code ANONYMOUS_SUITE} for anonymous suites
64      * @see ResultDisplayHandler#ANONYMOUS_SUITE
65      */

66     void displaySuiteRunning(final String JavaDoc suiteName) {
67         
68         /*
69          * Called from the EventDispatch thread.
70          */

71         
72         assert EventQueue.isDispatchThread();
73         assert runningSuiteName == null;
74         assert runningSuiteNode == null;
75         
76         runningSuiteName = suiteName;
77         
78         if (live) {
79             runningSuiteNode = new TestsuiteNode(suiteName, filtered);
80             add(new Node[] {runningSuiteNode});
81         }
82         
83         assert runningSuiteName != null;
84         assert (runningSuiteNode != null) == live;
85     }
86     
87     /**
88      */

89     TestsuiteNode displayReport(final Report report) {
90         assert EventQueue.isDispatchThread();
91         assert (runningSuiteNode != null)
92                == (live && (runningSuiteName != null));
93         
94         TestsuiteNode correspondingNode;
95         
96         if (reports == null) {
97             reports = new ArrayList JavaDoc<Report>(10);
98         }
99         reports.add(report);
100
101         final boolean isPassedSuite = updateStatistics(report);
102         
103         if (runningSuiteName != null) {
104             runningSuiteName = null;
105             
106             if (live) {
107                 if (filtered && isPassedSuite) {
108                     remove(new Node[] {runningSuiteNode});
109                     correspondingNode = null;
110                 } else {
111                     runningSuiteNode.displayReport(report);
112                     correspondingNode = runningSuiteNode;
113                 }
114                 runningSuiteNode = null;
115             } else {
116                 correspondingNode = null;
117             }
118         } else {
119             if (live && !(filtered && isPassedSuite)) {
120                 add(new Node[] {
121                     correspondingNode = createNode(report)});
122             } else {
123                 correspondingNode = null;
124             }
125         }
126         
127         assert runningSuiteName == null;
128         assert runningSuiteNode == null;
129         
130         return correspondingNode;
131     }
132     
133     /**
134      */

135     void displayReports(final Collection JavaDoc<Report> newReports) {
136         assert EventQueue.isDispatchThread();
137         
138         if (reports == null) {
139             reports = new ArrayList JavaDoc<Report>(newReports);
140         } else {
141             reports.addAll(newReports);
142         }
143         
144         if (!live) {
145             for (Report report : reports) {
146                 updateStatistics(report);
147             }
148         } else {
149             Node[] nodesToAdd;
150             if (!filtered) {
151                 nodesToAdd = new Node[newReports.size()];
152                 int index = 0;
153                 for (Report report : newReports) {
154                     updateStatistics(report);
155                     nodesToAdd[index++] = createNode(report);
156                 }
157                 add(nodesToAdd);
158             } else {
159                 List JavaDoc<Node> toAdd = new ArrayList JavaDoc<Node>(newReports.size());
160                 for (Report report : newReports) {
161                     boolean isFailed = updateStatistics(report);
162                     if (isFailed) {
163                         toAdd.add(createNode(report));
164                     }
165                 }
166                 if (!toAdd.isEmpty()) {
167                     nodesToAdd = toAdd.toArray(new Node[toAdd.size()]);
168                     add(nodesToAdd);
169                 }
170             }
171         }
172     }
173     
174     /**
175      * Updates statistics of reports (passed/failed test suites).
176      * It is called when a report node is about to be added.
177      *
178      * @param report report for which a node is to be added
179      * @return <code>true</code> if the report reports a passed test suite,
180      * <code>false</code> if the report reports a failed test suite
181      */

182     private boolean updateStatistics(final Report report) {
183         
184         /* Called from the EventDispatch thread */
185         
186         final boolean isPassedSuite = !report.containsFailed();
187         if (isPassedSuite) {
188             passedSuites++;
189         } else {
190             failedSuites++;
191         }
192         return isPassedSuite;
193     }
194     
195     // PENDING - synchronization
196

197     /**
198      */

199     protected void addNotify() {
200         super.addNotify();
201         
202         live = true; //PENDING
203
addAllMatchingNodes();
204     }
205     
206     /**
207      */

208     protected void removeNotify() {
209         super.removeNotify();
210         
211         remove(getNodes()); //PENDING
212
live = false;
213     }
214     
215     /**
216      * Adds all nodes matching the current filter (if the filter is enabled)
217      * or all nodes generally (if the filter is off).
218      */

219     private void addAllMatchingNodes() {
220         final boolean filterOn = filtered;
221         final int matchingNodesCount = filterOn ? failedSuites
222                                                 : failedSuites + passedSuites;
223         final int nodesCount = (runningSuiteNode != null)
224                                ? matchingNodesCount + 1
225                                : matchingNodesCount;
226         if (nodesCount != 0) {
227             final Node[] nodes = new Node[nodesCount];
228             final Iterator JavaDoc<Report> i = reports.iterator();
229             int index = 0;
230             while (index < matchingNodesCount) {
231                 Report report = i.next();
232                 if (!filterOn || report.containsFailed()) {
233                     nodes[index++] = createNode(report);
234                 }
235             }
236             if (runningSuiteNode != null) {
237                 nodes[index++] = runningSuiteNode;
238             }
239             add(nodes);
240         }
241     }
242     
243     /**
244      */

245     private void removeAllNodes() {
246         remove(getNodes());
247     }
248     
249     /**
250      */

251     private TestsuiteNode createNode(final Report report) {
252         return new TestsuiteNode(report, filtered);
253     }
254     
255     /**
256      */

257     void setFiltered(final boolean filtered) {
258         assert EventQueue.isDispatchThread();
259         
260         if (filtered == this.filtered) {
261             return;
262         }
263         this.filtered = filtered;
264         
265         if (!live) {
266             return;
267         }
268         if (passedSuites == 0) {
269             return;
270         }
271
272         if (filtered) {
273             removePassedSuites();
274         } else {
275             addPassedSuites();
276         }
277     }
278     
279     /**
280      */

281     private void removePassedSuites() {
282         assert EventQueue.isDispatchThread();
283         assert live;
284         
285         final Node[] nodesToRemove = new Node[passedSuites];
286         final Node[] nodes = getNodes();
287         int nodesIndex = 0;
288         for (int index = 0;
289                     index < nodesToRemove.length;
290                     nodesIndex++) {
291             TestsuiteNode node = (TestsuiteNode) nodes[nodesIndex];
292             Report report = node.getReport();
293             if (report == null) {
294                 continue;
295             }
296             if (!report.containsFailed()) {
297                 nodesToRemove[index++] = node;
298             } else {
299                 node.setFiltered(filtered);
300             }
301         }
302         while (nodesIndex < nodes.length) {
303             Report report;
304             assert (report = ((TestsuiteNode) nodes[nodesIndex]).getReport())
305                            == null
306                    || report.containsFailed();
307             ((TestsuiteNode) nodes[nodesIndex++]).setFiltered(filtered);
308         }
309         remove(nodesToRemove);
310     }
311     
312     /**
313      */

314     private void addPassedSuites() {
315         assert EventQueue.isDispatchThread();
316         assert live;
317         
318         removeAllNodes();
319         addAllMatchingNodes();
320     }
321     
322 }
323
Popular Tags