gistfile1.js

// Prototyping a test harness autogen
// Here's a run against Array.prototype

Test_Array = {
run_tests : function() {
  for (var i in this) {
    if (/^test_/.test(i)) {
      var __obj = new Array(args);
      this[i](__obj);
    }
  }
},

test_deleteFirst : function(__obj) {
  // Call signature:   __obj.deleteFirst(obj);
  // Call argument definitions
  var obj = null;
  var extraArg = true; // for the extra arg test
  __obj.deleteFirst(obj);
  __obj.deleteFirst(obj, extraArg); // too many args
  assert_fail(function(){  __obj.deleteFirst(); }); // too few args
  var rv = __obj.deleteFirst(obj);
  assert('non-null return value', rv != null);
},

test_stableSort : function(__obj) {
  // Call signature:   __obj.stableSort(f);
  // Call argument definitions
  var f = null;
  var extraArg = true; // for the extra arg test
  __obj.stableSort(f);
  __obj.stableSort(f, extraArg); // too many args
  assert_fail(function(){  __obj.stableSort(); }); // too few args
  // f(a,b); // called as a function
  var rv = __obj.stableSort(f);
  assert('non-null return value', rv != null);
},

test_all : function(__obj) {
  // Call signature:   __obj.all(f);
  // Call argument definitions
  var f = null;
  var extraArg = true; // for the extra arg test
  __obj.all(f);
  __obj.all(f, extraArg); // too many args
  assert_fail(function(){  __obj.all(); }); // too few args
  // f(this[i], i, this); // called as a function
  var rv = __obj.all(f);
  assert('non-null return value', rv != null);
},

test_any : function(__obj) {
  // Call signature:   __obj.any(f);
  // Call argument definitions
  var f = null;
  var extraArg = true; // for the extra arg test
  __obj.any(f);
  __obj.any(f, extraArg); // too many args
  assert_fail(function(){  __obj.any(); }); // too few args
  // f(this[i], i, this); // called as a function
  var rv = __obj.any(f);
  assert('non-null return value', rv != null);
},

test_allIn : function(__obj) {
  // Call signature:   __obj.allIn(obj);
  // Call argument definitions
  var obj = null;
  var extraArg = true; // for the extra arg test
  __obj.allIn(obj);
  __obj.allIn(obj, extraArg); // too many args
  assert_fail(function(){  __obj.allIn(); }); // too few args
  // obj[k] is being iterated
  var rv = __obj.allIn(obj);
  assert('non-null return value', rv != null);
},

test_anyIn : function(__obj) {
  // Call signature:   __obj.anyIn(obj);
  // Call argument definitions
  var obj = null;
  var extraArg = true; // for the extra arg test
  __obj.anyIn(obj);
  __obj.anyIn(obj, extraArg); // too many args
  assert_fail(function(){  __obj.anyIn(); }); // too few args
  // obj[k] is being iterated
  var rv = __obj.anyIn(obj);
  assert('non-null return value', rv != null);
},

test_equals : function(__obj) {
  // Call signature:   __obj.equals(array);
  // Call argument definitions
  var array = null;
  var extraArg = true; // for the extra arg test
  __obj.equals(array);
  __obj.equals(array, extraArg); // too many args
  assert_fail(function(){  __obj.equals(); }); // too few args
  array.length; // is accessed
  // array[i] is being iterated
  var rv = __obj.equals(array);
  assert('non-null return value', rv != null);
},

test_rotate : function(__obj) {
  // Call signature:   __obj.rotate(backToFront);
  // Call argument definitions
  var backToFront = null;
  var extraArg = true; // for the extra arg test
  __obj.rotate(backToFront);
  __obj.rotate(backToFront, extraArg); // too many args
  assert_fail(function(){  __obj.rotate(); }); // too few args
  var rv = __obj.rotate(backToFront);
  assert('non-null return value', rv != null);
},

test_random : function(__obj) {
  // Call signature:   __obj.random();
  var extraArg = true; // for the extra arg test
  __obj.random();
  __obj.random(extraArg); // too many args
  var rv = __obj.random();
  assert('non-null return value', rv != null);
},

test_flatten : function(__obj) {
  // Call signature:   __obj.flatten();
  var extraArg = true; // for the extra arg test
  __obj.flatten();
  __obj.flatten(extraArg); // too many args
  var rv = __obj.flatten();
  assert('non-null return value', rv != null);
},

test_take : function(__obj) {
  // Call signature:   __obj.take();

  __obj.take(1); // variable args
  __obj.take(1, 2); // variable args
  __obj.take(1, 2, 3); // variable args
  var rv = __obj.take();
  assert('non-null return value', rv != null);
},

test_pluck : function(__obj) {
  // Call signature:   __obj.pluck(key);
  // Call argument definitions
  var key = null;
  var extraArg = true; // for the extra arg test
  __obj.pluck(key);
  __obj.pluck(key, extraArg); // too many args
  assert_fail(function(){  __obj.pluck(); }); // too few args
  var rv = __obj.pluck(key);
  assert('non-null return value', rv != null);
},

test_setProperty : function(__obj) {
  // Call signature:   __obj.setProperty(key,value);
  // Call argument definitions
  var key = null;
  var value = null;
  var extraArg = true; // for the extra arg test
  __obj.setProperty(key, value);
  __obj.setProperty(key, value, extraArg); // too many args
  assert_fail(function(){  __obj.setProperty(key); }); // too few args
  var rv = __obj.setProperty(key,value);
  assert('null return value', rv == null);
},

test_allWith : function(__obj) {
  // Call signature:   __obj.allWith();

  __obj.allWith(1); // variable args
  __obj.allWith(1, 2); // variable args
  __obj.allWith(1, 2, 3); // variable args
  var rv = __obj.allWith();
  assert('non-null return value', rv != null);
},

test_bsearch : function(__obj) {
  // Call signature:   __obj.bsearch(key);
  // Call argument definitions
  var key = null;
  var extraArg = true; // for the extra arg test
  __obj.bsearch(key);
  __obj.bsearch(key, extraArg); // too many args
  assert_fail(function(){  __obj.bsearch(); }); // too few args
  var rv = __obj.bsearch(key);
  assert('non-null return value', rv != null);
},

test_sortNum : function(__obj) {
  // Call signature:   __obj.sortNum();
  var extraArg = true; // for the extra arg test
  __obj.sortNum();
  __obj.sortNum(extraArg); // too many args
  var rv = __obj.sortNum();
  assert('non-null return value', rv != null);
},

test_last : function(__obj) {
  // Call signature:   __obj.last();
  var extraArg = true; // for the extra arg test
  __obj.last();
  __obj.last(extraArg); // too many args
  var rv = __obj.last();
  assert('non-null return value', rv != null);
},

test_map : function(__obj) {
  // Call signature:   __obj.map(f);
  // Call argument definitions
  var f = null;
  var extraArg = true; // for the extra arg test
  __obj.map(f);
  __obj.map(f, extraArg); // too many args
  assert_fail(function(){  __obj.map(); }); // too few args
  // f(this[i], i, this); // called as a function
  var rv = __obj.map(f);
  assert('non-null return value', rv != null);
},

test_unique : function(__obj) {
  // Call signature:   __obj.unique();
  var extraArg = true; // for the extra arg test
  __obj.unique();
  __obj.unique(extraArg); // too many args
  var rv = __obj.unique();
  assert('non-null return value', rv != null);
},

test_forEach : function(__obj) {
  // Call signature:   __obj.forEach(f);
  // Call argument definitions
  var f = null;
  var extraArg = true; // for the extra arg test
  __obj.forEach(f);
  __obj.forEach(f, extraArg); // too many args
  assert_fail(function(){  __obj.forEach(); }); // too few args
  // f(this[i], i, this); // called as a function
  var rv = __obj.forEach(f);
  assert('null return value', rv == null);
},

test_set : function(__obj) {
  // Call signature:   __obj.set(newVal);
  // Call argument definitions
  var newVal = null;
  var extraArg = true; // for the extra arg test
  __obj.set(newVal);
  __obj.set(newVal, extraArg); // too many args
  assert_fail(function(){  __obj.set(); }); // too few args
  newVal.length; // is accessed
  // newVal[i] is being iterated
  var rv = __obj.set(newVal);
  assert('non-null return value', rv != null);
},

test_find : function(__obj) {
  // Call signature:   __obj.find(f);
  // Call argument definitions
  var f = null;
  var extraArg = true; // for the extra arg test
  __obj.find(f);
  __obj.find(f, extraArg); // too many args
  assert_fail(function(){  __obj.find(); }); // too few args
  // f(this[i], i, this); // called as a function
  var rv = __obj.find(f);
  assert('non-null return value', rv != null);
}
};