/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * 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 "src/trace_processor/db/column_storage_overlay.h"

#include <memory>

#include "src/base/test/gtest_test_suite.h"
#include "test/gtest_and_gmock.h"

namespace perfetto {
namespace trace_processor {
namespace {

TEST(ColumnStorageOverlay, FilterIntoEmptyOutput) {
  ColumnStorageOverlay rm(0, 10000);
  RowMap filter(4, 4);
  rm.FilterInto(&filter, [](uint32_t) -> bool {
    ADD_FAILURE() << "Should not have called lambda";
    return true;
  });

  ASSERT_EQ(filter.size(), 0u);
}

TEST(ColumnStorageOverlay, FilterIntoSingleRowTrue) {
  ColumnStorageOverlay rm(100, 10000);
  RowMap filter(6, 7);
  rm.FilterInto(&filter, [](uint32_t row) { return row == 106u; });

  ASSERT_EQ(filter.size(), 1u);
  ASSERT_EQ(filter.Get(0u), 6u);
}

TEST(ColumnStorageOverlay, FilterIntoSingleRowFalse) {
  ColumnStorageOverlay rm(100, 10000);
  RowMap filter(6, 7);
  rm.FilterInto(&filter, [](uint32_t row) {
    EXPECT_EQ(row, 106u);
    return row != 106u;
  });

  ASSERT_EQ(filter.size(), 0u);
}

TEST(ColumnStorageOverlay, FilterIntoRangeWithRange) {
  ColumnStorageOverlay rm(93, 157);
  RowMap filter(4, 7);
  rm.FilterInto(&filter, [](uint32_t row) { return row == 97u || row == 98u; });

  ASSERT_EQ(filter.size(), 2u);
  ASSERT_EQ(filter.Get(0u), 4u);
  ASSERT_EQ(filter.Get(1u), 5u);
}

TEST(ColumnStorageOverlay, FilterIntoOffsetRangeWithRange) {
  ColumnStorageOverlay rm(100000, 100010);
  RowMap filter(4, 7);
  rm.FilterInto(&filter, [](uint32_t row) { return row == 100004u; });

  ASSERT_EQ(filter.size(), 1u);
  ASSERT_EQ(filter.Get(0u), 4u);
}

TEST(ColumnStorageOverlay, FilterIntoLargeRangeWithRange) {
  ColumnStorageOverlay rm(0, 100000);
  RowMap filter(0, 100000);
  rm.FilterInto(&filter, [](uint32_t row) { return row % 2 == 0; });

  ASSERT_EQ(filter.size(), 100000u / 2);
  for (uint32_t i = 0; i < 100000 / 2; ++i) {
    ASSERT_EQ(filter.Get(i), i * 2);
  }
}

TEST(ColumnStorageOverlay, FilterIntoBitVectorWithRange) {
  ColumnStorageOverlay rm(
      BitVector{true, false, false, true, false, true, false, true, true});
  RowMap filter(1u, 5u);
  rm.FilterInto(&filter, [](uint32_t row) { return row == 3u || row == 7u; });

  ASSERT_EQ(filter.size(), 2u);
  ASSERT_EQ(filter.Get(0u), 1u);
  ASSERT_EQ(filter.Get(1u), 3u);
}

TEST(ColumnStorageOverlay, FilterIntoIndexVectorWithRange) {
  ColumnStorageOverlay rm(std::vector<uint32_t>{33, 2u, 45u, 7u, 8u, 9u});
  RowMap filter(2, 5);
  rm.FilterInto(&filter, [](uint32_t row) { return row == 45u || row == 8u; });

  ASSERT_EQ(filter.size(), 2u);
  ASSERT_EQ(filter.Get(0u), 2u);
  ASSERT_EQ(filter.Get(1u), 4u);
}

TEST(ColumnStorageOverlay, FilterIntoRangeWithBitVector) {
  ColumnStorageOverlay rm(27, 31);
  RowMap filter(BitVector{true, false, true, true});
  rm.FilterInto(&filter, [](uint32_t row) { return row == 29u || row == 30u; });

  ASSERT_EQ(filter.size(), 2u);
  ASSERT_EQ(filter.Get(0u), 2u);
  ASSERT_EQ(filter.Get(1u), 3u);
}

TEST(ColumnStorageOverlay, FilterIntoBitVectorWithBitVector) {
  ColumnStorageOverlay rm(BitVector{true, false, true, true, false, true});
  RowMap filter(BitVector{true, true, false, true});
  rm.FilterInto(&filter, [](uint32_t row) { return row == 2u || row == 5u; });

  ASSERT_EQ(filter.size(), 2u);
  ASSERT_EQ(filter.Get(0u), 1u);
  ASSERT_EQ(filter.Get(1u), 3u);
}

TEST(ColumnStorageOverlay, FilterIntoIndexVectorWithBitVector) {
  ColumnStorageOverlay rm(std::vector<uint32_t>{0u, 2u, 3u, 5u});
  RowMap filter(BitVector{true, true, false, true});
  rm.FilterInto(&filter, [](uint32_t row) { return row == 2u || row == 5u; });

  ASSERT_EQ(filter.size(), 2u);
  ASSERT_EQ(filter.Get(0u), 1u);
  ASSERT_EQ(filter.Get(1u), 3u);
}

TEST(ColumnStorageOverlay, FilterIntoRangeWithIndexVector) {
  ColumnStorageOverlay rm(27, 41);
  RowMap filter(std::vector<uint32_t>{3u, 5u, 9u, 10u, 12u});
  rm.FilterInto(&filter, [](uint32_t row) { return row == 32u || row == 39u; });

  ASSERT_EQ(filter.size(), 2u);
  ASSERT_EQ(filter.Get(0u), 5u);
  ASSERT_EQ(filter.Get(1u), 12u);
}

TEST(ColumnStorageOverlay, FilterIntoBitVectorWithIndexVector) {
  ColumnStorageOverlay rm(
      BitVector{false, true, false, true, true, false, true});
  RowMap filter(std::vector<uint32_t>{1u, 2u, 3u});
  rm.FilterInto(&filter, [](uint32_t row) { return row == 3u || row == 4u; });

  ASSERT_EQ(filter.size(), 2u);
  ASSERT_EQ(filter.Get(0u), 1u);
  ASSERT_EQ(filter.Get(1u), 2u);
}

TEST(ColumnStorageOverlay, FilterIntoIndexVectorWithIndexVector) {
  ColumnStorageOverlay rm(std::vector<uint32_t>{33u, 2u, 45u, 7u, 8u, 9u});
  RowMap filter(std::vector<uint32_t>{1u, 2u, 3u});
  rm.FilterInto(&filter, [](uint32_t row) { return row == 2u || row == 7u; });

  ASSERT_EQ(filter.size(), 2u);
  ASSERT_EQ(filter.Get(0u), 1u);
  ASSERT_EQ(filter.Get(1u), 3u);
}

}  // namespace
}  // namespace trace_processor
}  // namespace perfetto