sproutit-sproutcore 1.0.20090721145236 → 1.0.20090721145251

data/frameworks/sproutcore/frameworks/foundation/tests/system/routes.js

@@ -0,0 +1,33 @@
+// ========================================================================
+// SC.routes Base Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+var imgUrl,obj;
+module("SC.routes", {
+  
+  setup: function() {
+    
+	url = sc_static("file_exists.json"); 
+    request = SC.Request.getUrl(url) ;
+		
+	obj = SC.Object.create({			
+		name:'Test SproutCore',
+		imageDidLoad:function(){
+		 this.name = 'SproutCore';
+		}
+	});
+  },
+  
+  teardown: function() {
+
+  }
+  
+});
+
+// test("adding routes ", function() {
+//  SC.routes.add(':', obj, 'imageDidLoad');
+//  request.send() ;
+// });
+
+

data/frameworks/sproutcore/frameworks/foundation/tests/system/timer/invalidate.js

@@ -0,0 +1,38 @@
+// ========================================================================
+// SC.Timer Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+/**
+  Exercises timer invalidation on the SC.Timer class.
+*/
+module("Timer.invalidate") ;
+
+/**
+  A timer scheduled and then invalidated before the end of the run loop should 
+  not fire.
+  
+  @author Erich Ocean
+  @since 6e7becdfb4e7f22b340eb5e6d7f3b4df4ea65060
+*/
+test("invalidate immediately should never execute", function() {
+  
+  var fired = NO ;
+  
+  SC.RunLoop.begin() ;
+  var start = SC.RunLoop.currentRunLoop.get('startTime') ;
+  var t = SC.Timer.schedule({
+    target: this,
+    action: function() { fired = YES ; },
+    interval: 100
+  });
+  t.invalidate() ;
+  SC.RunLoop.end() ;
+  
+  stop(2500) ; // stops the test runner, fails after 2500ms
+  setTimeout(function() {
+    equals(NO, fired) ;
+    window.start() ; // starts the test runner
+  }, 1500);
+  
+});

data/frameworks/sproutcore/frameworks/foundation/tests/system/timer/invokeLater.js

@@ -0,0 +1,201 @@
+// ========================================================================
+// SC.Object.invokeLater Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+module("SC.Object.invokeLater") ;
+
+test("should invoke method string after specified time", function() {
+  SC.RunLoop.begin() ;
+  var fired = NO ;
+  var o = SC.Object.create({
+    func: function() { fired = YES; }
+  });
+  o.invokeLater('func', 200) ;
+  SC.RunLoop.end() ;
+  
+  var tries = 20 ;
+  var f = function f() {
+    if (!fired && --tries >= 0) {
+      setTimeout(f, 100) ;
+      return ;
+    }
+    equals(YES, fired, 'did not fire') ;
+    window.start() ; // starts the test runner
+  } ;
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 300) ;
+});
+
+test("should invoke method instance after specified time", function() {
+  SC.RunLoop.begin() ;
+  var fired = NO ;
+  var o = SC.Object.create({
+    func: function() { fired = YES; }
+  });
+  o.invokeLater(o.func, 200) ;
+  SC.RunLoop.end() ;
+  
+  var tries = 20 ;
+  var f = function f() {
+    if (!fired && --tries >= 0) {
+      setTimeout(f, 100) ;
+      return ;
+    }
+    equals(YES, fired, 'did not fire') ;
+    window.start() ; // starts the test runner
+  } ;
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 300) ;
+});
+
+test("should invoke method string immediately if no time passed", function() {
+  SC.RunLoop.begin() ;
+  var fired = NO ;
+  var o = SC.Object.create({
+    func: function() { fired = YES; }
+  });
+  o.invokeLater('func') ;
+  SC.RunLoop.end() ;
+  
+  var tries = 20 ;
+  var f = function f() {
+    if (!fired && --tries >= 0) {
+      setTimeout(f, 100) ;
+      return ;
+    }
+    equals(YES, fired, 'did not fire') ;
+    window.start() ; // starts the test runner
+  } ;
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 300) ;
+});
+
+test("should automatically bind with arguments if passed", function() {
+  SC.RunLoop.begin() ;
+  var fired = NO ;
+  var g1 = null, g2 = null ;
+  
+  var o = SC.Object.create({
+    func: function(arg1, arg2) { 
+      g1 = arg1 ; g2 = arg2 ; fired = YES ; 
+    }
+  });
+  o.invokeLater('func', 200, 'ARG1', 'ARG2') ;
+  SC.RunLoop.end() ;
+  
+  var tries = 20 ;
+  var f = function f() {
+    if (!fired && --tries >= 0) {
+      setTimeout(f, 100) ;
+      return ;
+    }
+    equals(YES, fired, 'did not fire') ;
+    equals(g1, 'ARG1', 'arg1') ;
+    equals(g2, 'ARG2', 'arg2') ;
+    window.start() ; // starts the test runner
+  } ;
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 300) ;
+});
+
+module("Function.invokeLater") ;
+
+test("should invoke function with target after specified time", function() {
+  SC.RunLoop.begin() ;
+  var fired = NO ;
+  var target = null;
+  var o = SC.Object.create() ;
+  var func = function() { fired = YES; target = this; } ; 
+  func.invokeLater(o, 200) ;
+  SC.RunLoop.end() ;
+  
+  var tries = 20 ;
+  var f = function f() {
+    if (!fired && --tries >= 0) {
+      setTimeout(f, 100) ;
+      return ;
+    }
+    equals(YES, fired, 'did not fire') ;
+    equals(target, o, 'target') ;
+    window.start() ; // starts the test runner
+  } ;
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 300) ;
+});
+
+test("should invoke object with no target after specified time", function() {
+  SC.RunLoop.begin() ;
+  var fired = NO ;
+  var func = function() { fired = YES; } ; 
+  func.invokeLater(null, 200) ;
+  SC.RunLoop.end() ;
+  
+  var tries = 20 ;
+  var f = function f() {
+    if (!fired && --tries >= 0) {
+      setTimeout(f, 100) ;
+      return ;
+    }
+    equals(YES, fired, 'did not fire') ;
+    window.start() ; // starts the test runner
+  } ;
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 300) ;
+});
+
+test("should invoke function immediately if no time passed", function() {
+  SC.RunLoop.begin() ;
+  var fired = NO ;
+  var o = SC.Object.create() ;
+  var func = function() { fired = YES; } ; 
+  func.invokeLater(o) ;
+  SC.RunLoop.end() ;
+  
+  var tries = 20 ;
+  var f = function f() {
+    if (!fired && --tries >= 0) {
+      setTimeout(f, 100) ;
+      return ;
+    }
+    equals(YES, fired, 'did not fire') ;
+    window.start() ; // starts the test runner
+  } ;
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 300) ;
+});
+
+test("should automatically bind with arguments if passed", function() {
+  SC.RunLoop.begin() ;
+  var fired = NO ;
+  var g1 = null, g2 = null ;
+  
+  var o = SC.Object.create() ;
+  var func = function(arg1, arg2) { 
+    g1 = arg1 ; g2 = arg2 ; fired = YES ; 
+  } ; 
+  func.invokeLater(o, 200, 'ARG1', 'ARG2') ;
+  SC.RunLoop.end() ;
+  
+  var tries = 20 ;
+  var f = function f() {
+    if (!fired && --tries >= 0) {
+      setTimeout(f, 100) ;
+      return ;
+    }
+    equals(YES, fired, 'did not fire') ;
+    equals(g1, 'ARG1', 'arg1') ;
+    equals(g2, 'ARG2', 'arg2') ; 
+    window.start() ; // starts the test runner
+  } ;
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 300) ;
+});

data/frameworks/sproutcore/frameworks/foundation/tests/system/timer/isPaused.js

@@ -0,0 +1,71 @@
+// ========================================================================
+// SC.Timer.isPaused Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+module("Timer.isPaused") ;
+
+test("setting isPaused should stop firing", function() {
+  
+  var firedCount = 0 ;
+  
+  SC.RunLoop.begin() ;
+  var start = SC.RunLoop.currentRunLoop.get('startTime') ;
+  var t = SC.Timer.schedule({
+    target: this,
+    action: function() { firedCount++ ; },
+    interval: 100,
+    repeats: YES
+  });
+  SC.RunLoop.end() ;
+  
+  // wait for timer to fire twice, then pause it.
+  var tries1 = 10 ;
+  var f1 = function f1() {
+    if(firedCount<2) {
+      if (--tries1 >= 0) {
+        setTimeout(f1, 100) ;
+      } else {
+        equals(NO, YES, 'Timer never fired 2 times - f1') ;
+        window.start() ; // starts the test runner
+      }
+    } else {
+      equals(NO, t.get('isPaused'), 'should start with isPaused = NO');
+      t.set('isPaused', YES) ;
+      firedCount = 0 ; // Reset count here.
+      setTimeout(f2, 300) ;
+    }
+  };
+  
+  // once timer paused, make sure it did not fire again.
+  var f2 = function f2() {
+    equals(0, firedCount, 'timer kept firing!') ;
+    equals(YES, t.get('isPaused'), 'timer is not paused') ;
+    t.set('isPaused', NO) ;
+    setTimeout(f3, 300) ;
+  } ;
+  
+  // once timer has verified paused, unpause and make sure it fires again.
+  var tries2 = 10 ;
+  var f3 = function f3() {
+    if (firedCount <= 2) {
+      if (--tries2 >= 0) {
+        setTimeout(f3, 100) ;
+      } else {
+        equals(NO, YES, "Timer did not resume") ;
+        window.start() ; // starts the test runner
+      }
+      
+    // timer fired, clean up.
+    } else {
+      t.invalidate() ;
+      equals(NO, t.get('isPaused'), 'timer did not unpause') ;
+      window.start() ; // starts the test runner
+    }
+  };
+  
+  stop() ; // stops the test runner
+  setTimeout(f1, 300) ;
+});
+
+// using invalidate on a repeating timer is tested in schedule().

data/frameworks/sproutcore/frameworks/foundation/tests/system/timer/performAction.js

@@ -0,0 +1,67 @@
+// ========================================================================
+// SC.Timer Base Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+module("SC.Timer.fireTime + SC.Timer.performAction ",{
+  	setup: function() {
+    	objectA = {} ;
+    	objectB = {} ;
+		
+		object = SC.Object.create({			
+			performActionProp:'',
+		  	callAction:function(){
+		    	this.set('performActionProp','performAction');
+		    }	
+		});	
+  	}
+
+});
+
+test("performAction() should call the specified method ",function(){
+	var timerObj;
+    timerObj = SC.Timer.create(); //created a timer object
+ 	timerObj.action = object.callAction();	
+	timerObj.performAction();
+	equals('performAction',object.performActionProp);
+});
+
+
+
+test("fireTime() should return the next time the timer should fire", function(){
+	var timerObj;	
+	
+	timerObj = SC.Timer.create();
+
+	equals(-1,timerObj.fireTime(),'for isValid YES');	
+	equals(-1,timerObj.fireTime(),'for startTime not set');	
+	
+	timerObj.startTime = 10;
+	timerObj.interval = 10;	
+	timerObj.lastFireTime = 5;
+	equals(20,timerObj.fireTime(),'next fire time');	
+	
+});
+
+test("fire() should call the action", function() {
+	var count = 0;
+	SC.RunLoop.begin() ;
+	var start = SC.RunLoop.currentRunLoop.get('startTime') ;
+	var t = SC.Timer.schedule({
+		target: this,
+		action: function() {
+			count++;
+		},
+		interval: 100
+	});
+	t.fire();
+	SC.RunLoop.end() ;
+	stop(2500) ; // stops the test runner, fails after 2500ms
+	setTimeout(function() {
+		equals(2, count) ;
+		window.start() ; // starts the test runner
+		}, 1500);
+});
+
+
+

data/frameworks/sproutcore/frameworks/foundation/tests/system/timer/schedule.js

@@ -0,0 +1,170 @@
+// ========================================================================
+// SC.Timer.schedule() Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+module("Timer.schedule single timer") ;
+
+test("single timer should execute once and invalidate", function() {
+  var fired = [] ;
+  
+  SC.RunLoop.begin() ;
+  var start = SC.RunLoop.currentRunLoop.get('startTime') ;
+  var t = SC.Timer.schedule({
+    target: this,
+    action: function() { fired.push(Date.now()); },
+    interval: 100, 
+    repeats: NO
+  });
+  SC.RunLoop.end() ;
+  
+  var checks = 10 ;
+  var f = function f() {
+    
+    if (fired.length === 0 && --checks > 0) {
+      // wait(100, f);
+      setTimeout(f, 100) ; 
+      return ;
+    }
+    
+    // should only fire once
+    equals(1, fired.length, 'fired count') ;
+    
+    // timer should no longer be valid
+    equals(NO, t.get('isValid'), 'isValid');
+    
+    window.start() ; // starts the test runner
+  } ;
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 300) ;
+});
+
+test("repeating timer with no limit should repeat until terminated", function() {
+  var fired = [] ;
+  
+  // schedule repeating timer
+  SC.RunLoop.begin() ;
+  var start = SC.RunLoop.currentRunLoop.get('startTime') ;
+  var runs = 4 ;
+  
+  var t = SC.Timer.schedule({
+    target: this,
+    action: function() { 
+      fired.push(Date.now()); 
+      if (--runs <= 0) t.invalidate(); 
+    },
+    interval: 100, 
+    repeats: YES
+  });
+  SC.RunLoop.end() ;
+  
+  // We can't gaurantee when timeouts will execute in the browser so we 
+  // have to be a little flexible about testing repeated loops like this.
+  var checks = 10 ;
+  var f = function f() {
+    
+    if (--checks < 0) {
+      window.start();
+      equals(YES, NO, 'Check Count Exceeded') ;
+    }
+    
+    if (runs > 0) {
+      // wait(100, f) ; // wait until timer fires 4 times.
+      setTimeout(f, 100) ;
+    } else {
+      var diffs = fired.map(function(x) { return x - start; });
+      equals(4, fired.length, 'fired count: %@'.fmt(diffs.join(', '))) ;
+      equals(NO, t.get('isValid'), 'isValid') ;
+      window.start() ; // starts the test runner
+    }
+  };
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 600) ;
+});
+
+test("repeating timer should terminate after expiration", function() {
+  var fired = [] ;
+  
+  // schedule repeating timer
+  SC.RunLoop.begin() ;
+  var start = SC.RunLoop.currentRunLoop.get('startTime') ;
+  var runs = 4 ;
+  
+  var t = SC.Timer.schedule({
+    target: this,
+    action: function() { 
+      fired.push(Date.now()); 
+    },
+    interval: 100, 
+    repeats: YES,
+    until: start + 500
+  });
+  SC.RunLoop.end() ;
+  
+  // We can't gaurantee when timeouts will execute in the browser so we 
+  // have to be a little flexible about testing repeated loops like this.
+  var checks = 10 ;
+  var f = function f() {
+    if (--checks < 0) {
+      window.start();
+      equals(YES, NO, 'Timer never invalidated :') ;
+    }
+    
+    if ((checks > 0) && t.get('isValid')) {
+      //wait(100, f);
+      setTimeout(f, 100) ;
+    } else {
+      var diffs = fired.map(function(x) { return x - start; });
+      equals(NO, t.get('isValid'), 'Timer did not terminate: %@'.fmt(diffs.join(', '))) ;
+      window.start() ; // starts the test runner
+    }
+  };
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 600) ;
+});
+
+test("scheduling multiple timers at the same time should cause them to fire at same time", function() {
+  
+  var f1 = 0; var f2 = 0;
+  SC.RunLoop.begin() ;
+  var start = SC.RunLoop.currentRunLoop.get('startTime') ;
+  
+  var t1 = SC.Timer.schedule({
+    target: this, 
+    action: function() { 
+      f1 = SC.RunLoop.currentRunLoop.get('startTime'); 
+    },
+    interval: 100
+  });
+  
+  var t2 = SC.Timer.schedule({
+    target: this, 
+    action: function() { 
+      f2 = SC.RunLoop.currentRunLoop.get('startTime'); 
+    },
+    interval: 100
+  });
+
+  SC.RunLoop.end();
+  
+  // be lenient on execution time since we can't control the browser.
+  var tries = 10 ;
+  var f = function f() {
+    if ((f1 === 0 || f2 === 0) && --tries >= 0) {
+      // wait(100, f) ;
+      setTimeout(f, 100) ;
+      return ;
+    }
+    
+    equals(f1, f2, 'execution time f1 == f2');
+    equals(NO, t1.get('isValid'), 't1.isValid') ;
+    equals(NO, t2.get('isValid'), 't2.isValid') ;
+    window.start() ; // starts the test runner
+  } ;
+  
+  stop() ; // stops the test runner
+  setTimeout(f, 200) ;
+});