Use include-code for password4j docs

This follows the new convention of using include-code going forward to
ensure that the documentation compiles and is tested. This also corrected
a few errors in custom params for Ballooning and PBKDF2 examples.

Issue gh-17706

docs/src/test/java/org/springframework/security/docs/features/authentication/password4jargon2/Argon2UsageTests.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2004-present the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.docs.features.authentication.password4jargon2;
+
+import com.password4j.Argon2Function;
+import com.password4j.types.Argon2;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.crypto.password4j.Argon2Password4jPasswordEncoder;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Rob Winch
+ */
+public class Argon2UsageTests {
+
+	@Test
+	void defaultParams() {
+		// tag::default-params[]
+		PasswordEncoder encoder = new Argon2Password4jPasswordEncoder();
+		String result = encoder.encode("myPassword");
+		assertThat(encoder.matches("myPassword", result)).isTrue();
+		// end::default-params[]
+	}
+
+	@Test
+	void customParameters() {
+		// tag::custom-params[]
+		Argon2Function argon2Fn = Argon2Function.getInstance(65536, 3, 4, 32,
+				Argon2.ID);
+		PasswordEncoder encoder = new Argon2Password4jPasswordEncoder(argon2Fn);
+		String result = encoder.encode("myPassword");
+		assertThat(encoder.matches("myPassword", result)).isTrue();
+		// end::custom-params[]
+	}
+
+}

docs/src/test/java/org/springframework/security/docs/features/authentication/password4jballooning/BallooningHashingUsageTests.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2004-present the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.docs.features.authentication.password4jballooning;
+
+import com.password4j.BalloonHashingFunction;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.crypto.password4j.BalloonHashingPassword4jPasswordEncoder;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Rob Winch
+ */
+public class BallooningHashingUsageTests {
+
+	@Test
+	void defaultParams() {
+		// tag::default-params[]
+		PasswordEncoder encoder = new BalloonHashingPassword4jPasswordEncoder();
+		String result = encoder.encode("myPassword");
+		assertThat(encoder.matches("myPassword", result)).isTrue();
+		// end::default-params[]
+	}
+
+	@Test
+	void customParameters() {
+		// tag::custom-params[]
+		BalloonHashingFunction ballooningHashingFn =
+			BalloonHashingFunction.getInstance("SHA-256", 1024, 3, 4, 3);
+		PasswordEncoder encoder = new BalloonHashingPassword4jPasswordEncoder(ballooningHashingFn);
+		String result = encoder.encode("myPassword");
+		assertThat(encoder.matches("myPassword", result)).isTrue();
+		// end::custom-params[]
+	}
+
+}

docs/src/test/java/org/springframework/security/docs/features/authentication/password4jbcrypt/BcryptUsageTests.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2004-present the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.docs.features.authentication.password4jbcrypt;
+
+import com.password4j.BcryptFunction;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.crypto.password4j.BcryptPassword4jPasswordEncoder;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Rob Winch
+ */
+public class BcryptUsageTests {
+
+	@Test
+	void defaultParams() {
+		// tag::default-params[]
+		PasswordEncoder encoder = new BCryptPasswordEncoder();
+		String result = encoder.encode("myPassword");
+		assertThat(encoder.matches("myPassword", result)).isTrue();
+		// end::default-params[]
+	}
+
+	@Test
+	void customParameters() {
+		// tag::custom-params[]
+		BcryptFunction bcryptFn = BcryptFunction.getInstance(12);
+		PasswordEncoder encoder = new BcryptPassword4jPasswordEncoder(bcryptFn);
+		String result = encoder.encode("myPassword");
+		assertThat(encoder.matches("myPassword", result)).isTrue();
+		// end::custom-params[]
+	}
+
+}

docs/src/test/java/org/springframework/security/docs/features/authentication/password4jpbkdf2/Pbkdf2UsageTests.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2004-present the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.docs.features.authentication.password4jpbkdf2;
+
+import com.password4j.PBKDF2Function;
+import com.password4j.types.Hmac;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.crypto.password4j.Pbkdf2Password4jPasswordEncoder;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Rob Winch
+ */
+public class Pbkdf2UsageTests {
+
+	@Test
+	void defaultParams() {
+		// tag::default-params[]
+		PasswordEncoder encoder = new Pbkdf2Password4jPasswordEncoder();
+		String result = encoder.encode("myPassword");
+		assertThat(encoder.matches("myPassword", result)).isTrue();
+		// end::default-params[]
+	}
+
+	@Test
+	void customParameters() {
+		// tag::custom-params[]
+		PBKDF2Function pbkdf2Fn = PBKDF2Function.getInstance(Hmac.SHA256, 100000, 256);
+		PasswordEncoder encoder = new Pbkdf2Password4jPasswordEncoder(pbkdf2Fn);
+		String result = encoder.encode("myPassword");
+		assertThat(encoder.matches("myPassword", result)).isTrue();
+		// end::custom-params[]
+	}
+
+}

docs/src/test/java/org/springframework/security/docs/features/authentication/password4jscrypt/ScryptUsageTests.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2004-present the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.security.docs.features.authentication.password4jscrypt;
+
+import com.password4j.ScryptFunction;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.crypto.password4j.ScryptPassword4jPasswordEncoder;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Rob Winch
+ */
+public class ScryptUsageTests {
+
+	@Test
+	void defaultParams() {
+		// tag::default-params[]
+		PasswordEncoder encoder = new ScryptPassword4jPasswordEncoder();
+		String result = encoder.encode("myPassword");
+		assertThat(encoder.matches("myPassword", result)).isTrue();
+		// end::default-params[]
+	}
+
+	@Test
+	void customParameters() {
+		// tag::custom-params[]
+		ScryptFunction scryptFn = ScryptFunction.getInstance(32768, 8, 1, 32);
+		PasswordEncoder encoder = new ScryptPassword4jPasswordEncoder(scryptFn);
+		String result = encoder.encode("myPassword");
+		assertThat(encoder.matches("myPassword", result)).isTrue();
+		// end::custom-params[]
+	}
+
+}

docs/src/test/kotlin/org/springframework/security/kt/docs/features/authentication/password4jargon2/Argon2UsageTests.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2004-present the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.security.kt.docs.features.authentication.password4jargon2
+
+import com.password4j.Argon2Function
+import com.password4j.types.Argon2
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.springframework.security.crypto.password.PasswordEncoder
+import org.springframework.security.crypto.password4j.Argon2Password4jPasswordEncoder
+
+/**
+ * @author Rob Winch
+ */
+class Argon2UsageTests {
+
+    @Test
+    fun defaultParams() {
+        // tag::default-params[]
+        val encoder: PasswordEncoder = Argon2Password4jPasswordEncoder()
+        val result = encoder.encode("myPassword")
+        assertThat(encoder.matches("myPassword", result)).isTrue()
+        // end::default-params[]
+    }
+
+    @Test
+    fun customParameters() {
+        // tag::custom-params[]
+        val argon2Fn = Argon2Function.getInstance(
+            65536, 3, 4, 32,
+            Argon2.ID
+        )
+        val encoder: PasswordEncoder = Argon2Password4jPasswordEncoder(argon2Fn)
+        val result = encoder.encode("myPassword")
+        assertThat(encoder.matches("myPassword", result)).isTrue()
+        // end::custom-params[]
+    }
+}

docs/src/test/kotlin/org/springframework/security/kt/docs/features/authentication/password4jballooning/BallooningHashingUsageTests.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2004-present the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.security.kt.docs.features.authentication.password4jballooning
+
+import com.password4j.BalloonHashingFunction
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.Test
+import org.springframework.security.crypto.password.PasswordEncoder
+import org.springframework.security.crypto.password4j.BalloonHashingPassword4jPasswordEncoder
+
+/**
+ * @author Rob Winch
+ */
+class BallooningHashingUsageTests {
+    @Test
+    fun defaultParams() {
+        // tag::default-params[]
+        val encoder: PasswordEncoder = BalloonHashingPassword4jPasswordEncoder()
+        val result = encoder.encode("myPassword")
+        Assertions.assertThat(encoder.matches("myPassword", result)).isTrue()
+        // end::default-params[]
+    }
+
+    @Test
+    fun customParameters() {
+        // tag::custom-params[]
+        val ballooningHashingFn =
+            BalloonHashingFunction.getInstance("SHA-256", 1024, 3, 4, 3)
+        val encoder: PasswordEncoder = BalloonHashingPassword4jPasswordEncoder(ballooningHashingFn)
+        val result = encoder.encode("myPassword")
+        Assertions.assertThat(encoder.matches("myPassword", result)).isTrue()
+        // end::custom-params[]
+    }
+}

docs/src/test/kotlin/org/springframework/security/kt/docs/features/authentication/password4jbcrypt/BcryptUsageTests.kt

@@ -0,0 +1,32 @@
+package org.springframework.security.kt.docs.features.authentication.password4jbcrypt
+
+import com.password4j.BcryptFunction
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.Test
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder
+import org.springframework.security.crypto.password.PasswordEncoder
+import org.springframework.security.crypto.password4j.BcryptPassword4jPasswordEncoder
+
+/**
+ * @author Rob Winch
+ */
+class BcryptUsageTests {
+    @Test
+    fun defaultParams() {
+        // tag::default-params[]
+        val encoder: PasswordEncoder = BCryptPasswordEncoder()
+        val result = encoder.encode("myPassword")
+        Assertions.assertThat(encoder.matches("myPassword", result)).isTrue()
+        // end::default-params[]
+    }
+
+    @Test
+    fun customParameters() {
+        // tag::custom-params[]
+        val bcryptFunction = BcryptFunction.getInstance(12)
+        val encoder: PasswordEncoder = BcryptPassword4jPasswordEncoder(bcryptFunction)
+        val result = encoder.encode("myPassword")
+        Assertions.assertThat(encoder.matches("myPassword", result)).isTrue()
+        // end::custom-params[]
+    }
+}

docs/src/test/kotlin/org/springframework/security/kt/docs/features/authentication/password4jpbkdf2/Pbkdf2UsageTests.kt

@@ -0,0 +1,32 @@
+package org.springframework.security.kt.docs.features.authentication.password4jpbkdf2
+
+import com.password4j.PBKDF2Function
+import com.password4j.types.Hmac
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.Test
+import org.springframework.security.crypto.password.PasswordEncoder
+import org.springframework.security.crypto.password4j.Pbkdf2Password4jPasswordEncoder
+
+/**
+ * @author Rob Winch
+ */
+class Pbkdf2UsageTests {
+    @Test
+    fun defaultParams() {
+        // tag::default-params[]
+        val encoder: PasswordEncoder = Pbkdf2Password4jPasswordEncoder()
+        val result = encoder.encode("myPassword")
+        Assertions.assertThat(encoder.matches("myPassword", result)).isTrue()
+        // end::default-params[]
+    }
+
+    @Test
+    fun customParameters() {
+        // tag::custom-params[]
+        val pbkdf2Fn = PBKDF2Function.getInstance(Hmac.SHA256, 100000, 256)
+        val encoder: PasswordEncoder = Pbkdf2Password4jPasswordEncoder(pbkdf2Fn)
+        val result = encoder.encode("myPassword")
+        Assertions.assertThat(encoder.matches("myPassword", result)).isTrue()
+        // end::custom-params[]
+    }
+}

docs/src/test/kotlin/org/springframework/security/kt/docs/features/authentication/password4jscrypt/ScryptUsageTests.kt

@@ -0,0 +1,31 @@
+package org.springframework.security.kt.docs.features.authentication.password4jscrypt
+
+import com.password4j.ScryptFunction
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.Test
+import org.springframework.security.crypto.password.PasswordEncoder
+import org.springframework.security.crypto.password4j.ScryptPassword4jPasswordEncoder
+
+/**
+ * @author Rob Winch
+ */
+class ScryptUsageTests {
+    @Test
+    fun defaultParams() {
+        // tag::default-params[]
+        val encoder: PasswordEncoder = ScryptPassword4jPasswordEncoder()
+        val result = encoder.encode("myPassword")
+        Assertions.assertThat(encoder.matches("myPassword", result)).isTrue()
+        // end::default-params[]
+    }
+
+    @Test
+    fun customParameters() {
+        // tag::custom-params[]
+        val scryptFn = ScryptFunction.getInstance(32768, 8, 1, 32)
+        val encoder: PasswordEncoder = ScryptPassword4jPasswordEncoder(scryptFn)
+        val result = encoder.encode("myPassword")
+        Assertions.assertThat(encoder.matches("myPassword", result)).isTrue()
+        // end::custom-params[]
+    }
+}