Function TestOneCase

catboost/libs/helpers/ut/array_subset_ut.cpp:57–148

    }

    void TestOneCase(
        const NCB::TArraySubset<TVector<int>>& arraySubset,
        const TVector<int>& expectedSubset
    ) {
        UNIT_ASSERT_EQUAL(arraySubset.Size(), expectedSubset.size());

        // ForEach
        {
            size_t expectedIndex = 0;
            arraySubset.ForEach([&](size_t index, int value) {
                UNIT_ASSERT_VALUES_EQUAL(expectedIndex, index);
                UNIT_ASSERT_VALUES_EQUAL(expectedSubset[index], value);
                ++expectedIndex;
            });
            UNIT_ASSERT_VALUES_EQUAL(expectedIndex, expectedSubset.size());
        }

        // ParallelForEach
        {
            NPar::TLocalExecutor localExecutor;
            localExecutor.RunAdditionalThreads(3);

            for (size_t approximateBlockSize : xrange(0, 12)) { // use 0 as undefined
                TVector<bool> indicesIterated(expectedSubset.size(), false);
                arraySubset.ParallelForEach(
                    [&](size_t index, int value) {
                        UNIT_ASSERT_VALUES_EQUAL(expectedSubset[index], value);

                        auto& indexIterated = indicesIterated.at(index);
                        UNIT_ASSERT(!indexIterated); // each index must be visited only once
                        indexIterated = true;
                    },
                    &localExecutor,
                    approximateBlockSize != 0 ? TMaybe<size_t>(approximateBlockSize) : Nothing()
                );
                UNIT_ASSERT(!IsIn(indicesIterated, false)); // each index was visited
            }
        }

        // external iteration
        {
            auto* src = arraySubset.GetSrc();
            const auto* subsetIndexing = arraySubset.GetSubsetIndexing();

            for (size_t approximateBlockSize : xrange(1, 12)) {
                const NCB::TSimpleIndexRangesGenerator<size_t> parallelUnitRanges =
                    subsetIndexing->GetParallelUnitRanges(approximateBlockSize);

                TVector<bool> indicesIterated(expectedSubset.size(), false);

                for (size_t unitRangeIdx : xrange(parallelUnitRanges.RangesCount())) {
                    auto unitRange = parallelUnitRanges.GetRange(unitRangeIdx);
                    auto elementRange = subsetIndexing->GetElementRangeFromUnitRange(unitRange);

                    size_t expectedIndex = elementRange.Begin;
                    subsetIndexing->ForEachInSubRange(
                        unitRange,
                        [&](size_t index, size_t srcIndex) {