Warzone 2100 Forums

Code: Select all

(function() {
  var Assertation, Runner, SimpleTest, TestCase, assertationKeyword, res, test,
    __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; };

  assertationKeyword = 'AssertationError:';

  Runner = (function() {

    function Runner(tests) {
      this.tests = tests;
      this.result = [];
    }

    Runner.prototype.run = function() {
      var test, _i, _len, _ref, _results;
      _ref = this.tests;
      _results = [];
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        test = _ref[_i];
        _results.push(this.result.push(test.run()));
      }
      return _results;
    };

    Runner.prototype.getResultText = function() {
      var res, testResult, text, _i, _j, _len, _len1, _ref;
      testResult = [];
      _ref = this.result;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        res = _ref[_i];
        for (_j = 0, _len1 = res.length; _j < _len1; _j++) {
          text = res[_j];
          testResult.push("" + text["class"] + "." + text.test + " " + text.result + " " + text.error);
        }
      }
      return testResult.join('\n');
    };

    Runner.prototype.toString = function() {
      return 'Testrunner';
    };

    return Runner;

  })();

  Assertation = (function() {

    function Assertation() {}

    Assertation.prototype.assert = function(val) {
      if (!val) {
        throw "" + assertationKeyword + " assertation of " + val + " fail";
      }
    };

    return Assertation;

  })();

  TestCase = (function(_super) {

    __extends(TestCase, _super);

    function TestCase(_name) {
      var key, value;
      this._name = _name != null ? _name : 'unnamed test';
      this._tests = [];
      for (key in this) {
        value = this[key];
        if (key.slice(0, 4) === 'test') {
          this._tests.push(key);
        }
      }
      this.result = [];
    }

    TestCase.prototype.preTest = function() {};

    TestCase.prototype.postTest = function() {};

    TestCase.prototype.run = function() {
      var key, _i, _len, _ref;
      _ref = this._tests;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        key = _ref[_i];
        this.preTest();
        this.result.push(this.doTest(key));
        this.postTest();
      }
      return this.result;
    };

    TestCase.prototype.doTest = function(key) {
      var msg;
      try {
        this[key]();
      } catch (error) {
        msg = error.toString();
        if (msg.slice(0, (assertationKeyword.length - 1) + 1 || 9e9) === assertationKeyword) {
          return {
            'result': 'fail',
            'class': this._name,
            'test': key,
            'error': msg.slice(assertationKeyword.length)
          };
        } else {
          return {
            'result': 'error',
            'class': this._name,
            'test': key,
            'error': msg
          };
        }
      }
      return {
        'result': 'pass',
        'class': this._name,
        'test': key,
        'error': ''
      };
    };

    return TestCase;

  })(Assertation);

  SimpleTest = (function(_super) {

    __extends(SimpleTest, _super);

    function SimpleTest() {
      return SimpleTest.__super__.constructor.apply(this, arguments);
    }

    SimpleTest.prototype.testFoo = function() {
      return this.assert(1);
    };

    SimpleTest.prototype.testNegative = function() {
      return this.assert(0);
    };

    return SimpleTest;

  })(TestCase);

  test = new SimpleTest('zzzzz');

  res = new Runner([test]);

  res.run();

  console(res.getResultText());

}).call(this);

Code: Select all

// test class can be writted in more pretty way
SimpleTest = (function(_super) {

    __extends(SimpleTest, _super);

    function SimpleTest() {
      return SimpleTest.__super__.constructor.apply(this, arguments);
    }

   // test method. It can be more pretty too, return is not needed. It exception catched  test failed or errored, else passed
   SimpleTest.prototype.testFoo = function() {
    // you can put any code and any number of assertation to here.  
    return this.assert(1);
    };

    SimpleTest.prototype.testNegative = function() {
      return this.assert(0);
    };

    return SimpleTest;

  })(TestCase);

  // this part should be integrated. For example search all instances of TestCase in code and use them.  
  test = new SimpleTest('zzzzz');
  res = new Runner([test]);
  
  // running tests
  res.run();
  // printing test output
  console(res.getResultText());

Code: Select all

assertationKeyword = 'AssertationError:'

class Runner
  constructor: (@tests) ->
    @result = []

  run: () ->
    for test in @tests
      @result.push test.run()

  getResultText: () ->
    testResult = []
    for res in @result
      for text in res
        testResult.push("#{text.class}.#{text.test} #{text.result} #{text.error}")
    testResult.join('\n')

  toString: ()->
    'Testrunner'

class Assertation
  assert: (val) ->
    if !val
      throw  "#{assertationKeyword} assertation of #{val} fail"


class TestCase extends Assertation
  constructor: (@_name='unnamed test')->
    @_tests = []
    for key, value of @
      if key[..3] == 'test'
        @_tests.push(key)
    @result  = []



  preTest: ->
  postTest: ->

  run: () ->
    for key in @_tests
      @preTest()
      @result.push @doTest(key)
      @postTest()
    return @result

  doTest: (key) ->
    try
      @[key]()
    catch error
      msg = error.toString()
      if msg[..assertationKeyword.length-1] == assertationKeyword
        return {'result': 'fail', 'class': @_name, 'test': key, 'error': msg[assertationKeyword.length..] }
      else
        return {'result': 'error', 'class': @_name, 'test': key, 'error': msg }
    return {'result': 'pass', 'class': @_name, 'test': key, 'error': '' }





class SimpleTest extends TestCase
  testFoo: () ->
    @assert 1
  testNegative: () ->
    @assert 0



test = new SimpleTest('zzzzz')
res =  new Runner([test])
res.run()
console res.getResultText()