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)

val baseFixture = kotlinFixture {
    factory<Int> { 3 } // fixture 생성
}

val fixture = baseFixture.new {
    factory<Long> { 100L } // baseFixture의 설정을 orverriding할 수 있다.
}

println(fixture<Long>()) // Prints 100
println(fixture<Int>()) // Prints 3
println(fixture<Int> {
    factory<Int> { 4 } // (3)
}) // Prints 4

val fixture = kotlinFixture {
    repeatCount { 3 }
}

val listOfThreeItems = fixture<List<Int>>() // 10, 81, 3

class KotlinClass(val readOnly: List<String>, private var private: List<String>) {
    var member: List<String>? = null
}

val fixture = kotlinFixture {
    // Public constructor parameters overridden by reference:
    repeatCount(KotlinClass::readOnly) { 1 }

    // Private constructor parameters are overridden by name:
    repeatCount<KotlinClass>("private") { 2 }

    // Public member properties overridden by reference:
    repeatCount(KotlinClass::member) { 3 }
}

val fixture = kotlinFixture {
    subType<Number, Int>()
}

val alwaysInt = fixture<Number>()

val fixture = kotlinFixture {
    factory<Number> {
        41
    }
}

val alwaysFortyOne = fixture<Number>()

// 범위 내에서 생성할 수 있다.
factory<Number> {
    random.nextInt(10, 50)
}

// range를 사용하여 범위 내에서 생성할 수 있다.
val fixture = kotlinFixture {
    // Generate using ranges (and iterables)
    factory<Int> { range(1..10) }
}

val betweenOneAndTen = fixture<Int>()

class KotlinClass(val readOnly: String, private var private: String) {
    var member: String? = null
}

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" }
}

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 }
    }
}

val fixture = kotlinFixture {
    // All nullable types will be populated with a value
    nullabilityStrategy(NeverNullStrategy)
}

value: String = "default"

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)
    }
}

val fixture = kotlinFixture {
    recursionStrategy(NullRecursionStrategy)
}

val fixture = kotlinFixture {
    constructorStrategy(ModestConstructorStrategy)
}