1 19 20 package org.netbeans.modules.junit.output; 21 22 import java.awt.EventQueue ; 23 import java.util.ArrayList ; 24 import java.util.Collection ; 25 import java.util.Iterator ; 26 import java.util.List ; 27 import org.openide.nodes.Children; 28 import org.openide.nodes.Node; 29 30 34 final class RootNodeChildren extends Children.Array { 35 36 37 private volatile boolean filtered; 38 39 private Collection <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 runningSuiteName; 48 49 private TestsuiteNode runningSuiteNode; 50 51 54 RootNodeChildren(final boolean filtered) { 55 super(); 56 this.filtered = filtered; 57 } 58 59 66 void displaySuiteRunning(final String suiteName) { 67 68 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 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 <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 135 void displayReports(final Collection <Report> newReports) { 136 assert EventQueue.isDispatchThread(); 137 138 if (reports == null) { 139 reports = new ArrayList <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 <Node> toAdd = new ArrayList <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 182 private boolean updateStatistics(final Report report) { 183 184 185 186 final boolean isPassedSuite = !report.containsFailed(); 187 if (isPassedSuite) { 188 passedSuites++; 189 } else { 190 failedSuites++; 191 } 192 return isPassedSuite; 193 } 194 195 197 199 protected void addNotify() { 200 super.addNotify(); 201 202 live = true; addAllMatchingNodes(); 204 } 205 206 208 protected void removeNotify() { 209 super.removeNotify(); 210 211 remove(getNodes()); live = false; 213 } 214 215 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 <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 245 private void removeAllNodes() { 246 remove(getNodes()); 247 } 248 249 251 private TestsuiteNode createNode(final Report report) { 252 return new TestsuiteNode(report, filtered); 253 } 254 255 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 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 314 private void addPassedSuites() { 315 assert EventQueue.isDispatchThread(); 316 assert live; 317 318 removeAllNodes(); 319 addAllMatchingNodes(); 320 } 321 322 } 323 | Popular Tags |