<!DOCTYPE html>
<!--
Copyright (c) 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/base/iteration_helpers.html">
<link rel="import" href="/tracing/core/test_utils.html">
<link rel="import" href="/tracing/model/heap_dump.html">
<link rel="import" href="/tracing/model/memory_allocator_dump.html">
<link rel="import" href="/tracing/model/memory_dump_test_utils.html">
<link rel="import" href="/tracing/ui/analysis/memory_dump_overview_pane.html">
<link rel="import"
    href="/tracing/ui/analysis/memory_dump_sub_view_test_utils.html">
<link rel="import" href="/tracing/ui/analysis/memory_dump_sub_view_util.html">
<link rel="import" href="/tracing/ui/brushing_state_controller.html">

<script>
'use strict';

tr.b.unittest.testSuite(function() {
  var ScalarNumeric = tr.v.ScalarNumeric;
  var sizeInBytes_smallerIsBetter =
      tr.b.Unit.byName.sizeInBytes_smallerIsBetter;
  var MemoryAllocatorDump = tr.model.MemoryAllocatorDump;
  var HeapDump = tr.model.HeapDump;
  var AggregationMode = tr.ui.analysis.MemoryColumn.AggregationMode;
  var checkSizeNumericFields = tr.ui.analysis.checkSizeNumericFields;
  var checkColor = tr.ui.analysis.checkColor;
  var checkColumns = tr.ui.analysis.checkColumns;
  var checkColumnInfosAndColor = tr.ui.analysis.checkColumnInfosAndColor;
  var convertToProcessMemoryDumps = tr.ui.analysis.convertToProcessMemoryDumps;
  var extractProcessMemoryDumps = tr.ui.analysis.extractProcessMemoryDumps;
  var extractVmRegions = tr.ui.analysis.extractVmRegions;
  var extractMemoryAllocatorDumps = tr.ui.analysis.extractMemoryAllocatorDumps;
  var isElementDisplayed = tr.ui.analysis.isElementDisplayed;
  var addProcessMemoryDump = tr.model.MemoryDumpTestUtils.addProcessMemoryDump;
  var addGlobalMemoryDump = tr.model.MemoryDumpTestUtils.addGlobalMemoryDump;
  var ProcessNameColumn = tr.ui.analysis.ProcessNameColumn;
  var UsedMemoryColumn = tr.ui.analysis.UsedMemoryColumn;
  var PeakMemoryColumn = tr.ui.analysis.PeakMemoryColumn;
  var ByteStatColumn = tr.ui.analysis.ByteStatColumn;
  var AllocatorColumn = tr.ui.analysis.AllocatorColumn;
  var TracingColumn = tr.ui.analysis.TracingColumn;

  function spanMatcher(expectedTitle) {
    return function(actualTitle) {
      assert.instanceOf(actualTitle, HTMLElement);
      assert.strictEqual(actualTitle.tagName, 'SPAN');
      assert.strictEqual(Polymer.dom(actualTitle).textContent, expectedTitle);
    };
  }

  function colorLegendMatcher(expectedTitle) {
    return function(actualTitle) {
      assert.instanceOf(actualTitle, HTMLElement);
      assert.strictEqual(actualTitle.tagName, 'TR-UI-B-COLOR-LEGEND');
      assert.strictEqual(actualTitle.label, expectedTitle);
    };
  }

  var EXPECTED_COLUMNS = [
    { title: 'Process', type: ProcessNameColumn, noAggregation: true },
    { title: spanMatcher('Total resident'), type: UsedMemoryColumn },
    { title: spanMatcher('Peak total resident'), type: PeakMemoryColumn },
    { title: spanMatcher('PSS'), type: ByteStatColumn },
    { title: spanMatcher('Private dirty'), type: ByteStatColumn },
    { title: spanMatcher('Swapped'), type: ByteStatColumn },
    { title: spanMatcher('Private'), type: UsedMemoryColumn },
    { title: colorLegendMatcher('blink'), type: AllocatorColumn },
    { title: colorLegendMatcher('gpu'), type: AllocatorColumn },
    { title: colorLegendMatcher('malloc'), type: AllocatorColumn },
    { title: colorLegendMatcher('oilpan'), type: AllocatorColumn },
    { title: colorLegendMatcher('v8'), type: AllocatorColumn },
    { title: spanMatcher('tracing'), type: TracingColumn }
  ];

  function checkRow(columns, row, expectedTitle, expectedSizes,
      expectedContexts) {
    // Check title.
    var formattedTitle = columns[0].formatTitle(row);
    if (typeof expectedTitle === 'function')
      expectedTitle(formattedTitle);
    else
      assert.strictEqual(formattedTitle, expectedTitle);

    // Check all sizes. The first assert below is a test sanity check.
    assert.lengthOf(expectedSizes, columns.length - 1 /* all except title */);
    for (var i = 0; i < expectedSizes.length; i++)
      checkSizeNumericFields(row, columns[i + 1], expectedSizes[i]);

    // There should be no row nesting on the overview pane.
    assert.isUndefined(row.subRows);

    if (expectedContexts)
      assert.deepEqual(tr.b.asArray(row.contexts), expectedContexts);
    else
      assert.isUndefined(row.contexts);
  }

  function checkRows(columns, actualRows, expectedRows) {
    if (expectedRows === undefined) {
      assert.isUndefined(actualRows);
      return;
    }
    assert.lengthOf(actualRows, expectedRows.length);
    for (var i = 0; i < expectedRows.length; i++) {
      var actualRow = actualRows[i];
      var expectedRow = expectedRows[i];
      checkRow(columns, actualRow, expectedRow.title, expectedRow.sizes,
          expectedRow.contexts);
    }
  }

  function checkSpanWithColor(span, expectedText, expectedColorReservedName) {
    assert.strictEqual(span.tagName, 'SPAN');
    assert.strictEqual(Polymer.dom(span).textContent, expectedText);
    checkColor(span.style.color, expectedColorReservedName);
  }

  function checkColorLegend(legend, expectedLabel) {
    assert.strictEqual(legend.tagName, 'TR-UI-B-COLOR-LEGEND');
    assert.strictEqual(legend.label, expectedLabel);
  }

  function createAndCheckMemoryDumpOverviewPane(
      test, processMemoryDumps, expectedRows, expectedFooterRows,
      aggregationMode) {
    var viewEl =
        tr.ui.analysis.createTestPane('tr-ui-a-memory-dump-overview-pane');
    viewEl.processMemoryDumps = processMemoryDumps;
    viewEl.aggregationMode = aggregationMode;
    viewEl.rebuild();
    test.addHTMLOutput(viewEl);

    // Check that the table is shown.
    assert.isTrue(isElementDisplayed(viewEl.$.table));
    assert.isFalse(isElementDisplayed(viewEl.$.info_text));

    assert.isUndefined(viewEl.createChildPane());

    var table = viewEl.$.table;
    var columns = table.tableColumns;
    checkColumns(columns, EXPECTED_COLUMNS, aggregationMode);
    var rows = table.tableRows;

    checkRows(columns, table.tableRows, expectedRows);
    checkRows(columns, table.footerRows, expectedFooterRows);
  }

  var FIELD = 1 << 0;
  var DUMP = 1 << 1;

  function checkOverviewColumnInfosAndColor(column, fieldAndDumpMask,
      dumpCreatedCallback, expectedInfos, expectedColorReservedName) {
    var fields = fieldAndDumpMask.map(function(mask, index) {
      return mask & FIELD ?
          new ScalarNumeric(sizeInBytes_smallerIsBetter, 1024 + 32 * index) :
          undefined;
    });

    var contexts;
    if (dumpCreatedCallback === undefined) {
      contexts = undefined;
    } else {
      tr.c.TestUtils.newModel(function(model) {
        var process = model.getOrCreateProcess(1);
        fieldAndDumpMask.forEach(function(mask, i) {
          var timestamp = 10 + i;
          var gmd = addGlobalMemoryDump(model, {ts: timestamp});
          if (mask & DUMP) {
            var pmd = addProcessMemoryDump(gmd, process, {ts: timestamp});
            dumpCreatedCallback(pmd, mask);
          }
        });
        contexts = model.globalMemoryDumps.map(function(gmd) {
          return gmd.processMemoryDumps[1];
        });
      });
    }

    checkColumnInfosAndColor(
        column, fields, contexts, expectedInfos, expectedColorReservedName);
  }

  test('instantiate_empty', function() {
    tr.ui.analysis.createAndCheckEmptyPanes(this,
        'tr-ui-a-memory-dump-overview-pane', 'processMemoryDumps',
        function(viewEl) {
          // Check that the info text is shown.
          assert.isTrue(isElementDisplayed(viewEl.$.info_text));
          assert.isFalse(isElementDisplayed(viewEl.$.table));
        });
  });

  test('instantiate_singleGlobalMemoryDump', function() {
    var processMemoryDumps = convertToProcessMemoryDumps(
        [tr.ui.analysis.createSingleTestGlobalMemoryDump()]);
    createAndCheckMemoryDumpOverviewPane(this,
        processMemoryDumps,
        [  // Table rows.
          {
            title: colorLegendMatcher('Process 1'),
            sizes: [[29884416], undefined, [9437184], [5767168], undefined,
                undefined, undefined, undefined, [7340032], undefined,
                undefined, [2097152]],
            contexts: extractProcessMemoryDumps(processMemoryDumps, 1)
          },
          {
            title: colorLegendMatcher('Process 2'),
            sizes: [[17825792], [39845888], [18350080], [0], [32], [8912896],
                [7340032], [0], [1048576], [1], [5242880], [1572864]],
            contexts: extractProcessMemoryDumps(processMemoryDumps, 2)
          },
          {
            title: colorLegendMatcher('Process 4'),
            sizes: [undefined, [17825792], undefined, undefined, undefined,
                undefined, undefined, undefined, undefined, undefined,
                undefined, undefined],
            contexts: extractProcessMemoryDumps(processMemoryDumps, 4)
          }
        ],
        [  // Footer rows.
          {
            title: 'Total',
            sizes: [[47710208], [57671680], [27787264], [5767168], [32],
                [8912896], [7340032], [0], [8388608], [1], [5242880],
                [3670016]],
            contexts: undefined
          }
        ],
        undefined /* no aggregation */);
  });

  test('instantiate_multipleGlobalMemoryDumps', function() {
    var processMemoryDumps = convertToProcessMemoryDumps(
        tr.ui.analysis.createMultipleTestGlobalMemoryDumps());
    createAndCheckMemoryDumpOverviewPane(this,
        processMemoryDumps,
        [  // Table rows.
          {
            title: colorLegendMatcher('Process 1'),
            sizes: [[31457280, 29884416, undefined], undefined,
                [10485760, 9437184, undefined], [8388608, 5767168, undefined],
                undefined, undefined, undefined, undefined,
                [undefined, 7340032, undefined], undefined, undefined,
                [undefined, 2097152, undefined]],
            contexts: extractProcessMemoryDumps(processMemoryDumps, 1)
          },
          {
            title: colorLegendMatcher('Process 2'),
            sizes: [[19398656, 17825792, 15728640],
                [40370176, 39845888, 40894464], [18350080, 18350080, 18350080],
                [0, 0, -2621440], [32, 32, 64], [10485760, 8912896, 7340032],
                [undefined, 7340032, 6291456], [undefined, 0, 1048576],
                [2097152, 1048576, 786432], [undefined, 1, undefined],
                [5242880, 5242880, 5767168], [1048576, 1572864, 2097152]],
            contexts: extractProcessMemoryDumps(processMemoryDumps, 2)
          },
          {
            title: colorLegendMatcher('Process 3'),
            sizes: [undefined, undefined, undefined, undefined, undefined,
                undefined, undefined, undefined, undefined,
                [2147483648, undefined, 1073741824],
                [1073741824, undefined, 2147483648], undefined],
            contexts: extractProcessMemoryDumps(processMemoryDumps, 3)
          },
          {
            title: colorLegendMatcher('Process 4'),
            sizes: [undefined, [undefined, 17825792, 17825792], undefined,
                undefined, undefined, undefined, undefined, undefined,
                undefined, undefined, undefined, undefined],
            contexts: extractProcessMemoryDumps(processMemoryDumps, 4)
          }
        ],
        [  // Footer rows.
          {
            title: 'Total',
            sizes: [[50855936, 47710208, 15728640],
                [40370176, 57671680, 58720256], [28835840, 27787264, 18350080],
                [8388608, 5767168, -2621440], [32, 32, 64],
                [10485760, 8912896, 7340032], [undefined, 7340032, 6291456],
                [undefined, 0, 1048576], [2097152, 8388608, 786432],
                [2147483648, 1, 1073741824], [1078984704, 5242880, 2153250816],
                [1048576, 3670016, 2097152]],
            contexts: undefined
          }
        ],
        AggregationMode.DIFF);
  });

  test('instantiate_singleProcessMemoryDump', function() {
    var processMemoryDumps = convertToProcessMemoryDumps(
        [tr.ui.analysis.createSingleTestProcessMemoryDump()]);
    createAndCheckMemoryDumpOverviewPane(this,
        processMemoryDumps,
        [  // Table rows.
          {
            title: colorLegendMatcher('Process 2'),
            sizes: [[17825792], [39845888], [18350080], [0], [32], [8912896],
                [7340032], [0], [1048576], [1], [5242880], [1572864]],
            contexts: extractProcessMemoryDumps(processMemoryDumps, 2)
          }
        ],
        [] /* footer rows */,
        undefined /* no aggregation */);
  });

  test('instantiate_multipleProcessMemoryDumps', function() {
    var processMemoryDumps = convertToProcessMemoryDumps(
        tr.ui.analysis.createMultipleTestProcessMemoryDumps());
    createAndCheckMemoryDumpOverviewPane(this,
        processMemoryDumps,
        [  // Table rows.
          {
            title: colorLegendMatcher('Process 2'),
            sizes: [[19398656, 17825792, 15728640],
                [40370176, 39845888, 40894464], [18350080, 18350080, 18350080],
                [0, 0, -2621440], [32, 32, 64], [10485760, 8912896, 7340032],
                [undefined, 7340032, 6291456], [undefined, 0, 1048576],
                [2097152, 1048576, 786432], [undefined, 1, undefined],
                [5242880, 5242880, 5767168], [1048576, 1572864, 2097152]],
            contexts: extractProcessMemoryDumps(processMemoryDumps, 2)
          }
        ],
        [] /* footer rows */,
        AggregationMode.MAX);
  });

  test('selection', function() {
    var processMemoryDumps = convertToProcessMemoryDumps(
        tr.ui.analysis.createMultipleTestGlobalMemoryDumps());

    var viewEl =
        tr.ui.analysis.createTestPane('tr-ui-a-memory-dump-overview-pane');
    viewEl.processMemoryDumps = processMemoryDumps;
    viewEl.aggregationMode = AggregationMode.DIFF;
    viewEl.rebuild();
    this.addHTMLOutput(viewEl);

    var table = viewEl.$.table;

    // Simulate clicking on the 'malloc' cell of the second process.
    table.selectedTableRow = table.tableRows[1];
    table.selectedColumnIndex = 9;
    assert.lengthOf(viewEl.requestedChildPanes, 2);
    var lastChildPane = viewEl.requestedChildPanes[1];
    assert.equal(
        lastChildPane.tagName, 'TR-UI-A-MEMORY-DUMP-ALLOCATOR-DETAILS-PANE');
    assert.strictEqual(lastChildPane.aggregationMode, AggregationMode.DIFF);
    assert.deepEqual(lastChildPane.memoryAllocatorDumps,
        extractMemoryAllocatorDumps(processMemoryDumps, 2, 'malloc'));

    // Simulate clicking on the 'Oilpan' cell of the second process.
    table.selectedColumnIndex = 10;
    assert.lengthOf(viewEl.requestedChildPanes, 3);
    var lastChildPane = viewEl.requestedChildPanes[2];
    assert.isUndefined(viewEl.lastChildPane);
  });

  test('memory', function() {
    var processMemoryDumps = convertToProcessMemoryDumps(
        tr.ui.analysis.createMultipleTestGlobalMemoryDumps());
    var containerEl = document.createElement('div');
    containerEl.brushingStateController =
        new tr.c.BrushingStateController(undefined);

    function simulateView(pids, aggregationMode,
        expectedSelectedCellFieldValues, expectedSelectedRowTitle,
        expectedSelectedColumnIndex, callback) {
      var viewEl =
          tr.ui.analysis.createTestPane('tr-ui-a-memory-dump-overview-pane');
      var table = viewEl.$.table;
      Polymer.dom(containerEl).textContent = '';
      Polymer.dom(containerEl).appendChild(viewEl);

      var displayedProcessMemoryDumps = processMemoryDumps.map(
          function(memoryDumps) {
            return tr.b.filterItems(memoryDumps, function(pid, pmd) {
              return pids.indexOf(pmd.process.pid) !== -1;
            });
          });
      viewEl.processMemoryDumps = displayedProcessMemoryDumps;
      viewEl.aggregationMode = aggregationMode;
      viewEl.rebuild();

      if (expectedSelectedCellFieldValues === undefined) {
        assert.isUndefined(viewEl.childPaneBuilder);
      } else {
        checkSizeNumericFields(table.selectedTableRow,
            table.tableColumns[table.selectedColumnIndex],
            expectedSelectedCellFieldValues);
      }

      assert.strictEqual(
          table.selectedColumnIndex, expectedSelectedColumnIndex);
      if (expectedSelectedRowTitle === undefined)
        assert.isUndefined(table.selectedTableRow);
      else
        assert.equal(table.selectedTableRow.title, expectedSelectedRowTitle);

      callback(viewEl, viewEl.$.table);
    }

    simulateView(
        [1, 2, 3, 4],  // All processes.
        AggregationMode.DIFF,
        undefined, undefined, undefined,  // No cell should be selected.
        function(view, table) {
          assert.isUndefined(view.createChildPane());

          // Select the 'PSS' column of the second process.
          table.selectedTableRow = table.tableRows[1];
          table.selectedColumnIndex = 3;
        });

    simulateView(
        [2, 3],
        AggregationMode.MAX,
        [18350080, 18350080, 18350080], 'Process 2', 3, /* PSS */
        function(view, table) {
          var childPane = view.createChildPane();
          assert.equal(
              childPane.tagName, 'TR-UI-A-MEMORY-DUMP-VM-REGIONS-DETAILS-PANE');
          assert.deepEqual(tr.b.asArray(childPane.vmRegions),
              extractVmRegions(processMemoryDumps, 2));
          assert.strictEqual(childPane.aggregationMode, AggregationMode.MAX);
        });

    simulateView(
        [3],
        undefined, /* No aggregation */
        undefined, undefined, undefined,  // No cell selected.
        function(view, table) {
          assert.isUndefined(view.createChildPane());
        });

    simulateView(
        [1, 2, 3, 4],
        AggregationMode.DIFF,
        [18350080, 18350080, 18350080], 'Process 2', 3, /* PSS */
        function(view, table) {
          var childPane = view.createChildPane();
          assert.equal(
              childPane.tagName, 'TR-UI-A-MEMORY-DUMP-VM-REGIONS-DETAILS-PANE');
          assert.deepEqual(tr.b.asArray(childPane.vmRegions),
              extractVmRegions(processMemoryDumps, 2));
          assert.strictEqual(childPane.aggregationMode, AggregationMode.DIFF);

          // Select the 'v8' column of the first process (empty cell).
          table.selectedTableRow = table.tableRows[0];
          table.selectedColumnIndex = 10;
        });

    simulateView(
        [1],
        undefined, /* No aggregation */
        undefined, undefined, undefined,  // No cell should selected.
        function(view, table) {
          assert.isUndefined(view.createChildPane());

          // Select 'Total resident' column of the first process.
          table.selectedTableRow = table.tableRows[0];
          table.selectedColumnIndex = 1;
        });

    simulateView(
        [1, 2, 3, 4],
        AggregationMode.MAX,
        [31457280, 29884416, undefined], 'Process 1', 1, /* Total resident */
        function(view, table) {
          var childPane = view.createChildPane();
          assert.equal(
              childPane.tagName, 'TR-UI-A-MEMORY-DUMP-VM-REGIONS-DETAILS-PANE');
          assert.deepEqual(tr.b.asArray(childPane.vmRegions),
              extractVmRegions(processMemoryDumps, 1));
          assert.strictEqual(childPane.aggregationMode, AggregationMode.MAX);
        });
  });

  test('processNameColumn_formatTitle', function() {
    var c = new ProcessNameColumn();

    // With context (total row).
    assert.strictEqual(c.formatTitle({
      title: 'Total',
      usedMemoryCells: {}
    }), 'Total');

    // Without context (process row).
    var title = c.formatTitle({
      title: 'Process 1',
      usedMemoryCells: {},
      contexts: [tr.ui.analysis.createSingleTestProcessMemoryDump()]
    });
    checkColorLegend(title, 'Process 1');
  });

  test('usedMemoryColumn', function() {
    var c = new UsedMemoryColumn('Private', 'bytes', tr.b.identity,
        AggregationMode.DIFF);
    checkSpanWithColor(c.title, 'Private',
        'used_memory_column' /* blue (column title) */);
    checkColor(c.color(undefined /* contexts */),
        'used_memory_column' /* blue (column cells) */);
  });

  test('peakMemoryColumn', function() {
    var c = new PeakMemoryColumn('Peak', 'bytes', tr.b.identity,
        AggregationMode.MAX);
    checkSpanWithColor(c.title, 'Peak',
        'used_memory_column' /* blue (column title) */);
    checkColor(c.color(undefined) /* contexts */,
        'used_memory_column' /* blue (column cells) */);

    var RESETTABLE_PEAK = 1 << 2;
    var NON_RESETTABLE_PEAK = 1 << 3;
    function checkPeakColumnInfosAndColor(fieldAndDumpMask, expectedInfos) {
      checkOverviewColumnInfosAndColor(c,
          fieldAndDumpMask,
          function(pmd, mask) {
            if (mask & RESETTABLE_PEAK) {
              assert.strictEqual(
                  mask & NON_RESETTABLE_PEAK, 0);  // Test sanity check.
              pmd.arePeakResidentBytesResettable = true;
            } else if (mask & NON_RESETTABLE_PEAK) {
              pmd.arePeakResidentBytesResettable = false;
            }
          },
          expectedInfos,
          'used_memory_column');
    }

    // No context.
    checkOverviewColumnInfosAndColor(c,
        [FIELD],
        undefined /* no context */,
        [] /* no infos */,
        'used_memory_column' /* blue color */);
    checkOverviewColumnInfosAndColor(c,
        [FIELD, FIELD, 0, FIELD],
        undefined /* no context */,
        [] /* no infos */,
        'used_memory_column' /* blue color */);

    // All resettable.
    var EXPECTED_RESETTABLE_INFO = {
      icon: '\u21AA',
      message: 'Peak RSS since previous memory dump.'
    };
    checkPeakColumnInfosAndColor([
      FIELD | DUMP | RESETTABLE_PEAK
    ], [EXPECTED_RESETTABLE_INFO]);
    checkPeakColumnInfosAndColor([
      FIELD | DUMP | RESETTABLE_PEAK,
      DUMP /* ignored because there's no field */,
      0,
      FIELD | DUMP | RESETTABLE_PEAK
    ], [EXPECTED_RESETTABLE_INFO]);

    // All non-resettable.
    var EXPECTED_NON_RESETTABLE_INFO = {
      icon: '\u21A6',
      message: 'Peak RSS since process startup. Finer grained peaks require ' +
          'a Linux kernel version \u2265 4.0.'
    };
    checkPeakColumnInfosAndColor([
      FIELD | DUMP | NON_RESETTABLE_PEAK
    ], [EXPECTED_NON_RESETTABLE_INFO]);
    checkPeakColumnInfosAndColor([
      0,
      DUMP | RESETTABLE_PEAK /* ignored because there's no field */,
      FIELD | DUMP | NON_RESETTABLE_PEAK,
      FIELD | DUMP | NON_RESETTABLE_PEAK
    ], [EXPECTED_NON_RESETTABLE_INFO]);

    // Combination (warning).
    var EXPECTED_COMBINATION_INFO = {
      icon: '\u26A0',
      message: 'Both resettable and non-resettable peak RSS values were ' +
          'provided by the process',
      color: 'red'
    };
    checkPeakColumnInfosAndColor([
      FIELD | DUMP | NON_RESETTABLE_PEAK,
      0,
      FIELD | DUMP | RESETTABLE_PEAK,
      0
    ], [EXPECTED_COMBINATION_INFO]);
  });

  test('byteStatColumn', function() {
    var c = new ByteStatColumn('Stat', 'bytes', tr.b.identity,
        AggregationMode.DIFF);
    checkSpanWithColor(c.title, 'Stat',
        'used_memory_column' /* blue (column title) */);

    var HAS_OWN_VM_REGIONS = 1 << 2;
    function checkByteStatColumnInfosAndColor(
        fieldAndDumpMask, expectedInfos, expectedIsOlderColor) {
      checkOverviewColumnInfosAndColor(c,
          fieldAndDumpMask,
          function(pmd, mask) {
            if (mask & HAS_OWN_VM_REGIONS)
              pmd.vmRegions = [];
          },
          expectedInfos,
          expectedIsOlderColor ?
              'older_used_memory_column' /* light blue */ :
              'used_memory_column' /* blue color */);
    }

    var EXPECTED_ALL_OLDER_VALUES = {
      icon: '\u26AF',
      message: 'Older value (only heavy (purple) memory dumps contain ' +
          'memory maps).'
    };
    var EXPECTED_SOME_OLDER_VALUES = {
      icon: '\u26AF',
      message: 'Older value at some selected timestamps (only heavy ' +
          '(purple) memory dumps contain memory maps).'
    };

    // No context.
    checkOverviewColumnInfosAndColor(c,
        [FIELD],
        undefined /* no context */,
        [] /* no infos */,
        'used_memory_column' /* blue color */);
    checkOverviewColumnInfosAndColor(c,
        [FIELD, FIELD, 0, FIELD],
        undefined /* no context */,
        [] /* no infos */,
        'used_memory_column' /* blue color */);

    // All process memory dumps have own VM regions.
    checkByteStatColumnInfosAndColor([
      FIELD | DUMP | HAS_OWN_VM_REGIONS
    ], [] /* no infos */, false /* blue color */);
    checkByteStatColumnInfosAndColor([
      FIELD | DUMP | HAS_OWN_VM_REGIONS,
      FIELD | DUMP | HAS_OWN_VM_REGIONS,
      0,
      FIELD | DUMP | HAS_OWN_VM_REGIONS
    ], [] /* no infos */, false /* blue color */);

    // No process memory dumps have own VM regions.
    checkByteStatColumnInfosAndColor([
      FIELD | DUMP
    ], [EXPECTED_ALL_OLDER_VALUES], true /* light blue */);
    checkByteStatColumnInfosAndColor([
      FIELD | DUMP,
      FIELD | DUMP
    ], [EXPECTED_ALL_OLDER_VALUES], true /* light blue */);

    // Some process memory dumps don't have own VM regions.
    checkByteStatColumnInfosAndColor([
      FIELD | DUMP,
      0,
      FIELD | DUMP
    ], [EXPECTED_SOME_OLDER_VALUES], true /* light blue */);
    checkByteStatColumnInfosAndColor([
      FIELD | DUMP | HAS_OWN_VM_REGIONS,
      FIELD | DUMP,
      FIELD | DUMP | HAS_OWN_VM_REGIONS
    ], [EXPECTED_SOME_OLDER_VALUES], false /* blue */);
  });

  test('allocatorColumn', function() {
    var c = new AllocatorColumn('Allocator', 'bytes', tr.b.identity,
        AggregationMode.MAX);
    checkColorLegend(c.title, 'Allocator');
    checkColor(c.color(undefined /* contexts */),
        undefined /* no color (column cells) */);

    var HAS_HEAP_DUMPS = 1 << 2;
    var HAS_ALLOCATOR_HEAP_DUMP = 1 << 3;
    var MISSING_SIZE = 1 << 4;
    function checkAllocatorColumnInfosAndColor(fieldAndDumpMask,
        expectedInfos) {
      checkOverviewColumnInfosAndColor(c,
          fieldAndDumpMask,
          function(pmd, mask) {
            if (mask & HAS_HEAP_DUMPS)
              pmd.heapDumps = {};
            if (mask & HAS_ALLOCATOR_HEAP_DUMP)
              pmd.heapDumps['Allocator'] = new HeapDump(pmd, 'Allocator');
            var mad = new MemoryAllocatorDump(pmd, 'Allocator');
            if (!(mask & MISSING_SIZE)) {
              mad.addNumeric('size',
                  new ScalarNumeric(sizeInBytes_smallerIsBetter, 7));
            }
            pmd.memoryAllocatorDumps = [mad];
          },
          expectedInfos,
          undefined /* no color */);
    }

    // No context.
    checkOverviewColumnInfosAndColor(c,
        [FIELD],
        undefined /* no context */,
        [] /* no infos */,
        undefined /* no color */);
    checkOverviewColumnInfosAndColor(c,
        [FIELD, FIELD, 0, FIELD],
        undefined /* no context */,
        [] /* no infos */,
        undefined /* no color */);

    // No infos.
    checkAllocatorColumnInfosAndColor([
      FIELD | DUMP
    ], [] /* no infos */);
    checkAllocatorColumnInfosAndColor([
      FIELD | DUMP,
      FIELD | DUMP | HAS_HEAP_DUMPS,
      0,
      FIELD | DUMP
    ], [] /* infos */);

    var EXPECTED_ALL_HAVE_ALLOCATOR_HEAP_DUMP = {
      icon: '\u2630',
      message: 'Heap dump provided.'
    };
    var EXPECTED_SOME_HAVE_ALLOCATOR_HEAP_DUMP = {
      icon: '\u2630',
      message: 'Heap dump provided at some selected timestamps.'
    };

    // All process memory dumps have heap dumps.
    checkAllocatorColumnInfosAndColor([
      FIELD | DUMP | HAS_HEAP_DUMPS | HAS_ALLOCATOR_HEAP_DUMP
    ], [EXPECTED_ALL_HAVE_ALLOCATOR_HEAP_DUMP]);
    checkAllocatorColumnInfosAndColor([
      FIELD | DUMP | HAS_HEAP_DUMPS | HAS_ALLOCATOR_HEAP_DUMP,
      FIELD | DUMP | HAS_HEAP_DUMPS | HAS_ALLOCATOR_HEAP_DUMP,
      FIELD | DUMP | HAS_HEAP_DUMPS | HAS_ALLOCATOR_HEAP_DUMP
    ], [EXPECTED_ALL_HAVE_ALLOCATOR_HEAP_DUMP]);

    // Some process memory dumps have heap dumps.
    checkAllocatorColumnInfosAndColor([
      0,
      FIELD | DUMP | HAS_HEAP_DUMPS | HAS_ALLOCATOR_HEAP_DUMP
    ], [EXPECTED_SOME_HAVE_ALLOCATOR_HEAP_DUMP]);
    checkAllocatorColumnInfosAndColor([
      FIELD | DUMP | HAS_HEAP_DUMPS | HAS_ALLOCATOR_HEAP_DUMP,
      FIELD | DUMP | HAS_HEAP_DUMPS,
      FIELD | DUMP | HAS_HEAP_DUMPS | HAS_ALLOCATOR_HEAP_DUMP
    ], [EXPECTED_SOME_HAVE_ALLOCATOR_HEAP_DUMP]);

    var EXPECTED_ALL_MISSING_SIZE = {
      icon: '\u26A0',
      message: 'Size was not provided.',
      color: 'red'
    };
    var EXPECTED_SOME_MISSING_SIZE = {
      icon: '\u26A0',
      message: 'Size was not provided at some selected timestamps.',
      color: 'red'
    };

    // All process memory dumps are missing allocator size.
    checkAllocatorColumnInfosAndColor([
      FIELD | DUMP | MISSING_SIZE
    ], [EXPECTED_ALL_MISSING_SIZE]);
    checkAllocatorColumnInfosAndColor([
      FIELD | DUMP | MISSING_SIZE,
      FIELD | DUMP | MISSING_SIZE,
      FIELD | DUMP | MISSING_SIZE
    ], [EXPECTED_ALL_MISSING_SIZE]);

    // Some process memory dumps use Android memtrack PSS fallback.
    checkAllocatorColumnInfosAndColor([
      0,
      FIELD | DUMP | MISSING_SIZE
    ], [EXPECTED_SOME_MISSING_SIZE]);
    checkAllocatorColumnInfosAndColor([
      FIELD | DUMP | MISSING_SIZE,
      FIELD | DUMP,
      FIELD | DUMP | MISSING_SIZE
    ], [EXPECTED_SOME_MISSING_SIZE]);

    // Combination of heap dump and memtrack fallback infos.
    checkAllocatorColumnInfosAndColor([
      FIELD | DUMP | MISSING_SIZE | HAS_HEAP_DUMPS |
          HAS_ALLOCATOR_HEAP_DUMP
    ], [
      EXPECTED_ALL_HAVE_ALLOCATOR_HEAP_DUMP,
      EXPECTED_ALL_MISSING_SIZE
    ]);
    checkAllocatorColumnInfosAndColor([
      FIELD | DUMP | HAS_HEAP_DUMPS | HAS_ALLOCATOR_HEAP_DUMP,
      FIELD | DUMP,
      FIELD | DUMP | MISSING_SIZE
    ], [
      EXPECTED_SOME_HAVE_ALLOCATOR_HEAP_DUMP,
      EXPECTED_SOME_MISSING_SIZE
    ]);
  });

  test('tracingColumn', function() {
    var c = new TracingColumn('Tracing', 'bytes', tr.b.identity,
        AggregationMode.DIFF);
    checkSpanWithColor(c.title, 'Tracing',
        'tracing_memory_column' /* expected column title gray color */);
    checkColor(c.color(undefined /* contexts */),
        'tracing_memory_column' /* expected column cells gray color */);
  });
});
</script>