From fd02a9a9b4846c51e3f596a042d8596fa56646bd Mon Sep 17 00:00:00 2001
From: Matthew Dolan <info@mattdolan.com>
Date: Wed, 10 Jun 2020 21:52:12 +0100
Subject: [PATCH] Improvements to documentation (#51)

---
 .idea/codeStyles/Project.xml                  |   3 +
 README.adoc                                   | 144 +++++
 README.md                                     | 527 ------------------
 fixture-android-tests/README.adoc             |   5 +
 fixture-android-tests/README.md               |   5 -
 fixture-generex/README.adoc                   |  40 ++
 fixture-generex/build.gradle.kts              |  67 +++
 .../kotlinfixture/config/GeneratorString.kt   |  29 +
 .../com/appmattus/kotlinfixture/Asserter.kt   |  20 +-
 .../config}/GeneratorStringKtTest.kt          |  29 +-
 fixture-javafaker/README.adoc                 |  42 ++
 fixture-javafaker/build.gradle.kts            |   4 +-
 .../fake/javafaker/JavaFakerConfiguration.kt  |   9 +
 .../fake/javafaker/option/CreditCard.kt       |  12 +
 .../com/appmattus/kotlinfixture/Asserter.kt   |   8 +-
 fixture-kotest/README.adoc                    |  30 +
 fixture-kotest/README.md                      |   5 -
 fixture-kotest/build.gradle.kts               |   4 +-
 fixture/README.adoc                           |   4 +
 fixture/README.md                             |   4 -
 fixture/comparison.adoc                       |  52 ++
 fixture/configuration-options.adoc            | 410 ++++++++++++++
 .../com/appmattus/kotlinfixture/Unresolved.kt |   3 +-
 .../logging/SysOutLoggingStrategy.kt          |   4 +-
 .../resolver/PopulateInstance.kt              |   4 +-
 .../resolver/ThreeTenResolver.kt              |   4 +-
 .../kotlinfixture/resolver/TimeResolver.kt    |   5 +-
 .../appmattus/kotlinfixture/ComparisonTest.kt |  12 +-
 .../decorator/filter/FilterDecoratorTest.kt   |   2 +-
 .../recursion/RecursionDecoratorTest.kt       |   6 +-
 settings.gradle.kts                           |   1 +
 31 files changed, 906 insertions(+), 588 deletions(-)
 create mode 100644 README.adoc
 delete mode 100644 README.md
 create mode 100644 fixture-android-tests/README.adoc
 delete mode 100644 fixture-android-tests/README.md
 create mode 100644 fixture-generex/README.adoc
 create mode 100644 fixture-generex/build.gradle.kts
 create mode 100644 fixture-generex/src/main/kotlin/com/appmattus/kotlinfixture/config/GeneratorString.kt
 rename fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/GeneratorString.kt => fixture-generex/src/test/kotlin/com/appmattus/kotlinfixture/Asserter.kt (56%)
 rename {fixture-javafaker/src/test/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker => fixture-generex/src/test/kotlin/com/appmattus/kotlinfixture/decorator/config}/GeneratorStringKtTest.kt (71%)
 create mode 100644 fixture-javafaker/README.adoc
 create mode 100644 fixture-kotest/README.adoc
 delete mode 100644 fixture-kotest/README.md
 create mode 100644 fixture/README.adoc
 delete mode 100644 fixture/README.md
 create mode 100644 fixture/comparison.adoc
 create mode 100644 fixture/configuration-options.adoc

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index cf74757a..a3d2982b 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -3,6 +3,9 @@
     <AndroidXmlCodeStyleSettings>
       <option name="USE_CUSTOM_SETTINGS" value="true" />
     </AndroidXmlCodeStyleSettings>
+    <AsciiDocCodeStyleSettings>
+      <option name="ONE_SENTENCE_PER_LINE" value="false" />
+    </AsciiDocCodeStyleSettings>
     <JetCodeStyleSettings>
       <option name="PACKAGES_TO_USE_STAR_IMPORTS">
         <value>
diff --git a/README.adoc b/README.adoc
new file mode 100644
index 00000000..6d05a9c2
--- /dev/null
+++ b/README.adoc
@@ -0,0 +1,144 @@
+= KotlinFixture
+Appmattus Limited <info@appmattus.com>
+:toc: preamble
+:toc-title: Contents
+:homepage: https://github.com/appmattus/kotlinfixture
+ifdef::env-github[]
+:tip-caption: :bulb:
+:note-caption: :information_source:
+:important-caption: :heavy_exclamation_mark:
+:caution-caption: :fire:
+:warning-caption: :warning:
+endif::[]
+:link-appmattus: https://github.com/appmattus/kotlinfixture[KotlinFixture]
+
+https://bintray.com/appmattus/maven/fixture/_latestVersion[image:https://api.bintray.com/packages/appmattus/maven/fixture/images/download.svg[Download]]
+https://github.com/appmattus/kotlinfixture/actions[image:https://github.com/appmattus/kotlinfixture/workflows/CI/badge.svg[CI status]]
+https://codecov.io/gh/appmattus/kotlinfixture[image:https://codecov.io/gh/appmattus/kotlinfixture/branch/master/graph/badge.svg[Coverage status]]
+link:LICENSE.md[image:https://img.shields.io/badge/License-Apache%202.0-blue.svg[License]]
+
+A tool to generate well-defined, but essentially random, input following the
+idea of constrained non-determinism.
+
+== Getting started
+
+Include the following dependency in your `build.gradle.kts` file:
+
+[source,kotlin]
+._build.gradle.kts_
+----
+testImplementation("com.appmattus.fixture:fixture:<latest-version>")
+----
+
+Simply create a fixture and invoke it with the type to be generated:
+
+[source,kotlin]
+----
+val fixture = kotlinFixture()
+
+// Generate a list of strings
+val aListOfStrings = fixture<List<String>>()
+
+// Nulls are supported
+val sometimesNull = fixture<Int?>()
+
+// Create instances of classes
+// Optional parameters will be randomly used or overridden
+data class ADataClass(val value: String = "default")
+val aClass = fixture<ADataClass>()
+
+// Abstract classes will pick a sub-class at random
+// This could be a Byte, Double, Long, Float, Int or Short
+val anyNumber = fixture<Number>()
+
+// Pick randomly from a list
+val randomStringFromTheList = fixture(listOf("Cat", "Dog", "Horse"))
+val anotherRandomIntFromAList = fixture(1..5)
+----
+
+You can also generate an infinite sequence of a type, which you can then
+filter:
+
+[source,kotlin]
+----
+val fixture = kotlinFixture()
+
+val intSequence = fixture.asSequence<Int>()
+
+// Standard Kotlin sequence functions can then be applied before using
+// the sequence through an iterator for access to the next() function.
+
+// For example, you can filter values
+val oddIterator = intSequence.filter { it.absoluteValue.rem(2) == 1 }.iterator()
+val oddNumber = oddIterator.next()
+val anotherOddNumber = oddIterator.next()
+
+// Or, ensure it returns only distinct values
+enum class XYZ { X, Y, Z }
+val enumIterator = fixture.asSequence<XYZ>().distinct().iterator()
+val aDistinctValue = enumIterator.next()
+val anotherDistinctValue = enumIterator.next()
+----
+
+[WARNING]
+====
+The sequence can hang indefinitely if the applied operators prevent the generation of new values. For example:
+
+* `distinct` will hang if we exhaust all available values. A good practice is to add a `take(count)` which will throw a `NoSuchElementException` if we try to generate more values.
+* `filter` that can never be fulfilled e.g. `filter { false }`
+====
+
+== Configuration options
+
+Everything can be customised, see link:fixture/configuration-options.adoc[configuration options] for more details.
+
+== Kotest integration: property based testing
+
+The library provides {link-appmattus} powered property based testing for https://github.com/kotest/kotest/[Kotest].
+
+See link:fixture-kotest/README.adoc[Kotest integration] for more details.
+
+== Java Faker integration: pretty data
+
+Generate values with a closer match to real data using http://dius.github.io/java-faker/[Java Faker].
+
+See link:fixture-javafaker/README.adoc[Java Faker integration] for more details.
+
+== Generex integration: regex to random string
+
+To generate a random string from a Regex, look no further than the Generex integration.
+
+See link:fixture-generex/README.adoc[Generex integration] for more details.
+
+== Related projects
+
+* Marcello Galhardo's https://github.com/marcellogalhardo/kotlin-fixture[Kotlin.Fixture].
+* FlexTrade's https://github.com/FlexTradeUKLtd/kfixture[KFixture] wrapper for https://github.com/FlexTradeUKLtd/jfixture[JFixture].
+* Jeasy's https://github.com/j-easy/easy-random[Easy Random],
+
+Please take a look at the feature link:fixture/comparison.adoc[comparison with related projects].
+
+== Contributing
+
+Please fork this repository and contribute back using
+https://github.com/appmattus/kotlinfixture/pulls[pull requests].
+
+All contributions, large or small, major features, bug fixes, additional
+language translations, unit/integration tests are welcome.
+
+== License
+
+link:LICENSE.md[image:https://img.shields.io/badge/License-Apache%202.0-blue.svg[License]]
+
+Copyright 2020 Appmattus Limited
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may
+not use this file except in compliance with the License. You may obtain
+a copy of the License at
+https://www.apache.org/licenses/LICENSE-2.0[https://www.apache.org/licenses/LICENSE-2.0].
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/README.md b/README.md
deleted file mode 100644
index 7c1e8e16..00000000
--- a/README.md
+++ /dev/null
@@ -1,527 +0,0 @@
-# Fixture for Kotlin
-
-[![Download](https://api.bintray.com/packages/appmattus/maven/fixture/images/download.svg)](https://bintray.com/appmattus/maven/fixture/_latestVersion)
-[![CI status](https://github.com/appmattus/kotlinfixture/workflows/CI/badge.svg)](https://github.com/appmattus/kotlinfixture/actions)
-[![Coverage status](https://codecov.io/gh/appmattus/kotlinfixture/branch/master/graph/badge.svg)](https://codecov.io/gh/appmattus/kotlinfixture)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE.md)
-
-## Getting started
-
-Include the following dependencies in your `build.gradle.kts` file:
-
-```kotlin
-testImplementation("com.appmattus.fixture:fixture:<latest-version>")
-
-// Add for Kotest integration
-testImplementation("com.appmattus.fixture:fixture-kotest:<latest-version>")
-
-// Add for Java Faker integration
-testImplementation("com.appmattus.fixture:fixture-javafaker:<latest-version>")
-```
-
-Simply create a fixture and invoke it with the type to be generated:
-
-```kotlin
-val fixture = kotlinFixture()
-
-// Generate a list of strings
-val aListOfStrings = fixture<List<String>>()
-
-// Nulls are supported
-val sometimesNull = fixture<Int?>()
-
-// Create instances of classes
-// Optional parameters will be randomly used or overridden
-data class ADataClass(val value: String = "default")
-val aClass = fixture<ADataClass>()
-
-// Abstract classes will pick a sub-class at random
-// This could be a Byte, Double, Long, Float, Int or Short
-val anyNumber = fixture<Number>()
-
-// Pick randomly from a list
-val randomStringFromTheList = fixture(listOf("Cat", "Dog", "Horse"))
-val anotherRandomIntFromAList = fixture(1..5)
-```
-
-You can also generate an infinite sequence of a type, which can then be
-filtered:
-
-```kotlin
-val fixture = kotlinFixture()
-
-val intSequence = fixture.asSequence<Int>()
-
-// Standard Kotlin sequence functions can then be applied before using
-// the sequence through an iterator for access to the next() function.
-
-// For example, you can filter values
-val oddIterator = intSequence.filter { it.absoluteValue.rem(2) == 1 }.iterator()
-val oddNumber = oddIterator.next()
-val anotherOddNumber = oddIterator.next()
-
-// Or, ensure it returns only distinct values
-// NOTE: As the sequence is infinite, distinct will hang if no more
-// distinct values can be generated
-enum class XYZ { X, Y, Z }
-val enumIterator = fixture.asSequence<XYZ>().distinct().iterator()
-val aDistinctValue = enumIterator.next()
-val anotherDistinctValue = enumIterator.next()
-```
-
-### Configuration options
-
-The default configuration can be overridden when creating the fixture object or
-when creating a particular implementation.
-
-It is possible to create a new fixture based on an existing one, which allows
-the addition of configuration changes:
-
-```kotlin
-val baseFixture = kotlinFixture {
-    factory<Int> { 3 }
-}
-
-val fixture = baseFixture.new {
-    factory<Long> { 100L }
-}
-
-// Prints 100
-println(fixture<Long>())
-// Prints 3
-println(fixture<Int>())
-```
-
-#### repeatCount
-
-Used to determine the length used for lists and maps.
-
-```kotlin
-val fixture = kotlinFixture {
-    repeatCount { 3 }
-}
-
-val listOfThreeItems = fixture<List<String>>()
-
-val listOfSevenItems = fixture<List<String>> {
-    // Overrides the parent configuration
-    repeatCount { 7 }
-}
-```
-
-`repeatCount` is a factory method so can be used to return lists and maps of
-different lengths each execution:
-
-```kotlin
-repeatCount {
-    random.nextInt(1, 5)
-}
-```
-
-#### subType
-
-Used to always return an instance of a particular subclass for a superclass.
-
-```kotlin
-val fixture = kotlinFixture {
-    subType<Number, Int>()
-}
-
-val alwaysInt = fixture<Number>()
-
-val alwaysFloat = fixture<Number> {
-    // Overrides the parent configuration
-    subType<Number, Float>()
-}
-```
-
-#### factory
-
-Used to return the given instance for a particular class using a factory
-method.
-
-```kotlin
-val fixture = kotlinFixture {
-    factory<Number> {
-        41
-    }
-}
-
-val alwaysFortyOne = fixture<Number>()
-
-val alwaysOnePointFive = fixture<Number> {
-    // Overrides the parent configuration
-    factory<Number> {
-        1.5
-    }
-}
-```
-
-As `factory` is a factory method you can return different values on every
-execution:
-
-```kotlin
-factory<Number> {
-    random.nextInt(10, 50)
-}
-```
-
-##### Date and Calendar instances
-
-By default `Date` and `Calendar` instances pick a date within 10 years of
-1 Jan 2020.
-
-This can be overridden using `factory` which has some built in constructs:
-
-```kotlin
-val fixture = kotlinFixture {
-    // Generate using ranges (and iterables)
-    factory<Int> { range(1..10) }
-
-    // Generate between two dates
-    factory<Date> { between(startDate, endDate) }
-}
-
-val betweenTwoDates = fixture<Date>()
-
-// You can also override at instance creation
-
-val pastDate = fixture<Date> {
-    factory<Date> { before(Date()) }
-}
-
-val futureDate = fixture<Date> {
-    factory<Date> { after(Date()) }
-}
-```
-
-#### filter
-
-Used to allow generated values to be filtered using standard sequence
-functions.
-
-```kotlin
-val fixture = kotlinFixture {
-    filter<Int> {
-        filter { it % 2 == 0 }
-    }
-
-    // Can be used to return distinct values.
-    // NOTE: As the sequence is infinite, distinct will hang if no more
-    // distinct values can be generated
-    filter<String> {
-        distinct()
-    }
-}
-
-val evenNumber = fixture<Int>()
-
-val evenNumberLessThan100 = fixture<Int> {
-    // Overrides the parent configuration
-    filter<Int> {
-        filter { it < 100 }
-    }
-}
-```
-
-#### property
-
-Used to override constructor parameters or mutable properties when generating
-instances of generic classes.
-
-Given the following Kotlin class:
-
-```kotlin
-class KotlinClass(val readOnly: String, private var private: String) {
-    var member: String? = null
-}
-```
-
-We can override creating an instance of `KotlinClass` as follows:
-
-```kotlin
-val fixture = kotlinFixture {
-    // Public constructor parameters overridden by reference:
-    property(KotlinClass::readOnly) { "a" }
-
-    // Private constructor parameters are overridden by name:
-    property<KotlinClass, String>("private") { "b" }
-
-    // Public member properties overridden by reference:
-    property(KotlinClass::member) { "c" }
-}
-```
-
-Given the following Java class:
-
-```java
-public class JavaClass {
-    private final String constructor;
-    private String mutable;
-
-    public JavaClass(String constructor) { this.constructor = constructor; }
-
-    public void setMutable(String mutable) { this.mutable = mutable; }
-}
-```
-
-We can override creating an instance of `JavaClass` as follows:
-
-```kotlin
-val fixture = kotlinFixture {
-    // Setter overridden by reference:
-    property<String>(JavaClass::setMutable) { "d" }
-
-    // Constructor parameters don't typically retain names and so are
-    // overridden by a positional 'arg' names:
-    property<JavaClass, String>("arg0") { "e" }
-}
-```
-
-#### random
-
-By default a `Random` class is used that will generate unique values between
-runs. If you want repeatability you can specify a seeded `Random` instance.
-
-```kotlin
-val fixture = kotlinFixture {
-    random = Random(seed = 10)
-}
-
-val alwaysTheSame = fixture<Int>()
-
-// Can be specified on creation, but makes the result static
-val aStaticValue = fixture<Int> {
-    random = Random(seed = 5)
-}
-```
-
-#### nullabilityStrategy
-
-By default when the library comes across a nullable type, such as `String?` it
-will randomly return a value or null. This can be overridden by setting a
-nullability strategy.
-
-```kotlin
-val fixture = kotlinFixture {
-    // All nullable types will be populated with a value
-    nullabilityStrategy(NeverNullStrategy)
-}
-
-// You can also override at instance creation
-
-fixture<AnObject> {
-    // All nullable types will be populated with null
-    nullabilityStrategy(AlwaysNullStrategy)
-}
-```
-
-It is also possible to define and implement your own nullability strategy by
-implementing `NullabilityStrategy` and applying it as above.
-
-#### optionalStrategy
-
-By default when the library comes across an optional type, such as
-`value: String = "default"` it will randomly return that default value
-or a generated value. This can be overridden by setting an optional
-strategy.
-
-```kotlin
-val fixture = kotlinFixture {
-    // All optionals will be populated with generated values
-    optionalStrategy(NeverOptionalStrategy)
-}
-
-// You can also override at instance creation
-
-fixture<AnObject> {
-    // All optionals will be populated with their default value
-    optionalStrategy(AlwaysOptionalStrategy) {
-        // You can override the strategy for a particular class
-        classOverride<AnotherObject>(NeverOptionalStrategy)
-
-        // You can override the strategy for a property of a class
-        propertyOverride(AnotherObject::property, RandomlyOptionalStrategy)
-    }
-}
-```
-
-#### recursionStrategy
-
-When recursion is detected the library will, by default, throw an
-`UnsupportedOperationException` with the details of the circular reference. This
-strategy can be changed to instead return `null` for the reference, however, if
-this results in an invalid object an exception will still be thrown as the
-object requested couldn't be resolved.
-
-```kotlin
-val fixture = kotlinFixture {
-    recursionStrategy(NullRecursionStrategy)
-}
-
-// You can also override at instance creation
-
-fixture<AnObject> {
-    recursionStrategy(NullRecursionStrategy)
-}
-```
-
-It is also possible to define and implement your own recursion strategy by
-implementing `RecursionStrategy` and applying it as above.
-
-#### loggingStrategy
-
-A basic logger can be applied using the built in `SysOutLoggingStrategy`. It is
-also possible to define and implement your own logging strategy by implementing
-`LoggingStrategy` and applying it as below.
-
-```kotlin
-val fixture = kotlinFixture {
-    loggingStrategy(SysOutLoggingStrategy)
-}
-
-fixture<String> {
-    // You can also override at instance creation
-    loggingStrategy(SysOutLoggingStrategy)
-}
-```
-
-This outputs:
-
-```text
-ktype kotlin.String →
-    class kotlin.String →
-        Success(5878ec34-c30f-40c7-ad52-c15a39b44ac1)
-    Success(5878ec34-c30f-40c7-ad52-c15a39b44ac1)
-```
-
-#### constructorStrategy
-
-By default when the library generates an instance of a class it picks a
-constructor at random. This can be overridden by setting a constructor
-strategy.
-
-```kotlin
-val fixture = kotlinFixture {
-    constructorStrategy(ModestConstructorStrategy)
-}
-```
-
-The following strategies are built in:
-
-- [RandomConstructorStrategy](fixture/src/main/kotlin/com/appmattus/kotlinfixture/decorator/constructor/RandomConstructorStrategy.kt),
-  order constructors by random.
-
-- [ModestConstructorStrategy](fixture/src/main/kotlin/com/appmattus/kotlinfixture/decorator/constructor/ModestConstructorStrategy.kt),
-  order constructors by the most modest constructor first. i.e. fewer
-  parameters returned first.
-
-- [GreedyConstructorStrategy](fixture/src/main/kotlin/com/appmattus/kotlinfixture/decorator/constructor/GreedyConstructorStrategy.kt),
-  order constructors by the most greedy constructor first. i.e. greater
-  parameters returned first.
-
-- [ArrayFavouringConstructorStrategy](fixture/src/main/kotlin/com/appmattus/kotlinfixture/decorator/constructor/ArrayFavouringConstructorStrategy.kt),
-  order constructors selecting those with the most parameters of
-  Array<*> before any other.
-
-- [ListFavouringConstructorStrategy](fixture/src/main/kotlin/com/appmattus/kotlinfixture/decorator/constructor/ListFavouringConstructorStrategy.kt),
-  order constructors selecting those with the most parameters of List<*>
-  before any other.
-
-It is also possible to define and implement your own constructor
-strategy by implementing `ConstructorStrategy` and applying it as above.
-
-## Kotest support
-
-[Kotest](https://github.com/kotest/kotest/) supports
-[property testing](https://github.com/kotest/kotest/blob/master/doc/reference.md#property-based-testing-),
-but to use it with more than just the few basic types that are built
-into the library requires you to create your own custom generators that
-you then have to provide.
-
-Including the `fixture-kotest` dependency in your project adds extension
-functions `checkAll` and `forAll` to the fixture. These
-functions wrap the equivalent functions from Kotest while providing
-generation of all the classes
-[KotlinFixture](https://github.com/appmattus/kotlinfixture) supports.
-For example:
-
-```kotlin
-data class Person(name: String, age: Int)
-
-fixture.checkAll { person1: Person, person2: Person ->
-   person1 shouldNotBeSameInstanceAs person2
-}
-```
-
-## Java Faker support
-
-The [Java Faker](http://dius.github.io/java-faker/) library generates
-fake data, useful if you need to generate objects with pretty data.
-
-Including the `fixture-javafaker` dependency in your project adds a
-`javaFakerStrategy` which will use
-[Java Faker](http://dius.github.io/java-faker/) to populate named
-properties such as `name`, `city` and `phoneNumber`. A full list of
-supported properties and how they map to
-[Java Faker](http://dius.github.io/java-faker/) can be found in
-[JavaFakerConfiguration](fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/JavaFakerConfiguration.kt).
-
-Additionally, the `javaFakerStrategy` function allows you to override
-faker settings such as `locale`.
-
-```kotlin
-
-val fixture = kotlinFixture {
-    javaFakerStrategy()
-}
-
-data class Person(val name: String, val age: Long)
-
-println(fixture<Person>()) // Person(name=Keneth Bartoletti, age=54)
-```
-
-### Regex to String generation
-
-The module also introduces the ability to generate a random string from
-a Regex, with no need to enable the faker functionality:
-
-```kotlin
-        data class DataClass(val index: String, val value: String)
-
-        val indexRegex = "[a-z][0-9]".toRegex()
-        val valueRegex = "[A-Z]{3}".toRegex()
-
-        val fixture = kotlinFixture {
-            factory<String> { regexify(indexRegex) }
-
-            property(DataClass::value) { regexify(valueRegex) }
-        }
-
-        println(fixture<DataClass>()) // DataClass(index=m3, value=CGJ)
-```
-
-## Contributing
-
-Please fork this repository and contribute back using
-[pull requests](https://github.com/appmattus/kotlinfixture/pulls).
-
-All contributions, large or small, major features, bug fixes, additional
-language translations, unit/integration tests are welcomed.
-
-## License
-
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE.md)
-
-Copyright 2019 Appmattus Limited
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may
-not use this file except in compliance with the License. You may obtain
-a copy of the License at
-[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/fixture-android-tests/README.adoc b/fixture-android-tests/README.adoc
new file mode 100644
index 00000000..e9c03c19
--- /dev/null
+++ b/fixture-android-tests/README.adoc
@@ -0,0 +1,5 @@
+= fixture-android-tests module
+
+This module enables the execution of tests for Android specific resolvers,
+such as link:../fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/AndroidUriResolver.kt[AndroidUriResolver],
+using http://robolectric.org[Robolectric].
\ No newline at end of file
diff --git a/fixture-android-tests/README.md b/fixture-android-tests/README.md
deleted file mode 100644
index 66b5c043..00000000
--- a/fixture-android-tests/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# fixture-android-tests module
-
-This module enables the execution of tests for Android specific resolvers,
-such as [AndroidUriResolver](../fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/AndroidUriResolver.kt),
-using [Robolectric](http://robolectric.org).
diff --git a/fixture-generex/README.adoc b/fixture-generex/README.adoc
new file mode 100644
index 00000000..c06343e8
--- /dev/null
+++ b/fixture-generex/README.adoc
@@ -0,0 +1,40 @@
+== Generex integration
+ifdef::env-github[]
+:tip-caption: :bulb:
+:note-caption: :information_source:
+:important-caption: :heavy_exclamation_mark:
+:caution-caption: :fire:
+:warning-caption: :warning:
+endif::[]
+
+[source,kotlin]
+._build.gradle.kts_
+----
+// Add for Generex integration
+testImplementation("com.appmattus.fixture:fixture-generex:<latest-version>")
+----
+
+The https://github.com/mifmif/Generex[Generex] library generates random
+strings from a regular expression.
+
+Including the `fixture-generex` dependency in your project adds a
+`regexToRandom` function to `factory` and `property` generators.
+
+[source,kotlin]
+----
+data class DataClass(val index: String, val value: String)
+
+val indexRegex = "[a-z][0-9]".toRegex()
+val valueRegex = "[A-Z]{3}".toRegex()
+
+val fixture = kotlinFixture {
+    factory<String> { regexToRandom(indexRegex) }
+
+    property(DataClass::value) { regexToRandom(valueRegex) }
+}
+
+println(fixture<DataClass>()) // DataClass(index=m3, value=CGJ)
+----
+
+IMPORTANT: Be careful with object creation inside the generation function as it
+will be called for every instance of the object you create.
diff --git a/fixture-generex/build.gradle.kts b/fixture-generex/build.gradle.kts
new file mode 100644
index 00000000..c7fb6ed5
--- /dev/null
+++ b/fixture-generex/build.gradle.kts
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2020 Appmattus Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    kotlin("jvm")
+    id("com.android.lint")
+}
+
+apply(from = "$rootDir/bintray.gradle.kts")
+apply(from = "$rootDir/gradle/scripts/jacoco.gradle.kts")
+
+dependencies {
+    api(kotlin("stdlib-jdk8"))
+    api(project(":fixture"))
+    api("com.github.mifmif:generex:1.0.2")
+
+    testImplementation("junit:junit:4.13")
+    testImplementation(kotlin("test"))
+    testImplementation(kotlin("test-junit"))
+    testImplementation("com.nhaarman.mockitokotlin2:mockito-kotlin:2.2.0")
+
+    testImplementation(kotlin("reflect"))
+    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.3.7")
+}
+
+lintOptions {
+    isAbortOnError = true
+    isWarningsAsErrors = true
+    htmlOutput = file("$buildDir/reports/lint-results.html")
+    xmlOutput = file("$buildDir/reports/lint-results.xml")
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+tasks.withType<KotlinCompile> {
+    kotlinOptions.jvmTarget = "1.8"
+}
+
+// Fix lack of source code when publishing pure Kotlin projects
+// See https://github.com/novoda/bintray-release/issues/262
+tasks.whenTaskAdded {
+    if (name == "generateSourcesJarForMavenPublication") {
+        this as Jar
+        from(sourceSets.main.get().allSource)
+    }
+}
+
+tasks.getByName("check").finalizedBy(rootProject.tasks.getByName("detekt"))
+tasks.getByName("check").finalizedBy(rootProject.tasks.getByName("markdownlint"))
diff --git a/fixture-generex/src/main/kotlin/com/appmattus/kotlinfixture/config/GeneratorString.kt b/fixture-generex/src/main/kotlin/com/appmattus/kotlinfixture/config/GeneratorString.kt
new file mode 100644
index 00000000..bbcb9b90
--- /dev/null
+++ b/fixture-generex/src/main/kotlin/com/appmattus/kotlinfixture/config/GeneratorString.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2020 Appmattus Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.appmattus.kotlinfixture.config
+
+import com.mifmif.common.regex.Generex
+
+fun Generator<String>.regexToRandom(regex: String, minLength: Int = 1, maxLength: Int = Int.MAX_VALUE): String {
+    return Generex(regex).apply {
+        setSeed(random.nextLong())
+    }.random(minLength, maxLength)
+}
+
+fun Generator<String>.regexToRandom(regex: Regex, minLength: Int = 1, maxLength: Int = Int.MAX_VALUE): String {
+    return regexToRandom(regex.pattern, minLength, maxLength)
+}
diff --git a/fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/GeneratorString.kt b/fixture-generex/src/test/kotlin/com/appmattus/kotlinfixture/Asserter.kt
similarity index 56%
rename from fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/GeneratorString.kt
rename to fixture-generex/src/test/kotlin/com/appmattus/kotlinfixture/Asserter.kt
index d400da3e..250d1620 100644
--- a/fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/GeneratorString.kt
+++ b/fixture-generex/src/test/kotlin/com/appmattus/kotlinfixture/Asserter.kt
@@ -14,18 +14,16 @@
  * limitations under the License.
  */
 
-package com.appmattus.kotlinfixture.decorator.fake.javafaker
+package com.appmattus.kotlinfixture
 
-import com.appmattus.kotlinfixture.config.Generator
-import com.github.javafaker.Faker
-import kotlin.random.asJavaRandom
+import kotlin.test.fail
 
-@Suppress("SpellCheckingInspection")
-fun Generator<String>.regexify(regex: String): String {
-    return Faker(random.asJavaRandom()).regexify(regex)
-}
+fun assertIsRandom(block: () -> Any?) {
+    val initial = block()
+
+    repeat(1000) {
+        if (initial != block()) return
+    }
 
-@Suppress("SpellCheckingInspection")
-fun Generator<String>.regexify(regex: Regex): String {
-    return regexify(regex.pattern)
+    fail("Value always equal to $initial")
 }
diff --git a/fixture-javafaker/src/test/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/GeneratorStringKtTest.kt b/fixture-generex/src/test/kotlin/com/appmattus/kotlinfixture/decorator/config/GeneratorStringKtTest.kt
similarity index 71%
rename from fixture-javafaker/src/test/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/GeneratorStringKtTest.kt
rename to fixture-generex/src/test/kotlin/com/appmattus/kotlinfixture/decorator/config/GeneratorStringKtTest.kt
index 666b29c4..f9825205 100644
--- a/fixture-javafaker/src/test/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/GeneratorStringKtTest.kt
+++ b/fixture-generex/src/test/kotlin/com/appmattus/kotlinfixture/decorator/config/GeneratorStringKtTest.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Appmattus Limited
+ * Copyright 2020 Appmattus Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
-package com.appmattus.kotlinfixture.decorator.fake.javafaker
+package com.appmattus.kotlinfixture.decorator.config
 
 import com.appmattus.kotlinfixture.assertIsRandom
+import com.appmattus.kotlinfixture.config.regexToRandom
 import com.appmattus.kotlinfixture.kotlinFixture
 import kotlin.random.Random
 import kotlin.test.Test
@@ -29,10 +30,10 @@ class GeneratorStringKtTest {
     private val regex = pattern.toRegex()
 
     @Test
-    fun `regexify using regex generates string matching regex`() {
+    fun `regexToRandom using regex generates string matching regex`() {
 
         val fixture = kotlinFixture {
-            factory<String> { regexify(regex) }
+            factory<String> { regexToRandom(regex) }
         }
 
         repeat(100) {
@@ -45,10 +46,10 @@ class GeneratorStringKtTest {
     }
 
     @Test
-    fun `regexify using regex is random`() {
+    fun `regexToRandom using regex is random`() {
 
         val fixture = kotlinFixture {
-            factory<String> { regexify(regex) }
+            factory<String> { regexToRandom(regex) }
         }
 
         assertIsRandom {
@@ -57,9 +58,9 @@ class GeneratorStringKtTest {
     }
 
     @Test
-    fun `regexify using regex uses seeded random`() {
+    fun `regexToRandom using regex uses seeded random`() {
         val fixture = kotlinFixture {
-            factory<String> { regexify(regex) }
+            factory<String> { regexToRandom(regex) }
         }
 
         val value1 = fixture<String> {
@@ -73,10 +74,10 @@ class GeneratorStringKtTest {
     }
 
     @Test
-    fun `regexify using string generates string matching regex`() {
+    fun `regexToRandom using string generates string matching regex`() {
 
         val fixture = kotlinFixture {
-            factory<String> { regexify(pattern) }
+            factory<String> { regexToRandom(pattern) }
         }
 
         repeat(100) {
@@ -89,10 +90,10 @@ class GeneratorStringKtTest {
     }
 
     @Test
-    fun `regexify using string is random`() {
+    fun `regexToRandom using string is random`() {
 
         val fixture = kotlinFixture {
-            factory<String> { regexify(pattern) }
+            factory<String> { regexToRandom(pattern) }
         }
 
         assertIsRandom {
@@ -101,9 +102,9 @@ class GeneratorStringKtTest {
     }
 
     @Test
-    fun `regexify using string uses seeded random`() {
+    fun `regexToRandom using string uses seeded random`() {
         val fixture = kotlinFixture {
-            factory<String> { regexify(pattern) }
+            factory<String> { regexToRandom(pattern) }
         }
 
         val value1 = fixture<String> {
diff --git a/fixture-javafaker/README.adoc b/fixture-javafaker/README.adoc
new file mode 100644
index 00000000..7997d52e
--- /dev/null
+++ b/fixture-javafaker/README.adoc
@@ -0,0 +1,42 @@
+== Java Faker integration
+ifdef::env-github[]
+:tip-caption: :bulb:
+:note-caption: :information_source:
+:important-caption: :heavy_exclamation_mark:
+:caution-caption: :fire:
+:warning-caption: :warning:
+endif::[]
+
+[source,kotlin]
+._build.gradle.kts_
+----
+// Add for Java Faker integration
+testImplementation("com.appmattus.fixture:fixture-javafaker:<latest-version>")
+----
+
+The http://dius.github.io/java-faker/[Java Faker] library generates
+fake data, useful if you need to generate objects with pretty data.
+
+Including the `fixture-javafaker` dependency in your project adds a
+`javaFakerStrategy` which uses
+http://dius.github.io/java-faker/[Java Faker] to populate named
+properties such as `name`, `city` and `phoneNumber`. A full list of
+supported properties and how they map to
+http://dius.github.io/java-faker/[Java Faker] can be found in
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/JavaFakerConfiguration.kt[JavaFakerConfiguration]`.
+
+[source,kotlin]
+----
+
+val fixture = kotlinFixture {
+    javaFakerStrategy()
+}
+
+data class Person(val name: String, val age: Long)
+
+println(fixture<Person>()) // Person(name=Keneth Bartoletti, age=54)
+----
+
+Additionally, the `javaFakerStrategy` function allows you to override
+faker settings such as `locale`. The available options can be found in
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/JavaFakerConfigurationBuilder.kt[JavaFakerConfigurationBuilder]`.
diff --git a/fixture-javafaker/build.gradle.kts b/fixture-javafaker/build.gradle.kts
index 2d5fe52f..a282d285 100644
--- a/fixture-javafaker/build.gradle.kts
+++ b/fixture-javafaker/build.gradle.kts
@@ -41,8 +41,8 @@ dependencies {
 lintOptions {
     isAbortOnError = true
     isWarningsAsErrors = true
-    htmlOutput = file("${buildDir}/reports/lint-results.html")
-    xmlOutput = file("${buildDir}/reports/lint-results.xml")
+    htmlOutput = file("$buildDir/reports/lint-results.html")
+    xmlOutput = file("$buildDir/reports/lint-results.xml")
 }
 
 java {
diff --git a/fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/JavaFakerConfiguration.kt b/fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/JavaFakerConfiguration.kt
index 3f0e7bd0..cd36c5b3 100644
--- a/fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/JavaFakerConfiguration.kt
+++ b/fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/JavaFakerConfiguration.kt
@@ -76,6 +76,7 @@ data class JavaFakerConfiguration(
             // Aviation
             entry("aircraft") { aviation().aircraft() },
             entry("airport") { aviation().airport() },
+            @Suppress("SpellCheckingInspection")
             entry("METAR") { aviation().METAR() },
 
             // Business
@@ -84,11 +85,15 @@ data class JavaFakerConfiguration(
             entry("creditCardType") { business().creditCardType() },
 
             // Code
+            @Suppress("SpellCheckingInspection")
             entry("asin") { code().asin() },
             entry("ean13") { code().ean13() },
             entry("ean8") { code().ean8() },
+            @Suppress("SpellCheckingInspection")
             entry("gtin13") { code().gtin13() },
+            @Suppress("SpellCheckingInspection")
             entry("gtin8") { code().gtin8() },
+            @Suppress("SpellCheckingInspection")
             entry("imei") { code().imei() },
             entry("isbn10") { code().isbn10(it.isbn10Separator) },
             entry("isbn13") { code().isbn13(it.isbn13Separator) },
@@ -153,6 +158,7 @@ data class JavaFakerConfiguration(
                     else -> finance().creditCard(it.creditCard.creditCardType)
                 }
             },
+            @Suppress("SpellCheckingInspection")
             entry("iban") { finance().iban() },
 
             // IdNumber
@@ -169,8 +175,10 @@ data class JavaFakerConfiguration(
                 }
             },
             entry("ipV4Address") { internet().ipV4Address() },
+            @Suppress("SpellCheckingInspection")
             entry("ipV4Cidr") { internet().ipV4Cidr() },
             entry("ipV6Address") { internet().ipV6Address() },
+            @Suppress("SpellCheckingInspection")
             entry("ipV6Cidr") { internet().ipV6Cidr() },
             entry("macAddress") { internet().macAddress() },
             entry("password") {
@@ -206,6 +214,7 @@ data class JavaFakerConfiguration(
             entry("phoneNumber") { phoneNumber().phoneNumber() },
 
             // Stock
+            @Suppress("SpellCheckingInspection")
             entry("nsdqSymbol") { stock().nsdqSymbol() },
             entry("nyseSymbol") { stock().nyseSymbol() },
 
diff --git a/fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/option/CreditCard.kt b/fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/option/CreditCard.kt
index 99124df2..4b81293d 100644
--- a/fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/option/CreditCard.kt
+++ b/fixture-javafaker/src/main/kotlin/com/appmattus/kotlinfixture/decorator/fake/javafaker/option/CreditCard.kt
@@ -23,14 +23,26 @@ enum class CreditCard(internal val creditCardType: CreditCardType?) {
     Any(null),
 
     AmericanExpress(CreditCardType.AMERICAN_EXPRESS),
+
+    @Suppress("SpellCheckingInspection")
     Dankort(CreditCardType.DANKORT),
+
     DinersClub(CreditCardType.DINERS_CLUB),
+
     Discover(CreditCardType.DISCOVER),
+
+    @Suppress("SpellCheckingInspection")
     Forbrugsforeningen(CreditCardType.FORBRUGSFORENINGEN),
+
     JCB(CreditCardType.JCB),
+
     Laser(CreditCardType.LASER),
+
     Mastercard(CreditCardType.MASTERCARD),
+
     Solo(CreditCardType.SOLO),
+
     Switch(CreditCardType.SWITCH),
+
     Visa(CreditCardType.VISA)
 }
diff --git a/fixture-javafaker/src/test/kotlin/com/appmattus/kotlinfixture/Asserter.kt b/fixture-javafaker/src/test/kotlin/com/appmattus/kotlinfixture/Asserter.kt
index c1893202..250d1620 100644
--- a/fixture-javafaker/src/test/kotlin/com/appmattus/kotlinfixture/Asserter.kt
+++ b/fixture-javafaker/src/test/kotlin/com/appmattus/kotlinfixture/Asserter.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Appmattus Limited
+ * Copyright 2020 Appmattus Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,9 +27,3 @@ fun assertIsRandom(block: () -> Any?) {
 
     fail("Value always equal to $initial")
 }
-
-fun assertNone(iterations: Int = 1000, block: () -> Boolean) {
-    repeat(iterations) {
-        if (block()) fail("Value is true")
-    }
-}
diff --git a/fixture-kotest/README.adoc b/fixture-kotest/README.adoc
new file mode 100644
index 00000000..e29b0128
--- /dev/null
+++ b/fixture-kotest/README.adoc
@@ -0,0 +1,30 @@
+== Kotest integration
+
+[source,kotlin]
+._build.gradle.kts_
+----
+// Add for Kotest integration
+testImplementation("com.appmattus.fixture:fixture-kotest:<latest-version>")
+----
+
+https://github.com/kotest/kotest/[Kotest] supports
+https://github.com/kotest/kotest/blob/master/doc/reference.md#property-based-testing-[property testing],
+but to use it with more than just the few basic types built
+into the library requires you to create your own custom generators which
+you then provide.
+
+Including the `fixture-kotest` dependency in your project adds extension
+functions `checkAll` and `forAll` to the fixture. These
+functions wrap the equivalent functions from Kotest while providing
+generation of all the classes
+https://github.com/appmattus/kotlinfixture[KotlinFixture] supports.
+For example:
+
+[source,kotlin]
+----
+data class Person(name: String, age: Int)
+
+fixture.checkAll { person1: Person, person2: Person ->
+   person1 shouldNotBeSameInstanceAs person2
+}
+----
diff --git a/fixture-kotest/README.md b/fixture-kotest/README.md
deleted file mode 100644
index b4dd7359..00000000
--- a/fixture-kotest/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# fixture-kotest module
-
-This module provides integration with
-[Kotest](https://github.com/kotest/kotest/), see the main
-[readme](../README.md#kotest-support) for further details.
diff --git a/fixture-kotest/build.gradle.kts b/fixture-kotest/build.gradle.kts
index 69df786a..13f85b4d 100644
--- a/fixture-kotest/build.gradle.kts
+++ b/fixture-kotest/build.gradle.kts
@@ -41,8 +41,8 @@ dependencies {
 lintOptions {
     isAbortOnError = true
     isWarningsAsErrors = true
-    htmlOutput = file("${buildDir}/reports/lint-results.html")
-    xmlOutput = file("${buildDir}/reports/lint-results.xml")
+    htmlOutput = file("$buildDir/reports/lint-results.html")
+    xmlOutput = file("$buildDir/reports/lint-results.xml")
 }
 
 java {
diff --git a/fixture/README.adoc b/fixture/README.adoc
new file mode 100644
index 00000000..8afa334d
--- /dev/null
+++ b/fixture/README.adoc
@@ -0,0 +1,4 @@
+== fixture module
+
+This module provides the main implementation of KotlinFixture, see the
+main link:../README.md[readme] for further details.
diff --git a/fixture/README.md b/fixture/README.md
deleted file mode 100644
index bc7ee436..00000000
--- a/fixture/README.md
+++ /dev/null
@@ -1,4 +0,0 @@
-# fixture module
-
-This module provides the main implementation of Kotlin-Fixture,
-see the main [readme](../README.md) for further details.
diff --git a/fixture/comparison.adoc b/fixture/comparison.adoc
new file mode 100644
index 00000000..7f8f5849
--- /dev/null
+++ b/fixture/comparison.adoc
@@ -0,0 +1,52 @@
+= Comparison with related projects
+:toc: preamble
+ifdef::env-github[]
+:tip-caption: :bulb:
+:note-caption: :information_source:
+:important-caption: :heavy_exclamation_mark:
+:caution-caption: :fire:
+:warning-caption: :warning:
+endif::[]
+:link-easyrandom: Jeasy's https://github.com/j-easy/easy-random[Easy Random]
+:link-flextrade: FlexTrade's https://github.com/FlexTradeUKLtd/kfixture[KFixture]
+:link-appmattus: https://github.com/appmattus/kotlinfixture[KotlinFixture]
+:link-marcellogalhardo: Marcello Galhardo's https://github.com/marcellogalhardo/kotlin-fixture[Kotlin.Fixture]
+
+Before writing {link-appmattus}, we originally looked to extend
+{link-flextrade}, however, as the core project is Java based we struggled with
+the type system, and so we started work on {link-appmattus}.
+
+Being Java based means {link-easyrandom} and {link-flextrade} will never be
+able to understand Kotlin's https://kotlinlang.org/docs/reference/null-safety.html#nullable-types-and-non-null-types[nullable types].
+Currently {link-marcellogalhardo}, which is Kotlin based, doesn't support
+nullable types either, although this functionality could be added.
+
+Unlike {link-appmattus}, the other libraries have no understanding of Kotlin's
+https://kotlinlang.org/docs/reference/functions.html#default-arguments[default values]
+which can mean missing an important test scenario.
+
+Only {link-appmattus} has built-in support for abstract classes. Kotlin's https://kotlinlang.org/docs/reference/sealed-classes.html[sealed classes]
+are abstract so not supported, with only {link-marcellogalhardo} supporting
+sealed classes but not abstract classes.
+
+For ease of use, a fixture library needs good support for built-in types to
+reduce the amount of customisation required, whether that is types such as
+Kotlin's `https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-pair/[Pair]`,
+Java types such as `Currency` and `Locale` or even Java 8s time types. The user
+should expect them to seamlessly work with no additional configuration.
+
+Needless to say all software has bugs, we have tried hard to ensure we create
+core types as expected, and hopefully have enough tests to back that up.
+However, when comparing our library to our competitors we did find
+various unsupported types, not random, or generated invalid types. For example:
+
+- {link-flextrade} does not support `Pair`, `Triple`, `Currency` or `Locale`.
+- `HashMap` is not random in any of the competitors.
+- `SortedSet` and `SortedMap` generate invalid objects in {link-flextrade}.
+- Various `List` types either generate invalid objects or aren't random in {link-easyrandom}.
+- {link-marcellogalhardo} doesn't support primitive arrays such as `ByteArray` and `IntArray`.
+
+Our comprehensive link:src/test/kotlin/com/appmattus/kotlinfixture/ComparisonTest.kt[ComparisonTest]
+contains more details.
+
+If you find any bugs or have any feature requests for more built-in types please create an https://github.com/appmattus/kotlinfixture/issues[issue].
diff --git a/fixture/configuration-options.adoc b/fixture/configuration-options.adoc
new file mode 100644
index 00000000..aac91962
--- /dev/null
+++ b/fixture/configuration-options.adoc
@@ -0,0 +1,410 @@
+= Configuration options
+:toc: preamble
+:toc-title: Options
+ifdef::env-github[]
+:tip-caption: :bulb:
+:note-caption: :information_source:
+:important-caption: :heavy_exclamation_mark:
+:caution-caption: :fire:
+:warning-caption: :warning:
+endif::[]
+
+All the configuration options available in KotlinFixture can be set when
+creating the fixture object as well as when creating a particular
+implementation.
+
+You can also create a new fixture based on an existing one, which allows
+changes to the configuration.
+
+[source,kotlin]
+----
+val baseFixture = kotlinFixture {
+    factory<Int> { 3 } // <1>
+}
+
+val fixture = baseFixture.new {
+    factory<Long> { 100L } // <2>
+}
+
+println(fixture<Long>()) // Prints 100
+println(fixture<Int>()) // Prints 3
+println(fixture<Int> {
+    factory<Int> { 4 } // <3>
+}) // Prints 4
+----
+<1> Configuration when creating the fixture object.
+<2> Create a new fixture based on an existing one, allowing overriding configuration.
+<3> Configuration can also be overridden when creating a particular object.
+
+== Setting list and map length with `repeatCount`
+
+Used to determine the length used for lists and maps. By default, the library generates 5 items.
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    repeatCount { 3 }
+}
+
+val listOfThreeItems = fixture<List<Int>>() // 10, 81, 3
+----
+
+`repeatCount` is a factory method so can be used to return lists and maps of
+different lengths each execution:
+
+[source,kotlin]
+----
+repeatCount {
+    random.nextInt(1, 5)
+}
+----
+
+== Resolving abstract superclasses to a chosen subclass with `subType`
+
+Used to always return an instance of a particular subclass for a superclass.
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    subType<Number, Int>()
+}
+
+val alwaysInt = fixture<Number>()
+----
+
+== Customising class generation with `factory`
+
+Used to return the given instance for a particular class using a factory
+method.
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    factory<Number> {
+        41
+    }
+}
+
+val alwaysFortyOne = fixture<Number>()
+----
+
+As `factory` is a factory method you can return different values on every
+execution:
+
+[source,kotlin]
+----
+factory<Number> {
+    random.nextInt(10, 50)
+}
+----
+
+=== Generating values in a `range`
+
+`factory` has a built-in `range` function to make it easy to generate values
+in a range.
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    // Generate using ranges (and iterables)
+    factory<Int> { range(1..10) }
+}
+
+val betweenOneAndTen = fixture<Int>()
+----
+
+=== Generating `Date` and `Calendar` values
+
+By default, `Date` and `Calendar` instances pick a date within 10 years of
+1 Jan 2020.
+
+This can be overridden using the built-in constructs `between`, `before` and
+`after` in your `factory` definition:
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    // Generate between two dates
+    factory<Date> { between(startDate, endDate) }
+}
+
+val betweenTwoDates = fixture<Date>()
+----
+
+== Customising generation of class properties with `property`
+
+Used to override constructor parameters or mutable properties when generating
+instances of generic classes.
+
+._Kotlin class example_
+[%collapsible%open]
+====
+
+Given the following Kotlin class:
+
+[source,kotlin]
+----
+class KotlinClass(val readOnly: String, private var private: String) {
+    var member: String? = null
+}
+----
+
+We can override creating an instance of `KotlinClass` as follows:
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    // Public constructor parameters overridden by reference:
+    property(KotlinClass::readOnly) { "a" }
+
+    // Private constructor parameters are overridden by name:
+    property<KotlinClass, String>("private") { "b" }
+
+    // Public member properties overridden by reference:
+    property(KotlinClass::member) { "c" }
+}
+----
+====
+
+._Java class example_
+[%collapsible]
+====
+Given the following Java class:
+
+[source,java]
+----
+public class JavaClass {
+    private final String constructor;
+    private String mutable;
+
+    public JavaClass(String constructor) { this.constructor = constructor; }
+
+    public void setMutable(String mutable) { this.mutable = mutable; }
+}
+----
+
+We can override creating an instance of `JavaClass` as follows:
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    // Setter overridden by reference:
+    property<String>(JavaClass::setMutable) { "d" }
+
+    // Constructor parameters don't typically retain names and so are
+    // overridden by a positional 'arg' names:
+    property<JavaClass, String>("arg0") { "e" }
+}
+----
+====
+
+== Filtering generated values with `filter`
+
+Used to allow generated values to be filtered using standard sequence
+functions.
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    filter<Int> {
+        filter { it % 2 == 0 }
+    }
+
+    // Can be used to return distinct values.
+    filter<String> {
+        distinct()
+    }
+}
+
+val evenNumber = fixture<Int>()
+
+val evenNumberLessThan100 = fixture<Int> {
+    // Builds upon the parent configuration
+    filter<Int> {
+        filter { it < 100 }
+    }
+}
+----
+
+WARNING: As the sequence is infinite, distinct will hang if no more distinct values can be generated.
+
+== Providing a seeded `random`
+
+By default, we generate unique values between runs using a default `Random`
+class. If you want repeatability you can specify a seeded `Random` instance.
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    random = Random(seed = 10)
+}
+
+val alwaysTheSame = fixture<Int>()
+----
+
+NOTE: While you can specify `random` at object creation, this will make the result static
+i.e. `fixture<Int> { random = Random(seed = 5) }` will always return the same value.
+
+== Overriding nullability with `nullabilityStrategy`
+
+By default, when the library comes across a nullable type, such as `String?` it
+will randomly return a value or null. This can be overridden by setting a
+nullability strategy.
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    // All nullable types will be populated with a value
+    nullabilityStrategy(NeverNullStrategy)
+}
+----
+
+._Available strategies_
+[%collapsible]
+====
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/nullability/NeverNullStrategy.kt[NeverNullStrategy]`::
+populate nullable values with a non-null value.
+
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/nullability/AlwaysNullStrategy.kt[AlwaysNullStrategy]`::
+populate nullable values with `null`.
+
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/nullability/RandomlyNullStrategy.kt[RandomlyNullStrategy]`::
+populate nullable values randomly with `null`.
+====
+
+It is also possible to define and implement your own nullability strategy by
+implementing `link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/nullability/NullabilityStrategy.kt[NullabilityStrategy]`
+and applying it as above.
+
+== Overriding the use of default values with `optionalStrategy`
+
+By default, when the library comes across an optional type, such as
+`value: String = &quot;default&quot;` it will randomly return the default value,
+or a generated value. This can be overridden by setting an optional
+strategy.
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    // All optionals will be populated with their default value
+    optionalStrategy(AlwaysOptionalStrategy) {
+        // You can override the strategy for a particular class
+        classOverride<AnotherObject>(NeverOptionalStrategy)
+
+        // You can override the strategy for a property of a class
+        propertyOverride(AnotherObject::property, RandomlyOptionalStrategy)
+    }
+}
+----
+
+._Available strategies_
+[%collapsible]
+====
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/optional/AlwaysOptionalStrategy.kt[AlwaysOptionalStrategy]`::
+always use the properties the default value.
+
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/optional/NeverOptionalStrategy.kt[NeverOptionalStrategy]`::
+never use the properties the default value.
+
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/optional/RandomlyOptionalStrategy.kt[RandomlyOptionalStrategy]`::
+randomly use the properties the default value.
+====
+
+It is also possible to define and implement your own optional strategy by
+implementing `link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/optional/OptionalStrategy.kt[OptionalStrategy]`
+and applying it as above.
+
+== Changing how recursion behaves with `recursionStrategy`
+
+When the library detects recursion, by default, it will throw an
+`UnsupportedOperationException` with the details of the circular reference. This
+strategy can be changed to instead return `null` for the reference, however, if
+this results in an invalid object an exception will still be thrown as the
+object requested couldn't be resolved.
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    recursionStrategy(NullRecursionStrategy)
+}
+----
+
+._Available strategies_
+[%collapsible]
+====
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/recursion/NullRecursionStrategy.kt[NullRecursionStrategy]`::
+use `null` for circular references.
+
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/recursion/ThrowingRecursionStrategy.kt[ThrowingRecursionStrategy]`::
+throw an exception when finding circular references.
+
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/recursion/UnresolvedRecursionStrategy.kt[UnresolvedRecursionStrategy]`::
+use `Unresolved` for circular references, which may result in generation of a
+valid object as other scenarios will be tried
+====
+
+It is also possible to define and implement your own recursion strategy by
+implementing `link:../fixture/src/main/kotlin/com/appmattus/kotlinfixture/decorator/recursion/RecursionStrategy.kt[RecursionStrategy]` and applying it as above.
+
+== Logging object generation with `loggingStrategy`
+
+A basic logger can be applied using the built in `link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/logging/SysOutLoggingStrategy.kt[SysOutLoggingStrategy]`.
+It is also possible to define and implement your own logging strategy by
+implementing `link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/logging/LoggingStrategy.kt[LoggingStrategy]`
+and applying it as below.
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    loggingStrategy(SysOutLoggingStrategy)
+}
+----
+
+The logger for `fixture<String>()` outputs:
+
+[source,text]
+----
+ktype kotlin.String →
+    class kotlin.String →
+        Success(5878ec34-c30f-40c7-ad52-c15a39b44ac1)
+    Success(5878ec34-c30f-40c7-ad52-c15a39b44ac1)
+----
+
+== Choosing the constructor to generate an object with `constructorStrategy`
+
+By default, when the library generates an instance of a class it picks a
+constructor at random. This can be overridden by setting a constructor
+strategy.
+
+[source,kotlin]
+----
+val fixture = kotlinFixture {
+    constructorStrategy(ModestConstructorStrategy)
+}
+----
+
+._Available strategies_
+[%collapsible]
+====
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/constructor/RandomConstructorStrategy.kt[RandomConstructorStrategy]`::
+order constructors by random.
+
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/constructor/ModestConstructorStrategy.kt[ModestConstructorStrategy]`::
+order constructors by the most modest constructor first. i.e. fewer
+parameters returned first.
+
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/constructor/GreedyConstructorStrategy.kt[GreedyConstructorStrategy]`::
+order constructors by the most greedy constructor first. i.e. greater
+parameters returned first.
+
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/constructor/ArrayFavouringConstructorStrategy.kt[ArrayFavouringConstructorStrategy]`::
+order constructors selecting those with the most parameters of
+`Array<*>` before any other.
+
+`link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/constructor/ListFavouringConstructorStrategy.kt[ListFavouringConstructorStrategy]`::
+order constructors selecting those with the most parameters of `List<*>`
+before any other.
+====
+
+It is also possible to define and implement your own constructor
+strategy by implementing `link:src/main/kotlin/com/appmattus/kotlinfixture/decorator/constructor/ConstructorStrategy.kt[ConstructorStrategy]` and applying it as above.
diff --git a/fixture/src/main/kotlin/com/appmattus/kotlinfixture/Unresolved.kt b/fixture/src/main/kotlin/com/appmattus/kotlinfixture/Unresolved.kt
index 5753f48e..472f3941 100644
--- a/fixture/src/main/kotlin/com/appmattus/kotlinfixture/Unresolved.kt
+++ b/fixture/src/main/kotlin/com/appmattus/kotlinfixture/Unresolved.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Appmattus Limited
+ * Copyright 2020 Appmattus Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -65,6 +65,7 @@ sealed class Unresolved {
                 writer.write(stackTrace.prependIndent("    ".repeat(depth + 1)))
                 writer.write("\n")
             }
+            Unhandled -> Unit
         }
     }
 }
diff --git a/fixture/src/main/kotlin/com/appmattus/kotlinfixture/decorator/logging/SysOutLoggingStrategy.kt b/fixture/src/main/kotlin/com/appmattus/kotlinfixture/decorator/logging/SysOutLoggingStrategy.kt
index a49f4fd1..d6f50f7b 100644
--- a/fixture/src/main/kotlin/com/appmattus/kotlinfixture/decorator/logging/SysOutLoggingStrategy.kt
+++ b/fixture/src/main/kotlin/com/appmattus/kotlinfixture/decorator/logging/SysOutLoggingStrategy.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Appmattus Limited
+ * Copyright 2020 Appmattus Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,7 +28,7 @@ object SysOutLoggingStrategy : LoggingStrategy {
         val indent = "    ".repeat(stack.size - 1)
 
         val prefix = when (obj) {
-            is KType -> "ktype "
+            is KType -> @Suppress("SpellCheckingInspection") "ktype "
             else -> ""
         }
         println("$indent$prefix$obj → ")
diff --git a/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/PopulateInstance.kt b/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/PopulateInstance.kt
index 6ffd5770..368a2f3d 100644
--- a/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/PopulateInstance.kt
+++ b/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/PopulateInstance.kt
@@ -18,6 +18,7 @@ package com.appmattus.kotlinfixture.resolver
 
 import com.appmattus.kotlinfixture.Context
 import com.appmattus.kotlinfixture.Unresolved
+import java.util.Locale
 import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
 import kotlin.reflect.KMutableProperty
@@ -54,7 +55,8 @@ internal interface PopulateInstance {
         callContext.obj.memberFunctions.filter {
             it.name.startsWith("set") && it.valueParameters.size == 1
         }.filterNot {
-            val name = it.name.removePrefix("set").decapitalize()
+            @Suppress("EXPERIMENTAL_API_USAGE_ERROR")
+            val name = it.name.removePrefix("set").decapitalize(Locale.getDefault())
             callContext.constructorParameterNames.contains(name)
         }.forEach {
             val propertyResult = callContext.context.resolve(
diff --git a/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/ThreeTenResolver.kt b/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/ThreeTenResolver.kt
index a732d457..017c06c1 100644
--- a/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/ThreeTenResolver.kt
+++ b/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/ThreeTenResolver.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Appmattus Limited
+ * Copyright 2020 Appmattus Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -98,6 +98,7 @@ internal class ThreeTenResolver : Resolver {
         generatePreciseChronoUnit()
     )
 
+    @Suppress("SpellCheckingInspection")
     private fun Context.generatePreciseChronoUnit() = listOf(
         ChronoUnit.NANOS,
         ChronoUnit.MICROS,
@@ -112,6 +113,7 @@ internal class ThreeTenResolver : Resolver {
     companion object {
         private val hasThreeTen: Boolean by lazy {
             try {
+                @Suppress("SpellCheckingInspection")
                 Class.forName("org.threeten.bp.LocalDate", false, ThreeTenResolver::class.java.classLoader)
                 true
             } catch (expected: ClassNotFoundException) {
diff --git a/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/TimeResolver.kt b/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/TimeResolver.kt
index c532c19c..78e4e826 100644
--- a/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/TimeResolver.kt
+++ b/fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/TimeResolver.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Appmattus Limited
+ * Copyright 2020 Appmattus Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,7 @@
 
 package com.appmattus.kotlinfixture.resolver
 
+import android.annotation.SuppressLint
 import com.appmattus.kotlinfixture.Context
 import com.appmattus.kotlinfixture.Unresolved
 import com.appmattus.kotlinfixture.typeOf
@@ -39,6 +40,7 @@ import java.util.Date
 import java.util.TimeZone
 
 @Suppress("TooManyFunctions")
+@SuppressLint("NewApi")
 internal class TimeResolver : Resolver {
 
     @Suppress("ComplexMethod")
@@ -97,6 +99,7 @@ internal class TimeResolver : Resolver {
         generatePreciseChronoUnit()
     )
 
+    @Suppress("SpellCheckingInspection")
     private fun Context.generatePreciseChronoUnit() = listOf(
         ChronoUnit.NANOS,
         ChronoUnit.MICROS,
diff --git a/fixture/src/test/kotlin/com/appmattus/kotlinfixture/ComparisonTest.kt b/fixture/src/test/kotlin/com/appmattus/kotlinfixture/ComparisonTest.kt
index 26acf4f6..ad6a4699 100644
--- a/fixture/src/test/kotlin/com/appmattus/kotlinfixture/ComparisonTest.kt
+++ b/fixture/src/test/kotlin/com/appmattus/kotlinfixture/ComparisonTest.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Appmattus Limited
+ * Copyright 2020 Appmattus Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -114,6 +114,7 @@ class ComparisonTest {
         private val marcellogalhardo = Fixture()
         private val flextrade = KFixture()
         private val appmattus = kotlinFixture()
+        private val easyRandom = EasyRandom()
 
         private val nullableType = typeOf<String?>()
 
@@ -143,6 +144,15 @@ class ComparisonTest {
                 result == null
             }
         }
+
+        @Test
+        fun `easyrandom nullability unsupported`() {
+            assertNone {
+                val result = easyRandom.nextObject((nullableType.classifier as KClass<*>).java)
+
+                result == null
+            }
+        }
     }
 
     @RunWith(Parameterized::class)
diff --git a/fixture/src/test/kotlin/com/appmattus/kotlinfixture/decorator/filter/FilterDecoratorTest.kt b/fixture/src/test/kotlin/com/appmattus/kotlinfixture/decorator/filter/FilterDecoratorTest.kt
index 0808c0ef..339039bc 100644
--- a/fixture/src/test/kotlin/com/appmattus/kotlinfixture/decorator/filter/FilterDecoratorTest.kt
+++ b/fixture/src/test/kotlin/com/appmattus/kotlinfixture/decorator/filter/FilterDecoratorTest.kt
@@ -47,7 +47,7 @@ class FilterDecoratorTest {
     private val context = TestContext(config, resolver)
 
     @Test
-    fun `not ktype calls original resolver`() {
+    fun `not KType calls original resolver`() {
         val decoratedResolver = FilterDecorator().decorate(resolver)
         decoratedResolver.resolve(context, Float::class)
 
diff --git a/fixture/src/test/kotlin/com/appmattus/kotlinfixture/decorator/recursion/RecursionDecoratorTest.kt b/fixture/src/test/kotlin/com/appmattus/kotlinfixture/decorator/recursion/RecursionDecoratorTest.kt
index ad330aee..515f350c 100644
--- a/fixture/src/test/kotlin/com/appmattus/kotlinfixture/decorator/recursion/RecursionDecoratorTest.kt
+++ b/fixture/src/test/kotlin/com/appmattus/kotlinfixture/decorator/recursion/RecursionDecoratorTest.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Appmattus Limited
+ * Copyright 2020 Appmattus Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -37,7 +37,7 @@ class RecursionDecoratorTest {
     }.build()
 
     @Test
-    fun `calls resolver when same ktype recursively requested again`() {
+    fun `calls resolver when same KType recursively requested again`() {
         val resolver = TestResolver(listOf(typeOf<Int>(), typeOf<Float>()))
 
         val decoratedResolver = RecursionDecorator().decorate(resolver)
@@ -47,7 +47,7 @@ class RecursionDecoratorTest {
     }
 
     @Test
-    fun `does not call resolver when all different ktypes recursively requested`() {
+    fun `does not call resolver when all different KTypes recursively requested`() {
         val resolver = TestResolver(listOf(typeOf<Int>(), typeOf<Double>(), typeOf<Short>()))
 
         val decoratedResolver = RecursionDecorator().decorate(resolver)
diff --git a/settings.gradle.kts b/settings.gradle.kts
index b6c7612c..4a60a274 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -18,5 +18,6 @@ include(
     "fixture",
     "fixture-javafaker",
     "fixture-kotest",
+    "fixture-generex",
     "fixture-android-tests"
 )