@@ -11,6 +11,7 @@ repositories {
 
 dependencies {
 testImplementation(kotlin("test"))
+testImplementation("org.junit.jupiter:junit-jupiter-params:5.12.2")
 }
 
 tasks.test {

@@ -1,38 +1,33 @@
 package com.schmoczer.leetcode._0001
 
 import org.junit.jupiter.api.BeforeEach
-import kotlin.test.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
 import kotlin.test.assertContentEquals
 
 class TwoSumTest {
+private companion object {
+@JvmStatic
+fun twoSumInputs() = listOf(
+Arguments.of(intArrayOf(2, 7, 11, 15), 9, intArrayOf(0, 1)),
+Arguments.of(intArrayOf(3, 2, 4), 6, intArrayOf(1, 2)),
+Arguments.of(intArrayOf(3, 3), 6, intArrayOf(0, 1)),
+)
+}
+
 private lateinit var sut: TwoSum
 
 @BeforeEach
 fun setUp() {
 sut = TwoSum()
 }
 
-@Test
-fun `first and second index of 2,7,11,15 lead for target of 9`() {
-val input = intArrayOf(2, 7, 11, 15)
-val expected = intArrayOf(0, 1)
-
-assertContentEquals(expected, sut.twoSum(input, 9))
-}
-
-@Test
-fun `second and third index of 3,2,4 for target of 6`() {
-val input = intArrayOf(3, 2, 4)
-val expected = intArrayOf(1, 2)
-
-assertContentEquals(expected, sut.twoSum(input, 6))
-}
-
-@Test
-fun `first and second index of 3,3 for target of 6`() {
-val input = intArrayOf(3, 3)
-val expected = intArrayOf(0, 1)
+@ParameterizedTest(name = "two sum for input {0} with target {1} is {2}")
+@MethodSource("twoSumInputs")
+fun `returns the correct indices for two sum`(input: IntArray, target: Int, expected: IntArray) {
+val result = sut.twoSum(input, target)
 
-assertContentEquals(expected, sut.twoSum(input, 6))
+assertContentEquals(expected, result)
 }
 }

@@ -1,36 +1,37 @@
 package com.schmoczer.leetcode._0005
 
 import org.junit.jupiter.api.BeforeEach
-import kotlin.test.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
 import kotlin.test.assertEquals
 
 class LongestPalindromicSubstringTest {
+private companion object {
+@JvmStatic
+fun palindromeInputs() = listOf(
+Arguments.of("babad", "bab"),
+Arguments.of("cbbd", "bb"),
+Arguments.of("a", "a"),
+Arguments.of(
+"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+),
+)
+}
+
 private lateinit var sut: LongestPalindromicSubstring
 
 @BeforeEach
 fun setUp() {
 sut = LongestPalindromicSubstring()
 }
 
-@Test
-fun `bab is a palindrom babad`() {
-assertEquals("bab", sut.longestPalindrome("babad"))
-}
-
-@Test
-fun `bb is a palindrome in cbbd`() {
-assertEquals("bb", sut.longestPalindrome("cbbd"))
-}
-
-@Test
-fun `a is a palindrome in a`() {
-assertEquals("a", sut.longestPalindrome("a"))
-}
+@ParameterizedTest(name = "longest palindrome in \"{0}\" is \"{1}\"")
+@MethodSource("palindromeInputs")
+fun `returns the correct longest palindromic substring`(input: String, expected: String) {
+val result = sut.longestPalindrome(input)
 
-@Test
-fun `long String containing only the same letter`() {
-val input =
-"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
-assertEquals(input, sut.longestPalindrome(input))
+assertEquals(expected, result)
 }
 }

@@ -1,74 +1,42 @@
 package com.schmoczer.leetcode._0008
 
 import org.junit.jupiter.api.BeforeEach
-import kotlin.test.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
 import kotlin.test.assertEquals
 
 class StringToIntegerTests {
+private companion object {
+@JvmStatic
+fun stringToIntegerInputs() = listOf(
+Arguments.of("42", 42),
+Arguments.of(" -042", -42),
+Arguments.of("1337c0d3", 1337),
+Arguments.of("0-1", 0),
+Arguments.of("words and 987", 0),
+Arguments.of("-2147483648", Int.MIN_VALUE),
+Arguments.of("2147483647", Int.MAX_VALUE),
+Arguments.of("-91283472332", Int.MIN_VALUE),
+Arguments.of("-2147483649", Int.MIN_VALUE),
+Arguments.of("2147483648", Int.MAX_VALUE),
+Arguments.of("", 0),
+Arguments.of(" ", 0),
+)
+}
+
 private lateinit var sut: StringToInteger
 
 @BeforeEach
 fun setUp() {
 sut = StringToInteger()
 }
 
-@Test
-fun `"42" as String is 42 as Int`() {
-assertEquals(42, sut.myAtoi("42"))
-}
-
-@Test
-fun `" -042" as String is -42 as Int`() {
-assertEquals(-42, sut.myAtoi(" -042"))
-}
-
-@Test
-fun `"1337c0d3" as String is 1337 as Int`() {
-assertEquals(1337, sut.myAtoi("1337c0d3"))
-}
-
-@Test
-fun `"0-1" as String is 0 as Int`() {
-assertEquals(0, sut.myAtoi("0-1"))
-}
-
-@Test
-fun `"words and 987" as String is 0 as Int`() {
-assertEquals(0, sut.myAtoi("words and 987"))
-}
-
-@Test
-fun `"-2147483648" as String is -2147483648`() {
-assertEquals(Int.MIN_VALUE, sut.myAtoi("-2147483648"))
-}
-
-@Test
-fun `"2147483647" as String is 2147483647`() {
-assertEquals(Int.MAX_VALUE, sut.myAtoi("2147483647"))
-}
-
-@Test
-fun `"-91283472332" as String is -2147483648 because it is lower than Int MIN_VALUE`() {
-assertEquals(Int.MIN_VALUE, sut.myAtoi("-91283472332"))
-}
-
-@Test
-fun `"-2147483649" as String is -2147483648 because it is lower than Int MIN_VALUE`() {
-assertEquals(Int.MIN_VALUE, sut.myAtoi("-2147483649"))
-}
-
-@Test
-fun `"2147483648" as String is 2147483647 because it is higher than Int MAX_VALUE`() {
-assertEquals(Int.MAX_VALUE, sut.myAtoi("2147483648"))
-}
-
-@Test
-fun `empty String is 0`() {
-assertEquals(0, sut.myAtoi(""))
-}
+@ParameterizedTest(name = "myAtoi(\"{0}\") = {1}")
+@MethodSource("stringToIntegerInputs")
+fun `converts string to integer correctly`(input: String, expected: Int) {
+val result = sut.myAtoi(input)
 
-@Test
-fun `multiple whitespaces are 0`() {
-assertEquals(0, sut.myAtoi(" "))
+assertEquals(expected, result)
 }
 }

@@ -1,45 +1,36 @@
 package com.schmoczer.leetcode._0020
 
 import org.junit.jupiter.api.BeforeEach
-import kotlin.test.Test
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
+import kotlin.test.assertEquals
 
 class ValidParenthesesTest {
+private companion object {
+@JvmStatic
+fun parenthesesInputs() = listOf(
+Arguments.of("()", true),
+Arguments.of("()[]{}", true),
+Arguments.of("(]", false),
+Arguments.of("([])", true),
+Arguments.of("(", false),
+Arguments.of(")", false),
+)
+}
+
 private lateinit var sut: ValidParentheses
 
 @BeforeEach
 fun setUp() {
 sut = ValidParentheses()
 }
 
-@Test
-fun `() is valid`() {
-assertTrue(sut.isValid("()"))
-}
-
-@Test
-fun `all 3 brackets opening and closing after each other is valid`() {
-assertTrue(sut.isValid("()[]{}"))
-}
-
-@Test
-fun `closing bracket different from opening bracket is not valid`() {
-assertFalse(sut.isValid("(]"))
-}
-
-@Test
-fun `square brackets inside round brackets is valid`() {
-assertTrue(sut.isValid("([])"))
-}
-
-@Test
-fun `only 1 opening bracket is not valid`() {
-assertFalse(sut.isValid("("))
-}
+@ParameterizedTest(name = "isValid(\"{0}\") = {1}")
+@MethodSource("parenthesesInputs")
+fun `validates parentheses correctly`(input: String, expected: Boolean) {
+val result = sut.isValid(input)
 
-@Test
-fun `only closing bracket is not valid`() {
-assertFalse(sut.isValid(")"))
+assertEquals(expected, result)
 }
 }

@@ -1,28 +1,34 @@
 package com.schmoczer.leetcode._0042
 
 import org.junit.jupiter.api.BeforeEach
-import kotlin.test.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
+import org.junit.jupiter.params.provider.MethodSource
 import kotlin.test.assertEquals
 
 class TrappingRainWaterTests {
+private companion object {
+@JvmStatic
+fun waterInputs() = listOf(
+Arguments.of(intArrayOf(0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1), 6),
+Arguments.of(intArrayOf(4, 2, 0, 3, 2, 5), 9),
+Arguments.of(intArrayOf(0, 0, 0, 0), 0),
+Arguments.of(intArrayOf(2, 0, 2), 2),
+)
+}
+
 private lateinit var sut: TrappingRainWater
 
 @BeforeEach
 fun setUp() {
 sut = TrappingRainWater()
 }
 
-@Test
-fun `0,1,0,2,1,0,1,3,2,1,2,1 traps 6 water`() {
-val input = intArrayOf(0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1)
-
-assertEquals(6, sut.trap(input))
-}
-
-@Test
-fun `4,2,0,3,2,5 traps 9 water`() {
-val input = intArrayOf(4, 2, 0, 3, 2, 5)
+@ParameterizedTest(name = "trapped water for heights {0} is {1}")
+@MethodSource("waterInputs")
+fun `returns the correct amount of trapped water`(heights: IntArray, expected: Int) {
+val result = sut.trap(heights)
 
-assertEquals(9, sut.trap(input))
+assertEquals(expected, result)
 }
 }