// Copyright 2016 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "cobalt/browser/memory_tracker/tool/tool_impl.h"
#include "build/build_config.h"

#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace cobalt {
namespace browser {
namespace memory_tracker {

using ::nb::analytics::AllocationGroup;
using ::nb::analytics::AllocationRecord;
using ::nb::analytics::AllocationVisitor;

// Tests the expectation that AllocationSizeBinner will correctly bin
// allocations.
TEST(MemoryTrackerToolTest, AllocationSizeBinner) {
  const size_t index =
      AllocationSizeBinner::GetBucketIndexForAllocationSize(24);
  EXPECT_EQ(5, static_cast<int>(index));

  const size_t kAllocSize = 24;

  AllocationSizeBinner binner(NULL);
  void* dummy_memory = SbMemoryAllocate(kAllocSize);

  AllocationRecord allocation_record(kAllocSize, NULL);
  binner.Visit(dummy_memory, allocation_record);

  size_t min_val = 0;
  size_t max_val = 0;
  AllocationSizeBinner::GetSizeRange(kAllocSize, &min_val, &max_val);
  EXPECT_EQ(16, static_cast<int>(min_val));
  EXPECT_EQ(31, static_cast<int>(max_val));

  // 0 -> [0,0]
  // 1 -> [1,1]
  // 2 -> [2,3]
  // 3 -> [4,7]
  // 4 -> [8,15]
  // 5 -> [16,31] ...
  EXPECT_EQ(1, binner.allocation_histogram()[5]);

  allocation_record.size = 15;
  binner.Visit(NULL, allocation_record);
  binner.Visit(NULL, allocation_record);

  size_t min_value = 0;
  size_t max_value = 0;
  binner.GetLargestSizeRange(&min_value, &max_value);
  EXPECT_EQ(min_value, static_cast<int>(8));
  EXPECT_EQ(max_value, static_cast<int>(15));

  std::string csv_string = binner.ToCSVString();

  // Expect header.
  bool found = (csv_string.find("\"8...15\",\"16...31\"") != std::string::npos);
  EXPECT_TRUE(found);

  // Expect data.
  found = (csv_string.find("2,1") != std::string::npos);
  SbMemoryDeallocate(dummy_memory);
}

// Tests the expectation that AllocationSizeBinner will correctly bin
// allocations.
TEST(MemoryTrackerToolTest, FindTopSizes) {
  const size_t min_size = 21;
  const size_t max_size = 23;
  AllocationGroup* group = NULL;  // signals "accept any group".

  FindTopSizes top_sizes_visitor(min_size, max_size, group);

  AllocationRecord record_a(21, group);
  AllocationRecord record_b(22, group);
  AllocationRecord record_c(22, group);
  AllocationRecord record_d(24, group);

  const void* dummy_alloc = NULL;
  top_sizes_visitor.Visit(dummy_alloc, record_a);
  top_sizes_visitor.Visit(dummy_alloc, record_b);
  top_sizes_visitor.Visit(dummy_alloc, record_c);
  top_sizes_visitor.Visit(dummy_alloc, record_d);

  std::vector<FindTopSizes::GroupAllocation> top_allocations =
      top_sizes_visitor.GetTopAllocations();

  // Expect element 24 to be filtered out, leaving only 22 and 24.
  EXPECT_EQ(top_allocations.size(), 2);
  // Expect that allocation size 22 is the top allocation.
  EXPECT_EQ(top_allocations[0].allocation_size, 22);
  EXPECT_EQ(top_allocations[0].allocation_count, 2);
  // And then the 21 byte allocation.
  EXPECT_EQ(top_allocations[1].allocation_size, 21);
  EXPECT_EQ(top_allocations[1].allocation_count, 1);
}

}  // namespace memory_tracker
}  // namespace browser
}  // namespace cobalt