Repository: MarvinJWendt/testza
Pull request #87 (2022-03-20 00:00:08)

refactor: renamed `Mock` to `Fuzz`
BREAKING CHANGE: Adapting to this breaking change is easily done by replacing all occurrences of `testza.Mock` with `testza.Fuzz`


Patch:
diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index f228598..3b3638e 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -13,7 +13,7 @@ jobs:
     strategy:
       matrix:
         os: [ ubuntu-latest, windows-latest, macos-latest ]
-        go: [1.15, 1.16, 1.17]
+        go: [1.15, 1.16, 1.17, 1.18]
     steps:
       - name: Set up Go ${{ matrix.go }}
         uses: actions/setup-go@v2
@@ -34,6 +34,6 @@ jobs:
         run: go test -coverprofile="coverage.txt" -covermode=atomic -race .
 
       - name: Upload coverage to Codecov
-        if: success() && matrix.go == 1.17 && matrix.os == 'ubuntu-latest'
+        if: success() && matrix.go == 1.18 && matrix.os == 'ubuntu-latest'
         # uses: codecov/codecov-action@v1
         run: bash <(curl -s https://codecov.io/bash)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0283976..5d51e0a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,9 @@
 <a name="unreleased"></a>
 ## [Unreleased]
 
+### Code Refactoring
+- renamed `Mock` to `Fuzz`
+
 
 <a name="v0.2.15"></a>
 ## [v0.2.15] - 2022-02-14
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 97e1653..d882f4c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -7,18 +7,18 @@ This guide will explain how you can contribute to testza.
 Every function in testza follows a specific name scheme.
 As you can see in the [documentations Table of Contents](https://github.com/MarvinJWendt/testza#documentation), testza has many different modules.
 The first word of a new function, is always the module name (eg. `Assert`, `Capture`, `Snapshot`, etc.).
-If the function is inside a nested sub-module, the module names will be chained as in `MockInputBool`.
+If the function is inside a nested sub-module, the module names will be chained as in `FuzzInputBool`.
 The last word of the function name is the actual function name itself.
 
 ### Example
 
 ```
-  ┌ Mocking part of testza
-  |   ┌ Mock different inputs
-  |   |   ┌ Mock integer inputs
-  |   |   |   ┌ Full set of integer input mocking
+  ┌ Fuzz part of testza
+  |   ┌ Fuzz different inputs
+  |   |   ┌ Fuzz integer inputs
+  |   |   |   ┌ Full set of integer input fuzzing
   |   |   |   |
-MockInputIntFull()
+FuzzInputIntFull()
 ```
 
 ## File Naming
diff --git a/README.md b/README.md
index f143a67..b0d163c 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@
 </a>
 
 <a href="https://codecov.io/gh/MarvinJWendt/testza">
-<!-- unittestcount:start --><img src="https://img.shields.io/badge/Unit_Tests-3136-magenta?style=flat-square" alt="Unit test count"><!-- unittestcount:end -->
+<!-- unittestcount:start --><img src="https://img.shields.io/badge/Unit_Tests-3140-magenta?style=flat-square" alt="Unit test count"><!-- unittestcount:end -->
 </a>
   
 <a href="https://pkg.go.dev/github.com/MarvinJWendt/testza" target="_blank">
@@ -70,7 +70,7 @@ go get github.com/MarvinJWendt/testza
 
 Testza is a full-featured testing framework for Go.
 It integrates with the default test runner, so you can use it with the standard `go test` tool.
-Testza contains easy to use methods, like assertions, output capturing, mocking, and much more.
+Testza contains easy to use methods, like assertions, output capturing, fuzzing, and much more.
 
 The main goal of testza is to provide an easy and fun experience writing tests and providing a nice, user-friendly output.
 Even developers who never used testza, will get into it quickly.
@@ -93,14 +93,14 @@ testza.AssertEqual(t, object, object) // -> Pass
 terminalOutput, _ := testza.CaptureStdout(func(w io.Writer) error {fmt.Println("Hello"); return nil})
 testza.AssertEqual(t, terminalOutput, "Hello\n") // -> Pass
 
-// - Mocking -
+// - Fuzzing -
 // Testing a function that accepts email addresses as a parameter:
 
 // Testset of many different email addresses
-emailAddresses := testza.MockStringEmailAddresses()
+emailAddresses := testza.FuzzStringEmailAddresses()
 
 // Run a test for every string in the test set
-testza.MockStringRunTests(t, emailAddresses, func(t *testing.T, index int, str string) {
+testza.FuzzStringRunTests(t, emailAddresses, func(t *testing.T, index int, str string) {
   user, domain, err := internal.ParseEmailAddress(str) // Use your function
   testza.AssertNoError(t, err) // Assert that your function does not return an error
   testza.AssertNotZero(t, user) // Assert that the user is returned
@@ -204,74 +204,74 @@ testza.MockStringRunTests(t, emailAddresses, func(t *testing.T, index int, str s
 
 </tr>
 <tr>
-<td><a href="https://github.com/MarvinJWendt/testza#Mock-Input-Bool">Mock Input Bool</a></td>
+<td><a href="https://github.com/MarvinJWendt/testza#Fuzz-Input-Bool">Fuzz Input Bool</a></td>
 <td>
 
 <details>
 <summary>Click to expand</summary>
 
-  - [MockInputBoolFull](https://github.com/MarvinJWendt/testza#MockInputBoolFull)
-  - [MockInputBoolModify](https://github.com/MarvinJWendt/testza#MockInputBoolModify)
-  - [MockInputBoolRunTests](https://github.com/MarvinJWendt/testza#MockInputBoolRunTests)
+  - [FuzzInputBoolFull](https://github.com/MarvinJWendt/testza#FuzzInputBoolFull)
+  - [FuzzInputBoolModify](https://github.com/MarvinJWendt/testza#FuzzInputBoolModify)
+  - [FuzzInputBoolRunTests](https://github.com/MarvinJWendt/testza#FuzzInputBoolRunTests)
 </td>
 
 </details>
 
 </tr>
 <tr>
-<td><a href="https://github.com/MarvinJWendt/testza#Mock-Input-String">Mock Input String</a></td>
+<td><a href="https://github.com/MarvinJWendt/testza#Fuzz-Input-String">Fuzz Input String</a></td>
 <td>
 
 <details>
 <summary>Click to expand</summary>
 
-  - [MockInputStringEmailAddresses](https://github.com/MarvinJWendt/testza#MockInputStringEmailAddresses)
-  - [MockInputStringEmpty](https://github.com/MarvinJWendt/testza#MockInputStringEmpty)
-  - [MockInputStringFull](https://github.com/MarvinJWendt/testza#MockInputStringFull)
-  - [MockInputStringGenerateRandom](https://github.com/MarvinJWendt/testza#MockInputStringGenerateRandom)
-  - [MockInputStringHtmlTags](https://github.com/MarvinJWendt/testza#MockInputStringHtmlTags)
-  - [MockInputStringLimit](https://github.com/MarvinJWendt/testza#MockInputStringLimit)
-  - [MockInputStringLong](https://github.com/MarvinJWendt/testza#MockInputStringLong)
-  - [MockInputStringModify](https://github.com/MarvinJWendt/testza#MockInputStringModify)
-  - [MockInputStringNumeric](https://github.com/MarvinJWendt/testza#MockInputStringNumeric)
-  - [MockInputStringRunTests](https://github.com/MarvinJWendt/testza#MockInputStringRunTests)
-  - [MockInputStringUsernames](https://github.com/MarvinJWendt/testza#MockInputStringUsernames)
+  - [FuzzInputStringEmailAddresses](https://github.com/MarvinJWendt/testza#FuzzInputStringEmailAddresses)
+  - [FuzzInputStringEmpty](https://github.com/MarvinJWendt/testza#FuzzInputStringEmpty)
+  - [FuzzInputStringFull](https://github.com/MarvinJWendt/testza#FuzzInputStringFull)
+  - [FuzzInputStringGenerateRandom](https://github.com/MarvinJWendt/testza#FuzzInputStringGenerateRandom)
+  - [FuzzInputStringHtmlTags](https://github.com/MarvinJWendt/testza#FuzzInputStringHtmlTags)
+  - [FuzzInputStringLimit](https://github.com/MarvinJWendt/testza#FuzzInputStringLimit)
+  - [FuzzInputStringLong](https://github.com/MarvinJWendt/testza#FuzzInputStringLong)
+  - [FuzzInputStringModify](https://github.com/MarvinJWendt/testza#FuzzInputStringModify)
+  - [FuzzInputStringNumeric](https://github.com/MarvinJWendt/testza#FuzzInputStringNumeric)
+  - [FuzzInputStringRunTests](https://github.com/MarvinJWendt/testza#FuzzInputStringRunTests)
+  - [FuzzInputStringUsernames](https://github.com/MarvinJWendt/testza#FuzzInputStringUsernames)
 </td>
 
 </details>
 
 </tr>
 <tr>
-<td><a href="https://github.com/MarvinJWendt/testza#Mock-Input-Float64">Mock Input Float64</a></td>
+<td><a href="https://github.com/MarvinJWendt/testza#Fuzz-Input-Float64">Fuzz Input Float64</a></td>
 <td>
 
 <details>
 <summary>Click to expand</summary>
 
-  - [MockInputFloat64Full](https://github.com/MarvinJWendt/testza#MockInputFloat64Full)
-  - [MockInputFloat64GenerateRandomNegative](https://github.com/MarvinJWendt/testza#MockInputFloat64GenerateRandomNegative)
-  - [MockInputFloat64GenerateRandomPositive](https://github.com/MarvinJWendt/testza#MockInputFloat64GenerateRandomPositive)
-  - [MockInputFloat64GenerateRandomRange](https://github.com/MarvinJWendt/testza#MockInputFloat64GenerateRandomRange)
-  - [MockInputFloat64Modify](https://github.com/MarvinJWendt/testza#MockInputFloat64Modify)
-  - [MockInputFloat64RunTests](https://github.com/MarvinJWendt/testza#MockInputFloat64RunTests)
+  - [FuzzInputFloat64Full](https://github.com/MarvinJWendt/testza#FuzzInputFloat64Full)
+  - [FuzzInputFloat64GenerateRandomNegative](https://github.com/MarvinJWendt/testza#FuzzInputFloat64GenerateRandomNegative)
+  - [FuzzInputFloat64GenerateRandomPositive](https://github.com/MarvinJWendt/testza#FuzzInputFloat64GenerateRandomPositive)
+  - [FuzzInputFloat64GenerateRandomRange](https://github.com/MarvinJWendt/testza#FuzzInputFloat64GenerateRandomRange)
+  - [FuzzInputFloat64Modify](https://github.com/MarvinJWendt/testza#FuzzInputFloat64Modify)
+  - [FuzzInputFloat64RunTests](https://github.com/MarvinJWendt/testza#FuzzInputFloat64RunTests)
 </td>
 
 </details>
 
 </tr>
 <tr>
-<td><a href="https://github.com/MarvinJWendt/testza#Mock-Input-Int">Mock Input Int</a></td>
+<td><a href="https://github.com/MarvinJWendt/testza#Fuzz-Input-Int">Fuzz Input Int</a></td>
 <td>
 
 <details>
 <summary>Click to expand</summary>
 
-  - [MockInputIntFull](https://github.com/MarvinJWendt/testza#MockInputIntFull)
-  - [MockInputIntGenerateRandomNegative](https://github.com/MarvinJWendt/testza#MockInputIntGenerateRandomNegative)
-  - [MockInputIntGenerateRandomPositive](https://github.com/MarvinJWendt/testza#MockInputIntGenerateRandomPositive)
-  - [MockInputIntGenerateRandomRange](https://github.com/MarvinJWendt/testza#MockInputIntGenerateRandomRange)
-  - [MockInputIntModify](https://github.com/MarvinJWendt/testza#MockInputIntModify)
-  - [MockInputIntRunTests](https://github.com/MarvinJWendt/testza#MockInputIntRunTests)
+  - [FuzzInputIntFull](https://github.com/MarvinJWendt/testza#FuzzInputIntFull)
+  - [FuzzInputIntGenerateRandomNegative](https://github.com/MarvinJWendt/testza#FuzzInputIntGenerateRandomNegative)
+  - [FuzzInputIntGenerateRandomPositive](https://github.com/MarvinJWendt/testza#FuzzInputIntGenerateRandomPositive)
+  - [FuzzInputIntGenerateRandomRange](https://github.com/MarvinJWendt/testza#FuzzInputIntGenerateRandomRange)
+  - [FuzzInputIntModify](https://github.com/MarvinJWendt/testza#FuzzInputIntModify)
+  - [FuzzInputIntRunTests](https://github.com/MarvinJWendt/testza#FuzzInputIntRunTests)
 </td>
 
 </details>
@@ -1019,245 +1019,245 @@ Example:
     testza.AssertEqual(t, "Hello", stdout)
     testza.AssertEqual(t, "World", stderr)
 
-### Mock Input Bool
+### Fuzz Input Bool
 
-#### MockInputBoolFull
+#### FuzzInputBoolFull
 
 ```go
-func MockInputBoolFull() []bool
+func FuzzInputBoolFull() []bool
 ```
 
-MockInputBoolFull returns true and false in a boolean slice.
+FuzzInputBoolFull returns true and false in a boolean slice.
 
-#### MockInputBoolModify
+#### FuzzInputBoolModify
 
 ```go
-func MockInputBoolModify(inputSlice []bool, modifier func(index int, value bool) bool) (floats []bool)
+func FuzzInputBoolModify(inputSlice []bool, modifier func(index int, value bool) bool) (floats []bool)
 ```
 
-MockInputBoolModify returns a modified version of a test set.
+FuzzInputBoolModify returns a modified version of a test set.
 
 Example:
 
-    testset := testza.MockInputBoolModify(testza.MockInputBoolFull(), func(index int, value bool) bool {
+    testset := testza.FuzzInputBoolModify(testza.FuzzInputBoolFull(), func(index int, value bool) bool {
     	return !value
     })
 
-#### MockInputBoolRunTests
+#### FuzzInputBoolRunTests
 
 ```go
-func MockInputBoolRunTests(t testRunner, testSet []bool, testFunc func(t *testing.T, index int, f bool))
+func FuzzInputBoolRunTests(t testRunner, testSet []bool, testFunc func(t *testing.T, index int, f bool))
 ```
 
-MockInputBoolRunTests runs a test for every value in a testset. You can use
+FuzzInputBoolRunTests runs a test for every value in a testset. You can use
 the value as input parameter for your functions, to sanity test against many
 different cases. This ensures that your functions have a correct error
 handling and enables you to test against hunderts of cases easily.
 
 Example:
 
-    testza.MockInputBoolRunTests(t, testza.MockInputBoolFull(), func(t *testing.T, index int, b bool) {
+    testza.FuzzInputBoolRunTests(t, testza.FuzzInputBoolFull(), func(t *testing.T, index int, b bool) {
     	// Test logic
     	// err := YourFunction(b)
     	// testza.AssertNoError(t, err)
     	// ...
     })
 
-### Mock Input Float64
+### Fuzz Input Float64
 
-#### MockInputFloat64Full
+#### FuzzInputFloat64Full
 
 ```go
-func MockInputFloat64Full() (floats []float64)
+func FuzzInputFloat64Full() (floats []float64)
 ```
 
-MockInputFloat64Full returns a combination of every float64 testset and some
+FuzzInputFloat64Full returns a combination of every float64 testset and some
 random float64s (positive and negative).
 
-#### MockInputFloat64GenerateRandomNegative
+#### FuzzInputFloat64GenerateRandomNegative
 
 ```go
-func MockInputFloat64GenerateRandomNegative(count int, min float64) (floats []float64)
+func FuzzInputFloat64GenerateRandomNegative(count int, min float64) (floats []float64)
 ```
 
-MockInputFloat64GenerateRandomNegative generates random negative integers
+FuzzInputFloat64GenerateRandomNegative generates random negative integers
 with a minimum of min. If the minimum is positive, it will be converted to a
 negative number. If it is set to 0, there is no limit.
 
-#### MockInputFloat64GenerateRandomPositive
+#### FuzzInputFloat64GenerateRandomPositive
 
 ```go
-func MockInputFloat64GenerateRandomPositive(count int, max float64) (floats []float64)
+func FuzzInputFloat64GenerateRandomPositive(count int, max float64) (floats []float64)
 ```
 
-MockInputFloat64GenerateRandomPositive generates random positive integers
+FuzzInputFloat64GenerateRandomPositive generates random positive integers
 with a maximum of max. If the maximum is 0, or below, the maximum will be
 set to math.MaxInt64.
 
-#### MockInputFloat64GenerateRandomRange
+#### FuzzInputFloat64GenerateRandomRange
 
 ```go
-func MockInputFloat64GenerateRandomRange(count int, min, max float64) (floats []float64)
+func FuzzInputFloat64GenerateRandomRange(count int, min, max float64) (floats []float64)
 ```
 
-MockInputFloat64GenerateRandomRange generates random positive integers with
+FuzzInputFloat64GenerateRandomRange generates random positive integers with
 a maximum of max. If the maximum is 0, or below, the maximum will be set to
 math.MaxInt64.
 
-#### MockInputFloat64Modify
+#### FuzzInputFloat64Modify
 
 ```go
-func MockInputFloat64Modify(inputSlice []float64, modifier func(index int, value float64) float64) (floats []float64)
+func FuzzInputFloat64Modify(inputSlice []float64, modifier func(index int, value float64) float64) (floats []float64)
 ```
 
-MockInputFloat64Modify returns a modified version of a test set.
+FuzzInputFloat64Modify returns a modified version of a test set.
 
 Example:
 
-    testset := testza.MockInputFloat64Modify(testza.MockInputFloat64Full(), func(index int, value float64) float64 {
+    testset := testza.FuzzInputFloat64Modify(testza.FuzzInputFloat64Full(), func(index int, value float64) float64 {
     	return value * 2
     })
 
-#### MockInputFloat64RunTests
+#### FuzzInputFloat64RunTests
 
 ```go
-func MockInputFloat64RunTests(t testRunner, testSet []float64, testFunc func(t *testing.T, index int, f float64))
+func FuzzInputFloat64RunTests(t testRunner, testSet []float64, testFunc func(t *testing.T, index int, f float64))
 ```
 
-MockInputFloat64RunTests runs a test for every value in a testset. You can
+FuzzInputFloat64RunTests runs a test for every value in a testset. You can
 use the value as input parameter for your functions, to sanity test against
 many different cases. This ensures that your functions have a correct error
 handling and enables you to test against hunderts of cases easily.
 
 Example:
 
-    testza.MockInputFloat64RunTests(t, testza.MockInputFloat64Full(), func(t *testing.T, index int, f float64) {
+    testza.FuzzInputFloat64RunTests(t, testza.FuzzInputFloat64Full(), func(t *testing.T, index int, f float64) {
     	// Test logic
     	// err := YourFunction(f)
     	// testza.AssertNoError(t, err)
     	// ...
     })
 
-### Mock Input Int
+### Fuzz Input Int
 
-#### MockInputIntFull
+#### FuzzInputIntFull
 
 ```go
-func MockInputIntFull() (ints []int)
+func FuzzInputIntFull() (ints []int)
 ```
 
-MockInputIntFull returns a combination of every integer testset and some
+FuzzInputIntFull returns a combination of every integer testset and some
 random integers (positive and negative).
 
-#### MockInputIntGenerateRandomNegative
+#### FuzzInputIntGenerateRandomNegative
 
 ```go
-func MockInputIntGenerateRandomNegative(count, min int) (ints []int)
+func FuzzInputIntGenerateRandomNegative(count, min int) (ints []int)
 ```
 
-MockInputIntGenerateRandomNegative generates random negative integers with a
+FuzzInputIntGenerateRandomNegative generates random negative integers with a
 minimum of min. If the minimum is 0, or above, the maximum will be set to
 math.MinInt64.
 
-#### MockInputIntGenerateRandomPositive
+#### FuzzInputIntGenerateRandomPositive
 
 ```go
-func MockInputIntGenerateRandomPositive(count, max int) (ints []int)
+func FuzzInputIntGenerateRandomPositive(count, max int) (ints []int)
 ```
 
-MockInputIntGenerateRandomPositive generates random positive integers with a
+FuzzInputIntGenerateRandomPositive generates random positive integers with a
 maximum of max. If the maximum is 0, or below, the maximum will be set to
 math.MaxInt64.
 
-#### MockInputIntGenerateRandomRange
+#### FuzzInputIntGenerateRandomRange
 
 ```go
-func MockInputIntGenerateRandomRange(count, min, max int) (ints []int)
+func FuzzInputIntGenerateRandomRange(count, min, max int) (ints []int)
 ```
 
-MockInputIntGenerateRandomRange generates random integers with a range of
+FuzzInputIntGenerateRandomRange generates random integers with a range of
 min to max.
 
-#### MockInputIntModify
+#### FuzzInputIntModify
 
 ```go
-func MockInputIntModify(inputSlice []int, modifier func(index int, value int) int) (ints []int)
+func FuzzInputIntModify(inputSlice []int, modifier func(index int, value int) int) (ints []int)
 ```
 
-MockInputIntModify returns a modified version of a test set.
+FuzzInputIntModify returns a modified version of a test set.
 
 Example:
 
-    testset := testza.MockInputIntModify(testza.MockInputIntFull(), func(index int, value int) int {
+    testset := testza.FuzzInputIntModify(testza.FuzzInputIntFull(), func(index int, value int) int {
     	return value * 2
     })
 
-#### MockInputIntRunTests
+#### FuzzInputIntRunTests
 
 ```go
-func MockInputIntRunTests(t testRunner, testSet []int, testFunc func(t *testing.T, index int, i int))
+func FuzzInputIntRunTests(t testRunner, testSet []int, testFunc func(t *testing.T, index int, i int))
 ```
 
-MockInputIntRunTests runs a test for every value in a testset. You can use
+FuzzInputIntRunTests runs a test for every value in a testset. You can use
 the value as input parameter for your functions, to sanity test against many
 different cases. This ensures that your functions have a correct error
 handling and enables you to test against hunderts of cases easily.
 
 Example:
 
-    testza.MockInputIntRunTests(t, testza.MockInputIntFull(), func(t *testing.T, index int, i int) {
+    testza.FuzzInputIntRunTests(t, testza.FuzzInputIntFull(), func(t *testing.T, index int, i int) {
     	// Test logic
     	// err := YourFunction(i)
     	// testza.AssertNoError(t, err)
     	// ...
     })
 
-### Mock Input String
+### Fuzz Input String
 
-#### MockInputStringEmailAddresses
+#### FuzzInputStringEmailAddresses
 
 ```go
-func MockInputStringEmailAddresses() []string
+func FuzzInputStringEmailAddresses() []string
 ```
 
-MockInputStringEmailAddresses returns a test set with valid email addresses.
+FuzzInputStringEmailAddresses returns a test set with valid email addresses.
 The addresses may look like they are invalid, but they are all conform to
 RFC 2822 and could be used. You can use this test set to test your email
 validation process.
 
-#### MockInputStringEmpty
+#### FuzzInputStringEmpty
 
 ```go
-func MockInputStringEmpty() []string
+func FuzzInputStringEmpty() []string
 ```
 
-MockInputStringEmpty returns a test set with a single empty string.
+FuzzInputStringEmpty returns a test set with a single empty string.
 
-#### MockInputStringFull
+#### FuzzInputStringFull
 
 ```go
-func MockInputStringFull() (ret []string)
+func FuzzInputStringFull() (ret []string)
 ```
 
-MockInputStringFull contains all string test sets plus ten generated random
+FuzzInputStringFull contains all string test sets plus ten generated random
 strings. This test set is huge and should only be used if you want to make
 sure that no string, at all, can crash a process.
 
-#### MockInputStringGenerateRandom
+#### FuzzInputStringGenerateRandom
 
 ```go
-func MockInputStringGenerateRandom(count, length int) (result []string)
+func FuzzInputStringGenerateRandom(count, length int) (result []string)
 ```
 
-MockInputStringGenerateRandom returns random strings in a test set.
+FuzzInputStringGenerateRandom returns random strings in a test set.
 
-#### MockInputStringHtmlTags
+#### FuzzInputStringHtmlTags
 
 ```go
-func MockInputStringHtmlTags() []string
+func FuzzInputStringHtmlTags() []string
 ```
 
-MockInputStringHtmlTags returns a test set with different html tags.
+FuzzInputStringHtmlTags returns a test set with different html tags.
 
 Example:
 
@@ -1265,76 +1265,76 @@ Example:
     - <script>alert('XSS')</script>
     - <a href="https://github.com/MarvinJWendt/testza">link</a>
 
-#### MockInputStringLimit
+#### FuzzInputStringLimit
 
 ```go
-func MockInputStringLimit(testSet []string, max int) []string
+func FuzzInputStringLimit(testSet []string, max int) []string
 ```
 
-MockInputStringLimit limits a test set in size.
+FuzzInputStringLimit limits a test set in size.
 
-#### MockInputStringLong
+#### FuzzInputStringLong
 
 ```go
-func MockInputStringLong() (testSet []string)
+func FuzzInputStringLong() (testSet []string)
 ```
 
-MockInputStringLong returns a test set with long random strings. Returns:
+FuzzInputStringLong returns a test set with long random strings. Returns:
 [0]: Random string (length: 25) [1]: Random string (length: 50) [2]: Random
 string (length: 100) [3]: Random string (length: 1,000) [4]: Random string
 (length: 100,000)
 
-#### MockInputStringModify
+#### FuzzInputStringModify
 
 ```go
-func MockInputStringModify(inputSlice []string, modifier func(index int, value string) string) (ret []string)
+func FuzzInputStringModify(inputSlice []string, modifier func(index int, value string) string) (ret []string)
 ```
 
-MockInputStringModify returns a modified version of a test set.
+FuzzInputStringModify returns a modified version of a test set.
 
 Example:
 
-    testset := testza.MockInputStringModify(testza.MockInputStringFull(), func(index int, value string) string {
+    testset := testza.FuzzInputStringModify(testza.FuzzInputStringFull(), func(index int, value string) string {
     	return value + " some suffix"
     })
 
-#### MockInputStringNumeric
+#### FuzzInputStringNumeric
 
 ```go
-func MockInputStringNumeric() []string
+func FuzzInputStringNumeric() []string
 ```
 
-MockInputStringNumeric returns a test set with strings that are numeric. The
+FuzzInputStringNumeric returns a test set with strings that are numeric. The
 highest number in here is "9223372036854775807", which is equal to the
 maxmim int64.
 
-#### MockInputStringRunTests
+#### FuzzInputStringRunTests
 
 ```go
-func MockInputStringRunTests(t testRunner, testSet []string, testFunc func(t *testing.T, index int, str string))
+func FuzzInputStringRunTests(t testRunner, testSet []string, testFunc func(t *testing.T, index int, str string))
 ```
 
-MockInputStringRunTests runs a test for every value in a testset. You can
+FuzzInputStringRunTests runs a test for every value in a testset. You can
 use the value as input parameter for your functions, to sanity test against
 many different cases. This ensures that your functions have a correct error
 handling and enables you to test against hunderts of cases easily.
 
 Example:
 
-    testza.MockInputStringRunTests(t, testza.MockInputStringFull(), func(t *testing.T, index int, str string) {
+    testza.FuzzInputStringRunTests(t, testza.FuzzInputStringFull(), func(t *testing.T, index int, str string) {
     	// Test logic
     	// err := YourFunction(str)
     	// testza.AssertNoError(t, err)
     	// ...
     })
 
-#### MockInputStringUsernames
+#### FuzzInputStringUsernames
 
 ```go
-func MockInputStringUsernames() []string
+func FuzzInputStringUsernames() []string
 ```
 
-MockInputStringUsernames returns a test set with usernames.
+FuzzInputStringUsernames returns a test set with usernames.
 
 ### Settings
 
diff --git a/ci/main.go b/ci/main.go
index 5da82d7..c64d89c 100644
--- a/ci/main.go
+++ b/ci/main.go
@@ -19,10 +19,10 @@ var Categories = []Category{
 	{Name: "Settings", Prefix: "Set"},
 	{Name: "Assert", Prefix: "Assert"},
 	{Name: "Capture", Prefix: "Capture"},
-	{Name: "Mock Input Bool", Prefix: "MockInputBool"},
-	{Name: "Mock Input String", Prefix: "MockInputString"},
-	{Name: "Mock Input Float64", Prefix: "MockInputFloat64"},
-	{Name: "Mock Input Int", Prefix: "MockInputInt"},
+	{Name: "Fuzz Input Bool", Prefix: "FuzzInputBool"},
+	{Name: "Fuzz Input String", Prefix: "FuzzInputString"},
+	{Name: "Fuzz Input Float64", Prefix: "FuzzInputFloat64"},
+	{Name: "Fuzz Input Int", Prefix: "FuzzInputInt"},
 	{Name: "Snapshot", Prefix: "Snapshot"},
 }
 
diff --git a/mock-bools.go b/fuzz-bools.go
similarity index 68%
rename from mock-bools.go
rename to fuzz-bools.go
index 304d77a..45eb5b1 100644
--- a/mock-bools.go
+++ b/fuzz-bools.go
@@ -7,23 +7,23 @@ import (
 	"github.com/MarvinJWendt/testza/internal"
 )
 
-// MockInputBoolFull returns true and false in a boolean slice.
-func MockInputBoolFull() []bool {
+// FuzzInputBoolFull returns true and false in a boolean slice.
+func FuzzInputBoolFull() []bool {
 	return []bool{true, false}
 }
 
-// MockInputBoolRunTests runs a test for every value in a testset.
+// FuzzInputBoolRunTests runs a test for every value in a testset.
 // You can use the value as input parameter for your functions, to sanity test against many different cases.
 // This ensures that your functions have a correct error handling and enables you to test against hunderts of cases easily.
 //
 // Example:
-//  testza.MockInputBoolRunTests(t, testza.MockInputBoolFull(), func(t *testing.T, index int, b bool) {
+//  testza.FuzzInputBoolRunTests(t, testza.FuzzInputBoolFull(), func(t *testing.T, index int, b bool) {
 //  	// Test logic
 //  	// err := YourFunction(b)
 //  	// testza.AssertNoError(t, err)
 //  	// ...
 //  })
-func MockInputBoolRunTests(t testRunner, testSet []bool, testFunc func(t *testing.T, index int, f bool)) {
+func FuzzInputBoolRunTests(t testRunner, testSet []bool, testFunc func(t *testing.T, index int, f bool)) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -43,13 +43,13 @@ func MockInputBoolRunTests(t testRunner, testSet []bool, testFunc func(t *testin
 	}
 }
 
-// MockInputBoolModify returns a modified version of a test set.
+// FuzzInputBoolModify returns a modified version of a test set.
 //
 // Example:
-//  testset := testza.MockInputBoolModify(testza.MockInputBoolFull(), func(index int, value bool) bool {
+//  testset := testza.FuzzInputBoolModify(testza.FuzzInputBoolFull(), func(index int, value bool) bool {
 //  	return !value
 //  })
-func MockInputBoolModify(inputSlice []bool, modifier func(index int, value bool) bool) (floats []bool) {
+func FuzzInputBoolModify(inputSlice []bool, modifier func(index int, value bool) bool) (floats []bool) {
 	for i, input := range inputSlice {
 		floats = append(floats, modifier(i, input))
 	}
diff --git a/mock-floats64.go b/fuzz-floats64.go
similarity index 63%
rename from mock-floats64.go
rename to fuzz-floats64.go
index 11ffb23..583c37e 100644
--- a/mock-floats64.go
+++ b/fuzz-floats64.go
@@ -9,20 +9,20 @@ import (
 	"github.com/MarvinJWendt/testza/internal"
 )
 
-// MockInputFloat64Full returns a combination of every float64 testset and some random float64s (positive and negative).
-func MockInputFloat64Full() (floats []float64) {
+// FuzzInputFloat64Full returns a combination of every float64 testset and some random float64s (positive and negative).
+func FuzzInputFloat64Full() (floats []float64) {
 	for i := 0; i < 50; i++ {
 		floats = append(floats,
-			MockInputFloat64GenerateRandomPositive(1, float64(i*1000))[0],
-			MockInputFloat64GenerateRandomNegative(1, float64(i*1000*-1))[0],
+			FuzzInputFloat64GenerateRandomPositive(1, float64(i*1000))[0],
+			FuzzInputFloat64GenerateRandomNegative(1, float64(i*1000*-1))[0],
 		)
 	}
 	return
 }
 
-// MockInputFloat64GenerateRandomRange generates random positive integers with a maximum of max.
+// FuzzInputFloat64GenerateRandomRange generates random positive integers with a maximum of max.
 // If the maximum is 0, or below, the maximum will be set to math.MaxInt64.
-func MockInputFloat64GenerateRandomRange(count int, min, max float64) (floats []float64) {
+func FuzzInputFloat64GenerateRandomRange(count int, min, max float64) (floats []float64) {
 	for i := 0; i < count; i++ {
 		floats = append(floats, min+rand.Float64()*(max-min))
 	}
@@ -30,45 +30,45 @@ func MockInputFloat64GenerateRandomRange(count int, min, max float64) (floats []
 	return
 }
 
-// MockInputFloat64GenerateRandomPositive generates random positive integers with a maximum of max.
+// FuzzInputFloat64GenerateRandomPositive generates random positive integers with a maximum of max.
 // If the maximum is 0, or below, the maximum will be set to math.MaxInt64.
-func MockInputFloat64GenerateRandomPositive(count int, max float64) (floats []float64) {
+func FuzzInputFloat64GenerateRandomPositive(count int, max float64) (floats []float64) {
 	if max <= 0 {
 		max = math.MaxFloat64
 	}
 
-	floats = append(floats, MockInputFloat64GenerateRandomRange(count, 0, max)...)
+	floats = append(floats, FuzzInputFloat64GenerateRandomRange(count, 0, max)...)
 
 	return
 }
 
-// MockInputFloat64GenerateRandomNegative generates random negative integers with a minimum of min.
+// FuzzInputFloat64GenerateRandomNegative generates random negative integers with a minimum of min.
 // If the minimum is positive, it will be converted to a negative number.
 // If it is set to 0, there is no limit.
-func MockInputFloat64GenerateRandomNegative(count int, min float64) (floats []float64) {
+func FuzzInputFloat64GenerateRandomNegative(count int, min float64) (floats []float64) {
 	if min > 0 {
 		min *= -1
 	} else if min == 0 {
 		min = math.MaxFloat64 * -1
 	}
 
-	floats = append(floats, MockInputFloat64GenerateRandomRange(count, min, 0)...)
+	floats = append(floats, FuzzInputFloat64GenerateRandomRange(count, min, 0)...)
 
 	return
 }
 
-// MockInputFloat64RunTests runs a test for every value in a testset.
+// FuzzInputFloat64RunTests runs a test for every value in a testset.
 // You can use the value as input parameter for your functions, to sanity test against many different cases.
 // This ensures that your functions have a correct error handling and enables you to test against hunderts of cases easily.
 //
 // Example:
-//  testza.MockInputFloat64RunTests(t, testza.MockInputFloat64Full(), func(t *testing.T, index int, f float64) {
+//  testza.FuzzInputFloat64RunTests(t, testza.FuzzInputFloat64Full(), func(t *testing.T, index int, f float64) {
 //  	// Test logic
 //  	// err := YourFunction(f)
 //  	// testza.AssertNoError(t, err)
 //  	// ...
 //  })
-func MockInputFloat64RunTests(t testRunner, testSet []float64, testFunc func(t *testing.T, index int, f float64)) {
+func FuzzInputFloat64RunTests(t testRunner, testSet []float64, testFunc func(t *testing.T, index int, f float64)) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -88,13 +88,13 @@ func MockInputFloat64RunTests(t testRunner, testSet []float64, testFunc func(t *
 	}
 }
 
-// MockInputFloat64Modify returns a modified version of a test set.
+// FuzzInputFloat64Modify returns a modified version of a test set.
 //
 // Example:
-//  testset := testza.MockInputFloat64Modify(testza.MockInputFloat64Full(), func(index int, value float64) float64 {
+//  testset := testza.FuzzInputFloat64Modify(testza.FuzzInputFloat64Full(), func(index int, value float64) float64 {
 //  	return value * 2
 //  })
-func MockInputFloat64Modify(inputSlice []float64, modifier func(index int, value float64) float64) (floats []float64) {
+func FuzzInputFloat64Modify(inputSlice []float64, modifier func(index int, value float64) float64) (floats []float64) {
 	for i, input := range inputSlice {
 		floats = append(floats, modifier(i, input))
 	}
diff --git a/mock-ints.go b/fuzz-ints.go
similarity index 61%
rename from mock-ints.go
rename to fuzz-ints.go
index 48faee9..a00c186 100644
--- a/mock-ints.go
+++ b/fuzz-ints.go
@@ -9,19 +9,19 @@ import (
 	"github.com/MarvinJWendt/testza/internal"
 )
 
-// MockInputIntFull returns a combination of every integer testset and some random integers (positive and negative).
-func MockInputIntFull() (ints []int) {
+// FuzzInputIntFull returns a combination of every integer testset and some random integers (positive and negative).
+func FuzzInputIntFull() (ints []int) {
 	for i := 0; i < 50; i++ {
 		ints = append(ints,
-			MockInputIntGenerateRandomPositive(1, i*1000)[0],
-			MockInputIntGenerateRandomNegative(1, i*1000*-1)[0],
+			FuzzInputIntGenerateRandomPositive(1, i*1000)[0],
+			FuzzInputIntGenerateRandomNegative(1, i*1000*-1)[0],
 		)
 	}
 	return
 }
 
-// MockInputIntGenerateRandomRange generates random integers with a range of min to max.
-func MockInputIntGenerateRandomRange(count, min, max int) (ints []int) {
+// FuzzInputIntGenerateRandomRange generates random integers with a range of min to max.
+func FuzzInputIntGenerateRandomRange(count, min, max int) (ints []int) {
 	for i := 0; i < count; i++ {
 		ints = append(ints, rand.Intn(max-min)+min)
 	}
@@ -29,28 +29,28 @@ func MockInputIntGenerateRandomRange(count, min, max int) (ints []int) {
 	return
 }
 
-// MockInputIntGenerateRandomPositive generates random positive integers with a maximum of max.
+// FuzzInputIntGenerateRandomPositive generates random positive integers with a maximum of max.
 // If the maximum is 0, or below, the maximum will be set to math.MaxInt64.
-func MockInputIntGenerateRandomPositive(count, max int) (ints []int) {
+func FuzzInputIntGenerateRandomPositive(count, max int) (ints []int) {
 	if max <= 0 {
 		max = math.MaxInt64
 	}
 
-	ints = append(ints, MockInputIntGenerateRandomRange(count, 1, max)...)
+	ints = append(ints, FuzzInputIntGenerateRandomRange(count, 1, max)...)
 
 	return
 }
 
-// MockInputIntGenerateRandomNegative generates random negative integers with a minimum of min.
+// FuzzInputIntGenerateRandomNegative generates random negative integers with a minimum of min.
 // If the minimum is 0, or above, the maximum will be set to math.MinInt64.
-func MockInputIntGenerateRandomNegative(count, min int) (ints []int) {
+func FuzzInputIntGenerateRandomNegative(count, min int) (ints []int) {
 	if min >= 0 {
 		min = math.MinInt64
 	}
 
 	min = int(math.Abs(float64(min)))
 
-	randomPositives := MockInputIntGenerateRandomPositive(count, min)
+	randomPositives := FuzzInputIntGenerateRandomPositive(count, min)
 
 	for _, p := range randomPositives {
 		ints = append(ints, p*-1)
@@ -59,18 +59,18 @@ func MockInputIntGenerateRandomNegative(count, min int) (ints []int) {
 	return
 }
 
-// MockInputIntRunTests runs a test for every value in a testset.
+// FuzzInputIntRunTests runs a test for every value in a testset.
 // You can use the value as input parameter for your functions, to sanity test against many different cases.
 // This ensures that your functions have a correct error handling and enables you to test against hunderts of cases easily.
 //
 // Example:
-//  testza.MockInputIntRunTests(t, testza.MockInputIntFull(), func(t *testing.T, index int, i int) {
+//  testza.FuzzInputIntRunTests(t, testza.FuzzInputIntFull(), func(t *testing.T, index int, i int) {
 //  	// Test logic
 //  	// err := YourFunction(i)
 //  	// testza.AssertNoError(t, err)
 //  	// ...
 //  })
-func MockInputIntRunTests(t testRunner, testSet []int, testFunc func(t *testing.T, index int, i int)) {
+func FuzzInputIntRunTests(t testRunner, testSet []int, testFunc func(t *testing.T, index int, i int)) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -90,13 +90,13 @@ func MockInputIntRunTests(t testRunner, testSet []int, testFunc func(t *testing.
 	}
 }
 
-// MockInputIntModify returns a modified version of a test set.
+// FuzzInputIntModify returns a modified version of a test set.
 //
 // Example:
-//  testset := testza.MockInputIntModify(testza.MockInputIntFull(), func(index int, value int) int {
+//  testset := testza.FuzzInputIntModify(testza.FuzzInputIntFull(), func(index int, value int) int {
 //  	return value * 2
 //  })
-func MockInputIntModify(inputSlice []int, modifier func(index int, value int) int) (ints []int) {
+func FuzzInputIntModify(inputSlice []int, modifier func(index int, value int) int) (ints []int) {
 	for i, input := range inputSlice {
 		ints = append(ints, modifier(i, input))
 	}
diff --git a/mock-strings.go b/fuzz-strings.go
similarity index 68%
rename from mock-strings.go
rename to fuzz-strings.go
index e6085a1..9c51e1f 100644
--- a/mock-strings.go
+++ b/fuzz-strings.go
@@ -7,45 +7,45 @@ import (
 	"github.com/MarvinJWendt/testza/internal"
 )
 
-// MockInputStringEmpty returns a test set with a single empty string.
-func MockInputStringEmpty() []string {
+// FuzzInputStringEmpty returns a test set with a single empty string.
+func FuzzInputStringEmpty() []string {
 	return []string{""}
 }
 
-// MockInputStringLong returns a test set with long random strings.
+// FuzzInputStringLong returns a test set with long random strings.
 // Returns:
 // [0]: Random string (length: 25)
 // [1]: Random string (length: 50)
 // [2]: Random string (length: 100)
 // [3]: Random string (length: 1,000)
 // [4]: Random string (length: 100,000)
-func MockInputStringLong() (testSet []string) {
-	testSet = append(testSet, MockInputStringGenerateRandom(1, 25)...)
-	testSet = append(testSet, MockInputStringGenerateRandom(1, 50)...)
-	testSet = append(testSet, MockInputStringGenerateRandom(1, 100)...)
-	testSet = append(testSet, MockInputStringGenerateRandom(1, 1_000)...)
-	testSet = append(testSet, MockInputStringGenerateRandom(1, 100_000)...)
+func FuzzInputStringLong() (testSet []string) {
+	testSet = append(testSet, FuzzInputStringGenerateRandom(1, 25)...)
+	testSet = append(testSet, FuzzInputStringGenerateRandom(1, 50)...)
+	testSet = append(testSet, FuzzInputStringGenerateRandom(1, 100)...)
+	testSet = append(testSet, FuzzInputStringGenerateRandom(1, 1_000)...)
+	testSet = append(testSet, FuzzInputStringGenerateRandom(1, 100_000)...)
 
 	return
 }
 
-// MockInputStringNumeric returns a test set with strings that are numeric.
+// FuzzInputStringNumeric returns a test set with strings that are numeric.
 // The highest number in here is "9223372036854775807", which is equal to the maxmim int64.
-func MockInputStringNumeric() []string {
+func FuzzInputStringNumeric() []string {
 	positiveNumbers := []string{"0", "1", "2", "3", "100", "1.1", "1337", "13.37", "0.000000000001", "9223372036854775807"}
-	negativeNumbers := MockInputStringModify(positiveNumbers, func(index int, value string) string { return "-" + value })
+	negativeNumbers := FuzzInputStringModify(positiveNumbers, func(index int, value string) string { return "-" + value })
 	return append(positiveNumbers, negativeNumbers...)
 }
 
-// MockInputStringUsernames returns a test set with usernames.
-func MockInputStringUsernames() []string {
+// FuzzInputStringUsernames returns a test set with usernames.
+func FuzzInputStringUsernames() []string {
 	return []string{"MarvinJWendt", "Zipper1337", "n00b", "l33t", "j0rgan", "test", "test123", "TEST", "test_", "TEST_"}
 }
 
-// MockInputStringEmailAddresses returns a test set with valid email addresses.
+// FuzzInputStringEmailAddresses returns a test set with valid email addresses.
 // The addresses may look like they are invalid, but they are all conform to RFC 2822 and could be used.
 // You can use this test set to test your email validation process.
-func MockInputStringEmailAddresses() []string {
+func FuzzInputStringEmailAddresses() []string {
 	return []string{
 		"hello@world.com",
 		"hello+world@example.com",
@@ -88,13 +88,13 @@ func MockInputStringEmailAddresses() []string {
 	}
 }
 
-// MockInputStringHtmlTags returns a test set with different html tags.
+// FuzzInputStringHtmlTags returns a test set with different html tags.
 //
 // Example:
 //  - <script>
 //  - <script>alert('XSS')</script>
 //  - <a href="https://github.com/MarvinJWendt/testza">link</a>
-func MockInputStringHtmlTags() []string {
+func FuzzInputStringHtmlTags() []string {
 	return []string{
 		"<script>alert('XSS')</script>",
 		"<script>",
@@ -104,25 +104,25 @@ func MockInputStringHtmlTags() []string {
 	}
 }
 
-// MockInputStringFull contains all string test sets plus ten generated random strings.
+// FuzzInputStringFull contains all string test sets plus ten generated random strings.
 // This test set is huge and should only be used if you want to make sure that no string, at all, can crash a process.
-func MockInputStringFull() (ret []string) {
-	ret = append(ret, MockInputStringUsernames()...)
-	ret = append(ret, MockInputStringHtmlTags()...)
-	ret = append(ret, MockInputStringEmailAddresses()...)
-	ret = append(ret, MockInputStringEmpty()...)
-	ret = append(ret, MockInputStringNumeric()...)
-	ret = append(ret, MockInputStringLong()...)
+func FuzzInputStringFull() (ret []string) {
+	ret = append(ret, FuzzInputStringUsernames()...)
+	ret = append(ret, FuzzInputStringHtmlTags()...)
+	ret = append(ret, FuzzInputStringEmailAddresses()...)
+	ret = append(ret, FuzzInputStringEmpty()...)
+	ret = append(ret, FuzzInputStringNumeric()...)
+	ret = append(ret, FuzzInputStringLong()...)
 
 	for i := 0; i < 10; i++ {
-		ret = append(ret, MockInputStringGenerateRandom(1, i)...)
+		ret = append(ret, FuzzInputStringGenerateRandom(1, i)...)
 	}
 
 	return
 }
 
-// MockInputStringLimit limits a test set in size.
-func MockInputStringLimit(testSet []string, max int) []string {
+// FuzzInputStringLimit limits a test set in size.
+func FuzzInputStringLimit(testSet []string, max int) []string {
 	if len(testSet) <= max {
 		return testSet
 	}
@@ -134,8 +134,8 @@ func MockInputStringLimit(testSet []string, max int) []string {
 	return testSet[:max]
 }
 
-// MockInputStringGenerateRandom returns random strings in a test set.
-func MockInputStringGenerateRandom(count, length int) (result []string) {
+// FuzzInputStringGenerateRandom returns random strings in a test set.
+func FuzzInputStringGenerateRandom(count, length int) (result []string) {
 	var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
 
 	for i := 0; i < count; i++ {
@@ -149,18 +149,18 @@ func MockInputStringGenerateRandom(count, length int) (result []string) {
 	return
 }
 
-// MockInputStringRunTests runs a test for every value in a testset.
+// FuzzInputStringRunTests runs a test for every value in a testset.
 // You can use the value as input parameter for your functions, to sanity test against many different cases.
 // This ensures that your functions have a correct error handling and enables you to test against hunderts of cases easily.
 //
 // Example:
-//  testza.MockInputStringRunTests(t, testza.MockInputStringFull(), func(t *testing.T, index int, str string) {
+//  testza.FuzzInputStringRunTests(t, testza.FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 //  	// Test logic
 //  	// err := YourFunction(str)
 //  	// testza.AssertNoError(t, err)
 //  	// ...
 //  })
-func MockInputStringRunTests(t testRunner, testSet []string, testFunc func(t *testing.T, index int, str string)) {
+func FuzzInputStringRunTests(t testRunner, testSet []string, testFunc func(t *testing.T, index int, str string)) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -180,13 +180,13 @@ func MockInputStringRunTests(t testRunner, testSet []string, testFunc func(t *te
 	}
 }
 
-// MockInputStringModify returns a modified version of a test set.
+// FuzzInputStringModify returns a modified version of a test set.
 //
 // Example:
-//  testset := testza.MockInputStringModify(testza.MockInputStringFull(), func(index int, value string) string {
+//  testset := testza.FuzzInputStringModify(testza.FuzzInputStringFull(), func(index int, value string) string {
 //  	return value + " some suffix"
 //  })
-func MockInputStringModify(inputSlice []string, modifier func(index int, value string) string) (ret []string) {
+func FuzzInputStringModify(inputSlice []string, modifier func(index int, value string) string) (ret []string) {
 	for i, str := range inputSlice {
 		ret = append(ret, modifier(i, str))
 	}


Test patch:
diff --git a/assert_test.go b/assert_test.go
index 155eec9..65dc2c4 100644
--- a/assert_test.go
+++ b/assert_test.go
@@ -29,7 +29,7 @@ type assertionTestStructNested struct {
 }
 
 func randomString() string {
-	return MockInputStringGenerateRandom(1, rand.Intn(10))[0]
+	return FuzzInputStringGenerateRandom(1, rand.Intn(10))[0]
 }
 
 func generateStruct() (ret assertionTestStruct) {
@@ -290,7 +290,7 @@ func TestAssertNotZero_fails(t *testing.T) {
 
 func TestAssertEqual(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+		FuzzInputStringRunTests(t, FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 			t.Helper()
 
 			testEqual(t, str, str)
@@ -323,7 +323,7 @@ func TestAssertEqual(t *testing.T) {
 
 func TestAssertEqual_fails(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+		FuzzInputStringRunTests(t, FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 			AssertTestFails(t, func(t TestingPackageWithFailFunctions) {
 				AssertEqual(t, str, str+" addon")
 			})
@@ -352,7 +352,7 @@ func TestAssertEqual_fails(t *testing.T) {
 
 func TestAssertNotEqual(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+		FuzzInputStringRunTests(t, FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 			AssertNotEqual(t, str, str+" addon")
 		})
 	})
@@ -375,7 +375,7 @@ func TestAssertNotEqual(t *testing.T) {
 
 func TestAssertNotEqual_fails(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+		FuzzInputStringRunTests(t, FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 			t.Helper()
 
 			AssertTestFails(t, func(t TestingPackageWithFailFunctions) {
@@ -418,7 +418,7 @@ func TestAssertNotEqual_fails(t *testing.T) {
 
 func TestAssertEqualValues(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+		FuzzInputStringRunTests(t, FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 			AssertEqualValues(t, str, str)
 		})
 	})
@@ -426,7 +426,7 @@ func TestAssertEqualValues(t *testing.T) {
 
 func TestAssertEqualValues_fails(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+		FuzzInputStringRunTests(t, FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 			AssertTestFails(t, func(t TestingPackageWithFailFunctions) {
 				AssertEqualValues(t, str, str+" addon")
 			})
@@ -436,7 +436,7 @@ func TestAssertEqualValues_fails(t *testing.T) {
 
 func TestAssertNotEqualValues(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+		FuzzInputStringRunTests(t, FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 			AssertNotEqualValues(t, str, str+" addon")
 		})
 	})
@@ -444,7 +444,7 @@ func TestAssertNotEqualValues(t *testing.T) {
 
 func TestAssertNotEqualValues_fails(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+		FuzzInputStringRunTests(t, FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 			AssertTestFails(t, func(t TestingPackageWithFailFunctions) {
 				AssertNotEqualValues(t, str, str)
 			})
@@ -800,7 +800,7 @@ func TestAssertLen_fails(t *testing.T) {
 }
 
 func TestAssertLen_full(t *testing.T) {
-	MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+	FuzzInputStringRunTests(t, FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 		AssertLen(t, str, len(str))
 	})
 }
@@ -929,7 +929,7 @@ func TestAssertIsDecreasing_fail(t *testing.T) {
 
 func TestAssertSameElements(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+		FuzzInputStringRunTests(t, FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 			t.Helper()
 
 			testEqual(t, str, str)
@@ -979,7 +979,7 @@ func TestAssertSameElements(t *testing.T) {
 
 func TestAssertSameElementsFails(t *testing.T) {
 	t.Run("Not an array", func(t *testing.T) {
-		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+		FuzzInputStringRunTests(t, FuzzInputStringFull(), func(t *testing.T, index int, str string) {
 			AssertTestFails(t, func(t TestingPackageWithFailFunctions) {
 				AssertSameElements(t, str, str)
 			})
diff --git a/configuration_test.go b/configuration_test.go
index 0d27828..68ca257 100644
--- a/configuration_test.go
+++ b/configuration_test.go
@@ -35,7 +35,7 @@ func TestSetLineNumbersEnabled(t *testing.T) {
 func TestSetRandomSeed(t *testing.T) {
 	SetRandomSeed(1337)
 	AssertEqual(t, int64(1337), randomSeed)
-	AssertEqual(t, "4U390O49B9", MockInputStringGenerateRandom(1, 10)[0])
+	AssertEqual(t, "4U390O49B9", FuzzInputStringGenerateRandom(1, 10)[0])
 	un := time.Now().UnixNano()
 	SetRandomSeed(un)
 	AssertEqual(t, un, randomSeed)
diff --git a/fuzz_test.go b/fuzz_test.go
new file mode 100644
index 0000000..118e8e6
--- /dev/null
+++ b/fuzz_test.go
@@ -0,0 +1,150 @@
+package testza_test
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+
+	. "github.com/MarvinJWendt/testza"
+)
+
+func TestFuzzInputStringModify(t *testing.T) {
+	stringSlice := []string{"Hello", "World", "TeSt"}
+	expected := []string{"hello", "world", "test"}
+
+	input := FuzzInputStringModify(stringSlice, func(index int, value string) string {
+		return strings.ToLower(value)
+	})
+
+	AssertEqual(t, expected, input)
+}
+
+func TestFuzzInputStringLimit(t *testing.T) {
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("Limit=%d", i), func(t *testing.T) {
+			AssertEqual(t, i, len(FuzzInputStringLimit(FuzzInputStringFull(), i)))
+		})
+	}
+}
+
+func TestFuzzInputStringGenerateRandom(t *testing.T) {
+	for i := 0; i < 100; i++ {
+		t.Run(fmt.Sprintf("Length=%d", i), func(t *testing.T) {
+			AssertEqual(t, i, len(FuzzInputStringGenerateRandom(1, i)[0]))
+		})
+	}
+
+	for i := 0; i < 100; i++ {
+		t.Run(fmt.Sprintf("Count=%d", i), func(t *testing.T) {
+			AssertEqual(t, i, len(FuzzInputStringGenerateRandom(i, 5)))
+		})
+	}
+}
+
+func TestFuzzInputStringNumeric(t *testing.T) {
+	for _, v := range FuzzInputStringNumeric() {
+		t.Run(v, func(t *testing.T) {
+			f, err := strconv.ParseFloat(v, 64)
+			AssertNumeric(t, f)
+			AssertNoError(t, err)
+		})
+	}
+}
+
+func TestFuzzInputStringFull(t *testing.T) {
+	AssertGreater(t, len(FuzzInputStringFull()), 0)
+}
+
+func TestFuzzInputBoolFull(t *testing.T) {
+	AssertEqual(t, []bool{true, false}, FuzzInputBoolFull())
+}
+
+func TestFuzzInputBoolRunTests(t *testing.T) {
+	FuzzInputBoolRunTests(t, FuzzInputBoolFull(), func(t *testing.T, index int, f bool) {
+		AssertNotNil(t, f)
+	})
+}
+
+func TestFuzzInputIntGenerateRandomPositive(t *testing.T) {
+	for i := 0; i < 100; i++ {
+		t.Run("GenerateRandomPositive generates positive numbers only", func(t *testing.T) {
+			AssertGreater(t, FuzzInputIntGenerateRandomPositive(1, 100)[0], 0)
+		})
+
+		t.Run("GenerateRandomNegative generates negative numbers only", func(t *testing.T) {
+			AssertLess(t, FuzzInputIntGenerateRandomNegative(1, 100)[0], 0)
+		})
+	}
+}
+
+func TestFuzzInputIntFull(t *testing.T) {
+	AssertGreater(t, len(FuzzInputIntFull()), 0)
+}
+
+func TestFuzzInputIntRunTests(t *testing.T) {
+	FuzzInputIntRunTests(t, FuzzInputIntFull(), func(t *testing.T, index int, f int) {
+		AssertNotNil(t, f)
+	})
+}
+
+func TestFuzzInputIntModify(t *testing.T) {
+	testSet := FuzzInputIntFull()
+	s := FuzzInputIntModify(testSet, func(index int, value int) int {
+		return value * -1
+	})
+
+	for i, f := range testSet {
+		t.Run("Number should be inverted", func(t *testing.T) {
+			AssertEqual(t, f, s[i]*-1)
+		})
+	}
+}
+
+func TestFuzzInputFloat64Full(t *testing.T) {
+	AssertGreater(t, len(FuzzInputFloat64Full()), 0)
+}
+
+func TestFuzzInputFloat64RunTests(t *testing.T) {
+	FuzzInputFloat64RunTests(t, FuzzInputFloat64Full(), func(t *testing.T, index int, f float64) {
+		AssertNotNil(t, f)
+	})
+}
+
+func TestFuzzInputFloat64GenerateRandomNegative(t *testing.T) {
+	for i := 0; i < 100; i++ {
+		n := FuzzInputFloat64GenerateRandomNegative(1, 0)[0]
+		t.Run(fmt.Sprintf("%v must be negative", n), func(t *testing.T) {
+			AssertLess(t, n, 0)
+		})
+	}
+}
+
+func TestFuzzInputFloat64GenerateRandomPositive(t *testing.T) {
+	for i := 0; i < 100; i++ {
+		n := FuzzInputFloat64GenerateRandomPositive(1, 0)[0]
+		t.Run(fmt.Sprintf("%v must be positive", n), func(t *testing.T) {
+			AssertGreater(t, n, 0)
+		})
+	}
+}
+
+func TestFuzzInputFloat64Modify(t *testing.T) {
+	testSet := FuzzInputFloat64Full()
+	s := FuzzInputFloat64Modify(testSet, func(index int, value float64) float64 {
+		return value * -1
+	})
+
+	for i, f := range testSet {
+		t.Run("Number should be inverted", func(t *testing.T) {
+			AssertEqual(t, f, s[i]*-1)
+		})
+	}
+}
+
+func TestFuzzInputBoolModify(t *testing.T) {
+	s := FuzzInputBoolModify(FuzzInputBoolFull(), func(index int, value bool) bool {
+		return !value
+	})
+	AssertEqual(t, []bool{false, true}, s)
+}
diff --git a/mock_test.go b/mock_test.go
deleted file mode 100644
index fd035f7..0000000
--- a/mock_test.go
+++ /dev/null
@@ -1,150 +0,0 @@
-package testza_test
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"testing"
-
-	. "github.com/MarvinJWendt/testza"
-)
-
-func TestMockInputStringModify(t *testing.T) {
-	stringSlice := []string{"Hello", "World", "TeSt"}
-	expected := []string{"hello", "world", "test"}
-
-	input := MockInputStringModify(stringSlice, func(index int, value string) string {
-		return strings.ToLower(value)
-	})
-
-	AssertEqual(t, expected, input)
-}
-
-func TestMockInputStringLimit(t *testing.T) {
-	for i := 0; i < 10; i++ {
-		t.Run(fmt.Sprintf("Limit=%d", i), func(t *testing.T) {
-			AssertEqual(t, i, len(MockInputStringLimit(MockInputStringFull(), i)))
-		})
-	}
-}
-
-func TestMockInputStringGenerateRandom(t *testing.T) {
-	for i := 0; i < 100; i++ {
-		t.Run(fmt.Sprintf("Length=%d", i), func(t *testing.T) {
-			AssertEqual(t, i, len(MockInputStringGenerateRandom(1, i)[0]))
-		})
-	}
-
-	for i := 0; i < 100; i++ {
-		t.Run(fmt.Sprintf("Count=%d", i), func(t *testing.T) {
-			AssertEqual(t, i, len(MockInputStringGenerateRandom(i, 5)))
-		})
-	}
-}
-
-func TestMockInputStringNumeric(t *testing.T) {
-	for _, v := range MockInputStringNumeric() {
-		t.Run(v, func(t *testing.T) {
-			f, err := strconv.ParseFloat(v, 64)
-			AssertNumeric(t, f)
-			AssertNoError(t, err)
-		})
-	}
-}
-
-func TestMockInputStringFull(t *testing.T) {
-	AssertGreater(t, len(MockInputStringFull()), 0)
-}
-
-func TestMockInputBoolFull(t *testing.T) {
-	AssertEqual(t, []bool{true, false}, MockInputBoolFull())
-}
-
-func TestMockInputBoolRunTests(t *testing.T) {
-	MockInputBoolRunTests(t, MockInputBoolFull(), func(t *testing.T, index int, f bool) {
-		AssertNotNil(t, f)
-	})
-}
-
-func TestMockInputIntGenerateRandomPositive(t *testing.T) {
-	for i := 0; i < 100; i++ {
-		t.Run("GenerateRandomPositive generates positive numbers only", func(t *testing.T) {
-			AssertGreater(t, MockInputIntGenerateRandomPositive(1, 100)[0], 0)
-		})
-
-		t.Run("GenerateRandomNegative generates negative numbers only", func(t *testing.T) {
-			AssertLess(t, MockInputIntGenerateRandomNegative(1, 100)[0], 0)
-		})
-	}
-}
-
-func TestMockInputIntFull(t *testing.T) {
-	AssertGreater(t, len(MockInputIntFull()), 0)
-}
-
-func TestMockInputIntRunTests(t *testing.T) {
-	MockInputIntRunTests(t, MockInputIntFull(), func(t *testing.T, index int, f int) {
-		AssertNotNil(t, f)
-	})
-}
-
-func TestMockInputIntModify(t *testing.T) {
-	testSet := MockInputIntFull()
-	s := MockInputIntModify(testSet, func(index int, value int) int {
-		return value * -1
-	})
-
-	for i, f := range testSet {
-		t.Run("Number should be inverted", func(t *testing.T) {
-			AssertEqual(t, f, s[i]*-1)
-		})
-	}
-}
-
-func TestMockInputFloat64Full(t *testing.T) {
-	AssertGreater(t, len(MockInputFloat64Full()), 0)
-}
-
-func TestMockInputFloat64RunTests(t *testing.T) {
-	MockInputFloat64RunTests(t, MockInputFloat64Full(), func(t *testing.T, index int, f float64) {
-		AssertNotNil(t, f)
-	})
-}
-
-func TestMockInputFloat64GenerateRandomNegative(t *testing.T) {
-	for i := 0; i < 100; i++ {
-		n := MockInputFloat64GenerateRandomNegative(1, 0)[0]
-		t.Run(fmt.Sprintf("%v must be negative", n), func(t *testing.T) {
-			AssertLess(t, n, 0)
-		})
-	}
-}
-
-func TestMockInputFloat64GenerateRandomPositive(t *testing.T) {
-	for i := 0; i < 100; i++ {
-		n := MockInputFloat64GenerateRandomPositive(1, 0)[0]
-		t.Run(fmt.Sprintf("%v must be positive", n), func(t *testing.T) {
-			AssertGreater(t, n, 0)
-		})
-	}
-}
-
-func TestMockInputFloat64Modify(t *testing.T) {
-	testSet := MockInputFloat64Full()
-	s := MockInputFloat64Modify(testSet, func(index int, value float64) float64 {
-		return value * -1
-	})
-
-	for i, f := range testSet {
-		t.Run("Number should be inverted", func(t *testing.T) {
-			AssertEqual(t, f, s[i]*-1)
-		})
-	}
-}
-
-func TestMockInputBoolModify(t *testing.T) {
-	s := MockInputBoolModify(MockInputBoolFull(), func(index int, value bool) bool {
-		return !value
-	})
-	AssertEqual(t, []bool{false, true}, s)
-}
diff --git a/snapshot_test.go b/snapshot_test.go
index 10b8696..8be2dda 100644
--- a/snapshot_test.go
+++ b/snapshot_test.go
@@ -55,7 +55,7 @@ func TestSnapshotCreateOrValidate(t *testing.T) {
 }
 
 func TestSnapshotCreateOrValidate_create_random(t *testing.T) {
-	name := t.Name() + testza.MockInputStringGenerateRandom(1, rand.Intn(10))[0]
+	name := t.Name() + testza.FuzzInputStringGenerateRandom(1, rand.Intn(10))[0]
 	err := testza.SnapshotCreateOrValidate(t, name, snapshotObject)
 	testza.AssertNoError(t, err)