sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

data/frameworks/sproutcore/frameworks/foundation/tests/mixins/string.js

@@ -0,0 +1,17 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+/*global module test equals context ok same */
+
+module('String.prototype.w()');
+
+test("'one two three'.w() => ['one','two','three']", function() {
+  same('one two three'.w(), ['one','two','three'], "should be equal");
+});
+
+test("'one    two    three'.w() with extra spaces between words => ['one','two','three']", function() {
+  same('one    two    three'.w(), ['one','two','three'], "should be equal");
+});
+

data/frameworks/sproutcore/frameworks/foundation/tests/private/tree_item_observer/flat_case.js

@@ -0,0 +1,325 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+// The TreeItemObserver is tested based on the common use cases.
+
+var root, content, flattened, delegate, obs, length, extra;
+
+// default delegate class.  Does the bare minimum for tree item to function
+var Delegate = SC.Object.extend(SC.TreeItemContent, {
+  
+  treeItemChildrenKey: "children",
+  treeItemIsExpandedKey: "isExpanded",
+  
+  // This method is used to record range change info
+  
+  rangeIndexes: null,
+  rangeCallCount: 0,
+  
+  rangeDidChange: function(array, objects, key, indexes) {
+    this.rangeCallCount++;
+    this.rangeIndexes = indexes.frozenCopy();
+  }
+
+});
+
+
+var TestObject = SC.Object.extend({
+  toString: function() { return "TestObject(%@)".fmt(this.get('title')); }
+});
+
+/**
+  Verifies that the passed observer object has the proper content.  This will
+  iterate over the passed expected array, calling objectAt() on the observer
+  to verify that it matches.  If you passed the expected index set, it will
+  also verify that the range observer on the observer was fire with the 
+  matching set of indexes.
+  
+  Finally, pass an optional description.
+*/
+function verifyObjectAt(obs, expected, eindexes, desc) {
+  var idx, len = expected.get('length'), actual;
+
+  // eindexes is optional
+  if (desc === undefined) {
+    desc = eindexes;
+    eindexes = undefined;
+  }
+  
+  equals(obs.get('length'), len, "%@ - length should match".fmt(desc));
+  for(idx=0;idx<len;idx++) {
+    actual = obs.objectAt(idx);
+    equals(actual, expected[idx], "%@ - observer.objectAt(%@) should match expected".fmt(desc, idx));
+  }
+  
+  if (eindexes !== undefined) {
+    if (eindexes) {
+      ok(delegate.rangeCallCount>0, 'range observer should be called (actual callCount=%@)'.fmt(delegate.rangeCallCount));
+    } else {
+      ok(delegate.rangeCallCount===0, 'range observer should NOT be called (actual callCount=%@)'.fmt(delegate.rangeCallCount));
+    }
+    
+    same(delegate.rangeIndexes, eindexes, 'range observer should be called with expected indexes');
+  }
+  
+}
+
+
+module("SC.TreeItemObserver - Flat Array Use Case", {
+  setup: function() {
+    content = "1 2 3 4 5".w().map(function(x) { 
+      return TestObject.create({ title: x });
+    });
+    
+    root = TestObject.create({
+      title: "ROOT",
+      children: content,
+      isExpanded: YES
+    });
+    
+    flattened = content.slice();
+    
+    delegate = Delegate.create();
+
+    extra = TestObject.create({ title: "EXTRA" });
+
+    obs = SC.TreeItemObserver.create({ delegate: delegate, item: root });
+    
+    obs.addRangeObserver(null, delegate, delegate.rangeDidChange);
+  },
+  
+  teardown: function() {
+    if (obs) obs.destroy(); // cleanup
+    content = delegate = obs = null ;
+  }
+});
+
+
+// ..........................................................
+// LENGTH
+// 
+
+test("length on create", function() {
+  equals(obs.get('length'), 5, 'should have length of array on create');
+});
+
+test("length after replace", function() {
+  equals(obs.get('length'), 5, 'precond - should have length of array on create');
+
+  SC.run(function() { content.replace(2,1, [extra]); }); // replace
+  equals(obs.get('length'), 5, 'length should not change');
+});
+
+test("length after insert", function() {
+  equals(obs.get('length'), 5, 'precond - should have length of array on create');
+
+  SC.run(function() { content.insertAt(2, extra); });
+  equals(obs.get('length'), 6, 'length should change');  
+});
+
+test("length after remove", function() {
+  equals(obs.get('length'), 5, 'precond - should have length of array on create');
+
+  SC.run(function() { content.removeAt(2); });
+  equals(obs.get('length'), 4, 'length should change');  
+});
+
+// ..........................................................
+// OBJECT AT
+// 
+
+test("objectAt on create", function() {
+  verifyObjectAt(obs, flattened, "on create");
+});
+
+test("objectAt after replace", function() {
+
+  verifyObjectAt(obs, flattened, "PRECOND"); // verify initial state
+  
+  SC.run(function() { content.replace(2,1, [extra]); }); // replace
+  flattened[2] = extra;
+  
+  var change = SC.IndexSet.create(2);
+  verifyObjectAt(obs, flattened, change, "on create");
+});
+
+test("objectAt after insert", function() {
+  verifyObjectAt(obs, flattened, "PRECOND"); // verify initial state
+
+  SC.run(function() { content.insertAt(2,extra); }); // replace
+  flattened.insertAt(2, extra);
+  
+  var change = SC.IndexSet.create(2, flattened.length-2);
+  verifyObjectAt(obs, flattened, change, "after insert");
+});
+
+test("objectAt after remove", function() {
+  verifyObjectAt(obs, flattened, "PRECOND"); // verify initial state
+
+  SC.run(function() { content.removeAt(2); }); // replace
+  flattened.removeAt(2);
+
+  
+  var change = SC.IndexSet.create(2, flattened.length-1);
+  verifyObjectAt(obs, flattened, change, "after remove");
+});
+
+// ..........................................................
+// MODIFYING OBSERVER -> MODEL
+// 
+
+test("adding an object to end", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.pushObject(extra); });
+  flattened.pushObject(extra);
+  expected.pushObject(extra);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(flattened.length-1,1);
+  verifyObjectAt(obs, flattened, change, 'after pushing object');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("removing object at end", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.popObject(); });
+  flattened.popObject();
+  expected.popObject();
+  
+  // verify round trip
+  var change = SC.IndexSet.create(flattened.length,1);
+  verifyObjectAt(obs, flattened, change, 'after removing object');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("adding an object to start", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.insertAt(0, extra); });
+  flattened.insertAt(0, extra);
+  expected.insertAt(0, extra);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(0, flattened.length);
+  verifyObjectAt(obs, flattened, change, 'after pushing object');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("remove an object to start", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.removeAt(0); });
+  flattened.removeAt(0);
+  expected.removeAt(0);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(0, flattened.length+1);
+  verifyObjectAt(obs, flattened, change, 'after removing object');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("adding object in middle", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.insertAt(2, extra); });
+  flattened.insertAt(2, extra);
+  expected.insertAt(2, extra);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(2, flattened.length-2);
+  verifyObjectAt(obs, flattened, change, 'after adding object');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("removing object in middle", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.removeAt(2); });
+  flattened.removeAt(2);
+  expected.removeAt(2);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(2, flattened.length-1);
+  verifyObjectAt(obs, flattened, change, 'after removing object');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("replace object in middle", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.replace(2, 1, [extra]); });
+  flattened.replace(2, 1, [extra]);
+  expected.replace(2, 1, [extra]);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(2, 1);
+  verifyObjectAt(obs, flattened, change, 'after replacing object');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+// ..........................................................
+// SC.COLLECTION CONTENT SUPPORT
+// 
+
+test("contentGroupIndexes - not grouped", function() {
+  equals(delegate.get('treeItemIsGrouped'), NO, 'precond - delegate.treeItemIsGrouped == NO');
+  equals(obs.contentGroupIndexes(null, obs), null, 'contentGroupIndexes should be null');
+  
+  var idx, len = obs.get('length');
+  for(idx=0;idx<len;idx++) {
+    equals(obs.contentIndexIsGroup(null, obs, idx), NO, 'obs.contentIndexIsGroup(null, obs, %@) should be NO'.fmt(idx));
+  }
+});
+
+test("contentGroupIndexes - grouped", function() {
+  delegate.set('treeItemIsGrouped', YES);
+  equals(delegate.get('treeItemIsGrouped'), YES, 'precond - delegate.treeItemIsGrouped == YES');
+  same(obs.contentGroupIndexes(null, obs), SC.IndexSet.create(0, obs.get('length')), 'contentGroupIndexes should cover entire set');
+  
+  var idx, len = obs.get('length');
+  for(idx=0;idx<len;idx++) {
+    equals(obs.contentIndexIsGroup(null, obs, idx), YES, 'obs.contentIndexIsGroup(null, obs, %@) should be YES'.fmt(idx));
+  }
+});
+
+test("contentIndexOutlineLevel", function() {
+  var idx, len = obs.get('length');
+  for(idx=0;idx<len;idx++) {
+    equals(obs.contentIndexOutlineLevel(null, obs, idx), 0, 'obs.contentIndexOutlineLevel(null, obs, %@)'.fmt(idx));
+  }
+});
+
+test("contentIndexDisclosureState", function() {
+  var idx, len = obs.get('length');
+  for(idx=0;idx<len;idx++) {
+    equals(obs.contentIndexDisclosureState(null, obs, idx), SC.LEAF_NODE, 'obs.contentIndexDisclosureState(null, obs, %@) should eql SC.LEAF_NODE'.fmt(idx));
+  }
+});
+

data/frameworks/sproutcore/frameworks/foundation/tests/private/tree_item_observer/group_case.js

@@ -0,0 +1,718 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+// The TreeItemObserver is tested based on the common use cases.
+/*globals throws */
+
+var content, delegate, flattened, obs, extra, extrachild, root;
+
+// default delegate class.  Does the bare minimum for tree item to function
+var Delegate = SC.Object.extend(SC.TreeItemContent, {
+  
+  treeItemChildrenKey: "children",
+  treeItemIsExpandedKey: "isExpanded",
+  
+  // This method is used to record range change info
+  
+  rangeIndexes: null,
+  rangeCallCount: 0,
+  
+  rangeDidChange: function(array, objects, key, indexes) {
+    this.rangeCallCount++;
+    this.rangeIndexes = indexes.frozenCopy();
+  }
+  
+});
+
+var TestObject = SC.Object.extend({
+  toString: function() { return "TestObject(%@)".fmt(this.get('title')); }
+});
+
+/**
+  Verifies that the passed observer object has the proper content.  This will
+  iterate over the passed expected array, calling objectAt() on the observer
+  to verify that it matches.  If you passed the expected index set, it will
+  also verify that the range observer on the observer was fire with the 
+  matching set of indexes.
+  
+  Finally, pass an optional description.
+*/
+function verifyObjectAt(obs, expected, eindexes, desc) {
+  var idx, len = expected.get('length'), actual;
+
+  // eindexes is optional
+  if (desc === undefined) {
+    desc = eindexes;
+    eindexes = undefined;
+  }
+  
+  equals(obs.get('length'), len, "%@ - length should match".fmt(desc));
+  for(idx=0;idx<len;idx++) {
+    actual = obs.objectAt(idx);
+    equals(actual, expected[idx], "%@ - observer.objectAt(%@) should match expected".fmt(desc, idx));
+  }
+  
+  if (eindexes !== undefined) {
+    if (eindexes) {
+      ok(delegate.rangeCallCount>0, 'range observer should be called (actual callCount=%@)'.fmt(delegate.rangeCallCount));
+    } else {
+      ok(delegate.rangeCallCount===0, 'range observer should NOT be called (actual callCount=%@)'.fmt(delegate.rangeCallCount));
+    }
+    
+    same(delegate.rangeIndexes, eindexes, 'range observer should be called with expected indexes');
+  }
+  
+}
+
+
+module("SC.TreeItemObserver - Group Use Case", {
+  setup: function() {
+    content = [
+      TestObject.create({
+        isGroup: YES,
+        title: "A",
+        isExpanded: YES,
+        outline: 0,
+        children: "0 1 2 3 4".w().map(function(x) { 
+          return TestObject.create({ 
+            title: "A.%@".fmt(x), outline: 1 
+          });
+        })
+      }),
+
+      TestObject.create({
+        isGroup: YES,
+        title: "B",
+        isExpanded: YES,
+        outline: 0,
+        children: "0 1 2 3 4".w().map(function(x) { 
+          return TestObject.create({ 
+            title: "B.%@".fmt(x), outline: 1 
+          });
+        })
+      }),
+
+      TestObject.create({
+        isGroup: YES,
+        title: "C",
+        isExpanded: NO,
+        outline: 0,
+        children: "0 1 2 3 4".w().map(function(x) { 
+          return TestObject.create({ 
+            title: "C.%@".fmt(x), outline: 1 
+          });
+        })
+      })];
+      
+    root = TestObject.create({
+      title: "ROOT",
+      children: content,
+      isExpanded: YES
+    });
+
+  
+    extra = TestObject.create({ title: "EXTRA" });
+    
+    extrachild = TestObject.create({
+      title: "EXTRA",
+      isExpanded: YES,
+      children: "0 1 2".w().map(function(x) { 
+        return TestObject.create({ title: "EXTRA.%@".fmt(x) });
+      })
+    });
+    
+    flattened = [
+      content[0],
+      content[0].children[0],
+      content[0].children[1],
+      content[0].children[2],
+      content[0].children[3],
+      content[0].children[4],
+      content[1],
+      content[1].children[0],
+      content[1].children[1],
+      content[1].children[2],
+      content[1].children[3],
+      content[1].children[4],
+      content[2]];
+      
+    delegate = Delegate.create();
+
+    // create root observer
+    obs = SC.TreeItemObserver.create({ delegate: delegate, item: root });
+    obs.addRangeObserver(null, delegate, delegate.rangeDidChange);
+  },
+  
+  teardown: function() {
+    if (obs) obs.destroy(); // cleanup
+    content = delegate = obs = null ;
+  }
+});
+
+
+// ..........................................................
+// LENGTH
+// 
+
+test("length on create", function() {
+  equals(obs.get('length'), flattened.length, 'should have length of array on create');
+});
+
+
+// ..........................................................
+// OBJECT AT
+// 
+
+test("objectAt on create", function() {
+  verifyObjectAt(obs, flattened, null, "on create");
+});
+
+// ..........................................................
+// CHANGING MODEL LAYER CONTENT - TOP LEVEL/NO CHILDREN
+// 
+
+test("pushing object to top level with no children", function() {
+
+  SC.run(function() { content.pushObject(extra); });
+  flattened.pushObject(extra);
+
+  var change = SC.IndexSet.create(flattened.length-1);
+  verifyObjectAt(obs, flattened, change, "after pushing top level object");
+});
+
+test("popping object to top level with no children", function() {
+  SC.run(function() { content.popObject(); });
+  flattened.popObject();
+
+  var change = SC.IndexSet.create(flattened.length);
+  verifyObjectAt(obs, flattened, change, "after popping top level object");
+});
+
+test("inserting object in middle of top level with no children", function() {
+  SC.run(function() { content.insertAt(2,extra); });
+  flattened.insertAt(12, extra);
+
+  var change = SC.IndexSet.create(12,flattened.length-12);
+  verifyObjectAt(obs, flattened, change, "after pushing top level object");
+});
+
+test("replacing object at top level with no children", function() {
+  SC.run(function() { content.replace(2,1, [extra]); });
+  flattened.replace(12, 1, [extra]);
+
+  var change = SC.IndexSet.create(12);
+  verifyObjectAt(obs, flattened, change, "after pushing top level object");
+});
+
+test("removing object at top level with no children", function() {
+  SC.run(function() { content.removeAt(2); });
+  flattened.removeAt(12);
+
+  var change = SC.IndexSet.create(12, flattened.length-11);
+  verifyObjectAt(obs, flattened, change,"after pushing top level object");
+});
+
+// ..........................................................
+// CHANGING MODEL LAYER CONTENT - GROUP LEVEL
+// 
+
+test("pushing object to group", function() {
+  var base = content[1].children;
+  SC.run(function() { base.pushObject(extra); });
+  flattened.insertAt(12, extra);
+
+  // changed reflect nearest top-level group
+  var change = SC.IndexSet.create(6, flattened.length-6);
+  verifyObjectAt(obs, flattened, change, "after pushing");
+});
+
+test("popping object from group", function() {
+  var base = content[1].children;
+  SC.run(function() { base.popObject(); });
+  flattened.removeAt(11);
+
+  // changed reflect nearest top-level group
+  var change = SC.IndexSet.create(6, flattened.length-5);
+  verifyObjectAt(obs, flattened, change, "after popping");
+});
+
+test("inserting object in middle of group", function() {
+  var base = content[1].children;
+  SC.run(function() { base.insertAt(2,extra); });
+  flattened.insertAt(9, extra);
+
+  // changed reflect nearest top-level group
+  var change = SC.IndexSet.create(6, flattened.length-6);
+  verifyObjectAt(obs, flattened, change, "after insert");
+});
+
+test("replacing object in group", function() {
+  var base = content[1].children;
+  SC.run(function() { base.replace(2,1, [extra]); });
+  flattened.replace(9, 1, [extra]);
+
+  // changed reflect nearest top-level group
+  var change = SC.IndexSet.create(6, flattened.length-7);
+  verifyObjectAt(obs, flattened, change, "after replacing");
+});
+
+test("removing object in gorup", function() {
+  var base = content[1].children;
+  SC.run(function() { base.removeAt(2); });
+  flattened.removeAt(9);
+
+  // changed reflect nearest top-level group
+  var change = SC.IndexSet.create(6, flattened.length-5);
+  verifyObjectAt(obs, flattened, change, "after removing");
+});
+
+test("replacing group children array", function() {
+  var children = extrachild.children;
+  SC.run(function() { content[1].set('children', children); });
+  flattened.replace(7,5,children);
+  
+  // changed reflect nearest top-level group
+  var change = SC.IndexSet.create(6, flattened.length-4);
+  verifyObjectAt(obs, flattened, change, "after removing");
+});
+
+test("changing expansion property on group", function() {
+  SC.run(function() { content[1].set('isExpanded', NO); });
+  flattened.removeAt(7,5);
+  
+  // changed reflect nearest top-level group
+  var change = SC.IndexSet.create(6, flattened.length-1);
+  verifyObjectAt(obs, flattened, change, "after removing");
+});
+
+// ..........................................................
+// CHANGING MODEL LAYER CONTENT - TOP LEVEL, W CHILDREN, NOT EXPANDED
+// 
+
+test("pushing object to top level with children, not expanded", function() {
+  extrachild.set('isExpanded', NO);
+  SC.run(function() { content.pushObject(extrachild); });
+  flattened.pushObject(extrachild);
+  verifyObjectAt(obs, flattened, "after pushing top level object");
+});
+
+test("inserting object in middle of top level with children, not expanded", function() {
+  extrachild.set('isExpanded', NO);
+  SC.run(function() { content.insertAt(2,extrachild); });
+  flattened.insertAt(12, extrachild);
+  verifyObjectAt(obs, flattened, "after pushing top level object");
+});
+
+// ..........................................................
+// CHANGING MODEL LAYER CONTENT - TOP LEVEL/CHILDREN/EXPANDED
+// 
+
+test("pushing object to top level with children", function() {
+  SC.run(function() { content.pushObject(extrachild); });
+  flattened.replace(flattened.length,0,[extrachild]);
+  flattened.replace(flattened.length,0,extrachild.children);
+  
+  verifyObjectAt(obs, flattened, "after pushing top level object");
+});
+
+test("popping object at top level with children", function() {
+  SC.run(function() { 
+    content.popObject(); // first one has no children
+    content.popObject(); // second one has children 
+  });
+  
+  flattened.length=6; // truncate
+  verifyObjectAt(obs, flattened, "after popping top level object");
+});
+
+test("inserting object in middle of top level with children", function() {
+  SC.run(function() { content.insertAt(2,extrachild); });
+  flattened.replace(12,0,[extrachild]);
+  flattened.replace(13,0,extrachild.children);
+  verifyObjectAt(obs, flattened, "after pushing top level object");
+});
+
+test("inserting object in middle of top level between items with children", function() {
+  SC.run(function() { content.insertAt(1,extrachild); });
+  flattened.replace(6,0,[extrachild]);
+  flattened.replace(7,0,extrachild.children);
+  verifyObjectAt(obs, flattened, "after pushing top level object");
+});
+
+test("replacing object at top level with no children => children", function() {
+  SC.run(function() { content.replace(2,1, [extrachild]); });
+  flattened.replace(12,1,[extrachild]);
+  flattened.replace(13,0,extrachild.children);
+  verifyObjectAt(obs, flattened, "after inserting top level object");
+});
+
+test("replacing object at top level with children => children", function() {
+  SC.run(function() { content.replace(1,1, [extrachild]); });
+  flattened.replace(6,6,[extrachild]);
+  flattened.replace(7,0,extrachild.children);
+  verifyObjectAt(obs, flattened, "after replacing top level object");
+});
+
+test("removing object at top level with children", function() {
+  SC.run(function() { content.removeAt(1); });
+  flattened.replace(6,6,null);
+  verifyObjectAt(obs, flattened, "after removing top level object");
+});
+
+// ..........................................................
+// MODIFYING OBSERVER -> MODEL, TOP-LEVEL
+// 
+
+test("adding an group to end", function() {
+  var expected = content.slice();
+  
+  SC.run(function() { obs.pushObject(extrachild); });
+  flattened.pushObject(extrachild);
+  flattened.replace(flattened.length, 0, extrachild.children);
+  expected.pushObject(extrachild);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(flattened.length-4,4);
+  verifyObjectAt(obs, flattened, change, 'after pushing object - should have item and its children');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("adding regular item to end", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.pushObject(extra); });
+  flattened.pushObject(extra);
+  expected.pushObject(extra);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(flattened.length-1,1);
+  verifyObjectAt(obs, flattened, change, 'after pushing object');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("adding an group to beginning", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.insertAt(0, extrachild); });
+  flattened.insertAt(0, extrachild);
+  flattened.replace(1, 0, extrachild.children);
+  expected.insertAt(0,extrachild);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(0,flattened.length);
+  verifyObjectAt(obs, flattened, change, 'after pushing object - should have item and its children');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("adding regular item to beginning", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.insertAt(0, extra); });
+  flattened.insertAt(0, extra);
+  expected.insertAt(0, extra);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(0,flattened.length);
+  verifyObjectAt(obs, flattened, change, 'after pushing object');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("adding an group to middle", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.replace(6, 0, extrachild); });
+  flattened.insertAt(6, extrachild);
+  flattened.replace(7, 0, extrachild.children);
+  expected.insertAt(1,extrachild);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(6,flattened.length-6);
+  verifyObjectAt(obs, flattened, change, 'after pushing object - should have item and its children');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("adding regular item to middle", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.insertAt(6, extra); });
+  flattened.insertAt(6, extra);
+  expected.insertAt(1, extra);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(6,flattened.length-6);
+  verifyObjectAt(obs, flattened, change, 'after pushing object');
+  
+  // verify content change
+  same(content, expected, 'content should have new extra item');
+});
+
+test("removing a group item", function() {
+  
+  var expected = content.slice();
+  
+  SC.run(function() { obs.removeAt(6); });
+  flattened.removeAt(6,6);
+  expected.removeAt(1);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(6,flattened.length);
+  verifyObjectAt(obs, flattened, change, 'after removing object - should remove children');
+  
+  // verify content change
+  same(content, expected, 'content should have removed item');
+});
+
+test("removing entire group", function() {
+  
+  var expected = content.slice();
+
+  // note: select entire group here...
+  SC.run(function() { obs.removeAt(6,6); });
+  flattened.removeAt(6,6);
+  expected.removeAt(1);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(6,flattened.length);
+  verifyObjectAt(obs, flattened, change, 'after removing object - should remove children');
+  
+  // verify content change
+  same(content, expected, 'content should have removed item');
+});
+
+test("removing partial group", function() {
+  
+  var expected = content.slice();
+
+  // note: select entire group here...
+  should_throw(function() {
+    obs.removeAt(3,6);
+  }, Error, "should throw error when trying to remove uneven boundaries");
+
+  // verify no change
+  var change = null;
+  verifyObjectAt(obs, flattened, change, 'after removing object - should remove children');
+  
+  // verify content change
+  same(content, expected, 'content should have removed item');
+});
+
+test("removing group header and some of the children", function() {
+  
+  var expected = content.slice();
+
+  // note: select entire group here...
+  should_throw(function() {
+    obs.removeAt(6, 3);
+  }, Error, "should throw error when trying to remove uneven boundaries");
+
+  // verify no change
+  var change = null;
+  verifyObjectAt(obs, flattened, change, 'after removing object - should remove children');
+  
+  // verify content change
+  same(content, expected, 'content should have removed item');
+});
+
+// ..........................................................
+// MODIFYING OBSERVER -> MODEL, GROUP-LEVEL
+// 
+
+test("adding regular item to end of group", function() {
+  
+  var expected = content[0].children.slice();
+  
+  SC.run(function() { 
+    obs.replace(6, 0, [extra], SC.DROP_AFTER); 
+  });
+  flattened.replace(6, 0, [extra]);
+  expected.pushObject(extra);
+  
+  // verify round trip - change covers effected group
+  var change = SC.IndexSet.create(0, flattened.length);
+  verifyObjectAt(obs, flattened, change, 'after pushing object');
+  
+  // verify content change
+  same(content[0].children, expected, 'content.children should change');
+});
+
+test("removing regular item to end of group", function() {
+  
+  var base     = content[0].children,
+      expected = base.slice();
+  
+  SC.run(function() { 
+    obs.removeAt(5); 
+  });
+  flattened.removeAt(5);
+  expected.popObject();
+  
+  // verify round trip - change covers effected group
+  var change = SC.IndexSet.create(0, flattened.length+1);
+  verifyObjectAt(obs, flattened, change, 'after removing object');
+  
+  // verify content change
+  same(base, expected, 'content.children should change');
+});
+
+test("adding regular item to beginning", function() {
+
+  var base     = content[0].children,
+      expected = base.slice();
+  
+  SC.run(function() { obs.insertAt(1, extra); });
+  flattened.insertAt(1, extra);
+  expected.insertAt(0, extra);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(0,flattened.length);
+  verifyObjectAt(obs, flattened, change, 'after pushing object - should have item');
+  
+  // verify content change
+  same(base, expected, 'content should have new extra item');
+});
+
+test("removing regular item to beginning", function() {
+
+  var base     = content[0].children,
+      expected = base.slice();
+  
+  SC.run(function() { obs.removeAt(1); });
+  flattened.removeAt(1);
+  expected.removeAt(0);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(0,flattened.length+1);
+  verifyObjectAt(obs, flattened, change, 'after pushing object - should have item');
+  
+  // verify content change
+  same(base, expected, 'content should have new extra item');
+});
+
+test("adding regular item to middle", function() {
+  
+  var base     = content[0].children,
+      expected = base.slice();
+  
+  SC.run(function() { obs.insertAt(3, extra); });
+  flattened.insertAt(3, extra);
+  expected.insertAt(2, extra);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(0,flattened.length);
+  verifyObjectAt(obs, flattened, change, 'after adding object');
+  
+  // verify content change
+  same(base, expected, 'content should have new extra item');
+});
+
+test("removing regular item to middle", function() {
+  
+  var base     = content[0].children,
+      expected = base.slice();
+  
+  SC.run(function() { obs.removeAt(3); });
+  flattened.removeAt(3);
+  expected.removeAt(2);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(0,flattened.length+1);
+  verifyObjectAt(obs, flattened, change, 'after adding object');
+  
+  // verify content change
+  same(base, expected, 'content should have new extra item');
+});
+
+test("replacing regular items in middle", function() {
+  
+  var base     = content[0].children,
+      expected = base.slice();
+  
+  SC.run(function() { obs.replace(3, 3, [extra]); });
+  flattened.replace(3, 3, [extra]);
+  expected.replace(2, 3, [extra]);
+  
+  // verify round trip
+  var change = SC.IndexSet.create(0,flattened.length+2);
+  verifyObjectAt(obs, flattened, change, 'after replacing object');
+  
+  // verify content change
+  same(base, expected, 'content should have new extra item');
+});
+
+// ..........................................................
+// SC.COLLECTION CONTENT SUPPORT
+// 
+
+test("contentGroupIndexes - not grouped", function() {
+  equals(delegate.get('treeItemIsGrouped'), NO, 'precond - delegate.treeItemIsGrouped == NO');
+  equals(obs.contentGroupIndexes(null, obs), null, 'contentGroupIndexes should be null');
+  
+  var idx, len = obs.get('length');
+  for(idx=0;idx<len;idx++) {
+    equals(obs.contentIndexIsGroup(null, obs, idx), NO, 'obs.contentIndexIsGroup(null, obs, %@) should be NO'.fmt(idx));
+  }
+});
+
+test("contentGroupIndexes - grouped", function() {
+  delegate.set('treeItemIsGrouped', YES);
+  equals(delegate.get('treeItemIsGrouped'), YES, 'precond - delegate.treeItemIsGrouped == YES');
+  
+  var set = SC.IndexSet.create(0).add(6).add(12);
+  same(obs.contentGroupIndexes(null, obs), set, 'contentGroupIndexes should cover just top leve items');
+  
+  var idx, len = obs.get('length');
+  for(idx=0;idx<len;idx++) {
+    equals(obs.contentIndexIsGroup(null, obs, idx), set.contains(idx), 'obs.contentIndexIsGroup(null, obs, %@)'.fmt(idx));
+  }
+});
+
+test("contentIndexOutlineLevel", function() {
+  var idx, len = obs.get('length');
+  for(idx=0;idx<len;idx++) {
+    var expected = flattened[idx].outline;
+    
+    equals(obs.contentIndexOutlineLevel(null, obs, idx), expected, 'obs.contentIndexOutlineLevel(null, obs, %@)'.fmt(idx));
+  }
+});
+
+test("contentIndexDisclosureState", function() {
+  var idx, len = obs.get('length');
+  for(idx=0;idx<len;idx++) {
+    var expected = flattened[idx].isExpanded;
+    expected = (expected === NO) ? SC.BRANCH_CLOSED : (expected ? SC.BRANCH_OPEN : SC.LEAF_NODE);
+    
+    var str ;
+    switch(expected) {
+      case SC.BRANCH_CLOSED: 
+        str = "SC.BRANCH_CLOSED";
+        break;
+      case SC.BRANCH_OPEN:
+        str = "SC.BRANCH_OPEN";
+        break;
+      default:
+         str = "SC.LEAF_NODE";
+         break;
+    }
+    
+    equals(obs.contentIndexDisclosureState(null, obs, idx), expected, 'obs.contentIndexDisclosureState(null, obs, %@) should eql %@'.fmt(idx,str));
+  }
+});