// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.
// This file is copied from
// https://github.com/ClickHouse/ClickHouse/blob/master/src/Common/tests/gtest_pod_array.cpp
// and modified by Doris

#include "vec/common/pod_array.h"

#include <gtest/gtest.h>

#include "runtime/primitive_type.h"
#include "vec/common/allocator_fwd.h"
#include "vec/core/field.h"

namespace doris {

TEST(PODArrayTest, PODArrayBasicMove) {
    static constexpr size_t initial_bytes = 32;
    using Array = vectorized::PODArray<
            uint64_t, initial_bytes,
            AllocatorWithStackMemory<Allocator<false, false, false, DefaultMemoryAllocator, false>,
                                     initial_bytes>>;

    {
        Array arr;
        Array arr2;
        arr2 = std::move(arr);
    }

    {
        Array arr;

        arr.push_back(1);
        arr.push_back(2);
        arr.push_back(3);

        Array arr2;

        arr2 = std::move(arr);

        ASSERT_EQ(arr2.size(), 3);
        ASSERT_EQ(arr2[0], 1);
        ASSERT_EQ(arr2[1], 2);
        ASSERT_EQ(arr2[2], 3);

        arr = std::move(arr2);

        ASSERT_EQ(arr.size(), 3);
        ASSERT_EQ(arr[0], 1);
        ASSERT_EQ(arr[1], 2);
        ASSERT_EQ(arr[2], 3);
    }

    {
        Array arr;

        arr.push_back(1);
        arr.push_back(2);
        arr.push_back(3);
        arr.push_back(4);
        arr.push_back(5);

        Array arr2;

        arr2 = std::move(arr);

        ASSERT_EQ(arr2.size(), 5);
        ASSERT_EQ(arr2[0], 1);
        ASSERT_EQ(arr2[1], 2);
        ASSERT_EQ(arr2[2], 3);
        ASSERT_EQ(arr2[3], 4);
        ASSERT_EQ(arr2[4], 5);

        arr = std::move(arr2);

        ASSERT_EQ(arr.size(), 5);
        ASSERT_EQ(arr[0], 1);
        ASSERT_EQ(arr[1], 2);
        ASSERT_EQ(arr[2], 3);
        ASSERT_EQ(arr[3], 4);
        ASSERT_EQ(arr[4], 5);
    }

    {
        Array arr;

        arr.push_back(1);
        arr.push_back(2);
        arr.push_back(3);

        Array arr2;

        arr2.push_back(4);
        arr2.push_back(5);
        arr2.push_back(6);
        arr2.push_back(7);

        arr2 = std::move(arr);

        ASSERT_EQ(arr2.size(), 3);
        ASSERT_EQ(arr2[0], 1);
        ASSERT_EQ(arr2[1], 2);
        ASSERT_EQ(arr2[2], 3);
    }

    {
        Array arr;

        arr.push_back(1);
        arr.push_back(2);
        arr.push_back(3);

        Array arr2;

        arr2.push_back(4);
        arr2.push_back(5);
        arr2.push_back(6);
        arr2.push_back(7);
        arr2.push_back(8);

        arr = std::move(arr2);

        ASSERT_EQ(arr.size(), 5);
        ASSERT_EQ(arr[0], 4);
        ASSERT_EQ(arr[1], 5);
        ASSERT_EQ(arr[2], 6);
        ASSERT_EQ(arr[3], 7);
        ASSERT_EQ(arr[4], 8);
    }
}

TEST(PODArrayTest, PODArrayBasicSwap) {
    static constexpr size_t initial_bytes = 32;
    using Array = vectorized::PODArray<
            uint64_t, initial_bytes,
            AllocatorWithStackMemory<Allocator<false, false, false, DefaultMemoryAllocator, false>,
                                     initial_bytes>>;

    {
        Array arr;
        Array arr2;
        arr.swap(arr2);
        arr2.swap(arr);
    }

    {
        Array arr;

        Array arr2;

        arr2.push_back(1);
        arr2.push_back(2);
        arr2.push_back(3);

        arr.swap(arr2);

        ASSERT_TRUE(arr.size() == 3);
        ASSERT_TRUE(arr[0] == 1);
        ASSERT_TRUE(arr[1] == 2);
        ASSERT_TRUE(arr[2] == 3);

        ASSERT_TRUE(arr2.empty());

        arr.swap(arr2);

        ASSERT_TRUE(arr.empty());

        ASSERT_TRUE(arr2.size() == 3);
        ASSERT_TRUE(arr2[0] == 1);
        ASSERT_TRUE(arr2[1] == 2);
        ASSERT_TRUE(arr2[2] == 3);
    }

    {
        Array arr;

        Array arr2;

        arr2.push_back(1);
        arr2.push_back(2);
        arr2.push_back(3);
        arr2.push_back(4);
        arr2.push_back(5);

        arr.swap(arr2);

        ASSERT_TRUE(arr.size() == 5);
        ASSERT_TRUE(arr[0] == 1);
        ASSERT_TRUE(arr[1] == 2);
        ASSERT_TRUE(arr[2] == 3);
        ASSERT_TRUE(arr[3] == 4);
        ASSERT_TRUE(arr[4] == 5);

        ASSERT_TRUE(arr2.empty());

        arr.swap(arr2);

        ASSERT_TRUE(arr.empty());

        ASSERT_TRUE(arr2.size() == 5);
        ASSERT_TRUE(arr2[0] == 1);
        ASSERT_TRUE(arr2[1] == 2);
        ASSERT_TRUE(arr2[2] == 3);
        ASSERT_TRUE(arr2[3] == 4);
        ASSERT_TRUE(arr2[4] == 5);
    }

    {
        Array arr;

        arr.push_back(1);
        arr.push_back(2);
        arr.push_back(3);

        Array arr2;

        arr2.push_back(4);
        arr2.push_back(5);
        arr2.push_back(6);

        arr.swap(arr2);

        ASSERT_TRUE(arr.size() == 3);
        ASSERT_TRUE(arr[0] == 4);
        ASSERT_TRUE(arr[1] == 5);
        ASSERT_TRUE(arr[2] == 6);

        ASSERT_TRUE(arr2.size() == 3);
        ASSERT_TRUE(arr2[0] == 1);
        ASSERT_TRUE(arr2[1] == 2);
        ASSERT_TRUE(arr2[2] == 3);

        arr.swap(arr2);

        ASSERT_TRUE(arr.size() == 3);
        ASSERT_TRUE(arr[0] == 1);
        ASSERT_TRUE(arr[1] == 2);
        ASSERT_TRUE(arr[2] == 3);

        ASSERT_TRUE(arr2.size() == 3);
        ASSERT_TRUE(arr2[0] == 4);
        ASSERT_TRUE(arr2[1] == 5);
        ASSERT_TRUE(arr2[2] == 6);
    }

    {
        Array arr;

        arr.push_back(1);
        arr.push_back(2);

        Array arr2;

        arr2.push_back(3);
        arr2.push_back(4);
        arr2.push_back(5);

        arr.swap(arr2);

        ASSERT_TRUE(arr.size() == 3);
        ASSERT_TRUE(arr[0] == 3);
        ASSERT_TRUE(arr[1] == 4);
        ASSERT_TRUE(arr[2] == 5);

        ASSERT_TRUE(arr2.size() == 2);
        ASSERT_TRUE(arr2[0] == 1);
        ASSERT_TRUE(arr2[1] == 2);

        arr.swap(arr2);

        ASSERT_TRUE(arr.size() == 2);
        ASSERT_TRUE(arr[0] == 1);
        ASSERT_TRUE(arr[1] == 2);

        ASSERT_TRUE(arr2.size() == 3);
        ASSERT_TRUE(arr2[0] == 3);
        ASSERT_TRUE(arr2[1] == 4);
        ASSERT_TRUE(arr2[2] == 5);
    }

    {
        Array arr;

        arr.push_back(1);
        arr.push_back(2);
        arr.push_back(3);

        Array arr2;

        arr2.push_back(4);
        arr2.push_back(5);
        arr2.push_back(6);
        arr2.push_back(7);
        arr2.push_back(8);

        arr.swap(arr2);

        ASSERT_TRUE(arr.size() == 5);
        ASSERT_TRUE(arr[0] == 4);
        ASSERT_TRUE(arr[1] == 5);
        ASSERT_TRUE(arr[2] == 6);
        ASSERT_TRUE(arr[3] == 7);
        ASSERT_TRUE(arr[4] == 8);

        ASSERT_TRUE(arr2.size() == 3);
        ASSERT_TRUE(arr2[0] == 1);
        ASSERT_TRUE(arr2[1] == 2);
        ASSERT_TRUE(arr2[2] == 3);

        arr.swap(arr2);

        ASSERT_TRUE(arr.size() == 3);
        ASSERT_TRUE(arr[0] == 1);
        ASSERT_TRUE(arr[1] == 2);
        ASSERT_TRUE(arr[2] == 3);

        ASSERT_TRUE(arr2.size() == 5);
        ASSERT_TRUE(arr2[0] == 4);
        ASSERT_TRUE(arr2[1] == 5);
        ASSERT_TRUE(arr2[2] == 6);
        ASSERT_TRUE(arr2[3] == 7);
        ASSERT_TRUE(arr2[4] == 8);
    }

    {
        Array arr;

        arr.push_back(1);
        arr.push_back(2);
        arr.push_back(3);
        arr.push_back(4);
        arr.push_back(5);

        Array arr2;

        arr2.push_back(6);
        arr2.push_back(7);
        arr2.push_back(8);
        arr2.push_back(9);
        arr2.push_back(10);

        arr.swap(arr2);

        ASSERT_TRUE(arr.size() == 5);
        ASSERT_TRUE(arr[0] == 6);
        ASSERT_TRUE(arr[1] == 7);
        ASSERT_TRUE(arr[2] == 8);
        ASSERT_TRUE(arr[3] == 9);
        ASSERT_TRUE(arr[4] == 10);

        ASSERT_TRUE(arr2.size() == 5);
        ASSERT_TRUE(arr2[0] == 1);
        ASSERT_TRUE(arr2[1] == 2);
        ASSERT_TRUE(arr2[2] == 3);
        ASSERT_TRUE(arr2[3] == 4);
        ASSERT_TRUE(arr2[4] == 5);

        arr.swap(arr2);

        ASSERT_TRUE(arr.size() == 5);
        ASSERT_TRUE(arr[0] == 1);
        ASSERT_TRUE(arr[1] == 2);
        ASSERT_TRUE(arr[2] == 3);
        ASSERT_TRUE(arr[3] == 4);
        ASSERT_TRUE(arr[4] == 5);

        ASSERT_TRUE(arr2.size() == 5);
        ASSERT_TRUE(arr2[0] == 6);
        ASSERT_TRUE(arr2[1] == 7);
        ASSERT_TRUE(arr2[2] == 8);
        ASSERT_TRUE(arr2[3] == 9);
        ASSERT_TRUE(arr2[4] == 10);
    }
}

TEST(PODArrayTest, PODArrayBasicSwapMoveConstructor) {
    static constexpr size_t initial_bytes = 32;
    using Array = vectorized::PODArray<
            uint64_t, initial_bytes,
            AllocatorWithStackMemory<Allocator<false, false, false, DefaultMemoryAllocator, false>,
                                     initial_bytes>>;

    {
        Array arr;
        Array arr2 {std::move(arr)};
    }

    {
        Array arr;

        arr.push_back(1);
        arr.push_back(2);
        arr.push_back(3);

        Array arr2 {std::move(arr)};

        ASSERT_TRUE(arr.empty()); // NOLINT

        ASSERT_TRUE(arr2.size() == 3);
        ASSERT_TRUE(arr2[0] == 1);
        ASSERT_TRUE(arr2[1] == 2);
        ASSERT_TRUE(arr2[2] == 3);
    }

    {
        Array arr;

        arr.push_back(1);
        arr.push_back(2);
        arr.push_back(3);
        arr.push_back(4);
        arr.push_back(5);

        Array arr2 {std::move(arr)};

        ASSERT_TRUE(arr.empty()); // NOLINT

        ASSERT_TRUE(arr2.size() == 5);
        ASSERT_TRUE(arr2[0] == 1);
        ASSERT_TRUE(arr2[1] == 2);
        ASSERT_TRUE(arr2[2] == 3);
        ASSERT_TRUE(arr2[3] == 4);
        ASSERT_TRUE(arr2[4] == 5);
    }
}

TEST(PODArrayTest, PODArrayInsert) {
    {
        std::string str = "test_string_abacaba";
        vectorized::PODArray<char> chars;
        chars.insert(chars.end(), str.begin(), str.end());
        EXPECT_EQ(str, std::string(chars.data(), chars.size()));

        std::string insert_in_the_middle = "insert_in_the_middle";
        auto pos = str.size() / 2;
        str.insert(str.begin() + pos, insert_in_the_middle.begin(), insert_in_the_middle.end());
        chars.insert(chars.begin() + pos, insert_in_the_middle.begin(), insert_in_the_middle.end());
        EXPECT_EQ(str, std::string(chars.data(), chars.size()));

        std::string insert_with_resize;
        insert_with_resize.reserve(chars.capacity() * 2);
        char cur_char = 'a';
        while (insert_with_resize.size() < insert_with_resize.capacity()) {
            insert_with_resize += cur_char;
            if (cur_char == 'z') {
                cur_char = 'a';
            } else {
                ++cur_char;
            }
        }
        str.insert(str.begin(), insert_with_resize.begin(), insert_with_resize.end());
        chars.insert(chars.begin(), insert_with_resize.begin(), insert_with_resize.end());
        EXPECT_EQ(str, std::string(chars.data(), chars.size()));
    }
    {
        vectorized::PODArray<uint64_t> values;
        vectorized::PODArray<uint64_t> values_to_insert;

        for (size_t i = 0; i < 120; ++i) {
            values.emplace_back(i);
        }

        values.insert(values.begin() + 1, values_to_insert.begin(), values_to_insert.end());
        ASSERT_EQ(values.size(), 120);

        values_to_insert.emplace_back(0);
        values_to_insert.emplace_back(1);

        values.insert(values.begin() + 1, values_to_insert.begin(), values_to_insert.end());
        ASSERT_EQ(values.size(), 122);

        values_to_insert.clear();
        for (size_t i = 0; i < 240; ++i) {
            values_to_insert.emplace_back(i);
        }

        values.insert(values.begin() + 1, values_to_insert.begin(), values_to_insert.end());
        ASSERT_EQ(values.size(), 362);
    }
}

// TEST(PODArrayTest, PODArrayInsertFromItself)
// {
//     {
//         vectorized::PaddedPODArray<UInt64> array { 1 };

//         for (size_t i = 0; i < 3; ++i)
//             array.insertFromItself(array.begin(), array.end());

//         vectorized::PaddedPODArray<UInt64> expected {1,1,1,1,1,1,1,1};
//         ASSERT_EQ(array,expected);
//     }
// }

TEST(PODArrayTest, PODArrayAssign) {
    {
        vectorized::PaddedPODArray<uint64_t> array;
        array.push_back(1);
        array.push_back(2);

        array.assign({1, 2, 3});

        ASSERT_EQ(array.size(), 3);
        ASSERT_EQ(array, vectorized::PaddedPODArray<uint64_t>({1, 2, 3}));
    }
    {
        vectorized::PaddedPODArray<uint64_t> array;
        array.push_back(1);
        array.push_back(2);

        array.assign({});

        ASSERT_TRUE(array.empty());
    }
    {
        vectorized::PaddedPODArray<uint64_t> array;
        array.assign({});

        ASSERT_TRUE(array.empty());
    }
}

TEST(PODArrayTest, PODNoOverallocation) {
    /// Check that PaddedPODArray allocates for smaller number of elements than the power of two due to padding.
    /// NOTE: It's Ok to change these numbers if you will modify initial size or padding.

    vectorized::PaddedPODArray<char> chars;
    std::vector<size_t> capacities;

    size_t prev_capacity = 0;
    for (size_t i = 0; i < 1000000; ++i) {
        chars.emplace_back();
        if (chars.capacity() != prev_capacity) {
            prev_capacity = chars.capacity();
            capacities.emplace_back(prev_capacity);
        }
    }

    EXPECT_EQ(capacities, (std::vector<size_t> {4064, 8160, 16352, 32736, 65504, 131040, 262112,
                                                524256, 1048544}));
}

template <size_t size>
struct ItemWithSize {
    char v[size] {};
};

TEST(PODArrayTest, PODInsertElementSizeNotMultipleOfLeftPadding) {
    using ItemWith24Size = ItemWithSize<24>;
    vectorized::PaddedPODArray<ItemWith24Size> arr1_initially_empty;

    size_t items_to_insert_size = 120000;

    for (size_t test = 0; test < items_to_insert_size; ++test) {
        arr1_initially_empty.emplace_back();
    }

    EXPECT_EQ(arr1_initially_empty.size(), items_to_insert_size);

    vectorized::PaddedPODArray<ItemWith24Size> arr2_initially_nonempty;

    for (size_t test = 0; test < items_to_insert_size; ++test) {
        arr2_initially_nonempty.emplace_back();
    }

    EXPECT_EQ(arr1_initially_empty.size(), items_to_insert_size);
}

TEST(PODArrayTest, PODErase) {
    {
        vectorized::PaddedPODArray<uint64_t> items {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        vectorized::PaddedPODArray<uint64_t> expected;
        expected = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

        items.erase(items.begin(), items.begin());
        EXPECT_EQ(items, expected);

        items.erase(items.end(), items.end());
        EXPECT_EQ(items, expected);
    }
    {
        vectorized::PaddedPODArray<uint64_t> actual {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        vectorized::PaddedPODArray<uint64_t> expected;

        expected = {0, 1, 4, 5, 6, 7, 8, 9};
        actual.erase(actual.begin() + 2, actual.begin() + 4);
        EXPECT_EQ(actual, expected);

        expected = {0, 1, 4};
        actual.erase(actual.begin() + 3, actual.end());
        EXPECT_EQ(actual, expected);

        expected = {};
        actual.erase(actual.begin(), actual.end());
        EXPECT_EQ(actual, expected);

        for (size_t i = 0; i < 10; ++i) {
            actual.emplace_back(static_cast<uint64_t>(i));
        }

        expected = {0, 1, 4, 5, 6, 7, 8, 9};
        actual.erase(actual.begin() + 2, actual.begin() + 4);
        EXPECT_EQ(actual, expected);

        expected = {0, 1, 4};
        actual.erase(actual.begin() + 3, actual.end());
        EXPECT_EQ(actual, expected);

        expected = {};
        actual.erase(actual.begin(), actual.end());
        EXPECT_EQ(actual, expected);
    }
    {
        vectorized::PaddedPODArray<uint64_t> actual {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        vectorized::PaddedPODArray<uint64_t> expected;

        expected = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        actual.erase(actual.begin());
        EXPECT_EQ(actual, expected);
    }
}

TEST(PODArrayTest, PaddedPODArrayTrackingMemory) {
    auto t = MemTrackerLimiter::create_shared(MemTrackerLimiter::Type::GLOBAL, "UT");
    //  PaddedPODArray
    {
        SCOPED_SWITCH_THREAD_MEM_TRACKER_LIMITER(t);
        EXPECT_EQ(t->consumption(), 0);
        size_t PRE_GROWTH_SIZE = vectorized::TrackingGrowthMinSize;

        vectorized::PaddedPODArray<uint64_t, 4096> array;
        EXPECT_EQ(t->consumption(), 0);
        int64_t mem_consumption = t->consumption();
        size_t c_res_mem = 0;

        auto tracking_size = [&array, &c_res_mem](size_t c_end_new) {
            return (((c_end_new - c_res_mem) >> 16) << 16) + (array.allocated_bytes() >> 3);
        };

        auto check_memory_growth = [&t, &mem_consumption, &c_res_mem](size_t mem_growth) {
            EXPECT_EQ(t->consumption(), mem_consumption + mem_growth)
                    << ", current: " << mem_consumption << ", c_res_mem: " << c_res_mem
                    << ", mem_growth: " << mem_growth << ", expected: " << t->consumption() << ", "
                    << get_stack_trace();
            std::cout << "PODArrayTest check_memory, current: " << mem_consumption
                      << ", c_res_mem: " << c_res_mem << ", mem_growth: " << mem_growth
                      << ", expected: " << t->consumption() << std::endl;
            mem_consumption += mem_growth;
            c_res_mem += mem_growth;
        };

        array.push_back(1);
        EXPECT_EQ(array.size(), 1);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        // c_end_new: 8, c_res_mem: 0, c_end_of_storage: 4064, res_mem_growth: 4064
        check_memory_growth(array.allocated_bytes());

        array.push_back(2);
        EXPECT_EQ(array.size(), 2);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);

        array.resize_fill(PRE_GROWTH_SIZE / sizeof(uint64_t));
        EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t));
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        // c_end_new: 262144, c_res_mem: 4064, c_end_of_storage: 524256, res_mem_growth: 262144
        check_memory_growth(tracking_size(PRE_GROWTH_SIZE));

        array.push_back(3);
        EXPECT_EQ(array.size(), (PRE_GROWTH_SIZE / sizeof(uint64_t)) + 1);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);

        array.assign({1, 2, 3});
        EXPECT_EQ(array.size(), 3);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);

        array.resize((PRE_GROWTH_SIZE / sizeof(uint64_t)) * 3);
        EXPECT_EQ(array.size(), (PRE_GROWTH_SIZE / sizeof(uint64_t)) * 3);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        //  c_end_new: 786432, c_res_mem: 266208, c_end_of_storage: 1048544, res_mem_growth: 589824
        check_memory_growth(tracking_size(PRE_GROWTH_SIZE * 3));

        array.push_back_without_reserve(11);
        EXPECT_EQ(array.size(), (PRE_GROWTH_SIZE / sizeof(uint64_t)) * 3 + 1);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);

        array.resize_fill(PRE_GROWTH_SIZE / sizeof(uint64_t) * 6, 2);
        EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 6);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        // c_end_new: 1572864, c_res_mem: 856032, c_end_of_storage: 2097120, res_mem_growth: 917504
        check_memory_growth(tracking_size(PRE_GROWTH_SIZE * 6));

        array.push_back_without_reserve(22);
        EXPECT_EQ(array.size(), (PRE_GROWTH_SIZE / sizeof(uint64_t)) * 6 + 1);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);

        array.emplace_back(33);
        EXPECT_EQ(array.size(), (PRE_GROWTH_SIZE / sizeof(uint64_t)) * 6 + 2);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);

        array.pop_back();
        EXPECT_EQ(array.size(), (PRE_GROWTH_SIZE / sizeof(uint64_t)) * 6 + 1);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);

        for (int i = 0; i < (PRE_GROWTH_SIZE / sizeof(uint64_t)) * 2; i++) {
            array.push_back(2);
            array.pop_back();
            array.pop_back();
        }
        EXPECT_EQ(array.size(), (PRE_GROWTH_SIZE / sizeof(uint64_t)) * 4 + 1);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);

        array.resize_fill(PRE_GROWTH_SIZE / sizeof(uint64_t) * 7, 3);
        EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 7);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        // c_end_new: 1835008, c_res_mem: 1773536, c_end_of_storage: 2097120, res_mem_growth: 262144,
        check_memory_growth(tracking_size(PRE_GROWTH_SIZE * 7));

        {
            vectorized::PaddedPODArray<uint64_t, 32> array2;
            array2.push_back(3);
            doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
            // c_end_new: 8, c_res_mem: 0, c_end_of_storage: 8, res_mem_growth: 8
            EXPECT_EQ(t->consumption(),
                      mem_consumption + array2.allocated_bytes()); // 40 = array2.allocated_bytes()
            array2.resize_fill(PRE_GROWTH_SIZE / sizeof(uint64_t), 3);
            doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
            // c_end_new: 262144, c_res_mem: 8, c_end_of_storage: 524256, res_mem_growth: 262144
            EXPECT_EQ(t->consumption(),
                      mem_consumption + 40 +
                              PRE_GROWTH_SIZE); // 40 + PRE_GROWTH_SIZE = array2.c_res_mem
            array.insert(array2.begin(), array2.end());
            doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
            // c_end_new: 2097152, c_res_mem: 2035680, c_end_of_storage: 4194272, res_mem_growth: 524288
            EXPECT_EQ(t->consumption(),
                      mem_consumption + tracking_size(PRE_GROWTH_SIZE * 8) + 40 + PRE_GROWTH_SIZE);
        }
        EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 8);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(tracking_size(PRE_GROWTH_SIZE * 8)); // release array2

        {
            vectorized::PaddedPODArray<uint64_t, 32> array2;
            array2.resize_fill((PRE_GROWTH_SIZE / sizeof(uint64_t)) * 7, 3);
            // c_end_new: 1835008, c_res_mem: 0, c_end_of_storage: 2097120, res_mem_growth: 2097120
            array.insert_small_allow_read_write_overflow15(array2.begin(), array2.end());
            // c_end_new: 3932160, c_res_mem: 2559968, c_end_of_storage: 4194272, res_mem_growth: 1634304
        }
        EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 15);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(
                array.allocated_bytes() -
                mem_consumption); // array.capacity > tracking_size(PRE_GROWTH_SIZE * 15)

        {
            vectorized::PaddedPODArray<uint64_t, 32> array2;
            array2.push_back(3);
            array.insert(array2.begin(), array2.end());
        }
        EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 15 + 1);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);

        array.resize_fill(PRE_GROWTH_SIZE / sizeof(uint64_t) * 16, 4);
        EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 16);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        // c_end_new: 4194304, c_res_mem: 4194272, c_end_of_storage: 8388576, res_mem_growth: 1048576
        check_memory_growth(tracking_size(PRE_GROWTH_SIZE * 16));

        {
            vectorized::PaddedPODArray<uint64_t, 32> array2;
            array2.resize_fill(PRE_GROWTH_SIZE / sizeof(uint64_t), 3);
            array.insert(array.begin(), array2.begin(), array2.end());
        }
        EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 17);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);

        {
            vectorized::PaddedPODArray<uint64_t, 32> array2;
            array2.resize_fill((PRE_GROWTH_SIZE / sizeof(uint64_t) * 2), 3);
            array.insert_assume_reserved(array2.begin(), array2.end());
            array.insert_assume_reserved_and_allow_overflow(array2.begin(), array2.end());
        }
        EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 21);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(tracking_size(PRE_GROWTH_SIZE * 21));

        size_t n = 100;
        array.assign(n, (uint64_t)0);
        EXPECT_EQ(array.size(), 100);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);

        array.erase(array.begin() + 10, array.end());
        EXPECT_EQ(array.size(), 10);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        check_memory_growth(0);
    }
    EXPECT_EQ(t->consumption(), 0);
}

TEST(PODArrayTest, PODArrayTrackingMemory) {
    auto t = MemTrackerLimiter::create_shared(MemTrackerLimiter::Type::GLOBAL, "UT");

    // PODArray with AllocatorWithStackMemory
    {
        SCOPED_SWITCH_THREAD_MEM_TRACKER_LIMITER(t);
        EXPECT_EQ(t->consumption(), 0);
        size_t PRE_GROWTH_SIZE = vectorized::TrackingGrowthMinSize;

        static constexpr size_t initial_bytes = 32;
        using Array =
                vectorized::PODArray<uint64_t, initial_bytes,
                                     AllocatorWithStackMemory<Allocator<
                                             false, false, false, DefaultMemoryAllocator, false>>>;
        Array array;

        array.push_back(1);
        EXPECT_EQ(array.size(), 1);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        // reset_resident_memory, c_end_new: 8, c_res_mem: 0, c_end_of_storage: 32, res_mem_growth: 32
        EXPECT_EQ(t->consumption(), array.allocated_bytes());

        array.resize_fill(PRE_GROWTH_SIZE / sizeof(uint64_t), 1);
        EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t));
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        // reset_resident_memory, c_end_new: 262144, c_res_mem: 32, c_end_of_storage: 262144, res_mem_growth: 262112
        EXPECT_EQ(t->consumption(), PRE_GROWTH_SIZE);

        // test swap
        size_t new_capacity = 0;
        size_t new_size = 0;
        {
            Array array2;
            array2.resize_fill(PRE_GROWTH_SIZE / sizeof(uint64_t) * 2, 1);
            EXPECT_EQ(array2.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 2);
            doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
            // reset_resident_memory, c_end_new: 524288, c_res_mem: 0, c_end_of_storage: 524288, res_mem_growth: 524288
            EXPECT_EQ(t->consumption(), PRE_GROWTH_SIZE * 3);
            new_capacity = array2.capacity();
            new_size = array2.size();

            array.swap(array2);
            EXPECT_EQ(array2.size(), PRE_GROWTH_SIZE / sizeof(uint64_t));
            EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 2);
            doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
            EXPECT_EQ(t->consumption(), PRE_GROWTH_SIZE * 3);
            EXPECT_EQ(array.capacity(), new_capacity);
            EXPECT_EQ(array.size(), new_size);
        }
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        EXPECT_EQ(t->consumption(), PRE_GROWTH_SIZE * 2);
    }
    EXPECT_EQ(t->consumption(), 0);

    // PODArray with Allocator
    {
        SCOPED_SWITCH_THREAD_MEM_TRACKER_LIMITER(t);
        EXPECT_EQ(t->consumption(), 0);
        static constexpr size_t PRE_GROWTH_SIZE = (1ULL << 20); // 1M

        static constexpr size_t initial_bytes = 32;
        using Array =
                vectorized::PODArray<uint64_t, initial_bytes,
                                     Allocator<false, false, false, DefaultMemoryAllocator, false>>;
        Array array;

        array.push_back(1);
        EXPECT_EQ(array.size(), 1);
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        EXPECT_EQ(t->consumption(), array.allocated_bytes());

        array.resize_fill(PRE_GROWTH_SIZE / sizeof(uint64_t), 1);
        EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t));
        doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
        EXPECT_EQ(t->consumption(), PRE_GROWTH_SIZE);

        // test swap
        size_t new_capacity = 0;
        size_t new_size = 0;
        {
            Array array2;
            array2.resize_fill(PRE_GROWTH_SIZE / sizeof(uint64_t) * 2, 1);
            EXPECT_EQ(array2.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 2);
            doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
            EXPECT_EQ(t->consumption(), PRE_GROWTH_SIZE * 3);
            new_capacity = array2.capacity();
            new_size = array2.size();

            array.swap(array2);
            EXPECT_EQ(array2.size(), PRE_GROWTH_SIZE / sizeof(uint64_t));
            EXPECT_EQ(array.size(), PRE_GROWTH_SIZE / sizeof(uint64_t) * 2);
            doris::thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
            EXPECT_EQ(t->consumption(), PRE_GROWTH_SIZE * 3);
            EXPECT_EQ(array.capacity(), new_capacity);
            EXPECT_EQ(array.size(), new_size);
        }
        EXPECT_EQ(t->consumption(), PRE_GROWTH_SIZE * 2);
    }
    EXPECT_EQ(t->consumption(), 0);
}

} // end namespace doris