Repository: MarvinJWendt/testza
Pull request #6 (2021-07-19 11:44:45)

refactor: change structure
BREAKING CHANGE: Functions have a new structure.


Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 25f1ef9..d73864e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,10 @@
 <a name="unreleased"></a>
 ## [Unreleased]
 
+### Code Refactoring
+- rewrite CI to new structure
+- change structure
+
 
 <a name="v0.0.3"></a>
 ## [v0.0.3] - 2021-07-17
diff --git a/README.md b/README.md
index 397aea8..fbe653b 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-1467-magenta?style=flat-square" alt="Unit test count"><!-- unittestcount:end -->
+<!-- unittestcount:start --><img src="https://img.shields.io/badge/Unit_Tests-1469-magenta?style=flat-square" alt="Unit test count"><!-- unittestcount:end -->
 </a>
 
 <a href="https://github.com/MarvinJWendt/testza/issues">
@@ -59,56 +59,41 @@ 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 is structured a bit differently than you might be used to in Go, but we think that it makes writing tests as easy and efficient as possible.  
-After all, writing tests should be very simple and should not require you to study a whole framework.  
-That's why we made testza to integrate perfectly with your IDE.
-You don't even have to lookup the documentation, as testza is self-explanatory.
+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.
 
 ## Getting Started
 
 Testza is very IDE friendly and was made to integrate with your IDE to increase your productivity.  
 
 ```go
-   ┌ Testza package
-   |    ┌ Container for all testza modules
-   |    |     ┌ The module you want to use (Press Ctrl+Space to see a list of all modules)
-testza.Use.XXXXXXX
-
-
 // --- Some Examples ---
 
 // - Some assertions -
-testza.Use.Assert.True(t, true) // -> Pass
-testza.Use.Assert.NoError(t, err) // -> Pass
-testza.Use.Assert.Equal(t, object, object) // -> Pass
+testza.AssertTrue(t, true) // -> Pass
+testza.AssertNoError(t, err) // -> Pass
+testza.AssertEqual(t, object, object) // -> Pass
 // ...
 
 // - Testing console output -
 // Test the output of your CLI tool easily!
-terminalOutput, _ := testza.Use.Capture.Stdout(func(w io.Writer) error {fmt.Println("Hello"); return nil})
-testza.Use.Assert.Equal(t, terminalOutput, "Hello\n") // -> Pass
+terminalOutput, _ := testza.CaptureStdout(func(w io.Writer) error {fmt.Println("Hello"); return nil})
+testza.AssertEqual(t, terminalOutput, "Hello\n") // -> Pass
 
 // - Mocking -
 // Testing a function that accepts email addresses as a parameter:
 
 // Testset of many different email addresses
-emailAddresses := testza.Use.Mock.Strings.EmailAddresses()
+emailAddresses := testza.MockStringEmailAddresses()
 
 // Run a test for every string in the test set
-testza.Use.Mock.Strings.RunTests(t, emailAddresses, func(t *testing.T, index int, str string) {
+testza.MockStringRunTests(t, emailAddresses, func(t *testing.T, index int, str string) {
   user, domain, err := internal.ParseEmailAddress(str) // Use your function
-  testza.Use.Assert.NoError(t, err) // Assert that your function does not return an error
-  testza.Use.Assert.NotZero(t, user) // Assert that the user is returned
-  testza.Use.Assert.NotZero(t, domain) // Assert that the domain is returned
+  testza.AssertNoError(t, err) // Assert that your function does not return an error
+  testza.AssertNotZero(t, user) // Assert that the user is returned
+  testza.AssertNotZero(t, domain) // Assert that the domain is returned
 })
 
-// - Aliases -
-// You can use aliases to shorten the usage of testza for modules that you use often!
-
-var assert = testza.Use.Assert
-var stringTests = testza.Use.Mock.Strings
-// ...
-
 // And that's just a few examples of what you can do with Testza!
 ```
 
@@ -126,31 +111,31 @@ var stringTests = testza.Use.Mock.Strings
 <details>
 <summary>Click to expand</summary>
 
-  - [CompletesIn](https://github.com/MarvinJWendt/testza#testzaUseAssertCompletesIn)
-  - [Contains](https://github.com/MarvinJWendt/testza#testzaUseAssertContains)
-  - [Equal](https://github.com/MarvinJWendt/testza#testzaUseAssertEqual)
-  - [EqualValues](https://github.com/MarvinJWendt/testza#testzaUseAssertEqualValues)
-  - [False](https://github.com/MarvinJWendt/testza#testzaUseAssertFalse)
-  - [Greater](https://github.com/MarvinJWendt/testza#testzaUseAssertGreater)
-  - [Implements](https://github.com/MarvinJWendt/testza#testzaUseAssertImplements)
-  - [KindOf](https://github.com/MarvinJWendt/testza#testzaUseAssertKindOf)
-  - [Less](https://github.com/MarvinJWendt/testza#testzaUseAssertLess)
-  - [Nil](https://github.com/MarvinJWendt/testza#testzaUseAssertNil)
-  - [NoError](https://github.com/MarvinJWendt/testza#testzaUseAssertNoError)
-  - [NotCompletesIn](https://github.com/MarvinJWendt/testza#testzaUseAssertNotCompletesIn)
-  - [NotContains](https://github.com/MarvinJWendt/testza#testzaUseAssertNotContains)
-  - [NotEqual](https://github.com/MarvinJWendt/testza#testzaUseAssertNotEqual)
-  - [NotEqualValues](https://github.com/MarvinJWendt/testza#testzaUseAssertNotEqualValues)
-  - [NotImplements](https://github.com/MarvinJWendt/testza#testzaUseAssertNotImplements)
-  - [NotKindOf](https://github.com/MarvinJWendt/testza#testzaUseAssertNotKindOf)
-  - [NotNil](https://github.com/MarvinJWendt/testza#testzaUseAssertNotNil)
-  - [NotNumeric](https://github.com/MarvinJWendt/testza#testzaUseAssertNotNumeric)
-  - [NotPanic](https://github.com/MarvinJWendt/testza#testzaUseAssertNotPanic)
-  - [NotZero](https://github.com/MarvinJWendt/testza#testzaUseAssertNotZero)
-  - [Numeric](https://github.com/MarvinJWendt/testza#testzaUseAssertNumeric)
-  - [Panic](https://github.com/MarvinJWendt/testza#testzaUseAssertPanic)
-  - [True](https://github.com/MarvinJWendt/testza#testzaUseAssertTrue)
-  - [Zero](https://github.com/MarvinJWendt/testza#testzaUseAssertZero)
+  - [AssertCompletesIn](https://github.com/MarvinJWendt/testza#AssertCompletesIn)
+  - [AssertContains](https://github.com/MarvinJWendt/testza#AssertContains)
+  - [AssertEqual](https://github.com/MarvinJWendt/testza#AssertEqual)
+  - [AssertEqualValues](https://github.com/MarvinJWendt/testza#AssertEqualValues)
+  - [AssertFalse](https://github.com/MarvinJWendt/testza#AssertFalse)
+  - [AssertGreater](https://github.com/MarvinJWendt/testza#AssertGreater)
+  - [AssertImplements](https://github.com/MarvinJWendt/testza#AssertImplements)
+  - [AssertKindOf](https://github.com/MarvinJWendt/testza#AssertKindOf)
+  - [AssertLess](https://github.com/MarvinJWendt/testza#AssertLess)
+  - [AssertNil](https://github.com/MarvinJWendt/testza#AssertNil)
+  - [AssertNoError](https://github.com/MarvinJWendt/testza#AssertNoError)
+  - [AssertNotCompletesIn](https://github.com/MarvinJWendt/testza#AssertNotCompletesIn)
+  - [AssertNotContains](https://github.com/MarvinJWendt/testza#AssertNotContains)
+  - [AssertNotEqual](https://github.com/MarvinJWendt/testza#AssertNotEqual)
+  - [AssertNotEqualValues](https://github.com/MarvinJWendt/testza#AssertNotEqualValues)
+  - [AssertNotImplements](https://github.com/MarvinJWendt/testza#AssertNotImplements)
+  - [AssertNotKindOf](https://github.com/MarvinJWendt/testza#AssertNotKindOf)
+  - [AssertNotNil](https://github.com/MarvinJWendt/testza#AssertNotNil)
+  - [AssertNotNumeric](https://github.com/MarvinJWendt/testza#AssertNotNumeric)
+  - [AssertNotPanic](https://github.com/MarvinJWendt/testza#AssertNotPanic)
+  - [AssertNotZero](https://github.com/MarvinJWendt/testza#AssertNotZero)
+  - [AssertNumeric](https://github.com/MarvinJWendt/testza#AssertNumeric)
+  - [AssertPanic](https://github.com/MarvinJWendt/testza#AssertPanic)
+  - [AssertTrue](https://github.com/MarvinJWendt/testza#AssertTrue)
+  - [AssertZero](https://github.com/MarvinJWendt/testza#AssertZero)
 </td>
 
 </details>
@@ -163,81 +148,81 @@ var stringTests = testza.Use.Mock.Strings
 <details>
 <summary>Click to expand</summary>
 
-  - [Stderr](https://github.com/MarvinJWendt/testza#testzaUseCaptureStderr)
-  - [Stdout](https://github.com/MarvinJWendt/testza#testzaUseCaptureStdout)
+  - [CaptureStderr](https://github.com/MarvinJWendt/testza#CaptureStderr)
+  - [CaptureStdout](https://github.com/MarvinJWendt/testza#CaptureStdout)
 </td>
 
 </details>
 
 </tr>
 <tr>
-<td><a href="https://github.com/MarvinJWendt/testza#MockInputsStrings">Mock.Inputs.Strings</a></td>
+<td><a href="https://github.com/MarvinJWendt/testza#MockInputBool">Mock Input Bool</a></td>
 <td>
 
 <details>
 <summary>Click to expand</summary>
 
-  - [EmailAddresses](https://github.com/MarvinJWendt/testza#testzaUseMockInputsInputsStringsEmailAddresses)
-  - [Empty](https://github.com/MarvinJWendt/testza#testzaUseMockInputsInputsStringsEmpty)
-  - [Full](https://github.com/MarvinJWendt/testza#testzaUseMockInputsInputsStringsFull)
-  - [GenerateRandom](https://github.com/MarvinJWendt/testza#testzaUseMockInputsInputsStringsGenerateRandom)
-  - [HtmlTags](https://github.com/MarvinJWendt/testza#testzaUseMockInputsInputsStringsHtmlTags)
-  - [Limit](https://github.com/MarvinJWendt/testza#testzaUseMockInputsInputsStringsLimit)
-  - [Long](https://github.com/MarvinJWendt/testza#testzaUseMockInputsInputsStringsLong)
-  - [Modify](https://github.com/MarvinJWendt/testza#testzaUseMockInputsInputsStringsModify)
-  - [Numeric](https://github.com/MarvinJWendt/testza#testzaUseMockInputsInputsStringsNumeric)
-  - [RunTests](https://github.com/MarvinJWendt/testza#testzaUseMockInputsInputsStringsRunTests)
+  - [MockInputBoolFull](https://github.com/MarvinJWendt/testza#MockInputBoolFull)
+  - [MockInputBoolModify](https://github.com/MarvinJWendt/testza#MockInputBoolModify)
+  - [MockInputBoolRunTests](https://github.com/MarvinJWendt/testza#MockInputBoolRunTests)
 </td>
 
 </details>
 
 </tr>
 <tr>
-<td><a href="https://github.com/MarvinJWendt/testza#MockInputsBools">Mock.Inputs.Bools</a></td>
+<td><a href="https://github.com/MarvinJWendt/testza#MockInputString">Mock Input String</a></td>
 <td>
 
 <details>
 <summary>Click to expand</summary>
 
-  - [Full](https://github.com/MarvinJWendt/testza#testzaUseMockInputsBoolsFull)
-  - [Modify](https://github.com/MarvinJWendt/testza#testzaUseMockInputsBoolsModify)
-  - [RunTests](https://github.com/MarvinJWendt/testza#testzaUseMockInputsBoolsRunTests)
+  - [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)
 </td>
 
 </details>
 
 </tr>
 <tr>
-<td><a href="https://github.com/MarvinJWendt/testza#MockInputsFloats64">Mock.Inputs.Floats64</a></td>
+<td><a href="https://github.com/MarvinJWendt/testza#MockInputFloat64">Mock Input Float64</a></td>
 <td>
 
 <details>
 <summary>Click to expand</summary>
 
-  - [Full](https://github.com/MarvinJWendt/testza#testzaUseMockInputsFloats64Full)
-  - [GenerateRandomNegative](https://github.com/MarvinJWendt/testza#testzaUseMockInputsFloats64GenerateRandomNegative)
-  - [GenerateRandomPositive](https://github.com/MarvinJWendt/testza#testzaUseMockInputsFloats64GenerateRandomPositive)
-  - [GenerateRandomRange](https://github.com/MarvinJWendt/testza#testzaUseMockInputsFloats64GenerateRandomRange)
-  - [Modify](https://github.com/MarvinJWendt/testza#testzaUseMockInputsFloats64Modify)
-  - [RunTests](https://github.com/MarvinJWendt/testza#testzaUseMockInputsFloats64RunTests)
+  - [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)
 </td>
 
 </details>
 
 </tr>
 <tr>
-<td><a href="https://github.com/MarvinJWendt/testza#MockInputsInts">Mock.Inputs.Ints</a></td>
+<td><a href="https://github.com/MarvinJWendt/testza#MockInputInt">Mock Input Int</a></td>
 <td>
 
 <details>
 <summary>Click to expand</summary>
 
-  - [Full](https://github.com/MarvinJWendt/testza#testzaUseMockInputsIntsFull)
-  - [GenerateRandomNegative](https://github.com/MarvinJWendt/testza#testzaUseMockInputsIntsGenerateRandomNegative)
-  - [GenerateRandomPositive](https://github.com/MarvinJWendt/testza#testzaUseMockInputsIntsGenerateRandomPositive)
-  - [GenerateRandomRange](https://github.com/MarvinJWendt/testza#testzaUseMockInputsIntsGenerateRandomRange)
-  - [Modify](https://github.com/MarvinJWendt/testza#testzaUseMockInputsIntsModify)
-  - [RunTests](https://github.com/MarvinJWendt/testza#testzaUseMockInputsIntsRunTests)
+  - [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)
 </td>
 
 </details>
@@ -247,489 +232,496 @@ var stringTests = testza.Use.Mock.Strings
 
 ### Assert
 
-#### testza.Use.Assert.CompletesIn
+#### AssertCompletesIn
 
 ```go
-func CompletesIn(t testRunner, duration time.Duration, f func(), msg ...interface{})
+func AssertCompletesIn(t testRunner, duration time.Duration, f func(), msg ...interface{})
 ```
 
-CompletesIn asserts that a function completes in a given time. Use this
-function to test that functions do not take too long to complete.
+AssertCompletesIn asserts that a function completes in a given time. Use
+this function to test that functions do not take too long to complete.
 
 NOTE: Every system takes a different amount of time to complete a function.
 Do not set the duration too low, if you want consistent results.
 
-#### testza.Use.Assert.Contains
+#### AssertContains
 
 ```go
-func Contains(t testRunner, object, element interface{}, msg ...interface{})
+func AssertContains(t testRunner, object, element interface{}, msg ...interface{})
 ```
 
+AssertContains asserts that a string/list/array/slice/map contains the
+specified element.
 
-
-#### testza.Use.Assert.Equal
+#### AssertEqual
 
 ```go
-func Equal(t testRunner, expected interface{}, actual interface{}, msg ...interface{})
+func AssertEqual(t testRunner, expected interface{}, actual interface{}, msg ...interface{})
 ```
 
-Equal asserts that two objects are equal.
+AssertEqual asserts that two objects are equal.
 
-#### testza.Use.Assert.EqualValues
+#### AssertEqualValues
 
 ```go
-func EqualValues(t testRunner, expected interface{}, actual interface{}, msg ...interface{})
+func AssertEqualValues(t testRunner, expected interface{}, actual interface{}, msg ...interface{})
 ```
 
-EqualValues asserts that two objects have equal values.
+AssertEqualValues asserts that two objects have equal values.
 
-#### testza.Use.Assert.False
+#### AssertFalse
 
 ```go
-func False(t testRunner, value interface{}, msg ...interface{})
+func AssertFalse(t testRunner, value interface{}, msg ...interface{})
 ```
 
-False asserts that an expression or object resolves to false.
+AssertFalse asserts that an expression or object resolves to false.
 
-#### testza.Use.Assert.Greater
+#### AssertGreater
 
 ```go
-func Greater(t testRunner, object1, object2 interface{}, msg ...interface{})
+func AssertGreater(t testRunner, object1, object2 interface{}, msg ...interface{})
 ```
 
-Greater asserts that the first object is greater than the second.
+AssertGreater asserts that the first object is greater than the second.
 
-#### testza.Use.Assert.Implements
+#### AssertImplements
 
 ```go
-func Implements(t testRunner, interfaceObject, object interface{}, msg ...interface{})
+func AssertImplements(t testRunner, interfaceObject, object interface{}, msg ...interface{})
 ```
 
-Implements checks if an objects implements an interface.
+AssertImplements asserts that an objects implements an interface.
 
-    testza.Use.Assert.Implements(t, (*YourInterface)(nil), new(YourObject))
-    testza.Use.Assert.Implements(t, (*fmt.Stringer)(nil), new(types.Const)) => pass
+    testza.AssertImplements(t, (*YourInterface)(nil), new(YourObject))
+    testza.AssertImplements(t, (*fmt.Stringer)(nil), new(types.Const)) => pass
 
-#### testza.Use.Assert.KindOf
+#### AssertKindOf
 
 ```go
-func KindOf(t testRunner, expectedKind reflect.Kind, object interface{}, msg ...interface{})
+func AssertKindOf(t testRunner, expectedKind reflect.Kind, object interface{}, msg ...interface{})
 ```
 
-KindOf asserts that the object is a type of kind exptectedKind.
+AssertKindOf asserts that the object is a type of kind exptectedKind.
 
-#### testza.Use.Assert.Less
+#### AssertLess
 
 ```go
-func Less(t testRunner, object1, object2 interface{}, msg ...interface{})
+func AssertLess(t testRunner, object1, object2 interface{}, msg ...interface{})
 ```
 
-Less asserts that the first object is less than the second.
+AssertLess asserts that the first object is less than the second.
 
-#### testza.Use.Assert.Nil
+#### AssertNil
 
 ```go
-func Nil(t testRunner, object interface{}, msg ...interface{})
+func AssertNil(t testRunner, object interface{}, msg ...interface{})
 ```
 
-Nil asserts that an object is nil.
+AssertNil asserts that an object is nil.
 
-#### testza.Use.Assert.NoError
+#### AssertNoError
 
 ```go
-func NoError(t testRunner, err interface{}, msg ...interface{})
+func AssertNoError(t testRunner, err interface{}, msg ...interface{})
 ```
 
-NoError asserts that an error is nil.
+AssertNoError asserts that an error is nil.
 
-#### testza.Use.Assert.NotCompletesIn
+#### AssertNotCompletesIn
 
 ```go
-func NotCompletesIn(t testRunner, duration time.Duration, f func(), msg ...interface{})
+func AssertNotCompletesIn(t testRunner, duration time.Duration, f func(), msg ...interface{})
 ```
 
-NotCompletesIn asserts that a function does not complete in a given time.
-Use this function to test that functions do not complete to quickly. For
-example if your database connection completes in under a millisecond, there
-might be something wrong.
+AssertNotCompletesIn asserts that a function does not complete in a given
+time. Use this function to test that functions do not complete to quickly.
+For example if your database connection completes in under a millisecond,
+there might be something wrong.
 
 NOTE: Every system takes a different amount of time to complete a function.
 Do not set the duration too high, if you want consistent results.
 
-#### testza.Use.Assert.NotContains
+#### AssertNotContains
 
 ```go
-func NotContains(t testRunner, object, element interface{}, msg ...interface{})
+func AssertNotContains(t testRunner, object, element interface{}, msg ...interface{})
 ```
 
+AssertNotContains asserts that a string/list/array/slice/map does not
+contain the specified element.
 
-
-#### testza.Use.Assert.NotEqual
+#### AssertNotEqual
 
 ```go
-func NotEqual(t testRunner, expected interface{}, actual interface{}, msg ...interface{})
+func AssertNotEqual(t testRunner, expected interface{}, actual interface{}, msg ...interface{})
 ```
 
-NotEqual asserts that two objects are not equal.
+AssertNotEqual asserts that two objects are not equal.
 
-#### testza.Use.Assert.NotEqualValues
+#### AssertNotEqualValues
 
 ```go
-func NotEqualValues(t testRunner, expected interface{}, actual interface{}, msg ...interface{})
+func AssertNotEqualValues(t testRunner, expected interface{}, actual interface{}, msg ...interface{})
 ```
 
-NotEqualValues asserts that two objects do not have equal values.
+AssertNotEqualValues asserts that two objects do not have equal values.
 
-#### testza.Use.Assert.NotImplements
+#### AssertNotImplements
 
 ```go
-func NotImplements(t testRunner, interfaceObject, object interface{}, msg ...interface{})
+func AssertNotImplements(t testRunner, interfaceObject, object interface{}, msg ...interface{})
 ```
 
-NotImplements checks if an object does not implement an interface.
+AssertNotImplements asserts that an object does not implement an interface.
 
-    testza.Use.Assert.NotImplements(t, (*YourInterface)(nil), new(YourObject))
-    testza.Use.Assert.NotImplements(t, (*fmt.Stringer)(nil), new(types.Const)) => fail, because types.Const does implement fmt.Stringer.
+    testza.AssertNotImplements(t, (*YourInterface)(nil), new(YourObject))
+    testza.AssertNotImplements(t, (*fmt.Stringer)(nil), new(types.Const)) => fail, because types.Const does implement fmt.Stringer.
 
-#### testza.Use.Assert.NotKindOf
+#### AssertNotKindOf
 
 ```go
-func NotKindOf(t testRunner, kind reflect.Kind, object interface{}, msg ...interface{})
+func AssertNotKindOf(t testRunner, kind reflect.Kind, object interface{}, msg ...interface{})
 ```
 
-NotKindOf asserts that the object is not a type of kind `kind`.
+AssertNotKindOf asserts that the object is not a type of kind `kind`.
 
-#### testza.Use.Assert.NotNil
+#### AssertNotNil
 
 ```go
-func NotNil(t testRunner, object interface{}, msg ...interface{})
+func AssertNotNil(t testRunner, object interface{}, msg ...interface{})
 ```
 
-NotNil assertsthat an object is not nil.
+AssertNotNil asserts that an object is not nil.
 
-#### testza.Use.Assert.NotNumeric
+#### AssertNotNumeric
 
 ```go
-func NotNumeric(t testRunner, object interface{}, msg ...interface{})
+func AssertNotNumeric(t testRunner, object interface{}, msg ...interface{})
 ```
 
-Number checks if the object is not a numeric type. Numeric types are: Int,
-Int8, Int16, Int32, Int64, Float32, Float64, Uint, Uint8, Uint16, Uint32,
-Uint64, Complex64 and Complex128.
+AssertNotNumeric checks if the object is not a numeric type. Numeric types
+are: Int, Int8, Int16, Int32, Int64, Float32, Float64, Uint, Uint8, Uint16,
+Uint32, Uint64, Complex64 and Complex128.
 
-#### testza.Use.Assert.NotPanic
+#### AssertNotPanic
 
 ```go
-func NotPanic(t testRunner, f func(), msg ...interface{})
+func AssertNotPanic(t testRunner, f func(), msg ...interface{})
 ```
 
-NotPanic asserts that a function does not panic.
+AssertNotPanic asserts that a function does not panic.
 
-#### testza.Use.Assert.NotZero
+#### AssertNotZero
 
 ```go
-func NotZero(t testRunner, value interface{}, msg ...interface{})
+func AssertNotZero(t testRunner, value interface{}, msg ...interface{})
 ```
 
-NotZero asserts that the value is not the zero value for it's type.
+AssertNotZero asserts that the value is not the zero value for it's type.
 
-    testza.Use.Assert.NotZero(t, 1337)
-    testza.Use.Assert.NotZero(t, true)
-    testza.Use.Assert.NotZero(t, "Hello, World")
+    testza.AssertNotZero(t, 1337)
+    testza.AssertNotZero(t, true)
+    testza.AssertNotZero(t, "Hello, World")
 
-#### testza.Use.Assert.Numeric
+#### AssertNumeric
 
 ```go
-func Numeric(t testRunner, object interface{}, msg ...interface{})
+func AssertNumeric(t testRunner, object interface{}, msg ...interface{})
 ```
 
-Numeric asserts that the object is a numeric type. Numeric types are: Int,
-Int8, Int16, Int32, Int64, Float32, Float64, Uint, Uint8, Uint16, Uint32,
-Uint64, Complex64 and Complex128.
+AssertNumeric asserts that the object is a numeric type. Numeric types are:
+Int, Int8, Int16, Int32, Int64, Float32, Float64, Uint, Uint8, Uint16,
+Uint32, Uint64, Complex64 and Complex128.
 
-#### testza.Use.Assert.Panic
+#### AssertPanic
 
 ```go
-func Panic(t testRunner, f func(), msg ...interface{})
+func AssertPanic(t testRunner, f func(), msg ...interface{})
 ```
 
-Panic asserts that a function panics.
+AssertPanic asserts that a function panics.
 
-#### testza.Use.Assert.True
+#### AssertTrue
 
 ```go
-func True(t testRunner, value interface{}, msg ...interface{})
+func AssertTrue(t testRunner, value interface{}, msg ...interface{})
 ```
 
-True asserts that an expression or object resolves to true.
+AssertTrue asserts that an expression or object resolves to true.
 
-#### testza.Use.Assert.Zero
+#### AssertZero
 
 ```go
-func Zero(t testRunner, value interface{}, msg ...interface{})
+func AssertZero(t testRunner, value interface{}, msg ...interface{})
 ```
 
-Zero asserts that the value is the zero value for it's type.
+AssertZero asserts that the value is the zero value for it's type.
 
-    testza.Use.Assert.Zero(t, 0)
-    testza.Use.Assert.Zero(t, false)
-    testza.Use.Assert.Zero(t, "")
+    testza.AssertZero(t, 0)
+    testza.AssertZero(t, false)
+    testza.AssertZero(t, "")
 
 ### Capture
 
-#### testza.Use.Capture.Stderr
+#### CaptureStderr
 
 ```go
-func Stderr(capture func(w io.Writer) error) (string, error)
+func CaptureStderr(capture func(w io.Writer) error) (string, error)
 ```
 
-Stderr captures everything written to stderr from a specific function. You
-can use this method in tests, to validate that your functions writes a
-string to the terminal.
+CaptureStderr captures everything written to stderr from a specific
+function. You can use this method in tests, to validate that your functions
+writes a string to the terminal.
 
-#### testza.Use.Capture.Stdout
+#### CaptureStdout
 
 ```go
-func Stdout(capture func(w io.Writer) error) (string, error)
+func CaptureStdout(capture func(w io.Writer) error) (string, error)
 ```
 
-Stdout captures everything written to stdout from a specific function. You
-can use this method in tests, to validate that your functions writes a
-string to the terminal.
+CaptureStdout captures everything written to stdout from a specific
+function. You can use this method in tests, to validate that your functions
+writes a string to the terminal.
 
-### Mock.Inputs.Bools
+### Mock Input Bool
 
-#### testza.Use.Mock.Inputs.Bools.Full
+#### MockInputBoolFull
 
 ```go
-func Full() []bool
+func MockInputBoolFull() []bool
 ```
 
-Full returns true and false in a boolean slice.
+MockInputBoolFull returns true and false in a boolean slice.
 
-#### testza.Use.Mock.Inputs.Bools.Modify
+#### MockInputBoolModify
 
 ```go
-func Modify(inputSlice []bool, f func(index int, value bool) bool) (floats []bool)
+func MockInputBoolModify(inputSlice []bool, f func(index int, value bool) bool) (floats []bool)
 ```
 
-Modify returns a modified version of a test set.
+MockInputBoolModify returns a modified version of a test set.
 
-#### testza.Use.Mock.Inputs.Bools.RunTests
+#### MockInputBoolRunTests
 
 ```go
-func RunTests(t testRunner, testSet []bool, testFunc func(t *testing.T, index int, f bool))
+func MockInputBoolRunTests(t testRunner, testSet []bool, testFunc func(t *testing.T, index int, f bool))
 ```
 
-RunTests 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.
+MockInputBoolRunTests 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.
 
-### Mock.Inputs.Floats64
+### Mock Input Float64
 
-#### testza.Use.Mock.Inputs.Floats64.Full
+#### MockInputFloat64Full
 
 ```go
-func Full() (floats []float64)
+func MockInputFloat64Full() (floats []float64)
 ```
 
+MockInputFloat64Full returns a combination of every float64 testset and some
+random float64s (positive and negative).
 
-
-#### testza.Use.Mock.Inputs.Floats64.GenerateRandomNegative
+#### MockInputFloat64GenerateRandomNegative
 
 ```go
-func GenerateRandomNegative(count int, min float64) (floats []float64)
+func MockInputFloat64GenerateRandomNegative(count int, min float64) (floats []float64)
 ```
 
-GenerateRandomNegative 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.
+MockInputFloat64GenerateRandomNegative 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.
 
-#### testza.Use.Mock.Inputs.Floats64.GenerateRandomPositive
+#### MockInputFloat64GenerateRandomPositive
 
 ```go
-func GenerateRandomPositive(count int, max float64) (floats []float64)
+func MockInputFloat64GenerateRandomPositive(count int, max float64) (floats []float64)
 ```
 
-GenerateRandomPositive generates random positive integers with a maximum of
-max. If the maximum is 0, or below, the maximum will be set to
-math.MaxInt64.
+MockInputFloat64GenerateRandomPositive generates random positive integers
+with a maximum of max. If the maximum is 0, or below, the maximum will be
+set to math.MaxInt64.
 
-#### testza.Use.Mock.Inputs.Floats64.GenerateRandomRange
+#### MockInputFloat64GenerateRandomRange
 
 ```go
-func GenerateRandomRange(count int, min, max float64) (floats []float64)
+func MockInputFloat64GenerateRandomRange(count int, min, max float64) (floats []float64)
 ```
 
-GenerateRandomRange generates random positive integers with a maximum of
-max. If the maximum is 0, or below, the maximum will be set to
+MockInputFloat64GenerateRandomRange generates random positive integers with
+a maximum of max. If the maximum is 0, or below, the maximum will be set to
 math.MaxInt64.
 
-#### testza.Use.Mock.Inputs.Floats64.Modify
+#### MockInputFloat64Modify
 
 ```go
-func Modify(inputSlice []float64, f func(index int, value float64) float64) (floats []float64)
+func MockInputFloat64Modify(inputSlice []float64, f func(index int, value float64) float64) (floats []float64)
 ```
 
-Modify returns a modified version of a test set.
+MockInputFloat64Modify returns a modified version of a test set.
 
-#### testza.Use.Mock.Inputs.Floats64.RunTests
+#### MockInputFloat64RunTests
 
 ```go
-func RunTests(t testRunner, testSet []float64, testFunc func(t *testing.T, index int, f float64))
+func MockInputFloat64RunTests(t testRunner, testSet []float64, testFunc func(t *testing.T, index int, f float64))
 ```
 
-RunTests 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.
+MockInputFloat64RunTests 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.
 
-### Mock.Inputs.Ints
+### Mock Input Int
 
-#### testza.Use.Mock.Inputs.Ints.Full
+#### MockInputIntFull
 
 ```go
-func Full() (ints []int)
+func MockInputIntFull() (ints []int)
 ```
 
-Full returns a combination of every integer testset and some random integers
-(positive and negative).
+MockInputIntFull returns a combination of every integer testset and some
+random integers (positive and negative).
 
-#### testza.Use.Mock.Inputs.Ints.GenerateRandomNegative
+#### MockInputIntGenerateRandomNegative
 
 ```go
-func GenerateRandomNegative(count, min int) (ints []int)
+func MockInputIntGenerateRandomNegative(count, min int) (ints []int)
 ```
 
-GenerateRandomNegative generates random negative integers with a minimum of
-min. If the minimum is 0, or above, the maximum will be set to
+MockInputIntGenerateRandomNegative generates random negative integers with a
+minimum of min. If the minimum is 0, or above, the maximum will be set to
 math.MinInt64.
 
-#### testza.Use.Mock.Inputs.Ints.GenerateRandomPositive
+#### MockInputIntGenerateRandomPositive
 
 ```go
-func GenerateRandomPositive(count, max int) (ints []int)
+func MockInputIntGenerateRandomPositive(count, max int) (ints []int)
 ```
 
-GenerateRandomPositive generates random positive integers with a maximum of
-max. If the maximum is 0, or below, the maximum will be set to
+MockInputIntGenerateRandomPositive generates random positive integers with a
+maximum of max. If the maximum is 0, or below, the maximum will be set to
 math.MaxInt64.
 
-#### testza.Use.Mock.Inputs.Ints.GenerateRandomRange
+#### MockInputIntGenerateRandomRange
 
 ```go
-func GenerateRandomRange(count, min, max int) (ints []int)
+func MockInputIntGenerateRandomRange(count, min, max int) (ints []int)
 ```
 
-GenerateRandomRange generates random integers with a range of min to max.
+MockInputIntGenerateRandomRange generates random integers with a range of
+min to max.
 
-#### testza.Use.Mock.Inputs.Ints.Modify
+#### MockInputIntModify
 
 ```go
-func Modify(inputSlice []int, f func(index int, value int) int) (ints []int)
+func MockInputIntModify(inputSlice []int, f func(index int, value int) int) (ints []int)
 ```
 
-Modify returns a modified version of a test set.
+MockInputIntModify returns a modified version of a test set.
 
-#### testza.Use.Mock.Inputs.Ints.RunTests
+#### MockInputIntRunTests
 
 ```go
-func RunTests(t testRunner, testSet []int, testFunc func(t *testing.T, index int, i int))
+func MockInputIntRunTests(t testRunner, testSet []int, testFunc func(t *testing.T, index int, i int))
 ```
 
-RunTests 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.
+MockInputIntRunTests 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.
 
-### Mock.Inputs.Strings
+### Mock Input String
 
-#### testza.Use.Mock.Inputs.Inputs.Strings.EmailAddresses
+#### MockInputStringEmailAddresses
 
 ```go
-func EmailAddresses() []string
+func MockInputStringEmailAddresses() []string
 ```
 
-EmailAddresses returns a test set with valid email addresses.
+MockInputStringEmailAddresses returns a test set with valid email addresses.
 
-#### testza.Use.Mock.Inputs.Inputs.Strings.Empty
+#### MockInputStringEmpty
 
 ```go
-func Empty() []string
+func MockInputStringEmpty() []string
 ```
 
-Empty returns a test set with a single empty string.
+MockInputStringEmpty returns a test set with a single empty string.
 
-#### testza.Use.Mock.Inputs.Inputs.Strings.Full
+#### MockInputStringFull
 
 ```go
-func Full() (ret []string)
+func MockInputStringFull() (ret []string)
 ```
 
-Full contains all string test sets plus ten generated random strings.
+MockInputStringFull contains all string test sets plus ten generated random
+strings.
 
-#### testza.Use.Mock.Inputs.Inputs.Strings.GenerateRandom
+#### MockInputStringGenerateRandom
 
 ```go
-func GenerateRandom(count, length int) (result []string)
+func MockInputStringGenerateRandom(count, length int) (result []string)
 ```
 
-GenerateRandom returns random StringsHelper in a test set.
+MockInputStringGenerateRandom returns random StringsHelper in a test set.
 
-#### testza.Use.Mock.Inputs.Inputs.Strings.HtmlTags
+#### MockInputStringHtmlTags
 
 ```go
-func HtmlTags() []string
+func MockInputStringHtmlTags() []string
 ```
 
-HtmlTags returns a test set with html tags.
+MockInputStringHtmlTags returns a test set with html tags.
 
-#### testza.Use.Mock.Inputs.Inputs.Strings.Limit
+#### MockInputStringLimit
 
 ```go
-func Limit(testSet []string, max int) []string
+func MockInputStringLimit(testSet []string, max int) []string
 ```
 
-Limit limits a test set in size.
+MockInputStringLimit limits a test set in size.
 
-#### testza.Use.Mock.Inputs.Inputs.Strings.Long
+#### MockInputStringLong
 
 ```go
-func Long() (testSet []string)
+func MockInputStringLong() (testSet []string)
 ```
 
-Long returns a test set with long random strings. Returns: - Random string
-(length: 25) - Random string (length: 50) - Random string (length: 100) -
-Random string (length: 1,000) - Random string (length: 100,000)
+MockInputStringLong returns a test set with long random strings. Returns: -
+Random string (length: 25) - Random string (length: 50) - Random string
+(length: 100) - Random string (length: 1,000) - Random string (length:
+100,000)
 
-#### testza.Use.Mock.Inputs.Inputs.Strings.Modify
+#### MockInputStringModify
 
 ```go
-func Modify(inputSlice []string, f func(index int, value string) string) (ret []string)
+func MockInputStringModify(inputSlice []string, f func(index int, value string) string) (ret []string)
 ```
 
-Modify returns a modified version of a test set.
+MockInputStringModify returns a modified version of a test set.
 
-#### testza.Use.Mock.Inputs.Inputs.Strings.Numeric
+#### MockInputStringNumeric
 
 ```go
-func Numeric() []string
+func MockInputStringNumeric() []string
 ```
 
-Numeric returns a test set with strings that are numeric. The highest number
-in here is "9223372036854775807", which is equal to the maxmim int64.
+MockInputStringNumeric returns a test set with strings that are numeric. The
+highest number in here is "9223372036854775807", which is equal to the
+maxmim int64.
 
-#### testza.Use.Mock.Inputs.Inputs.Strings.RunTests
+#### MockInputStringRunTests
 
 ```go
-func RunTests(t testRunner, testSet []string, testFunc func(t *testing.T, index int, str string))
+func MockInputStringRunTests(t testRunner, testSet []string, testFunc func(t *testing.T, index int, str string))
 ```
 
-RunTests 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.
+MockInputStringRunTests 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.
 
 
 <!-- docs:end -->
diff --git a/assert.go b/assert.go
index 98dbd5f..de74ec9 100644
--- a/assert.go
+++ b/assert.go
@@ -14,11 +14,11 @@ import (
 
 // ** Getter Methods **
 
-func (a AssertHelper) isKind(expectedKind reflect.Kind, value interface{}) bool {
+func isKind(expectedKind reflect.Kind, value interface{}) bool {
 	return reflect.TypeOf(value).Kind() == expectedKind
 }
 
-func (a AssertHelper) isNumber(value interface{}) bool {
+func isNumber(value interface{}) bool {
 	numberKinds := []reflect.Kind{
 		reflect.Int,
 		reflect.Int8,
@@ -37,7 +37,7 @@ func (a AssertHelper) isNumber(value interface{}) bool {
 	}
 
 	for _, k := range numberKinds {
-		if a.isKind(k, value) {
+		if isKind(k, value) {
 			return true
 		}
 	}
@@ -46,7 +46,7 @@ func (a AssertHelper) isNumber(value interface{}) bool {
 }
 
 // completesIn returns if a function completes in a specific time.
-func (a AssertHelper) completesIn(duration time.Duration, f func()) bool {
+func completesIn(duration time.Duration, f func()) bool {
 	done := make(chan bool)
 	go func() {
 		f()
@@ -61,11 +61,11 @@ func (a AssertHelper) completesIn(duration time.Duration, f func()) bool {
 	}
 }
 
-func (a AssertHelper) isZero(value interface{}) bool {
+func isZero(value interface{}) bool {
 	return value == nil || reflect.DeepEqual(value, reflect.Zero(reflect.TypeOf(value)).Interface())
 }
 
-func (a AssertHelper) isEqual(expected interface{}, actual interface{}) bool {
+func isEqual(expected interface{}, actual interface{}) bool {
 	if expected == nil || actual == nil {
 		return expected == actual
 	}
@@ -86,8 +86,8 @@ func (a AssertHelper) isEqual(expected interface{}, actual interface{}) bool {
 	return bytes.Equal(expectedB, actualB)
 }
 
-func (a AssertHelper) hasEqualValues(expected interface{}, actual interface{}) bool {
-	if a.isEqual(expected, actual) {
+func hasEqualValues(expected interface{}, actual interface{}) bool {
+	if isEqual(expected, actual) {
 		return true
 	}
 
@@ -104,7 +104,7 @@ func (a AssertHelper) hasEqualValues(expected interface{}, actual interface{}) b
 	return false
 }
 
-func (a AssertHelper) doesImplement(interfaceObject, object interface{}) bool {
+func doesImplement(interfaceObject, object interface{}) bool {
 	interfaceType := reflect.TypeOf(interfaceObject).Elem()
 
 	if object == nil {
@@ -117,7 +117,7 @@ func (a AssertHelper) doesImplement(interfaceObject, object interface{}) bool {
 	return true
 }
 
-func (a AssertHelper) doesContain(object, element interface{}) bool {
+func doesContain(object, element interface{}) bool {
 	objectValue := reflect.ValueOf(object)
 	objectKind := reflect.TypeOf(object).Kind()
 
@@ -127,7 +127,7 @@ func (a AssertHelper) doesContain(object, element interface{}) bool {
 	case reflect.Map:
 	default:
 		for i := 0; i < objectValue.Len(); i++ {
-			if Use.Assert.isEqual(objectValue.Index(i).Interface(), element) {
+			if isEqual(objectValue.Index(i).Interface(), element) {
 				return true
 			}
 		}
@@ -138,13 +138,13 @@ func (a AssertHelper) doesContain(object, element interface{}) bool {
 
 // ** Helper Methods **
 
-// KindOf asserts that the object is a type of kind exptectedKind.
-func (a AssertHelper) KindOf(t testRunner, expectedKind reflect.Kind, object interface{}, msg ...interface{}) {
+// AssertKindOf asserts that the object is a type of kind exptectedKind.
+func AssertKindOf(t testRunner, expectedKind reflect.Kind, object interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if !a.isKind(expectedKind, object) {
+	if !isKind(expectedKind, object) {
 		internal.Fail(t,
 			fmt.Sprintf("A value that !!should be a type of kind %s!! is a type of kind %s.", expectedKind.String(), reflect.TypeOf(object).Kind().String()),
 			internal.NewObjectsExpectedActual(expectedKind, object),
@@ -153,13 +153,13 @@ func (a AssertHelper) KindOf(t testRunner, expectedKind reflect.Kind, object int
 	}
 }
 
-// NotKindOf asserts that the object is not a type of kind `kind`.
-func (a AssertHelper) NotKindOf(t testRunner, kind reflect.Kind, object interface{}, msg ...interface{}) {
+// AssertNotKindOf asserts that the object is not a type of kind `kind`.
+func AssertNotKindOf(t testRunner, kind reflect.Kind, object interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if a.isKind(kind, object) {
+	if isKind(kind, object) {
 		internal.Fail(t,
 			fmt.Sprintf("A value that !!should not be a type of kind %s!! is a type of kind %s.", kind.String(), reflect.TypeOf(object).Kind().String()),
 			internal.NewObjectsExpectedActual(kind, object),
@@ -168,98 +168,98 @@ func (a AssertHelper) NotKindOf(t testRunner, kind reflect.Kind, object interfac
 	}
 }
 
-// Numeric asserts that the object is a numeric type.
+// AssertNumeric asserts that the object is a numeric type.
 // Numeric types are:
 // Int, Int8, Int16, Int32, Int64, Float32, Float64, Uint, Uint8, Uint16, Uint32, Uint64, Complex64 and Complex128.
-func (a AssertHelper) Numeric(t testRunner, object interface{}, msg ...interface{}) {
-	if !a.isNumber(object) {
+func AssertNumeric(t testRunner, object interface{}, msg ...interface{}) {
+	if !isNumber(object) {
 		internal.Fail(t, "An object that !!should be a number!! is not of a numeric type.", internal.NewObjectsSingleNamed("object", object))
 	}
 }
 
-// Number checks if the object is not a numeric type.
+// AssertNotNumeric checks if the object is not a numeric type.
 // Numeric types are:
 // Int, Int8, Int16, Int32, Int64, Float32, Float64, Uint, Uint8, Uint16, Uint32, Uint64, Complex64 and Complex128.
-func (a AssertHelper) NotNumeric(t testRunner, object interface{}, msg ...interface{}) {
-	if a.isNumber(object) {
+func AssertNotNumeric(t testRunner, object interface{}, msg ...interface{}) {
+	if isNumber(object) {
 		internal.Fail(t, "An object that !!should not be a number!! is of a numeric type.", internal.NewObjectsSingleNamed("object", object))
 	}
 }
 
-// Zero asserts that the value is the zero value for it's type.
-//     testza.Use.Assert.Zero(t, 0)
-//     testza.Use.Assert.Zero(t, false)
-//     testza.Use.Assert.Zero(t, "")
-func (a AssertHelper) Zero(t testRunner, value interface{}, msg ...interface{}) {
+// AssertZero asserts that the value is the zero value for it's type.
+//     testza.AssertZero(t, 0)
+//     testza.AssertZero(t, false)
+//     testza.AssertZero(t, "")
+func AssertZero(t testRunner, value interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if !a.isZero(value) {
+	if !isZero(value) {
 		internal.Fail(t, "An object that !!should have it's zero value!!, does not have it's zero value.", internal.NewObjectsSingleNamed("object", value))
 	}
 }
 
-// NotZero asserts that the value is not the zero value for it's type.
-//     testza.Use.Assert.NotZero(t, 1337)
-//     testza.Use.Assert.NotZero(t, true)
-//     testza.Use.Assert.NotZero(t, "Hello, World")
-func (a AssertHelper) NotZero(t testRunner, value interface{}, msg ...interface{}) {
+// AssertNotZero asserts that the value is not the zero value for it's type.
+//     testza.AssertNotZero(t, 1337)
+//     testza.AssertNotZero(t, true)
+//     testza.AssertNotZero(t, "Hello, World")
+func AssertNotZero(t testRunner, value interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if a.isZero(value) {
+	if isZero(value) {
 		internal.Fail(t, "An object that !!should not have it's zero value!!, does have it's zero value.", internal.NewObjectsSingleNamed("object", value))
 	}
 }
 
-// Equal asserts that two objects are equal.
-func (a AssertHelper) Equal(t testRunner, expected interface{}, actual interface{}, msg ...interface{}) {
+// AssertEqual asserts that two objects are equal.
+func AssertEqual(t testRunner, expected interface{}, actual interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if !Use.Assert.isEqual(expected, actual) {
+	if !isEqual(expected, actual) {
 		internal.Fail(t, "Two objects that !!should be equal!!, are not equal.", internal.NewObjectsExpectedActual(expected, actual), msg...)
 	}
 }
 
-// NotEqual asserts that two objects are not equal.
-func (a AssertHelper) NotEqual(t testRunner, expected interface{}, actual interface{}, msg ...interface{}) {
+// AssertNotEqual asserts that two objects are not equal.
+func AssertNotEqual(t testRunner, expected interface{}, actual interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if Use.Assert.isEqual(expected, actual) {
+	if isEqual(expected, actual) {
 		internal.Fail(t, "Two objects that !!should not be equal!!, are equal.", internal.NewObjectsExpectedActual(expected, actual), msg...)
 	}
 }
 
-// EqualValues asserts that two objects have equal values.
-func (a AssertHelper) EqualValues(t testRunner, expected interface{}, actual interface{}, msg ...interface{}) {
+// AssertEqualValues asserts that two objects have equal values.
+func AssertEqualValues(t testRunner, expected interface{}, actual interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if !Use.Assert.hasEqualValues(expected, actual) {
+	if !hasEqualValues(expected, actual) {
 		internal.Fail(t, "Two objects that !!should have equal values!!, do not have equal values.", internal.NewObjectsExpectedActual(expected, actual), msg...)
 	}
 }
 
-// NotEqualValues asserts that two objects do not have equal values.
-func (a AssertHelper) NotEqualValues(t testRunner, expected interface{}, actual interface{}, msg ...interface{}) {
+// AssertNotEqualValues asserts that two objects do not have equal values.
+func AssertNotEqualValues(t testRunner, expected interface{}, actual interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if Use.Assert.hasEqualValues(expected, actual) {
+	if hasEqualValues(expected, actual) {
 		internal.Fail(t, "Two objects that !!should not have equal values!!, do have equal values.", internal.NewObjectsExpectedActual(expected, actual), msg...)
 	}
 }
 
-// True asserts that an expression or object resolves to true.
-func (a AssertHelper) True(t testRunner, value interface{}, msg ...interface{}) {
+// AssertTrue asserts that an expression or object resolves to true.
+func AssertTrue(t testRunner, value interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -269,8 +269,8 @@ func (a AssertHelper) True(t testRunner, value interface{}, msg ...interface{})
 	}
 }
 
-// False asserts that an expression or object resolves to false.
-func (a AssertHelper) False(t testRunner, value interface{}, msg ...interface{}) {
+// AssertFalse asserts that an expression or object resolves to false.
+func AssertFalse(t testRunner, value interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -280,56 +280,58 @@ func (a AssertHelper) False(t testRunner, value interface{}, msg ...interface{})
 	}
 }
 
-// Implements checks if an objects implements an interface.
+// AssertImplements asserts that an objects implements an interface.
 //
-//	testza.Use.Assert.Implements(t, (*YourInterface)(nil), new(YourObject))
-//	testza.Use.Assert.Implements(t, (*fmt.Stringer)(nil), new(types.Const)) => pass
-func (a AssertHelper) Implements(t testRunner, interfaceObject, object interface{}, msg ...interface{}) {
+//	testza.AssertImplements(t, (*YourInterface)(nil), new(YourObject))
+//	testza.AssertImplements(t, (*fmt.Stringer)(nil), new(types.Const)) => pass
+func AssertImplements(t testRunner, interfaceObject, object interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if !Use.Assert.doesImplement(interfaceObject, object) {
+	if !doesImplement(interfaceObject, object) {
 		internal.Fail(t, fmt.Sprintf("An object that !!should implement %s!! does not implement it.", reflect.TypeOf(interfaceObject).String()), internal.Objects{}, msg...)
 	}
 }
 
-// NotImplements checks if an object does not implement an interface.
+// AssertNotImplements asserts that an object does not implement an interface.
 //
-//	testza.Use.Assert.NotImplements(t, (*YourInterface)(nil), new(YourObject))
-//	testza.Use.Assert.NotImplements(t, (*fmt.Stringer)(nil), new(types.Const)) => fail, because types.Const does implement fmt.Stringer.
-func (a AssertHelper) NotImplements(t testRunner, interfaceObject, object interface{}, msg ...interface{}) {
+//	testza.AssertNotImplements(t, (*YourInterface)(nil), new(YourObject))
+//	testza.AssertNotImplements(t, (*fmt.Stringer)(nil), new(types.Const)) => fail, because types.Const does implement fmt.Stringer.
+func AssertNotImplements(t testRunner, interfaceObject, object interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if Use.Assert.doesImplement(interfaceObject, object) {
+	if doesImplement(interfaceObject, object) {
 		internal.Fail(t, fmt.Sprintf("An object that !!should not implement %s!! does implement it.", reflect.TypeOf(interfaceObject).String()), internal.Objects{}, msg...)
 	}
 }
 
-func (a AssertHelper) Contains(t testRunner, object, element interface{}, msg ...interface{}) {
+// AssertContains asserts that a string/list/array/slice/map contains the specified element.
+func AssertContains(t testRunner, object, element interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if !Use.Assert.doesContain(object, element) {
+	if !doesContain(object, element) {
 		internal.Fail(t, "An object !!does not contain!! the object it should contain.", internal.Objects{{Name: "object", Data: object}, {Name: "element that is missing in object", Data: element}})
 	}
 }
 
-func (a AssertHelper) NotContains(t testRunner, object, element interface{}, msg ...interface{}) {
+// AssertNotContains asserts that a string/list/array/slice/map does not contain the specified element.
+func AssertNotContains(t testRunner, object, element interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if Use.Assert.doesContain(object, element) {
+	if doesContain(object, element) {
 		internal.Fail(t, "An object !!does contain!! an object it should not contain.", internal.Objects{{Name: "object", Data: object}, {Name: "element that should not be in object", Data: element}})
 	}
 }
 
-// Panic asserts that a function panics.
-func (a AssertHelper) Panic(t testRunner, f func(), msg ...interface{}) {
+// AssertPanic asserts that a function panics.
+func AssertPanic(t testRunner, f func(), msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -343,8 +345,8 @@ func (a AssertHelper) Panic(t testRunner, f func(), msg ...interface{}) {
 	f()
 }
 
-// NotPanic asserts that a function does not panic.
-func (a AssertHelper) NotPanic(t testRunner, f func(), msg ...interface{}) {
+// AssertNotPanic asserts that a function does not panic.
+func AssertNotPanic(t testRunner, f func(), msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -358,8 +360,8 @@ func (a AssertHelper) NotPanic(t testRunner, f func(), msg ...interface{}) {
 	f()
 }
 
-// Nil asserts that an object is nil.
-func (a AssertHelper) Nil(t testRunner, object interface{}, msg ...interface{}) {
+// AssertNil asserts that an object is nil.
+func AssertNil(t testRunner, object interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -369,8 +371,8 @@ func (a AssertHelper) Nil(t testRunner, object interface{}, msg ...interface{})
 	}
 }
 
-// NotNil assertsthat an object is not nil.
-func (a AssertHelper) NotNil(t testRunner, object interface{}, msg ...interface{}) {
+// AssertNotNil asserts that an object is not nil.
+func AssertNotNil(t testRunner, object interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -380,39 +382,39 @@ func (a AssertHelper) NotNil(t testRunner, object interface{}, msg ...interface{
 	}
 }
 
-// CompletesIn asserts that a function completes in a given time.
+// AssertCompletesIn asserts that a function completes in a given time.
 // Use this function to test that functions do not take too long to complete.
 //
 // NOTE: Every system takes a different amount of time to complete a function.
 // Do not set the duration too low, if you want consistent results.
-func (a AssertHelper) CompletesIn(t testRunner, duration time.Duration, f func(), msg ...interface{}) {
+func AssertCompletesIn(t testRunner, duration time.Duration, f func(), msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if !a.completesIn(duration, f) {
+	if !completesIn(duration, f) {
 		internal.Fail(t, fmt.Sprintf("The function !!should complete in %s!!, but it did not.", duration), internal.Objects{}, msg...)
 	}
 }
 
-// NotCompletesIn asserts that a function does not complete in a given time.
+// AssertNotCompletesIn asserts that a function does not complete in a given time.
 // Use this function to test that functions do not complete to quickly.
 // For example if your database connection completes in under a millisecond, there might be something wrong.
 //
 // NOTE: Every system takes a different amount of time to complete a function.
 // Do not set the duration too high, if you want consistent results.
-func (a AssertHelper) NotCompletesIn(t testRunner, duration time.Duration, f func(), msg ...interface{}) {
+func AssertNotCompletesIn(t testRunner, duration time.Duration, f func(), msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
 
-	if a.completesIn(duration, f) {
+	if completesIn(duration, f) {
 		internal.Fail(t, fmt.Sprintf("The function !!should not complete in %s!!, but it did.", duration), internal.Objects{}, msg...)
 	}
 }
 
-// NoError asserts that an error is nil.
-func (a AssertHelper) NoError(t testRunner, err interface{}, msg ...interface{}) {
+// AssertNoError asserts that an error is nil.
+func AssertNoError(t testRunner, err interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -427,8 +429,8 @@ func (a AssertHelper) NoError(t testRunner, err interface{}, msg ...interface{})
 	}
 }
 
-// Greater asserts that the first object is greater than the second.
-func (a AssertHelper) Greater(t testRunner, object1, object2 interface{}, msg ...interface{}) {
+// AssertGreater asserts that the first object is greater than the second.
+func AssertGreater(t testRunner, object1, object2 interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -445,8 +447,8 @@ func (a AssertHelper) Greater(t testRunner, object1, object2 interface{}, msg ..
 	}
 }
 
-// Less asserts that the first object is less than the second.
-func (a AssertHelper) Less(t testRunner, object1, object2 interface{}, msg ...interface{}) {
+// AssertLess asserts that the first object is less than the second.
+func AssertLess(t testRunner, object1, object2 interface{}, msg ...interface{}) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
diff --git a/capture.go b/capture.go
index 3ce64ad..10bf616 100644
--- a/capture.go
+++ b/capture.go
@@ -7,12 +7,9 @@ import (
 	"os"
 )
 
-// CaptureHelper contains methods to capture terminal output.
-type CaptureHelper struct{}
-
-// Stdout captures everything written to stdout from a specific function.
+// CaptureStdout captures everything written to stdout from a specific function.
 // You can use this method in tests, to validate that your functions writes a string to the terminal.
-func (h *CaptureHelper) Stdout(capture func(w io.Writer) error) (string, error) {
+func CaptureStdout(capture func(w io.Writer) error) (string, error) {
 	originalStdout := os.Stdout
 	r, w, err := os.Pipe()
 	if err != nil {
@@ -42,9 +39,9 @@ func (h *CaptureHelper) Stdout(capture func(w io.Writer) error) (string, error)
 	return string(out), nil
 }
 
-// Stderr captures everything written to stderr from a specific function.
+// CaptureStderr captures everything written to stderr from a specific function.
 // You can use this method in tests, to validate that your functions writes a string to the terminal.
-func (h *CaptureHelper) Stderr(capture func(w io.Writer) error) (string, error) {
+func CaptureStderr(capture func(w io.Writer) error) (string, error) {
 	originalStderr := os.Stderr
 	r, w, err := os.Pipe()
 	if err != nil {
diff --git a/ci/main.go b/ci/main.go
index ed71876..0bb547e 100644
--- a/ci/main.go
+++ b/ci/main.go
@@ -15,14 +15,13 @@ var goDoc string
 
 var Functions []Function
 
-var Modules = []Module{
-	{Name: "Assert", StructName: "AssertHelper", Path: "testza.Use.Assert"},
-	{Name: "Capture", StructName: "CaptureHelper", Path: "testza.Use.Capture"},
-	// {Name: "Mock", StructName: "MockHelper", Path: "testza.Use.Mock"},
-	{Name: "Mock.Inputs.Strings", StructName: "MockInputsStringsHelper", Path: "testza.Use.Mock.Inputs.Inputs.Strings"},
-	{Name: "Mock.Inputs.Bools", StructName: "MockInputsBoolsHelper", Path: "testza.Use.Mock.Inputs.Bools"},
-	{Name: "Mock.Inputs.Floats64", StructName: "MockInputsFloats64Helper", Path: "testza.Use.Mock.Inputs.Floats64"},
-	{Name: "Mock.Inputs.Ints", StructName: "MockInputsIntsHelper", Path: "testza.Use.Mock.Inputs.Ints"},
+var Categories = []Category{
+	{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"},
 }
 
 func main() {
@@ -34,11 +33,9 @@ func main() {
 	writeBetween("README.md", "docs", getMarkdown())
 }
 
-type Module struct {
-	Name       string
-	StructName string
-	Path       string
-	HasMethods bool
+type Category struct {
+	Name   string
+	Prefix string
 }
 
 type Function struct {
@@ -79,7 +76,7 @@ func parseGoDoc() {
 			continue
 		}
 
-		var re = regexp.MustCompile(`(?m)\)( (?P<name>.*?)\()`)
+		var re = regexp.MustCompile(`(?m)func (?P<name>[a-zA-Z0-9]*)`)
 		Functions[i].Name = regexGroupsToMap(re, f.Head)["name"]
 
 		var newBody string
@@ -90,21 +87,6 @@ func parseGoDoc() {
 	}
 }
 
-func getModuleOfObject(head string) Module {
-	head = strings.TrimLeft(head, "*")
-
-	var re = regexp.MustCompile(`(?m)(?P<name>[a-zA-Z1-9]*)?\)`)
-	parent := regexGroupsToMap(re, head)["name"]
-
-	for _, module := range Modules {
-		if module.StructName == parent {
-			return module
-		}
-	}
-
-	return Module{}
-}
-
 func pathToMarkdownLink(path string) string {
 	path = strings.ReplaceAll(path, " ", "")
 	path = strings.ReplaceAll(path, ".", "")
@@ -112,8 +94,19 @@ func pathToMarkdownLink(path string) string {
 	return path
 }
 
+func getCategoryOfFunctionName(name string) (c Category) {
+
+	for _, category := range Categories {
+		if strings.HasPrefix(name, category.Prefix) {
+			c = category
+		}
+	}
+
+	return
+}
+
 func getMarkdown() (md string) {
-	var lastModule Module
+	var lastCategory Category
 
 	md += `<table>
   <tr>
@@ -121,12 +114,12 @@ func getMarkdown() (md string) {
     <th>Methods</th>
   </tr>`
 
-	for _, module := range Modules {
-		path := module.Name
+	for _, category := range Categories {
+		path := category.Name
 		path = pathToMarkdownLink(path)
 		md += "<tr>\n"
-		md += fmt.Sprintf(`<td><a href="https://github.com/MarvinJWendt/testza#%s">%s</a></td>`+"\n", path, module.Name)
-		// md += fmt.Sprintf("\n- [%s](https://github.com/MarvinJWendt/testza#%s)\n", module.Name, path)
+		md += fmt.Sprintf(`<td><a href="https://github.com/MarvinJWendt/testza#%s">%s</a></td>`+"\n", path, category.Name)
+		// md += fmt.Sprintf("\n- [%s](https://github.com/MarvinJWendt/testza#%s)\n", category.Name, path)
 
 		md += "<td>\n\n<details>\n<summary>Click to expand</summary>\n\n"
 		for _, f := range Functions {
@@ -134,9 +127,8 @@ func getMarkdown() (md string) {
 				continue
 			}
 
-			if getModuleOfObject(f.Head).Path == module.Path {
-				md += fmt.Sprintf("  - [%s](https://github.com/MarvinJWendt/testza#%s)\n", f.Name, pathToMarkdownLink(module.Path+f.Name))
-				// md += fmt.Sprintf("  - [%s](https://github.com/MarvinJWendt/testza#%s)\n", f.Name, pathToMarkdownLink(module.Path+f.Name))
+			if strings.HasPrefix(f.Name, category.Prefix) {
+				md += fmt.Sprintf("  - [%s](https://github.com/MarvinJWendt/testza#%s)\n", f.Name, pathToMarkdownLink(f.Name))
 			}
 		}
 		md += "</td>\n\n</details>\n\n"
@@ -150,13 +142,13 @@ func getMarkdown() (md string) {
 			continue
 		}
 
-		module := getModuleOfObject(f.Head)
-		if module.StructName != lastModule.StructName {
-			md += fmt.Sprintf("### %s\n\n", module.Name)
+		category := getCategoryOfFunctionName(f.Name)
+		if category != lastCategory {
+			md += fmt.Sprintf("### %s\n\n", category.Name)
 		}
-		lastModule = module
+		lastCategory = category
 
-		md += "#### " + module.Path + "." + f.Name + "\n\n"
+		md += "#### " + f.Name + "\n\n"
 		var re = regexp.MustCompile(`(?m)func \(.*?\)`)
 		md += "```go\n" + re.ReplaceAllString(f.Head, "func") + "\n```\n\n"
 		md += f.Body + "\n"
diff --git a/doc.go b/doc.go
index b8a9fa7..ab1fdc0 100644
--- a/doc.go
+++ b/doc.go
@@ -1,10 +1,4 @@
 /*
 Package 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 is structured a bit differently than you might be used to in Go, but we think that it makes writing tests as easy and efficient as possible.
-After all, writing tests should be very simple and should not require you to study a whole framework.
-That's why we made testza to integrate perfectly with your IDE. You don't even have to lookup the documentation, as testza is self-explanatory.
-
-Just type `testza.Use.` and you will get a list of all modules of testza in your IDE.
 */
 package testza
diff --git a/mock-bools.go b/mock-bools.go
index 608792e..59d29e3 100644
--- a/mock-bools.go
+++ b/mock-bools.go
@@ -7,17 +7,15 @@ import (
 	"github.com/MarvinJWendt/testza/internal"
 )
 
-type MockInputsBoolsHelper struct{}
-
-// Full returns true and false in a boolean slice.
-func (MockInputsBoolsHelper) Full() []bool {
+// MockInputBoolFull returns true and false in a boolean slice.
+func MockInputBoolFull() []bool {
 	return []bool{true, false}
 }
 
-// RunTests runs a test for every value in a testset.
+// MockInputBoolRunTests 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.
-func (s MockInputsBoolsHelper) RunTests(t testRunner, testSet []bool, testFunc func(t *testing.T, index int, f bool)) {
+func MockInputBoolRunTests(t testRunner, testSet []bool, testFunc func(t *testing.T, index int, f bool)) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -37,8 +35,8 @@ func (s MockInputsBoolsHelper) RunTests(t testRunner, testSet []bool, testFunc f
 	}
 }
 
-// Modify returns a modified version of a test set.
-func (h MockInputsBoolsHelper) Modify(inputSlice []bool, f func(index int, value bool) bool) (floats []bool) {
+// MockInputBoolModify returns a modified version of a test set.
+func MockInputBoolModify(inputSlice []bool, f func(index int, value bool) bool) (floats []bool) {
 	for i, input := range inputSlice {
 		floats = append(floats, f(i, input))
 	}
diff --git a/mock-floats64.go b/mock-floats64.go
index 9058872..f454d00 100644
--- a/mock-floats64.go
+++ b/mock-floats64.go
@@ -9,23 +9,20 @@ import (
 	"github.com/MarvinJWendt/testza/internal"
 )
 
-// MockInputsFloats64Helper contains integer test sets.
-// Use testza.Use.Mock.Inputs.Floats64.
-type MockInputsFloats64Helper struct{}
-
-func (h MockInputsFloats64Helper) Full() (floats []float64) {
+// MockInputFloat64Full returns a combination of every float64 testset and some random float64s (positive and negative).
+func MockInputFloat64Full() (floats []float64) {
 	for i := 0; i < 50; i++ {
 		floats = append(floats,
-			h.GenerateRandomPositive(1, float64(i*1000))[0],
-			h.GenerateRandomNegative(1, float64(i*1000*-1))[0],
+			MockInputFloat64GenerateRandomPositive(1, float64(i*1000))[0],
+			MockInputFloat64GenerateRandomNegative(1, float64(i*1000*-1))[0],
 		)
 	}
 	return
 }
 
-// GenerateRandomRange generates random positive integers with a maximum of max.
+// MockInputFloat64GenerateRandomRange 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 (h MockInputsFloats64Helper) GenerateRandomRange(count int, min, max float64) (floats []float64) {
+func MockInputFloat64GenerateRandomRange(count int, min, max float64) (floats []float64) {
 	for i := 0; i < count; i++ {
 		floats = append(floats, min+rand.Float64()*(max-min))
 	}
@@ -33,37 +30,37 @@ func (h MockInputsFloats64Helper) GenerateRandomRange(count int, min, max float6
 	return
 }
 
-// GenerateRandomPositive generates random positive integers with a maximum of max.
+// MockInputFloat64GenerateRandomPositive 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 (h MockInputsFloats64Helper) GenerateRandomPositive(count int, max float64) (floats []float64) {
+func MockInputFloat64GenerateRandomPositive(count int, max float64) (floats []float64) {
 	if max <= 0 {
 		max = math.MaxFloat64
 	}
 
-	floats = append(floats, h.GenerateRandomRange(count, 0, max)...)
+	floats = append(floats, MockInputFloat64GenerateRandomRange(count, 0, max)...)
 
 	return
 }
 
-// GenerateRandomNegative generates random negative integers with a minimum of min.
+// MockInputFloat64GenerateRandomNegative 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 (h MockInputsFloats64Helper) GenerateRandomNegative(count int, min float64) (floats []float64) {
+func MockInputFloat64GenerateRandomNegative(count int, min float64) (floats []float64) {
 	if min > 0 {
 		min *= -1
 	} else if min == 0 {
 		min = math.MaxFloat64 * -1
 	}
 
-	floats = append(floats, h.GenerateRandomRange(count, min, 0)...)
+	floats = append(floats, MockInputFloat64GenerateRandomRange(count, min, 0)...)
 
 	return
 }
 
-// RunTests runs a test for every value in a testset.
+// MockInputFloat64RunTests 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.
-func (s MockInputsFloats64Helper) RunTests(t testRunner, testSet []float64, testFunc func(t *testing.T, index int, f float64)) {
+func MockInputFloat64RunTests(t testRunner, testSet []float64, testFunc func(t *testing.T, index int, f float64)) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -83,8 +80,8 @@ func (s MockInputsFloats64Helper) RunTests(t testRunner, testSet []float64, test
 	}
 }
 
-// Modify returns a modified version of a test set.
-func (h MockInputsFloats64Helper) Modify(inputSlice []float64, f func(index int, value float64) float64) (floats []float64) {
+// MockInputFloat64Modify returns a modified version of a test set.
+func MockInputFloat64Modify(inputSlice []float64, f func(index int, value float64) float64) (floats []float64) {
 	for i, input := range inputSlice {
 		floats = append(floats, f(i, input))
 	}
diff --git a/mock-ints.go b/mock-ints.go
index bb4130e..ccaa0dc 100644
--- a/mock-ints.go
+++ b/mock-ints.go
@@ -9,22 +9,19 @@ import (
 	"github.com/MarvinJWendt/testza/internal"
 )
 
-// MockInputsIntsHelper contains integer test sets.
-type MockInputsIntsHelper struct{}
-
-// Full returns a combination of every integer testset and some random integers (positive and negative).
-func (h MockInputsIntsHelper) Full() (ints []int) {
+// MockInputIntFull returns a combination of every integer testset and some random integers (positive and negative).
+func MockInputIntFull() (ints []int) {
 	for i := 0; i < 50; i++ {
 		ints = append(ints,
-			h.GenerateRandomPositive(1, i*1000)[0],
-			h.GenerateRandomNegative(1, i*1000*-1)[0],
+			MockInputIntGenerateRandomPositive(1, i*1000)[0],
+			MockInputIntGenerateRandomNegative(1, i*1000*-1)[0],
 		)
 	}
 	return
 }
 
-// GenerateRandomRange generates random integers with a range of min to max.
-func (h MockInputsIntsHelper) GenerateRandomRange(count, min, max int) (ints []int) {
+// MockInputIntGenerateRandomRange generates random integers with a range of min to max.
+func MockInputIntGenerateRandomRange(count, min, max int) (ints []int) {
 	for i := 0; i < count; i++ {
 		ints = append(ints, rand.Intn(max-min)+min)
 	}
@@ -32,28 +29,28 @@ func (h MockInputsIntsHelper) GenerateRandomRange(count, min, max int) (ints []i
 	return
 }
 
-// GenerateRandomPositive generates random positive integers with a maximum of max.
+// MockInputIntGenerateRandomPositive 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 (h MockInputsIntsHelper) GenerateRandomPositive(count, max int) (ints []int) {
+func MockInputIntGenerateRandomPositive(count, max int) (ints []int) {
 	if max <= 0 {
 		max = math.MaxInt64
 	}
 
-	ints = append(ints, h.GenerateRandomRange(count, 1, max)...)
+	ints = append(ints, MockInputIntGenerateRandomRange(count, 1, max)...)
 
 	return
 }
 
-// GenerateRandomNegative generates random negative integers with a minimum of min.
+// MockInputIntGenerateRandomNegative 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 (h MockInputsIntsHelper) GenerateRandomNegative(count, min int) (ints []int) {
+func MockInputIntGenerateRandomNegative(count, min int) (ints []int) {
 	if min >= 0 {
 		min = math.MinInt64
 	}
 
 	min = int(math.Abs(float64(min)))
 
-	randomPositives := h.GenerateRandomPositive(count, min)
+	randomPositives := MockInputIntGenerateRandomPositive(count, min)
 
 	for _, p := range randomPositives {
 		ints = append(ints, p*-1)
@@ -62,10 +59,10 @@ func (h MockInputsIntsHelper) GenerateRandomNegative(count, min int) (ints []int
 	return
 }
 
-// RunTests runs a test for every value in a testset.
+// MockInputIntRunTests 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.
-func (s MockInputsIntsHelper) RunTests(t testRunner, testSet []int, testFunc func(t *testing.T, index int, i int)) {
+func MockInputIntRunTests(t testRunner, testSet []int, testFunc func(t *testing.T, index int, i int)) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -85,8 +82,8 @@ func (s MockInputsIntsHelper) RunTests(t testRunner, testSet []int, testFunc fun
 	}
 }
 
-// Modify returns a modified version of a test set.
-func (h MockInputsIntsHelper) Modify(inputSlice []int, f func(index int, value int) int) (ints []int) {
+// MockInputIntModify returns a modified version of a test set.
+func MockInputIntModify(inputSlice []int, f func(index int, value int) int) (ints []int) {
 	for i, input := range inputSlice {
 		ints = append(ints, f(i, input))
 	}
diff --git a/mock-strings.go b/mock-strings.go
index cc774d2..744542d 100644
--- a/mock-strings.go
+++ b/mock-strings.go
@@ -7,46 +7,43 @@ import (
 	"github.com/MarvinJWendt/testza/internal"
 )
 
-// MockInputsStringsHelper contains strings test sets.
-type MockInputsStringsHelper struct{}
-
-// Empty returns a test set with a single empty string.
-func (s MockInputsStringsHelper) Empty() []string {
+// MockInputStringEmpty returns a test set with a single empty string.
+func MockInputStringEmpty() []string {
 	return []string{""}
 }
 
-// Long returns a test set with long random strings.
+// MockInputStringLong returns a test set with long random strings.
 // Returns:
 // - Random string (length: 25)
 // - Random string (length: 50)
 // - Random string (length: 100)
 // - Random string (length: 1,000)
 // - Random string (length: 100,000)
-func (s MockInputsStringsHelper) Long() (testSet []string) {
-	testSet = append(testSet, s.GenerateRandom(1, 25)...)
-	testSet = append(testSet, s.GenerateRandom(1, 50)...)
-	testSet = append(testSet, s.GenerateRandom(1, 100)...)
-	testSet = append(testSet, s.GenerateRandom(1, 1_000)...)
-	testSet = append(testSet, s.GenerateRandom(1, 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)...)
 
 	return
 }
 
-// Numeric returns a test set with strings that are numeric.
+// MockInputStringNumeric returns a test set with strings that are numeric.
 // The highest number in here is "9223372036854775807", which is equal to the maxmim int64.
-func (s MockInputsStringsHelper) Numeric() []string {
+func MockInputStringNumeric() []string {
 	positiveNumbers := []string{"0", "1", "2", "3", "100", "1.1", "1337", "13.37", "0.000000000001", "9223372036854775807"}
-	negativeNumbers := s.Modify(positiveNumbers, func(index int, value string) string { return "-" + value })
+	negativeNumbers := MockInputStringModify(positiveNumbers, func(index int, value string) string { return "-" + value })
 	return append(positiveNumbers, negativeNumbers...)
 }
 
-// Usernames returns a test set with usernames.
-func (s MockInputsStringsHelper) Usernames() []string {
+// MockInputStringUsernames returns a test set with usernames.
+func MockInputStringUsernames() []string {
 	return []string{"MarvinJWendt", "Zipper1337", "n00b", "l33t", "j0rgan", "test", "test123", "TEST", "test_", "TEST_"}
 }
 
-// EmailAddresses returns a test set with valid email addresses.
-func (s MockInputsStringsHelper) EmailAddresses() []string {
+// MockInputStringEmailAddresses returns a test set with valid email addresses.
+func MockInputStringEmailAddresses() []string {
 	return []string{
 		"hello@world.com",
 		"hello+world@example.com",
@@ -89,8 +86,8 @@ func (s MockInputsStringsHelper) EmailAddresses() []string {
 	}
 }
 
-// HtmlTags returns a test set with html tags.
-func (s MockInputsStringsHelper) HtmlTags() []string {
+// MockInputStringHtmlTags returns a test set with html tags.
+func MockInputStringHtmlTags() []string {
 	return []string{
 		"<script>alert('XSS')</script>",
 		"<script>",
@@ -100,24 +97,24 @@ func (s MockInputsStringsHelper) HtmlTags() []string {
 	}
 }
 
-// Full contains all string test sets plus ten generated random strings.
-func (s MockInputsStringsHelper) Full() (ret []string) {
-	ret = append(ret, s.Usernames()...)
-	ret = append(ret, s.HtmlTags()...)
-	ret = append(ret, s.EmailAddresses()...)
-	ret = append(ret, s.Empty()...)
-	ret = append(ret, s.Numeric()...)
-	ret = append(ret, s.Long()...)
+// MockInputStringFull contains all string test sets plus ten generated random strings.
+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()...)
 
 	for i := 0; i < 10; i++ {
-		ret = append(ret, s.GenerateRandom(1, i)...)
+		ret = append(ret, MockInputStringGenerateRandom(1, i)...)
 	}
 
 	return
 }
 
-// Limit limits a test set in size.
-func (s MockInputsStringsHelper) Limit(testSet []string, max int) []string {
+// MockInputStringLimit limits a test set in size.
+func MockInputStringLimit(testSet []string, max int) []string {
 	if len(testSet) <= max {
 		return testSet
 	}
@@ -129,8 +126,8 @@ func (s MockInputsStringsHelper) Limit(testSet []string, max int) []string {
 	return testSet[:max]
 }
 
-// GenerateRandom returns random StringsHelper in a test set.
-func (s MockInputsStringsHelper) GenerateRandom(count, length int) (result []string) {
+// MockInputStringGenerateRandom returns random StringsHelper in a test set.
+func MockInputStringGenerateRandom(count, length int) (result []string) {
 	var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
 
 	for i := 0; i < count; i++ {
@@ -144,10 +141,10 @@ func (s MockInputsStringsHelper) GenerateRandom(count, length int) (result []str
 	return
 }
 
-// RunTests runs a test for every value in a testset.
+// MockInputStringRunTests 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.
-func (s MockInputsStringsHelper) RunTests(t testRunner, testSet []string, testFunc func(t *testing.T, index int, str string)) {
+func MockInputStringRunTests(t testRunner, testSet []string, testFunc func(t *testing.T, index int, str string)) {
 	if test, ok := t.(helper); ok {
 		test.Helper()
 	}
@@ -167,8 +164,8 @@ func (s MockInputsStringsHelper) RunTests(t testRunner, testSet []string, testFu
 	}
 }
 
-// Modify returns a modified version of a test set.
-func (s MockInputsStringsHelper) Modify(inputSlice []string, f func(index int, value string) string) (ret []string) {
+// MockInputStringModify returns a modified version of a test set.
+func MockInputStringModify(inputSlice []string, f func(index int, value string) string) (ret []string) {
 	for i, str := range inputSlice {
 		ret = append(ret, f(i, str))
 	}


Test patch:
diff --git a/assert_test.go b/assert_test.go
index bec1c28..63526b8 100644
--- a/assert_test.go
+++ b/assert_test.go
@@ -23,7 +23,7 @@ type assertionTestStructNested struct {
 }
 
 func randomString() string {
-	return Use.Mock.Inputs.Strings.GenerateRandom(1, rand.Intn(10))[0]
+	return MockInputStringGenerateRandom(1, rand.Intn(10))[0]
 }
 
 func generateStruct() (ret assertionTestStruct) {
@@ -41,13 +41,13 @@ func testEqual(t *testing.T, expected, actual interface{}) {
 	t.Run("Equal", func(t *testing.T) {
 		t.Helper()
 
-		Use.Assert.Equal(t, expected, actual)
+		AssertEqual(t, expected, actual)
 	})
 
 	t.Run("EqualValues", func(t *testing.T) {
 		t.Helper()
 
-		Use.Assert.EqualValues(t, expected, actual)
+		AssertEqualValues(t, expected, actual)
 	})
 }
 
@@ -72,7 +72,7 @@ func TestAssertHelper_KindOf(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.kind.String(), func(t *testing.T) {
-			Use.Assert.KindOf(t, test.kind, test.value)
+			AssertKindOf(t, test.kind, test.value)
 		})
 	}
 }
@@ -98,7 +98,7 @@ func TestAssertHelper_NotKindOf(t *testing.T) {
 	}
 	for _, test := range tests {
 		t.Run(test.kind.String(), func(t *testing.T) {
-			Use.Assert.NotKindOf(t, test.kind, test.value)
+			AssertNotKindOf(t, test.kind, test.value)
 		})
 	}
 }
@@ -129,7 +129,7 @@ func TestAssertHelper_Numeric(t *testing.T) {
 
 	for _, number := range numbers {
 		t.Run(pterm.Sprintf("Type=%s;Value=%#v", reflect.TypeOf(number).Kind().String(), number), func(t *testing.T) {
-			Use.Assert.Numeric(t, number)
+			AssertNumeric(t, number)
 		})
 	}
 }
@@ -138,7 +138,7 @@ func TestAssertHelper_NotNumber(t *testing.T) {
 	noNumbers := []interface{}{"Hello, World!", true, false}
 	for _, number := range noNumbers {
 		t.Run(pterm.Sprintf("Type=%s;Value=%#v", reflect.TypeOf(number).Kind().String(), number), func(t *testing.T) {
-			Use.Assert.NotNumeric(t, number)
+			AssertNotNumeric(t, number)
 		})
 	}
 }
@@ -149,7 +149,7 @@ func TestAssertHelper_Zero(t *testing.T) {
 
 	for i, value := range zeroValues {
 		t.Run(fmt.Sprint(i), func(t *testing.T) {
-			Use.Assert.Zero(t, value)
+			AssertZero(t, value)
 		})
 	}
 }
@@ -160,14 +160,14 @@ func TestAssertHelper_NotZero(t *testing.T) {
 
 	for i, value := range zeroValues {
 		t.Run(fmt.Sprint(i), func(t *testing.T) {
-			Use.Assert.NotZero(t, value)
+			AssertNotZero(t, value)
 		})
 	}
 }
 
 func TestAssertHelper_Equal(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		Use.Mock.Inputs.Strings.RunTests(t, Use.Mock.Inputs.Strings.Full(), func(t *testing.T, index int, str string) {
+		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
 			t.Helper()
 
 			testEqual(t, str, str)
@@ -185,8 +185,8 @@ func TestAssertHelper_Equal(t *testing.T) {
 
 func TestAssertHelper_NotEqual(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		Use.Mock.Inputs.Strings.RunTests(t, Use.Mock.Inputs.Strings.Full(), func(t *testing.T, index int, str string) {
-			Use.Assert.NotEqual(t, str, str+" addon")
+		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+			AssertNotEqual(t, str, str+" addon")
 		})
 	})
 
@@ -197,10 +197,10 @@ func TestAssertHelper_NotEqual(t *testing.T) {
 			s2 := s
 			s2.Name += " addon"
 			t.Run("NotEqual", func(t *testing.T) {
-				Use.Assert.NotEqual(t, s, s2)
+				AssertNotEqual(t, s, s2)
 			})
 			t.Run("NotEqualValues", func(t *testing.T) {
-				Use.Assert.NotEqualValues(t, s, s2)
+				AssertNotEqualValues(t, s, s2)
 			})
 		}
 	})
@@ -208,66 +208,66 @@ func TestAssertHelper_NotEqual(t *testing.T) {
 
 func TestAssert_EqualValues(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		Use.Mock.Inputs.Strings.RunTests(t, Use.Mock.Inputs.Strings.Full(), func(t *testing.T, index int, str string) {
-			Use.Assert.EqualValues(t, str, str)
+		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+			AssertEqualValues(t, str, str)
 		})
 	})
 }
 
 func TestAssert_NotEqualValues(t *testing.T) {
 	t.Run("String", func(t *testing.T) {
-		Use.Mock.Inputs.Strings.RunTests(t, Use.Mock.Inputs.Strings.Full(), func(t *testing.T, index int, str string) {
-			Use.Assert.NotEqualValues(t, str, str+" addon")
+		MockInputStringRunTests(t, MockInputStringFull(), func(t *testing.T, index int, str string) {
+			AssertNotEqualValues(t, str, str+" addon")
 		})
 	})
 }
 
 func TestAssertHelper_True(t *testing.T) {
-	Use.Assert.True(t, true)
+	AssertTrue(t, true)
 }
 
 func TestAssertHelper_False(t *testing.T) {
-	Use.Assert.False(t, false)
+	AssertFalse(t, false)
 }
 
 func TestAssert_Implements(t *testing.T) {
 	t.Run("ConstImplementsStringer", func(t *testing.T) {
-		Use.Assert.Implements(t, (*fmt.Stringer)(nil), new(types.Const))
+		AssertImplements(t, (*fmt.Stringer)(nil), new(types.Const))
 	})
 }
 
 func TestAssert_NotImplements(t *testing.T) {
 	t.Run("assertionTestStructNotImplementsFmtStringer", func(t *testing.T) {
-		Use.Assert.NotImplements(t, (*fmt.Stringer)(nil), new(assertionTestStruct))
+		AssertNotImplements(t, (*fmt.Stringer)(nil), new(assertionTestStruct))
 	})
 }
 
 func TestAssertHelper_Contains(t *testing.T) {
 	s := []string{"Hello", "World"}
 
-	Use.Assert.Contains(t, s, "World")
+	AssertContains(t, s, "World")
 }
 
 func TestAssertHelper_NotContains(t *testing.T) {
 	s := []string{"Hello", "World"}
 
-	Use.Assert.NotContains(t, s, "asdasd")
+	AssertNotContains(t, s, "asdasd")
 }
 
 func TestAssertHelper_Panic(t *testing.T) {
-	Use.Assert.Panic(t, func() {
+	AssertPanic(t, func() {
 		panic("TestPanic")
 	})
 }
 
 func TestAssertHelper_NotPanic(t *testing.T) {
-	Use.Assert.NotPanic(t, func() {
+	AssertNotPanic(t, func() {
 		// If we do nothing here it can't panic ;)
 	})
 }
 
 func TestAssertHelper_Nil(t *testing.T) {
-	Use.Assert.Nil(t, nil)
+	AssertNil(t, nil)
 }
 
 func TestAssertHelper_NotNil(t *testing.T) {
@@ -275,29 +275,29 @@ func TestAssertHelper_NotNil(t *testing.T) {
 
 	for _, v := range objectsNotNil {
 		t.Run(pterm.Sprintf("Value=%#v", v), func(t *testing.T) {
-			Use.Assert.NotNil(t, v)
+			AssertNotNil(t, v)
 		})
 	}
 }
 
 func TestAssertHelper_CompletesIn(t *testing.T) {
-	Use.Assert.CompletesIn(t, 50*time.Millisecond, func() {
+	AssertCompletesIn(t, 50*time.Millisecond, func() {
 		time.Sleep(5 * time.Millisecond)
 	})
 }
 
 func TestAssertHelper_NotCompletesIn(t *testing.T) {
-	Use.Assert.NotCompletesIn(t, 10*time.Microsecond, func() {
+	AssertNotCompletesIn(t, 10*time.Microsecond, func() {
 		time.Sleep(15 * time.Millisecond)
 	})
 }
 
 func TestAssertHelper_Greater(t *testing.T) {
-	Use.Assert.Greater(t, 2, 1)
-	Use.Assert.Greater(t, 5, 4)
+	AssertGreater(t, 2, 1)
+	AssertGreater(t, 5, 4)
 }
 
 func TestAssertHelper_Less(t *testing.T) {
-	Use.Assert.Less(t, 1, 2)
-	Use.Assert.Less(t, 4, 5)
+	AssertLess(t, 1, 2)
+	AssertLess(t, 4, 5)
 }
diff --git a/capture_test.go b/capture_test.go
index 27d632e..de6f021 100644
--- a/capture_test.go
+++ b/capture_test.go
@@ -25,9 +25,9 @@ func TestCaptureHelper_Stdout(t *testing.T) {
 
 	for i, tt := range tests {
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
-			got, err := Use.Capture.Stdout(tt.args.capture)
-			Use.Assert.Nil(t, err)
-			Use.Assert.Equal(t, got, tt.want)
+			got, err := CaptureStdout(tt.args.capture)
+			AssertNil(t, err)
+			AssertEqual(t, got, tt.want)
 		})
 	}
 }
@@ -49,9 +49,9 @@ func TestCaptureHelper_Stderr(t *testing.T) {
 
 	for i, tt := range tests {
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
-			got, err := Use.Capture.Stderr(tt.args.capture)
-			Use.Assert.Nil(t, err)
-			Use.Assert.Equal(t, got, tt.want)
+			got, err := CaptureStderr(tt.args.capture)
+			AssertNil(t, err)
+			AssertEqual(t, got, tt.want)
 		})
 	}
 }
diff --git a/mock_test.go b/mock_test.go
index 364f1ab..5d7f8c9 100644
--- a/mock_test.go
+++ b/mock_test.go
@@ -11,17 +11,17 @@ func TestStringsHelper_Modify(t *testing.T) {
 	stringSlice := []string{"Hello", "World", "TeSt"}
 	expected := []string{"hello", "world", "test"}
 
-	input := Use.Mock.Inputs.Strings.Modify(stringSlice, func(index int, value string) string {
+	input := MockInputStringModify(stringSlice, func(index int, value string) string {
 		return strings.ToLower(value)
 	})
 
-	Use.Assert.Equal(t, expected, input)
+	AssertEqual(t, expected, input)
 }
 
 func TestStringsHelper_Limit(t *testing.T) {
 	for i := 0; i < 10; i++ {
 		t.Run(fmt.Sprintf("Limit=%d", i), func(t *testing.T) {
-			Use.Assert.Equal(t, i, len(Use.Mock.Inputs.Strings.Limit(Use.Mock.Inputs.Strings.Full(), i)))
+			AssertEqual(t, i, len(MockInputStringLimit(MockInputStringFull(), i)))
 		})
 	}
 }
@@ -29,70 +29,70 @@ func TestStringsHelper_Limit(t *testing.T) {
 func TestStringsHelper_GenerateRandom(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		t.Run(fmt.Sprintf("Length=%d", i), func(t *testing.T) {
-			Use.Assert.Equal(t, i, len(Use.Mock.Inputs.Strings.GenerateRandom(1, i)[0]))
+			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) {
-			Use.Assert.Equal(t, i, len(Use.Mock.Inputs.Strings.GenerateRandom(i, 5)))
+			AssertEqual(t, i, len(MockInputStringGenerateRandom(i, 5)))
 		})
 	}
 }
 
 func TestStringsHelper_Numeric(t *testing.T) {
-	for _, v := range Use.Mock.Inputs.Strings.Numeric() {
+	for _, v := range MockInputStringNumeric() {
 		t.Run(v, func(t *testing.T) {
 			f, err := strconv.ParseFloat(v, 64)
-			Use.Assert.Numeric(t, f)
-			Use.Assert.NoError(t, err)
+			AssertNumeric(t, f)
+			AssertNoError(t, err)
 		})
 	}
 }
 
 func TestStringsHelper_Full(t *testing.T) {
-	Use.Assert.Greater(t, len(Use.Mock.Inputs.Strings.Full()), 0)
+	AssertGreater(t, len(MockInputStringFull()), 0)
 }
 
 func TestBoolsHelper_Full(t *testing.T) {
-	Use.Assert.Contains(t, Use.Mock.Inputs.Bools.Full(), true)
-	Use.Assert.Contains(t, Use.Mock.Inputs.Bools.Full(), false)
+	AssertContains(t, MockInputBoolFull(), true)
+	AssertContains(t, MockInputBoolFull(), false)
 }
 
 func TestBoolsHelper_RunTests(t *testing.T) {
-	Use.Mock.Inputs.Bools.RunTests(t, Use.Mock.Inputs.Bools.Full(), func(t *testing.T, index int, f bool) {
-		Use.Assert.NotNil(t, f)
+	MockInputBoolRunTests(t, MockInputBoolFull(), func(t *testing.T, index int, f bool) {
+		AssertNotNil(t, f)
 	})
 }
 
 func TestIntsHelper_GenerateRandomPositive(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		t.Run("GenerateRandomPositive generates positive numbers only", func(t *testing.T) {
-			Use.Assert.Greater(t, Use.Mock.Inputs.Ints.GenerateRandomPositive(1, 100)[0], 0)
+			AssertGreater(t, MockInputIntGenerateRandomPositive(1, 100)[0], 0)
 		})
 
 		t.Run("GenerateRandomNegative generates negative numbers only", func(t *testing.T) {
-			Use.Assert.Less(t, Use.Mock.Inputs.Ints.GenerateRandomNegative(1, 100)[0], 0)
+			AssertLess(t, MockInputIntGenerateRandomNegative(1, 100)[0], 0)
 		})
 	}
 }
 
 func TestIntsHelper_Full(t *testing.T) {
-	Use.Assert.Greater(t, len(Use.Mock.Inputs.Ints.Full()), 0)
+	AssertGreater(t, len(MockInputIntFull()), 0)
 }
 
 func TestIntsHelper_RunTests(t *testing.T) {
-	Use.Mock.Inputs.Ints.RunTests(t, Use.Mock.Inputs.Ints.Full(), func(t *testing.T, index int, f int) {
-		Use.Assert.NotNil(t, f)
+	MockInputIntRunTests(t, MockInputIntFull(), func(t *testing.T, index int, f int) {
+		AssertNotNil(t, f)
 	})
 }
 
 func TestFloats64Helper_Full(t *testing.T) {
-	Use.Assert.Greater(t, len(Use.Mock.Inputs.Floats64.Full()), 0)
+	AssertGreater(t, len(MockInputFloat64Full()), 0)
 }
 
 func TestFloats64Helper_RunTests(t *testing.T) {
-	Use.Mock.Inputs.Floats64.RunTests(t, Use.Mock.Inputs.Floats64.Full(), func(t *testing.T, index int, f float64) {
-		Use.Assert.NotNil(t, f)
+	MockInputFloat64RunTests(t, MockInputFloat64Full(), func(t *testing.T, index int, f float64) {
+		AssertNotNil(t, f)
 	})
 }
diff --git a/testza.go b/testza.go
index 553b317..8da4929 100644
--- a/testza.go
+++ b/testza.go
@@ -8,34 +8,3 @@ import (
 func init() {
 	rand.Seed(time.Now().UnixNano())
 }
-
-// Use util functions of testza directly in the default testing system of Go.
-// Methods in here integrate directly with the default Go testing system, and give detailed output.
-// The methods will trigger the test to fail, if your expected behavior didn't occur.
-var Use Helper
-
-// Helper contains helper methods for the Go testing system.
-// Methods in here integrate directly with the default Go testing system, and give detailed output.
-// The methods will trigger the test to fail, if your expected behavior didn't occur.
-type Helper struct {
-	Assert  AssertHelper
-	Mock    MockHelper
-	Capture CaptureHelper
-}
-
-// AssertHelper contains assertion methods for the Go testing system.
-type AssertHelper struct {
-}
-
-type MockInputsHelper struct {
-	Strings  MockInputsStringsHelper
-	Floats64 MockInputsFloats64Helper
-	Ints     MockInputsIntsHelper
-	Bools    MockInputsBoolsHelper
-}
-
-// MockHelper contains mocking methods for the Go testing system.
-// Do not use this struct directly, use the methods in Use.
-type MockHelper struct {
-	Inputs MockInputsHelper
-}