<!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="/core/test_utils.html">
<link rel="import" href="/core/trace_model/attribute.html">
<link rel="import" href="/core/trace_model/trace_model.html">
<link rel="import" href="/core/trace_model/global_memory_dump.html">
<link rel="import" href="/core/trace_model/process_memory_dump.html">

<script>
'use strict';

tv.b.unittest.testSuite(function() {
  var TraceModel = tv.c.TraceModel;
  var GlobalMemoryDump = tv.c.trace_model.GlobalMemoryDump;
  var ProcessMemoryDump = tv.c.trace_model.ProcessMemoryDump;
  var MemoryAllocatorDump = tv.c.trace_model.MemoryAllocatorDump;
  var VMRegion = tv.c.trace_model.VMRegion;
  var ScalarAttribute = tv.c.trace_model.ScalarAttribute;

  var createProcessMemoryDump = function(timestamp, model) {
    var gmd = new GlobalMemoryDump(model, timestamp);
    model.globalMemoryDumps.push(gmd);
    var p = model.getOrCreateProcess(123);
    var pmd = new ProcessMemoryDump(gmd, p, timestamp + 1);
    p.memoryDumps.push(pmd);
    return pmd;
  }

  var createFinalizedProcessMemoryDump = function(timestamp, createdCallback) {
    var model = tv.c.test_utils.newModel(function(model) {
      createdCallback(createProcessMemoryDump(timestamp, model));
    });
    var pmds = model.getProcess(123).memoryDumps;
    assert.lengthOf(pmds, 1);
    return pmds[0];
  }

  function checkProtectionFlagsToString(protectionFlags, expectedString) {
    var vmRegion = VMRegion.fromDict({
      startAddress: 256,
      sizeInBytes: 336,
      protectionFlags: protectionFlags,
      mappedFile: '[stack:20310]',
      byteStats: {
        privateResident: 96,
        sharedResident: 144,
        proportionalResident: 158
      }
    });
    assert.strictEqual(vmRegion.protectionFlagsToString, expectedString);
  }

  test('totalResidentSizeInBytes_undefinedVmRegions', function() {
    var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {});
    assert.isUndefined(pmd.mostRecentTotalProportionalResidentSizeInBytes);
    assert.isUndefined(pmd.mostRecentTotalPrivateResidentSizeInBytes);
    assert.isUndefined(pmd.mostRecentTotalSharedResidentSizeInBytes);
  });

  test('totalResidentSizeInBytes_zeroVmRegions', function() {
    var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
      pmd.vmRegions = [];
    });
    assert.equal(pmd.mostRecentTotalProportionalResidentSizeInBytes, 0);
    assert.equal(pmd.mostRecentTotalPrivateResidentSizeInBytes, 0);
    assert.equal(pmd.mostRecentTotalSharedResidentSizeInBytes, 0);
  });

  test('totalResidentSizeInBytes_oneVmRegion', function() {
    var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
      pmd.vmRegions = [
        VMRegion.fromDict({
          startAddress: 256,
          sizeInBytes: 336,
          protectionFlags: VMRegion.PROTECTION_FLAG_READ |
              VMRegion.PROTECTION_FLAG_WRITE,
          mappedFile: '[stack:20310]',
          byteStats: {
            privateResident: 96,
            sharedResident: 144,
            proportionalResident: 158
          }
        })
      ];
    });
    assert.equal(pmd.mostRecentTotalProportionalResidentSizeInBytes, 158);
    assert.equal(pmd.mostRecentTotalPrivateResidentSizeInBytes, 96);
    assert.equal(pmd.mostRecentTotalSharedResidentSizeInBytes, 144);
  });

  test('totalResidentSizeInBytes_twoVmRegions', function() {
    var pmd = createFinalizedProcessMemoryDump(42, function(pmd) {
      pmd.vmRegions = [
        VMRegion.fromDict({
          startAddress: 256,
          sizeInBytes: 336,
          protectionFlags: VMRegion.PROTECTION_FLAG_READ |
              VMRegion.PROTECTION_FLAG_WRITE,
          mappedFile: '[stack:20310]',
          byteStats: {
            privateResident: 96,
            sharedResident: 144,
            proportionalResident: 158
          }
        }),
        VMRegion.fromDict({
          startAddress: 848,
          sizeInBytes: 592,
          protectionFlags: VMRegion.PROTECTION_FLAG_READ |
              VMRegion.PROTECTION_FLAG_EXECUTE,
          mappedFile: '/dev/ashmem/dalvik',
          byteStats: {
            privateResident: 205,
            sharedResident: 0,
            proportionalResident: 205
          }
        })
      ];
    });
    assert.equal(pmd.mostRecentTotalProportionalResidentSizeInBytes, 363);
    assert.equal(pmd.mostRecentTotalPrivateResidentSizeInBytes, 301);
    assert.equal(pmd.mostRecentTotalSharedResidentSizeInBytes, 144);
  });

  test('hookUpMostRecentVmRegionsLinks_emptyArray', function() {
    var dumps = [];
    ProcessMemoryDump.hookUpMostRecentVmRegionsLinks(dumps);
    assert.lengthOf(dumps, 0);
  });

  test('hookUpMostRecentVmRegionsLinks_nonEmptyArray', function() {
    var m = new TraceModel();

    // A dump with no VM regions or allocator dumps.
    var dump1 = createProcessMemoryDump(1, m);

    // A dump with VM regions and malloc and Oilpan allocator dumps.
    var dump2 = createProcessMemoryDump(2, m);
    dump2.vmRegions = [];
    dump2.memoryAllocatorDumps = (function() {
      var oilpanDump = new MemoryAllocatorDump('oilpan');
      oilpanDump.addAttribute('outer_size', new ScalarAttribute('bytes', 1024));
      oilpanDump.addAttribute('objects_count',
          new ScalarAttribute('objects', 7));
      oilpanDump.addAttribute('inner_size', new ScalarAttribute('bytes', 768));

      var v8Dump = new MemoryAllocatorDump('v8');
      v8Dump.addAttribute('outer_size', new ScalarAttribute('bytes', 2048));
      v8Dump.addAttribute('objects_count', new ScalarAttribute('objects', 15));
      v8Dump.addAttribute('inner_size', new ScalarAttribute('bytes', 1999));

      return [oilpanDump. v8Dump];
    })();

    // A dump with malloc and V8 allocator dumps.
    var dump3 = createProcessMemoryDump(3, m);
    dump3.memoryAllocatorDumps = (function() {
      var mallocDump = new MemoryAllocatorDump('malloc');
      mallocDump.addAttribute('outer_size', new ScalarAttribute('bytes', 1024));
      mallocDump.addAttribute('objects_count',
          new ScalarAttribute('objects', 7));
      mallocDump.addAttribute('inner_size', new ScalarAttribute('bytes', 768));

      var v8Dump = new MemoryAllocatorDump('v8');
      v8Dump.addAttribute('outer_size', new ScalarAttribute('bytes', 2048));
      v8Dump.addAttribute('objects_count', new ScalarAttribute('objects', 15));
      v8Dump.addAttribute('inner_size', new ScalarAttribute('bytes', 1999));

      return [mallocDump. v8Dump];
    })();

    // A dump with VM regions.
    var dump4 = createProcessMemoryDump(4, m);
    dump4.vmRegions = [
      VMRegion.fromDict({
        startAddress: 256,
        sizeInBytes: 336,
        protectionFlags: VMRegion.PROTECTION_FLAG_READ |
            VMRegion.PROTECTION_FLAG_WRITE,
        mappedFile: '[stack:20310]',
        byteStats: {
          privateResident: 96,
          sharedResident: 144,
          proportionalResident: 158
        }
      })
    ];

    var dumps = [dump1, dump2, dump3, dump4];
    ProcessMemoryDump.hookUpMostRecentVmRegionsLinks(dumps);

    assert.lengthOf(dumps, 4);

    assert.equal(dumps[0], dump1);
    assert.isUndefined(dump1.mostRecentVmRegions);

    assert.equal(dumps[1], dump2);
    assert.equal(dump2.mostRecentVmRegions, dump2.vmRegions_);

    assert.equal(dumps[2], dump3);
    assert.equal(dump3.mostRecentVmRegions, dump2.vmRegions_);

    assert.equal(dumps[3], dump4);
    assert.equal(dump4.mostRecentVmRegions, dump4.vmRegions_);
  });

  test('vmRegion_protectionFlagsToString', function() {
    checkProtectionFlagsToString(undefined, undefined);
    checkProtectionFlagsToString(0, '---');
    checkProtectionFlagsToString(VMRegion.PROTECTION_FLAG_READ, 'r--');
    checkProtectionFlagsToString(
        VMRegion.PROTECTION_FLAG_READ | VMRegion.PROTECTION_FLAG_EXECUTE,
        'r-x');
    checkProtectionFlagsToString(
        VMRegion.PROTECTION_FLAG_READ | VMRegion.PROTECTION_FLAG_WRITE,
        'rw-');
  });
});
</script>