diff --git a/src/main/java/org/springframework/data/mapping/PreferredConstructor.java b/src/main/java/org/springframework/data/mapping/PreferredConstructor.java
index 8b0cb8273d..94cf5cfd21 100644
--- a/src/main/java/org/springframework/data/mapping/PreferredConstructor.java
+++ b/src/main/java/org/springframework/data/mapping/PreferredConstructor.java
@@ -20,7 +20,7 @@
 import java.util.List;
 
 import org.springframework.core.annotation.MergedAnnotations;
-import org.springframework.data.annotation.PersistenceConstructor;
+import org.springframework.data.annotation.PersistenceCreator;
 import org.springframework.util.Assert;
 import org.springframework.util.ReflectionUtils;
 
@@ -34,6 +34,7 @@
  * @author Mark Paluch
  * @author Myeonghyeon Lee
  * @author Xeno Amess
+ * @author Pavel Anisimov
  */
 public final class PreferredConstructor<T, P extends PersistentProperty<P>> extends InstanceCreatorMetadataSupport<T, P> {
 
@@ -75,12 +76,12 @@ public boolean isNoArgConstructor() {
 	}
 
 	/**
-	 * Returns whether the constructor was explicitly selected (by {@link PersistenceConstructor}).
+	 * Returns whether the constructor was explicitly selected (by {@link PersistenceCreator}).
 	 *
 	 * @return
 	 */
 	public boolean isExplicitlyAnnotated() {
-		return MergedAnnotations.from(getExecutable()).isPresent(PersistenceConstructor.class);
+		return MergedAnnotations.from(getExecutable()).isPresent(PersistenceCreator.class);
 	}
 
 	/**
diff --git a/src/test/java/org/springframework/data/mapping/PreferredConstructorDiscovererUnitTests.java b/src/test/java/org/springframework/data/mapping/PreferredConstructorDiscovererUnitTests.java
index d5f4b8bfa7..a8c09b819f 100755
--- a/src/test/java/org/springframework/data/mapping/PreferredConstructorDiscovererUnitTests.java
+++ b/src/test/java/org/springframework/data/mapping/PreferredConstructorDiscovererUnitTests.java
@@ -25,7 +25,6 @@
 
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Value;
-import org.springframework.data.annotation.PersistenceConstructor;
 import org.springframework.data.annotation.PersistenceCreator;
 import org.springframework.data.mapping.PreferredConstructorDiscovererUnitTests.Outer.Inner;
 import org.springframework.data.mapping.model.BasicPersistentEntity;
@@ -39,56 +38,55 @@
  * @author Roman Rodov
  * @author Mark Paluch
  * @author Christoph Strobl
+ * @author Pavel Anisimov
  */
 class PreferredConstructorDiscovererUnitTests<P extends PersistentProperty<P>> {
 
 	@Test // DATACMNS-1126
 	void findsNoArgConstructorForClassWithoutExplicitConstructor() {
 
-		assertThat(PreferredConstructorDiscoverer.discover(EntityWithoutConstructor.class)).satisfies(constructor -> {
+		var constructor = PreferredConstructorDiscoverer.discover(EntityWithoutConstructor.class);
 
-			assertThat(constructor).isNotNull();
-			assertThat(constructor.isNoArgConstructor()).isTrue();
-			assertThat(constructor.isExplicitlyAnnotated()).isFalse();
-		});
+		assertThat(constructor).isNotNull();
+		assertThat(constructor.isNoArgConstructor()).isTrue();
+		assertThat(constructor.isExplicitlyAnnotated()).isFalse();
 	}
 
 	@Test // DATACMNS-1126
 	void findsNoArgConstructorForClassWithMultipleConstructorsAndNoArgOne() {
 
-		assertThat(PreferredConstructorDiscoverer.discover(ClassWithEmptyConstructor.class)).satisfies(constructor -> {
+		var constructor = PreferredConstructorDiscoverer.discover(ClassWithEmptyConstructor.class);
 
-			assertThat(constructor).isNotNull();
-			assertThat(constructor.isNoArgConstructor()).isTrue();
-			assertThat(constructor.isExplicitlyAnnotated()).isFalse();
-		});
+		assertThat(constructor).isNotNull();
+		assertThat(constructor.isNoArgConstructor()).isTrue();
+		assertThat(constructor.isExplicitlyAnnotated()).isFalse();
 	}
 
 	@Test // DATACMNS-1126
 	void doesNotThrowExceptionForMultipleConstructorsAndNoNoArgConstructorWithoutAnnotation() {
 
-		assertThat(PreferredConstructorDiscoverer.discover(ClassWithMultipleConstructorsWithoutEmptyOne.class)).isNull();
+		var constructor = PreferredConstructorDiscoverer.discover(ClassWithMultipleConstructorsWithoutEmptyOne.class);
+
+		assertThat(constructor).isNull();
 	}
 
 	@Test // DATACMNS-1126
-	@SuppressWarnings({ "unchecked", "rawtypes" })
 	void usesConstructorWithAnnotationOverEveryOther() {
 
-		assertThat(PreferredConstructorDiscoverer.discover(ClassWithMultipleConstructorsAndAnnotation.class))
-				.satisfies(constructor -> {
+		PreferredConstructor<ClassWithMultipleConstructorsAndAnnotation, P> constructor =
+				PreferredConstructorDiscoverer.discover(ClassWithMultipleConstructorsAndAnnotation.class);
 
-					assertThat(constructor).isNotNull();
-					assertThat(constructor.isNoArgConstructor()).isFalse();
-					assertThat(constructor.isExplicitlyAnnotated()).isTrue();
+		assertThat(constructor).isNotNull();
+		assertThat(constructor.isNoArgConstructor()).isFalse();
+		assertThat(constructor.isExplicitlyAnnotated()).isTrue();
 
-					assertThat(constructor.hasParameters()).isTrue();
+		assertThat(constructor.hasParameters()).isTrue();
 
-					Iterator<Parameter<Object, P>> parameters = (Iterator) constructor.getParameters().iterator();
+		Iterator<Parameter<Object, P>> parameters = constructor.getParameters().iterator();
 
-					Parameter<?, P> parameter = parameters.next();
-					assertThat(parameter.getType().getType()).isEqualTo(Long.class);
-					assertThat(parameters.hasNext()).isFalse();
-				});
+		Parameter<?, P> parameter = parameters.next();
+		assertThat(parameter.getType().getType()).isEqualTo(Long.class);
+		assertThat(parameters.hasNext()).isFalse();
 	}
 
 	@Test // DATACMNS-134, DATACMNS-1126
@@ -96,11 +94,12 @@ void discoversInnerClassConstructorCorrectly() {
 
 		PersistentEntity<Inner, P> entity = new BasicPersistentEntity<>(TypeInformation.of(Inner.class));
 
-		assertThat(PreferredConstructorDiscoverer.discover(entity)).satisfies(constructor -> {
+		var constructor = PreferredConstructorDiscoverer.discover(entity);
+
+		assertThat(constructor).isNotNull();
 
-			Parameter<?, P> parameter = constructor.getParameters().iterator().next();
-			assertThat(constructor.isParentParameter(parameter)).isTrue();
-		});
+		Parameter<?, P> parameter = constructor.getParameters().iterator().next();
+		assertThat(constructor.isParentParameter(parameter)).isTrue();
 	}
 
 	@Test // DATACMNS-1082, DATACMNS-1126
@@ -109,77 +108,80 @@ void skipsSyntheticConstructor() {
 		PersistentEntity<SyntheticConstructor, P> entity = new BasicPersistentEntity<>(
 				TypeInformation.of(SyntheticConstructor.class));
 
-		assertThat(PreferredConstructorDiscoverer.discover(entity)).satisfies(constructor -> {
+		var constructor = PreferredConstructorDiscoverer.discover(entity);
+		assertThat(constructor).isNotNull();
 
-			var annotation = constructor.getConstructor().getAnnotation(PersistenceConstructor.class);
-			assertThat(annotation).isNotNull();
-			assertThat(constructor.getConstructor().isSynthetic()).isFalse();
-		});
+		var annotation = constructor.getConstructor().getAnnotation(PersistenceCreator.class);
+		assertThat(annotation).isNotNull();
+		assertThat(constructor.getConstructor().isSynthetic()).isFalse();
 	}
 
 	@Test // GH-2313
 	void capturesEnclosingTypeParameterOfNonStaticInnerClass() {
 
-		assertThat(PreferredConstructorDiscoverer.discover(NonStaticWithGenericTypeArgUsedInCtor.class)).satisfies(ctor -> {
+		var constructor = PreferredConstructorDiscoverer.discover(NonStaticWithGenericTypeArgUsedInCtor.class);
 
-			assertThat(ctor.getParameters()).hasSize(2);
-			assertThat(ctor.getParameters().get(0).getName()).isEqualTo("this$0");
-			assertThat(ctor.getParameters().get(1).getName()).isEqualTo("value");
-		});
+		assertThat(constructor).isNotNull();
+		assertThat(constructor.getParameters()).hasSize(2);
+		assertThat(constructor.getParameters().get(0).getName()).isEqualTo("this$0");
+		assertThat(constructor.getParameters().get(1).getName()).isEqualTo("value");
 	}
 
 	@Test // GH-2313
 	void capturesSuperClassEnclosingTypeParameterOfNonStaticInnerClass() {
 
-		assertThat(PreferredConstructorDiscoverer.discover(NonStaticInnerWithGenericArgUsedInCtor.class))
-				.satisfies(ctor -> {
+		var constructor = PreferredConstructorDiscoverer.discover(NonStaticInnerWithGenericArgUsedInCtor.class);
 
-					assertThat(ctor.getParameters()).hasSize(2);
-					assertThat(ctor.getParameters().get(0).getName()).isEqualTo("this$0");
-					assertThat(ctor.getParameters().get(1).getName()).isEqualTo("value");
-				});
+		assertThat(constructor).isNotNull();
+		assertThat(constructor.getParameters()).hasSize(2);
+		assertThat(constructor.getParameters().get(0).getName()).isEqualTo("this$0");
+		assertThat(constructor.getParameters().get(1).getName()).isEqualTo("value");
 	}
 
 	@Test // GH-2332
 	void detectsMetaAnnotatedValueAnnotation() {
 
-		assertThat(PreferredConstructorDiscoverer.discover(ClassWithMetaAnnotatedParameter.class)).satisfies(ctor -> {
+		var constructor = PreferredConstructorDiscoverer.discover(ClassWithMetaAnnotatedParameter.class);
 
-			assertThat(ctor.getParameters().get(0).getSpelExpression()).isEqualTo("${hello-world}");
-			assertThat(ctor.getParameters().get(0).getAnnotations()).isNotNull();
-		});
+		assertThat(constructor).isNotNull();
+		assertThat(constructor.getParameters().get(0).getSpelExpression()).isEqualTo("${hello-world}");
+		assertThat(constructor.getParameters().get(0).getAnnotations()).isNotNull();
 	}
 
 	@Test // GH-2332
-	void detectsCanonicalRecordConstructor() {
+	void detectsCanonicalRecordConstructorWhenRecordHasSingleArgConstructor() {
 
-		assertThat(PreferredConstructorDiscoverer.discover(RecordWithSingleArgConstructor.class)).satisfies(ctor -> {
+		var constructor = PreferredConstructorDiscoverer.discover(RecordWithSingleArgConstructor.class);
 
-			assertThat(ctor.getParameters()).hasSize(2);
-			assertThat(ctor.getParameters().get(0).getRawType()).isEqualTo(Long.class);
-			assertThat(ctor.getParameters().get(1).getRawType()).isEqualTo(String.class);
-		});
+		assertThat(constructor).isNotNull();
+		assertThat(constructor.getParameters()).hasSize(2);
+		assertThat(constructor.getParameters().get(0).getRawType()).isEqualTo(Long.class);
+		assertThat(constructor.getParameters().get(1).getRawType()).isEqualTo(String.class);
+	}
 
-		assertThat(PreferredConstructorDiscoverer.discover(RecordWithNoArgConstructor.class)).satisfies(ctor -> {
+	@Test // GH-2332
+	void detectsCanonicalRecordConstructorWhenRecordHasNoArgConstructor() {
 
-			assertThat(ctor.getParameters()).hasSize(2);
-			assertThat(ctor.getParameters().get(0).getRawType()).isEqualTo(Long.class);
-			assertThat(ctor.getParameters().get(1).getRawType()).isEqualTo(String.class);
-		});
+		var constructor = PreferredConstructorDiscoverer.discover(RecordWithNoArgConstructor.class);
+
+		assertThat(constructor).isNotNull();
+		assertThat(constructor.getParameters()).hasSize(2);
+		assertThat(constructor.getParameters().get(0).getRawType()).isEqualTo(Long.class);
+		assertThat(constructor.getParameters().get(1).getRawType()).isEqualTo(String.class);
 	}
 
 	@Test // GH-2332
 	void detectsAnnotatedRecordConstructor() {
 
-		assertThat(PreferredConstructorDiscoverer.discover(RecordWithPersistenceCreator.class)).satisfies(ctor -> {
+		var constructor = PreferredConstructorDiscoverer.discover(RecordWithPersistenceCreator.class);
 
-			assertThat(ctor.getParameters()).hasSize(1);
-			assertThat(ctor.getParameters().get(0).getRawType()).isEqualTo(String.class);
-		});
+		assertThat(constructor).isNotNull();
+		assertThat(constructor.getParameters()).hasSize(1);
+		assertThat(constructor.getParameters().get(0).getRawType()).isEqualTo(String.class);
 	}
 
 	static class SyntheticConstructor {
-		@PersistenceConstructor
+		@PersistenceCreator
 		private SyntheticConstructor(String x) {}
 
 		class InnerSynthetic {
@@ -220,7 +222,7 @@ public ClassWithMultipleConstructorsAndAnnotation() {}
 
 		public ClassWithMultipleConstructorsAndAnnotation(String value) {}
 
-		@PersistenceConstructor
+		@PersistenceCreator
 		public ClassWithMultipleConstructorsAndAnnotation(Long value) {}
 	}