sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

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

@@ -0,0 +1,313 @@
+// ========================================================================
+// SC.Set Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+var a, b, c ; // global variables
+
+module("creating SC.Set instances", {
+  
+  setup: function() {
+    // create objects...
+    a = { name: "a" } ;
+    b = { name: "b" } ;
+    c = { name: "c" } ;
+  },
+  
+  teardown: function() {
+    a = undefined ;
+    b = undefined ;
+    c = undefined ;
+  }
+  
+});
+
+test("new SC.Set() should create empty set", function() {
+  var set = new SC.Set() ;
+  equals(set.length, 0) ;
+});
+
+test("new SC.Set([1,2,3]) should create set with three items in them", function() {
+  var set = new SC.Set([a,b,c]) ;
+  equals(set.length, 3) ;
+  equals(set.contains(a), YES) ;
+  equals(set.contains(b), YES) ;
+  equals(set.contains(c), YES) ;
+});
+
+test("SC.Set.create() is an alias for new SC.Set()", function() {
+  var set = SC.Set.create() ;
+  equals(set.length, 0) ;
+  
+  var set = SC.Set.create([a,b,c]) ;
+  equals(set.length, 3) ;
+  equals(set.contains(a), YES) ;
+  equals(set.contains(b), YES) ;
+  equals(set.contains(c), YES) ;
+});
+
+test("new SC.Set() should accept anything that implements SC.Array", function() {
+  var arrayLikeObject = SC.Object.create(SC.Array, {
+    _content: [a,b,c],
+    length: 3,
+    objectAt: function(idx) { return this._content[idx]; } 
+  }) ;
+  
+  var set = SC.Set.create(arrayLikeObject) ;
+  equals(set.length, 3) ;
+  equals(set.contains(a), YES) ;
+  equals(set.contains(b), YES) ;
+  equals(set.contains(c), YES) ;
+});
+
+test("new SC.Set() should accept anything that looks like an array, even if it does not implement SC.Array", function() {
+  var arrayLikeObject = { length: 3, '0': a, '1': b, '2': c } ;
+  
+  var set = SC.Set.create(arrayLikeObject) ;
+  equals(set.length, 3) ;
+  equals(set.contains(a), YES) ;
+  equals(set.contains(b), YES) ;
+  equals(set.contains(c), YES) ;
+});
+
+var set ; // global variables
+
+// The tests below also end up testing the contains() method pretty 
+// exhaustively.
+module("SC.Set.add + SC.Set.contains", {
+  
+  setup: function() {
+    set = SC.Set.create() ;
+  },
+  
+  teardown: function() {
+    set = undefined ;
+  }
+  
+});
+
+test("should add an SC.Object", function() {
+  var obj = SC.Object.create() ;
+  
+  var oldLength = set.length ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES, "contains()") ;
+  equals(oldLength+1, set.length, "new set length") ;
+});
+
+test("should add a regular hash", function() {
+  var obj = {} ;
+  
+  var oldLength = set.length ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES, "contains()") ;
+  equals(oldLength+1, set.length, "new set length") ;
+});
+
+test("should add a string", function() {
+  var obj = "String!" ;
+  
+  var oldLength = set.length ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES, "contains()") ;
+  equals(oldLength+1, set.length, "new set length") ;
+});
+
+test("should add a number", function() {
+  var obj = 23 ;
+  
+  var oldLength = set.length ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES, "contains()") ;
+  equals(oldLength+1, set.length, "new set length") ;
+});
+
+test("should add a bool", function() {
+  var obj = true ;
+  
+  var oldLength = set.length ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES, "contains()") ;
+  equals(oldLength+1, set.length, "new set length") ;
+});
+
+test("should add a function", function() {
+  var obj = function() { return "Test function"; } ;
+  
+  var oldLength = set.length ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES, "contains()") ;
+  equals(oldLength+1, set.length, "new set length") ;
+});
+
+test("should NOT add a null", function() {
+  set.add(null) ;
+  equals(set.length, 0) ;
+  equals(set.contains(null), NO) ;
+});
+
+test("should NOT add an undefined", function() {
+  set.add(undefined) ;
+  equals(set.length, 0) ;
+  equals(set.contains(undefined), NO) ;
+});
+
+test("adding an item, removing it, adding another item", function() {
+  var item1 = "item1" ;
+  var item2 = "item2" ;
+
+  set.add(item1) ; // add to set
+  set.remove(item1) ; //remove from set
+  set.add(item2) ;
+  
+  equals(NO, set.contains(item1), "set.contains(item1)") ;
+  
+  set.add(item1) ; // re-add to set
+  equals(2, set.length, "set.length") ;
+});
+
+module("SC.Set.remove + SC.Set.contains", {
+  
+  // generate a set with every type of object, but none of the specific
+  // ones we add in the tests below...
+  setup: function() {
+    set = SC.Set.create([
+      SC.Object.create({ dummy: YES }),
+      { isHash: YES },
+      "Not the String",
+      16, false]) ;
+  },
+  
+  teardown: function() {
+    set = undefined ;
+  }
+  
+});
+
+test("should remove an SC.Object and reduce length", function() {
+  var obj = SC.Object.create() ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES) ;
+  var oldLength = set.length ;
+  
+  set.remove(obj) ;
+  equals(NO, set.contains(obj), "should be removed") ;
+  equals(oldLength-1, set.length, "should be 1 shorter") ;
+});
+
+test("should remove a regular hash and reduce length", function() {
+  var obj = {} ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES) ;
+  var oldLength = set.length ;
+  
+  set.remove(obj) ;
+  equals(NO, set.contains(obj), "should be removed") ;
+  equals(oldLength-1, set.length, "should be 1 shorter") ;
+});
+
+test("should remove a string and reduce length", function() {
+  var obj = "String!" ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES) ;
+  var oldLength = set.length ;
+  
+  set.remove(obj) ;
+  equals(NO, set.contains(obj), "should be removed") ;
+  equals(oldLength-1, set.length, "should be 1 shorter") ;
+});
+
+test("should remove a number and reduce length", function() {
+  var obj = 23 ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES) ;
+  var oldLength = set.length ;
+  
+  set.remove(obj) ;
+  equals(NO, set.contains(obj), "should be removed") ;
+  equals(oldLength-1, set.length, "should be 1 shorter") ;
+});
+
+test("should remove a bool and reduce length", function() {
+  var obj = true ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES) ;
+  var oldLength = set.length ;
+  
+  set.remove(obj) ;
+  equals(NO, set.contains(obj), "should be removed") ;
+  equals(oldLength-1, set.length, "should be 1 shorter") ;
+});
+
+test("should remove a function and reduce length", function() {
+  var obj = function() { return "Test function"; } ;
+  set.add(obj) ;
+  equals(set.contains(obj), YES) ;
+  var oldLength = set.length ;
+  
+  set.remove(obj) ;
+  equals(NO, set.contains(obj), "should be removed") ;
+  equals(oldLength-1, set.length, "should be 1 shorter") ;
+});
+
+test("should NOT remove a null", function() {
+  var oldLength = set.length ;
+  set.remove(null) ;
+  equals(oldLength, set.length) ;
+});
+
+test("should NOT remove an undefined", function() {
+  var oldLength = set.length ;
+  set.remove(undefined) ;
+  equals(oldLength, set.length) ;
+});
+
+test("should ignore removing an object not in the set", function() {
+  var obj = SC.Object.create() ;
+  var oldLength = set.length ;
+  set.remove(obj) ;
+  equals(oldLength, set.length) ;
+});
+
+// test("should remove all the elements in the set", function() {
+// 	var obj = [2,3,4];
+// 	set.add(obj) ;
+// 	var oldLength = set.length ;
+// 	equals(6, oldLength);
+// 	a = set.removeEach(obj);
+// 	equals(0, a.length);
+// });
+
+module("SC.Set.pop + SC.Set.clone", {
+// generate a set with every type of object, but none of the specific
+// ones we add in the tests below...
+	setup: function() {
+		set = SC.Set.create([
+			SC.Object.create({ dummy: YES }),
+			{ isHash: YES },
+			"Not the String",
+			16, false]) ;
+		},
+		
+		teardown: function() {
+			set = undefined ;
+		}
+});
+
+test("the pop() should remove an arbitrary object from the set", function() {
+	var oldLength = set.length ;
+	var obj = set.pop();
+	equals(SC.T_OBJECT,SC.typeOf(obj),'pops up an object');
+	equals(oldLength-1,set.length,'length shorter by 1');
+});
+
+test("the clone() should return an indentical set", function() {
+	var oldLength = set.length ;
+	var obj = set.clone();
+	equals(oldLength,obj.length,'length of the clone should be same');
+	equals(YES,obj.contains(set[0]));
+	equals(YES,obj.contains(set[1]));
+	equals(YES,obj.contains(set[2]));
+	equals(YES,obj.contains(set[3]));
+	equals(YES,obj.contains(set[4]));
+});

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

@@ -0,0 +1,84 @@
+// ========================================================================
+// 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") ;
+});

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

@@ -0,0 +1,13 @@
+// ==========================================================================
+// 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)
+// ==========================================================================
+
+// 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() {};

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/testsuite.css

@@ -0,0 +1,131 @@
+#qunit,
+#qunit div, 
+#qunit h1 { 
+  font-family: 'Helvetica Neue', 'Helvetica', 'Arial', verdana, sans-serif; 
+  margin: 0; 
+  padding: 0 
+}
+
+#qunit {
+  position: absolute;
+  top: 0;
+  left:0 ;
+  right: 0;
+  bottom: 0;
+  overflow: auto;
+  font-size: 10pt; 
+}
+
+#qunit h1 { 
+  padding: 15px; 
+  font-size: large; 
+  background-color: #06b; 
+  color: white; 
+}
+
+#qunit h1 a { color: white; }
+
+#qunit h2 { 
+  padding: 10px; 
+  background-color: #eee; 
+  color: black; 
+  margin: 0; 
+  font-size: small; 
+  font-weight: normal 
+}
+
+#qunit .pass { color: green; } 
+#qunit .fail { color: red; } 
+#qunit p.result { margin-left: 1em; }
+
+#qunit #banner { 
+  height: 2em; 
+  border-bottom: 1px solid white; 
+}
+
+#qunit h2.pass { background-color: green; }
+#qunit h2.fail { background-color: red; }
+
+#qunit div.testrunner-toolbar { 
+  background: #eee; 
+  border-top: 1px solid black; 
+  padding: 10px; 
+}
+
+#qunit ol#tests > li > strong { cursor:pointer; }
+
+#qunit div#fx-tests h4 { background: red; }
+
+#qunit div#fx-tests h4.pass { background: green; }
+
+#qunit div#fx-tests div.box {
+	background: red url(data/cow.jpg) no-repeat;
+	overflow: hidden;
+	border: 2px solid #000;
+}
+
+#qunit div#fx-tests div.overflow {
+	overflow: visible;
+}
+
+#qunit div.inline     { display: inline; }
+#qunit div.autoheight { height: auto; }
+#qunit div.autowidth  { width: auto; }
+#qunit div.autoopacity { opacity: auto; }
+#qunit div.largewidth { width: 100px; }
+#qunit div.largeheight { height: 100px; }
+#qunit div.largeopacity {
+	filter: progid:DXImageTransform.Microsoft.Alpha(opacity=100);
+}
+
+#qunit div.medwidth { width: 50px; }
+
+#qunit div.medheight { height: 50px; }
+#qunit div.medopacity {
+	opacity: 0.5;
+	filter: progid:DXImageTransform.Microsoft.Alpha(opacity=50);
+}
+
+#qunit div.nowidth {
+	width: 0px;
+}
+
+#qunit div.noheight {
+	height: 0px;
+}
+
+#qunit div.noopacity {
+	opacity: 0;
+	filter: progid:DXImageTransform.Microsoft.Alpha(opacity=0);
+}
+
+#qunit div.hidden {
+	display: none;
+}
+
+div#fx-tests div.widewidth {
+	background-repeat: repeat-x;
+}
+
+div#fx-tests div.wideheight {
+	background-repeat: repeat-y;
+}
+
+div#fx-tests div.widewidth.wideheight {
+	background-repeat: repeat;
+}
+
+div#fx-tests div.noback {
+	background-image: none;
+}
+
+div.chain, div.chain div { width: 100px; height: 20px; position: relative; float: left; }
+div.chain div { position: absolute; top: 0px; left: 0px; }
+
+div.chain.test { background: red; }
+div.chain.test div { background: green; }
+
+div.chain.out { background: green; }
+div.chain.out div { background: red; display: none; }
+
+div#show-tests * { display: none; }

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

@@ -0,0 +1,43 @@
+// ==========================================================================
+// 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)
+// ==========================================================================
+
+/*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. 
+*/
+function notest(name, callback, nowait) {
+  
+}
+