sproutcore 1.9.2 → 1.10.0.rc.1

data/lib/frameworks/sproutcore/frameworks/runtime/system/string.js

@@ -33,7 +33,7 @@ SC.String = /** @scope SC.String.prototype */ {
     // formatters are optional
     if (formatter) value = formatter(value, arg);
     else if (arg) {
-      throw "String.fmt was given a formatting string, but key `" + key + "` has no formatter! String: " + string;
+      throw new Error("String.fmt was given a formatting string, but key `" + key + "` has no formatter! String: " + string);
     }
     
     return value;
@@ -93,13 +93,17 @@ SC.String = /** @scope SC.String.prototype */ {
     return string.replace(/%\{(.*?)\}/g, function(match, propertyPath) {
       hasHadNamedArguments = YES;
       if (!data) {
-        throw "Cannot use named parameters with `fmt` without a data hash. String: '" + string + "'";
+        throw new Error("Cannot use named parameters with `fmt` without a data hash. String: '" + string + "'");
       }
 
-      return SC.String._scs_valueForKey(propertyPath, data, string);
+      var ret = SC.String._scs_valueForKey(propertyPath, data, string);
+      // If a value was found, return that; otherwise return the original matched text to retain it in the string
+      // for future formatting.
+      if (!SC.none(ret)) { return ret; }
+      else { return match; }
     }).replace(/%@([0-9]+)?/g, function(match, index) {
       if (hasHadNamedArguments) {
-        throw "Invalid attempt to use both named parameters and indexed parameters. String: '" + string + "'";
+        throw new Error("Invalid attempt to use both named parameters and indexed parameters. String: '" + string + "'");
       }
       index = index ? parseInt(index, 10) - 1 : i++;
       if(args[index]!==undefined) return args[index];

data/lib/frameworks/sproutcore/frameworks/runtime/tests/core/tupleForPropertyPath.js

@@ -41,3 +41,7 @@ test("should check for the tuple property when path is undefined",function(){
      object2 = SC.tupleForPropertyPath(object.value,'');
      equals(YES,object2 === null,'returns null for undefined path');	
 });
+
+test("should check for path argument", function() {
+	equals(SC.tupleForPropertyPath(null), null, "returns null for null path");
+})

data/lib/frameworks/sproutcore/frameworks/runtime/tests/mixins/observable/chained.js

@@ -4,61 +4,150 @@
 //            ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-module("SC.Observable - Observing with @each");
+/*global module, test, equals */
 
-test("chained observers on enumerable properties are triggered when the observed property of any item changes", function() {
-  var family = SC.Object.create({ momma: null });
-  var momma = SC.Object.create({ children: [] });
+var family, grandma, momma, child1, child2, child3, child4, child5, observerFiredCount, observer2FiredCount;
+module("SC.Observable - Observing with @each", {
+  setup: function () {
+    momma = SC.Object.create({ children: [] });
+    grandma = SC.Object.create({ momma: momma });
+    family = SC.Object.create({
+      grandma: grandma,
+      eachCallback: function () {
+        observerFiredCount++;
+      },
+      childrenCallback: function () {
+        observer2FiredCount++;
+      }
+    });
 
-  var child1 = SC.Object.create({ name: "Bartholomew" });
-  var child2 = SC.Object.create({ name: "Agnes" });
-  var child3 = SC.Object.create({ name: "Dan" });
-  var child4 = SC.Object.create({ name: "Nancy" });
+    child1 = SC.Object.create({ name: "Bartholomew" });
+    child2 = SC.Object.create({ name: "Agnes" });
+    child3 = SC.Object.create({ name: "Dan" });
+    child4 = SC.Object.create({ name: "Nancy" });
+    child5 = SC.Object.create({ name: "Constance" });
 
-  family.set('momma', momma);
-  momma.set('children', [child1, child2, child3]);
+    momma.set('children', [child1, child2, child3]);
 
-  var observerFiredCount = 0;
-  family.addObserver('momma.children.@each.name', this, function() {
-    observerFiredCount++;
-  });
+    observerFiredCount = 0;
+    observer2FiredCount = 0;
+  },
+
+  teardown: function () {
+    family.destroy();
+    grandma.destroy();
+    momma.destroy();
+    child1.destroy();
+    child2.destroy();
+    child3.destroy();
+    child4.destroy();
+    child5.destroy();
+
+    family = grandma = momma = child1 = child2 = child3 = child4 = child5 = null;
+  }
+});
+
+test("chained observers on enumerable properties are triggered when the observed property of any item changes", function () {
+  family.addObserver('grandma.momma.children.@each.name', family, family.eachCallback);
+  family.addObserver('grandma.momma.children', family, family.childrenCallback);
 
   observerFiredCount = 0;
-  SC.run(function() { momma.get('children').setEach('name', 'Juan'); });
+  SC.run(function () { momma.get('children').setEach('name', 'Juan'); });
   equals(observerFiredCount, 3, "observer fired after changing child names");
 
   observerFiredCount = 0;
-  SC.run(function() { momma.children.pushObject(child4); });
+  SC.run(function () { momma.children.pushObject(child4); });
   equals(observerFiredCount, 1, "observer fired after adding a new item");
 
   observerFiredCount = 0;
-  SC.run(function() { child4.set('name', "Herbert"); });
+  SC.run(function () { child4.set('name', "Herbert"); });
   equals(observerFiredCount, 1, "observer fired after changing property on new object");
 
+  var oldChildren = momma.get('children');
   momma.set('children', []);
+  observerFiredCount = 0;
+  SC.run(function () {
+    oldChildren.pushObject(child5);
+    oldChildren.objectAt(0).set('name', "Hanna");
+  });
+  equals(observerFiredCount, 0, "observer did not fire after changing removed array and property on an object in removed array");
+  equals(observer2FiredCount, 1, "children observer did fire only once by replacing children with empty array");
+
+  observerFiredCount = 0;
+  observer2FiredCount = 0;
+  SC.run(function () { child1.set('name', "Hanna"); });
+  equals(observerFiredCount, 0, "observer did not fire after changing property on a removed object");
+
+  observerFiredCount = 0;
+  SC.run(function () { momma.set('children', [child1, child2, child3, child4]); });
+  equals(observerFiredCount, 0, "@each observer did not fire after replacing children with 4 objects");
+  equals(observer2FiredCount, 1, "children observer did fire only once after replacing children with 4 objects");
+
+  observerFiredCount = 0;
+  observer2FiredCount = 0;
+  SC.run(function () { momma.set('children', []); });
+  equals(observerFiredCount, 0, "@each observer did not fire after replacing children with empty array");
+  equals(observer2FiredCount, 1, "children observer did fire only once after replacing children with empty array");
+
+  observerFiredCount = 0;
+  SC.run(function () { momma.get('children').pushObjects([child1, child2, child3, child4]); });
+  equals(observerFiredCount, 1, "observer did fire only once after adding 4 objects");
+
+  observerFiredCount = 0;
+  SC.run(function () { momma.get('children').removeObjects([child1, child2]); });
+  equals(observerFiredCount, 1, "observer did fire once after removing 2 of 4 objects");
+
+  observerFiredCount = 0;
+  SC.run(function () { momma.get('children').removeObjects([child3, child4]); });
+  equals(observerFiredCount, 1, "observer did fire once after removing all objects");
 
+  // New grandma.
   observerFiredCount = 0;
-  SC.run(function() { child1.set('name', "Hanna"); });
-  equals(observerFiredCount, 0, "observer did not fire after removing changing property on a removed object");
+  grandma.destroy();
+  grandma = SC.Object.create({ momma: momma });
+  family.set('grandma', grandma);
+  equals(observerFiredCount, 0, "observer did not fire after replacing dear old grandma");
+
+  oldChildren = momma.get('children');
+  momma.destroy();
+  momma = SC.Object.create({ children: oldChildren });
+  grandma.set('momma', momma);
+  equals(observerFiredCount, 0, "observer did not fire after replacing dear old momma");
+
+  // Clean up.
+  family.removeObserver('grandma.momma.children.@each.name', family, family.eachCallback);
+});
+
+
+test("observer cleanup", function () {
+  family.addObserver('grandma.momma.children.@each.name', family, family.eachCallback);
+  family.removeObserver('grandma.momma.children.@each.name', family, family.eachCallback);
+
+  // Clean up.
+  equals(family._kvo_observed_keys.length, 0, "family has no observed keys");
+  equals(grandma._kvo_observed_keys.length, 0, "grandma has no observed keys");
+  equals(momma._kvo_observed_keys.length, 0, "momma has no observed keys: %@".fmt(momma._kvo_observed_keys.toArray()));
+  equals(momma.children._kvo_observed_keys.length, 0, "momma.children has no observed keys: %@".fmt(momma.children._kvo_observed_keys.toArray()));
+  equals(child1._kvo_observed_keys.length, 0, "child1 has no observed keys");
 });
 
-test("content observers are removed correctly", function() {
+test("content observers are removed correctly", function () {
   var child1 = SC.Object.create({ name: "Bartholomew", age: 15 });
   var child2 = SC.Object.create({ name: "Agnes", age: 12 });
   var children = [child1, child2];
 
   var observerFiredCount = 0;
-  var observerFunc = function() { observerFiredCount++; }
+  var observerFunc = function () { observerFiredCount++; };
 
   children.addObserver('@each.name', this, observerFunc);
   children.removeObserver('@each.name', this, observerFunc);
   observerFiredCount = 0;
-  SC.run(function() { children.setEach('name', "Hanna"); });
+  SC.run(function () { children.setEach('name', "Hanna"); });
   equals(observerFiredCount, 0, "name observer did not fire after it was removed");
 
   children.addObserver('@each.age', this, observerFunc);
   children.removeObserver('@each.age', this, observerFunc);
   observerFiredCount = 0;
-  SC.run(function() { children.setEach('age', 14); });
+  SC.run(function () { children.setEach('age', 14); });
   equals(observerFiredCount, 0, "age observer did not fire after it was removed");
 });

data/lib/frameworks/sproutcore/frameworks/runtime/tests/mixins/observable/observable.js

@@ -588,7 +588,7 @@ module("Observable objects & object properties ", {
 
   setup: function() {
     window.NormalArray = [1,2,3,4,5];
-    
+
     object = SC.Object.create({
 
       normal: 'value',
@@ -898,43 +898,43 @@ module("addObservesHandler and removeObservesHandler functions", {
     window.TestNS = SC.Object.create({
       value: 0
     });
-    
+
     objectA = SC.Object.create({
-      
+
       value: 0,
       arrayValue: [],
-      
+
       handler1NotifiedCount: 0,
       handler2NotifiedCount: 0,
       arrayHandlerNotifiedCount: 0,
-      
+
       handler1: function() {
         this.handler1NotifiedCount++;
       },
-      
+
       handler2: function() {
         this.handler2NotifiedCount++;
       },
-      
+
       arrayHandler: function() {
         this.arrayHandlerNotifiedCount++;
       }
-      
+
     });
   },
-  
+
   teardown: function() {
     objectA = null;
     window.TestNS = null;
   }
-  
+
 });
 
 test("add and remove observer handler1", function() {
   objectA.addObservesHandler(objectA.handler1, 'value');
   objectA.set('value', 100);
   equals(objectA.handler1NotifiedCount, 1, "observes handler1 should be notified");
-  
+
   objectA.removeObservesHandler(objectA.handler1, 'value');
   objectA.set('value', 200);
   equals(objectA.handler1NotifiedCount, 1, "observes handler1 should not be notified");
@@ -944,7 +944,7 @@ test("add and remove observer handler2", function() {
   objectA.addObservesHandler(objectA.handler2, 'TestNS.value');
   window.TestNS.set('value', 1000);
   equals(objectA.handler2NotifiedCount, 1, "observes handler2 should be notified");
-  
+
   objectA.removeObservesHandler(objectA.handler2, 'TestNS.value');
   window.TestNS.set('value', 2000);
   equals(objectA.handler2NotifiedCount, 1, "observes handler1 should not be notified");
@@ -954,13 +954,13 @@ test("add and remove observer array handler without chain observes", function()
   objectA.addObservesHandler(objectA.arrayHandler, 'arrayValue.[]');
   objectA.arrayValue.pushObject(SC.Object.create());
   ok(objectA.arrayHandlerNotifiedCount > 0, "observes array handler should be notified aftering pushing object to array");
-  
+
   objectA.arrayHandlerNotifiedCount = 0;
-  
+
   objectA.removeObservesHandler(objectA.arrayHandler, 'arrayValue.[]');
   objectA.arrayValue.pushObject(SC.Object.create());
   equals(objectA.arrayHandlerNotifiedCount, 0, "observes array handler should not be notified after removing observes handler");
-  
+
   objectA.addObservesHandler(objectA.arrayHandler, 'arrayValue.[]');
   objectA.set('arrayValue', []);
   equals(objectA.arrayHandlerNotifiedCount, 0, "observes array handler should not be notified after assigning new array");
@@ -972,18 +972,71 @@ test("add and remove observer array handler with chain observes", function() {
   objectA.addObservesHandler(objectA.arrayHandler, '*arrayValue.[]');
   objectA.arrayValue.pushObject(SC.Object.create());
   ok(objectA.arrayHandlerNotifiedCount > 0, "observes array handler should be notified aftering pushing object to array");
-  
+
   objectA.arrayHandlerNotifiedCount = 0;
-  
+
   objectA.removeObservesHandler(objectA.arrayHandler, '*arrayValue.[]');
   objectA.arrayValue.pushObject(SC.Object.create());
   equals(objectA.arrayHandlerNotifiedCount, 0, "observes array handler should not be notified of push after removing observes handler");
   objectA.set('arrayValue', []);
   equals(objectA.arrayHandlerNotifiedCount, 0, "observes array handler should not be notified of new array after removing observes handler");
-  
+
   objectA.addObservesHandler(objectA.arrayHandler, '*arrayValue.[]');
   objectA.set('arrayValue', []);
   ok(objectA.arrayHandlerNotifiedCount > 0, "observes array handler should be notified after assigning new array");
   objectA.arrayValue.pushObject(SC.Object.create());
   ok(objectA.arrayHandlerNotifiedCount > 0, "observes array handler should be notified after pushing object to new array");
 });
+
+
+module("Cleaning up observables", {
+
+  setup: function() {
+    window.TestNS = SC.Object.create({
+      value1: 'a',
+      value2: 'b'
+    });
+
+    SC.run(function() {
+      object = SC.Object.create({
+
+        myValue1Binding: 'TestNS.value1',
+
+        value2DidChange: function() {
+
+        }.observes('TestNS.value2')
+
+      });
+    });
+  },
+
+  teardown: function() {
+    object = window.TestNS = null;
+  }
+
+});
+
+/**
+  This test highlights a problem with destroying Observable objects.  Previously
+  bindings and observers on the object resulted in the object being retained in
+  the ObserverSets of other objects, preventing them from being freed.  The
+  addition of destroyObservable to SC.Observable fixes this.
+*/
+test("destroying an observable should remove binding objects and clear observer queues", function() {
+  var observerSet1, observerSet2,
+    targetGuid1, targetGuid2;
+
+  targetGuid1 = SC.guidFor(object);
+  targetGuid2 = SC.guidFor(object.bindings[0]);
+  observerSet1 = TestNS._kvo_observers_value1;
+  observerSet2 = TestNS._kvo_observers_value2;
+  equals(observerSet1.members.length, 1, "The length of the members array on TestNS._kvo_observers_value1 should be");
+  equals(observerSet2.members.length, 1, "The length of the members array on TestNS._kvo_observers_value2 should be");
+  ok(!SC.none(observerSet1._members[targetGuid2]), "The object should be retained in TestNS._kvo_observers_value1.");
+  ok(!SC.none(observerSet2._members[targetGuid1]), "The object should be retained in TestNS._kvo_observers_value2.");
+  object.destroy();
+  equals(observerSet1.members.length, 0, "The length of the members array on TestNS._kvo_observers_value1 should be");
+  equals(observerSet2.members.length, 0, "The length of the members array on TestNS._kvo_observers_value2 should be");
+  ok(SC.none(observerSet1._members[targetGuid2]), "The object should not be retained in TestNS._kvo_observers_value1.");
+  ok(SC.none(observerSet2._members[targetGuid1]), "The object should not be retained in TestNS._kvo_observers_value2.");
+});

data/lib/frameworks/sproutcore/frameworks/runtime/tests/system/binding.js

@@ -12,49 +12,71 @@
 var fromObject, toObject, binding, Bon1, bon2 ; // global variables
 
 module("basic object binding", {
-  
-  setup: function() {
+
+  setup: function () {
     fromObject = SC.Object.create({ value: 'start' }) ;
+    midObject = SC.Object.create({ value: 'middle' });
     toObject = SC.Object.create({ value: 'end' }) ;
-    binding = SC.Binding.from("value", fromObject).to("value", toObject).connect() ;
+    binding1 = SC.Binding.from("value", fromObject).to("value", midObject).connect() ;
+    binding2 = SC.Binding.from("value", midObject).to("value", toObject).connect();
     SC.Binding.flushPendingChanges() ; // actually sets up up the connection
+  },
+
+  teardown: function () {
+    fromObject.destroy();
+    midObject.destroy();
+    toObject.destroy();
+    fromObject = midObject = toObject = binding1 = binding2 = null;
   }
 });
-  
+
 test("binding is connected", function() {
-  equals(binding.isConnected, YES, "binding.isConnected") ;
+  equals(binding1.isConnected, YES, "binding1.isConnected") ;
+  equals(binding2.isConnected, YES, "binding2.isConnected") ;
 });
 
 test("binding has actually been setup", function() {
-  equals(binding._connectionPending, NO, "binding._connectionPending") ;
+  equals(binding1._connectionPending, NO, "binding1._connectionPending") ;
+  equals(binding2._connectionPending, NO, "binding2._connectionPending") ;
 });
 
 test("binding should have synced on connect", function() {
   equals(toObject.get("value"), "start", "toObject.value should match fromObject.value");
+  equals(midObject.get("value"), "start", "midObject.value should match fromObject.value");
 });
 
 test("changing fromObject should mark binding as dirty", function() {
   fromObject.set("value", "change") ;
-  equals(binding._changePending, YES) ;
+  ok(SC.Binding._changeQueue.contains(binding1), "the binding should be in the _changeQueue");
+  SC.Binding.flushPendingChanges() ;
+  ok(SC.Binding._changeQueue.contains(binding2), "the binding should be in the _changeQueue");
 });
 
 test("fromObject change should propogate to toObject only after flush", function() {
   fromObject.set("value", "change") ;
+  equals(midObject.get("value"), "start") ;
   equals(toObject.get("value"), "start") ;
   SC.Binding.flushPendingChanges() ;
-  equals(toObject.get("value"), "change") ;    
+  equals(midObject.get("value"), "change") ;
+  SC.Binding.flushPendingChanges() ;
+  equals(toObject.get("value"), "change") ;
 });
 
 test("changing toObject should mark binding as dirty", function() {
   toObject.set("value", "change") ;
-  equals(binding._changePending, YES) ;
+  ok(SC.Binding._changeQueue.contains(binding2), "the binding should be in the _changeQueue");
+  SC.Binding.flushPendingChanges() ;
+  ok(SC.Binding._changeQueue.contains(binding1), "the binding should be in the _changeQueue");
 });
 
 test("toObject change should propogate to fromObject only after flush", function() {
   toObject.set("value", "change") ;
+  equals(midObject.get("value"), "start") ;
   equals(fromObject.get("value"), "start") ;
   SC.Binding.flushPendingChanges() ;
-  equals(fromObject.get("value"), "change") ;    
+  equals(midObject.get("value"), "change") ;
+  SC.Binding.flushPendingChanges() ;
+  equals(fromObject.get("value"), "change") ;
 });
 
 test("suspended observing during bindings", function() {
@@ -64,20 +86,20 @@ test("suspended observing during bindings", function() {
     value1: 'value1',
     value2: 'value2'
   });
-  
+
   toObject = SC.Object.create({
     value1: 'value1',
     value2: 'value2',
-    
+
     callCount: 0,
-    
+
     observer: function() {
       equals(this.get('value1'), 'CHANGED', 'value1 when observer fires');
       equals(this.get('value2'), 'CHANGED', 'value2 when observer fires');
       this.callCount++;
     }.observes('value1', 'value2')
   });
-  
+
   toObject.bind('value1', fromObject, 'value1');
   toObject.bind('value2', fromObject, 'value2');
 
@@ -85,20 +107,34 @@ test("suspended observing during bindings", function() {
   // fire after bindings are done flushing.
   fromObject.set('value1', 'CHANGED').set('value2', 'CHANGED');
   SC.Binding.flushPendingChanges();
-  
+
   equals(toObject.callCount, 2, 'should call observer twice');
 });
 
 test("binding will disconnect", function() {
-  binding.disconnect();
-  equals(binding.isConnected, NO, "binding.isConnected");
+  binding1.disconnect();
+  equals(binding1.isConnected, NO, "binding1.isConnected");
 });
 
 test("binding disconnection actually works", function() {
-  binding.disconnect();
+  binding1.disconnect();
   fromObject.set('value', 'change');
   SC.Binding.flushPendingChanges();
+  equals(midObject.get('value'), 'start');
+  SC.Binding.flushPendingChanges();
   equals(toObject.get('value'), 'start');
+
+  binding1.connect();
+  SC.Binding.flushPendingChanges();
+  equals(midObject.get('value'), 'change');
+  SC.Binding.flushPendingChanges();
+  equals(toObject.get('value'), 'change');
+});
+
+test("binding destruction actually works", function() {
+  binding1.destroy()
+  ok(binding1.isDestroyed, "binding marks itself as destroyed.");
+  ok(!binding1._fromTarget && !binding1._toTarget, "binding destruction removes binding targets.");
 });
 
 module("bindings on classes");
@@ -122,6 +158,10 @@ test("should connect when multiple instances of class are created", function() {
     var mySecondObj;
     SC.run(function() { mySecondObj = myClass.create() });
     equals(mySecondObj.get('foo'), "How to Be Happy");
+
+    SC.run(function() { myFirstObj.destroy(); })
+    ok(myFirstObj.fooBinding.isDestroyed, "destroying an object destroys its class bindings.");
+
   } finally {
     window.TestNamespace = undefined;
   }
@@ -134,70 +174,70 @@ module("one way binding", {
     binding = SC.Binding.from("value", fromObject).to("value", toObject).oneWay().connect() ;
     SC.Binding.flushPendingChanges() ; // actually sets up up the connection
   }
-  
+
 });
-  
+
 test("changing fromObject should mark binding as dirty", function() {
   fromObject.set("value", "change") ;
-  equals(binding._changePending, YES) ;
+  ok(SC.Binding._changeQueue.contains(binding), "the binding should be in the _changeQueue");
 });
 
 test("fromObject change should propogate after flush", function() {
   fromObject.set("value", "change") ;
   equals(toObject.get("value"), "start") ;
   SC.Binding.flushPendingChanges() ;
-  equals(toObject.get("value"), "change") ;    
+  equals(toObject.get("value"), "change") ;
 });
 
 test("changing toObject should not make binding dirty", function() {
   toObject.set("value", "change") ;
-  equals(binding._changePending, NO) ;
+  ok(!SC.Binding._changeQueue.contains(binding), "the binding should not be in the _changeQueue");
 });
 
 test("toObject change should NOT propogate", function() {
   toObject.set("value", "change") ;
   equals(fromObject.get("value"), "start") ;
   SC.Binding.flushPendingChanges() ;
-  equals(fromObject.get("value"), "start") ;    
+  equals(fromObject.get("value"), "start") ;
 });
 
 var first, second, third, binding1, binding2 ; // global variables
 
 module("chained binding", {
-  
+
   setup: function() {
     first = SC.Object.create({ output: 'first' }) ;
-    
-    second = SC.Object.create({ 
+
+    second = SC.Object.create({
       input: 'second',
       output: 'second',
-      
+
       inputDidChange: function() {
         this.set("output", this.get("input")) ;
-      }.observes("input")  
+      }.observes("input")
     }) ;
-    
+
     third = SC.Object.create({ input: "third" }) ;
-    
+
     binding1 = SC.Binding.from("output", first).to("input", second).connect() ;
     binding2 = SC.Binding.from("output", second).to("input", third).connect() ;
     SC.Binding.flushPendingChanges() ; // actually sets up up the connection
   }
-  
+
 });
 
 test("changing first output should propagate to third after flush", function() {
   first.set("output", "change") ;
   equals("change", first.get("output"), "first.output") ;
   ok("change" !== third.get("input"), "third.input") ;
-  
+
   var didChange = YES;
   while(didChange) didChange = SC.Binding.flushPendingChanges() ;
-  
+
   // bindings should not have bending changes
-  equals(binding1._changePending, NO, "binding1._changePending") ;
-  equals(binding2._changePending, NO, "binding2._changePending") ;
-  
+  ok(!SC.Binding._changeQueue.contains(binding1), "the binding should not be in the _changeQueue");
+  ok(!SC.Binding._changeQueue.contains(binding2), "the binding should not be in the _changeQueue");
+
   equals("change", first.get("output"), "first.output") ;
   equals("change", second.get("input"), "second.input") ;
   equals("change", second.get("output"), "second.output") ;
@@ -205,27 +245,27 @@ test("changing first output should propagate to third after flush", function() {
 });
 
 module("Custom Binding", {
-  
+
   setup: function() {
 	Bon1 = SC.Object.extend({
 		value1: "hi",
 		value2: 83,
 		array1: []
 	});
-	
+
 	bon2 = SC.Object.create({
 		val1: "hello",
 		val2: 25,
 		arr: [1,2,3,4]
 	});
-	
+
 	TestNamespace = {
       bon2: bon2,
       Bon1: Bon1
     } ;
   },
-  
-  teardown: function() { 
+
+  teardown: function() {
     bon2.destroy();
   }
 });
@@ -273,40 +313,40 @@ test("two bindings to the same value should sync in the order they are initializ
 
   SC.RunLoop.begin();
 
-  window.a = SC.Object.create({ 
-    foo: "bar" 
+  window.a = SC.Object.create({
+    foo: "bar"
   });
-  
+
   var a = window.a;
-  
-  window.b = SC.Object.create({ 
+
+  window.b = SC.Object.create({
     foo: "baz",
     fooBinding: "a.foo",
-    
+
     C: SC.Object.extend({
       foo: "bee",
       fooBinding: "*owner.foo"
     }),
-    
+
     init: function() {
       sc_super();
       this.set('c', this.C.create({ owner: this }));
     }
-    
+
   });
-  
+
   var b = window.b;
 
   SC.LOG_BINDINGS = NO;
-    
+
   SC.RunLoop.end();
-  
+
   equals(a.get('foo'), "bar", 'a.foo should not change');
   equals(b.get('foo'), "bar", 'a.foo should propogate up to b.foo');
   equals(b.c.get('foo'), "bar", 'a.foo should propogate up to b.c.foo');
-  
+
   window.a = window.b = null ;
-  
+
 });
 
 module("AND binding", {
@@ -327,7 +367,7 @@ module("AND binding", {
     SC.testControllerA.destroy();
     SC.testControllerB.destroy();
   }
-  
+
 });
 
 test("toObject.value should be YES if both sources are YES", function() {
@@ -384,7 +424,7 @@ module("OR binding", {
     SC.testControllerA.destroy();
     SC.testControllerB.destroy();
   }
-  
+
 });
 
 test("toObject.value should be first value if first value is truthy", function() {