sample_map_unittest.cc 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/metrics/sample_map.h"
  5. #include <memory>
  6. #include "base/test/gtest_util.h"
  7. #include "testing/gtest/include/gtest/gtest.h"
  8. namespace base {
  9. namespace {
  10. TEST(SampleMapTest, AccumulateTest) {
  11. SampleMap samples(1);
  12. samples.Accumulate(1, 100);
  13. samples.Accumulate(2, 200);
  14. samples.Accumulate(1, -200);
  15. EXPECT_EQ(-100, samples.GetCount(1));
  16. EXPECT_EQ(200, samples.GetCount(2));
  17. EXPECT_EQ(300, samples.sum());
  18. EXPECT_EQ(100, samples.TotalCount());
  19. EXPECT_EQ(samples.redundant_count(), samples.TotalCount());
  20. }
  21. TEST(SampleMapTest, Accumulate_LargeValuesDontOverflow) {
  22. SampleMap samples(1);
  23. samples.Accumulate(250000000, 100);
  24. samples.Accumulate(500000000, 200);
  25. samples.Accumulate(250000000, -200);
  26. EXPECT_EQ(-100, samples.GetCount(250000000));
  27. EXPECT_EQ(200, samples.GetCount(500000000));
  28. EXPECT_EQ(75000000000LL, samples.sum());
  29. EXPECT_EQ(100, samples.TotalCount());
  30. EXPECT_EQ(samples.redundant_count(), samples.TotalCount());
  31. }
  32. TEST(SampleMapTest, AddSubtractTest) {
  33. SampleMap samples1(1);
  34. SampleMap samples2(2);
  35. samples1.Accumulate(1, 100);
  36. samples1.Accumulate(2, 100);
  37. samples1.Accumulate(3, 100);
  38. samples2.Accumulate(1, 200);
  39. samples2.Accumulate(2, 200);
  40. samples2.Accumulate(4, 200);
  41. samples1.Add(samples2);
  42. EXPECT_EQ(300, samples1.GetCount(1));
  43. EXPECT_EQ(300, samples1.GetCount(2));
  44. EXPECT_EQ(100, samples1.GetCount(3));
  45. EXPECT_EQ(200, samples1.GetCount(4));
  46. EXPECT_EQ(2000, samples1.sum());
  47. EXPECT_EQ(900, samples1.TotalCount());
  48. EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount());
  49. samples1.Subtract(samples2);
  50. EXPECT_EQ(100, samples1.GetCount(1));
  51. EXPECT_EQ(100, samples1.GetCount(2));
  52. EXPECT_EQ(100, samples1.GetCount(3));
  53. EXPECT_EQ(0, samples1.GetCount(4));
  54. EXPECT_EQ(600, samples1.sum());
  55. EXPECT_EQ(300, samples1.TotalCount());
  56. EXPECT_EQ(samples1.redundant_count(), samples1.TotalCount());
  57. }
  58. TEST(SampleMapIteratorTest, IterateTest) {
  59. SampleMap samples(1);
  60. samples.Accumulate(1, 100);
  61. samples.Accumulate(2, 200);
  62. samples.Accumulate(4, -300);
  63. samples.Accumulate(5, 0);
  64. std::unique_ptr<SampleCountIterator> it = samples.Iterator();
  65. HistogramBase::Sample min;
  66. int64_t max;
  67. HistogramBase::Count count;
  68. it->Get(&min, &max, &count);
  69. EXPECT_EQ(1, min);
  70. EXPECT_EQ(2, max);
  71. EXPECT_EQ(100, count);
  72. EXPECT_FALSE(it->GetBucketIndex(nullptr));
  73. it->Next();
  74. it->Get(&min, &max, &count);
  75. EXPECT_EQ(2, min);
  76. EXPECT_EQ(3, max);
  77. EXPECT_EQ(200, count);
  78. it->Next();
  79. it->Get(&min, &max, &count);
  80. EXPECT_EQ(4, min);
  81. EXPECT_EQ(5, max);
  82. EXPECT_EQ(-300, count);
  83. it->Next();
  84. EXPECT_TRUE(it->Done());
  85. }
  86. TEST(SampleMapIteratorTest, SkipEmptyRanges) {
  87. SampleMap samples(1);
  88. samples.Accumulate(5, 1);
  89. samples.Accumulate(10, 2);
  90. samples.Accumulate(15, 3);
  91. samples.Accumulate(20, 4);
  92. samples.Accumulate(25, 5);
  93. SampleMap samples2(2);
  94. samples2.Accumulate(5, 1);
  95. samples2.Accumulate(20, 4);
  96. samples2.Accumulate(25, 5);
  97. samples.Subtract(samples2);
  98. std::unique_ptr<SampleCountIterator> it = samples.Iterator();
  99. EXPECT_FALSE(it->Done());
  100. HistogramBase::Sample min;
  101. int64_t max;
  102. HistogramBase::Count count;
  103. it->Get(&min, &max, &count);
  104. EXPECT_EQ(10, min);
  105. EXPECT_EQ(11, max);
  106. EXPECT_EQ(2, count);
  107. it->Next();
  108. EXPECT_FALSE(it->Done());
  109. it->Get(&min, &max, &count);
  110. EXPECT_EQ(15, min);
  111. EXPECT_EQ(16, max);
  112. EXPECT_EQ(3, count);
  113. it->Next();
  114. EXPECT_TRUE(it->Done());
  115. }
  116. TEST(SampleMapIteratorDeathTest, IterateDoneTest) {
  117. SampleMap samples(1);
  118. std::unique_ptr<SampleCountIterator> it = samples.Iterator();
  119. EXPECT_TRUE(it->Done());
  120. HistogramBase::Sample min;
  121. int64_t max;
  122. HistogramBase::Count count;
  123. EXPECT_DCHECK_DEATH(it->Get(&min, &max, &count));
  124. EXPECT_DCHECK_DEATH(it->Next());
  125. samples.Accumulate(1, 100);
  126. it = samples.Iterator();
  127. EXPECT_FALSE(it->Done());
  128. }
  129. } // namespace
  130. } // namespace base