sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

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

@@ -81,4 +81,42 @@ test("element to be added is at idx > length of array ", function() {
 	ary = numbers;
 	ary.replace(2,3,new_numbers,"put the new number overlapping existing numbers ");
 	equals(5, ary.get('length'), "length") ;
-});
+});
+
+
+// ..........................................................
+// TEST SC.ARRAY COMPLIANCE
+// 
+
+var DummyDelegate = SC.Object.extend({
+  content: [], // source array
+
+  sparseArrayDidRequestLength: function(sparseArray) {
+    sparseArray.provideLength(this.content.length);
+  },
+  
+  sparseArrayDidRequestIndex: function(sparseArray, index) {
+    sparseArray.provideObjectAtIndex(index, this.content[index]);
+  },
+  
+  sparseArrayDidRequestIndexOf: function(sparseArray, object) {
+    return this.content.indexOf(object);    
+  },
+  
+  sparseArrayShouldReplace: function(sparseArray, idx, amt, objects) {
+    this.content.replace(idx, amt, objects) ; // keep internal up-to-date
+    return YES ; // allow anything
+  }
+  
+});
+
+SC.ArraySuite.generate("SC.SparseArray", {
+  newObject: function(amt) {
+    if (amt === undefined || typeof amt === SC.T_NUMBER) {
+      amt = this.expected(amt);
+    }
+
+    var del = DummyDelegate.create({ content: amt });
+    return SC.SparseArray.create({ delegate: del });
+  }
+});

data/frameworks/sproutcore/frameworks/testing/core.js

@@ -4,6 +4,7 @@
 //            Portions ©2008-2009 Apple, Inc. All rights reserved.
 // License:   Licened under MIT license (see license.js)
 // ==========================================================================
+/*globals CoreTest */
 
 // these compiler directives are normally defined in runtime's core.  But
 // since the testing framework needs to be totally independent, we redefine
@@ -11,3 +12,185 @@
 var require = require || function sc_require() {};
 var sc_require = sc_require || require;
 var sc_resource = sc_resource || function sc_resource() {};
+
+/** @namespace
+
+  CoreTest is the unit testing library for SproutCore.  It includes a test 
+  runner based on QUnit with some useful extensions for testing SproutCore-
+  based applications.
+  
+  You can use CoreTest just like you would use QUnit in your tests directory.
+*/
+CoreTest = {
+  
+  /** 
+    Empty function.  Useful for some operations. 
+  */
+  K: function() { return this; },
+
+  /**
+    Copied from SproutCore Runtime Core.  Included here to avoid dependencies.
+
+    @param obj {Object} the object to beget
+    @returns {Object} the new object.
+  */
+  beget: function(obj) {
+    if (!obj) return null ;
+    var K = CoreTest.K; K.prototype = obj ;
+    var ret = new K();
+    K.prototype = null ; // avoid leaks
+    return ret ;
+  },
+  
+  /**
+    Copied from SproutCore Runtime Core.  Included here to avoid dependencies.
+
+    @param target {Object} the target object to extend
+    @param properties {Object} one or more objects with properties to copy.
+    @returns {Object} the target object.
+    @static
+  */
+  mixin: function() {
+    // copy reference to target object
+    var target = arguments[0] || {};
+    var idx = 1;
+    var length = arguments.length ;
+    var options ;
+
+    // Handle case where we have only one item...extend CoreTest
+    if (length === 1) {
+      target = this || {};
+      idx=0;
+    }
+
+    for ( ; idx < length; idx++ ) {
+      if (!(options = arguments[idx])) continue ;
+      for(var key in options) {
+        if (!options.hasOwnProperty(key)) continue ;
+        var src = target[key];
+        var copy = options[key] ;
+        if (target===copy) continue ; // prevent never-ending loop
+        if (copy !== undefined) target[key] = copy ;
+      }
+    }
+
+    return target;
+  },
+  
+  
+  /** Borrowed from SproutCore Runtime Core */
+  fmt: function(str) {
+    // first, replace any ORDERED replacements.
+    var args = arguments;
+    var idx  = 1; // the current index for non-numerical replacements
+    return str.replace(/%@([0-9]+)?/g, function(s, argIndex) {
+      argIndex = (argIndex) ? parseInt(argIndex,0) : idx++ ;
+      s =args[argIndex];
+      return ((s===null) ? '(null)' : (s===undefined) ? '' : s).toString(); 
+    }) ;
+  },
+  
+  /**
+    Returns a stub function that records any passed arguments and a call
+    count.  You can pass no parameters, a single function or a hash.  
+    
+    If you pass no parameters, then this simply returns a function that does 
+    nothing but record being called.  
+    
+    If you pass a function, then the function will execute when the method is
+    called, allowing you to stub in some fake behavior.
+    
+    If you pass a hash, you can supply any properties you want attached to the
+    stub function.  The two most useful are "action", which is the function 
+    that will execute when the stub runs (as if you just passed a function), 
+    and "expect" which should evaluate the stub results.
+    
+    In your unit test you can verify the stub by calling stub.expect(X), 
+    where X is the number of times you expect the function to be called.  If
+    you implement your own test function, you can actually pass whatever you
+    want.
+    
+    Calling stub.reset() will reset the record on the stub for further 
+    testing.
+
+    @param {String} name the name of the stub to use for logging
+    @param {Function|Hash} func the function or hash
+    @returns {Function} stub function
+  */
+  stub: function(name, func) {  
+
+    // normalize param
+    var attrs = {};
+    if (typeof func === "function") {
+      attrs.action = func;
+    } else if (typeof func === "object") {
+      attrs = func ;
+    }
+
+    // create basic stub
+    var ret = function() {
+      ret.callCount++;
+      
+      // get arguments into independent array and save in history
+      var args = [], loc = arguments.length;
+      while(--loc >= 0) args[loc] = arguments[loc];
+      args.unshift(this); // save context
+      ret.history.push(args);
+      
+      return ret.action.apply(this, arguments);
+    };
+    ret.callCount = 0 ;
+    ret.history = [];
+    ret.stubName = name ;
+
+    // copy attrs
+    var key;
+    for(key in attrs) {
+      if (!attrs.hasOwnProperty(key)) continue ;
+      ret[key] = attrs[key];
+    }
+
+    // add on defaults
+    if (!ret.reset) {
+      ret.reset = function() {
+        this.callCount = 0;
+        this.history = [];
+      };
+    }
+    
+    if (!ret.action) {
+      ret.action = function() { return this; };
+    }
+    
+    if (!ret.expect) {
+      ret.expect = function(callCount) {
+        if (callCount === YES) {
+          ok(this.callCount > 0, CoreTest.fmt("%@ should be called at least once", this.stubName));
+        } else {
+          if (callCount === NO) callCount = 0;
+          equals(this.callCount, callCount, CoreTest.fmt("%@ should be called X times", this.stubName));
+        }
+      };
+    }
+    
+    return ret ;
+  },
+  
+
+  /** Test is OK */
+  OK: 'passed',
+  
+  /** Test failed */
+  FAIL: 'failed',
+  
+  /** Test raised exception */
+  ERROR: 'errors',
+  
+  /** Test raised warning */
+  WARN: 'warnings',
+  
+  showUI : false
+  
+  
+  
+};

data/frameworks/sproutcore/frameworks/testing/english.lproj/runner.css

@@ -0,0 +1,126 @@
+.core-test {
+  font: 12px/16px "Helvetica", Verdana, Arial, sans-serif;
+  margin: 0;
+  padding: 0;
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  auto: 0;
+}
+  
+.core-test .useragent {
+  border-bottom: 1px solid #000;
+  font: 10pt "Helvetica", Verdana, Arial, sans-serif;
+  height: 15px;
+}
+
+.core-test .testresult {
+  background: rgb(238, 238, 238);
+  border-bottom: 1px solid #bbb;
+  font-weight: bold;
+  margin: 0;
+  padding: 6px;
+  text-align: right;
+  position: relative;
+}
+
+.testresult label.hide-passed {
+  position: absolute;
+  display: block;
+  margin: 0;
+  padding: 0;
+  left: 20px;
+  height: 14px;
+  top: 50%;
+  margin-top: -8px;
+}
+
+.testresult label.hide-passed.disabled {
+  color: #aaa;
+}
+
+.testresult em {
+  display: block;
+  font-weight: normal;
+  font-style: normal;
+}
+
+.testresult em span {
+  border: 1px solid #666;
+  display: inline-block;
+  font-weight: bold;
+  padding: 2px 4px;
+}
+
+.core-test tbody th {
+    text-align: left;
+    min-width: 300px;
+  }
+
+.core-test .detail {
+  padding: 20px;
+}
+
+.core-test table {
+  background: #000;
+  border-spacing: 1px;
+  width: 100%;
+}
+
+.core-test .hide-clean tr.clean {
+  display: none;
+}
+
+.core-test table td,
+.core-test table th {
+    background: #fff;
+    padding: 4px;
+  }
+
+.core-test tbody td {
+  text-align: center;
+  padding: 8px;
+}
+
+.core-test th em {
+  display: block;
+  font-weight: normal;
+  font-size: 10px;
+  font-style: normal;
+}
+
+.core-test thead th:first-child {
+  text-align: left;
+}
+
+.core-test .warnings {
+  background: #E49723;
+}
+
+.core-test .passed {
+  background: #80D175;
+}
+
+.core-test .failed {
+  background: #ea4d44;
+}
+
+.core-test .errors {
+  background: red;
+  color: #fff;
+}
+
+.core-test tr.test th {
+  background: #454545;
+  color: #fff;
+  font-size: 12px;
+  padding: 2px 4px;
+  text-align: right;
+}
+
+.core-test td.desc,
+.core-test th.desc {
+  text-align: left;
+  width: 90%;
+}

data/frameworks/sproutcore/frameworks/testing/extras.js

@@ -8,32 +8,6 @@
 /*global Q$ synchronize */
 // additional methods for use with qunit
 
-/**
-  Converts the passed string into HTML and then appends it to the main body 
-  element.  This is a useful way to automatically load fixture HTML into the
-  main page.
-*/
-function htmlbody(string) {
-  synchronize(function() {
-    var html = Q$(string) ;
-    var body = Q$('body')[0];
-    
-    // first, find the first element with id 'htmlbody-begin'  if exists,
-    // remove everything after that to reset...
-    var begin = Q$('body #htmlbody-begin')[0];
-    if (!begin) {
-      begin = Q$('<div id="htmlbody-begin"></div>')[0];
-      body.appendChild(begin);
-    } else {
-      while(begin.nextSibling) body.removeChild(begin.nextSibling);
-    }
-    begin = null; 
-    
-    // now append new content
-    html.each(function() { body.appendChild(this); });
-  }) ;
-}
-
 /**
   Call this method instead of test() to temporarily disable a test. 
 */

data/frameworks/sproutcore/frameworks/testing/qunit.js

@@ -260,24 +260,24 @@ $.extend(window, {
 
 $(window).load(function() {
   
-  if ($('#qunit').length === 0) {
-    $('body').append($('<div id="qunit"></div>'));
-  }
-  
-  if($('#userAgent').length == 0) {
-    $('#qunit').append($('<div id="userAgent"></div>'));
-  }
-
-  if ($('#tests').length == 0) {
-    $('#qunit').append($('<ol id="tests"></ol>')) ;
-  }
-  
-	$('#userAgent').html(navigator.userAgent);
-	var head = $('<div class="testrunner-toolbar"><label for="filter">Hide passed tests</label></div>').insertAfter("#userAgent");
-	$('<input type="checkbox" id="filter" />').attr("disabled", true).prependTo(head).click(function() {
-		$('li.pass')[this.checked ? 'hide' : 'show']();
-	});
-	runTest();	
+  //   if ($('#qunit').length === 0) {
+  //     $('body').append($('<div id="qunit"></div>'));
+  //   }
+  //   
+  //   if($('#userAgent').length == 0) {
+  //     $('#qunit').append($('<div id="userAgent"></div>'));
+  //   }
+  // 
+  //   if ($('#tests').length == 0) {
+  //     $('#qunit').append($('<ol id="tests"></ol>')) ;
+  //   }
+  //   
+  // $('#userAgent').html(navigator.userAgent);
+  // var head = $('<div class="testrunner-toolbar"><label for="filter">Hide passed tests</label></div>').insertAfter("#userAgent");
+  // $('<input type="checkbox" id="filter" />').attr("disabled", true).prependTo(head).click(function() {
+  //  $('li.pass')[this.checked ? 'hide' : 'show']();
+  // });
+	//runTest();	
 });
 
 function synchronize(callback) {
@@ -538,12 +538,9 @@ function isSet(a, b, msg) {
 		for ( var i = 0; i < a.length; i++ )
 			if ( a[i] != b[i] )
 				ret = false;
-	} else
-		ret = false;
-	config.assertions.push({
-		result: ret,
-		message: !ret ? (msg + " expected: " + serialArray(b) + " result: " + serialArray(a)) : msg
-	});
+	} else ret = false;
+		
+	window.ok(ret, a, b, msg);
 }
 
 /**
@@ -591,7 +588,18 @@ function t(a,b,c) {
 	var s = "";
 	for ( var i = 0; i < f.length; i++ )
 		s += (s && ",") + '"' + f[i].id + '"';
-	isSet(f, q.apply(q,c), a + " (" + b + ")");
+
+	var a1 = a, b1 = b;
+	var ret = true;
+	
+	a = f ;
+	b = q.apply(q,c);
+	if ( a && b && a.length != undefined && a.length == b.length ) {
+		for ( var i = 0; i < a.length; i++ ) {
+			if ( a[i] != b[i] ) ret = false;
+		}
+	} else ret = false;
+	window.ok(ret, a, b, a1 + " (" + b1 + ")");
 }
 
 /**