spade 0.0.1

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

@@ -0,0 +1,28 @@
+test("Regular expression escaping a string", function() {
+  same('\.+*?[^]$(){}=!<>|:'.escapeForRegExp(), '\\.\\+\\*\\?\\[\\^\\]\\$\\(\\)\\{\\}\\=\\!\\<\\>\\|\\:', "should be escaped");
+});
+
+test("Pluralizing a string", function() {
+  expect(8);
+  same('Goat'.pluralize(), 'Goats', "standard pluralization");
+  same('There are many goat'.pluralize(), 'There are many goats', "standard pluralization of a multi-word string");
+  same('Bunny'.pluralize(), 'Bunnies', "non-standard pluralization");
+  same('I like bunny'.pluralize(), 'I like bunnies', "non-standard pluralization of a multi-word string");
+  same('child'.pluralize(), 'children', "irregular pluralization");
+  same('I have three child'.pluralize(), 'I have three children', "irregular pluralization of a multi-word string");
+  same('sheep'.pluralize(), 'sheep', "uncountable pluralization");
+  same('Please hold this sheep'.pluralize(), 'Please hold this sheep', "uncountable pluralization of a multi-word string");
+});
+
+test("Singularizing a string", function() {
+  expect(8);
+  same('Vegetables'.singularize(), 'Vegetable', "standard singularization");
+  same('Broccoli is a vegetables'.singularize(), 'Broccoli is a vegetable', "standard singularization of a multi-word string");
+  same('Properties'.singularize(), 'Property', "non-standard singularization");
+  same('Buy a properties'.singularize(), 'Buy a property', "non-standard singularization of a multi-word string");
+  same('people'.singularize(), 'person', "irregular singularization");
+  same('The Village People'.singularize(), 'The Village Person', "irregular singularization of a multi-word string");
+  same('money'.singularize(), 'money', "uncountable singularization");
+  same('Gotta git da money'.singularize(), 'Gotta git da money', "uncountable singularization of a multi-word string");
+});
+

data/sproutcore/frameworks/foundation/tests/mixins/validatable/ui.js

@@ -0,0 +1,74 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            portions copyright @2009 Apple Inc.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/*global module test htmlbody ok equals same stop start */
+
+(function() {
+  var pane = SC.ControlTestPane.design()
+  .add("with valid value", SC.View.extend(SC.Validatable), { 
+    value: SC.Object.create({ data: 'here is some data' })
+  })
+  
+  .add("with error value", SC.View.extend(SC.Validatable), { 
+    value: SC.Error.create({ errorValue: 'bad data', message: 'Input is bad' })
+  });
+    
+pane.show(); // add a test to show the test pane
+
+pane.verifyInvalid = function(view, isInvalid) {
+  var layer = view.$();
+  if (isInvalid) {
+    ok(layer.hasClass('invalid'), 'layer should have invalid class');
+  }
+  else {
+    ok(!layer.hasClass('invalid'), 'layer should not have invalid class');
+  }
+};
+
+
+// ..........................................................
+// TEST INITIAL STATES
+// 
+
+module('SC.Validatable ui', pane.standardSetup());
+
+test("with valid value", function() {
+  var view = pane.view('with valid value');
+  pane.verifyInvalid(view, NO);
+});
+
+test("with invalid value", function() {
+  var view = pane.view('with error value');
+  pane.verifyInvalid(view, YES);
+});
+
+
+// ..........................................................
+// TEST CHANGING VIEWS
+//
+
+test("changing from invalid to valid", function() {
+  var view = pane.view('with error value');
+  
+  SC.RunLoop.begin();
+  view.set('value', 'not an SC.Error instance');
+  SC.RunLoop.end();
+  
+  pane.verifyInvalid(view, NO);
+});
+
+test("changing from valid to invalid", function() {
+  var view = pane.view('with valid value');
+  
+  SC.RunLoop.begin();
+  view.set('value', SC.Error.create());
+  SC.RunLoop.end();
+  
+  pane.verifyInvalid(view, YES);
+});
+
+})();

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

@@ -0,0 +1,325 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 Apple Inc. All rights reserved.
+// License:   Licensed 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/sproutcore/frameworks/foundation/tests/private/tree_item_observer/group_case.js

@@ -0,0 +1,718 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+// The TreeItemObserver is tested based on the common use cases.
+/*globals throws should_throw*/
+
+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],             // 0
+      content[0].children[0], // 1
+      content[0].children[1], // 2
+      content[0].children[2], // 3
+      content[0].children[3], // 4
+      content[0].children[4], // 5
+      content[1],             // 6
+      content[1].children[0], // 7
+      content[1].children[1], // 8
+      content[1].children[2], // 9
+      content[1].children[3], // 10
+      content[1].children[4], // 11
+      content[2]];            // 12
+      
+    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));
+  }
+});