Adding tests for javascript response; required copying files that would exist in…

Adding tests for javascript response; required copying files that would exist in other places in the main LMS to test_files because the test environment is fragile. This tests the code, but not the environment.

common/lib/xmodule/xmodule/tests/__init__.py

@@ -8,6 +8,7 @@
 import unittest
 import os
 import fs
+import json
 
 import numpy
 
@@ -29,9 +30,9 @@ i4xs = ModuleSystem(
     render_template=Mock(),
     replace_urls=Mock(),
     user=Mock(),
-    filestore=fs.osfs.OSFS(os.path.dirname(os.path.realpath(__file__))),
+    filestore=fs.osfs.OSFS(os.path.dirname(os.path.realpath(__file__))+"/test_files"),
     debug=True,
-    xqueue_callback_url='/',
+    xqueue=None,
     is_staff=False
 )
 
@@ -356,6 +357,20 @@ class ChoiceResponseTest(unittest.TestCase):
         self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_3_1'), 'incorrect')
         self.assertEquals(test_lcp.grade_answers(test_answers).get_correctness('1_4_1'), 'correct')
 
+class JavascriptResponseTest(unittest.TestCase):
+
+    def test_jr_grade(self):
+        os.environ["NODE_PATH"] = ""
+        problem_file = os.path.dirname(__file__) + "/test_files/javascriptresponse.xml"
+        coffee_file_path = os.path.dirname(__file__) + "/test_files/js/*.coffee"
+        os.system("coffee -c %s" % (coffee_file_path))
+        test_lcp = lcp.LoncapaProblem(open(problem_file).read(), '1', system=i4xs)
+        correct_answers = {'1_2_1': json.dumps({0: 4})}
+        incorrect_answers = {'1_2_1': json.dumps({0: 5})}
+
+        self.assertEquals(test_lcp.grade_answers(incorrect_answers).get_correctness('1_2_1'), 'incorrect')
+        self.assertEquals(test_lcp.grade_answers(correct_answers).get_correctness('1_2_1'), 'correct')
+
 #-----------------------------------------------------------------------------
 # Grading tests
 

common/lib/xmodule/xmodule/tests/test_files/javascriptresponse.xml

+<problem>
+
+<javascriptresponse>
+  <generator src="test_problem_generator.js"/>
+  <grader src="test_problem_grader.js"/>
+  <display class="TestProblemDisplay" src="test_problem_display.js"/>
+  <responseparam name="value" value="4"/>
+  <javascriptinput>
+  </javascriptinput>
+</javascriptresponse>
+
+</problem>
+

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/.npmignore

+*.coffee
+*.html
+.DS_Store
+.git*
+Cakefile
+documentation/
+examples/
+extras/coffee-script.js
+raw/
+src/
+test/

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/CNAME

+coffeescript.org
\ No newline at end of file

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/LICENSE

+Copyright (c) 2009-2012 Jeremy Ashkenas
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/README

+
+            {
+         }   }   {
+        {   {  }  }
+         }   }{  {
+        {  }{  }  }                    _____       __  __
+       ( }{ }{  { )                   / ____|     / _|/ _|
+     .- { { }  { }} -.               | |     ___ | |_| |_ ___  ___
+    (  ( } { } { } }  )              | |    / _ \|  _|  _/ _ \/ _ \
+    |`-..________ ..-'|              | |___| (_) | | | ||  __/  __/
+    |                 |               \_____\___/|_| |_| \___|\___|
+    |                 ;--.
+    |                (__  \            _____           _       _
+    |                 | )  )          / ____|         (_)     | |
+    |                 |/  /          | (___   ___ _ __ _ _ __ | |_
+    |                 (  /            \___ \ / __| '__| | '_ \| __|
+    |                 |/              ____) | (__| |  | | |_) | |_
+    |                 |              |_____/ \___|_|  |_| .__/ \__|
+     `-.._________..-'                                  | |
+                                                        |_|
+
+
+  CoffeeScript is a little language that compiles into JavaScript.
+
+  Install Node.js, and then the CoffeeScript compiler:
+  sudo bin/cake install
+
+  Or, if you have the Node Package Manager installed:
+  npm install -g coffee-script
+  (Leave off the -g if you don't wish to install globally.)
+
+  Execute a script:
+  coffee /path/to/script.coffee
+
+  Compile a script:
+  coffee -c /path/to/script.coffee
+
+  For documentation, usage, and examples, see:
+  http://coffeescript.org/
+
+  To suggest a feature, report a bug, or general discussion:
+  http://github.com/jashkenas/coffee-script/issues/
+
+  If you'd like to chat, drop by #coffeescript on Freenode IRC,
+  or on webchat.freenode.net.
+
+  The source repository:
+  git://github.com/jashkenas/coffee-script.git
+
+  All contributors are listed here:
+  http://github.com/jashkenas/coffee-script/contributors

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/Rakefile

+require 'rubygems'
+require 'erb'
+require 'fileutils'
+require 'rake/testtask'
+require 'json'
+
+desc "Build the documentation page"
+task :doc do
+  source = 'documentation/index.html.erb'
+  child = fork { exec "bin/coffee -bcw -o documentation/js documentation/coffee/*.coffee" }
+  at_exit { Process.kill("INT", child) }
+  Signal.trap("INT") { exit }
+  loop do
+    mtime = File.stat(source).mtime
+    if !@mtime || mtime > @mtime
+      rendered = ERB.new(File.read(source)).result(binding)
+      File.open('index.html', 'w+') {|f| f.write(rendered) }
+    end
+    @mtime = mtime
+    sleep 1
+  end
+end
+
+desc "Build coffee-script-source gem"
+task :gem do
+  require 'rubygems'
+  require 'rubygems/package'
+
+  gemspec = Gem::Specification.new do |s|
+    s.name      = 'coffee-script-source'
+    s.version   = JSON.parse(File.read('package.json'))["version"]
+    s.date      = Time.now.strftime("%Y-%m-%d")
+
+    s.homepage    = "http://jashkenas.github.com/coffee-script/"
+    s.summary     = "The CoffeeScript Compiler"
+    s.description = <<-EOS
+      CoffeeScript is a little language that compiles into JavaScript.
+      Underneath all of those embarrassing braces and semicolons,
+      JavaScript has always had a gorgeous object model at its heart.
+      CoffeeScript is an attempt to expose the good parts of JavaScript
+      in a simple way.
+    EOS
+
+    s.files = [
+      'lib/coffee_script/coffee-script.js',
+      'lib/coffee_script/source.rb'
+    ]
+
+    s.authors           = ['Jeremy Ashkenas']
+    s.email             = 'jashkenas@gmail.com'
+    s.rubyforge_project = 'coffee-script-source'
+  end
+
+  file = File.open("coffee-script-source.gem", "w")
+  Gem::Package.open(file, 'w') do |pkg|
+    pkg.metadata = gemspec.to_yaml
+
+    path = "lib/coffee_script/source.rb"
+    contents = <<-ERUBY
+module CoffeeScript
+  module Source
+    def self.bundled_path
+      File.expand_path("../coffee-script.js", __FILE__)
+    end
+  end
+end
+    ERUBY
+    pkg.add_file_simple(path, 0644, contents.size) do |tar_io|
+      tar_io.write(contents)
+    end
+
+    contents = File.read("extras/coffee-script.js")
+    path = "lib/coffee_script/coffee-script.js"
+    pkg.add_file_simple(path, 0644, contents.size) do |tar_io|
+      tar_io.write(contents)
+    end
+  end
+end

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/bin/cake

+#!/usr/bin/env node
+
+var path = require('path');
+var fs   = require('fs');
+var lib  = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
+
+require(lib + '/coffee-script/cake').run();

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/bin/coffee

+#!/usr/bin/env node
+
+var path = require('path');
+var fs   = require('fs');
+var lib  = path.join(path.dirname(fs.realpathSync(__filename)), '../lib');
+
+require(lib + '/coffee-script/command').run();

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/extras/jsl.conf

+# JavaScriptLint configuration file for CoffeeScript.
+
++no_return_value              # function {0} does not always return a value
++duplicate_formal             # duplicate formal argument {0}
+-equal_as_assign              # test for equality (==) mistyped as assignment (=)?{0}
++var_hides_arg                # variable {0} hides argument
++redeclared_var               # redeclaration of {0} {1}
+-anon_no_return_value         # anonymous function does not always return a value
++missing_semicolon            # missing semicolon
++meaningless_block            # meaningless block; curly braces have no impact
+-comma_separated_stmts        # multiple statements separated by commas (use semicolons?)
++unreachable_code             # unreachable code
++missing_break                # missing break statement
+-missing_break_for_last_case  # missing break statement for last case in switch
+-comparison_type_conv         # comparisons against null, 0, true, false, or an empty string allowing implicit type conversion (use === or !==)
+-inc_dec_within_stmt          # increment (++) and decrement (--) operators used as part of greater statement
+-useless_void                 # use of the void type may be unnecessary (void is always undefined)
++multiple_plus_minus          # unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x---y) signs
++use_of_label                 # use of label
+-block_without_braces         # block statement without curly braces
++leading_decimal_point        # leading decimal point may indicate a number or an object member
++trailing_decimal_point       # trailing decimal point may indicate a number or an object member
++octal_number                 # leading zeros make an octal number
++nested_comment               # nested comment
++misplaced_regex              # regular expressions should be preceded by a left parenthesis, assignment, colon, or comma
++ambiguous_newline            # unexpected end of line; it is ambiguous whether these lines are part of the same statement
++empty_statement              # empty statement or extra semicolon
+-missing_option_explicit      # the "option explicit" control comment is missing
++partial_option_explicit      # the "option explicit" control comment, if used, must be in the first script tag
++dup_option_explicit          # duplicate "option explicit" control comment
++useless_assign               # useless assignment
++ambiguous_nested_stmt        # block statements containing block statements should use curly braces to resolve ambiguity
++ambiguous_else_stmt          # the else statement could be matched with one of multiple if statements (use curly braces to indicate intent)
+-missing_default_case         # missing default case in switch statement
++duplicate_case_in_switch     # duplicate case in switch statements
++default_not_at_end           # the default case is not at the end of the switch statement
++legacy_cc_not_understood     # couldn't understand control comment using /*@keyword@*/ syntax
++jsl_cc_not_understood        # couldn't understand control comment using /*jsl:keyword*/ syntax
++useless_comparison           # useless comparison; comparing identical expressions
++with_statement               # with statement hides undeclared variables; use temporary variable instead
++trailing_comma_in_array      # extra comma is not recommended in array initializers
++assign_to_function_call      # assignment to a function call
++parseint_missing_radix       # parseInt missing radix parameter
++lambda_assign_requires_semicolon

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/lib/coffee-script/browser.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var CoffeeScript, runScripts;
+
+  CoffeeScript = require('./coffee-script');
+
+  CoffeeScript.require = require;
+
+  CoffeeScript["eval"] = function(code, options) {
+    var _ref;
+    if (options == null) {
+      options = {};
+    }
+    if ((_ref = options.bare) == null) {
+      options.bare = true;
+    }
+    return eval(CoffeeScript.compile(code, options));
+  };
+
+  CoffeeScript.run = function(code, options) {
+    if (options == null) {
+      options = {};
+    }
+    options.bare = true;
+    return Function(CoffeeScript.compile(code, options))();
+  };
+
+  if (typeof window === "undefined" || window === null) {
+    return;
+  }
+
+  CoffeeScript.load = function(url, callback) {
+    var xhr;
+    xhr = new (window.ActiveXObject || XMLHttpRequest)('Microsoft.XMLHTTP');
+    xhr.open('GET', url, true);
+    if ('overrideMimeType' in xhr) {
+      xhr.overrideMimeType('text/plain');
+    }
+    xhr.onreadystatechange = function() {
+      var _ref;
+      if (xhr.readyState === 4) {
+        if ((_ref = xhr.status) === 0 || _ref === 200) {
+          CoffeeScript.run(xhr.responseText);
+        } else {
+          throw new Error("Could not load " + url);
+        }
+        if (callback) {
+          return callback();
+        }
+      }
+    };
+    return xhr.send(null);
+  };
+
+  runScripts = function() {
+    var coffees, execute, index, length, s, scripts;
+    scripts = document.getElementsByTagName('script');
+    coffees = (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = scripts.length; _i < _len; _i++) {
+        s = scripts[_i];
+        if (s.type === 'text/coffeescript') {
+          _results.push(s);
+        }
+      }
+      return _results;
+    })();
+    index = 0;
+    length = coffees.length;
+    (execute = function() {
+      var script;
+      script = coffees[index++];
+      if ((script != null ? script.type : void 0) === 'text/coffeescript') {
+        if (script.src) {
+          return CoffeeScript.load(script.src, execute);
+        } else {
+          CoffeeScript.run(script.innerHTML);
+          return execute();
+        }
+      }
+    })();
+    return null;
+  };
+
+  if (window.addEventListener) {
+    addEventListener('DOMContentLoaded', runScripts, false);
+  } else {
+    attachEvent('onload', runScripts);
+  }
+
+}).call(this);

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/lib/coffee-script/cake.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var CoffeeScript, cakefileDirectory, fatalError, fs, helpers, missingTask, oparse, options, optparse, path, printTasks, switches, tasks;
+
+  fs = require('fs');
+
+  path = require('path');
+
+  helpers = require('./helpers');
+
+  optparse = require('./optparse');
+
+  CoffeeScript = require('./coffee-script');
+
+  tasks = {};
+
+  options = {};
+
+  switches = [];
+
+  oparse = null;
+
+  helpers.extend(global, {
+    task: function(name, description, action) {
+      var _ref;
+      if (!action) {
+        _ref = [description, action], action = _ref[0], description = _ref[1];
+      }
+      return tasks[name] = {
+        name: name,
+        description: description,
+        action: action
+      };
+    },
+    option: function(letter, flag, description) {
+      return switches.push([letter, flag, description]);
+    },
+    invoke: function(name) {
+      if (!tasks[name]) {
+        missingTask(name);
+      }
+      return tasks[name].action(options);
+    }
+  });
+
+  exports.run = function() {
+    var arg, args, _i, _len, _ref, _results;
+    global.__originalDirname = fs.realpathSync('.');
+    process.chdir(cakefileDirectory(__originalDirname));
+    args = process.argv.slice(2);
+    CoffeeScript.run(fs.readFileSync('Cakefile').toString(), {
+      filename: 'Cakefile'
+    });
+    oparse = new optparse.OptionParser(switches);
+    if (!args.length) {
+      return printTasks();
+    }
+    try {
+      options = oparse.parse(args);
+    } catch (e) {
+      return fatalError("" + e);
+    }
+    _ref = options["arguments"];
+    _results = [];
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      arg = _ref[_i];
+      _results.push(invoke(arg));
+    }
+    return _results;
+  };
+
+  printTasks = function() {
+    var cakefilePath, desc, name, relative, spaces, task;
+    relative = path.relative || path.resolve;
+    cakefilePath = path.join(relative(__originalDirname, process.cwd()), 'Cakefile');
+    console.log("" + cakefilePath + " defines the following tasks:\n");
+    for (name in tasks) {
+      task = tasks[name];
+      spaces = 20 - name.length;
+      spaces = spaces > 0 ? Array(spaces + 1).join(' ') : '';
+      desc = task.description ? "# " + task.description : '';
+      console.log("cake " + name + spaces + " " + desc);
+    }
+    if (switches.length) {
+      return console.log(oparse.help());
+    }
+  };
+
+  fatalError = function(message) {
+    console.error(message + '\n');
+    console.log('To see a list of all tasks/options, run "cake"');
+    return process.exit(1);
+  };
+
+  missingTask = function(task) {
+    return fatalError("No such task: " + task);
+  };
+
+  cakefileDirectory = function(dir) {
+    var parent;
+    if (path.existsSync(path.join(dir, 'Cakefile'))) {
+      return dir;
+    }
+    parent = path.normalize(path.join(dir, '..'));
+    if (parent !== dir) {
+      return cakefileDirectory(parent);
+    }
+    throw new Error("Cakefile not found in " + (process.cwd()));
+  };
+
+}).call(this);

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/lib/coffee-script/coffee-script.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var Lexer, RESERVED, compile, fs, lexer, parser, path, vm, _ref,
+    __hasProp = {}.hasOwnProperty;
+
+  fs = require('fs');
+
+  path = require('path');
+
+  _ref = require('./lexer'), Lexer = _ref.Lexer, RESERVED = _ref.RESERVED;
+
+  parser = require('./parser').parser;
+
+  vm = require('vm');
+
+  if (require.extensions) {
+    require.extensions['.coffee'] = function(module, filename) {
+      var content;
+      content = compile(fs.readFileSync(filename, 'utf8'), {
+        filename: filename
+      });
+      return module._compile(content, filename);
+    };
+  } else if (require.registerExtension) {
+    require.registerExtension('.coffee', function(content) {
+      return compile(content);
+    });
+  }
+
+  exports.VERSION = '1.3.3';
+
+  exports.RESERVED = RESERVED;
+
+  exports.helpers = require('./helpers');
+
+  exports.compile = compile = function(code, options) {
+    var header, js, merge;
+    if (options == null) {
+      options = {};
+    }
+    merge = exports.helpers.merge;
+    try {
+      js = (parser.parse(lexer.tokenize(code))).compile(options);
+      if (!options.header) {
+        return js;
+      }
+    } catch (err) {
+      if (options.filename) {
+        err.message = "In " + options.filename + ", " + err.message;
+      }
+      throw err;
+    }
+    header = "Generated by CoffeeScript " + this.VERSION;
+    return "// " + header + "\n" + js;
+  };
+
+  exports.tokens = function(code, options) {
+    return lexer.tokenize(code, options);
+  };
+
+  exports.nodes = function(source, options) {
+    if (typeof source === 'string') {
+      return parser.parse(lexer.tokenize(source, options));
+    } else {
+      return parser.parse(source);
+    }
+  };
+
+  exports.run = function(code, options) {
+    var mainModule;
+    if (options == null) {
+      options = {};
+    }
+    mainModule = require.main;
+    mainModule.filename = process.argv[1] = options.filename ? fs.realpathSync(options.filename) : '.';
+    mainModule.moduleCache && (mainModule.moduleCache = {});
+    mainModule.paths = require('module')._nodeModulePaths(path.dirname(fs.realpathSync(options.filename)));
+    if (path.extname(mainModule.filename) !== '.coffee' || require.extensions) {
+      return mainModule._compile(compile(code, options), mainModule.filename);
+    } else {
+      return mainModule._compile(code, mainModule.filename);
+    }
+  };
+
+  exports["eval"] = function(code, options) {
+    var Module, Script, js, k, o, r, sandbox, v, _i, _len, _module, _ref1, _ref2, _require;
+    if (options == null) {
+      options = {};
+    }
+    if (!(code = code.trim())) {
+      return;
+    }
+    Script = vm.Script;
+    if (Script) {
+      if (options.sandbox != null) {
+        if (options.sandbox instanceof Script.createContext().constructor) {
+          sandbox = options.sandbox;
+        } else {
+          sandbox = Script.createContext();
+          _ref1 = options.sandbox;
+          for (k in _ref1) {
+            if (!__hasProp.call(_ref1, k)) continue;
+            v = _ref1[k];
+            sandbox[k] = v;
+          }
+        }
+        sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox;
+      } else {
+        sandbox = global;
+      }
+      sandbox.__filename = options.filename || 'eval';
+      sandbox.__dirname = path.dirname(sandbox.__filename);
+      if (!(sandbox !== global || sandbox.module || sandbox.require)) {
+        Module = require('module');
+        sandbox.module = _module = new Module(options.modulename || 'eval');
+        sandbox.require = _require = function(path) {
+          return Module._load(path, _module, true);
+        };
+        _module.filename = sandbox.__filename;
+        _ref2 = Object.getOwnPropertyNames(require);
+        for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+          r = _ref2[_i];
+          if (r !== 'paths') {
+            _require[r] = require[r];
+          }
+        }
+        _require.paths = _module.paths = Module._nodeModulePaths(process.cwd());
+        _require.resolve = function(request) {
+          return Module._resolveFilename(request, _module);
+        };
+      }
+    }
+    o = {};
+    for (k in options) {
+      if (!__hasProp.call(options, k)) continue;
+      v = options[k];
+      o[k] = v;
+    }
+    o.bare = true;
+    js = compile(code, o);
+    if (sandbox === global) {
+      return vm.runInThisContext(js);
+    } else {
+      return vm.runInContext(js, sandbox);
+    }
+  };
+
+  lexer = new Lexer;
+
+  parser.lexer = {
+    lex: function() {
+      var tag, _ref1;
+      _ref1 = this.tokens[this.pos++] || [''], tag = _ref1[0], this.yytext = _ref1[1], this.yylineno = _ref1[2];
+      return tag;
+    },
+    setInput: function(tokens) {
+      this.tokens = tokens;
+      return this.pos = 0;
+    },
+    upcomingInput: function() {
+      return "";
+    }
+  };
+
+  parser.yy = require('./nodes');
+
+}).call(this);

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/lib/coffee-script/helpers.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var extend, flatten;
+
+  exports.starts = function(string, literal, start) {
+    return literal === string.substr(start, literal.length);
+  };
+
+  exports.ends = function(string, literal, back) {
+    var len;
+    len = literal.length;
+    return literal === string.substr(string.length - len - (back || 0), len);
+  };
+
+  exports.compact = function(array) {
+    var item, _i, _len, _results;
+    _results = [];
+    for (_i = 0, _len = array.length; _i < _len; _i++) {
+      item = array[_i];
+      if (item) {
+        _results.push(item);
+      }
+    }
+    return _results;
+  };
+
+  exports.count = function(string, substr) {
+    var num, pos;
+    num = pos = 0;
+    if (!substr.length) {
+      return 1 / 0;
+    }
+    while (pos = 1 + string.indexOf(substr, pos)) {
+      num++;
+    }
+    return num;
+  };
+
+  exports.merge = function(options, overrides) {
+    return extend(extend({}, options), overrides);
+  };
+
+  extend = exports.extend = function(object, properties) {
+    var key, val;
+    for (key in properties) {
+      val = properties[key];
+      object[key] = val;
+    }
+    return object;
+  };
+
+  exports.flatten = flatten = function(array) {
+    var element, flattened, _i, _len;
+    flattened = [];
+    for (_i = 0, _len = array.length; _i < _len; _i++) {
+      element = array[_i];
+      if (element instanceof Array) {
+        flattened = flattened.concat(flatten(element));
+      } else {
+        flattened.push(element);
+      }
+    }
+    return flattened;
+  };
+
+  exports.del = function(obj, key) {
+    var val;
+    val = obj[key];
+    delete obj[key];
+    return val;
+  };
+
+  exports.last = function(array, back) {
+    return array[array.length - (back || 0) - 1];
+  };
+
+}).call(this);

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/lib/coffee-script/index.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var key, val, _ref;
+
+  _ref = require('./coffee-script');
+  for (key in _ref) {
+    val = _ref[key];
+    exports[key] = val;
+  }
+
+}).call(this);

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/lib/coffee-script/optparse.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var LONG_FLAG, MULTI_FLAG, OPTIONAL, OptionParser, SHORT_FLAG, buildRule, buildRules, normalizeArguments;
+
+  exports.OptionParser = OptionParser = (function() {
+
+    function OptionParser(rules, banner) {
+      this.banner = banner;
+      this.rules = buildRules(rules);
+    }
+
+    OptionParser.prototype.parse = function(args) {
+      var arg, i, isOption, matchedRule, options, originalArgs, pos, rule, seenNonOptionArg, skippingArgument, value, _i, _j, _len, _len1, _ref;
+      options = {
+        "arguments": []
+      };
+      skippingArgument = false;
+      originalArgs = args;
+      args = normalizeArguments(args);
+      for (i = _i = 0, _len = args.length; _i < _len; i = ++_i) {
+        arg = args[i];
+        if (skippingArgument) {
+          skippingArgument = false;
+          continue;
+        }
+        if (arg === '--') {
+          pos = originalArgs.indexOf('--');
+          options["arguments"] = options["arguments"].concat(originalArgs.slice(pos + 1));
+          break;
+        }
+        isOption = !!(arg.match(LONG_FLAG) || arg.match(SHORT_FLAG));
+        seenNonOptionArg = options["arguments"].length > 0;
+        if (!seenNonOptionArg) {
+          matchedRule = false;
+          _ref = this.rules;
+          for (_j = 0, _len1 = _ref.length; _j < _len1; _j++) {
+            rule = _ref[_j];
+            if (rule.shortFlag === arg || rule.longFlag === arg) {
+              value = true;
+              if (rule.hasArgument) {
+                skippingArgument = true;
+                value = args[i + 1];
+              }
+              options[rule.name] = rule.isList ? (options[rule.name] || []).concat(value) : value;
+              matchedRule = true;
+              break;
+            }
+          }
+          if (isOption && !matchedRule) {
+            throw new Error("unrecognized option: " + arg);
+          }
+        }
+        if (seenNonOptionArg || !isOption) {
+          options["arguments"].push(arg);
+        }
+      }
+      return options;
+    };
+
+    OptionParser.prototype.help = function() {
+      var letPart, lines, rule, spaces, _i, _len, _ref;
+      lines = [];
+      if (this.banner) {
+        lines.unshift("" + this.banner + "\n");
+      }
+      _ref = this.rules;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        rule = _ref[_i];
+        spaces = 15 - rule.longFlag.length;
+        spaces = spaces > 0 ? Array(spaces + 1).join(' ') : '';
+        letPart = rule.shortFlag ? rule.shortFlag + ', ' : '    ';
+        lines.push('  ' + letPart + rule.longFlag + spaces + rule.description);
+      }
+      return "\n" + (lines.join('\n')) + "\n";
+    };
+
+    return OptionParser;
+
+  })();
+
+  LONG_FLAG = /^(--\w[\w\-]*)/;
+
+  SHORT_FLAG = /^(-\w)$/;
+
+  MULTI_FLAG = /^-(\w{2,})/;
+
+  OPTIONAL = /\[(\w+(\*?))\]/;
+
+  buildRules = function(rules) {
+    var tuple, _i, _len, _results;
+    _results = [];
+    for (_i = 0, _len = rules.length; _i < _len; _i++) {
+      tuple = rules[_i];
+      if (tuple.length < 3) {
+        tuple.unshift(null);
+      }
+      _results.push(buildRule.apply(null, tuple));
+    }
+    return _results;
+  };
+
+  buildRule = function(shortFlag, longFlag, description, options) {
+    var match;
+    if (options == null) {
+      options = {};
+    }
+    match = longFlag.match(OPTIONAL);
+    longFlag = longFlag.match(LONG_FLAG)[1];
+    return {
+      name: longFlag.substr(2),
+      shortFlag: shortFlag,
+      longFlag: longFlag,
+      description: description,
+      hasArgument: !!(match && match[1]),
+      isList: !!(match && match[2])
+    };
+  };
+
+  normalizeArguments = function(args) {
+    var arg, l, match, result, _i, _j, _len, _len1, _ref;
+    args = args.slice(0);
+    result = [];
+    for (_i = 0, _len = args.length; _i < _len; _i++) {
+      arg = args[_i];
+      if (match = arg.match(MULTI_FLAG)) {
+        _ref = match[1].split('');
+        for (_j = 0, _len1 = _ref.length; _j < _len1; _j++) {
+          l = _ref[_j];
+          result.push('-' + l);
+        }
+      } else {
+        result.push(arg);
+      }
+    }
+    return result;
+  };
+
+}).call(this);

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/lib/coffee-script/repl.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var ACCESSOR, CoffeeScript, Module, REPL_PROMPT, REPL_PROMPT_CONTINUATION, REPL_PROMPT_MULTILINE, SIMPLEVAR, Script, autocomplete, backlog, completeAttribute, completeVariable, enableColours, error, getCompletions, inspect, multilineMode, pipedInput, readline, repl, run, stdin, stdout;
+
+  stdin = process.openStdin();
+
+  stdout = process.stdout;
+
+  CoffeeScript = require('./coffee-script');
+
+  readline = require('readline');
+
+  inspect = require('util').inspect;
+
+  Script = require('vm').Script;
+
+  Module = require('module');
+
+  REPL_PROMPT = 'coffee> ';
+
+  REPL_PROMPT_MULTILINE = '------> ';
+
+  REPL_PROMPT_CONTINUATION = '......> ';
+
+  enableColours = false;
+
+  if (process.platform !== 'win32') {
+    enableColours = !process.env.NODE_DISABLE_COLORS;
+  }
+
+  error = function(err) {
+    return stdout.write((err.stack || err.toString()) + '\n');
+  };
+
+  ACCESSOR = /\s*([\w\.]+)(?:\.(\w*))$/;
+
+  SIMPLEVAR = /(\w+)$/i;
+
+  autocomplete = function(text) {
+    return completeAttribute(text) || completeVariable(text) || [[], text];
+  };
+
+  completeAttribute = function(text) {
+    var all, completions, key, match, obj, possibilities, prefix, val;
+    if (match = text.match(ACCESSOR)) {
+      all = match[0], obj = match[1], prefix = match[2];
+      try {
+        val = Script.runInThisContext(obj);
+      } catch (error) {
+        return;
+      }
+      val = Object(val);
+      possibilities = Object.getOwnPropertyNames(val);
+      for (key in val) {
+        if (~possibilities.indexOf(val)) {
+          possibilities.push(key);
+        }
+      }
+      completions = getCompletions(prefix, possibilities);
+      return [completions, prefix];
+    }
+  };
+
+  completeVariable = function(text) {
+    var completions, free, keywords, possibilities, r, vars, _ref;
+    free = (_ref = text.match(SIMPLEVAR)) != null ? _ref[1] : void 0;
+    if (text === "") {
+      free = "";
+    }
+    if (free != null) {
+      vars = Script.runInThisContext('Object.getOwnPropertyNames(Object(this))');
+      keywords = (function() {
+        var _i, _len, _ref1, _results;
+        _ref1 = CoffeeScript.RESERVED;
+        _results = [];
+        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+          r = _ref1[_i];
+          if (r.slice(0, 2) !== '__') {
+            _results.push(r);
+          }
+        }
+        return _results;
+      })();
+      possibilities = vars.concat(keywords);
+      completions = getCompletions(free, possibilities);
+      return [completions, free];
+    }
+  };
+
+  getCompletions = function(prefix, candidates) {
+    var el, _i, _len, _results;
+    _results = [];
+    for (_i = 0, _len = candidates.length; _i < _len; _i++) {
+      el = candidates[_i];
+      if (el.indexOf(prefix) === 0) {
+        _results.push(el);
+      }
+    }
+    return _results;
+  };
+
+  process.on('uncaughtException', error);
+
+  backlog = '';
+
+  run = function(buffer) {
+    var code, returnValue, _;
+    buffer = buffer.replace(/(^|[\r\n]+)(\s*)##?(?:[^#\r\n][^\r\n]*|)($|[\r\n])/, "$1$2$3");
+    buffer = buffer.replace(/[\r\n]+$/, "");
+    if (multilineMode) {
+      backlog += "" + buffer + "\n";
+      repl.setPrompt(REPL_PROMPT_CONTINUATION);
+      repl.prompt();
+      return;
+    }
+    if (!buffer.toString().trim() && !backlog) {
+      repl.prompt();
+      return;
+    }
+    code = backlog += buffer;
+    if (code[code.length - 1] === '\\') {
+      backlog = "" + backlog.slice(0, -1) + "\n";
+      repl.setPrompt(REPL_PROMPT_CONTINUATION);
+      repl.prompt();
+      return;
+    }
+    repl.setPrompt(REPL_PROMPT);
+    backlog = '';
+    try {
+      _ = global._;
+      returnValue = CoffeeScript["eval"]("_=(" + code + "\n)", {
+        filename: 'repl',
+        modulename: 'repl'
+      });
+      if (returnValue === void 0) {
+        global._ = _;
+      }
+      repl.output.write("" + (inspect(returnValue, false, 2, enableColours)) + "\n");
+    } catch (err) {
+      error(err);
+    }
+    return repl.prompt();
+  };
+
+  if (stdin.readable) {
+    pipedInput = '';
+    repl = {
+      prompt: function() {
+        return stdout.write(this._prompt);
+      },
+      setPrompt: function(p) {
+        return this._prompt = p;
+      },
+      input: stdin,
+      output: stdout,
+      on: function() {}
+    };
+    stdin.on('data', function(chunk) {
+      var line, lines, _i, _len, _ref;
+      pipedInput += chunk;
+      if (!/\n/.test(pipedInput)) {
+        return;
+      }
+      lines = pipedInput.split("\n");
+      pipedInput = lines[lines.length - 1];
+      _ref = lines.slice(0, -1);
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        line = _ref[_i];
+        if (!(line)) {
+          continue;
+        }
+        stdout.write("" + line + "\n");
+        run(line);
+      }
+    });
+    stdin.on('end', function() {
+      var line, _i, _len, _ref;
+      _ref = pipedInput.trim().split("\n");
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        line = _ref[_i];
+        if (!(line)) {
+          continue;
+        }
+        stdout.write("" + line + "\n");
+        run(line);
+      }
+      stdout.write('\n');
+      return process.exit(0);
+    });
+  } else {
+    if (readline.createInterface.length < 3) {
+      repl = readline.createInterface(stdin, autocomplete);
+      stdin.on('data', function(buffer) {
+        return repl.write(buffer);
+      });
+    } else {
+      repl = readline.createInterface(stdin, stdout, autocomplete);
+    }
+  }
+
+  multilineMode = false;
+
+  repl.input.on('keypress', function(char, key) {
+    var cursorPos, newPrompt;
+    if (!(key && key.ctrl && !key.meta && !key.shift && key.name === 'v')) {
+      return;
+    }
+    cursorPos = repl.cursor;
+    repl.output.cursorTo(0);
+    repl.output.clearLine(1);
+    multilineMode = !multilineMode;
+    if (!multilineMode && backlog) {
+      repl._line();
+    }
+    backlog = '';
+    repl.setPrompt((newPrompt = multilineMode ? REPL_PROMPT_MULTILINE : REPL_PROMPT));
+    repl.prompt();
+    return repl.output.cursorTo(newPrompt.length + (repl.cursor = cursorPos));
+  });
+
+  repl.input.on('keypress', function(char, key) {
+    if (!(multilineMode && repl.line)) {
+      return;
+    }
+    if (!(key && key.ctrl && !key.meta && !key.shift && key.name === 'd')) {
+      return;
+    }
+    multilineMode = false;
+    return repl._line();
+  });
+
+  repl.on('attemptClose', function() {
+    if (multilineMode) {
+      multilineMode = false;
+      repl.output.cursorTo(0);
+      repl.output.clearLine(1);
+      repl._onLine(repl.line);
+      return;
+    }
+    if (backlog) {
+      backlog = '';
+      repl.output.write('\n');
+      repl.setPrompt(REPL_PROMPT);
+      return repl.prompt();
+    } else {
+      return repl.close();
+    }
+  });
+
+  repl.on('close', function() {
+    repl.output.write('\n');
+    return repl.input.destroy();
+  });
+
+  repl.on('line', run);
+
+  repl.setPrompt(REPL_PROMPT);
+
+  repl.prompt();
+
+}).call(this);

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/lib/coffee-script/scope.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var Scope, extend, last, _ref;
+
+  _ref = require('./helpers'), extend = _ref.extend, last = _ref.last;
+
+  exports.Scope = Scope = (function() {
+
+    Scope.root = null;
+
+    function Scope(parent, expressions, method) {
+      this.parent = parent;
+      this.expressions = expressions;
+      this.method = method;
+      this.variables = [
+        {
+          name: 'arguments',
+          type: 'arguments'
+        }
+      ];
+      this.positions = {};
+      if (!this.parent) {
+        Scope.root = this;
+      }
+    }
+
+    Scope.prototype.add = function(name, type, immediate) {
+      if (this.shared && !immediate) {
+        return this.parent.add(name, type, immediate);
+      }
+      if (Object.prototype.hasOwnProperty.call(this.positions, name)) {
+        return this.variables[this.positions[name]].type = type;
+      } else {
+        return this.positions[name] = this.variables.push({
+          name: name,
+          type: type
+        }) - 1;
+      }
+    };
+
+    Scope.prototype.namedMethod = function() {
+      if (this.method.name || !this.parent) {
+        return this.method;
+      }
+      return this.parent.namedMethod();
+    };
+
+    Scope.prototype.find = function(name) {
+      if (this.check(name)) {
+        return true;
+      }
+      this.add(name, 'var');
+      return false;
+    };
+
+    Scope.prototype.parameter = function(name) {
+      if (this.shared && this.parent.check(name, true)) {
+        return;
+      }
+      return this.add(name, 'param');
+    };
+
+    Scope.prototype.check = function(name) {
+      var _ref1;
+      return !!(this.type(name) || ((_ref1 = this.parent) != null ? _ref1.check(name) : void 0));
+    };
+
+    Scope.prototype.temporary = function(name, index) {
+      if (name.length > 1) {
+        return '_' + name + (index > 1 ? index - 1 : '');
+      } else {
+        return '_' + (index + parseInt(name, 36)).toString(36).replace(/\d/g, 'a');
+      }
+    };
+
+    Scope.prototype.type = function(name) {
+      var v, _i, _len, _ref1;
+      _ref1 = this.variables;
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        v = _ref1[_i];
+        if (v.name === name) {
+          return v.type;
+        }
+      }
+      return null;
+    };
+
+    Scope.prototype.freeVariable = function(name, reserve) {
+      var index, temp;
+      if (reserve == null) {
+        reserve = true;
+      }
+      index = 0;
+      while (this.check((temp = this.temporary(name, index)))) {
+        index++;
+      }
+      if (reserve) {
+        this.add(temp, 'var', true);
+      }
+      return temp;
+    };
+
+    Scope.prototype.assign = function(name, value) {
+      this.add(name, {
+        value: value,
+        assigned: true
+      }, true);
+      return this.hasAssignments = true;
+    };
+
+    Scope.prototype.hasDeclarations = function() {
+      return !!this.declaredVariables().length;
+    };
+
+    Scope.prototype.declaredVariables = function() {
+      var realVars, tempVars, v, _i, _len, _ref1;
+      realVars = [];
+      tempVars = [];
+      _ref1 = this.variables;
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        v = _ref1[_i];
+        if (v.type === 'var') {
+          (v.name.charAt(0) === '_' ? tempVars : realVars).push(v.name);
+        }
+      }
+      return realVars.sort().concat(tempVars.sort());
+    };
+
+    Scope.prototype.assignedVariables = function() {
+      var v, _i, _len, _ref1, _results;
+      _ref1 = this.variables;
+      _results = [];
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        v = _ref1[_i];
+        if (v.type.assigned) {
+          _results.push("" + v.name + " = " + v.type.value);
+        }
+      }
+      return _results;
+    };
+
+    return Scope;
+
+  })();
+
+}).call(this);

common/lib/xmodule/xmodule/tests/test_files/js/coffee-script/package.json

+{
+  "name":         "coffee-script",
+  "description":  "Unfancy JavaScript",
+  "keywords":     ["javascript", "language", "coffeescript", "compiler"],
+  "author":       "Jeremy Ashkenas",
+  "version":      "1.3.3",
+  "licenses":     [{
+    "type":       "MIT",
+    "url":        "https://raw.github.com/jashkenas/coffee-script/master/LICENSE"
+  }],
+  "engines":      {
+    "node":       ">=0.4.0"
+  },
+  "directories" : {
+    "lib" : "./lib/coffee-script"
+  },
+  "main" : "./lib/coffee-script/coffee-script",
+  "bin":          {
+    "coffee":     "./bin/coffee",
+    "cake":       "./bin/cake"
+  },
+  "homepage":     "http://coffeescript.org",
+  "bugs":         "https://github.com/jashkenas/coffee-script/issues",
+  "repository":   {
+    "type": "git",
+    "url": "git://github.com/jashkenas/coffee-script.git"
+  },
+  "devDependencies": {
+    "uglify-js":  ">=1.0.0",
+    "jison":      ">=0.2.0"
+  }
+}

common/lib/xmodule/xmodule/tests/test_files/js/compiled/c9a9cd4242d84c924fe5f8324e9ae79d.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var MinimaxProblemDisplay, root,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  MinimaxProblemDisplay = (function(_super) {
+
+    __extends(MinimaxProblemDisplay, _super);
+
+    function MinimaxProblemDisplay(state, submission, evaluation, container, submissionField, parameters) {
+      this.state = state;
+      this.submission = submission;
+      this.evaluation = evaluation;
+      this.container = container;
+      this.submissionField = submissionField;
+      this.parameters = parameters != null ? parameters : {};
+      MinimaxProblemDisplay.__super__.constructor.call(this, this.state, this.submission, this.evaluation, this.container, this.submissionField, this.parameters);
+    }
+
+    MinimaxProblemDisplay.prototype.render = function() {};
+
+    MinimaxProblemDisplay.prototype.createSubmission = function() {
+      var id, value, _ref, _results;
+      this.newSubmission = {};
+      if (this.submission != null) {
+        _ref = this.submission;
+        _results = [];
+        for (id in _ref) {
+          value = _ref[id];
+          _results.push(this.newSubmission[id] = value);
+        }
+        return _results;
+      }
+    };
+
+    MinimaxProblemDisplay.prototype.getCurrentSubmission = function() {
+      return this.newSubmission;
+    };
+
+    return MinimaxProblemDisplay;
+
+  })(XProblemDisplay);
+
+  root = typeof exports !== "undefined" && exports !== null ? exports : this;
+
+  root.TestProblemDisplay = TestProblemDisplay;
+
+}).call(this);
+;

common/lib/xmodule/xmodule/tests/test_files/js/mersenne-twister-min.js

+/*
+  I've wrapped Makoto Matsumoto and Takuji Nishimura's code in a namespace
+  so it's better encapsulated. Now you can have multiple random number generators
+  and they won't stomp all over eachother's state.
+  
+  If you want to use this as a substitute for Math.random(), use the random()
+  method like so:
+  
+  var m = new MersenneTwister();
+  var randomNumber = m.random();
+  
+  You can also call the other genrand_{foo}() methods on the instance.
+
+  If you want to use a specific seed in order to get a repeatable random
+  sequence, pass an integer into the constructor:
+
+  var m = new MersenneTwister(123);
+
+  and that will always produce the same random sequence.
+
+  Sean McCullough (banksean@gmail.com)
+*/
+
+/* 
+   A C-program for MT19937, with initialization improved 2002/1/26.
+   Coded by Takuji Nishimura and Makoto Matsumoto.
+ 
+   Before using, initialize the state by using init_genrand(seed)  
+   or init_by_array(init_key, key_length).
+ 
+   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+   All rights reserved.                          
+ 
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+ 
+     1. Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+ 
+     2. Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+ 
+     3. The names of its contributors may not be used to endorse or promote 
+        products derived from this software without specific prior written 
+        permission.
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+ 
+   Any feedback is very welcome.
+   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+*/
+
+var MersenneTwister = function(seed) {
+  if (seed == undefined) {
+    seed = new Date().getTime();
+  } 
+  /* Period parameters */  
+  this.N = 624;
+  this.M = 397;
+  this.MATRIX_A = 0x9908b0df;   /* constant vector a */
+  this.UPPER_MASK = 0x80000000; /* most significant w-r bits */
+  this.LOWER_MASK = 0x7fffffff; /* least significant r bits */
+ 
+  this.mt = new Array(this.N); /* the array for the state vector */
+  this.mti=this.N+1; /* mti==N+1 means mt[N] is not initialized */
+
+  this.init_genrand(seed);
+}  
+ 
+/* initializes mt[N] with a seed */
+MersenneTwister.prototype.init_genrand = function(s) {
+  this.mt[0] = s >>> 0;
+  for (this.mti=1; this.mti<this.N; this.mti++) {
+      var s = this.mt[this.mti-1] ^ (this.mt[this.mti-1] >>> 30);
+   this.mt[this.mti] = (((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253)
+  + this.mti;
+      /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+      /* In the previous versions, MSBs of the seed affect   */
+      /* only MSBs of the array mt[].                        */
+      /* 2002/01/09 modified by Makoto Matsumoto             */
+      this.mt[this.mti] >>>= 0;
+      /* for >32 bit machines */
+  }
+}
+ 
+/* initialize by an array with array-length */
+/* init_key is the array for initializing keys */
+/* key_length is its length */
+/* slight change for C++, 2004/2/26 */
+MersenneTwister.prototype.init_by_array = function(init_key, key_length) {
+  var i, j, k;
+  this.init_genrand(19650218);
+  i=1; j=0;
+  k = (this.N>key_length ? this.N : key_length);
+  for (; k; k--) {
+    var s = this.mt[i-1] ^ (this.mt[i-1] >>> 30)
+    this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1664525) << 16) + ((s & 0x0000ffff) * 1664525)))
+      + init_key[j] + j; /* non linear */
+    this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
+    i++; j++;
+    if (i>=this.N) { this.mt[0] = this.mt[this.N-1]; i=1; }
+    if (j>=key_length) j=0;
+  }
+  for (k=this.N-1; k; k--) {
+    var s = this.mt[i-1] ^ (this.mt[i-1] >>> 30);
+    this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) + (s & 0x0000ffff) * 1566083941))
+      - i; /* non linear */
+    this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
+    i++;
+    if (i>=this.N) { this.mt[0] = this.mt[this.N-1]; i=1; }
+  }
+
+  this.mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */ 
+}
+ 
+/* generates a random number on [0,0xffffffff]-interval */
+MersenneTwister.prototype.genrand_int32 = function() {
+  var y;
+  var mag01 = new Array(0x0, this.MATRIX_A);
+  /* mag01[x] = x * MATRIX_A  for x=0,1 */
+
+  if (this.mti >= this.N) { /* generate N words at one time */
+    var kk;
+
+    if (this.mti == this.N+1)   /* if init_genrand() has not been called, */
+      this.init_genrand(5489); /* a default initial seed is used */
+
+    for (kk=0;kk<this.N-this.M;kk++) {
+      y = (this.mt[kk]&this.UPPER_MASK)|(this.mt[kk+1]&this.LOWER_MASK);
+      this.mt[kk] = this.mt[kk+this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
+    }
+    for (;kk<this.N-1;kk++) {
+      y = (this.mt[kk]&this.UPPER_MASK)|(this.mt[kk+1]&this.LOWER_MASK);
+      this.mt[kk] = this.mt[kk+(this.M-this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
+    }
+    y = (this.mt[this.N-1]&this.UPPER_MASK)|(this.mt[0]&this.LOWER_MASK);
+    this.mt[this.N-1] = this.mt[this.M-1] ^ (y >>> 1) ^ mag01[y & 0x1];
+
+    this.mti = 0;
+  }
+
+  y = this.mt[this.mti++];
+
+  /* Tempering */
+  y ^= (y >>> 11);
+  y ^= (y << 7) & 0x9d2c5680;
+  y ^= (y << 15) & 0xefc60000;
+  y ^= (y >>> 18);
+
+  return y >>> 0;
+}
+ 
+/* generates a random number on [0,0x7fffffff]-interval */
+MersenneTwister.prototype.genrand_int31 = function() {
+  return (this.genrand_int32()>>>1);
+}
+ 
+/* generates a random number on [0,1]-real-interval */
+MersenneTwister.prototype.genrand_real1 = function() {
+  return this.genrand_int32()*(1.0/4294967295.0); 
+  /* divided by 2^32-1 */ 
+}
+
+/* generates a random number on [0,1)-real-interval */
+MersenneTwister.prototype.random = function() {
+  return this.genrand_int32()*(1.0/4294967296.0); 
+  /* divided by 2^32 */
+}
+ 
+/* generates a random number on (0,1)-real-interval */
+MersenneTwister.prototype.genrand_real3 = function() {
+  return (this.genrand_int32() + 0.5)*(1.0/4294967296.0); 
+  /* divided by 2^32 */
+}
+ 
+/* generates a random number on [0,1) with 53-bit resolution*/
+MersenneTwister.prototype.genrand_res53 = function() { 
+  var a=this.genrand_int32()>>>5, b=this.genrand_int32()>>>6; 
+  return(a*67108864.0+b)*(1.0/9007199254740992.0); 
+} 
+
+/* These real versions are due to Isaku Wada, 2002/01/09 added */
+if(typeof exports == 'undefined'){
+  var root = this;
+} else {
+  var root = exports;
+}
+root.MersenneTwister = MersenneTwister;

common/lib/xmodule/xmodule/tests/test_files/js/test_problem_display.coffee

+class MinimaxProblemDisplay extends XProblemDisplay
+
+  constructor: (@state, @submission, @evaluation, @container, @submissionField, @parameters={}) ->
+
+    super(@state, @submission, @evaluation, @container, @submissionField, @parameters)
+
+  render: () ->
+
+  createSubmission: () ->
+
+    @newSubmission = {}
+
+    if @submission?
+      for id, value of @submission
+        @newSubmission[id] = value
+
+  getCurrentSubmission: () ->
+    return @newSubmission
+
+root = exports ? this
+root.TestProblemDisplay = TestProblemDisplay

common/lib/xmodule/xmodule/tests/test_files/js/test_problem_display.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var MinimaxProblemDisplay, root,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  MinimaxProblemDisplay = (function(_super) {
+
+    __extends(MinimaxProblemDisplay, _super);
+
+    function MinimaxProblemDisplay(state, submission, evaluation, container, submissionField, parameters) {
+      this.state = state;
+      this.submission = submission;
+      this.evaluation = evaluation;
+      this.container = container;
+      this.submissionField = submissionField;
+      this.parameters = parameters != null ? parameters : {};
+      MinimaxProblemDisplay.__super__.constructor.call(this, this.state, this.submission, this.evaluation, this.container, this.submissionField, this.parameters);
+    }
+
+    MinimaxProblemDisplay.prototype.render = function() {};
+
+    MinimaxProblemDisplay.prototype.createSubmission = function() {
+      var id, value, _ref, _results;
+      this.newSubmission = {};
+      if (this.submission != null) {
+        _ref = this.submission;
+        _results = [];
+        for (id in _ref) {
+          value = _ref[id];
+          _results.push(this.newSubmission[id] = value);
+        }
+        return _results;
+      }
+    };
+
+    MinimaxProblemDisplay.prototype.getCurrentSubmission = function() {
+      return this.newSubmission;
+    };
+
+    return MinimaxProblemDisplay;
+
+  })(XProblemDisplay);
+
+  root = typeof exports !== "undefined" && exports !== null ? exports : this;
+
+  root.TestProblemDisplay = TestProblemDisplay;
+
+}).call(this);

common/lib/xmodule/xmodule/tests/test_files/js/test_problem_generator.coffee

+class TestProblemGenerator extends XProblemGenerator
+
+  constructor: (seed, @parameters = {}) ->
+
+    super(seed, @parameters)
+
+  generate: () ->
+
+    @problemState.value = @parameters.value
+
+    return @problemState
+
+root = exports ? this
+root.generatorClass = TestProblemGenerator

common/lib/xmodule/xmodule/tests/test_files/js/test_problem_generator.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var TestProblemGenerator, root,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  TestProblemGenerator = (function(_super) {
+
+    __extends(TestProblemGenerator, _super);
+
+    function TestProblemGenerator(seed, parameters) {
+      this.parameters = parameters != null ? parameters : {};
+      TestProblemGenerator.__super__.constructor.call(this, seed, this.parameters);
+    }
+
+    TestProblemGenerator.prototype.generate = function() {
+      this.problemState.value = this.parameters.value;
+      return this.problemState;
+    };
+
+    return TestProblemGenerator;
+
+  })(XProblemGenerator);
+
+  root = typeof exports !== "undefined" && exports !== null ? exports : this;
+
+  root.generatorClass = TestProblemGenerator;
+
+}).call(this);

common/lib/xmodule/xmodule/tests/test_files/js/test_problem_grader.coffee

+class TestProblemGrader extends XProblemGrader
+
+  constructor: (@submission, @problemState, @parameters={}) ->
+
+    super(@submission, @problemState, @parameters)
+
+  solve: () ->
+
+    @solution = {0: @problemState.value}
+
+  grade: () ->
+
+    if not @solution?
+      @solve()
+
+    allCorrect = true
+
+    for id, value of @solution
+      valueCorrect = if @submission? then (value == @submission[id]) else false
+      @evaluation[id] = valueCorrect
+      if not valueCorrect
+        allCorrect = false
+
+    return allCorrect
+
+root = exports ? this
+root.graderClass = TestProblemGrader

common/lib/xmodule/xmodule/tests/test_files/js/test_problem_grader.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var TestProblemGrader, root,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  TestProblemGrader = (function(_super) {
+
+    __extends(TestProblemGrader, _super);
+
+    function TestProblemGrader(submission, problemState, parameters) {
+      this.submission = submission;
+      this.problemState = problemState;
+      this.parameters = parameters != null ? parameters : {};
+      TestProblemGrader.__super__.constructor.call(this, this.submission, this.problemState, this.parameters);
+    }
+
+    TestProblemGrader.prototype.solve = function() {
+      return this.solution = {
+        0: this.problemState.value
+      };
+    };
+
+    TestProblemGrader.prototype.grade = function() {
+      var allCorrect, id, value, valueCorrect, _ref;
+      if (!(this.solution != null)) {
+        this.solve();
+      }
+      allCorrect = true;
+      _ref = this.solution;
+      for (id in _ref) {
+        value = _ref[id];
+        valueCorrect = this.submission != null ? value === this.submission[id] : false;
+        this.evaluation[id] = valueCorrect;
+        if (!valueCorrect) {
+          allCorrect = false;
+        }
+      }
+      return allCorrect;
+    };
+
+    return TestProblemGrader;
+
+  })(XProblemGrader);
+
+  root = typeof exports !== "undefined" && exports !== null ? exports : this;
+
+  root.graderClass = TestProblemGrader;
+
+}).call(this);

common/lib/xmodule/xmodule/tests/test_files/js/xproblem.coffee

+class XProblemGenerator
+  
+  constructor: (seed, @parameters={}) ->
+
+    @random = new MersenneTwister(seed)
+
+    @problemState = {}
+
+  generate: () ->
+
+    console.error("Abstract method called: XProblemGenerator.generate")
+
+class XProblemDisplay
+
+  constructor: (@state, @submission, @evaluation, @container, @submissionField, @parameters={}) ->
+
+  render: () ->
+
+    console.error("Abstract method called: XProblemDisplay.render")
+
+  updateSubmission: () ->
+
+    @submissionField.val(JSON.stringify(@getCurrentSubmission()))
+
+  getCurrentSubmission: () ->
+    console.error("Abstract method called: XProblemDisplay.getCurrentSubmission")
+
+class XProblemGrader
+
+  constructor: (@submission, @problemState, @parameters={}) ->
+
+    @solution   = null
+    @evaluation = {}
+
+  solve: () ->
+
+    console.error("Abstract method called: XProblemGrader.solve")
+
+  grade: () ->
+
+    console.error("Abstract method called: XProblemGrader.grade")
+
+root = exports ? this
+
+root.XProblemGenerator = XProblemGenerator
+root.XProblemDisplay   = XProblemDisplay
+root.XProblemGrader    = XProblemGrader

common/lib/xmodule/xmodule/tests/test_files/js/xproblem.js

+// Generated by CoffeeScript 1.3.3
+(function() {
+  var XProblemDisplay, XProblemGenerator, XProblemGrader, root;
+
+  XProblemGenerator = (function() {
+
+    function XProblemGenerator(seed, parameters) {
+      this.parameters = parameters != null ? parameters : {};
+      this.random = new MersenneTwister(seed);
+      this.problemState = {};
+    }
+
+    XProblemGenerator.prototype.generate = function() {
+      return console.error("Abstract method called: XProblemGenerator.generate");
+    };
+
+    return XProblemGenerator;
+
+  })();
+
+  XProblemDisplay = (function() {
+
+    function XProblemDisplay(state, submission, evaluation, container, submissionField, parameters) {
+      this.state = state;
+      this.submission = submission;
+      this.evaluation = evaluation;
+      this.container = container;
+      this.submissionField = submissionField;
+      this.parameters = parameters != null ? parameters : {};
+    }
+
+    XProblemDisplay.prototype.render = function() {
+      return console.error("Abstract method called: XProblemDisplay.render");
+    };
+
+    XProblemDisplay.prototype.updateSubmission = function() {
+      return this.submissionField.val(JSON.stringify(this.getCurrentSubmission()));
+    };
+
+    XProblemDisplay.prototype.getCurrentSubmission = function() {
+      return console.error("Abstract method called: XProblemDisplay.getCurrentSubmission");
+    };
+
+    return XProblemDisplay;
+
+  })();
+
+  XProblemGrader = (function() {
+
+    function XProblemGrader(submission, problemState, parameters) {
+      this.submission = submission;
+      this.problemState = problemState;
+      this.parameters = parameters != null ? parameters : {};
+      this.solution = null;
+      this.evaluation = {};
+    }
+
+    XProblemGrader.prototype.solve = function() {
+      return console.error("Abstract method called: XProblemGrader.solve");
+    };
+
+    XProblemGrader.prototype.grade = function() {
+      return console.error("Abstract method called: XProblemGrader.grade");
+    };
+
+    return XProblemGrader;
+
+  })();
+
+  root = typeof exports !== "undefined" && exports !== null ? exports : this;
+
+  root.XProblemGenerator = XProblemGenerator;
+
+  root.XProblemDisplay = XProblemDisplay;
+
+  root.XProblemGrader = XProblemGrader;
+
+}).call(this);