calculator/tests/utilities.js

/**
 * Copyright (c) 2012 The Chromium Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 *
 * The utility class defined in this file allow calculator tests to be written
 * more succinctly.
 *
 * Tests that would be written with QUnit like this:
 *
 *   test('Two Plus Two', function() {
 *     var mock = window.mockView.create();
 *     var controller = new Controller(new Model(8), mock);
 *     deepEqual(mock.testButton('2'), [null, null, '2'], '2');
 *     deepEqual(mock.testButton('+'), ['2', '+', null], '+');
 *     deepEqual(mock.testButton('2'), ['2', '+', '2'], '2');
 *     deepEqual(mock.testButton('='), ['4', '=', null], '=');
 *   });
 *
 * can instead be written as:
 *
 *   var run = calculatorTestRun.create();
 *   run.test('Two Plus Two', '2 + 2 = [4]');
 */

'use strict';

window.mockView = {

  create: function() {
    var view = Object.create(this);
    view.display = [];
    return view;
  },

  clearDisplay: function(values) {
    this.display = [];
    this.addValues(values);
  },

  addResults: function(values) {
    this.display.push([]);
    this.addValues(values);
  },

  addValues: function(values) {
    this.display.push([
      values.accumulator || '',
      values.operator || '',
      values.operand || ''
    ]);
  },

  setValues: function(values) {
    this.display.pop();
    this.addValues(values);
  },

  getValues: function() {
    var last = this.display[this.display.length - 1];
    return {
      accumulator: last && last[0] || null,
      operator: last && last[1] || null,
      operand: last && last[2] || null
    };
  },

  testButton: function(button) {
    this.onButton.call(this, button);
    return this.display;
  }

};

window.calculatorTestRun = {

  BUTTONS: {
    '0': 'zero',
    '1': 'one',
    '2': 'two',
    '3': 'three',
    '4': 'four',
    '5': 'five',
    '6': 'six',
    '7': 'seven',
    '8': 'eight',
    '9': 'nine',
    '.': 'point',
    '+': 'add',
    '-': 'subtract',
    '*': 'multiply',
    '/': 'divide',
    '=': 'equals',
    '~': 'negate',
    'A': 'clear',
    '<': 'back'
  },

  NAMES: {
    '~': '+ / -',
    'A': 'AC',
    '<': 'back',
  },

  /**
   * Returns an object representing a run of calculator tests.
   */
  create: function() {
    var run = Object.create(this);
    run.tests = [];
    run.success = true;
    return run;
  },

  /**
   * Runs a test defined as either a sequence or a function.
   */
  test: function(name, test) {
    this.tests.push({name: name, steps: [], success: true});
    if (typeof test === 'string')
      this.testSequence_(name, test);
    else if (typeof test === 'function')
      test.call(this, new Controller(new Model(8), window.mockView.create()));
    else
      this.fail(this.getDescription_('invalid test: ', test));
  },

  /**
   * Log test failures to the console.
   */
  log: function() {
    var parts = ['\n\n', 0, ' tests passed, ', 0, ' failed.\n\n'];
    if (!this.success) {
      this.tests.forEach(function(test, index) {
        var number = this.formatNumber_(index + 1, 2);
        var prefix = test.success ? 'PASS: ' : 'FAIL: ';
        parts[test.success ? 1 : 3] += 1;
        parts.push(number, ') ', prefix, test.name, '\n');
        test.steps.forEach(function(step) {
          var prefix = step.success ? 'PASS: ' : 'FAIL: ';
          step.messages.forEach(function(message) {
            parts.push('    ', prefix, message, '\n');
            prefix = '      ';
          });
        });
        parts.push('\n');
      }.bind(this));
      console.log(parts.join(''));
    }
  },

  /**
   * Verify that actual values after a test step match expectations.
   */
  verify: function(expected, actual, message) {
    if (this.areEqual_(expected, actual))
      this.succeed(message);
    else
      this.fail(message, expected, actual);
  },

  /**
   * Record a successful test step.
   */
  succeed: function(message) {
    var test = this.tests[this.tests.length - 1];
    test.steps.push({success: true, messages: [message]});
  },

  /**
   * Fail the current test step. Expected and actual values are optional.
   */
  fail: function(message, expected, actual) {
    var test = this.tests[this.tests.length - 1];
    var failure = {success: false, messages: [message]};
    if (expected !== undefined) {
      failure.messages.push(this.getDescription_('expected: ', expected));
      failure.messages.push(this.getDescription_('actual:   ', actual));
    }
    test.steps.push(failure);
    test.success = false;
    this.success = false;
  },

  /**
   * @private
   * Tests how a new calculator controller handles a sequence of numbers,
   * operations, and commands, verifying that the controller's view has expected
   * values displayed after each input handled by the controller.
   *
   * Within the sequence string, expected values must be specified as arrays of
   * the form described below. The strings '~', '<', and 'A' is interpreted as
   * the commands '+ / -', 'back', and 'AC' respectively, and other strings are
   * interpreted as the digits, periods, operations, and commands represented
   * by those strings.
   *
   * Expected values are sequences of arrays of the following forms:
   *
   *   []
   *   [accumulator]
   *   [accumulator operator operand]
   *   [accumulator operator prefix suffix]
   *
   * where |accumulator|, |operand|, |prefix|, and |suffix| are numbers or
   * underscores and |operator| is one of the operator characters or an
   * underscore. The |operand|, |prefix|, and |suffix| numbers may contain
   * leading zeros and embedded '=' characters which will be interpreted as
   * described in the comments for the |testNumber_()| method above. Underscores
   * represent values that are expected to be blank. '[]' arrays represent
   * horizontal separators expected in the display. '[accumulator]' arrays
   * adjust the last expected value array by setting only its accumulator value.
   * If that value is already set they behave like '[accumulator _ accumulator]'
   * arrays.
   *
   * Expected value array must be specified just after the sequence element
   * which they are meant to test, like this:
   *
   *   run.testSequence_(controller, '12 - 34 = [][-22 _ -22]')
   *
   * When expected values are not specified for an element, the following rules
   * are applied to obtain best guesses for the expected values for that
   * element's tests:
   *
   *   - The initial expected values arrays are:
   *
   *       [['', '', '']]
   *
   *   - If the element being tested is a number, the expected operand value
   *     of the last expected value array is set and changed as described in the
   *     comments for the |testNumber_()| method above.
   *
   *   - If the element being tested is the '+ / -' operation the expected
   *     values arrays will be changed as follows:
   *
   *       [*, [x, y, '']]     -> [*, [x, y, '']]
   *       [*, [x, y, z]]      -> [*, [x, y, -z]
   *       [*, [x, y, z1, z2]] -> [*, [x, y, -z1z2]
   *
   *   - If the element |e| being tested is the '+', '-', '*', or '/' operation
   *     the expected values will be changed as follows:
   *
   *       [*, [x, y, '']]     -> [*, ['', e, '']]
   *       [*, [x, y, z]]      -> [*, [z, y, z], ['', e, '']]
   *       [*, [x, y, z1, z2]] -> [*, [z1z2, y, z1z2], ['', e, '']]
   *
   *   - If the element being tested is the '=' command, the expected values
   *     will be changed as follows:
   *
   *       [*, ['', '', '']]   -> [*, [], ['0', '', '0']]
   *       [*, [x, y, '']]     -> [*, [x, y, z], [], ['0', '', '0']]
   *       [*, [x, y, z]]      -> [*, [x, y, z], [], [z, '', z]]
   *       [*, [x, y, z1, z2]] -> [*, [x, y, z], [], [z1z2, '', z1z2]]
   *
   * So for example this call:
   *
   *   run.testSequence_('My Test', '12 + 34 - 56 = [][-10]')
   *
   * would yield the following tests:
   *
   *   run.testInput_(controller, '1', [['', '', '1']]);
   *   run.testInput_(controller, '2', [['', '', '12']]);
   *   run.testInput_(controller, '+', [['12', '', '12'], ['', '+', '']]);
   *   run.testInput_(controller, '3', [['12', '', '12'], ['', '+', '3']]);
   *   run.testInput_(controller, '4', [..., ['', '+', '34']]);
   *   run.testInput_(controller, '-', [..., ['34', '', '34'], ['', '-', '']]);
   *   run.testInput_(controller, '2', [..., ['34', '', '34'], ['', '-', '2']]);
   *   run.testInput_(controller, '1', [..., ..., ['', '-', '21']]);
   *   run.testInput_(controller, '=', [[], [-10, '', -10]]);
   */
  testSequence_: function(name, sequence) {
    var controller = new Controller(new Model(8), window.mockView.create());
    var expected = [['', '', '']];
    var elements = this.parseSequence_(sequence);
    for (var i = 0; i < elements.length; ++i) {
      if (!Array.isArray(elements[i])) {  // Skip over expected value arrays.
        // Update and ajust expectations.
        this.updatedExpectations_(expected, elements[i]);
        if (Array.isArray(elements[i + 1] && elements[i + 1][0]))
          expected = this.adjustExpectations_([], elements[i + 1], 0);
        else
          expected = this.adjustExpectations_(expected, elements, i + 1);
        // Test.
        if (elements[i].match(/^-?[\d.][\d.=]*$/))
          this.testNumber_(controller, elements[i], expected);
        else
          this.testInput_(controller, elements[i], expected);
      };
    }
  },

  /** @private */
  parseSequence_: function(sequence) {
    // Define the patterns used below.
    var ATOMS = /(-?[\d.][\d.=]*)|([+*/=~<CAE_-])/g;  // number || command
    var VALUES = /(\[[^\[\]]*\])/g;                   // expected values
    // Massage the sequence into a JSON array string, so '2 + 2 = [4]' becomes:
    sequence = sequence.replace(ATOMS, ',$1$2,');     // ',2, ,+, ,2, ,=, [,4,]'
    sequence = sequence.replace(/\s+/g, '');          // ',2,,+,,2,,=,[,4,]'
    sequence = sequence.replace(VALUES, ',$1,');      // ',2,,+,,2,,=,,[,4,],'
    sequence = sequence.replace(/,,+/g, ',');         // ',2,+,2,=,[,4,],'
    sequence = sequence.replace(/\[,/g, '[');         // ',2,+,2,=,[4,],'
    sequence = sequence.replace(/,\]/g, ']');         // ',2,+,2,=,[4],'
    sequence = sequence.replace(/(^,)|(,$)/g, '');    // '2,+,2,=,[4]'
    sequence = sequence.replace(ATOMS, '"$1$2"');     // '"2","+","2","=",["4"]'
    sequence = sequence.replace(/"_"/g, '""');        // '"2","+","2","=",["4"]'
    // Fix some cases handled incorrectly by the massaging above, like the
    // original sequences '[_ _ 0=]' and '[-1]', which would have become
    // '["","","0","="]]' and '["-","1"]' respectively and would need to be
    // fixed to '["","","0="]]' and '["-1"]'respectively.
    sequence.replace(VALUES, function(match) {
      return match.replace(/(","=)|(=",")/g, '=').replace(/-","/g, '-');
    });
    // Return an array created from the resulting JSON string.
    return JSON.parse('[' + sequence + ']');
  },

  /** @private */
  updatedExpectations_: function(expected, element) {
    var last = expected[expected.length - 1];
    var empty = (last && !last[0] && !last[1] && !last[2] && !last[3]);
    var operand = last && last.slice(2).join('');
    var operation = element.match(/[+*/-]/);
    var equals = (element === '=');
    var negate = (element === '~');
    if (operation && !operand)
      expected.splice(-1, 1, ['', element, '']);
    else if (operation)
      expected.splice(-1, 1, [operand, last[1], operand], ['', element, '']);
    else if (equals && empty)
      expected.splice(-1, 1, [], [operand || '0', '', operand || '0']);
    else if (equals)
      expected.push([], [operand || '0', '', operand || '0']);
    else if (negate && operand)
      expected[expected.length - 1].splice(2, 2, '-' + operand);
  },

  /** @private */
  adjustExpectations_: function(expectations, adjustments, start) {
    var replace = !expectations.length;
    var adjustment, expectation;
    for (var i = 0; Array.isArray(adjustments[start + i]); ++i) {
      adjustment = adjustments[start + i];
      expectation = expectations[expectations.length - 1];
      if (adjustments[start + i].length != 1) {
        expectations.splice(-i - 1, replace ? 0 : 1);
        expectations.push(adjustments[start + i]);
      } else if (i || !expectation || !expectation.length || expectation[0]) {
        expectations.splice(-i - 1, replace ? 0 : 1);
        expectations.push([adjustment[0], '', adjustment[0]]);
      } else {
        expectations[expectations.length - i - 2][0] = adjustment[0];
      }
    }
    return expectations;
  },

  /**
   * @private
   * Tests how a calculator controller handles a sequence of digits and periods
   * representing a number. During the test, the expected operand values are
   * updated before each digit and period of the input according to these rules:
   *
   *   - If the last of the passed in expected values arrays has an expected
   *     accumulator value, add an empty expected values array and proceed
   *     according to the rules below with this new array.
   *
   *   - If the last of the passed in expected values arrays has no expected
   *     operand value and no expected operand prefix and suffix values, the
   *     expected operand used for the tests will start with the first digit or
   *     period of the numeric sequence and the following digits and periods of
   *     that sequence will be appended to that expected operand before each of
   *     the following digits and periods in the test.
   *
   *   - If the last of the passed in expected values arrays has a single
   *     expected operand value instead of operand prefix and suffix values, the
   *     expected operand used for the tests will start with the first character
   *     of that operand value and one additional character of that value will
   *     be added to the expected operand before each of the following digits
   *     and periods in the tests.
   *
   *   - If the last of the passed in expected values arrays has operand prefix
   *     and suffix values instead of an operand value, the expected operand
   *     used for the tests will start with the prefix value and the first
   *     character of the suffix value, and one character of that suffix value
   *     will be added to the expected operand before each of the following
   *     digits and periods in the tests.
   *
   *   - In all of these cases, leading zeros and occurrences of the '='
   *     character in the expected operand value will be ignored.
   *
   * For example the sequence of calls:
   *
   *   run.testNumber_(controller, '00', [[x, y, '0=']])
   *   run.testNumber_(controller, '1.2.3', [[x, y, '1.2=3']])
   *   run.testNumber_(controller, '45', [[x, y, '1.23', '45']])
   *
   * would yield the following tests:
   *
   *   run.testInput_(controller, '0', [[x, y, '0']]);
   *   run.testInput_(controller, '0', [[x, y, '0']]);
   *   run.testInput_(controller, '1', [[x, y, '1']]);
   *   run.testInput_(controller, '.', [[x, y, '1.']]);
   *   run.testInput_(controller, '2', [[x, y, '1.2']]);
   *   run.testInput_(controller, '.', [[x, y, '1.2']]);
   *   run.testInput_(controller, '3', [[x, y, '1.23']]);
   *   run.testInput_(controller, '4', [[x, y, '1.234']]);
   *   run.testInput_(controller, '5', [[x, y, '1.2345']]);
   *
   * It would also changes the expected value arrays to the following:
   *
   *   [[x, y, '1.2345']]
   */
  testNumber_: function(controller, number, expected) {
    var last = expected[expected.length - 1];
    var prefix = (last && !last[0] && last.length > 3 && last[2]) || '';
    var suffix = (last && !last[0] && last[last.length - 1]) || number;
    var append = (last && !last[0]) ? ['', last[1], ''] : ['', '', ''];
    var start = (last && !last[0]) ? -1 : expected.length;
    var count = (last && !last[0]) ? 1 : 0;
    expected.splice(start, count, append);
    for (var i = 0; i < number.length; ++i) {
      append[2] = prefix + suffix.slice(0, i + 1);
      append[2] = append[2].replace(/^0+([0-9])/, '$1').replace(/=/g, '');
      this.testInput_(controller, number[i], expected);
    }
  },

  /**
   * @private
   * Tests how a calculator controller handles a single element of input,
   * logging the state of the controller before and after the test.
   */
  testInput_: function(controller, input, expected) {
    var prefix = ['"', this.NAMES[input] || input, '": '];
    var before = this.addDescription_(prefix, controller, ' => ');
    var display = controller.view.testButton(this.BUTTONS[input]);
    var actual = display.slice(-expected.length);
    this.verify(expected, actual, this.getDescription_(before, controller));
  },

  /** @private */
  areEqual_: function(x, y) {
    return Array.isArray(x) ? this.areArraysEqual_(x, y) : (x == y);
  },

  /** @private */
  areArraysEqual_: function(a, b) {
    return Array.isArray(a) &&
           Array.isArray(b) &&
           a.length === b.length &&
           a.every(function(element, i) {
             return this.areEqual_(a[i], b[i]);
           }, this);
  },

  /** @private */
  getDescription_: function(prefix, object, suffix) {
    var strings = Array.isArray(prefix) ? prefix : prefix ? [prefix] : [];
    return this.addDescription_(strings, object, suffix).join('');
  },

  /** @private */
  addDescription_: function(prefix, object, suffix) {
    var strings = Array.isArray(prefix) ? prefix : prefix ? [prefix] : [];
    if (Array.isArray(object)) {
      strings.push('[', '');
      object.forEach(function(element) {
        this.addDescription_(strings, element, ', ');
      }, this);
      strings.pop();  // Pops the last ', ', or pops '' for empty arrays.
      strings.push(']');
    } else if (typeof object === 'number') {
      strings.push('#');
      strings.push(String(object));
    } else if (typeof object === 'string') {
      strings.push('"');
      strings.push(object);
      strings.push('"');
    } else if (object instanceof Controller) {
      strings.push('(');
      this.addDescription_(strings, object.model.accumulator, ' ');
      this.addDescription_(strings, object.model.operator, ' ');
      this.addDescription_(strings, object.model.operand, ' | ');
      this.addDescription_(strings, object.model.defaults.operator, ' ');
      this.addDescription_(strings, object.model.defaults.operand, ')');
    } else {
      strings.push(String(object));
    }
    strings.push(suffix || '');
    return strings;
  },

  /** @private */
  formatNumber_: function(number, digits) {
    var string = String(number);
    var array = Array(Math.max(digits - string.length, 0) + 1);
    array[array.length - 1] = string;
    return array.join('0');
  }

};