Revert "QAtomic: remove the copy ctor and assignment operator"

This reverts commit 6a93ec2435b8a453d43956fef6afa5f091d70ffc.

Reason for revert: Breaks qtdeclarative build, submodules need
to be clean before we deprecate or remove APIs.

Change-Id: Id0726b9bfad6072065b380b44b6ff6dffda79e45
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>

3 files changed, 99 insertions, 0 deletions

diff --git a/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp b/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp
index 315256e471..e8606b2568 100644
--- a/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp
+++ b/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp
@@ -21,6 +21,8 @@ private slots:
     // QAtomicInt members
     void constructor_data();
     void constructor();
+    void copy_constructor_data();
+    void copy_constructor();
     void assignment_operator_data();
     void assignment_operator();
 
@@ -234,6 +236,25 @@ void tst_QAtomicInt::constructor()
     QCOMPARE(atomic2.loadRelaxed(), value);
 }
 
+void tst_QAtomicInt::copy_constructor_data()
+{ constructor_data(); }
+
+void tst_QAtomicInt::copy_constructor()
+{
+    QFETCH(int, value);
+    QAtomicInt atomic1(value);
+    QCOMPARE(atomic1.loadRelaxed(), value);
+
+    QAtomicInt atomic2(atomic1);
+    QCOMPARE(atomic2.loadRelaxed(), value);
+    QAtomicInt atomic3 = atomic1;
+    QCOMPARE(atomic3.loadRelaxed(), value);
+    QAtomicInt atomic4(atomic2);
+    QCOMPARE(atomic4.loadRelaxed(), value);
+    QAtomicInt atomic5 = atomic2;
+    QCOMPARE(atomic5.loadRelaxed(), value);
+}
+
 void tst_QAtomicInt::assignment_operator_data()
 {
     QTest::addColumn<int>("value");
@@ -258,6 +279,10 @@ void tst_QAtomicInt::assignment_operator()
         QCOMPARE(atomic1.loadRelaxed(), newval);
         atomic1 = value;
         QCOMPARE(atomic1.loadRelaxed(), value);
+
+        QAtomicInt atomic2 = newval;
+        atomic1 = atomic2;
+        QCOMPARE(atomic1.loadRelaxed(), atomic2.loadRelaxed());
     }
 }
 
diff --git a/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp b/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
index 1ac07de80f..4e3c93c4e9 100644
--- a/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
+++ b/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
@@ -90,6 +90,12 @@ private Q_SLOTS:
     void constructor_data() { addData(); }
     void constructor();
 
+    void copy_data() { addData(); }
+    void copy();
+
+    void assign_data() { addData(); }
+    void assign();
+
     void operatorInteger_data() { addData(); }
     void operatorInteger();
 
@@ -213,6 +219,52 @@ void tst_QAtomicIntegerXX::constructor()
     QVERIFY(atomic.loadRelaxed() <= std::numeric_limits<T>::max());
 }
 
+void tst_QAtomicIntegerXX::copy()
+{
+    QFETCH(LargeInt, value);
+
+    QAtomicInteger<T> atomic(value);
+    QAtomicInteger<T> copy(atomic);
+    QCOMPARE(copy.loadRelaxed(), atomic.loadRelaxed());
+
+    QAtomicInteger<T> copy2 = atomic;
+    QCOMPARE(copy2.loadRelaxed(), atomic.loadRelaxed());
+
+    // move
+    QAtomicInteger<T> copy3(std::move(copy));
+    QCOMPARE(copy3.loadRelaxed(), atomic.loadRelaxed());
+
+    QAtomicInteger<T> copy4 = std::move(copy2);
+    QCOMPARE(copy4.loadRelaxed(), atomic.loadRelaxed());
+}
+
+void tst_QAtomicIntegerXX::assign()
+{
+    QFETCH(LargeInt, value);
+
+    QAtomicInteger<T> atomic(value);
+    QAtomicInteger<T> copy;
+    copy = atomic;
+    QCOMPARE(copy.loadRelaxed(), atomic.loadRelaxed());
+
+    QAtomicInteger<T> copy2;
+    copy2 = atomic;  // operator=(const QAtomicInteger &)
+    QCOMPARE(copy2.loadRelaxed(), atomic.loadRelaxed());
+
+    QAtomicInteger<T> copy2bis;
+    copy2bis = atomic.loadRelaxed(); // operator=(T)
+    QCOMPARE(copy2bis.loadRelaxed(), atomic.loadRelaxed());
+
+    // move
+    QAtomicInteger<T> copy3;
+    copy3 = std::move(copy);
+    QCOMPARE(copy3.loadRelaxed(), atomic.loadRelaxed());
+
+    QAtomicInteger<T> copy4;
+    copy4 = std::move(copy2);
+    QCOMPARE(copy4.loadRelaxed(), atomic.loadRelaxed());
+}
+
 void tst_QAtomicIntegerXX::operatorInteger()
 {
     QFETCH(LargeInt, value);
diff --git a/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp b/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp
index 1113e73b1b..c6bd784270 100644
--- a/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp
+++ b/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp
@@ -15,6 +15,7 @@ private slots:
     void alignment();
 
     void constructor();
+    void copy_constructor();
     void assignment_operator();
 
     void isTestAndSetNative();
@@ -100,6 +101,27 @@ void tst_QAtomicPointer::constructor()
     QCOMPARE(atomic3.loadRelaxed(), three);
 }
 
+void tst_QAtomicPointer::copy_constructor()
+{
+    void *one = this;
+    QAtomicPointer<void> atomic1 = one;
+    QAtomicPointer<void> atomic1_copy = atomic1;
+    QCOMPARE(atomic1_copy.loadRelaxed(), one);
+    QCOMPARE(atomic1_copy.loadRelaxed(), atomic1.loadRelaxed());
+
+    void *two = &one;
+    QAtomicPointer<void> atomic2 = two;
+    QAtomicPointer<void> atomic2_copy = atomic2;
+    QCOMPARE(atomic2_copy.loadRelaxed(), two);
+    QCOMPARE(atomic2_copy.loadRelaxed(), atomic2.loadRelaxed());
+
+    void *three = &two;
+    QAtomicPointer<void> atomic3 = three;
+    QAtomicPointer<void> atomic3_copy = atomic3;
+    QCOMPARE(atomic3_copy.loadRelaxed(), three);
+    QCOMPARE(atomic3_copy.loadRelaxed(), atomic3.loadRelaxed());
+}
+
 void tst_QAtomicPointer::assignment_operator()
 {
     void *one = this;