spade 0.0.1

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

@@ -0,0 +1,49 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2010 Apple Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/*global module test equals context ok same */
+var set ;
+module("SC.IndexSet#addEach", {
+  setup: function() {
+    set = SC.IndexSet.create().add(1000,2).add(1010).add(1020).add(1030);
+  }
+});
+
+function iter(s) {
+  var ret = [];
+  set.forEach(function(k) { ret.push(k); });
+  return ret ;
+}
+
+// ..........................................................
+// BASIC ADDS
+// 
+
+test("should iterate over an array", function() {
+  set.removeEach([1000, 1010, 1020, 1030]);
+  equals(set.get('length'), 1, 'should have correct index count');  
+  equals(set.get('max'), 1002, 'max should return 1 past last index');
+  same(iter(set), [1001]);
+});
+
+test("adding should iterate over a set", function() {
+  // add out of order...
+  var input = SC.Set.create().add(1030).add(1010).add(1020).add(1000);
+  set.removeEach(input);
+  equals(set.get('length'), 1, 'should have correct index count');  
+  equals(set.get('max'), 1002, 'max should return 1 past last index');
+  same(iter(set), [1001]);
+});
+
+
+test("adding should iterate over a indexset", function() {
+  // add out of order...
+  var input = SC.IndexSet.create().add(1000).add(1010).add(1020).add(1030);
+  set.removeEach(input);
+  equals(set.get('length'), 1, 'should have correct index count');  
+  equals(set.get('max'), 1002, 'max should return 1 past last index');
+  same(iter(set), [1001]);
+});

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

@@ -0,0 +1,89 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2010 Apple Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/*global module test equals context ok same notest */
+var set, ret ;
+module("SC.IndexSet#without", {
+  setup: function() {
+    set = SC.IndexSet.create(1,9);
+  }
+});
+
+function iter(s) {
+  var ret = [];
+  s.forEach(function(k) { ret.push(k); });
+  return ret ;
+}
+
+test("should return empty set when removing self", function() {
+  ret = set.without(set);
+  ok(ret !== set, 'is not same instance');
+  same(iter(ret), []);
+});
+
+test("should return set with range removed from middle", function() {
+  ret = SC.IndexSet.create(2,6);
+  ret = set.without(ret);
+  ok(ret !== set, 'is not same instance');
+  same(iter(ret), [1,8,9]);
+});
+
+test("should return set with range removed overlapping end", function() {
+  ret = set.without(SC.IndexSet.create(6,6));
+  ok(ret !== set, 'is not same instance');
+  same(iter(ret), [1,2,3,4,5]);
+});
+
+test("should return set with range removed overlapping beginning", function() {
+  ret = set.without(SC.IndexSet.create(0,6));
+  ok(ret !== set, 'is not same instance');
+  same(iter(ret), [6,7,8,9]);
+});
+
+
+test("should return set with multiple ranges removed", function() {
+  ret = set.without(SC.IndexSet.create(2,2).add(6,2));
+  ok(ret !== set, 'is not same instance');
+  same(iter(ret), [1,4,5,8,9]);
+});
+
+test("using without should properly hint returned index set", function() {
+  var set = SC.IndexSet.create(10000,5),
+      set2 = SC.IndexSet.create(10000),
+      actual = set.without(set2),
+      loc = SC.IndexSet.HINT_SIZE;
+      
+  while(loc<2000) { // spot check
+    equals(actual._content[loc], 0, 'index set should have hint at loc %@ - set: %@'.fmt(loc, actual.inspect()));
+    loc += SC.IndexSet.HINT_SIZE;
+  }
+});
+
+// ..........................................................
+// NORMALIZED PARAMETER CASES
+// 
+
+test("passing no params should return clone", function() {
+  ret = set.without();
+  ok(ret !== set, 'is not same instance');
+  ok(ret.isEqual(set), 'has same content');
+});
+
+test("passing single number should remove just that index", function() {
+  ret = set.without(5);
+  same(iter(ret), [1,2,3,4,6,7,8,9]);
+});
+
+test("passing two numbers should remove range", function() {
+  ret = set.without(2,6);
+  same(iter(ret), [1,8,9]);
+});
+
+test("passing range object should remove range", function() {
+  ret = set.without({ start: 2, length: 6 });
+  same(iter(ret), [1,8,9]);
+});
+

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

@@ -0,0 +1,260 @@
+// ==========================================================================
+// SC.Logger Unit Test
+// ==========================================================================
+
+/*globals module test equals */
+
+
+// Test console needed because testing for null functions,
+// ie. setting the actual console.log = null means setting up
+// and tearing down no longer work properly.
+
+function testConsole() {
+  return {
+    log: function() { return true; },
+    alert: function() { return true; },
+    debug: function() { return true; },
+    dir: function() { return true; },
+    dirxml: function() { return true; },
+    error: function() { return true; },
+    group: function() { return true; },
+    groupEnd: function() { return true; },
+    info: function() { return true; },
+    profile: function() { return true; },
+    profileEnd: function() { return true; },
+    time: function() { return true; },
+    timeEnd: function() { return true; },
+    trace: function() { return true; },
+    warn: function() { return true; }
+  };
+}
+
+module("SC.Logger", {
+  setup: function() {
+    SC.Logger.set('reporter', testConsole());
+    
+    SC.Logger.debugEnabled = true;
+    SC.Logger.format = true;
+    SC.Logger.fallBackOnLog = true;
+    SC.Logger.fallBackOnAlert = false;
+  },
+  teardown: function() {
+  }
+});
+
+
+// We'll use these a lot.
+var debugMessage    = "Test debug message",
+    infoMessage     = "Test informational message",
+    warnMessage     = "Test warning message",
+    errorMessage    = "Test error message",
+    debugGroupTitle = "Test debug group title",
+    infoGroupTitle  = "Test informational group title",
+    warnGroupTitle  = "Test warning group title",
+    errorGroupTitle = "Test error group title";
+
+var outputAll = function() {
+  // Outputs a log message for each possible level.
+  SC.Logger.debugGroup(debugGroupTitle);
+  SC.Logger.debug(debugMessage);
+  SC.Logger.debugGroupEnd();
+
+  SC.Logger.infoGroup(debugGroupTitle);
+  SC.Logger.info(infoMessage);
+  SC.Logger.infoGroupEnd();
+
+  SC.Logger.warnGroup(debugGroupTitle);
+  SC.Logger.warn(warnMessage);
+  SC.Logger.warnGroupEnd();
+
+  SC.Logger.errorGroup(debugGroupTitle);
+  SC.Logger.error(errorMessage);
+  SC.Logger.errorGroupEnd();
+};
+    
+
+
+test("exists", function() {
+  equals(SC.Logger.get('exists'), true, "Reporter does exist check");
+  
+  SC.Logger.set('reporter', null);
+  equals(SC.Logger.get('exists'), false, "Reporter does not exist check");
+});
+
+test("profile", function() {
+  equals(SC.Logger.profile(), true, "profile() function is defined");
+  
+  SC.Logger.get('reporter').profile = null;
+  equals(SC.Logger.profile(), false, "profile() function is null");
+});
+
+test("profileEnd", function() {
+  equals(SC.Logger.profileEnd(), true, "profileEnd() function is defined");
+  
+  SC.Logger.get('reporter').profileEnd = null;
+  equals(SC.Logger.profileEnd(), false, "profileEnd() function is null");
+});
+
+test("time", function() {
+  equals(SC.Logger.time('mytime'), true, "time() function is defined");
+  
+  SC.Logger.get('reporter').time = null;
+  equals(SC.Logger.time('mytime'), false, "time() function is null");
+});
+
+test("timeEnd", function() {
+  equals(SC.Logger.timeEnd('mytime'), true, "timeEnd() function is defined");
+  
+  SC.Logger.get('reporter').timeEnd = null;
+  equals(SC.Logger.timeEnd('mytime'), false, "timeEnd() function is null");
+});
+
+test("trace", function() {
+  equals(SC.Logger.trace(), true, "trace() function is defined");
+  
+  SC.Logger.get('reporter').trace = null;
+  equals(SC.Logger.trace(), false, "trace() function is null");
+});
+
+test("_argumentsToString", function() {
+  equals(SC.Logger._argumentsToString.apply(SC.Logger, ["test", "test2"]), "test" + SC.LOGGER_LOG_DELIMITER + "test2", "Formatting using default delimiter");
+  
+  SC.LOGGER_LOG_DELIMITER = "|";
+  equals(SC.Logger._argumentsToString.apply(SC.Logger, ["test", "test2"]), "test|test2", "Formatting using custom delimiter");
+});
+
+
+// ..........................................................
+// LOG LEVELS
+//
+// Since we can't really test whether or not things are output to the console,
+// we'll do all of our log level testing based on the log recording mechanism.
+//
+// In case anybody else has recorded a log message, all of these tests will
+// start out by clearing the recorded log messages array.
+
+test("Ensure that log levels function properly:  none", function() {
+  SC.Logger.set('recordedLogMessages', null);
+
+  SC.Logger.set('logRecordingLevel', SC.LOGGER_LEVEL_NONE);
+  outputAll();
+
+  // If it was null before, it should be still be null, since no messages
+  // should have been logged.
+  equals(SC.Logger.get('recordedLogMessages'), null, "recordedLogMessages remains null");
+
+  // If it was an empty array before, it should still be an empty array.
+  SC.Logger.set('recordedLogMessages', []);
+  outputAll();
+  equals(SC.Logger.getPath('recordedLogMessages.length'), 0, "recordedLogMessages remains an empty array");
+});
+
+test("Ensure that log levels function properly:  debug", function() {
+  SC.Logger.set('recordedLogMessages', null);
+
+  SC.Logger.set('logRecordingLevel', SC.LOGGER_LEVEL_DEBUG);
+  outputAll();
+
+  // All four messages (plus group begin / end directives) should have been
+  // logged.
+  equals(SC.Logger.getPath('recordedLogMessages.length'), 12, "recordedLogMessages should have all twelve entries");
+
+  equals(SC.Logger.getPath('recordedLogMessages.1').message, debugMessage,  "recordedLogMessages[1] should be the debug message");
+  equals(SC.Logger.getPath('recordedLogMessages.4').message, infoMessage,   "recordedLogMessages[4] should be the info message");
+  equals(SC.Logger.getPath('recordedLogMessages.7').message, warnMessage,   "recordedLogMessages[7] should be the warn message");
+  equals(SC.Logger.getPath('recordedLogMessages.10').message, errorMessage, "recordedLogMessages[10] should be the error message");  
+});
+
+test("Ensure that log levels function properly:  info", function() {
+  SC.Logger.set('recordedLogMessages', null);
+
+  SC.Logger.set('logRecordingLevel', SC.LOGGER_LEVEL_INFO);
+  outputAll();
+
+  // Three messages (plus group begin / end directives) should have been
+  // logged.
+  equals(SC.Logger.getPath('recordedLogMessages.length'), 9, "recordedLogMessages should have nine entries");
+
+  equals(SC.Logger.getPath('recordedLogMessages.1').message, infoMessage,  "recordedLogMessages[1] should be the info message");
+  equals(SC.Logger.getPath('recordedLogMessages.4').message, warnMessage,  "recordedLogMessages[4] should be the warn message");
+  equals(SC.Logger.getPath('recordedLogMessages.7').message, errorMessage, "recordedLogMessages[7] should be the error message");
+});
+
+test("Ensure that log levels function properly:  warn", function() {
+  SC.Logger.set('recordedLogMessages', null);
+
+  SC.Logger.set('logRecordingLevel', SC.LOGGER_LEVEL_WARN);
+  outputAll();
+
+  // Two messages (plus group begin / end directives) should have been logged.
+  equals(SC.Logger.getPath('recordedLogMessages.length'), 6, "recordedLogMessages should have 6 entries");
+
+  equals(SC.Logger.getPath('recordedLogMessages.1').message, warnMessage,  "recordedLogMessages[1] should be the warn message");
+  equals(SC.Logger.getPath('recordedLogMessages.4').message, errorMessage, "recordedLogMessages[4] should be the error message");
+});
+
+test("Ensure that log levels function properly:  error", function() {
+  SC.Logger.set('recordedLogMessages', null);
+
+  SC.Logger.set('logRecordingLevel', SC.LOGGER_LEVEL_ERROR);
+  outputAll();
+
+  // Only the error message (plus group begin / end directives) should have
+  // been logged.
+  equals(SC.Logger.getPath('recordedLogMessages.length'), 3, "recordedLogMessages should have three entries");
+
+  // That message should be equal to the error message.
+  equals(SC.Logger.getPath('recordedLogMessages.1').message, errorMessage, "recordedLogMessages[1] should be the error message");
+});
+
+
+test("Ensure that log messages via the “will format” methods actually format", function() {
+  SC.Logger.set('recordedLogMessages', null);
+  SC.Logger.set('logRecordingLevel', SC.LOGGER_LEVEL_DEBUG);
+
+  var format   = "This message should be formatted:  %@:%@",
+      expected = format.fmt(null, 1);
+
+  SC.Logger.debug(format, null, 1);
+  SC.Logger.info(format, null, 1);
+  SC.Logger.warn(format, null, 1);
+  SC.Logger.error(format, null, 1);
+
+  equals(SC.Logger.getPath('recordedLogMessages.0').message, expected, "debug() should call String.fmt");
+  equals(SC.Logger.getPath('recordedLogMessages.1').message, expected, "info() should call String.fmt");
+  equals(SC.Logger.getPath('recordedLogMessages.2').message, expected, "warn() should call String.fmt");
+  equals(SC.Logger.getPath('recordedLogMessages.3').message, expected, "error() should call String.fmt");
+});
+
+test("Ensure that log messages via the “will not format” methods don’t format, but are still recorded", function() {
+  SC.Logger.set('recordedLogMessages', null);
+  SC.Logger.set('logRecordingLevel', SC.LOGGER_LEVEL_DEBUG);
+
+  var message = "This message should not be formatted:  %@:%@";
+  SC.Logger.debugWithoutFmt(message, null, 1);
+  SC.Logger.infoWithoutFmt(message, null, 1);
+  SC.Logger.warnWithoutFmt(message, null, 1);
+  SC.Logger.errorWithoutFmt(message, null, 1);
+
+  // They should still be recorded and identified as a message.
+  equals(SC.Logger.getPath('recordedLogMessages.0').message, true, "debugWithoutFmt() should still record");
+  equals(SC.Logger.getPath('recordedLogMessages.1').message, true, "infoWithoutFmt() should still record");
+  equals(SC.Logger.getPath('recordedLogMessages.2').message, true, "warnWithoutFmt() should still record");
+  equals(SC.Logger.getPath('recordedLogMessages.3').message, true, "errorWithoutFmt() should still record");
+
+  equals(SC.Logger.getPath('recordedLogMessages.0').originalArguments[0], message, "debugWithoutFmt() should not call String.fmt");
+  equals(SC.Logger.getPath('recordedLogMessages.0').originalArguments[1], null, "debugWithoutFmt() should record all the arguments (1)");
+  equals(SC.Logger.getPath('recordedLogMessages.0').originalArguments[2], 1, "debugWithoutFmt() should record all the arguments (2)");
+
+  equals(SC.Logger.getPath('recordedLogMessages.1').originalArguments[0], message, "infoWithoutFmt() should not call String.fmt");
+  equals(SC.Logger.getPath('recordedLogMessages.1').originalArguments[1], null, "infoWithoutFmt() should record all the arguments (1)");
+  equals(SC.Logger.getPath('recordedLogMessages.2').originalArguments[2], 1, "infoWithoutFmt() should record all the arguments (2)");
+
+  equals(SC.Logger.getPath('recordedLogMessages.2').originalArguments[0], message, "warnWithoutFmt() should not call String.fmt");
+  equals(SC.Logger.getPath('recordedLogMessages.2').originalArguments[1], null, "warnWithoutFmt() should record all the arguments (1)");
+  equals(SC.Logger.getPath('recordedLogMessages.2').originalArguments[2], 1, "warnWithoutFmt() should record all the arguments (2)");
+
+  equals(SC.Logger.getPath('recordedLogMessages.3').originalArguments[0], message, "errorWithoutFmt() should not call String.fmt");
+  equals(SC.Logger.getPath('recordedLogMessages.3').originalArguments[1], null, "errorWithoutFmt() should record all the arguments (1)");
+  equals(SC.Logger.getPath('recordedLogMessages.3').originalArguments[2], 1, "errorWithoutFmt() should record all the arguments (2)");
+});

data/sproutcore/frameworks/runtime/tests/system/object/base.js

@@ -0,0 +1,195 @@
+// ========================================================================
+// SC.Object Base Tests
+// ========================================================================
+/*globals module test ok isObj equals expects same plan TestNamespace*/
+
+var obj, obj1, don, don1 ; // global variables
+
+module("A new SC.Object instance", {
+  
+  setup: function() {
+    obj = SC.Object.create({
+      foo: "bar",
+      total: 12345,
+      aMethodThatExists: function() {},
+      aMethodThatReturnsTrue: function() { return true; },
+      aMethodThatReturnsFoobar: function() { return "Foobar"; },
+      aMethodThatReturnsFalse: function() { return NO; }
+    });
+  },
+  
+  teardown: function() {
+    obj = undefined ;
+  }
+  
+});
+
+test("Should identify it's methods using the 'respondsTo' method", function() {
+  equals(obj.respondsTo('aMethodThatExists'), true) ;
+  equals(obj.respondsTo('aMethodThatDoesNotExist'), false) ;
+});
+
+test("Should return false when asked to perform a method it does not have", function() {
+  equals(obj.tryToPerform('aMethodThatDoesNotExist'), false) ;
+});
+
+test("Should pass back the return YES if method returned YES, NO if method not implemented or returned NO", function() {
+  equals(obj.tryToPerform('aMethodThatReturnsTrue'), YES, 'method that returns YES') ;
+  equals(obj.tryToPerform('aMethodThatReturnsFoobar'), YES, 'method that returns non-NO') ;
+  equals(obj.tryToPerform('aMethodThatReturnsFalse'), NO, 'method that returns NO') ;
+  equals(obj.tryToPerform('imaginaryMethod'), NO, 'method that is not implemented') ;
+});
+
+test("Should return it's properties when requested using SC.Object#get", function() {
+  equals(obj.get('foo'), 'bar') ;
+  equals(obj.get('total'), 12345) ;
+});
+
+test("Should allow changing of those properties by calling SC.Object#set", function() {
+  equals(obj.get('foo'), 'bar') ;
+  equals(obj.get('total'), 12345) ;
+  
+  obj.set( 'foo', 'Chunky Bacon' ) ;
+  obj.set( 'total', 12 ) ;
+  
+  equals(obj.get('foo'), 'Chunky Bacon') ;
+  equals(obj.get('total'), 12) ;
+});
+
+test("Should only advertise changes once per request to SC.Object#didChangeFor", function() {
+  obj.set( 'foo', 'Chunky Bacon' );
+  equals(obj.didChangeFor( this, 'foo' ), true) ;
+  equals(obj.didChangeFor( this, 'foo' ), false) ;
+});
+
+test("Should advertise changes once per request to SC.Object#didChangeFor when setting property to NULL", function() {
+  obj.set( 'foo', null );
+  equals(obj.didChangeFor( this, 'foo' ), true) ;
+  equals(obj.didChangeFor( this, 'foo' ), false) ;
+});
+
+test("When the object is destroyed the 'isDestroyed' status should change accordingly", function() {
+	equals(obj.get('isDestroyed'), NO);
+	obj.destroy();
+	equals(obj.get('isDestroyed'), YES);
+});
+
+module("SC.Object observers", {
+  setup: function() {
+    // create a namespace
+    TestNamespace = {
+      obj: SC.Object.create({
+        value: "test"
+      })
+    };
+    
+    // create an object
+    obj = SC.Object.create({
+      prop1: null,
+      
+      // normal observer
+      observer: function(){
+        this._normal = YES;
+      }.observes("prop1"),
+      
+      globalObserver: function() {
+        this._global = YES;
+      }.observes("TestNamespace.obj.value"),
+      
+      bothObserver: function() {
+        this._both = YES;
+      }.observes("prop1", "TestNamespace.obj.value")
+    });
+    
+  }
+});
+
+test("Local observers work", function() {
+  obj._normal = NO;
+  obj.set("prop1", NO);
+  equals(obj._normal, YES, "Normal observer did change.");
+});
+
+test("Global observers work", function() {
+  obj._global = NO;
+  TestNamespace.obj.set("value", "test2");
+  equals(obj._global, YES, "Global observer did change.");
+});
+
+test("Global+Local observer works", function() {
+  obj._both = NO;
+  obj.set("prop1", NO);
+  equals(obj._both, YES, "Both observer did change.");
+});
+
+module("SC.Object instance extended", {  
+  setup: function() {
+    obj = SC.Object.extend();
+	obj1 = obj.create();
+	don = SC.Object.extend();
+	don1 = don.create();
+  },
+  
+  teardown: function() {
+    obj = undefined ;
+    obj1 = undefined ;
+    don = undefined ;
+    don1 = undefined ;
+  }
+  
+});
+
+test("Checking the instance of method for an object", function() {
+	equals(obj1.instanceOf(obj), YES);
+	equals(obj1.instanceOf(don), NO);
+});
+
+test("Checking the kind of method for an object", function() {
+	equals(obj1.kindOf(obj), YES);
+	equals(obj1.kindOf(don), NO);
+	
+	equals(SC.kindOf(obj1, obj), YES);
+	equals(SC.kindOf(obj1, don), NO);
+	equals(SC.kindOf(null, obj1), NO);
+});
+
+
+module("SC.Object superclass and subclasses", {  
+  setup: function() {
+    obj = SC.Object.extend ({
+	  method1: function() {
+		return "hello";
+	  }
+	});
+	obj1 = obj.extend();
+	don = obj1.create ({
+	  method2: function() {
+		  return this.superclass();
+		}
+	});
+  },
+
+  teardown: function() {
+	obj = undefined ;
+    obj1 = undefined ;
+    don = undefined ;
+  }
+});
+
+test("Checking the superclass method for an existing function", function() {
+	equals(don.method2().method1(), "hello");
+});
+
+test("Checking the subclassOf function on an object and its subclass", function(){
+	equals(obj1.subclassOf(obj), YES);
+	equals(obj.subclassOf(obj1), NO);
+});
+
+test("subclasses should contain defined subclasses", function() {
+  ok(obj.subclasses.contains(obj1), 'obj.subclasses should contain obj1');
+  
+  equals(obj1.subclasses.get('length'),0,'obj1.subclasses should be empty');
+  
+  var kls2 = obj1.extend();
+  ok(obj1.subclasses.contains(kls2), 'obj1.subclasses should contain kls2');
+});