Add tests to repository

tests/javascript/backboje.js

@@ -0,0 +1,16 @@
+$(function(){
+  window.Todo = Backbone.Model.extend({
+    defaults: function() {
+      return {
+        done:  false,
+        order: Todos.nextOrder()
+      };
+    },
+
+    // Toggle the `done` state of this todo item.
+    toggle: function() {
+      this.save({done: !this.get("done")});
+    }
+
+  });
+});

tests/javascript/class.js

@@ -0,0 +1,83 @@
+// base class
+var Animal = Class.create({
+  initialize: function(name) {
+    this.name = name;
+  },
+  name: "",
+  eat: function() {
+    return this.say("Yum!");
+  },
+  say: function(message) {
+    return this.name + ": " + message;
+  }
+});
+
+// subclass that augments a method
+var Cat = Class.create(Animal, {
+  eat: function($super, food) {
+    if (food instanceof Mouse) return $super();
+    else return this.say("Yuk! I only eat mice.");
+  }
+});
+
+// empty subclass
+var Mouse = Class.create(Animal, {});
+
+//mixins
+var Sellable = {
+  getValue: function(pricePerKilo) {
+    return this.weight * pricePerKilo;
+  },
+
+  inspect: function() {
+    return '#<Sellable: #{weight}kg>'.interpolate(this);
+  }
+};
+
+var Reproduceable = {
+  reproduce: function(partner) {
+    if (partner.constructor != this.constructor || partner.sex == this.sex)
+      return null;
+    var weight = this.weight / 10, sex = Math.random(1).round() ? 'male' : 'female';
+    return new this.constructor('baby', weight, sex);
+  }
+};
+
+// base class with mixin
+var Plant = Class.create(Sellable, {
+  initialize: function(name, weight) {
+    this.name = name;
+    this.weight = weight;
+  },
+
+  inspect: function() {
+    return '#<Plant: #{name}>'.interpolate(this);
+  }
+});
+
+// subclass with mixin
+var Dog = Class.create(Animal, Reproduceable, {
+  initialize: function($super, name, weight, sex) {
+    this.weight = weight;
+    this.sex = sex;
+    $super(name);
+  }
+});
+
+// subclass with mixins
+var Ox = Class.create(Animal, Sellable, Reproduceable, {
+  initialize: function($super, name, weight, sex) {
+    this.weight = weight;
+    this.sex = sex;
+    $super(name);
+  },
+
+  eat: function(food) {
+    if (food instanceof Plant)
+      this.weight += food.weight;
+  },
+
+  inspect: function() {
+    return '#<Ox: #{name}>'.interpolate(this);
+  }
+});

tests/javascript/jquery.ui.progressbar.js

@@ -0,0 +1,107 @@
+/*
+ * jQuery UI Progressbar @VERSION
+ *
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Progressbar
+ *
+ * Depends:
+ *   jquery.ui.core.js
+ *   jquery.ui.widget.js
+ */
+(function( $, undefined ) {
+
+$.widget( "ui.progressbar", {
+	options: {
+		value: 0,
+		max: 100
+	},
+
+	min: 0,
+
+	_create: function() {
+		this.element
+			.addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
+			.attr({
+				role: "progressbar",
+				"aria-valuemin": this.min,
+				"aria-valuemax": this.options.max,
+				"aria-valuenow": this._value()
+			});
+
+		this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
+			.appendTo( this.element );
+
+		this.oldValue = this._value();
+		this._refreshValue();
+	},
+
+	_destroy: function() {
+		this.element
+			.removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
+			.removeAttr( "role" )
+			.removeAttr( "aria-valuemin" )
+			.removeAttr( "aria-valuemax" )
+			.removeAttr( "aria-valuenow" );
+
+		this.valueDiv.remove();
+	},
+
+	value: function( newValue ) {
+		if ( newValue === undefined ) {
+			return this._value();
+		}
+
+		this._setOption( "value", newValue );
+		return this;
+	},
+
+	_setOption: function( key, value ) {
+		if ( key === "value" ) {
+			this.options.value = value;
+			this._refreshValue();
+			if ( this._value() === this.options.max ) {
+				this._trigger( "complete" );
+			}
+		}
+
+		this._super( "_setOption", key, value );
+	},
+
+	_value: function() {
+		var val = this.options.value;
+		// normalize invalid value
+		if ( typeof val !== "number" ) {
+			val = 0;
+		}
+		return Math.min( this.options.max, Math.max( this.min, val ) );
+	},
+
+	_percentage: function() {
+		return 100 * this._value() / this.options.max;
+	},
+
+	_refreshValue: function() {
+		var value = this.value();
+		var percentage = this._percentage();
+
+		if ( this.oldValue !== value ) {
+			this.oldValue = value;
+			this._trigger( "change" );
+		}
+
+		this.valueDiv
+			.toggle( value > this.min )
+			.toggleClass( "ui-corner-right", value === this.options.max )
+			.width( percentage.toFixed(0) + "%" );
+		this.element.attr( "aria-valuenow", value );
+	}
+});
+
+$.extend( $.ui.progressbar, {
+	version: "@VERSION"
+});
+
+})( jQuery );

tests/javascript/namespaces.js

@@ -0,0 +1,27 @@
+/* Object Literal Notation */
+var objectLiteral = {
+    str: '1',
+    func: function() { return 1; }
+};
+
+/* Module Pattern 1 */
+var module = (function(){
+    var private = 1;
+    return {
+        method: function() { private++; }
+    };
+})();
+
+/* Module Pattern 2 */
+var module2 = {};
+(function(context){
+    var private = 1;
+    context.method = function() { private++; }
+})(module2);
+
+/* Module Pattern 3 */
+var module3 = {};
+(function(){
+    var private = 1;
+    this.method = function() { private++; }
+}).apply(module3);

tests/javascript/oreilly1.js

@@ -0,0 +1,42 @@
+// This example is from the book _JavaScript: The Definitive Guide_.    
+// Written by David Flanagan.  Copyright (c) 1996 O'Reilly & Associates.
+// This example is provided WITHOUT WARRANTY either expressed or implied.
+// You may study, use, modify, and distribute it for any purpose.        
+
+function Circle(radius) {   // the constructor defines the class itself
+    // r is an instance variable; defined and initialized in the constructor
+    this.r = radius;    
+}
+
+// Circle.PI is a class variable--it is a property of the constructor function
+Circle.PI = 3.14159;
+
+// Here is a function that computes a circle area.
+function Circle_area() { return Circle.PI * this.r * this.r; }
+
+// Here we make the function into an instance method by assigning it
+// to the prototype object of the constructor.  Remember that we have to
+// create and discard one object before the prototype object exists
+new Circle(0);
+Circle.prototype.area = Circle_area;
+
+// Here's another function.  It takes two circle objects are arguments and
+// returns the one that is larger (has the larger radius).  
+function Circle_max(a,b) {
+    if (a.r > b.r) return a;
+    else return b;
+}
+
+// Since this function compares two circle objects, it doesn't make sense as 
+// an instance method operating on a single circle object.  But we don't want
+// it to be a stand-alone function either, so we make it into a class method
+// by assigning it to the constructor function:
+Circle.max = Circle_max;
+
+// Here is some code that uses each of these fields:
+c = new Circle(1.0);       // create an instance of the Circle class
+c.r = 2.2;                 // set the r instance variable
+a = c.area();              // invoke the area() instance method 
+x = Math.exp(Circle.PI);   // use the PI class variable in our own computation.
+d = new Circle(1.2);       // create another Circle instance
+bigger = Circle.max(c,d);  // use the max() class method.

tests/javascript/small.js

@@ -0,0 +1,9 @@
+var app = {
+    foo: function(){},
+    bar: function(){}
+}
+
+var dsads = {
+    fdfsd: function(){},
+    dsadas: function(){}
+}