From dc652cfb054a11f0d4e7595c878af9e73dcd58e0 Mon Sep 17 00:00:00 2001
From: Gregg Van Hove <pair+gvanhove@pivotal.io>
Date: Tue, 3 Mar 2015 13:14:20 -0800
Subject: [PATCH] Clean up some TreeProcessor stuff.

- Properly segment parents of segmented suites
---
 spec/core/TreeProcessorSpec.js | 80 +++++++++++++++++++++++++++++++---
 src/core/TreeProcessor.js      |  8 ++--
 2 files changed, 78 insertions(+), 10 deletions(-)

diff --git a/spec/core/TreeProcessorSpec.js b/spec/core/TreeProcessorSpec.js
index e2badd5d..28c4dde7 100644
--- a/spec/core/TreeProcessorSpec.js
+++ b/spec/core/TreeProcessorSpec.js
@@ -500,22 +500,24 @@ describe("TreeProcessor", function() {
     expect(specifiedLeaf.execute).toHaveBeenCalled();
   });
 
-  it("runs a node twice if the order specified leaves and re-enters it", function() {
+  it("runs a node multiple times if the order specified leaves and re-enters it", function() {
     var leaf1 = new Leaf(),
         leaf2 = new Leaf(),
         leaf3 = new Leaf(),
-        reentered = new Node({ children: [leaf1, leaf2] }),
-        root = new Node({ children: [reentered, leaf3] }),
+        leaf4 = new Leaf(),
+        leaf5 = new Leaf(),
+        reentered = new Node({ children: [leaf1, leaf2, leaf3] }),
+        root = new Node({ children: [reentered, leaf4, leaf5] }),
         queueRunner = jasmine.createSpy('queueRunner'),
         processor = new j$.TreeProcessor({
           tree: root,
-          runnableIds: [leaf1.id, leaf3.id, leaf2.id],
+          runnableIds: [leaf1.id, leaf4.id, leaf2.id, leaf5.id, leaf3.id],
           queueRunnerFactory: queueRunner
         });
 
     processor.execute();
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
-    expect(queueableFns.length).toBe(3);
+    expect(queueableFns.length).toBe(5);
 
     queueableFns[0].fn();
     expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
@@ -523,13 +525,79 @@ describe("TreeProcessor", function() {
     expect(leaf1.execute).toHaveBeenCalled();
 
     queueableFns[1].fn();
-    expect(leaf3.execute).toHaveBeenCalled();
+    expect(leaf4.execute).toHaveBeenCalled();
 
     queueableFns[2].fn();
     expect(queueRunner.calls.count()).toBe(3);
     expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
     queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
     expect(leaf2.execute).toHaveBeenCalled();
+
+    queueableFns[3].fn();
+    expect(leaf5.execute).toHaveBeenCalled();
+
+    queueableFns[4].fn();
+    expect(queueRunner.calls.count()).toBe(4);
+    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
+    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    expect(leaf3.execute).toHaveBeenCalled();
+  });
+
+  it("runs a parent of a node with segments correctly", function() {
+    var leaf1 = new Leaf(),
+        leaf2 = new Leaf(),
+        leaf3 = new Leaf(),
+        leaf4 = new Leaf(),
+        leaf5 = new Leaf(),
+        parent = new Node({ children: [leaf1, leaf2, leaf3] }),
+        grandparent = new Node({ children: [parent] }),
+        root = new Node({ children: [grandparent, leaf4, leaf5] }),
+        queueRunner = jasmine.createSpy('queueRunner'),
+        processor = new j$.TreeProcessor({
+          tree: root,
+          runnableIds: [leaf1.id, leaf4.id, leaf2.id, leaf5.id, leaf3.id],
+          queueRunnerFactory: queueRunner
+        });
+
+    processor.execute();
+    var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
+    expect(queueableFns.length).toBe(5);
+
+    queueableFns[0].fn();
+    expect(queueRunner.calls.count()).toBe(2);
+    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
+
+    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    expect(queueRunner.calls.count()).toBe(3);
+
+    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    expect(leaf1.execute).toHaveBeenCalled();
+
+    queueableFns[1].fn();
+    expect(leaf4.execute).toHaveBeenCalled();
+
+    queueableFns[2].fn();
+    expect(queueRunner.calls.count()).toBe(4);
+    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
+
+    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    expect(queueRunner.calls.count()).toBe(5);
+
+    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    expect(leaf2.execute).toHaveBeenCalled();
+
+    queueableFns[3].fn();
+    expect(leaf5.execute).toHaveBeenCalled();
+
+    queueableFns[4].fn();
+    expect(queueRunner.calls.count()).toBe(6);
+    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
+
+    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    expect(queueRunner.calls.count()).toBe(7);
+
+    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    expect(leaf3.execute).toHaveBeenCalled();
   });
 
   it("runs nodes in the order they were declared", function() {
diff --git a/src/core/TreeProcessor.js b/src/core/TreeProcessor.js
index c3bf8f7b..275cb6aa 100644
--- a/src/core/TreeProcessor.js
+++ b/src/core/TreeProcessor.js
@@ -117,7 +117,7 @@ getJasmineRequireObj().TreeProcessor = function() {
           minIndex = childSegment.min;
 
         if (isSegmentBoundary(minIndex)) {
-          currentSegment = {index: result.length, owner: node, nodes: [], min: defaultMin, max: defaultMin};
+          currentSegment = {index: result.length, owner: node, nodes: [], min: defaultMin, max: defaultMax};
           result.push(currentSegment);
         }
 
@@ -130,11 +130,11 @@ getJasmineRequireObj().TreeProcessor = function() {
       nodeStats.segments = result;
     }
 
-    function orderChildSegments(array) {
+    function orderChildSegments(children) {
       var result = [];
 
-      for (var i = 0; i < array.length; i++) {
-        var child = array[i],
+      for (var i = 0; i < children.length; i++) {
+        var child = children[i],
             segments = stats[child.id].segments;
 
         for (var j = 0; j < segments.length; j++) {