sproutit-sproutcore 1.0.20090721145236 → 1.0.20090721145251

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

@@ -0,0 +1,122 @@
+// ========================================================================
+// SC.SparseArray Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+var objectA = 23, objectB = 12, objectC = 31, numbers, new_numbers;
+module("SC.SparseArray") ;
+
+test("new SparseArray has expected length", function() {
+  var ary = SC.SparseArray.array(10000) ;
+  equals(10000, ary.get('length'), "length") ;
+});
+
+test("fetching the object at index", function() {
+	var ary = SC.SparseArray.create(10);
+	var arr = ["I'll","be","there","4u"];
+	ary = arr;
+	equals(2 ,ary.indexOf('there'), "Index of 'there' is");
+});
+
+test("creating a clone of a sparse array", function() {
+	var ary = SC.SparseArray.create(6);
+	// var arr = ["captain","crash","and the","beauty","queen","from Mars"];
+	// 	ary = arr;
+	// ary.provideObjectAtIndex(0, "captain");
+	// ary.provideObjectAtIndex(1, "crash");
+	// ary.provideObjectAtIndex(2, "and the");
+	// ary.provideObjectAtIndex(3, "beauty");
+	// ary.provideObjectAtIndex(4, "queen");
+	// ary.provideObjectAtIndex(5, "from Mars");
+	// var cpy = ary.clone(); alert(cpy);
+});
+
+test("Update the sparse array using provideObjectAtIndex", function() {
+	var ary = SC.SparseArray.create(2);
+	var obj = "not";
+	ary.provideObjectAtIndex(0, obj);
+	equals(obj, ary._sa_content[0],"Content at 0th index");
+	obj = "now";
+	ary.provideObjectAtIndex(1, obj);
+	equals(obj, ary._sa_content[1],"Content at 1st index");
+});
+
+test("objectAt() should get the object at the specified index",function() {
+	var spArray = SC.SparseArray.create(4) ;
+	var arr = [SC.Object.create({ dummy: YES }),"Sproutcore",2,true];
+	spArray = arr;
+	equals(4,spArray.length,'the length');
+	equals(arr[0],spArray.objectAt(0),'first object');
+	equals(arr[1],spArray.objectAt(1),'second object');
+	equals(arr[2],spArray.objectAt(2),'third object');
+	equals(arr[3],spArray.objectAt(3),'fourth object');
+});
+
+module("SC.replace",{
+	setup: function() {
+		// create objects...
+		numbers= [1,2,3] ;
+		new_numbers = [4,5,6];
+	}
+});
+
+test("element to be added is at idx > length of array ", function() {
+	var ary = SC.SparseArray.array(5) ;
+	equals(5, ary.get('length'), "length") ;
+	ary = numbers;
+	ary.replace(7,3,new_numbers,"put the new number at idx>len ");
+	equals(6, ary.get('length'), "length") ;
+});
+
+test("element to be added is such that amt + idx > length of array ", function() {
+	var ary = SC.SparseArray.array(5) ;
+	equals(5, ary.get('length'), "length") ;
+	ary = numbers;
+	ary.replace(4,3,new_numbers,"put the new number at idx < len ");
+	equals(6, ary.get('length'), "length") ;
+});
+
+test("element to be added is at idx > length of array ", function() {
+	var ary = SC.SparseArray.array(5) ;
+	equals(5, ary.get('length'), "length") ;
+	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

@@ -0,0 +1,196 @@
+// ==========================================================================
+// Project:   SproutCore Unit Testing 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)
+// ==========================================================================
+/*globals CoreTest */
+
+// these compiler directives are normally defined in runtime's core.  But
+// since the testing framework needs to be totally independent, we redefine
+// them here also.
+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/additions.css

@@ -0,0 +1,8 @@
+/* Move test result to top of page where it is easier to see */
+#testresult {
+  position: absolute;
+  top: 19px;
+  right: 10px;
+  text-align: right;
+  font-weight:bold;
+}

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%;
+}