path: root/components/metrics/leak_detector/leak_analyzer_unittest.cc

// 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.

#include "components/metrics/leak_detector/leak_analyzer.h"

#include <stdint.h>

#include <algorithm>

#include "base/macros.h"
#include "components/metrics/leak_detector/custom_allocator.h"
#include "components/metrics/leak_detector/ranked_set.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace metrics {
namespace leak_detector {

namespace {

// Default ranking size and threshold used for leak analysis.
const int kDefaultRankedSetSize = 10;
const int kDefaultLeakThreshold = 5;

// Makes it easier to instantiate LeakDetectorValueTypes. Instantiates with an
// integer value that indicates an allocation size. Storing the size allows us
// to track the storage of the LeakDetectorValueType object within LeakAnalyzer.
//
// There is no need to test this with call stacks in addition to sizes because
// call stacks will be contained in a LeakDetectorValueType object as well.
LeakDetectorValueType Size(uint32_t value) {
  return LeakDetectorValueType(value);
}

}  // namespace

class LeakAnalyzerTest : public ::testing::Test {
 public:
  LeakAnalyzerTest() {}

  void SetUp() override { CustomAllocator::Initialize(); }
  void TearDown() override { EXPECT_TRUE(CustomAllocator::Shutdown()); }

 private:
  DISALLOW_COPY_AND_ASSIGN(LeakAnalyzerTest);
};

TEST_F(LeakAnalyzerTest, Empty) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);
  EXPECT_TRUE(analyzer.suspected_leaks().empty());
}

TEST_F(LeakAnalyzerTest, SingleSize) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);

  for (int i = 0; i < kDefaultLeakThreshold + 20; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    set.Add(Size(24), 10);
    analyzer.AddSample(std::move(set));

    // No leaks should have been detected.
    EXPECT_TRUE(analyzer.suspected_leaks().empty());
  }
}

TEST_F(LeakAnalyzerTest, VariousSizesWithoutIncrease) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);

  for (int i = 0; i < kDefaultLeakThreshold + 20; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    set.Add(Size(24), 30);
    set.Add(Size(32), 10);
    set.Add(Size(56), 90);
    set.Add(Size(64), 40);
    analyzer.AddSample(std::move(set));

    // No leaks should have been detected.
    EXPECT_TRUE(analyzer.suspected_leaks().empty());
  }
}

TEST_F(LeakAnalyzerTest, VariousSizesWithEqualIncrease) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);

  for (int i = 0; i < kDefaultLeakThreshold + 20; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    set.Add(Size(24), 30 + i * 10);
    set.Add(Size(32), 10 + i * 10);
    set.Add(Size(56), 90 + i * 10);
    set.Add(Size(64), 40 + i * 10);
    analyzer.AddSample(std::move(set));

    // No leaks should have been detected.
    EXPECT_TRUE(analyzer.suspected_leaks().empty());
  }
}

TEST_F(LeakAnalyzerTest, NotEnoughRunsToTriggerLeakReport) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);

  // Run this one iteration short of the number of cycles needed to trigger a
  // leak report. Because LeakAnalyzer requires |kDefaultLeakThreshold|
  // suspicions based on deltas between AddSample() calls, the below loop needs
  // to run |kDefaultLeakThreshold + 1| times to trigger a leak report.
  for (int i = 0; i <= kDefaultLeakThreshold - 1; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    set.Add(Size(24), 30 + i * 10);  // This one has a potential leak.
    set.Add(Size(32), 10 + i * 2);
    set.Add(Size(56), 90 + i);
    set.Add(Size(64), 40 + i / 2);
    analyzer.AddSample(std::move(set));

    // No leaks should have been detected.
    EXPECT_TRUE(analyzer.suspected_leaks().empty());
  }
}

TEST_F(LeakAnalyzerTest, LeakSingleSize) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);

  // Run this past the number of iterations required to trigger a leak report.
  for (int i = 0; i < kDefaultLeakThreshold + 10; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    set.Add(Size(32), 10);
    set.Add(Size(56), 90);
    set.Add(Size(24), 30 + i * 10);  // This one has a potential leak.
    set.Add(Size(64), 40);
    analyzer.AddSample(std::move(set));

    // No leaks should have been detected initially...
    if (i < kDefaultLeakThreshold) {
      EXPECT_TRUE(analyzer.suspected_leaks().empty());
    } else {
      // ... but there should be reported leaks once the threshold is reached.
      const auto& leaks = analyzer.suspected_leaks();
      ASSERT_EQ(1U, leaks.size());
      EXPECT_EQ(24U, leaks[0].size());
    }
  }
}

TEST_F(LeakAnalyzerTest, LeakSingleSizeOthersAlsoIncreasing) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);

  for (int i = 0; i < kDefaultLeakThreshold + 10; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    set.Add(Size(24), 30 + i * 10);  // This one has a potential leak.
    set.Add(Size(32), 10 + i * 2);
    set.Add(Size(56), 90 + i);
    set.Add(Size(64), 40 + i / 2);
    analyzer.AddSample(std::move(set));

    // No leaks should have been detected initially...
    if (i < kDefaultLeakThreshold) {
      EXPECT_TRUE(analyzer.suspected_leaks().empty());
    } else {
      // ... but there should be reported leaks once the threshold is reached.
      const auto& leaks = analyzer.suspected_leaks();
      ASSERT_EQ(1U, leaks.size());
      EXPECT_EQ(24U, leaks[0].size());
    }
  }
}

TEST_F(LeakAnalyzerTest, LeakMultipleSizes) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);

  for (int i = 0; i < kDefaultLeakThreshold + 10; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    set.Add(Size(24), 30 + i * 5);
    set.Add(Size(32), 10 + i * 40);
    set.Add(Size(56), 90 + i * 30);
    set.Add(Size(64), 40 + i * 20);
    set.Add(Size(80), 20 + i * 3);
    analyzer.AddSample(std::move(set));

    // No leaks should have been detected initially...
    if (i < kDefaultLeakThreshold) {
      EXPECT_TRUE(analyzer.suspected_leaks().empty());
    } else {
      // ... but there should be reported leaks once the threshold is reached.
      const auto& leaks = analyzer.suspected_leaks();
      ASSERT_EQ(3U, leaks.size());
      // These should be in order of increasing allocation size.
      EXPECT_EQ(32U, leaks[0].size());
      EXPECT_EQ(56U, leaks[1].size());
      EXPECT_EQ(64U, leaks[2].size());
    }
  }
}

TEST_F(LeakAnalyzerTest, LeakMultipleSizesValueOrder) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);

  for (int i = 0; i <= kDefaultLeakThreshold; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    // These are similar to LeakMultipleSizes, but the relative order of
    // allocation increases is different from the relative order of sizes.
    set.Add(Size(24), 30 + i * 5);
    set.Add(Size(32), 10 + i * 20);
    set.Add(Size(56), 90 + i * 40);
    set.Add(Size(64), 40 + i * 30);
    set.Add(Size(80), 20 + i * 3);
    analyzer.AddSample(std::move(set));
  }

  const auto& leaks = analyzer.suspected_leaks();
  ASSERT_EQ(3U, leaks.size());
  // These should be in order of increasing allocation size, NOT in order of
  // allocation count or deltas.
  EXPECT_EQ(32U, leaks[0].size());
  EXPECT_EQ(56U, leaks[1].size());
  EXPECT_EQ(64U, leaks[2].size());
}

TEST_F(LeakAnalyzerTest, EqualIncreasesNoLeak) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);

  for (int i = 0; i < kDefaultLeakThreshold + 20; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    set.Add(Size(24), 30 + i * 10);
    set.Add(Size(32), 10 + i * 10);
    set.Add(Size(56), 90 + i * 10);
    set.Add(Size(64), 40 + i * 10);
    set.Add(Size(80), 20 + i * 10);
    analyzer.AddSample(std::move(set));

    EXPECT_TRUE(analyzer.suspected_leaks().empty());
  }
}

TEST_F(LeakAnalyzerTest, NotBigEnoughDeltaGap) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);

  for (int i = 0; i < kDefaultLeakThreshold + 20; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    // These all have different increments but there is no clear group of
    // increases that are larger than the rest.
    set.Add(Size(24), 30 + i * 80);
    set.Add(Size(32), 10 + i * 45);
    set.Add(Size(56), 90 + i * 25);
    set.Add(Size(64), 40 + i * 15);
    set.Add(Size(80), 20 + i * 10);
    analyzer.AddSample(std::move(set));

    EXPECT_TRUE(analyzer.suspected_leaks().empty());
  }
}

TEST_F(LeakAnalyzerTest, RepeatedRisesUntilLeakFound) {
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kDefaultLeakThreshold);

  // Remember, there is an extra iteration beyond |kDefaultLeakThreshold| needed
  // to actually trigger the leak detection.
  for (int i = 0; i <= kDefaultLeakThreshold - 2; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    set.Add(Size(24), 30 + i * 10);
    set.Add(Size(32), 10);
    set.Add(Size(56), 90);
    set.Add(Size(64), 40);
    set.Add(Size(80), 20);
    analyzer.AddSample(std::move(set));

    EXPECT_TRUE(analyzer.suspected_leaks().empty());
  }

  // Drop back down to 30.
  for (int i = 0; i <= kDefaultLeakThreshold - 1; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    set.Add(Size(24), 30 + i * 10);
    set.Add(Size(32), 10);
    set.Add(Size(56), 90);
    set.Add(Size(64), 40);
    set.Add(Size(80), 20);
    analyzer.AddSample(std::move(set));

    EXPECT_TRUE(analyzer.suspected_leaks().empty());
  }

  // Drop back down to 30.
  for (int i = 0; i <= kDefaultLeakThreshold; ++i) {
    // Initially there should not be any leak detected.
    EXPECT_TRUE(analyzer.suspected_leaks().empty());

    RankedSet set(kDefaultRankedSetSize);
    set.Add(Size(24), 30 + i * 10);
    set.Add(Size(32), 10);
    set.Add(Size(56), 90);
    set.Add(Size(64), 40);
    set.Add(Size(80), 20);
    analyzer.AddSample(std::move(set));
  }
  const auto& leaks = analyzer.suspected_leaks();
  ASSERT_EQ(1U, leaks.size());
  EXPECT_EQ(24U, leaks[0].size());
}

TEST_F(LeakAnalyzerTest, LeakWithMultipleGroupsOfDeltas) {
  const int kRankedSetSize = 20;
  LeakAnalyzer analyzer(kRankedSetSize, kDefaultLeakThreshold);

  for (int i = 0; i <= kDefaultLeakThreshold; ++i) {
    RankedSet set(kRankedSetSize);
    set.Add(Size(24), 30 + i * 10);  // A group of smaller deltas.
    set.Add(Size(32), 10 + i * 3);
    set.Add(Size(80), 20 + i * 5);
    set.Add(Size(40), 30 + i * 7);
    set.Add(Size(56), 90);
    set.Add(Size(64), 40);
    set.Add(Size(128), 100);
    set.Add(Size(44), 100 + i * 10);  // A group of medium deltas.
    set.Add(Size(16), 60 + i * 50);
    set.Add(Size(4), 20 + i * 40);
    set.Add(Size(8), 100 + i * 60);
    set.Add(Size(48), 100);
    set.Add(Size(72), 60 + i * 240);  // A group of largest deltas.
    set.Add(Size(28), 100);
    set.Add(Size(100), 100 + i * 200);
    set.Add(Size(104), 60 + i * 128);
    analyzer.AddSample(std::move(set));
  }
  // Only the group of largest deltas should be caught.
  const auto& leaks = analyzer.suspected_leaks();
  ASSERT_EQ(3U, leaks.size());
  // These should be in order of increasing allocation size.
  EXPECT_EQ(72U, leaks[0].size());
  EXPECT_EQ(100U, leaks[1].size());
  EXPECT_EQ(104U, leaks[2].size());
}

TEST_F(LeakAnalyzerTest, LeakMultipleSizesWithLargeThreshold) {
  const int kLeakThreshold = 50;
  LeakAnalyzer analyzer(kDefaultRankedSetSize, kLeakThreshold);

  for (int i = 0; i <= kLeakThreshold + 10; ++i) {
    RankedSet set(kDefaultRankedSetSize);
    // * - Cluster of larger deltas
    set.Add(Size(24), 30 + i * 5);
    set.Add(Size(32), 10 + i * 40);  // *
    set.Add(Size(56), 90 + i * 30);  // *
    set.Add(Size(40), 30 + i * 7);
    set.Add(Size(64), 40 + i * 25);  // *
    set.Add(Size(80), 20 + i * 3);
    set.Add(Size(128), 100);
    set.Add(Size(44), 100 + i * 10);
    set.Add(Size(16), 60 + i * 50);  // *
    analyzer.AddSample(std::move(set));

    // No leaks should have been detected initially...
    if (i < kLeakThreshold) {
      EXPECT_TRUE(analyzer.suspected_leaks().empty());
    } else {
      // ... but there should be reported leaks once the threshold is reached.
      const auto& leaks = analyzer.suspected_leaks();
      ASSERT_EQ(4U, leaks.size());
      // These should be in order of increasing allocation size.
      EXPECT_EQ(16U, leaks[0].size());
      EXPECT_EQ(32U, leaks[1].size());
      EXPECT_EQ(56U, leaks[2].size());
      EXPECT_EQ(64U, leaks[3].size());
    }
  }
}

}  // namespace leak_detector
}  // namespace metrics