Purge qalgorithm.h of deprecated API

A large slice of it has been deprecated since 5.2.

Reflowed a doc paragraph pointed out, in the deprecation commit, as
having been left ragged by its edits.

Note: qSwap() is documented as \deprecated but not marked, where it's
defined, as deprecated.

Change-Id: Iaff10ac0c4c38e5b85f10eca4eedeab861f09959
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

10 files changed, 9 insertions, 1979 deletions

diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index cd568df213..642ea2b1f3 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -938,6 +938,7 @@ namespace SwapExceptionTester { // insulate users from the "using std::swap" bel
 }
 } // namespace QtPrivate
 
+// Documented in ../tools/qalgorithm.qdoc
 template <typename T>
 inline void qSwap(T &value1, T &value2)
     noexcept(noexcept(QtPrivate::SwapExceptionTester::checkSwap(value1)))
diff --git a/src/corelib/tools/qalgorithms.h b/src/corelib/tools/qalgorithms.h
index 1445de1008..6b55136bc3 100644
--- a/src/corelib/tools/qalgorithms.h
+++ b/src/corelib/tools/qalgorithms.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2020 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -47,271 +47,6 @@
 #endif
 
 QT_BEGIN_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-
-/*
-    Warning: The contents of QAlgorithmsPrivate is not a part of the public Qt API
-    and may be changed from version to version or even be completely removed.
-*/
-namespace QAlgorithmsPrivate {
-
-#if QT_DEPRECATED_SINCE(5, 2)
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::sort") Q_OUTOFLINE_TEMPLATE void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan);
-template <typename RandomAccessIterator, typename T>
-QT_DEPRECATED_X("Use std::sort") inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy);
-
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::stable_sort") Q_OUTOFLINE_TEMPLATE void qStableSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan);
-template <typename RandomAccessIterator, typename T>
-QT_DEPRECATED_X("Use std::stable_sort") inline void qStableSortHelper(RandomAccessIterator, RandomAccessIterator, const T &);
-
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::lower_bound") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::upper_bound") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::binary_search") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
-#endif // QT_DEPRECATED_SINCE(5, 2)
-
-}
-
-#if QT_DEPRECATED_SINCE(5, 2)
-template <typename InputIterator, typename OutputIterator>
-QT_DEPRECATED_X("Use std::copy") inline OutputIterator qCopy(InputIterator begin, InputIterator end, OutputIterator dest)
-{
-    while (begin != end)
-        *dest++ = *begin++;
-    return dest;
-}
-
-template <typename BiIterator1, typename BiIterator2>
-QT_DEPRECATED_X("Use std::copy_backward") inline BiIterator2 qCopyBackward(BiIterator1 begin, BiIterator1 end, BiIterator2 dest)
-{
-    while (begin != end)
-        *--dest = *--end;
-    return dest;
-}
-
-template <typename InputIterator1, typename InputIterator2>
-QT_DEPRECATED_X("Use std::equal") inline bool qEqual(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
-{
-    for (; first1 != last1; ++first1, ++first2)
-        if (!(*first1 == *first2))
-            return false;
-    return true;
-}
-
-template <typename ForwardIterator, typename T>
-QT_DEPRECATED_X("Use std::fill") inline void qFill(ForwardIterator first, ForwardIterator last, const T &val)
-{
-    for (; first != last; ++first)
-        *first = val;
-}
-
-template <typename Container, typename T>
-QT_DEPRECATED_X("Use std::fill") inline void qFill(Container &container, const T &val)
-{
-    qFill(container.begin(), container.end(), val);
-}
-
-template <typename InputIterator, typename T>
-QT_DEPRECATED_X("Use std::find") inline InputIterator qFind(InputIterator first, InputIterator last, const T &val)
-{
-    while (first != last && !(*first == val))
-        ++first;
-    return first;
-}
-
-template <typename Container, typename T>
-QT_DEPRECATED_X("Use std::find") inline typename Container::const_iterator qFind(const Container &container, const T &val)
-{
-    return qFind(container.constBegin(), container.constEnd(), val);
-}
-
-template <typename InputIterator, typename T, typename Size>
-QT_DEPRECATED_X("Use std::count") inline void qCount(InputIterator first, InputIterator last, const T &value, Size &n)
-{
-    for (; first != last; ++first)
-        if (*first == value)
-            ++n;
-}
-
-template <typename Container, typename T, typename Size>
-QT_DEPRECATED_X("Use std::count") inline void qCount(const Container &container, const T &value, Size &n)
-{
-    qCount(container.constBegin(), container.constEnd(), value, n);
-}
-
-#ifdef Q_QDOC
-typedef void* LessThan;
-template <typename T> LessThan qLess();
-template <typename T> LessThan qGreater();
-#else
-template <typename T>
-class QT_DEPRECATED_X("Use std::less") qLess
-{
-public:
-    inline bool operator()(const T &t1, const T &t2) const
-    {
-        return (t1 < t2);
-    }
-};
-
-template <typename T>
-class QT_DEPRECATED_X("Use std::greater") qGreater
-{
-public:
-    inline bool operator()(const T &t1, const T &t2) const
-    {
-        return (t2 < t1);
-    }
-};
-#endif
-
-template <typename RandomAccessIterator>
-QT_DEPRECATED_X("Use std::sort") inline void qSort(RandomAccessIterator start, RandomAccessIterator end)
-{
-    if (start != end)
-        QAlgorithmsPrivate::qSortHelper(start, end, *start);
-}
-
-template <typename RandomAccessIterator, typename LessThan>
-QT_DEPRECATED_X("Use std::sort") inline void qSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan)
-{
-    if (start != end)
-        QAlgorithmsPrivate::qSortHelper(start, end, *start, lessThan);
-}
-
-template<typename Container>
-QT_DEPRECATED_X("Use std::sort") inline void qSort(Container &c)
-{
-#ifdef Q_CC_BOR
-    // Work around Borland 5.5 optimizer bug
-    c.detach();
-#endif
-    if (!c.empty())
-        QAlgorithmsPrivate::qSortHelper(c.begin(), c.end(), *c.begin());
-}
-
-template <typename RandomAccessIterator>
-QT_DEPRECATED_X("Use std::stable_sort") inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end)
-{
-    if (start != end)
-        QAlgorithmsPrivate::qStableSortHelper(start, end, *start);
-}
-
-template <typename RandomAccessIterator, typename LessThan>
-QT_DEPRECATED_X("Use std::stable_sort") inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan)
-{
-    if (start != end)
-        QAlgorithmsPrivate::qStableSortHelper(start, end, *start, lessThan);
-}
-
-template<typename Container>
-QT_DEPRECATED_X("Use std::stable_sort") inline void qStableSort(Container &c)
-{
-#ifdef Q_CC_BOR
-    // Work around Borland 5.5 optimizer bug
-    c.detach();
-#endif
-    if (!c.empty())
-        QAlgorithmsPrivate::qStableSortHelper(c.begin(), c.end(), *c.begin());
-}
-
-template <typename RandomAccessIterator, typename T>
-QT_DEPRECATED_X("Use std::lower_bound") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
-{
-    // Implementation is duplicated from QAlgorithmsPrivate to keep existing code
-    // compiling. We have to allow using *begin and value with different types,
-    // and then implementing operator< for those types.
-    RandomAccessIterator middle;
-    int n = end - begin;
-    int half;
-
-    while (n > 0) {
-        half = n >> 1;
-        middle = begin + half;
-        if (*middle < value) {
-            begin = middle + 1;
-            n -= half + 1;
-        } else {
-            n = half;
-        }
-    }
-    return begin;
-}
-
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::lower_bound") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
-{
-    return QAlgorithmsPrivate::qLowerBoundHelper(begin, end, value, lessThan);
-}
-
-template <typename Container, typename T>
-QT_DEPRECATED_X("Use std::lower_bound") Q_OUTOFLINE_TEMPLATE typename Container::const_iterator qLowerBound(const Container &container, const T &value)
-{
-    return QAlgorithmsPrivate::qLowerBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
-}
-
-template <typename RandomAccessIterator, typename T>
-QT_DEPRECATED_X("Use std::upper_bound") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
-{
-    // Implementation is duplicated from QAlgorithmsPrivate.
-    RandomAccessIterator middle;
-    int n = end - begin;
-    int half;
-
-    while (n > 0) {
-        half = n >> 1;
-        middle = begin + half;
-        if (value < *middle) {
-            n = half;
-        } else {
-            begin = middle + 1;
-            n -= half + 1;
-        }
-    }
-    return begin;
-}
-
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::upper_bound") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
-{
-    return QAlgorithmsPrivate::qUpperBoundHelper(begin, end, value, lessThan);
-}
-
-template <typename Container, typename T>
-QT_DEPRECATED_X("Use std::upper_bound") Q_OUTOFLINE_TEMPLATE typename Container::const_iterator qUpperBound(const Container &container, const T &value)
-{
-    return QAlgorithmsPrivate::qUpperBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
-}
-
-template <typename RandomAccessIterator, typename T>
-QT_DEPRECATED_X("Use std::binary_search") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
-{
-    // Implementation is duplicated from QAlgorithmsPrivate.
-    RandomAccessIterator it = qLowerBound(begin, end, value);
-
-    if (it == end || value < *it)
-        return end;
-
-    return it;
-}
-
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::binary_search") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
-{
-    return QAlgorithmsPrivate::qBinaryFindHelper(begin, end, value, lessThan);
-}
-
-template <typename Container, typename T>
-QT_DEPRECATED_X("Use std::binary_search") Q_OUTOFLINE_TEMPLATE typename Container::const_iterator qBinaryFind(const Container &container, const T &value)
-{
-    return QAlgorithmsPrivate::qBinaryFindHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
-}
-#endif // QT_DEPRECATED_SINCE(5, 2)
 
 template <typename ForwardIterator>
 Q_OUTOFLINE_TEMPLATE void qDeleteAll(ForwardIterator begin, ForwardIterator end)
@@ -334,191 +69,6 @@ inline void qDeleteAll(const Container &c)
 */
 namespace QAlgorithmsPrivate {
 
-#if QT_DEPRECATED_SINCE(5, 2)
-
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::sort") Q_OUTOFLINE_TEMPLATE void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan)
-{
-top:
-    int span = int(end - start);
-    if (span < 2)
-        return;
-
-    --end;
-    RandomAccessIterator low = start, high = end - 1;
-    RandomAccessIterator pivot = start + span / 2;
-
-    if (lessThan(*end, *start))
-        qSwap(*end, *start);
-    if (span == 2)
-        return;
-
-    if (lessThan(*pivot, *start))
-        qSwap(*pivot, *start);
-    if (lessThan(*end, *pivot))
-        qSwap(*end, *pivot);
-    if (span == 3)
-        return;
-
-    qSwap(*pivot, *end);
-
-    while (low < high) {
-        while (low < high && lessThan(*low, *end))
-            ++low;
-
-        while (high > low && lessThan(*end, *high))
-            --high;
-
-        if (low < high) {
-            qSwap(*low, *high);
-            ++low;
-            --high;
-        } else {
-            break;
-        }
-    }
-
-    if (lessThan(*low, *end))
-        ++low;
-
-    qSwap(*end, *low);
-    qSortHelper(start, low, t, lessThan);
-
-    start = low + 1;
-    ++end;
-    goto top;
-}
-
-template <typename RandomAccessIterator, typename T>
-QT_DEPRECATED_X("Use std::sort") inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy)
-{
-    qSortHelper(begin, end, dummy, qLess<T>());
-}
-
-template <typename RandomAccessIterator>
-QT_DEPRECATED_X("Use std::reverse") Q_OUTOFLINE_TEMPLATE void qReverse(RandomAccessIterator begin, RandomAccessIterator end)
-{
-    --end;
-    while (begin < end)
-        qSwap(*begin++, *end--);
-}
-
-template <typename RandomAccessIterator>
-QT_DEPRECATED_X("Use std::rotate") Q_OUTOFLINE_TEMPLATE void qRotate(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end)
-{
-    qReverse(begin, middle);
-    qReverse(middle, end);
-    qReverse(begin, end);
-}
-
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::merge") Q_OUTOFLINE_TEMPLATE void qMerge(RandomAccessIterator begin, RandomAccessIterator pivot, RandomAccessIterator end, T &t, LessThan lessThan)
-{
-    const int len1 = pivot - begin;
-    const int len2 = end - pivot;
-
-    if (len1 == 0 || len2 == 0)
-        return;
-
-    if (len1 + len2 == 2) {
-        if (lessThan(*(begin + 1), *(begin)))
-            qSwap(*begin, *(begin + 1));
-        return;
-    }
-
-    RandomAccessIterator firstCut;
-    RandomAccessIterator secondCut;
-    int len2Half;
-    if (len1 > len2) {
-        const int len1Half = len1 / 2;
-        firstCut = begin + len1Half;
-        secondCut = qLowerBound(pivot, end, *firstCut, lessThan);
-        len2Half = secondCut - pivot;
-    } else {
-        len2Half = len2 / 2;
-        secondCut = pivot + len2Half;
-        firstCut = qUpperBound(begin, pivot, *secondCut, lessThan);
-    }
-
-    qRotate(firstCut, pivot, secondCut);
-    const RandomAccessIterator newPivot = firstCut + len2Half;
-    qMerge(begin, firstCut, newPivot, t, lessThan);
-    qMerge(newPivot, secondCut, end, t, lessThan);
-}
-
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::stable_sort") Q_OUTOFLINE_TEMPLATE void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &t, LessThan lessThan)
-{
-    const int span = end - begin;
-    if (span < 2)
-       return;
-
-    const RandomAccessIterator middle = begin + span / 2;
-    qStableSortHelper(begin, middle, t, lessThan);
-    qStableSortHelper(middle, end, t, lessThan);
-    qMerge(begin, middle, end, t, lessThan);
-}
-
-template <typename RandomAccessIterator, typename T>
-QT_DEPRECATED_X("Use std::stable_sort") inline void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy)
-{
-    qStableSortHelper(begin, end, dummy, qLess<T>());
-}
-
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::lower_bound") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
-{
-    RandomAccessIterator middle;
-    int n = int(end - begin);
-    int half;
-
-    while (n > 0) {
-        half = n >> 1;
-        middle = begin + half;
-        if (lessThan(*middle, value)) {
-            begin = middle + 1;
-            n -= half + 1;
-        } else {
-            n = half;
-        }
-    }
-    return begin;
-}
-
-
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::upper_bound") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
-{
-    RandomAccessIterator middle;
-    int n = end - begin;
-    int half;
-
-    while (n > 0) {
-        half = n >> 1;
-        middle = begin + half;
-        if (lessThan(value, *middle)) {
-            n = half;
-        } else {
-            begin = middle + 1;
-            n -= half + 1;
-        }
-    }
-    return begin;
-}
-
-template <typename RandomAccessIterator, typename T, typename LessThan>
-QT_DEPRECATED_X("Use std::binary_search") Q_OUTOFLINE_TEMPLATE RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
-{
-    RandomAccessIterator it = qLowerBoundHelper(begin, end, value, lessThan);
-
-    if (it == end || lessThan(value, *it))
-        return end;
-
-    return it;
-}
-
-#endif // QT_DEPRECATED_SINCE(5, 2)
-
 #ifdef Q_CC_CLANG
 // Clang had a bug where __builtin_ctz/clz/popcount were not marked as constexpr.
 #  if (defined __apple_build_version__ &&  __clang_major__ >= 7) || (Q_CC_CLANG >= 307)
@@ -896,7 +446,6 @@ QT_POPCOUNT_RELAXED_CONSTEXPR inline uint qCountLeadingZeroBits(unsigned long v)
     return qCountLeadingZeroBits(QIntegerForSizeof<long>::Unsigned(v));
 }
 
-QT_WARNING_POP
 QT_END_NAMESPACE
 
 #endif // QALGORITHMS_H
diff --git a/src/corelib/tools/qalgorithms.qdoc b/src/corelib/tools/qalgorithms.qdoc
index d480f2b487..f94a6856da 100644
--- a/src/corelib/tools/qalgorithms.qdoc
+++ b/src/corelib/tools/qalgorithms.qdoc
@@ -54,12 +54,11 @@
     \l {Output Iterators}{output iterator}), you will always get a
     compiler error, although not necessarily a very informative one.
 
-    Some algorithms have special requirements on the value type
-    stored in the containers. For example,
-    qDeleteAll() requires that the value type is a
-    non-const pointer type (for example, QWidget *). The value type
-    requirements are specified for each algorithm, and the compiler
-    will produce an error if a requirement isn't met.
+    Some algorithms have special requirements on the value type stored
+    in the containers. For example, qDeleteAll() requires that the
+    value type is a non-const pointer type (for example, QWidget
+    *). The value type requirements are specified for each algorithm,
+    and the compiler will produce an error if a requirement isn't met.
 
     The generic algorithms can be used on other container classes
     than those provided by Qt and STL. The syntax of STL-style
@@ -145,236 +144,9 @@
 
     QList's non-const iterator type is random access iterator.
 
-    \section1 Qt and the STL Algorithms
-
-    Historically, Qt used to provide functions which were direct equivalents of
-    many STL algorithmic functions. Starting with Qt 5.0, you are instead
-    encouraged to use directly the implementations available in the STL; most
-    of the Qt ones have been deprecated (although they are still available to
-    keep the old code compiling).
-
-    \section2 Porting guidelines
-
-    Most of the time, an application using the deprecated Qt algorithmic functions
-    can be easily ported to use the equivalent STL functions. You need to:
-
-    \list 1
-        \li add the \c{#include <algorithm>} preprocessor directive;
-        \li replace the Qt functions with the STL counterparts, according to the table below.
-    \endlist
-
-    \table
-    \header
-        \li Qt function
-        \li STL function
-    \row
-        \li qBinaryFind
-        \li \c std::binary_search or \c std::lower_bound
-    \row
-        \li qCopy
-        \li \c std::copy
-    \row
-        \li qCopyBackward
-        \li \c std::copy_backward
-    \row
-        \li qEqual
-        \li \c std::equal
-    \row
-        \li qFill
-        \li \c std::fill
-    \row
-        \li qFind
-        \li \c std::find
-    \row
-        \li qCount
-        \li \c std::count
-    \row
-        \li qSort
-        \li \c std::sort
-    \row
-        \li qStableSort
-        \li \c std::stable_sort
-    \row
-        \li qLowerBound
-        \li \c std::lower_bound
-    \row
-        \li qUpperBound
-        \li \c std::upper_bound
-    \row
-        \li qLess
-        \li \c std::less
-    \row
-        \li qGreater
-        \li \c std::greater
-
-    \endtable
-
-    The only cases in which the port may not be straightforward is if the old
-    code relied on template specializations of the qLess() and/or the qSwap()
-    functions, which were used internally by the implementations of the Qt
-    algorithmic functions, but are instead ignored by the STL ones.
-
-    In case the old code relied on the specialization of the qLess() functor,
-    then a workaround is explicitly passing an instance of the qLess() class
-    to the STL function, for instance like this:
-
-    \code
-        std::sort(container.begin(), container.end(), qLess<T>());
-    \endcode
-
-    Instead, since it's not possible to pass a custom swapper functor to STL
-    functions, the only workaround for a template specialization for qSwap() is
-    providing the same specialization for \c std::swap().
-
     \sa {container classes}, <QtGlobal>
 */
 
-/*! \fn template <typename InputIterator, typename OutputIterator> OutputIterator qCopy(InputIterator begin1, InputIterator end1, OutputIterator begin2)
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::copy instead.
-
-    Copies the items from range [\a begin1, \a end1) to range [\a
-    begin2, ...), in the order in which they appear.
-
-    The item at position \a begin1 is assigned to that at position \a
-    begin2; the item at position \a begin1 + 1 is assigned to that at
-    position \a begin2 + 1; and so on.
-
-    Example:
-    \snippet code/doc_src_qalgorithms.cpp 4
-
-    \sa qCopyBackward(), {input iterators}, {output iterators}
-*/
-
-/*! \fn template <typename BiIterator1, typename BiIterator2> BiIterator2 qCopyBackward(BiIterator1 begin1, BiIterator1 end1, BiIterator2 end2)
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::copy_backward instead.
-
-    Copies the items from range [\a begin1, \a end1) to range [...,
-    \a end2).
-
-    The item at position \a end1 - 1 is assigned to that at position
-    \a end2 - 1; the item at position \a end1 - 2 is assigned to that
-    at position \a end2 - 2; and so on.
-
-    Example:
-    \snippet code/doc_src_qalgorithms.cpp 5
-
-    \sa qCopy(), {bidirectional iterators}
-*/
-
-/*! \fn template <typename InputIterator1, typename InputIterator2> bool qEqual(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2)
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::equal instead.
-
-    Compares the items in the range [\a begin1, \a end1) with the
-    items in the range [\a begin2, ...). Returns \c true if all the
-    items compare equal; otherwise returns \c false.
-
-    Example:
-    \snippet code/doc_src_qalgorithms.cpp 6
-
-    This function requires the item type (in the example above,
-    QString) to implement \c operator==().
-
-    \sa {input iterators}
-*/
-
-/*! \fn template <typename ForwardIterator, typename T> void qFill(ForwardIterator begin, ForwardIterator end, const T &value)
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::fill instead.
-
-    Fills the range [\a begin, \a end) with \a value.
-
-    Example:
-    \snippet code/doc_src_qalgorithms.cpp 7
-
-    \sa qCopy(), {forward iterators}
-*/
-
-/*! \fn template <typename Container, typename T> void qFill(Container &container, const T &value)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::fill instead.
-
-    This is the same as qFill(\a{container}.begin(), \a{container}.end(), \a value);
-*/
-
-/*! \fn template <typename InputIterator, typename T> InputIterator qFind(InputIterator begin, InputIterator end, const T &value)
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::find instead.
-
-    Returns an iterator to the first occurrence of \a value in a
-    container in the range [\a begin, \a end). Returns \a end if \a
-    value isn't found.
-
-    Example:
-    \snippet code/doc_src_qalgorithms.cpp 8
-
-    This function requires the item type (in the example above,
-    QString) to implement \c operator==().
-
-    If the items in the range are in ascending order, you can get
-    faster results by using qLowerBound() or qBinaryFind() instead of
-    qFind().
-
-    \sa qBinaryFind(), {input iterators}
-*/
-
-/*! \fn template <typename Container, typename T> void qFind(const Container &container, const T &value)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::find instead.
-
-    This is the same as qFind(\a{container}.constBegin(), \a{container}.constEnd(), \a value);
-*/
-
-/*! \fn template <typename InputIterator, typename T, typename Size> void qCount(InputIterator begin, InputIterator end, const T &value, Size &n)
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::count instead.
-
-    Returns the number of occurrences of \a value in the range [\a begin, \a end),
-    which is returned in \a n. \a n is never initialized, the count is added to \a n.
-    It is the caller's responsibility to initialize \a n.
-
-    Example:
-
-    \snippet code/doc_src_qalgorithms.cpp 9
-
-    This function requires the item type (in the example above,
-    \c int) to implement \c operator==().
-
-    \sa {input iterators}
-*/
-
-/*! \fn template <typename Container, typename T, typename Size> void qCount(const Container &container, const T &value, Size &n)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::count instead.
-
-    Instead of operating on iterators, as in the other overload, this function
-    operates on the specified \a container to obtain the number of instances
-    of \a value in the variable passed as a reference in argument \a n.
-*/
-
 /*! \fn template <typename T> void qSwap(T &var1, T &var2)
     \relates <QtAlgorithms>
     \deprecated
@@ -387,311 +159,6 @@
     \snippet code/doc_src_qalgorithms.cpp 10
 */
 
-/*! \fn template <typename RandomAccessIterator> void qSort(RandomAccessIterator begin, RandomAccessIterator end)
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::sort instead.
-
-    Sorts the items in range [\a begin, \a end) in ascending order
-    using the quicksort algorithm.
-
-    Example:
-    \snippet code/doc_src_qalgorithms.cpp 11
-
-    The sort algorithm is efficient on large data sets. It operates
-    in \l {linear-logarithmic time}, O(\e{n} log \e{n}).
-
-    This function requires the item type (in the example above,
-    \c{int}) to implement \c operator<().
-
-    If neither of the two items is "less than" the other, the items are
-    taken to be equal. It is then undefined which one of the two
-    items will appear before the other after the sort.
-
-    \sa qStableSort(), {random access iterators}
-*/
-
-/*! \fn template <typename RandomAccessIterator, typename LessThan> void qSort(RandomAccessIterator begin, RandomAccessIterator end, LessThan lessThan)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::sort instead.
-
-    Uses the \a lessThan function instead of \c operator<() to
-    compare the items.
-
-    For example, here's how to sort the strings in a QStringList
-    in case-insensitive alphabetical order:
-
-    \snippet code/doc_src_qalgorithms.cpp 12
-
-    To sort values in reverse order, pass
-    \l{qGreater()}{qGreater<T>()} as the \a lessThan parameter. For
-    example:
-
-    \snippet code/doc_src_qalgorithms.cpp 13
-
-    If neither of the two items is "less than" the other, the items are
-    taken to be equal. It is then undefined which one of the two
-    items will appear before the other after the sort.
-
-    An alternative to using qSort() is to put the items to sort in a
-    QMap, using the sort key as the QMap key. This is often more
-    convenient than defining a \a lessThan function. For example, the
-    following code shows how to sort a list of strings case
-    insensitively using QMap:
-
-    \snippet code/doc_src_qalgorithms.cpp 14
-
-    \sa QMap
-*/
-
-/*! \fn template<typename Container> void qSort(Container &container)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::sort instead.
-
-    This is the same as qSort(\a{container}.begin(), \a{container}.end());
-*/
-
-/*!
-    \fn template <typename RandomAccessIterator> void qStableSort(RandomAccessIterator begin, RandomAccessIterator end)
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::stable_sort instead.
-
-    Sorts the items in range [\a begin, \a end) in ascending order
-    using a stable sorting algorithm.
-
-    If neither of the two items is "less than" the other, the items are
-    taken to be equal. The item that appeared before the other in the
-    original container will still appear first after the sort. This
-    property is often useful when sorting user-visible data.
-
-    Example:
-    \snippet code/doc_src_qalgorithms.cpp 15
-
-    The sort algorithm is efficient on large data sets. It operates
-    in \l {linear-logarithmic time}, O(\e{n} log \e{n}).
-
-    This function requires the item type (in the example above,
-    \c{int}) to implement \c operator<().
-
-    \sa qSort(), {random access iterators}
-*/
-
-/*!
-    \fn template <typename RandomAccessIterator, typename LessThan> void qStableSort(RandomAccessIterator begin, RandomAccessIterator end, LessThan lessThan)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::stable_sort instead.
-
-    Uses the \a lessThan function instead of \c operator<() to
-    compare the items.
-
-    For example, here's how to sort the strings in a QStringList
-    in case-insensitive alphabetical order:
-
-    \snippet code/doc_src_qalgorithms.cpp 16
-
-    Note that earlier versions of Qt allowed using a lessThan function that took its
-    arguments by non-const reference. From 4.3 and on this is no longer possible,
-    the arguments has to be passed by const reference or value.
-
-    To sort values in reverse order, pass
-    \l{qGreater()}{qGreater<T>()} as the \a lessThan parameter. For
-    example:
-
-    \snippet code/doc_src_qalgorithms.cpp 17
-
-    If neither of the two items is "less than" the other, the items are
-    taken to be equal. The item that appeared before the other in the
-    original container will still appear first after the sort. This
-    property is often useful when sorting user-visible data.
-*/
-
-/*!
-    \fn template <typename Container> void qStableSort(Container &container)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::stable_sort instead.
-
-    This is the same as qStableSort(\a{container}.begin(), \a{container}.end());
-*/
-
-/*! \fn template <typename RandomAccessIterator, typename T> RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::lower_bound instead.
-
-    Performs a binary search of the range [\a begin, \a end) and
-    returns the position of the first occurrence of \a value. If no
-    such item is found, returns the position where it should be
-    inserted.
-
-    The items in the range [\a begin, \e end) must be sorted in
-    ascending order; see qSort().
-
-    Example:
-    \snippet code/doc_src_qalgorithms.cpp 18
-
-    This function requires the item type (in the example above,
-    \c{int}) to implement \c operator<().
-
-    qLowerBound() can be used in conjunction with qUpperBound() to
-    iterate over all occurrences of the same value:
-
-    \snippet code/doc_src_qalgorithms.cpp 19
-
-    \sa qUpperBound(), qBinaryFind()
-*/
-
-/*!
-    \fn template <typename RandomAccessIterator, typename T, typename LessThan> RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::lower_bound instead.
-
-    Uses the \a lessThan function instead of \c operator<() to
-    compare the items.
-
-    Note that the items in the range must be sorted according to the order
-    specified by the \a lessThan object.
-*/
-
-/*!
-    \fn template <typename Container, typename T> void qLowerBound(const Container &container, const T &value)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::lower_bound instead.
-
-    For read-only iteration over containers, this function is broadly equivalent to
-    qLowerBound(\a{container}.begin(), \a{container}.end(), value). However, since it
-    returns a const iterator, you cannot use it to modify the container; for example,
-    to insert items.
-*/
-
-/*! \fn template <typename RandomAccessIterator, typename T> RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::upper_bound instead.
-
-    Performs a binary search of the range [\a begin, \a end) and
-    returns the position of the one-past-the-last occurrence of \a
-    value. If no such item is found, returns the position where the
-    item should be inserted.
-
-    The items in the range [\a begin, \e end) must be sorted in
-    ascending order; see qSort().
-
-    Example:
-    \snippet code/doc_src_qalgorithms.cpp 20
-
-    This function requires the item type (in the example above,
-    \c{int}) to implement \c operator<().
-
-    qUpperBound() can be used in conjunction with qLowerBound() to
-    iterate over all occurrences of the same value:
-
-    \snippet code/doc_src_qalgorithms.cpp 21
-
-    \sa qLowerBound(), qBinaryFind()
-*/
-
-/*!
-    \fn template <typename RandomAccessIterator, typename T, typename LessThan> RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::upper_bound instead.
-
-    Uses the \a lessThan function instead of \c operator<() to
-    compare the items.
-
-    Note that the items in the range must be sorted according to the order
-    specified by the \a lessThan object.
-*/
-
-/*!
-    \fn template <typename Container, typename T> void qUpperBound(const Container &container, const T &value)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::upper_bound instead.
-
-    This is the same as qUpperBound(\a{container}.begin(), \a{container}.end(), \a value);
-*/
-
-
-/*! \fn template <typename RandomAccessIterator, typename T> RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::binary_search or \c std::lower_bound instead.
-
-    Performs a binary search of the range [\a begin, \a end) and
-    returns the position of an occurrence of \a value. If there are
-    no occurrences of \a value, returns \a end.
-
-    The items in the range [\a begin, \a end) must be sorted in
-    ascending order; see qSort().
-
-    If there are many occurrences of the same value, any one of them
-    could be returned. Use qLowerBound() or qUpperBound() if you need
-    finer control.
-
-    Example:
-    \snippet code/doc_src_qalgorithms.cpp 22
-
-    This function requires the item type (in the example above,
-    QString) to implement \c operator<().
-
-    \sa qLowerBound(), qUpperBound(), {random access iterators}
-*/
-
-/*! \fn template <typename RandomAccessIterator, typename T, typename LessThan> RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::binary_search or \c std::lower_bound instead.
-
-    Uses the \a lessThan function instead of \c operator<() to
-    compare the items.
-
-    Note that the items in the range must be sorted according to the order
-    specified by the \a lessThan object.
-*/
-
-/*!
-    \fn template <typename Container, typename T> void qBinaryFind(const Container &container, const T &value)
-    \relates <QtAlgorithms>
-    \deprecated
-    \overload
-
-    Use \c std::binary_search or \c std::lower_bound instead.
-
-    This is the same as qBinaryFind(\a{container}.begin(), \a{container}.end(), \a value);
-*/
-
-
 /*!
     \fn template <typename ForwardIterator> void qDeleteAll(ForwardIterator begin, ForwardIterator end)
     \relates <QtAlgorithms>
@@ -724,39 +191,6 @@
     This is the same as qDeleteAll(\a{c}.begin(), \a{c}.end()).
 */
 
-/*! \fn template <typename LessThan> LessThan qLess()
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::less instead.
-
-    Returns a functional object, or functor, that can be passed to qSort()
-    or qStableSort().
-
-    Example:
-
-    \snippet code/doc_src_qalgorithms.cpp 24
-
-    \sa {qGreater()}{qGreater<T>()}
-*/
-
-/*! \fn template <typename LessThan> LessThan qGreater()
-    \relates <QtAlgorithms>
-    \deprecated
-
-    Use \c std::greater instead.
-
-    Returns a functional object, or functor, that can be passed to qSort()
-    or qStableSort().
-
-    Example:
-
-    \snippet code/doc_src_qalgorithms.cpp 25
-
-    \sa {qLess()}{qLess<T>()}
-*/
-
-
 /*!
     \fn uint qPopulationCount(quint8 v)
     \relates <QtAlgorithms>
diff --git a/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp b/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
index 44e6bef6f0..e0062b9118 100644
--- a/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
+++ b/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2020 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the test suite of the Qt Toolkit.
@@ -54,31 +54,6 @@ private slots:
     void swap2();
     void convenienceAPI();
 
-#if QT_DEPRECATED_SINCE(5, 2)
-    void test_qLowerBound_data();
-    void test_qLowerBound();
-    void test_qUpperBound_data();
-    void test_qUpperBound();
-    void test_qBinaryFind_data();
-    void test_qBinaryFind();
-    void qBinaryFindOneEntry();
-    void sortEmptyList();
-    void sortedList();
-    void sortAPItest();
-    void stableSortTest();
-    void stableSortCorrectnessTest_data();
-    void stableSortCorrectnessTest();
-    void convenienceAPI_deprecated();
-    void qCountIterators() const;
-    void qCountContainer() const;
-    void binaryFindOnLargeContainer() const;
-
-#if Q_TEST_PERFORMANCE
-    void performance();
-#endif
-
-#endif // QT_DEPRECATED_SINCE(5, 2)
-
     void popCount08_data() { popCount_data_impl(sizeof(quint8 )); }
     void popCount16_data() { popCount_data_impl(sizeof(quint16)); }
     void popCount32_data() { popCount_data_impl(sizeof(quint32)); }
@@ -120,155 +95,6 @@ private:
     void countLeading_impl();
 };
 
-#if QT_DEPRECATED_SINCE(5, 2)
-
-class TestInt
-{
-public:
-    TestInt(int number)  :m_number(number) {} ;
-    TestInt() : m_number(0) {};
-    bool operator<(const TestInt &other) const { ++TestInt::lessThanRefCount; return (m_number < other.m_number); }
-    int m_number;
-static long int lessThanRefCount;
-};
-
-long int TestInt::lessThanRefCount;
-
-
-QStringList dataSetTypes = QStringList() << "Random" << "Ascending"
-                << "Descending" << "Equal" << "Duplicates" << "Almost Sorted"  ;
-
-template <typename DataType>
-QList<DataType> generateData(QString dataSetType, const int length)
-{
-    QList<DataType> container;
-    if (dataSetType == "Random") {
-        for (int i = 0; i < length; ++i)
-            container.append(QRandomGenerator::global()->generate());
-    } else if (dataSetType == "Ascending") {
-        for (int i = 0; i < length; ++i)
-            container.append(i);
-    } else if (dataSetType == "Descending") {
-        for (int i = 0; i < length; ++i)
-            container.append(length - i);
-    } else if (dataSetType == "Equal") {
-        for (int i = 0; i < length; ++i)
-            container.append(43);
-    } else if (dataSetType == "Duplicates") {
-        for (int i = 0; i < length; ++i)
-            container.append(i % 10);
-    } else if (dataSetType == "Almost Sorted") {
-        for (int i = 0; i < length; ++i)
-            container.append(i);
-        for (int i = 0; i <= length / 10; ++i) {
-            const int iswap = i * 9;
-            DataType tmp = container.at(iswap);
-            container[iswap] = container.at(iswap + 1);
-            container[iswap + 1] = tmp;
-        }
-    }
-    return container;
-}
-
-struct ResultSet
-{
-    int numSorts;
-    long int lessThanRefCount;
-};
-
-
-template <typename ContainerType, typename Algorithm>
-ResultSet testRun(ContainerType &container, Algorithm &algorithm, int millisecs)
-{
-    TestInt::lessThanRefCount = 0;
-    int count = 0;
-    QElapsedTimer t;
-    t.start();
-    while(t.elapsed() < millisecs) {
-        ++count;
-        algorithm(container);
-    }
-    ResultSet result;
-    result.numSorts = count;
-    result.lessThanRefCount = TestInt::lessThanRefCount;
-    return result;
-}
-
-template <typename ContainerType, typename LessThan>
-bool isSorted(ContainerType &container, LessThan lessThan)
-{
-    for (int i=0; i < container.count() - 1; ++i)
-        if (lessThan(container.at(i+1), container.at(i))) {
-            return false;
-        }
-    return true;
-}
-
-template <typename ContainerType>
-bool isSorted(ContainerType &container)
-{
-    return isSorted(container, qLess<typename ContainerType::value_type>());
-}
-
-
-#if Q_TEST_PERFORMANCE
-void printHeader(QStringList &headers)
-{
-    cout << setw(10) << setiosflags(ios_base::left) << " ";
-    for (int h = 0; h < headers.count(); ++h) {
-        cout << setw(20) << setiosflags(ios_base::left) << headers.at(h).toLatin1().constData();
-    }
-    cout << Qt::endl;
-}
-
-template <typename ContainerType>
-void print(ContainerType testContainer)
-{
-    typedef typename ContainerType::value_type T;
-
-    foreach(T value, testContainer) {
-        cout << value << " ";
-    }
-
-    cout << Qt::endl;
-}
-
-template <typename Algorithm, typename DataType>
-QList<ResultSet> testAlgorithm(Algorithm &algorithm,  QStringList dataSetTypes,  int size, int time)
-{
-    QList<ResultSet> results;
-    foreach(QString dataSetType, dataSetTypes) {
-        QList<DataType> container = generateData<DataType>(dataSetType, size);
-        results.append(testRun(container, algorithm, time));
-        if (!isSorted(container))
-            qWarning("%s: container is not sorted after test", Q_FUNC_INFO);
-    }
-    return results;
-}
-
-template <typename Algorithm, typename DataType>
-void testAlgorithm(Algorithm algorithm, QStringList &dataSetTypes)
-{
-    QList<int> sizes = QList<int>() << 5 << 15 << 35 << 70 << 200 << 1000 << 10000;
-    printHeader(dataSetTypes);
-    for (int s = 0; s < sizes.count(); ++s){
-        cout << setw(10) <<  setiosflags(ios_base::left)<< sizes.at(s);
-        QList<ResultSet> results =
-            testAlgorithm<Algorithm, DataType>(algorithm, dataSetTypes, sizes.at(s), 100);
-        foreach(ResultSet result, results) {
-            stringstream numSorts;
-            numSorts << setiosflags(ios_base::left) << setw(10) << result.numSorts;
-            stringstream lessThan;
-            lessThan << setiosflags(ios_base::left) << setw(10) << result.lessThanRefCount / result.numSorts;
-            cout << numSorts.str() << lessThan.str();
-        }
-        cout << Qt::endl;
-    }
-}
-#endif
-
-#endif // QT_DEPRECATED_SINCE(5, 2)
-
 void tst_QAlgorithms::swap()
 {
     {
@@ -412,639 +238,6 @@ void tst_QAlgorithms::convenienceAPI()
     qDeleteAll(pointerList.begin(), pointerList.end());
 }
 
-#if QT_DEPRECATED_SINCE(5, 2)
-
-void tst_QAlgorithms::sortEmptyList()
-{
-    // Only test if it crashes
-    QStringList stringList;
-    stringList.sort();
-    QVERIFY(true);
-}
-
-void tst_QAlgorithms::sortedList()
-{
-    QList<int> list;
-    list << 4 << 3 << 6;
-
-    ::qSort(list.begin(), list.end());
-
-    QCOMPARE(list.count(), 3);
-    QCOMPARE(list.at(0), 3);
-    QCOMPARE(list.at(1), 4);
-    QCOMPARE(list.at(2), 6);
-
-    list.insert(qUpperBound(list.begin(), list.end(), 5), 5);
-    list.insert(qUpperBound(list.begin(), list.end(), 1), 1);
-    list.insert(qUpperBound(list.begin(), list.end(), 8), 8);
-
-    QCOMPARE(list.count(), 6);
-    QCOMPARE(list.at(0), 1);
-    QCOMPARE(list.at(1), 3);
-    QCOMPARE(list.at(2), 4);
-    QCOMPARE(list.at(3), 5);
-    QCOMPARE(list.at(4), 6);
-    QCOMPARE(list.at(5), 8);
-}
-
-
-void tst_QAlgorithms::test_qLowerBound_data()
-{
-    QTest::addColumn<QList<int> >("data");
-    QTest::addColumn<int>("resultValue");
-    QTest::addColumn<int>("resultIndex");
-
-    QTest::newRow("sorted-duplicate") << (QList<int>() << 1 << 2 << 2 << 3) << 2 << 1;
-}
-
-void tst_QAlgorithms::test_qLowerBound()
-{
-    QFETCH(QList<int>, data);
-    QFETCH(int, resultValue);
-    QFETCH(int, resultIndex);
-
-
-    QCOMPARE(qLowerBound(data.constBegin(), data.constEnd(), resultValue), data.constBegin() + resultIndex);
-    QCOMPARE(qLowerBound(data.begin(), data.end(), resultValue), data.begin() + resultIndex);
-    QCOMPARE(qLowerBound(data, resultValue), data.constBegin() + resultIndex);
-    QCOMPARE(qLowerBound(data.constBegin(), data.constEnd(), resultValue, qLess<int>()), data.constBegin() + resultIndex);
-}
-
-void tst_QAlgorithms::test_qUpperBound_data()
-{
-    QTest::addColumn<QList<int> >("data");
-    QTest::addColumn<int>("resultValue");
-    QTest::addColumn<int>("resultIndex");
-
-    QTest::newRow("sorted-duplicate") << (QList<int>() << 1 << 2 << 2 << 3) << 2 << 3;
-}
-
-void tst_QAlgorithms::test_qUpperBound()
-{
-    QFETCH(QList<int>, data);
-    QFETCH(int, resultValue);
-    QFETCH(int, resultIndex);
-
-    QCOMPARE(qUpperBound(data.constBegin(), data.constEnd(), resultValue), data.constBegin() + resultIndex);
-    QCOMPARE(qUpperBound(data.begin(), data.end(), resultValue), data.begin() + resultIndex);
-    QCOMPARE(qUpperBound(data, resultValue), data.constBegin() + resultIndex);
-    QCOMPARE(qUpperBound(data.constBegin(), data.constEnd(), resultValue, qLess<int>()), data.constBegin() + resultIndex);
-}
-
-void tst_QAlgorithms::test_qBinaryFind_data()
-{
-    QTest::addColumn<QList<int> >("data");
-    QTest::addColumn<int>("resultValue"); // -42 means not found
-
-    QTest::newRow("sorted-duplicate") << (QList<int>() << 1 << 2 << 2 << 3) << 2;
-    QTest::newRow("sorted-end") << (QList<int>() << -5 << -2 << 0 << 8) << 8;
-    QTest::newRow("sorted-beginning") << (QList<int>() << -5 << -2 << 0 << 8) << -5;
-    QTest::newRow("sorted-duplicate-beginning") << (QList<int>() << -5 << -5 << -2 << 0 << 8) << -5;
-    QTest::newRow("empty") << (QList<int>()) << -42;
-    QTest::newRow("not found 1 ") << (QList<int>() << 1 << 5 << 8 << 65) << -42;
-    QTest::newRow("not found 2 ") << (QList<int>() << -456 << -5 << 8 << 65) << -42;
-}
-
-void tst_QAlgorithms::test_qBinaryFind()
-{
-    QFETCH(QList<int>, data);
-    QFETCH(int, resultValue);
-
-    //-42 means not found
-    if (resultValue == -42) {
-        QVERIFY(qBinaryFind(data.constBegin(), data.constEnd(), resultValue) == data.constEnd());
-        QVERIFY(qBinaryFind(data, resultValue) == data.constEnd());
-        QVERIFY(qBinaryFind(data.begin(), data.end(), resultValue) == data.end());
-        QVERIFY(qBinaryFind(data.begin(), data.end(), resultValue, qLess<int>()) == data.end());
-        return;
-    }
-
-    QCOMPARE(*qBinaryFind(data.constBegin(), data.constEnd(), resultValue), resultValue);
-    QCOMPARE(*qBinaryFind(data.begin(), data.end(), resultValue), resultValue);
-    QCOMPARE(*qBinaryFind(data, resultValue), resultValue);
-    QCOMPARE(*qBinaryFind(data.constBegin(), data.constEnd(), resultValue, qLess<int>()), resultValue);
-}
-
-void tst_QAlgorithms::qBinaryFindOneEntry()
-{
-    QList<int> list;
-    list << 2;
-
-    QVERIFY(::qBinaryFind(list.constBegin(), list.constEnd(), 2) != list.constEnd());
-}
-
-
-void tst_QAlgorithms::sortAPItest()
-{
-    QList<int> testList = generateData<int>("Random", 101).toList();
-    qSort(testList);
-    QVERIFY(isSorted(testList));
-    qSort(testList.begin(), testList.end());
-    QVERIFY(isSorted(testList));
-    qSort(testList.begin(), testList.end(), qLess<int>());
-    QVERIFY(isSorted(testList));
-
-    testList = generateData<int>("Random", 71).toList();
-    qStableSort(testList);
-    QVERIFY(isSorted(testList));
-    qStableSort(testList.begin(), testList.end());
-    QVERIFY(isSorted(testList));
-    qStableSort(testList.begin(), testList.end(), qLess<int>());
-    QVERIFY(isSorted(testList));
-}
-
-
-class StableSortTest
-{
-public:
-    StableSortTest(){};
-    StableSortTest(int Major, int Minor) : Major(Major), Minor(Minor) {}
-    bool operator<(const StableSortTest &other) const {return (Major < other.Major); }
-    bool testMinor(const  StableSortTest &other) const {return  Minor < other.Minor; }
-
-int Major;
-int Minor;
-};
-
-ostream &operator<<(ostream &out, const StableSortTest& obj)  { out << obj.Major << "-" << obj.Minor; return out; }
-
-QList<StableSortTest> createStableTestList()
-{
-    QList<StableSortTest> stableTestList;
-    for (int i = 500; i >= 0; --i) {
-        for (int j = 0; j < 10; ++j)
-            stableTestList.append(StableSortTest(i, j));
-    }
-    return stableTestList;
-}
-
-template <typename ContainerType, typename LessThan>
-bool isStableSorted(ContainerType &container, LessThan lessThan)
-{
-    for (int i=0; i < container.count() - 1; ++i) {
-        //not sorted?
-        if (lessThan(container.at(i + 1), container.at(i)))
-            return false;
-        // equal?
-        if (lessThan(container.at(i),  container.at(i + 1)))
-            continue;
-        // minor version?
-        if(container.at(i + 1).testMinor(container.at(i)))
-            return false;
-    }
-    return true;
-}
-
-void tst_QAlgorithms::stableSortTest()
-{
-    // Selftests:
-    {
-        QList<StableSortTest> stableTestList = createStableTestList();
-        qSort(stableTestList.begin(), stableTestList.end(), qLess<StableSortTest>());
-        QVERIFY(isSorted(stableTestList, qLess<StableSortTest>()));
-        QVERIFY(!isStableSorted(stableTestList, qLess<StableSortTest>()));
-    }
-    {
-        QList<StableSortTest> stableTestList = createStableTestList();
-        qSort(stableTestList.begin(), stableTestList.end(), qGreater<StableSortTest>());
-        QVERIFY(isSorted(stableTestList, qGreater<StableSortTest>()));
-        QVERIFY(!isStableSorted(stableTestList, qGreater<StableSortTest>()));
-    }
-    {
-        QList<StableSortTest> stableTestList = createStableTestList();
-        qSort(stableTestList.begin(), stableTestList.end(), qGreater<StableSortTest>());
-        QVERIFY(!isSorted(stableTestList, qLess<StableSortTest>()));
-        QVERIFY(!isStableSorted(stableTestList, qGreater<StableSortTest>()));
-    }
-
-
-    // Stable sort with qLess
-    {
-        QList<StableSortTest> stableTestList = createStableTestList();
-        std::stable_sort(stableTestList.begin(), stableTestList.end(), qLess<StableSortTest>());
-        QVERIFY(isSorted(stableTestList, qLess<StableSortTest>()));
-        QVERIFY(isStableSorted(stableTestList, qLess<StableSortTest>()));
-    }
-    {
-        QList<StableSortTest> stableTestList = createStableTestList();
-        qStableSort(stableTestList.begin(), stableTestList.end(), qLess<StableSortTest>());
-        QVERIFY(isSorted(stableTestList, qLess<StableSortTest>()));
-        QVERIFY(isStableSorted(stableTestList, qLess<StableSortTest>()));
-    }
-
-    // Stable sort with qGreater
-    {
-        QList<StableSortTest> stableTestList = createStableTestList();
-        std::stable_sort(stableTestList.begin(), stableTestList.end(), qGreater<StableSortTest>());
-        QVERIFY(isSorted(stableTestList, qGreater<StableSortTest>()));
-        QVERIFY(isStableSorted(stableTestList, qGreater<StableSortTest>()));
-    }
-
-    {
-        QList<StableSortTest> stableTestList = createStableTestList();
-        qStableSort(stableTestList.begin(), stableTestList.end(), qGreater<StableSortTest>());
-        QVERIFY(isSorted(stableTestList, qGreater<StableSortTest>()));
-        QVERIFY(isStableSorted(stableTestList, qGreater<StableSortTest>()));
-    }
-}
-
-
-void tst_QAlgorithms::stableSortCorrectnessTest_data()
-{
-    const int dataSize = 1000;
-    QTest::addColumn<QList<int>>("unsorted");
-    QTest::newRow("From documentation") << (QList<int>() << 33 << 12 << 68 << 6 << 12);
-    QTest::newRow("Equal") << (generateData<int>("Equal", dataSize));
-    QTest::newRow("Ascending") << (generateData<int>("Ascending", dataSize));
-    QTest::newRow("Descending") << (generateData<int>("Descending", dataSize));
-    QTest::newRow("Duplicates") << (generateData<int>("Duplicates", dataSize));
-    QTest::newRow("Almost Sorted") << (generateData<int>("Almost Sorted", dataSize));
-    QTest::newRow("Random") << (generateData<int>("Random", dataSize));
-}
-
-void tst_QAlgorithms::stableSortCorrectnessTest()
-{
-    QFETCH(QList<int>, unsorted);
-
-    QList<int> sorted = unsorted;
-    qStableSort(sorted.begin(), sorted.end());
-
-    // Verify that sorted contains the same numbers as unsorted.
-    foreach(int value, unsorted) {
-        QVERIFY(sorted.contains(value));
-        int unsortedCount = 0;
-        qCount(unsorted.begin(), unsorted.end(), value, unsortedCount);
-        int sortedCount = 0;
-        qCount(sorted.begin(), sorted.end(), value, sortedCount);
-        QCOMPARE(sortedCount, unsortedCount);
-    }
-
-    QVERIFY(isSorted(sorted));
-}
-
-void tst_QAlgorithms::convenienceAPI_deprecated()
-{
-    // Compile-test for QAlgorithm convenience functions.
-    QList<int> list, list2;
-
-    qCopy(list.begin(), list.end(), list2.begin());
-    qCopyBackward(list.begin(), list.end(), list2.begin());
-    qEqual(list.begin(), list.end(), list2.begin());
-
-    qFill(list, 1);
-    qFill(list.begin(), list.end(), 1);
-
-    qFind(list, 1);
-    qFind(list.begin(), list.end(), 1);
-
-    int count1 = 0 , count2 = 0, count3 = 0;
-    qCount(list, 1, count1);
-    qCount(list.begin(), list.end(), 1, count2);
-    QCOMPARE(count1, count2);
-    QCOMPARE(count2, count3);
-
-    qSort(list);
-    qSort(list.begin(), list.end());
-    qSort(list.begin(), list.end(), qLess<int>());
-
-    qStableSort(list);
-    qStableSort(list.begin(), list.end());
-    qStableSort(list.begin(), list.end(), qLess<int>());
-
-    qLowerBound(list, 1);;
-    qLowerBound(list.begin(), list.end(),  1);
-    qLowerBound(list.begin(), list.end(), 1, qLess<int>());
-
-    qUpperBound(list, 1);
-    qUpperBound(list.begin(), list.end(),  1);
-    qUpperBound(list.begin(), list.end(), 1, qLess<int>());
-
-    qBinaryFind(list, 1);
-    qBinaryFind(list.begin(), list.end(),  1);
-    qBinaryFind(list.begin(), list.end(), 1, qLess<int>());
-}
-
-template <typename DataType>
-class QuickSortHelper
-{
-public:
-    void operator()(QList<DataType> list)
-    {
-        ::qSort(list);
-    }
-};
-
-template <typename DataType>
-class StableSortHelper
-{
-public:
-    void operator()(QList<DataType> list)
-    {
-        ::qStableSort(list);
-    }
-};
-
-template <typename DataType>
-class StlSortHelper
-{
-public:
-    void operator()(QList<DataType> list)
-    {
-        std::sort(list.begin(), list.end());
-    }
-};
-
-template <typename DataType>
-class StlStableSortHelper
-{
-public:
-    void operator()(QList<DataType> list)
-    {
-        std::stable_sort(list.begin(), list.end());
-    }
-};
-
-#if Q_TEST_PERFORMANCE
-void tst_QAlgorithms::performance()
-{
-    cout << Qt::endl << "Quick sort" << Qt::endl;
-    testAlgorithm<QuickSortHelper<TestInt>, TestInt>(QuickSortHelper<TestInt>(), dataSetTypes);
-    cout << Qt::endl << "stable sort" << Qt::endl;
-    testAlgorithm<StableSortHelper<TestInt>, TestInt>(StableSortHelper<TestInt>(), dataSetTypes);
-    cout << Qt::endl << "std::sort" << Qt::endl;
-    testAlgorithm<StlSortHelper<TestInt>, TestInt>(StlSortHelper<TestInt>(), dataSetTypes);
-    cout << Qt::endl << "std::stable_sort" << Qt::endl;
-    testAlgorithm<StlStableSortHelper<TestInt>, TestInt>(StlStableSortHelper<TestInt>(), dataSetTypes);
-/*
-    cout << Qt::endl << "Sorting lists of ints" << Qt::endl;
-    cout << Qt::endl << "Quick sort" << Qt::endl;
-    testAlgorithm<QuickSortHelper<int>, int>(QuickSortHelper<int>(), dataSetTypes);
-    cout << Qt::endl << "std::sort" << Qt::endl;
-    testAlgorithm<StlSortHelper<int>, int>(StlSortHelper<int>(), dataSetTypes);
-    cout << Qt::endl << "std::stable_sort" << Qt::endl;
-    testAlgorithm<StlStableSortHelper<int>, int>(StlStableSortHelper<int>(), dataSetTypes);
-*/
-}
-#endif
-
-void tst_QAlgorithms::qCountIterators() const
-{
-    QList<int> list;
-    list << 3 << 3 << 6 << 6 << 6 << 8;
-
-    {
-        int countOf7 = 0;
-        ::qCount(list.begin(), list.end(), 7, countOf7);
-        QCOMPARE(countOf7, 0);
-    }
-
-    {
-        int countOf3 = 0;
-        ::qCount(list.begin(), list.end(), 3, countOf3);
-        QCOMPARE(countOf3, 2);
-    }
-
-    {
-        int countOf6 = 0;
-        ::qCount(list.begin(), list.end(), 6, countOf6);
-        QCOMPARE(countOf6, 3);
-    }
-
-    {
-        int countOf8 = 0;
-        ::qCount(list.begin(), list.end(), 8, countOf8);
-        QCOMPARE(countOf8, 1);
-    }
-
-    /* Check that we add to the count, not set it. */
-    {
-        int countOf8 = 5;
-        ::qCount(list.begin(), list.end(), 8, countOf8);
-        QCOMPARE(countOf8, 6);
-    }
-}
-
-void tst_QAlgorithms::qCountContainer() const
-{
-    QList<int> list;
-    list << 3 << 3 << 6 << 6 << 6 << 8;
-
-    {
-        int countOf7 = 0;
-        ::qCount(list, 7, countOf7);
-        QCOMPARE(countOf7, 0);
-    }
-
-    {
-        int countOf3 = 0;
-        ::qCount(list, 3, countOf3);
-        QCOMPARE(countOf3, 2);
-    }
-
-    {
-        int countOf6 = 0;
-        ::qCount(list, 6, countOf6);
-        QCOMPARE(countOf6, 3);
-    }
-
-    {
-        int countOf8 = 0;
-        ::qCount(list, 8, countOf8);
-        QCOMPARE(countOf8, 1);
-    }
-
-    /* Check that we add to the count, not set it. */
-    {
-        int countOf8 = 5;
-        ::qCount(list, 8, countOf8);
-        QCOMPARE(countOf8, 6);
-    }
-}
-
-class RAI
-{
-  public:
-    typedef int difference_type;
-    typedef int value_type;
-    typedef std::random_access_iterator_tag iterator_category;
-    typedef int *pointer;
-    typedef int &reference;
-
-    RAI(int searched = 5, int hidePos = 4, int len = 10)
-        : curPos_(0)
-        , length_(len)
-        , searchedVal_(searched)
-        , searchedValPos_(hidePos)
-    {
-    }
-
-    int at(int pos) const
-    {
-        if (pos == searchedValPos_) {
-            return searchedVal_;
-        }
-        else if (pos < searchedValPos_) {
-            return searchedVal_ - 1;
-        }
-
-        return searchedVal_ + 1;
-    }
-
-    RAI begin() const
-    {
-        RAI rai = *this;
-        rai.setCurPos(0);
-        return rai;
-    }
-
-    RAI end() const
-    {
-        RAI rai = *this;
-        rai.setCurPos(length_);
-        return rai;
-    }
-
-    int pos() const
-    {
-        return curPos();
-    }
-
-    int size() const
-    {
-        return length_;
-    }
-
-    RAI operator+(int i) const
-    {
-        RAI rai = *this;
-        rai.setCurPos( rai.curPos() + i );
-        if (rai.curPos() > length_) {
-            rai.setCurPos(length_);
-        }
-        return rai;
-    }
-
-    RAI operator-(int i) const
-    {
-        RAI rai = *this;
-        rai.setCurPos( rai.curPos() - i );
-        if (rai.curPos() < 0) {
-            rai.setCurPos(0);
-        }
-        return rai;
-    }
-
-    int operator-(const RAI& it) const
-    {
-        return curPos() - it.curPos();
-    }
-
-    RAI& operator+=(int i)
-    {
-        setCurPos( curPos() + i );
-        if (curPos() > length_) {
-            setCurPos(length_);
-        }
-        return *this;
-    }
-
-    RAI& operator-=(int i)
-    {
-        setCurPos( curPos() - i);
-        if (curPos() < 0) {
-            setCurPos(0);
-        }
-        return *this;
-    }
-
-    RAI& operator++()
-    {
-        if (curPos() < length_) {
-            setCurPos( curPos() + 1 );
-        }
-        return *this;
-    }
-
-    RAI operator++(int)
-    {
-        RAI rai = *this;
-
-        if (curPos() < length_) {
-            setCurPos( curPos() + 1 );
-        }
-
-        return rai;
-    }
-
-    RAI& operator--()
-    {
-        if (curPos() > 0) {
-            setCurPos( curPos() - 1 );
-        }
-        return *this;
-    }
-
-    RAI operator--(int)
-    {
-        RAI rai = *this;
-
-        if (curPos() > 0) {
-            setCurPos( curPos() - 1 );
-        }
-
-        return rai;
-    }
-
-    bool operator==(const RAI& rai) const
-    {
-        return rai.curPos() == curPos();
-    }
-
-    bool operator!=(const RAI& rai) const
-    {
-        return !operator==(rai);
-    }
-
-    int operator*() const
-    {
-        return at(curPos());
-    }
-
-    int operator[](int i) const
-    {
-        return at(i);
-    }
-
-  private:
-
-    int curPos() const
-    {
-        return curPos_;
-    }
-
-    void setCurPos(int pos)
-    {
-        curPos_ = pos;
-    }
-
-    int curPos_;
-    int length_;
-    int searchedVal_;
-    int searchedValPos_;
-};
-
-void tst_QAlgorithms::binaryFindOnLargeContainer() const
-{
-  const int len = 2 * 1000 * 1000 * 537;
-  const int pos = len - 12345;
-  RAI rai(5, pos, len);
-
-  RAI foundIt = qBinaryFind(rai.begin(), rai.end(), 5);
-  QCOMPARE(foundIt.pos(), 1073987655);
-}
-
-#endif // QT_DEPRECATED_SINCE(5, 2)
-
 // alternative implementation of qPopulationCount for comparison:
 static constexpr const uint bitsSetInNibble[] = {
     0, 1, 1, 2, 1, 2, 2, 3,
diff --git a/tests/benchmarks/corelib/tools/CMakeLists.txt b/tests/benchmarks/corelib/tools/CMakeLists.txt
index 6aed3d0f90..c1b5cad1aa 100644
--- a/tests/benchmarks/corelib/tools/CMakeLists.txt
+++ b/tests/benchmarks/corelib/tools/CMakeLists.txt
@@ -10,4 +10,3 @@ add_subdirectory(qrect)
 add_subdirectory(qringbuffer)
 add_subdirectory(qstack)
 add_subdirectory(qvector)
-add_subdirectory(qalgorithms)
diff --git a/tests/benchmarks/corelib/tools/qalgorithms/.gitignore b/tests/benchmarks/corelib/tools/qalgorithms/.gitignore
deleted file mode 100644
index 379c13eb9b..0000000000
--- a/tests/benchmarks/corelib/tools/qalgorithms/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-tst_qalgorithms
diff --git a/tests/benchmarks/corelib/tools/qalgorithms/CMakeLists.txt b/tests/benchmarks/corelib/tools/qalgorithms/CMakeLists.txt
deleted file mode 100644
index 949dda2167..0000000000
--- a/tests/benchmarks/corelib/tools/qalgorithms/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-# Generated from qalgorithms.pro.
-
-#####################################################################
-## tst_bench_qalgorithms Binary:
-#####################################################################
-
-qt_add_benchmark(tst_bench_qalgorithms
-    SOURCES
-        tst_qalgorithms.cpp
-    PUBLIC_LIBRARIES
-        Qt::Test
-)
diff --git a/tests/benchmarks/corelib/tools/qalgorithms/qalgorithms.pro b/tests/benchmarks/corelib/tools/qalgorithms/qalgorithms.pro
deleted file mode 100644
index 0bde3ac66a..0000000000
--- a/tests/benchmarks/corelib/tools/qalgorithms/qalgorithms.pro
+++ /dev/null
@@ -1,5 +0,0 @@
-CONFIG += benchmark
-QT = core testlib
-
-TARGET = tst_bench_qalgorithms
-SOURCES = tst_qalgorithms.cpp
diff --git a/tests/benchmarks/corelib/tools/qalgorithms/tst_qalgorithms.cpp b/tests/benchmarks/corelib/tools/qalgorithms/tst_qalgorithms.cpp
deleted file mode 100644
index ea116a4006..0000000000
--- a/tests/benchmarks/corelib/tools/qalgorithms/tst_qalgorithms.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Copyright (C) 2012 Robin Burchell <robin+qt@viroteck.net>
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the test suite of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include <QtTest/QtTest>
-
-#include <iostream>
-#include <iomanip>
-#include <sstream>
-#include <algorithm>
-#include <qalgorithms.h>
-#include <QStringList>
-#include <QString>
-#include <QList>
-
-using namespace std;
-
-class tst_QAlgorithms : public QObject
-{
-    Q_OBJECT
-private slots:
-    void stableSort_data();
-    void stableSort();
-
-    void sort_data();
-    void sort();
-};
-
-template<typename DataType>
-QList<DataType> generateData(QString dataSetType, const int length)
-{
-    QList<DataType> container;
-    if (dataSetType == "Random") {
-        for (int i = 0; i < length; ++i)
-            container.append(QRandomGenerator::global()->generate());
-    } else if (dataSetType == "Ascending") {
-        for (int i = 0; i < length; ++i)
-            container.append(i);
-    } else if (dataSetType == "Descending") {
-        for (int i = 0; i < length; ++i)
-            container.append(length - i);
-    } else if (dataSetType == "Equal") {
-        for (int i = 0; i < length; ++i)
-            container.append(43);
-    } else if (dataSetType == "Duplicates") {
-        for (int i = 0; i < length; ++i)
-            container.append(i % 10);
-    } else if (dataSetType == "Almost Sorted") {
-        for (int i = 0; i < length; ++i)
-            container.append(i);
-        for (int i = 0; i<= length / 10; ++i) {
-            const int iswap = i * 9;
-            DataType tmp = container.at(iswap);
-            container[iswap] = container.at(iswap + 1);
-            container[iswap + 1] = tmp;
-        }
-    }
-
-    return container;
-}
-
-
-void tst_QAlgorithms::stableSort_data()
-{
-    const int dataSize = 5000;
-    QTest::addColumn<QList<int>>("unsorted");
-    QTest::newRow("Equal") << (generateData<int>("Equal", dataSize));
-    QTest::newRow("Ascending") << (generateData<int>("Ascending", dataSize));
-    QTest::newRow("Descending") << (generateData<int>("Descending", dataSize));
-    QTest::newRow("Duplicates") << (generateData<int>("Duplicates", dataSize));
-    QTest::newRow("Almost Sorted") << (generateData<int>("Almost Sorted", dataSize));
-}
-
-void tst_QAlgorithms::stableSort()
-{
-    QFETCH(QList<int>, unsorted);
-
-    QBENCHMARK {
-        QList<int> sorted = unsorted;
-        qStableSort(sorted.begin(), sorted.end());
-    }
-}
-
-void tst_QAlgorithms::sort_data()
-{
-    stableSort_data();
-}
-
-void tst_QAlgorithms::sort()
-{
-    QFETCH(QList<int>, unsorted);
-
-    QBENCHMARK {
-        QList<int> sorted = unsorted;
-        qSort(sorted.begin(), sorted.end());
-    }
-}
-
-
-QTEST_MAIN(tst_QAlgorithms)
-#include "tst_qalgorithms.moc"
-
diff --git a/tests/benchmarks/corelib/tools/tools.pro b/tests/benchmarks/corelib/tools/tools.pro
index b4ee0520a6..8abb9feefb 100644
--- a/tests/benchmarks/corelib/tools/tools.pro
+++ b/tests/benchmarks/corelib/tools/tools.pro
@@ -9,5 +9,4 @@ SUBDIRS = \
         qrect \
         qringbuffer \
         qstack \
-        qvector \
-        qalgorithms
+        qvector