Function TestMutable

catboost/libs/helpers/ut/array_subset_ut.cpp:157–203

    template <class F>
    void TestMutable(
        const TVector<int>& array,
        const NCB::TArraySubsetIndexing<size_t> arraySubsetIndexing,
        const TVector<int>& expectedModifiedSubset,
        F&& f
    ) {
        UNIT_ASSERT_EQUAL(arraySubsetIndexing.Size(), expectedModifiedSubset.size());

        for (auto iterationType : {
                EIterationType::ForEach,
                EIterationType::ParallelForEach,
                EIterationType::External
             })
        {
            TVector<int> arrayCopy = array;
            NCB::TArraySubset<TVector<int>> arraySubset{&arrayCopy, &arraySubsetIndexing};

            switch (iterationType) {
                case EIterationType::ForEach:
                    arraySubset.ForEach(f);
                    break;
                case EIterationType::ParallelForEach: {
                        NPar::TLocalExecutor localExecutor;
                        localExecutor.RunAdditionalThreads(3);

                        arraySubset.ParallelForEach(f, &localExecutor, 3);
                    }
                    break;
                case EIterationType::External: {
                    const auto* subsetIndexing = arraySubset.GetSubsetIndexing();

                    const NCB::TSimpleIndexRangesGenerator<size_t> parallelUnitRanges =
                        subsetIndexing->GetParallelUnitRanges(3);

                    for (size_t unitRangeIdx : xrange(parallelUnitRanges.RangesCount())) {
                        auto unitRange = parallelUnitRanges.GetRange(unitRangeIdx);
                        subsetIndexing->ForEachInSubRange(
                            unitRange,
                            [&](size_t index, size_t srcIndex) {
                                f(index, arrayCopy[srcIndex]);
                            }
                        );
                    }
                }
            }
        }
    }

    void TestGetSubset(
        const TVector<int>& v,