sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

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

@@ -3,6 +3,8 @@
 // ========================================================================
 /*globals module test ok isObj equals expects */
 
+var revMatches = NO ;
+
 module("object.propertyChanges", {  
   setup: function() {
     ObjectA = SC.Object.create({
@@ -25,7 +27,8 @@ module("object.propertyChanges", {
       }.observes('prop'),
 
       starProp: null,
-      starObserver: function(target, key) {
+      starObserver: function(target, key, value, rev) {
+        revMatches = (rev === target.propertyRevision) ;
         this.starProp = key;
       }
       
@@ -120,4 +123,10 @@ test("star observers", function() {
   
   ObjectA.set('bar', 'foo');
   equals(ObjectA.starProp, 'bar', 'should have fired star observer for bar');
-});
+});
+
+test("revision passed to observers should match .propertyRevision", function() {
+    
+  equals(revMatches, true) ;
+  
+});

data/frameworks/sproutcore/frameworks/runtime/tests/private/observer_queue/isObservingSuspended.js

@@ -0,0 +1,55 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+var callCount, obj;
+
+module("SC.Observers.isObservingSuspended", {
+  setup: function() {
+    callCount = 0;
+    
+    obj = SC.Object.create({ 
+      foo: "bar",
+
+      fooDidChange: function() { 
+        callCount++; 
+      }.observes('foo')
+    });
+  }
+});
+
+test("suspending observers stops notification", function() {
+  SC.Observers.suspendPropertyObserving();
+  SC.Observers.suspendPropertyObserving();
+  obj.set("foo");
+  equals(callCount, 0, 'should not notify observer while suspended');
+
+  SC.Observers.resumePropertyObserving();
+  equals(callCount, 0, 'should not notify observer while still suspended');
+  
+  SC.Observers.resumePropertyObserving();
+  equals(callCount, 1, 'should notify observer when resumed');
+  
+});
+
+// ..........................................................
+// SPECIAL CASES
+// 
+
+// this test verifies a specific bug in the SC.Observing.propertyDidChange method.
+test("suspended notifications should work when nesting property change groups", function() {
+  
+  SC.Observers.suspendPropertyObserving();
+  obj.beginPropertyChanges();
+  obj.set("foo");
+  equals(callCount, 0, 'should not notify observer while suspended');
+
+  obj.endPropertyChanges();
+  equals(callCount, 0, 'should not notify observer while suspended');
+
+  SC.Observers.resumePropertyObserving();
+  equals(callCount, 1, 'should notify observer when resumed');
+});

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

@@ -23,6 +23,10 @@ test("binding has actually been setup", function() {
   equals(binding._connectionPending, NO, "binding._connectionPending") ;
 });
 
+test("binding should have synced on connect", function() {
+  equals(toObject.get("value"), "start", "toObject.value should match fromObject.value");
+});
+
 test("changing fromObject should mark binding as dirty", function() {
   fromObject.set("value", "change") ;
   equals(binding._changePending, YES) ;
@@ -30,7 +34,7 @@ test("changing fromObject should mark binding as dirty", function() {
 
 test("fromObject change should propogate to toObject only after flush", function() {
   fromObject.set("value", "change") ;
-  equals(toObject.get("value"), "end") ;
+  equals(toObject.get("value"), "start") ;
   SC.Binding.flushPendingChanges() ;
   equals(toObject.get("value"), "change") ;    
 });
@@ -47,6 +51,38 @@ test("toObject change should propogate to fromObject only after flush", function
   equals(fromObject.get("value"), "change") ;    
 });
 
+test("suspended observing during bindings", function() {
+
+  // setup special binding
+  fromObject = SC.Object.create({
+    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');
+
+  // change both value1 + value2, then  flush bindings.  observer should only
+  // fire after bindings are done flushing.
+  fromObject.set('value1', 'CHANGED').set('value2', 'CHANGED');
+  SC.Binding.flushPendingChanges();
+  
+  equals(toObject.callCount, 2, 'should call observer twice');
+});
+
 module("one way binding", {
   
   setup: function() {
@@ -65,7 +101,7 @@ test("changing fromObject should mark binding as dirty", function() {
 
 test("fromObject change should propogate after flush", function() {
   fromObject.set("value", "change") ;
-  equals(toObject.get("value"), "end") ;
+  equals(toObject.get("value"), "start") ;
   SC.Binding.flushPendingChanges() ;
   equals(toObject.get("value"), "change") ;    
 });
@@ -112,11 +148,12 @@ test("changing first output should propograte to third after flush", function()
   equals("change", first.get("output"), "first.output") ;
   ok("change" !== third.get("input"), "third.input") ;
   
-  SC.Binding.flushPendingChanges() ;
+  var didChange = YES;
+  while(didChange) didChange = SC.Binding.flushPendingChanges() ;
   
   // bindings should not have bending changes
-  equals(NO, binding1._changePending, "binding1._changePending === NO") ;
-  equals(NO, binding2._changePending, "binding2._changePending === NO") ;
+  equals(binding1._changePending, NO, "binding1._changePending") ;
+  equals(binding2._changePending, NO, "binding2._changePending") ;
   
   equals("change", first.get("output"), "first.output") ;
   equals("change", second.get("input"), "second.input") ;
@@ -187,4 +224,42 @@ test("Binding with transforms, function to check the type of value", function()
 	bon2.set("val1","changed");
 	SC.Binding.flushPendingChanges();
 	equals(jon.get("value1"), bon2.get("val1"));
-});
+});
+
+test("two bindings to the same value should sync in the order they are initialized", function() {
+
+  SC.LOG_BINDINGS = YES;
+
+  SC.RunLoop.begin();
+
+  var a = window.a = SC.Object.create({ 
+    foo: "bar" 
+  });
+  
+  var b = 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 }));
+    }
+    
+  });
+
+  SC.LOG_BINDINGS = YES;
+    
+  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 ;
+  
+});

data/frameworks/sproutcore/frameworks/runtime/tests/system/index_set/add.js

@@ -0,0 +1,195 @@
+// ==========================================================================
+// 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 */
+var set ;
+module("SC.IndexSet#add", {
+  setup: function() {
+    set = SC.IndexSet.create();
+  }
+});
+
+function iter(s) {
+  var ret = [];
+  set.forEach(function(k) { ret.push(k); });
+  return ret ;
+}
+
+// ..........................................................
+// BASIC ADDS
+// 
+
+test("add range to end of set", function() {
+  set.add(1000,5);
+  equals(set.get('length'), 5, 'should have correct index count');  
+  equals(set.get('max'), 1005, 'max should return 1 past last index');
+  same(iter(set), [1000,1001,1002,1003,1004]);
+});
+
+test("add range into middle of empty range", function() {
+  set.add(100,2); // add initial set.
+  equals(iter(set)[0], 100, 'precond - first index is 100');
+  
+  // now add second range
+  set.add(10,1);
+  equals(set.get('length'), 3, 'should have extra length');
+  equals(set.get('max'), 102, 'max should return 1 past last index');
+  same(iter(set), [10, 100, 101]);
+});
+
+test("add range overlapping front edge of range", function() {
+  set.add(100,2); // add initial set.
+  equals(iter(set)[0], 100, 'precond - first index is 100');
+  
+  // now add second range
+  set.add(99,2);
+  equals(set.get('length'), 3, 'should have extra length');
+  equals(set.get('max'), 102, 'max should return 1 past last index');
+  same(iter(set), [99, 100, 101]);
+});
+
+test("add range overlapping last edge of range", function() {
+  set.add(100,2).add(200,2);
+  same(iter(set), [100,101,200,201], 'should have two sets');
+  
+  // now add overlapping range
+  set.add(101,2);
+  equals(set.get('length'), 5, 'new set.length');
+  equals(set.get('max'), 202, 'max should return 1 past last index');
+  same(iter(set), [100,101,102,200,201], 'should include 101-102');
+});
+
+test("add range overlapping two ranges, merging into one", function() {
+  set.add(100,2).add(110,2);
+  same(iter(set), [100,101,110,111], 'should have two sets');
+  
+  // now add overlapping range
+  set.add(101,10);
+  equals(set.get('length'), 12, 'new set.length');
+  equals(set.get('max'), 112, 'max should return 1 past last index');
+  same(iter(set), [100,101,102,103,104,105,106,107,108,109,110,111], 'should include one range 100-111');
+});
+
+test("add range overlapping three ranges, merging into one", function() {
+  set.add(100,2).add(105,2).add(110,2);
+  same(iter(set), [100,101,105,106,110,111], 'should have two sets');
+  
+  // now add overlapping range
+  set.add(101,10);
+  equals(set.get('length'), 12, 'new set.length');
+  equals(set.get('max'), 112, 'max should return 1 past last index');
+  same(iter(set), [100,101,102,103,104,105,106,107,108,109,110,111], 'should include one range 100-111');
+});
+
+test("add range partially overlapping one range and replaing another range, merging into one", function() {
+  set.add(100,2).add(105,2);
+  same(iter(set), [100,101,105,106], 'should have two sets');
+  
+  // now add overlapping range
+  set.add(101,10);
+  equals(set.get('length'), 11, 'new set.length');
+
+  equals(set.get('max'), 111, 'max should return 1 past last index');
+  same(iter(set), [100,101,102,103,104,105,106,107,108,109,110], 'should include one range 100-110');
+});
+
+test("add range overlapping last index", function() {
+  set.add(100,2); // add initial set.
+  equals(iter(set)[0], 100, 'precond - first index is 100');
+  
+  // now add second range
+  set.add(101,2);
+  equals(set.get('length'), 3, 'should have extra length');
+  equals(set.get('max'), 103, 'max should return 1 past last index');
+  same(iter(set), [100, 101, 102]);
+});
+
+test("add range matching existing range", function() {
+  set.add(100,5); // add initial set.
+  equals(iter(set)[0], 100, 'precond - first index is 100');
+  
+  // now add second range
+  set.add(100,5);
+  equals(set.get('length'), 5, 'should not change');
+  equals(set.get('max'), 105, 'max should return 1 past last index');
+  same(iter(set), [100, 101, 102, 103, 104]);  
+});
+
+// ..........................................................
+// NORMALIZED PARAMETER CASES
+// 
+
+test("add with no params should do nothing", function() {
+  set.add();
+  same(iter(set), []);
+});
+
+test("add with single number should add index only", function() {
+  set.add(2);
+  same(iter(set), [2]);
+});
+
+test("add with range object should add range only", function() {
+  set.add({ start: 2, length: 2 });
+  same(iter(set), [2,3]);
+});
+
+test("add with index set should add indexes in set", function() {
+  set.add(SC.IndexSet.create().add(2,2).add(10,2));
+  same(iter(set), [2,3,10,11]);
+});
+
+// ..........................................................
+// OTHER BEHAVIORS
+// 
+
+test("adding a range should trigger an observer notification", function() {
+  var callCnt = 0;
+  set.addObserver('[]', function() { callCnt++; });
+  set.add(10,10);
+  equals(callCnt, 1, 'should have called observer once');
+});
+
+test("adding a range over an existing range should not trigger an observer notification", function() {
+  var callCnt = 0;
+  set.add(10,10);
+  set.addObserver('[]', function() { callCnt++; });
+  set.add(15,5);
+  equals(callCnt, 0, 'should not have called observer');
+});
+
+test("appending a range to end should merge into last range", function() {
+  set = SC.IndexSet.create(2).add(3);
+  equals(set.rangeStartForIndex(3), 2, 'last two range should merge together (%@)'.fmt(set.inspect()));
+  equals(set.get('max'), 4, 'should have max');
+  equals(set.get('length'), 2, 'should have length');
+
+  set = SC.IndexSet.create(2000, 1000).add(3000, 1000);
+  equals(set.rangeStartForIndex(3990), 2000, 'last two range should merge together (%@)'.fmt(set.inspect()));
+  equals(set.get('max'), 4000, 'should have max');
+  equals(set.get('length'), 2000, 'should have length');
+  
+});
+
+test("appending range to start of empty set should create a single range", function() {
+  set = SC.IndexSet.create().add(0,2);
+  equals(set.rangeStartForIndex(1), 0, 'should have single range (%@)'.fmt(set.inspect()));
+  equals(set.get('length'), 2, 'should have length');
+  equals(set.get('max'), 2, 'should have max');
+  
+  set = SC.IndexSet.create().add(0,2000);
+  equals(set.rangeStartForIndex(1998), 0, 'should have single range (%@)'.fmt(set.inspect()));
+  equals(set.get('length'), 2000, 'should have length');
+  equals(set.get('max'), 2000, 'should have max');
+  
+});
+
+test("add raises exception when frozen", function() {
+  should_throw(function() {
+    set.freeze().add(0,2);    
+  }, SC.FROZEN_ERROR);  
+});
+

data/frameworks/sproutcore/frameworks/runtime/tests/system/index_set/clone.js

@@ -0,0 +1,43 @@
+// ==========================================================================
+// 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 notest */
+var set ;
+module("SC.IndexSet#clone", {
+  setup: function() {
+    set = SC.IndexSet.create();
+  }
+});
+
+test("clone should return new object with same key properties", function() {
+  set.add(100,100).add(200,100);
+  set.source = "foo";
+  
+  var set2 = set.clone();
+  ok(set2 !== null, 'return value should not be null');
+  ok(set2 !== set, 'cloned set should not be same instance as set');
+  ok(set.isEqual(set2), 'set.isEqual(set2) should be true');
+  
+  equals(set2.get('length'), set.get('length'), 'clone should have same length');
+  equals(set2.get('min'), set.get('min'), 'clone should have same min');
+  equals(set2.get('max'), set.get('max'), 'clone should have same max');
+  equals(set2.get('source'), set.get('source'), 'clone should have same source');
+
+});
+
+test("cloning frozen object returns unfrozen", function() {
+  var set2 = set.freeze().clone();
+  equals(set2.get('isFrozen'), NO, 'set2.isFrozen should be NO');
+});
+
+test("copy works like clone", function() {
+  same(set.copy(), set, 'should return copy');
+  ok(set.copy() !== set, 'should not return same instance');
+  
+  set.freeze();
+  equals(set.frozenCopy(), set, 'should return same instance when frozen');
+});
+