PyPySide: Skip all tests which use reference counting

[ChangeLog][PySide6] Tests which use reference counting
need to be skipped in upcoming PyPy builds.

Task-number: PYSIDE-535
Change-Id: I5dca3257d3dc40f53e9b4e4a69e24c07938047c2
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

43 files changed, 213 insertions, 137 deletions

diff --git a/sources/pyside6/tests/QtCore/qinstallmsghandler_test.py b/sources/pyside6/tests/QtCore/qinstallmsghandler_test.py
index df636cdd1..1a6214701 100644
--- a/sources/pyside6/tests/QtCore/qinstallmsghandler_test.py
+++ b/sources/pyside6/tests/QtCore/qinstallmsghandler_test.py
@@ -65,6 +65,7 @@ class QInstallMsgHandlerTest(unittest.TestCase):
         ret = qInstallMessageHandler(None)
         self.assertEqual(ret, None)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRet(self):
         ret = qInstallMessageHandler(None)
         self.assertEqual(ret, None)
diff --git a/sources/pyside6/tests/QtCore/qmodelindex_internalpointer_test.py b/sources/pyside6/tests/QtCore/qmodelindex_internalpointer_test.py
index 70ca5b9a6..c04c8b3c4 100644
--- a/sources/pyside6/tests/QtCore/qmodelindex_internalpointer_test.py
+++ b/sources/pyside6/tests/QtCore/qmodelindex_internalpointer_test.py
@@ -65,6 +65,7 @@ class TestQModelIndexInternalPointer(unittest.TestCase):
         i = idx.internalPointer()
         self.assertEqual(i, "Hello")
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReferenceCounting(self):
         # Test reference counting when retrieving data with
         # QModelIndex.internalPointer
diff --git a/sources/pyside6/tests/QtCore/qobject_destructor.py b/sources/pyside6/tests/QtCore/qobject_destructor.py
index d24017397..d9fe18d1d 100644
--- a/sources/pyside6/tests/QtCore/qobject_destructor.py
+++ b/sources/pyside6/tests/QtCore/qobject_destructor.py
@@ -45,6 +45,7 @@ class MyObject(QObject):
 
 
 class TestDestructor(unittest.TestCase):
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReference(self):
         o = QObject()
         m = MyObject(o)
diff --git a/sources/pyside6/tests/QtCore/qobject_event_filter_test.py b/sources/pyside6/tests/QtCore/qobject_event_filter_test.py
index 362982000..73c1544ed 100644
--- a/sources/pyside6/tests/QtCore/qobject_event_filter_test.py
+++ b/sources/pyside6/tests/QtCore/qobject_event_filter_test.py
@@ -115,6 +115,7 @@ class TestQObjectEventFilterPython(UsesQCoreApplication):
         self.assertEqual(filtered.times_called, 5)
         self.assertEqual(self.obj_filter.events_handled, 5)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testInstallEventFilterRefCountAfterDelete(self):
         '''Bug 910 - installEventFilter() increments reference count on target object
         http://bugs.pyside.org/show_bug.cgi?id=910'''
@@ -131,6 +132,7 @@ class TestQObjectEventFilterPython(UsesQCoreApplication):
         del obj
         self.assertEqual(wref(), None)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testInstallEventFilterRefCountAfterRemove(self):
         # Bug 910
         obj = QObject()
diff --git a/sources/pyside6/tests/QtCore/qobject_parent_test.py b/sources/pyside6/tests/QtCore/qobject_parent_test.py
index 63f8e3561..9dcbc05da 100644
--- a/sources/pyside6/tests/QtCore/qobject_parent_test.py
+++ b/sources/pyside6/tests/QtCore/qobject_parent_test.py
@@ -30,7 +30,6 @@
 
 import os
 import sys
-from sys import getrefcount
 import unittest
 
 from pathlib import Path
@@ -64,23 +63,26 @@ class ParentRefCountCase(unittest.TestCase):
         del self.child
         del self.parent
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testSetParent(self):
         # QObject.setParent() refcount changes
-        self.assertEqual(getrefcount(self.child), 2)
+        self.assertEqual(sys.getrefcount(self.child), 2)
         self.child.setParent(self.parent)
-        self.assertEqual(getrefcount(self.child), 3)
+        self.assertEqual(sys.getrefcount(self.child), 3)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testSetParentTwice(self):
-        self.assertEqual(getrefcount(self.child), 2)
+        self.assertEqual(sys.getrefcount(self.child), 2)
         self.child.setParent(self.parent)
-        self.assertEqual(getrefcount(self.child), 3)
+        self.assertEqual(sys.getrefcount(self.child), 3)
         self.child.setParent(self.parent)
-        self.assertEqual(getrefcount(self.child), 3)
+        self.assertEqual(sys.getrefcount(self.child), 3)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testConstructor(self):
         # QObject(QObject) refcount changes
         child = QObject(self.parent)
-        self.assertEqual(getrefcount(child), 3)
+        self.assertEqual(sys.getrefcount(child), 3)
 
 
 class ParentCase(unittest.TestCase):
@@ -215,77 +217,81 @@ class ParentCase(unittest.TestCase):
 class TestParentOwnership(unittest.TestCase):
     '''Test case for Parent/Child object ownership'''
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testParentDestructor(self):
         parent = QObject()
-        self.assertEqual(getrefcount(parent), 2)
+        self.assertEqual(sys.getrefcount(parent), 2)
 
         child = QObject(parent)
-        self.assertEqual(getrefcount(child), 3)
-        self.assertEqual(getrefcount(parent), 2)
+        self.assertEqual(sys.getrefcount(child), 3)
+        self.assertEqual(sys.getrefcount(parent), 2)
 
         del parent
-        self.assertEqual(getrefcount(child), 2)
+        self.assertEqual(sys.getrefcount(child), 2)
 
         # this will fail because parent deleted child cpp object
         self.assertRaises(RuntimeError, lambda: child.objectName())
 
     # test parent with multiples children
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testMultipleChildren(self):
         o = QObject()
-        self.assertEqual(getrefcount(o), 2)
+        self.assertEqual(sys.getrefcount(o), 2)
 
         c = QObject(o)
-        self.assertEqual(getrefcount(c), 3)
-        self.assertEqual(getrefcount(o), 2)
+        self.assertEqual(sys.getrefcount(c), 3)
+        self.assertEqual(sys.getrefcount(o), 2)
 
         c2 = QObject(o)
-        self.assertEqual(getrefcount(o), 2)
-        self.assertEqual(getrefcount(c), 3)
-        self.assertEqual(getrefcount(c2), 3)
+        self.assertEqual(sys.getrefcount(o), 2)
+        self.assertEqual(sys.getrefcount(c), 3)
+        self.assertEqual(sys.getrefcount(c2), 3)
 
         del o
-        self.assertEqual(getrefcount(c), 2)
-        self.assertEqual(getrefcount(c2), 2)
+        self.assertEqual(sys.getrefcount(c), 2)
+        self.assertEqual(sys.getrefcount(c2), 2)
 
         # this will fail because parent deleted child cpp object
         self.assertRaises(RuntimeError, lambda: c.objectName())
         self.assertRaises(RuntimeError, lambda: c2.objectName())
 
     # test recursive parent
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRecursiveParent(self):
         o = QObject()
-        self.assertEqual(getrefcount(o), 2)
+        self.assertEqual(sys.getrefcount(o), 2)
 
         c = QObject(o)
-        self.assertEqual(getrefcount(c), 3)
-        self.assertEqual(getrefcount(o), 2)
+        self.assertEqual(sys.getrefcount(c), 3)
+        self.assertEqual(sys.getrefcount(o), 2)
 
         c2 = QObject(c)
-        self.assertEqual(getrefcount(o), 2)
-        self.assertEqual(getrefcount(c), 3)
-        self.assertEqual(getrefcount(c2), 3)
+        self.assertEqual(sys.getrefcount(o), 2)
+        self.assertEqual(sys.getrefcount(c), 3)
+        self.assertEqual(sys.getrefcount(c2), 3)
 
         del o
-        self.assertEqual(getrefcount(c), 2)
-        self.assertEqual(getrefcount(c2), 2)
+        self.assertEqual(sys.getrefcount(c), 2)
+        self.assertEqual(sys.getrefcount(c2), 2)
 
         # this will fail because parent deleted child cpp object
         self.assertRaises(RuntimeError, lambda: c.objectName())
         self.assertRaises(RuntimeError, lambda: c2.objectName())
 
     # test parent transfer
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testParentTransfer(self):
         o = QObject()
-        self.assertEqual(getrefcount(o), 2)
+        self.assertEqual(sys.getrefcount(o), 2)
 
         c = QObject()
-        self.assertEqual(getrefcount(c), 2)
+        self.assertEqual(sys.getrefcount(c), 2)
 
         c.setParent(o)
-        self.assertEqual(getrefcount(c), 3)
+        self.assertEqual(sys.getrefcount(c), 3)
 
         c.setParent(None)
-        self.assertEqual(getrefcount(c), 2)
+        self.assertEqual(sys.getrefcount(c), 2)
 
         del c
         del o
diff --git a/sources/pyside6/tests/QtCore/qtimer_timeout_test.py b/sources/pyside6/tests/QtCore/qtimer_timeout_test.py
index ed2780c7a..7dbd30bd7 100644
--- a/sources/pyside6/tests/QtCore/qtimer_timeout_test.py
+++ b/sources/pyside6/tests/QtCore/qtimer_timeout_test.py
@@ -76,6 +76,7 @@ class TestTimeoutSignal(UsesQCoreApplication):
         # Default callback
         self.called = True
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testTimeoutSignal(self):
         # Test the QTimer timeout() signal
         refCount = sys.getrefcount(self.timer)
diff --git a/sources/pyside6/tests/QtCore/tr_noop_test.py b/sources/pyside6/tests/QtCore/tr_noop_test.py
index b2139e754..b665d4728 100644
--- a/sources/pyside6/tests/QtCore/tr_noop_test.py
+++ b/sources/pyside6/tests/QtCore/tr_noop_test.py
@@ -47,30 +47,35 @@ class QtTrNoopTest(unittest.TestCase):
     def tearDown(self):
         del self.txt
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testQtTrNoop(self):
         refcnt = sys.getrefcount(self.txt)
         result = QT_TR_NOOP(self.txt)
         self.assertEqual(result, self.txt)
         self.assertEqual(sys.getrefcount(result), refcnt + 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testQtTrNoopUtf8(self):
         refcnt = sys.getrefcount(self.txt)
         result = QT_TR_NOOP_UTF8(self.txt)
         self.assertEqual(result, self.txt)
         self.assertEqual(sys.getrefcount(result), refcnt + 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testQtTranslateNoop(self):
         refcnt = sys.getrefcount(self.txt)
         result = QT_TRANSLATE_NOOP(None, self.txt)
         self.assertEqual(result, self.txt)
         self.assertEqual(sys.getrefcount(result), refcnt + 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testQtTranslateNoopUtf8(self):
         refcnt = sys.getrefcount(self.txt)
         result = QT_TRANSLATE_NOOP_UTF8(self.txt)
         self.assertEqual(result, self.txt)
         self.assertEqual(sys.getrefcount(result), refcnt + 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testQtTranslateNoop3(self):
         refcnt = sys.getrefcount(self.txt)
         result = QT_TRANSLATE_NOOP3(None, self.txt, None)
diff --git a/sources/pyside6/tests/QtGui/bug_367.py b/sources/pyside6/tests/QtGui/bug_367.py
index eba44105c..40c0d6936 100644
--- a/sources/pyside6/tests/QtGui/bug_367.py
+++ b/sources/pyside6/tests/QtGui/bug_367.py
@@ -42,6 +42,7 @@ from PySide6.QtGui import QStandardItem, QStandardItemModel
 
 
 class BugTest(UsesQApplication):
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCase(self):
         model = QStandardItemModel()
         parentItem = model.invisibleRootItem()
diff --git a/sources/pyside6/tests/QtStateMachine/qabstracttransition_test.py b/sources/pyside6/tests/QtStateMachine/qabstracttransition_test.py
index 8c9fe6904..87f140580 100644
--- a/sources/pyside6/tests/QtStateMachine/qabstracttransition_test.py
+++ b/sources/pyside6/tests/QtStateMachine/qabstracttransition_test.py
@@ -30,7 +30,6 @@
 
 import os
 import sys
-from sys import getrefcount
 import unittest
 
 from pathlib import Path
@@ -91,107 +90,111 @@ class QAbstractTransitionTest(unittest.TestCase):
         QTimer.singleShot(100, app.quit)
         app.exec()
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCountOfTargetState(self):
         transition = QEventTransition()
         state1 = QState()
-        refcount1 = getrefcount(state1)
+        refcount1 = sys.getrefcount(state1)
 
         transition.setTargetState(state1)
 
         self.assertEqual(transition.targetState(), state1)
-        self.assertEqual(getrefcount(transition.targetState()), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(transition.targetState()), refcount1 + 1)
 
         state2 = QState()
-        refcount2 = getrefcount(state2)
+        refcount2 = sys.getrefcount(state2)
 
         transition.setTargetState(state2)
 
         self.assertEqual(transition.targetState(), state2)
-        self.assertEqual(getrefcount(transition.targetState()), refcount2 + 1)
-        self.assertEqual(getrefcount(state1), refcount1)
+        self.assertEqual(sys.getrefcount(transition.targetState()), refcount2 + 1)
+        self.assertEqual(sys.getrefcount(state1), refcount1)
 
         del transition
 
-        self.assertEqual(getrefcount(state2), refcount2)
+        self.assertEqual(sys.getrefcount(state2), refcount2)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCountOfTargetStates(self):
         transition = QEventTransition()
         state1 = QState()
         state2 = QState()
         states = [state1, state2]
-        refcount1 = getrefcount(state1)
-        refcount2 = getrefcount(state2)
+        refcount1 = sys.getrefcount(state1)
+        refcount2 = sys.getrefcount(state2)
 
         transition.setTargetStates(states)
 
         self.assertEqual(transition.targetStates(), states)
         self.assertEqual(transition.targetState(), state1)
-        self.assertEqual(getrefcount(transition.targetStates()[0]), refcount1 + 1)
-        self.assertEqual(getrefcount(transition.targetStates()[1]), refcount2 + 1)
+        self.assertEqual(sys.getrefcount(transition.targetStates()[0]), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(transition.targetStates()[1]), refcount2 + 1)
 
         del states
         del transition
 
-        self.assertEqual(getrefcount(state1), refcount1 - 1)
-        self.assertEqual(getrefcount(state2), refcount2 - 1)
+        self.assertEqual(sys.getrefcount(state1), refcount1 - 1)
+        self.assertEqual(sys.getrefcount(state2), refcount2 - 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCountOfTargetStatesAfterSingleTargetState(self):
         transition = QEventTransition()
         state0 = QState()
-        refcount0 = getrefcount(state0)
+        refcount0 = sys.getrefcount(state0)
 
         transition.setTargetState(state0)
 
         self.assertEqual(transition.targetState(), state0)
-        self.assertEqual(getrefcount(transition.targetState()), refcount0 + 1)
+        self.assertEqual(sys.getrefcount(transition.targetState()), refcount0 + 1)
 
         state1 = QState()
         state2 = QState()
         states = [state1, state2]
-        refcount1 = getrefcount(state1)
-        refcount2 = getrefcount(state2)
+        refcount1 = sys.getrefcount(state1)
+        refcount2 = sys.getrefcount(state2)
 
         transition.setTargetStates(states)
 
-        self.assertEqual(getrefcount(state0), refcount0)
+        self.assertEqual(sys.getrefcount(state0), refcount0)
         self.assertEqual(transition.targetStates(), states)
         self.assertEqual(transition.targetState(), state1)
-        self.assertEqual(getrefcount(transition.targetStates()[0]), refcount1 + 1)
-        self.assertEqual(getrefcount(transition.targetStates()[1]), refcount2 + 1)
+        self.assertEqual(sys.getrefcount(transition.targetStates()[0]), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(transition.targetStates()[1]), refcount2 + 1)
 
         del states
         del transition
 
-        self.assertEqual(getrefcount(state1), refcount1 - 1)
-        self.assertEqual(getrefcount(state2), refcount2 - 1)
+        self.assertEqual(sys.getrefcount(state1), refcount1 - 1)
+        self.assertEqual(sys.getrefcount(state2), refcount2 - 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCountOfTargetStatesBeforeSingleTargetState(self):
         transition = QEventTransition()
         state1 = QState()
         state2 = QState()
         states = [state1, state2]
-        refcount1 = getrefcount(state1)
-        refcount2 = getrefcount(state2)
+        refcount1 = sys.getrefcount(state1)
+        refcount2 = sys.getrefcount(state2)
 
         transition.setTargetStates(states)
 
         self.assertEqual(transition.targetStates(), states)
         self.assertEqual(transition.targetState(), state1)
-        self.assertEqual(getrefcount(transition.targetStates()[0]), refcount1 + 1)
-        self.assertEqual(getrefcount(transition.targetStates()[1]), refcount2 + 1)
+        self.assertEqual(sys.getrefcount(transition.targetStates()[0]), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(transition.targetStates()[1]), refcount2 + 1)
 
         state3 = QState()
-        refcount3 = getrefcount(state3)
+        refcount3 = sys.getrefcount(state3)
 
         transition.setTargetState(state3)
 
         self.assertEqual(transition.targetState(), state3)
-        self.assertEqual(getrefcount(transition.targetState()), refcount3 + 1)
+        self.assertEqual(sys.getrefcount(transition.targetState()), refcount3 + 1)
 
         del states
 
-        self.assertEqual(getrefcount(state1), refcount1 - 1)
-        self.assertEqual(getrefcount(state2), refcount2 - 1)
+        self.assertEqual(sys.getrefcount(state1), refcount1 - 1)
+        self.assertEqual(sys.getrefcount(state2), refcount2 - 1)
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/QtSvg/qsvggenerator_test.py b/sources/pyside6/tests/QtSvg/qsvggenerator_test.py
index c0d94fa17..2dd65047e 100644
--- a/sources/pyside6/tests/QtSvg/qsvggenerator_test.py
+++ b/sources/pyside6/tests/QtSvg/qsvggenerator_test.py
@@ -30,7 +30,6 @@
 
 import os
 import sys
-from sys import getrefcount
 import unittest
 
 from pathlib import Path
@@ -44,28 +43,29 @@ from PySide6.QtSvg import QSvgGenerator
 
 class QSvgGeneratorTest(unittest.TestCase):
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCountOfTOutputDevice(self):
         generator = QSvgGenerator()
         iodevice1 = QBuffer()
-        refcount1 = getrefcount(iodevice1)
+        refcount1 = sys.getrefcount(iodevice1)
 
         generator.setOutputDevice(iodevice1)
 
         self.assertEqual(generator.outputDevice(), iodevice1)
-        self.assertEqual(getrefcount(generator.outputDevice()), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(generator.outputDevice()), refcount1 + 1)
 
         iodevice2 = QBuffer()
-        refcount2 = getrefcount(iodevice2)
+        refcount2 = sys.getrefcount(iodevice2)
 
         generator.setOutputDevice(iodevice2)
 
         self.assertEqual(generator.outputDevice(), iodevice2)
-        self.assertEqual(getrefcount(generator.outputDevice()), refcount2 + 1)
-        self.assertEqual(getrefcount(iodevice1), refcount1)
+        self.assertEqual(sys.getrefcount(generator.outputDevice()), refcount2 + 1)
+        self.assertEqual(sys.getrefcount(iodevice1), refcount1)
 
         del generator
 
-        self.assertEqual(getrefcount(iodevice2), refcount2)
+        self.assertEqual(sys.getrefcount(iodevice2), refcount2)
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/QtUiTools/bug_909.py b/sources/pyside6/tests/QtUiTools/bug_909.py
index 99c80aa09..be6376735 100644
--- a/sources/pyside6/tests/QtUiTools/bug_909.py
+++ b/sources/pyside6/tests/QtUiTools/bug_909.py
@@ -43,6 +43,7 @@ from helper.usesqapplication import UsesQApplication
 
 
 class TestDestruction(UsesQApplication):
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testBug909(self):
         file = Path(__file__).resolve().parent / 'bug_909.ui'
         self.assertTrue(file.is_file())
diff --git a/sources/pyside6/tests/QtWidgets/bug_1002.py b/sources/pyside6/tests/QtWidgets/bug_1002.py
index ab9cee147..756d936ee 100644
--- a/sources/pyside6/tests/QtWidgets/bug_1002.py
+++ b/sources/pyside6/tests/QtWidgets/bug_1002.py
@@ -41,6 +41,7 @@ from helper.usesqapplication import UsesQApplication
 
 
 class TestBug1002 (UsesQApplication):
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReturnWindow(self):
         widget = QWidget()
         button = QPushButton(widget)
diff --git a/sources/pyside6/tests/QtWidgets/bug_1006.py b/sources/pyside6/tests/QtWidgets/bug_1006.py
index 9a1b7e653..81639c34c 100644
--- a/sources/pyside6/tests/QtWidgets/bug_1006.py
+++ b/sources/pyside6/tests/QtWidgets/bug_1006.py
@@ -91,6 +91,7 @@ class TestBug1006 (TimedQApplication):
         item = layout.itemAt(0)
         self.assertTrue(isinstance(item.widget(), QWidget))
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRemoveOrphanWidget(self):
         widget = QLabel()
         layout = QHBoxLayout()
@@ -101,6 +102,7 @@ class TestBug1006 (TimedQApplication):
         widget.setObjectName("MyWidget")
         self.assertEqual(sys.getrefcount(widget), 2)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRemoveChildWidget(self):
         parent = QLabel()
         widget = QLabel(parent)
diff --git a/sources/pyside6/tests/QtWidgets/bug_547.py b/sources/pyside6/tests/QtWidgets/bug_547.py
index 984a0c858..f5a321228 100644
--- a/sources/pyside6/tests/QtWidgets/bug_547.py
+++ b/sources/pyside6/tests/QtWidgets/bug_547.py
@@ -45,6 +45,7 @@ from PySide6.QtWidgets import QApplication, QTreeWidget, QTreeWidgetItem
 class MyMainWindow(unittest.TestCase):
     app = QApplication(sys.argv)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCase1(self):
         self._tree = QTreeWidget()
         self._tree.setColumnCount(2)
@@ -62,6 +63,7 @@ class MyMainWindow(unittest.TestCase):
         self.assertEqual(sys.getrefcount(self._i1), 3)
         self.assertEqual(sys.getrefcount(self._i11), 3)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCase2(self):
         self._tree = QTreeWidget()
         self._tree.setColumnCount(2)
@@ -78,6 +80,7 @@ class MyMainWindow(unittest.TestCase):
         self.assertEqual(sys.getrefcount(self._i1), 3)
         self.assertEqual(sys.getrefcount(self._i11), 3)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def _updateTree(self):
         self._tree.clear()
         if self._i1 and self._i11:
diff --git a/sources/pyside6/tests/QtWidgets/bug_576.py b/sources/pyside6/tests/QtWidgets/bug_576.py
index b148f7c89..7a078ce9d 100644
--- a/sources/pyside6/tests/QtWidgets/bug_576.py
+++ b/sources/pyside6/tests/QtWidgets/bug_576.py
@@ -48,6 +48,7 @@ class Bug576(unittest.TestCase):
         self._destroyed = True
         self.assertTrue(isinstance(button, QPushButton))
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testWidgetParent(self):
         self._destroyed = False
         app = QApplication(sys.argv)
diff --git a/sources/pyside6/tests/QtWidgets/bug_585.py b/sources/pyside6/tests/QtWidgets/bug_585.py
index 82d581af9..05a9cf3d8 100644
--- a/sources/pyside6/tests/QtWidgets/bug_585.py
+++ b/sources/pyside6/tests/QtWidgets/bug_585.py
@@ -41,6 +41,7 @@ from PySide6.QtWidgets import QApplication, QTreeWidget, QTreeWidgetItem
 
 
 class Bug585(unittest.TestCase):
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCase(self):
         app = QApplication([])
         self._tree = QTreeWidget()
diff --git a/sources/pyside6/tests/QtWidgets/bug_674.py b/sources/pyside6/tests/QtWidgets/bug_674.py
index 95e32edd1..ca66271f6 100644
--- a/sources/pyside6/tests/QtWidgets/bug_674.py
+++ b/sources/pyside6/tests/QtWidgets/bug_674.py
@@ -40,6 +40,7 @@ from PySide6.QtWidgets import QApplication, QGraphicsScene
 
 class TestBug679(unittest.TestCase):
     '''QGraphicsScene::clear() is missing'''
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testIt(self):
         app = QApplication([])
 
diff --git a/sources/pyside6/tests/QtWidgets/bug_811.py b/sources/pyside6/tests/QtWidgets/bug_811.py
index 38fbd652c..bfcd30f05 100644
--- a/sources/pyside6/tests/QtWidgets/bug_811.py
+++ b/sources/pyside6/tests/QtWidgets/bug_811.py
@@ -49,6 +49,7 @@ class TestUserData(QTextBlockUserData):
 
 
 class TestUserDataRefCount(UsesQApplication):
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefcount(self):
         textedit = QTextEdit()
         textedit.setReadOnly(True)
diff --git a/sources/pyside6/tests/QtWidgets/event_filter_test.py b/sources/pyside6/tests/QtWidgets/event_filter_test.py
index aee5a2926..08ca8c7b3 100644
--- a/sources/pyside6/tests/QtWidgets/event_filter_test.py
+++ b/sources/pyside6/tests/QtWidgets/event_filter_test.py
@@ -48,6 +48,7 @@ class MyFilter(QObject):
 
 
 class EventFilter(UsesQApplication):
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCount(self):
         o = QObject()
         filt = MyFilter()
diff --git a/sources/pyside6/tests/QtWidgets/keep_reference_test.py b/sources/pyside6/tests/QtWidgets/keep_reference_test.py
index 1766f16ee..9c661feeb 100644
--- a/sources/pyside6/tests/QtWidgets/keep_reference_test.py
+++ b/sources/pyside6/tests/QtWidgets/keep_reference_test.py
@@ -37,7 +37,6 @@ sys.path.append(os.fspath(Path(__file__).resolve().parents[1]))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-from sys import getrefcount
 from helper.usesqapplication import UsesQApplication
 from PySide6.QtCore import QAbstractTableModel
 from PySide6.QtWidgets import QTableView
@@ -73,32 +72,34 @@ class KeepReferenceTest(UsesQApplication):
         samemodel = view.model()
         self.assertEqual(model, samemodel)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReferenceCounting(self):
         '''Tests reference count of model object referred by view objects.'''
         model1 = TestModel()
-        refcount1 = getrefcount(model1)
+        refcount1 = sys.getrefcount(model1)
         view1 = QTableView()
         view1.setModel(model1)
-        self.assertEqual(getrefcount(view1.model()), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(view1.model()), refcount1 + 1)
 
         view2 = QTableView()
         view2.setModel(model1)
-        self.assertEqual(getrefcount(view2.model()), refcount1 + 2)
+        self.assertEqual(sys.getrefcount(view2.model()), refcount1 + 2)
 
         model2 = TestModel()
         view2.setModel(model2)
-        self.assertEqual(getrefcount(view1.model()), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(view1.model()), refcount1 + 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReferenceCountingWhenDeletingReferrer(self):
         '''Tests reference count of model object referred by deceased view object.'''
         model = TestModel()
-        refcount1 = getrefcount(model)
+        refcount1 = sys.getrefcount(model)
         view = QTableView()
         view.setModel(model)
-        self.assertEqual(getrefcount(view.model()), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(view.model()), refcount1 + 1)
 
         del view
-        self.assertEqual(getrefcount(model), refcount1)
+        self.assertEqual(sys.getrefcount(model), refcount1)
 
     def testReferreedObjectSurvivalAfterContextEnd(self):
         '''Model object assigned to a view object must survive after getting out of context.'''
diff --git a/sources/pyside6/tests/QtWidgets/qlayout_ref_test.py b/sources/pyside6/tests/QtWidgets/qlayout_ref_test.py
index 255119562..e7e61e75a 100644
--- a/sources/pyside6/tests/QtWidgets/qlayout_ref_test.py
+++ b/sources/pyside6/tests/QtWidgets/qlayout_ref_test.py
@@ -30,7 +30,6 @@
 
 import os
 import sys
-from sys import getrefcount
 import unittest
 
 from pathlib import Path
@@ -64,28 +63,30 @@ class SaveReference(UsesQApplication):
         del self.widget1
         super(SaveReference, self).tearDown()
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def checkLayoutReference(self, layout):
         # Checks the reference cound handling of layout.addWidget
-        self.assertEqual(getrefcount(self.widget1), 2)
+        self.assertEqual(sys.getrefcount(self.widget1), 2)
         layout.addWidget(self.widget1)
-        self.assertEqual(getrefcount(self.widget1), 3)
+        self.assertEqual(sys.getrefcount(self.widget1), 3)
 
-        self.assertEqual(getrefcount(self.widget2), 2)
+        self.assertEqual(sys.getrefcount(self.widget2), 2)
         layout.addWidget(self.widget2)
-        self.assertEqual(getrefcount(self.widget2), 3)
+        self.assertEqual(sys.getrefcount(self.widget2), 3)
 
         # Check if doesn't mess around with previous widget refcount
-        self.assertEqual(getrefcount(self.widget1), 3)
+        self.assertEqual(sys.getrefcount(self.widget1), 3)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testMoveLayout(self):
         l = QHBoxLayout()
-        self.assertEqual(getrefcount(self.widget1), 2)
+        self.assertEqual(sys.getrefcount(self.widget1), 2)
         l.addWidget(self.widget1)
-        self.assertEqual(getrefcount(self.widget1), 3)
+        self.assertEqual(sys.getrefcount(self.widget1), 3)
 
         w = QWidget()
         w.setLayout(l)
-        self.assertEqual(getrefcount(self.widget1), 3)
+        self.assertEqual(sys.getrefcount(self.widget1), 3)
 
     def testHBoxReference(self):
         # QHBoxLayout.addWidget reference count
@@ -133,18 +134,20 @@ class MultipleAdd(UsesQApplication):
         del self.win
         super(MultipleAdd, self).tearDown()
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCount(self):
         # Multiple QLayout.addWidget calls on the same widget
-        self.assertEqual(getrefcount(self.widget), 2)
+        self.assertEqual(sys.getrefcount(self.widget), 2)
         self.layout.addWidget(self.widget)
-        self.assertEqual(getrefcount(self.widget), 3)
+        self.assertEqual(sys.getrefcount(self.widget), 3)
         self.layout.addWidget(self.widget)
-        self.assertEqual(getrefcount(self.widget), 3)
+        self.assertEqual(sys.getrefcount(self.widget), 3)
         self.layout.addWidget(self.widget)
-        self.assertEqual(getrefcount(self.widget), 3)
+        self.assertEqual(sys.getrefcount(self.widget), 3)
 
 
 class InternalAdd(UsesQApplication):
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testInternalRef(self):
         mw = QWidget()
         w = QWidget()
@@ -153,35 +156,35 @@ class InternalAdd(UsesQApplication):
         topLayout = QGridLayout()
 
         # unique reference
-        self.assertEqual(getrefcount(w), 2)
-        self.assertEqual(getrefcount(ow), 2)
+        self.assertEqual(sys.getrefcount(w), 2)
+        self.assertEqual(sys.getrefcount(ow), 2)
 
         topLayout.addWidget(w, 0, 0)
         topLayout.addWidget(ow, 1, 0)
 
         # layout keep the referemce
-        self.assertEqual(getrefcount(w), 3)
-        self.assertEqual(getrefcount(ow), 3)
+        self.assertEqual(sys.getrefcount(w), 3)
+        self.assertEqual(sys.getrefcount(ow), 3)
 
         mainLayout = QGridLayout()
 
         mainLayout.addLayout(topLayout, 1, 0, 1, 4)
 
         # the same reference
-        self.assertEqual(getrefcount(w), 3)
-        self.assertEqual(getrefcount(ow), 3)
+        self.assertEqual(sys.getrefcount(w), 3)
+        self.assertEqual(sys.getrefcount(ow), 3)
 
         mw.setLayout(mainLayout)
 
         # now trasfer the ownership to mw
-        self.assertEqual(getrefcount(w), 3)
-        self.assertEqual(getrefcount(ow), 3)
+        self.assertEqual(sys.getrefcount(w), 3)
+        self.assertEqual(sys.getrefcount(ow), 3)
 
         del mw
 
         # remove the ref and invalidate the widget
-        self.assertEqual(getrefcount(w), 2)
-        self.assertEqual(getrefcount(ow), 2)
+        self.assertEqual(sys.getrefcount(w), 2)
+        self.assertEqual(sys.getrefcount(ow), 2)
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/QtWidgets/qlayout_test.py b/sources/pyside6/tests/QtWidgets/qlayout_test.py
index 4230470b7..57855fc05 100644
--- a/sources/pyside6/tests/QtWidgets/qlayout_test.py
+++ b/sources/pyside6/tests/QtWidgets/qlayout_test.py
@@ -89,6 +89,7 @@ class MissingItemAtLayout(QLayout):
 
 
 class QLayoutTest(UsesQApplication):
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testOwnershipTransfer(self):
         b = QPushButton("teste")
         l = MyLayout()
@@ -104,6 +105,7 @@ class QLayoutTest(UsesQApplication):
 
         self.assertEqual(sys.getrefcount(b), 3)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReferenceTransfer(self):
         b = QPushButton("teste")
         l = QHBoxLayout()
diff --git a/sources/pyside6/tests/QtWidgets/qlistwidget_test.py b/sources/pyside6/tests/QtWidgets/qlistwidget_test.py
index 3746d3675..d5b82070b 100644
--- a/sources/pyside6/tests/QtWidgets/qlistwidget_test.py
+++ b/sources/pyside6/tests/QtWidgets/qlistwidget_test.py
@@ -42,6 +42,7 @@ from helper.usesqapplication import UsesQApplication
 
 class QListWidgetTest(UsesQApplication):
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def populateList(self, lst):
         o = QObject()
         o.setObjectName("obj")
@@ -54,10 +55,12 @@ class QListWidgetTest(UsesQApplication):
         lst.addItem(item)
         self.assertTrue(sys.getrefcount(item), 3)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def checkCurrentItem(self, lst):
         item = lst.currentItem()
         self.assertTrue(sys.getrefcount(item), 3)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def checkItemData(self, lst):
         item = lst.currentItem()
         o = item.data(Qt.UserRole)
@@ -65,6 +68,7 @@ class QListWidgetTest(UsesQApplication):
         self.assertEqual(o, item._data)
         self.assertTrue(sys.getrefcount(o), 2)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testConstructorWithParent(self):
         lst = QListWidget()
         self.populateList(lst)
diff --git a/sources/pyside6/tests/QtWidgets/qmainwindow_test.py b/sources/pyside6/tests/QtWidgets/qmainwindow_test.py
index 5d6018b28..5201bfdb8 100644
--- a/sources/pyside6/tests/QtWidgets/qmainwindow_test.py
+++ b/sources/pyside6/tests/QtWidgets/qmainwindow_test.py
@@ -73,6 +73,7 @@ class TestMainWindow(UsesQApplication):
     def objDel(self, obj):
         self.app.quit()
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCountToNull(self):
         w = QMainWindow()
         c = QWidget()
@@ -84,6 +85,7 @@ class TestMainWindow(UsesQApplication):
         c = None
         self.app.exec()
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCountToAnother(self):
         w = QMainWindow()
         c = QWidget()
diff --git a/sources/pyside6/tests/QtWidgets/qstandarditemmodel_test.py b/sources/pyside6/tests/QtWidgets/qstandarditemmodel_test.py
index ddc9d2245..97fe18119 100644
--- a/sources/pyside6/tests/QtWidgets/qstandarditemmodel_test.py
+++ b/sources/pyside6/tests/QtWidgets/qstandarditemmodel_test.py
@@ -66,6 +66,7 @@ class QStandardItemModelTest(UsesQApplication):
 
 
 class QStandardItemModelRef(UsesQApplication):
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCount(self):
         model = QStandardItemModel(5, 5)
         items = []
diff --git a/sources/pyside6/tests/QtWidgets/qstyle_test.py b/sources/pyside6/tests/QtWidgets/qstyle_test.py
index 6993e8b90..1f837cda6 100644
--- a/sources/pyside6/tests/QtWidgets/qstyle_test.py
+++ b/sources/pyside6/tests/QtWidgets/qstyle_test.py
@@ -88,6 +88,7 @@ class SetStyleTest(UsesQApplication):
             QApplication.instance().processEvents()
         self.assertTrue(proxyStyle.polished > 0)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testSetStyleOwnership(self):
         style = QStyleFactory.create(QStyleFactory.keys()[0])
         self.assertEqual(sys.getrefcount(style), 2)
diff --git a/sources/pyside6/tests/QtWidgets/qtextedit_test.py b/sources/pyside6/tests/QtWidgets/qtextedit_test.py
index 28f435f94..bb6b98009 100644
--- a/sources/pyside6/tests/QtWidgets/qtextedit_test.py
+++ b/sources/pyside6/tests/QtWidgets/qtextedit_test.py
@@ -30,7 +30,6 @@
 
 import os
 import sys
-from sys import getrefcount
 import unittest
 
 from pathlib import Path
@@ -53,16 +52,17 @@ class DontTouchReference(UsesQApplication):
         self.cursor = self.editor.textCursor()
         self.table = self.cursor.insertTable(1, 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testQTextTable(self):
         # methods which return QTextTable should not increment its reference
-        self.assertEqual(getrefcount(self.table), 2)
+        self.assertEqual(sys.getrefcount(self.table), 2)
         f = self.cursor.currentFrame()
         del f
-        self.assertEqual(getrefcount(self.table), 2)
+        self.assertEqual(sys.getrefcount(self.table), 2)
         # destroying the cursor should not raise any "RuntimeError: internal
         # C++ object already deleted." when accessing the QTextTable
         del self.cursor
-        self.assertEqual(getrefcount(self.table), 2)
+        self.assertEqual(sys.getrefcount(self.table), 2)
         cell = self.table.cellAt(0, 0)
 
 
diff --git a/sources/pyside6/tests/QtWidgets/reference_count_test.py b/sources/pyside6/tests/QtWidgets/reference_count_test.py
index 00ebab4c3..92c63fac8 100644
--- a/sources/pyside6/tests/QtWidgets/reference_count_test.py
+++ b/sources/pyside6/tests/QtWidgets/reference_count_test.py
@@ -68,6 +68,7 @@ class ReferenceCount(UsesQApplication):
     def tearDown(self):
         super(ReferenceCount, self).tearDown()
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def beforeTest(self):
         points = [QPointF(0, 0), QPointF(100, 100), QPointF(0, 100)]
         pol = self.scene.addPolygon(QPolygonF(points))
@@ -77,6 +78,7 @@ class ReferenceCount(UsesQApplication):
         # refcount need be 3 because one ref for QGraphicsScene, and one to rect obj
         self.assertEqual(sys.getrefcount(pol), 3)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReferenceCount(self):
         global destroyedRect
         global destroyedPol
diff --git a/sources/pyside6/tests/signals/ref03_test.py b/sources/pyside6/tests/signals/ref03_test.py
index 01fba47f9..8274c9439 100644
--- a/sources/pyside6/tests/signals/ref03_test.py
+++ b/sources/pyside6/tests/signals/ref03_test.py
@@ -31,7 +31,6 @@
 
 import os
 import sys
-from sys import getrefcount
 import unittest
 
 from pathlib import Path
@@ -50,16 +49,17 @@ class DisconnectSignalsTest(unittest.TestCase):
     def tearDown(self):
         del self.emitter
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testConnectionRefCount(self):
 
         def destroyedSlot():
             pass
 
-        self.assertEqual(getrefcount(destroyedSlot), 2)
+        self.assertEqual(sys.getrefcount(destroyedSlot), 2)
         self.emitter.destroyed.connect(destroyedSlot)
-        self.assertEqual(getrefcount(destroyedSlot), 3)
+        self.assertEqual(sys.getrefcount(destroyedSlot), 3)
         self.emitter.destroyed.disconnect(destroyedSlot)
-        self.assertEqual(getrefcount(destroyedSlot), 2)
+        self.assertEqual(sys.getrefcount(destroyedSlot), 2)
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/signals/signal_manager_refcount_test.py b/sources/pyside6/tests/signals/signal_manager_refcount_test.py
index c3170f7a2..88f0a8a14 100644
--- a/sources/pyside6/tests/signals/signal_manager_refcount_test.py
+++ b/sources/pyside6/tests/signals/signal_manager_refcount_test.py
@@ -31,7 +31,6 @@
 
 import os
 import sys
-from sys import getrefcount
 import unittest
 
 from pathlib import Path
@@ -45,16 +44,17 @@ from PySide6.QtCore import QObject, SIGNAL
 class SignalManagerRefCount(unittest.TestCase):
     """Simple test case to check if the signal_manager is erroneously incrementing the object refcounter"""
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testObjectRefcount(self):
         """Emission of QObject.destroyed() to a python slot"""
         def callback():
             pass
         obj = QObject()
-        refcount = getrefcount(obj)
+        refcount = sys.getrefcount(obj)
         obj.destroyed.connect(callback)
-        self.assertEqual(refcount, getrefcount(obj))
+        self.assertEqual(refcount, sys.getrefcount(obj))
         QObject.disconnect(obj, SIGNAL('destroyed()'), callback)
-        self.assertEqual(refcount, getrefcount(obj))
+        self.assertEqual(refcount, sys.getrefcount(obj))
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside6/tests/signals/slot_reference_count_test.py b/sources/pyside6/tests/signals/slot_reference_count_test.py
index 54b904f42..5ab8ca6e9 100644
--- a/sources/pyside6/tests/signals/slot_reference_count_test.py
+++ b/sources/pyside6/tests/signals/slot_reference_count_test.py
@@ -30,7 +30,6 @@
 
 import os
 import sys
-from sys import getrefcount
 import unittest
 
 from pathlib import Path
@@ -54,17 +53,18 @@ class PythonSignalRefCount(unittest.TestCase):
     def tearDown(self):
         self.emitter
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCount(self):
         def cb(*args):
             pass
 
-        self.assertEqual(getrefcount(cb), 2)
+        self.assertEqual(sys.getrefcount(cb), 2)
 
         QObject.connect(self.emitter, SIGNAL('foo()'), cb)
-        self.assertEqual(getrefcount(cb), 3)
+        self.assertEqual(sys.getrefcount(cb), 3)
 
         QObject.disconnect(self.emitter, SIGNAL('foo()'), cb)
-        self.assertEqual(getrefcount(cb), 2)
+        self.assertEqual(sys.getrefcount(cb), 2)
 
 
 class CppSignalRefCount(unittest.TestCase):
@@ -75,17 +75,18 @@ class CppSignalRefCount(unittest.TestCase):
     def tearDown(self):
         self.emitter
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCount(self):
         def cb(*args):
             pass
 
-        self.assertEqual(getrefcount(cb), 2)
+        self.assertEqual(sys.getrefcount(cb), 2)
 
         self.emitter.destroyed.connect(cb)
-        self.assertEqual(getrefcount(cb), 3)
+        self.assertEqual(sys.getrefcount(cb), 3)
 
         QObject.disconnect(self.emitter, SIGNAL('destroyed()'), cb)
-        self.assertEqual(getrefcount(cb), 2)
+        self.assertEqual(sys.getrefcount(cb), 2)
 
 
 if __name__ == '__main__':
diff --git a/sources/shiboken6/tests/samplebinding/class_fields_test.py b/sources/shiboken6/tests/samplebinding/class_fields_test.py
index a29c84b1a..44d32ce39 100644
--- a/sources/shiboken6/tests/samplebinding/class_fields_test.py
+++ b/sources/shiboken6/tests/samplebinding/class_fields_test.py
@@ -33,7 +33,6 @@
 
 import os
 import sys
-from sys import getrefcount
 import unittest
 
 from pathlib import Path
@@ -141,34 +140,38 @@ class TestAccessingCppFields(unittest.TestCase):
         # attribution with invalid type
         self.assertRaises(TypeError, lambda : setattr(d, 'objectTypeField', 123))
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCountingAccessingObjectTypeField(self):
         '''Accessing a object type field should respect the reference counting rules.'''
         d = Derived()
 
         # attributing object to instance's field should increase its reference count
         o1 = ObjectType()
-        refcount1 = getrefcount(o1)
+        refcount1 = sys.getrefcount(o1)
         d.objectTypeField = o1
         self.assertEqual(d.objectTypeField, o1)
-        self.assertEqual(getrefcount(d.objectTypeField), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(d.objectTypeField), refcount1 + 1)
 
-        # attributing a new object to instance's field should decrease the previous object's reference count
+        # attributing a new object to instance's field should decrease the previous
+        # object's reference count
         o2 = ObjectType()
-        refcount2 = getrefcount(o2)
+        refcount2 = sys.getrefcount(o2)
         d.objectTypeField = o2
         self.assertEqual(d.objectTypeField, o2)
-        self.assertEqual(getrefcount(o1), refcount1)
-        self.assertEqual(getrefcount(d.objectTypeField), refcount2 + 1)
+        self.assertEqual(sys.getrefcount(o1), refcount1)
+        self.assertEqual(sys.getrefcount(d.objectTypeField), refcount2 + 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRefCountingOfReferredObjectAfterDeletingReferrer(self):
-        '''Deleting the object referring to other object should decrease the reference count of the referee.'''
+        '''Deleting the object referring to other object should decrease the
+        reference count of the referee.'''
         d = Derived()
         o = ObjectType()
-        refcount = getrefcount(o)
+        refcount = sys.getrefcount(o)
         d.objectTypeField = o
-        self.assertEqual(getrefcount(o), refcount + 1)
+        self.assertEqual(sys.getrefcount(o), refcount + 1)
         del d
-        self.assertEqual(getrefcount(o), refcount)
+        self.assertEqual(sys.getrefcount(o), refcount)
 
     def testStaticField(self):
         self.assertEqual(Derived.staticPrimitiveField, 0)
diff --git a/sources/shiboken6/tests/samplebinding/keep_reference_test.py b/sources/shiboken6/tests/samplebinding/keep_reference_test.py
index b68b52e9d..8e900489d 100644
--- a/sources/shiboken6/tests/samplebinding/keep_reference_test.py
+++ b/sources/shiboken6/tests/samplebinding/keep_reference_test.py
@@ -33,7 +33,6 @@
 
 import os
 import sys
-from sys import getrefcount
 import unittest
 
 from pathlib import Path
@@ -46,32 +45,34 @@ from sample import ObjectModel, ObjectView
 class TestKeepReference(unittest.TestCase):
     '''Test case for objects that keep references to other object without owning them (e.g. model/view relationships).'''
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReferenceCounting(self):
         '''Tests reference count of model-like object referred by view-like objects.'''
         model1 = ObjectModel()
-        refcount1 = getrefcount(model1)
+        refcount1 = sys.getrefcount(model1)
         view1 = ObjectView()
         view1.setModel(model1)
-        self.assertEqual(getrefcount(view1.model()), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(view1.model()), refcount1 + 1)
 
         view2 = ObjectView()
         view2.setModel(model1)
-        self.assertEqual(getrefcount(view2.model()), refcount1 + 2)
+        self.assertEqual(sys.getrefcount(view2.model()), refcount1 + 2)
 
         model2 = ObjectModel()
         view2.setModel(model2)
-        self.assertEqual(getrefcount(view1.model()), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(view1.model()), refcount1 + 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReferenceCountingWhenDeletingReferrer(self):
         '''Tests reference count of model-like object referred by deceased view-like object.'''
         model = ObjectModel()
-        refcount1 = getrefcount(model)
+        refcount1 = sys.getrefcount(model)
         view = ObjectView()
         view.setModel(model)
-        self.assertEqual(getrefcount(view.model()), refcount1 + 1)
+        self.assertEqual(sys.getrefcount(view.model()), refcount1 + 1)
 
         del view
-        self.assertEqual(getrefcount(model), refcount1)
+        self.assertEqual(sys.getrefcount(model), refcount1)
 
     def testReferreedObjectSurvivalAfterContextEnd(self):
         '''Model-like object assigned to a view-like object must survive after get out of context.'''
diff --git a/sources/shiboken6/tests/samplebinding/multiple_derived_test.py b/sources/shiboken6/tests/samplebinding/multiple_derived_test.py
index 08a13445d..0c40a4fd1 100644
--- a/sources/shiboken6/tests/samplebinding/multiple_derived_test.py
+++ b/sources/shiboken6/tests/samplebinding/multiple_derived_test.py
@@ -92,6 +92,7 @@ class MultipleDerivedTest(unittest.TestCase):
         self.assertTrue(issubclass(ExtMDerived1, Base1))
         self.assertTrue(issubclass(ExtMDerived1, Base2))
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived1ToBases(self):
         '''MDerived1 is casted by C++ to its parents and the binding must return the MDerived1 wrapper.'''
         a = MDerived1()
@@ -104,6 +105,7 @@ class MultipleDerivedTest(unittest.TestCase):
         self.assertEqual(a, b2)
         self.assertEqual(sys.getrefcount(a), refcnt + 2)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromExtMDerived1ToMDerived1Bases(self):
         '''Python defined class ExtMDerived1 is casted by C++ to MDerived1 parents and the binding must return the correct ExtMDerived1 instance.'''
         a = ExtMDerived1()
@@ -118,6 +120,7 @@ class MultipleDerivedTest(unittest.TestCase):
         self.assertEqual(a, b2)
         self.assertEqual(sys.getrefcount(a), refcnt + 2)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromSonOfMDerived1ToBases(self):
         '''SonOfMDerived1 is casted by C++ to its parents and the binding must return the SonOfMDerived1 wrapper.'''
         a = SonOfMDerived1()
@@ -138,6 +141,7 @@ class MultipleDerivedTest(unittest.TestCase):
         value = a.base2Method()
         self.assertTrue(value, Base2.base2Method(a) * a.multiplier)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived2ToBases(self):
         '''MDerived2 is casted by C++ to its parents and the binding must return the MDerived2 wrapper.'''
         a = MDerived2()
@@ -156,6 +160,7 @@ class MultipleDerivedTest(unittest.TestCase):
         self.assertEqual(a, b6)
         self.assertEqual(sys.getrefcount(a), refcnt + 4)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived3ToBases(self):
         '''MDerived3 is casted by C++ to its parents and the binding must return the MDerived3 wrapper.'''
         a = MDerived3()
@@ -186,6 +191,7 @@ class MultipleDerivedTest(unittest.TestCase):
         self.assertEqual(a, b6)
         self.assertEqual(sys.getrefcount(a), refcnt + 8)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived4ToBases(self):
         '''MDerived4 is casted by C++ to its parents and the binding must return the MDerived4 wrapper.'''
         a = MDerived4()
@@ -198,6 +204,7 @@ class MultipleDerivedTest(unittest.TestCase):
         self.assertEqual(a, b4)
         self.assertEqual(sys.getrefcount(a), refcnt + 2)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived5ToBases(self):
         '''MDerived5 is casted by C++ to its parents and the binding must return the MDerived5 wrapper.'''
         a = MDerived5()
@@ -210,6 +217,7 @@ class MultipleDerivedTest(unittest.TestCase):
         self.assertEqual(a, b4)
         self.assertEqual(sys.getrefcount(a), refcnt + 2)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testCastFromMDerived3ToBase3(self):
         '''MDerived3 is casted by C++ to Base3 grandparent using both the inherited and reimplement castToBase3 methods.'''
         a = MDerived3()
diff --git a/sources/shiboken6/tests/samplebinding/objecttype_test.py b/sources/shiboken6/tests/samplebinding/objecttype_test.py
index fb655c435..58036a458 100644
--- a/sources/shiboken6/tests/samplebinding/objecttype_test.py
+++ b/sources/shiboken6/tests/samplebinding/objecttype_test.py
@@ -75,6 +75,7 @@ class ObjectTypeTest(unittest.TestCase):
         o.setNullObject(None)
         self.assertEqual(o.callId(), 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testParentFromCpp(self):
         o = ObjectType()
         self.assertEqual(sys.getrefcount(o), 2)
@@ -113,6 +114,7 @@ class ObjectTypeTest(unittest.TestCase):
 
         Shiboken.invalidate(parents)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testClassDecref(self):
         # Bug was that class PyTypeObject wasn't decrefed when instance died
         before = sys.getrefcount(ObjectType)
diff --git a/sources/shiboken6/tests/samplebinding/objecttypelayout_test.py b/sources/shiboken6/tests/samplebinding/objecttypelayout_test.py
index 76f028f51..10b2f0ca9 100644
--- a/sources/shiboken6/tests/samplebinding/objecttypelayout_test.py
+++ b/sources/shiboken6/tests/samplebinding/objecttypelayout_test.py
@@ -46,6 +46,7 @@ from sample import *
 class ObjectTypeLayoutTest(unittest.TestCase):
     '''Test cases for ObjectTypeLayout class.'''
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testOwnershipOverride(self):
         l = ObjectTypeLayout()
 
diff --git a/sources/shiboken6/tests/samplebinding/ownership_delete_parent_test.py b/sources/shiboken6/tests/samplebinding/ownership_delete_parent_test.py
index 1f0d76cce..310bf08ee 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_delete_parent_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_delete_parent_test.py
@@ -46,6 +46,7 @@ from sample import ObjectType
 class DeleteParentTest(unittest.TestCase):
     '''Test case for deleting a parent object'''
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testParentDestructor(self):
         '''Delete parent object should invalidate child'''
         parent = ObjectType()
@@ -58,6 +59,7 @@ class DeleteParentTest(unittest.TestCase):
         self.assertRaises(RuntimeError, child.objectName)
         self.assertEqual(sys.getrefcount(child), refcount_before-1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testParentDestructorMultipleChildren(self):
         '''Delete parent object should invalidate all children'''
         parent = ObjectType()
@@ -71,6 +73,7 @@ class DeleteParentTest(unittest.TestCase):
             self.assertRaises(RuntimeError, child.objectName)
             self.assertEqual(sys.getrefcount(child), 4)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testRecursiveParentDelete(self):
         '''Delete parent should invalidate grandchildren'''
         parent = ObjectType()
diff --git a/sources/shiboken6/tests/samplebinding/ownership_reparenting_test.py b/sources/shiboken6/tests/samplebinding/ownership_reparenting_test.py
index d0b363790..0a5718429 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_reparenting_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_reparenting_test.py
@@ -65,6 +65,7 @@ class ReparentingTest(unittest.TestCase):
         for child in new_parent.children():
             self.assertTrue(child in object_list)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReparentWithTheSameParent(self):
         '''Set the same parent twice to check if the ref continue the same'''
         obj = ObjectType()
diff --git a/sources/shiboken6/tests/samplebinding/ownership_transference_test.py b/sources/shiboken6/tests/samplebinding/ownership_transference_test.py
index 3cea6b3fb..9d9492e29 100644
--- a/sources/shiboken6/tests/samplebinding/ownership_transference_test.py
+++ b/sources/shiboken6/tests/samplebinding/ownership_transference_test.py
@@ -45,6 +45,7 @@ from sample import ObjectType, BlackBox
 class BlackBoxTest(unittest.TestCase):
     '''The BlackBox class has cases of ownership transference between C++ and Python.'''
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testOwnershipTransference(self):
         '''Ownership transference from Python to C++ and back again.'''
         o1 = ObjectType()
@@ -77,6 +78,7 @@ class BlackBoxTest(unittest.TestCase):
         o3 = bb.retrieveObjectType(-5)
         self.assertEqual(o3, None)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testOwnershipTransferenceCppCreated(self):
         '''Ownership transference using a C++ created object.'''
         o1 = ObjectType.create()
diff --git a/sources/shiboken6/tests/samplebinding/point_test.py b/sources/shiboken6/tests/samplebinding/point_test.py
index bffaba6df..457df0c16 100644
--- a/sources/shiboken6/tests/samplebinding/point_test.py
+++ b/sources/shiboken6/tests/samplebinding/point_test.py
@@ -84,6 +84,7 @@ class PointTest(unittest.TestCase):
         pt2 += pt1
         self.assertFalse(pt1 == pt2)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReturnConstPointer(self):
         '''Point returns a const pointer for itself.'''
         pt1 = Point(5.0, 2.3)
diff --git a/sources/shiboken6/tests/samplebinding/pointerholder_test.py b/sources/shiboken6/tests/samplebinding/pointerholder_test.py
index 3468ceedc..d34ee7355 100644
--- a/sources/shiboken6/tests/samplebinding/pointerholder_test.py
+++ b/sources/shiboken6/tests/samplebinding/pointerholder_test.py
@@ -52,6 +52,7 @@ class TestPointerHolder(unittest.TestCase):
         ph = PointerHolder(a)
         self.assertEqual(ph.pointer(), a)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testReferenceCounting(self):
         '''Test reference counting when retrieving data with PointerHolder.pointer().'''
         a = (1, 2, 3)
diff --git a/sources/shiboken6/tests/samplebinding/privatector_test.py b/sources/shiboken6/tests/samplebinding/privatector_test.py
index c5f7ee58a..b06c65944 100644
--- a/sources/shiboken6/tests/samplebinding/privatector_test.py
+++ b/sources/shiboken6/tests/samplebinding/privatector_test.py
@@ -67,6 +67,7 @@ class PrivateCtorTest(unittest.TestCase):
         self.assertEqual(pd2, pd1)
         self.assertEqual(pd2.instanceCalls(), calls + 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testPrivateCtorRefCounting(self):
         '''Test refcounting of the singleton returned by PrivateCtor.instance().'''
         pd1 = PrivateCtor.instance()
diff --git a/sources/shiboken6/tests/samplebinding/privatedtor_test.py b/sources/shiboken6/tests/samplebinding/privatedtor_test.py
index f310ec51d..2f3b28069 100644
--- a/sources/shiboken6/tests/samplebinding/privatedtor_test.py
+++ b/sources/shiboken6/tests/samplebinding/privatedtor_test.py
@@ -68,6 +68,7 @@ class PrivateDtorTest(unittest.TestCase):
         self.assertEqual(pd2, pd1)
         self.assertEqual(pd2.instanceCalls(), calls + 1)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testPrivateDtorRefCounting(self):
         '''Test refcounting of the singleton returned by PrivateDtor.instance().'''
         pd1 = PrivateDtor.instance()
@@ -86,6 +87,7 @@ class PrivateDtorTest(unittest.TestCase):
         self.assertEqual(pd3.instanceCalls(), calls + 2)
         self.assertEqual(sys.getrefcount(pd3), refcnt)
 
+    @unittest.skipUnless(hasattr(sys, "getrefcount"), f"{sys.implementation.name} has no refcount")
     def testClassDecref(self):
         # Bug was that class PyTypeObject wasn't decrefed when instance
         # was invalidated