sproutcore 1.4.0-java

data/lib/frameworks/sproutcore/frameworks/runtime/tests/system/index_set/remove.js

@@ -0,0 +1,189 @@
+// ==========================================================================
+// 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 should_throw*/
+var set ;
+module("SC.IndexSet#remove", {
+  setup: function() {
+    set = SC.IndexSet.create();
+  }
+});
+
+function iter(s) {
+  var ret = [];
+  set.forEach(function(k) { ret.push(k); });
+  return ret ;
+}
+
+// ..........................................................
+// BASIC REMOVES
+// 
+
+test("remove a range after end of set", function() {
+  equals(set.get('length'), 0, 'precond - should be empty');  
+
+  set.remove(1000, 5);
+  equals(set.get('length'), 0, 'should still be empty');  
+  equals(set.get('max'), 0, 'max should return 1 past last index');
+  same(iter(set), [], 'should be empty');
+});
+
+test("remove range in middle of an existing range", function() {
+  set.add(100,4);
+  same(iter(set), [100, 101, 102, 103], 'precond - should have range');
+  
+  set.remove(101,2);
+  equals(set.get('length'), 2, 'new length should not include removed range');
+  equals(set.get('max'), 104, 'max should return 1 past last index');
+  same(iter(set), [100,103], 'should remove range in the middle'); 
+});
+
+test("remove range overlapping front edge of range", function() {
+  set.add(100,2); // add initial set.
+  equals(iter(set)[0], 100, 'precond - first index is 100');
+  
+  // now add second range
+  set.remove(99,2);
+  equals(set.get('length'), 1, 'should have extra length');
+  equals(set.get('max'), 102, 'max should return 1 past last index');
+  same(iter(set), [101]);
+});
+
+test("remove range overlapping last edge of range", function() {
+  set.add(100,2).add(200,2); // make sure not last range
+  same(iter(set), [100,101,200,201], 'should have two sets');
+  
+  // now add overlapping range
+  set.remove(101,2);
+  equals(set.get('length'), 3, 'new set.length');
+  equals(set.get('max'), 202, 'max should return 1 past last index');
+  same(iter(set), [100,200,201], 'should remove 101-102');
+});
+
+test("remove range overlapping two ranges, remove parts of both", function() {
+  set.add(100,2).add(110,2);
+  same(iter(set), [100,101,110,111], 'should have two sets');
+  
+  // now add overlapping range
+  set.remove(101,10);
+  equals(set.get('length'), 2, 'new set.length');
+  equals(set.get('max'), 112, 'max should return 1 past last index');
+  same(iter(set), [100,111], 'should remove range 101-110');
+});
+
+test("remove range overlapping three ranges, removing one and parts of the others", function() {
+  set.add(100,2).add(105,2).add(110,2);
+  same(iter(set), [100,101,105,106,110,111], 'should have two sets');
+  
+  // now add overlapping range
+  set.remove(101,10);
+  equals(set.get('length'), 2, 'new set.length');
+  equals(set.get('max'), 112, 'max should return 1 past last index');
+  same(iter(set), [100,111], 'should remove range 101-110');
+});
+
+test("remove range partially overlapping one range and replacing another range", function() {
+  set.add(100,2).add(105,2);
+  same(iter(set), [100,101,105,106], 'should have two sets');
+  
+  // now add overlapping range
+  set.remove(101,10);
+  equals(set.get('length'), 1, 'new set.length');
+
+  equals(set.get('max'), 101, 'max should return 1 past last index');
+  same(iter(set), [100], 'should include one range 100-110');
+});
+
+test("remove range overlapping last index", function() {
+  set.add(100,2); // add initial set.
+  equals(iter(set)[0], 100, 'precond - first index is 100');
+  
+  // now add second range
+  set.remove(101,2);
+  equals(set.get('length'), 1, 'should have extra length');
+  equals(set.get('max'), 101, 'max should return 1 past last index');
+  same(iter(set), [100]);
+});
+
+test("remove range matching existing range", function() {
+  set.add(100,5); // add initial set.
+  same(iter(set), [100, 101, 102, 103, 104]);
+  
+  // now add second range
+  set.remove(100,5);
+  equals(set.get('length'), 0, 'should be empty');
+  equals(set.get('max'), 0, 'max should return 1 past last index');
+  same(iter(set), []);  
+});
+
+// ..........................................................
+// NORMALIZED PARAMETER CASES
+// 
+
+test("remove with no params should do nothing", function() {
+  set.add(10,2).remove();
+  same(iter(set), [10,11]);
+});
+
+test("remove with single number should add index only", function() {
+  set.add(10,2).remove(10);
+  same(iter(set), [11]);
+});
+
+test("remove with range object should add range only", function() {
+  set.add(10,5).remove({ start: 10, length: 2 });
+  same(iter(set), [12,13,14]);
+});
+
+test("remove with index set should add indexes in set", function() {
+  set.add(0,14).remove(SC.IndexSet.create().add(2,2).add(10,2));
+  same(iter(set), [0,1,4,5,6,7,8,9,12,13]);
+});
+
+
+// ..........................................................
+// OTHER BEHAVIORS
+// 
+test("remove a range should trigger an observer notification", function() {
+  var callCnt = 0;
+  set.add(10, 20);
+  
+  set.addObserver('[]', function() { callCnt++; });
+  set.remove(10,10);
+  equals(callCnt, 1, 'should have called observer once');
+});
+
+test("removing a non-existant range should not trigger observer notification", function() {
+  var callCnt = 0;
+  
+  set.addObserver('[]', function() { callCnt++; });
+  set.remove(10,10); // 10-20 are already empty
+  equals(callCnt, 0, 'should NOT have called observer');
+});
+
+test("removing a clone of the same index set should leave an empty set", function() {
+  var set = SC.IndexSet.create(0,2), set2 = set.clone();
+  ok(set.isEqual(set2), 'precond - clone is equal to receiver');
+  set.remove(set2);
+  equals(set.get('length'), 0, 'set should now be empty');
+});
+
+test("removing an index range outside of target range (specific bug)", function() {
+
+  var set = SC.IndexSet.create(10,3);
+  var set2 = SC.IndexSet.create(0,3);
+  
+  // removing set2 from set should not changed set at all beceause it is 
+  // before the first range, but it causes a problem with the length.
+  set.remove(set2);
+  equals(set.get('length'), 3, 'length should not change');
+});
+
+test("remove() raises exception when frozen", function() {
+  should_throw(function() {
+    set.freeze().remove(0,2);    
+  }, SC.FROZEN_ERROR);  
+});

data/lib/frameworks/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/lib/frameworks/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/lib/frameworks/sproutcore/frameworks/runtime/tests/system/logger.js

@@ -0,0 +1,177 @@
+// ==========================================================================
+// 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() {
+  }
+});
+
+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("log", function() {
+  equals(SC.Logger.log("test"), true, "Function is defined" );
+  
+  var reporter = SC.Logger.get('reporter');
+  reporter.log = null;
+  equals(SC.Logger.log("test"), false, "Function is null");
+  
+  SC.Logger.fallBackOnAlert = true;
+  equals(SC.Logger.log("test"), true, "Function is null -- fallBackOnAlert true");
+});
+
+test("debug", function() {
+  equals(SC.Logger.debug("Debug"), true, "Function is defined");
+
+  SC.Logger.get('reporter').debug = null;
+  equals(SC.Logger.debug("Debug"), true, "Function is null -- fallBackOnLog true");
+
+  SC.Logger.fallBackOnLog = false;
+  equals(SC.Logger.debug("Debug"), false, "Function is null -- fallBackOnLog false");
+});
+
+test("dir", function() {
+  equals(SC.Logger.dir({test:"string"}), true, "Function is defined");
+  
+  SC.Logger.get('reporter').dir = null;
+  equals(SC.Logger.dir({test:"string"}), true, "Function is null -- fallBackOnLog true");
+  
+  SC.Logger.fallBackOnLog = false;
+  equals(SC.Logger.dir({test:"string"}), false, "Function is null -- fallBackOnLog false");
+});
+
+test("dirxml", function() {
+  equals(SC.Logger.dirxml("<here id='2'>is some XML</here>"), true, "Function is defined");
+  
+  SC.Logger.get('reporter').dirxml = null;
+  equals(SC.Logger.dirxml("<here id='2'>is some XML</here>"), true, "Function is null -- fallBackOnLog true");
+  
+  SC.Logger.fallBackOnLog = false;
+  equals(SC.Logger.dirxml("<here id='2'>is some XML</here>"), false, "Function is null -- fallBackOnLog false");
+});
+
+test("error", function() {
+  equals(SC.Logger.error("Error"), true, "Function is defined");
+  
+  SC.Logger.get('reporter').error = null;
+  equals(SC.Logger.error("Error"), true, "Function is null -- fallBackOnLog true");
+
+  SC.Logger.fallBackOnLog = false;
+  equals(SC.Logger.error("Error"), false, "Function is null -- fallBackOnLog false");
+});
+
+test("group", function() {
+  equals(SC.Logger.group("mygroup"), true, "Function is defined");
+  
+  SC.Logger.get('reporter').group = null;
+  equals(SC.Logger.group("mygroup"), false, "Function is null");
+});
+
+test("groupEnd", function() {
+  equals(SC.Logger.groupEnd("mygroup"), true, "Function is defined");
+  
+  SC.Logger.get('reporter').groupEnd = null;
+  equals(SC.Logger.groupEnd("mygroup"), false, "Function is null");
+});
+
+test("info", function() {
+  equals(SC.Logger.info("Info"), true, "Function is defined");
+  
+  SC.Logger.get('reporter').info = null;
+  equals(SC.Logger.info("Info"), true, "Function is null -- fallBackOnLog true");
+
+  SC.Logger.fallBackOnLog = false;
+  equals(SC.Logger.info("Info"), false, "Function is null -- fallBackOnLog false");
+});
+
+test("profile", function() {
+  equals(SC.Logger.profile(), true, "Function is defined");
+  
+  SC.Logger.get('reporter').profile = null;
+  equals(SC.Logger.profile(), false, "Function is null");
+});
+
+test("profileEnd", function() {
+  equals(SC.Logger.profileEnd(), true, "Function is defined");
+  
+  SC.Logger.get('reporter').profileEnd = null;
+  equals(SC.Logger.profileEnd(), false, "Function is null");
+});
+
+test("time", function() {
+  equals(SC.Logger.time('mytime'), true, "Function is defined");
+  
+  SC.Logger.get('reporter').time = null;
+  equals(SC.Logger.time('mytime'), false, "Function is null");
+});
+
+test("timeEnd", function() {
+  equals(SC.Logger.timeEnd('mytime'), true, "Function is defined");
+  
+  SC.Logger.get('reporter').timeEnd = null;
+  equals(SC.Logger.timeEnd('mytime'), false, "Function is null");
+});
+
+test("trace", function() {
+  equals(SC.Logger.trace(), true, "Function is defined");
+  
+  SC.Logger.get('reporter').trace = null;
+  equals(SC.Logger.trace(), false, "Function is null");
+});
+
+test("warn", function() {
+  equals(SC.Logger.warn("Warn"), true, "Function is defined");
+  
+  SC.Logger.get('reporter').warn = null;
+  equals(SC.Logger.warn("Warn"), true, "Function is null -- fallBackOnLog true");
+
+  SC.Logger.fallBackOnLog = false;
+  equals(SC.Logger.warn("Warn"), false, "Function is null -- fallBackOnLog false");
+});
+
+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");
+});