@@ -741,7 +741,6 @@ def __setattr__(self, name, value) -> None:
         with self.assertRaisesRegex(AttributeError, error_msg):
             del B().z
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def testConstructorErrorMessages(self):
         # bpo-31506: Improves the error message logic for object_new & object_init
 
 
@@ -1853,7 +1853,6 @@ class C(list):
             __new__ = object.__new__
         self.assertRaises(TypeError, C)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_object_new(self):
         class A(object):
             pass
 
@@ -125,24 +125,36 @@ impl Initializer for PyBaseObject {
         }
 
         let typ = zelf.class();
-        let object_type = &vm.ctx.types.object_type;
+        let object_type = vm.ctx.types.object_type;
 
         let typ_init = typ.slots.init.load().map(|f| f as usize);
         let object_init = object_type.slots.init.load().map(|f| f as usize);
 
         // if (type->tp_init != object_init) → first error
-        if typ_init != object_init {
+        // Note: typ_init can be None due to SLOTDEFINED check in copyslot_if_none,
+        // which means the slot was not explicitly defined. Treat None as equivalent
+        // to object's init (i.e., inherited but not overridden).
+        if typ_init.is_some() && typ_init != object_init {
             return Err(vm.new_type_error(
                 "object.__init__() takes exactly one argument (the instance to initialize)"
                     .to_owned(),
             ));
         }
 
-        let typ_new = typ.slots.new.load().map(|f| f as usize);
-        let object_new = object_type.slots.new.load().map(|f| f as usize);
-
         // if (type->tp_new == object_new) → second error
-        if typ_new == object_new {
+        // Can't compare slot pointers for __new__ because update_one_slot
+        // unconditionally sets new_wrapper for all heap types. Instead, check
+        // if any non-object class in the MRO defines __new__ in its own dict.
+        // This is safe because add_operators skips __new__ — only types that
+        // explicitly define __new__ have it in their dict.
+        let has_custom_new = typ.mro.read().iter().any(|cls| {
+            !cls.is(object_type)
+                && cls
+                    .attributes
+                    .read()
+                    .contains_key(identifier!(vm, __new__))
+        });
+        if !has_custom_new {
             return Err(vm.new_type_error(format!(
                 "{}.__init__() takes exactly one argument (the instance to initialize)",
                 typ.name()