<!DOCTYPE html>
<!--
Copyright 2015 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.
-->
<link rel="import" href="/tracing/core/test_utils.html">

<link rel="import" href="/dashboard/static/embed.html">

<script>
'use strict';

tr.b.unittest.testSuite(function() {

  var testOptions = {
    setUp: function() {
      // Reset the sample data for each test, in case they're
      // modified by some test case.
      window.GRAPH_DATA = {
        'data': [
          {'data': [[10000, 345], [12500, 345], [14000, 345]]},
          {'data': [[10000, 101], [12500, 102], [14000, 103]]}
        ],
        'annotations': {
          'series': [
            {'name': 'foo', 'units': 'ms'},
            {'name': 'bar', 'units': 'MB'}
          ],
          '0': {
            '0': {'r_foo': 'A', 'a_default_rev': 'r_foo', 'r_fizz': 123},
            '1': {'r_foo': 'B', 'a_default_rev': 'r_foo', 'r_fizz': 124},
            '2': {'r_foo': 'C', 'a_default_rev': 'r_foo', 'r_fizz': 125}
          },
          '1': {
            '0': {'r_foo': 'A', 'a_default_rev': 'r_foo', 'r_fizz': 123},
            '1': {'r_foo': 'B', 'a_default_rev': 'r_foo', 'r_fizz': 124},
            '2': {'r_foo': 'C', 'a_default_rev': 'r_foo', 'r_fizz': 125}
          }
        }
      };

      window.REVISION_INFO = {
        'r_fizz': {
           'name': 'Fizz Revision',
           'url': 'http://example.com/fizz'
        },
        'r_foo': {
           'name': 'Foo Revision',
           'url': 'http://example.com/foo'
        }
      };
    }
  };

  test('getRevisionDetails', function() {
    var data = GRAPH_DATA.data;
    var annotations = GRAPH_DATA.annotations;

    // If the different series in the graph data have different annotations,
    // but the same revision numbers, then only the annotations in the last
    // series are used. Note, the default revision is first in each list.
    assert.deepEqual(
       {
         10000: [
           {'name': 'Foo Revision', 'value': 'A'},
           {'name': 'Fizz Revision', 'value': 123}
         ],
         12500: [
           {'name': 'Foo Revision', 'value': 'B'},
           {'name': 'Fizz Revision', 'value': 124}
         ],
         14000: [
           {'name': 'Foo Revision', 'value': 'C'},
           {'name': 'Fizz Revision', 'value': 125}
         ]
       },
       embed.getRevisionDetails(data, annotations, REVISION_INFO));

    // If annotations are not provided, then default revision details are
    // still returned.
    assert.deepEqual(
       {
         10000: [{'name': 'X-Value', 'value': 10000}],
         12500: [{'name': 'X-Value', 'value': 12500}],
         14000: [{'name': 'X-Value', 'value': 14000}]
       },
       embed.getRevisionDetails(data, null, REVISION_INFO));
  }, testOptions);

  test('getDisplayRevision', function() {
    // The display revision of a revision that is a sha1 hash is truncated.
    assert.equal(
        '01234ab',
        embed.getDisplayRevision('01234abcde0123456789abcdefabcd0123456789'));
    // The display revision of other values is whatever was passed in.
    assert.equal('abcdefgh', embed.getDisplayRevision('abcdefgh'));
    assert.equal(1234567890, embed.getDisplayRevision(1234567890));
  }, testOptions);

  test('getRevisionName', function() {
    // If there's an entry in the revision info object, use the name there.
    assert.equal('Fizz Revision', embed.getRevisionName(123, 'r_fizz',
                                                        REVISION_INFO));
    assert.equal('Foo Revision', embed.getRevisionName(12345, 'r_foo',
                                                       REVISION_INFO));

    // Otherwise, just use a generic name for the revision type.
    assert.equal('X-Value', embed.getRevisionName(123, 'r_absent',
                                                  REVISION_INFO));
    assert.equal('X-Value', embed.getRevisionName(1234.5, 'r_absent',
                                                  REVISION_INFO));
    assert.equal('X-Value', embed.getRevisionName(123456, 'r_absent', null));
  }, testOptions);

  test('getRevisionLookup', function() {
    var data = GRAPH_DATA.data;
    var annotations = GRAPH_DATA.annotations;
    var revisionDetails = embed.getRevisionDetails(data, annotations,
                                                   REVISION_INFO);

    // The revision lookup array contains the x-values in order.
    assert.deepEqual(
        ['10000', '12500', '14000'],
        embed.getRevisionLookup(revisionDetails));
    assert.deepEqual([], embed.getRevisionLookup({}));
    assert.deepEqual(['100', '200'],
                     embed.getRevisionLookup({200: [], 100: []}));
  }, testOptions);

  test('makeReverseLookup', function() {
    // The makeReverseLookup function makes an object mapping items to indexes.
    assert.deepEqual({'x': 0, 'y': 1}, embed.makeReverseLookup(['x', 'y']));
    assert.deepEqual({'x': 1, 'z': 2},
                     embed.makeReverseLookup(['x', 'x', 'z']));
    assert.deepEqual({}, embed.makeReverseLookup([]));
  }, testOptions);

  test('changeXValuesToIndexes', function() {
    var data = GRAPH_DATA.data;
    var revisionLookup = ['10000', '12500', '14000'];

    // The data series start out like this:
    assert.deepEqual(
       [
         {'data': [[10000, 345], [12500, 345], [14000, 345]]},
         {'data': [[10000, 101], [12500, 102], [14000, 103]]}
       ],
       GRAPH_DATA.data);
    // After calling this function, the x values in all the data series have
    // been changed to indexes.
    embed.changeXValuesToIndexes(data, revisionLookup);
    assert.deepEqual(
       [
         {'data': [[0, 345], [1, 345], [2, 345]]},
         {'data': [[0, 101], [1, 102], [2, 103]]}
       ],
       GRAPH_DATA.data);
  }, testOptions);

  test('xAxisTickFormatter', function() {
    var revisionDetails = {
      100: [
        {'name': 'X Revision', 'value': 111},
        {'name': 'Y Revision', 'value': 'A'}
      ],
      200: [
        {'name': 'Y Revision', 'value': 'B'},
        {'name': 'Z Revision', 'value': '34.43'}
      ]
    };
    var revisionLookup = ['100', '200'];

    // The tick formatter gives the 'value' for the first revision
    // details entry. Note that the number given to the tick formatter
    // is an index in the revision lookup Array.
    assert.equal(
        '111', embed.xAxisTickFormatter(0, revisionDetails, revisionLookup));
    assert.equal(
        'B', embed.xAxisTickFormatter(1, revisionDetails, revisionLookup));

    // The tick formatter still gives values even when the given index isn't
    // an integer.
    assert.equal(
        '111', embed.xAxisTickFormatter(-1, revisionDetails, revisionLookup));
    assert.equal(
        '111', embed.xAxisTickFormatter(0.2, revisionDetails, revisionLookup));
    assert.equal(
        'B', embed.xAxisTickFormatter(0.9, revisionDetails, revisionLookup));
    assert.equal(
        'B', embed.xAxisTickFormatter(1.4, revisionDetails, revisionLookup));

    // If the index isn't found, another string is returned to indicate this.
    assert.equal(
        'undefined',
        embed.xAxisTickFormatter(2, revisionDetails, revisionLookup));
  }, testOptions);

  test('yAxisTickFormatter', function() {
    // Numbers are formatted to have no more than 3 decimal points,
    // and to have commas for the thousands (millions, billions) marker.
    assert.equal('3.142', embed.yAxisTickFormatter(3.14159));
    assert.equal('1,111.1', embed.yAxisTickFormatter(1111.1));
    assert.equal('1,111.1', embed.yAxisTickFormatter(1111.1));
    assert.equal('10,000', embed.yAxisTickFormatter(10000.00));
    assert.equal('1,000,000', embed.yAxisTickFormatter(1000000));
  }, testOptions);

});
</script>