sproutcore 1.6.0.beta.2-x86-mingw32

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

@@ -0,0 +1,199 @@
+// ==========================================================================
+// Project:   SproutCore Unit Testing Library
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed 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() {};
+
+// map used to exist, this is here for backwards compatibility
+var Q$ = jQuery;
+
+/** @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/lib/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/lib/frameworks/sproutcore/frameworks/testing/english.lproj/runner.css

@@ -0,0 +1,128 @@
+.core-test {
+  font: 12px/16px "Helvetica", Verdana, Arial, sans-serif;
+  margin: 0;
+  padding: 0;
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background-color: #f0f0f0;
+  overflow: auto;
+}
+  
+.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/lib/frameworks/sproutcore/frameworks/testing/english.lproj/testsuite.css

@@ -0,0 +1,136 @@
+#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);
+  -ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=50)"; 
+  -moz-opacity:0.5;
+}
+
+#qunit div.nowidth {
+	width: 0px;
+}
+
+#qunit div.noheight {
+	height: 0px;
+}
+
+#qunit div.noopacity {
+	opacity: 0;
+	filter: progid:DXImageTransform.Microsoft.Alpha(Opacity=0);
+  -ms-filter: "progid:DXImageTransform.Microsoft.Alpha(Opacity=0)"; 
+  -moz-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/lib/frameworks/sproutcore/frameworks/testing/extras.js

@@ -0,0 +1,17 @@
+// ==========================================================================
+// Project:   SproutCore Unit Testing Library
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/*global Q$ synchronize */
+// additional methods for use with qunit
+
+/**
+  Call this method instead of test() to temporarily disable a test. 
+*/
+function notest(name, callback, nowait) {
+  
+}
+

data/lib/frameworks/sproutcore/frameworks/testing/system/dump.js

@@ -0,0 +1,205 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/*globals CoreTest module */
+
+/**
+ * jsDump
+ * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
+ * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
+ * Date: 5/15/2008
+ * @projectDescription Advanced and extensible data dumping for Javascript.
+ * @version 1.0.0
+ * @author Ariel Flesler
+ * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
+ */
+(function(){
+  var reName, jsDump;
+  
+  function quote( str ){
+    return '"' + str.toString().replace(/"/g, '\\"') + '"';
+  }
+  
+  function literal( o ){
+    return o + '';  
+  }
+  
+  function join( pre, arr, post ){
+    var s     = jsDump.separator(),
+        base  = jsDump.indent(),
+        inner = jsDump.indent(1);
+        
+    if( arr.join )  arr = arr.join( ',' + s + inner );
+    if( !arr ) return pre + post;
+    
+    return [ pre, inner + arr, base + post ].join(s);
+  }
+  
+  function array( arr ){
+    var i = arr.length, ret = new Array(i);         
+    this.up();
+    while( i-- ) ret[i] = this._parse( arr[i] );        
+    this.down();
+    return join( '[', ret, ']' );
+  }
+  
+  reName = /^function (\w+)/;
+  
+  jsDump = CoreTest.jsDump = {
+
+    parse: function(obj, type) {
+      if (obj && obj.toString) {
+        var toString = obj.toString;
+        if ((toString !== Object.prototype.toString) && (toString !== Array.toString)) return obj.toString();
+      }
+      if (obj && obj.inspect) return obj.inspect();
+      
+      this.seen = [];
+      var ret = this._parse(obj, type);
+      this.seen = null;
+      return ret ;
+    },
+    
+    //type is used mostly internally, you can fix a (custom)type in advance
+    _parse: function( obj, type ) {
+      
+      
+      var parser = this.parsers[ type || this.typeOf(obj) ];
+      type = typeof parser;     
+
+      // avoid recursive loops
+      if ((parser === this.parsers.object) && (this.seen.indexOf(obj)>=0)) {
+        return '(recursive)';
+      }
+      this.seen.push(obj);
+      
+      return type == 'function' ? parser.call( this, obj ) :
+           type == 'string' ? parser :
+           this.parsers.error;
+    },
+    typeOf:function( obj ){
+      var type = typeof obj,
+        f = 'function';//we'll use it 3 times, save it
+        
+      if (obj && (obj.isObject || obj.isClass)) return 'scobj';
+      return type != 'object' && type != f ? type :
+        !obj ? 'null' :
+        obj.exec ? 'regexp' :// some browsers (FF) consider regexps functions
+        obj.getHours ? 'date' :
+        obj.scrollBy ?  'window' :
+        obj.nodeName == '#document' ? 'document' :
+        obj.nodeName ? 'node' :
+        obj.item ? 'nodelist' : // Safari reports nodelists as functions
+        obj.callee ? 'arguments' :
+        obj.call || obj.constructor != Array && //an array would also fall on this hack
+          (obj+'').indexOf(f) != -1 ? f : //IE reports functions like alert, as objects
+        'length' in obj ? 'array' :
+        type;
+    },
+    separator:function(){
+      return this.multiline ? this.HTML ? '<br />' : '\n' : this.HTML ? '&nbsp;' : ' ';
+    },
+    indent:function( extra ){// extra can be a number, shortcut for increasing-calling-decreasing
+      if( !this.multiline ) return '';
+      
+      var chr = this.indentChar;
+      if( this.HTML ) chr = chr.replace(/\t/g,'   ').replace(/ /g,'&nbsp;');
+      return (new Array( this._depth_ + (extra||0) )).join(chr);
+    },
+    up:function( a ){
+      this._depth_ += a || 1;
+    },
+    down:function( a ){
+      this._depth_ -= a || 1;
+    },
+    setParser:function( name, parser ){
+      this.parsers[name] = parser;
+    },
+    // The next 3 are exposed so you can use them
+    quote:quote, 
+    literal:literal,
+    join:join,
+    //
+    _depth_: 1,
+    // This is the list of parsers, to modify them, use jsDump.setParser
+    parsers:{
+      window: '[Window]',
+      document: '[Document]',
+      error:'[ERROR]', //when no parser is found, shouldn't happen
+      unknown: '[Unknown]',
+      'null':'null',
+      'undefined':'undefined',
+      'function':function( fn ){
+        var ret = 'function',
+          name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE
+        if( name ) ret += ' ' + name;
+        ret += '(';
+        
+        ret = [ ret, this._parse( fn, 'functionArgs' ), '){'].join('');
+        return join( ret, this._parse(fn,'functionCode'), '}' );
+      },
+      array: array,
+      nodelist: array,
+      'arguments': array,
+      scobj: function(obj) { return obj.toString(); },
+      object:function( map ){
+        
+        var ret = [ ];
+        this.up();
+        for( var key in map ) {
+          ret.push( this._parse(key,'key') + ': ' + this._parse(map[key]) );
+        }
+        this.down();
+        return join( '{', ret, '}' );
+      },
+      node:function( node ){
+        var open = this.HTML ? '&lt;' : '<',
+          close = this.HTML ? '&gt;' : '>';
+          
+        var tag = node.nodeName.toLowerCase(),
+          ret = open + tag;
+          
+        for( var a in this.DOMAttrs ){
+          var val = node[this.DOMAttrs[a]];
+          if( val ) {
+            ret += ' ' + a + '=' + this._parse( val, 'attribute' );
+          }
+        }
+        return ret + close + open + '/' + tag + close;
+      },
+      functionArgs:function( fn ){//function calls it internally, it's the arguments part of the function
+        var l = fn.length;
+        if( !l ) return '';       
+        
+        var args = new Array(l);
+        while( l-- ) args[l] = String.fromCharCode(97+l);//97 is 'a'
+        return ' ' + args.join(', ') + ' ';
+      },
+      key:quote, //object calls it internally, the key part of an item in a map
+      functionCode:'[code]', //function calls it internally, it's the content of the function
+      attribute:quote, //node calls it internally, it's an html attribute value
+      string:quote,
+      date:quote,
+      regexp:literal, //regex
+      number:literal,
+      'boolean':literal
+    },
+    DOMAttrs:{//attributes to dump from nodes, name=>realName
+      id:'id',
+      name:'name',
+      'class':'className'
+    },
+    HTML:true,//if true, entities are escaped ( <, >, \t, space and \n )
+    indentChar:'   ',//indentation unit
+    multiline:true //if true, items in a collection, are separated by a \n, else just a space.
+  };
+  
+  CoreTest.dump = function dump(obj,type) {
+    return CoreTest.jsDump.parse(obj, type);
+  };
+
+})();