Overload randomSublist and randomSubset with sizeRange parameter

Author: serpro69

core/src/integration/kotlin/io/github/serpro69/kfaker/docs/Extras.kt

@@ -213,13 +213,15 @@ class Extras : DescribeSpec({
             // START extras_random_everything_six
             val list = List(100) { it }
             faker.random.randomSublist(list, size = 10, shuffled = true)
+            faker.random.randomSublist(list, sizeRange = 6..42, shuffled = true)
             // END extras_random_everything_six
         }
 
         it("should generate random subset") {
             // START extras_random_everything_seven
             val set = setOf(*List(100) { it }.toTypedArray())
             faker.random.randomSubset(set, size = 10, shuffled = true)
+            faker.random.randomSubset(set, sizeRange = 66..99, shuffled = true)
             // END extras_random_everything_seven
         }
 

core/src/main/kotlin/io/github/serpro69/kfaker/RandomService.kt

@@ -285,10 +285,26 @@ class RandomService internal constructor(private val config: FakerConfig) {
             .subList(from, to)
     }
 
+    /**
+     * Returns a view of the portion of the [list]
+     * with pseudo-randomly generated `fromIndex` and (possibly) `toIndex` values.
+     *
+     * @param sizeRange the desired size range of the resulting list.
+     * The `size` of the returned list is the result of calling [nextInt] with the [sizeRange].
+     * IF `size <= 0` then `toIndex` will also be randomly-generated.
+     * @param shuffled if `true` the [list] will be shuffled before extracting the sublist
+     */
+    @JvmOverloads
+    fun <T> randomSublist(list: List<T>, sizeRange: IntRange, shuffled: Boolean = false): List<T> {
+        return randomSublist(list, nextInt(sizeRange), shuffled)
+    }
+
     /**
      * Returns a portion of the [set]
-     * with pseudo-randomly generated `fromIndex` and `toIndex` values.
+     * with pseudo-randomly generated `fromIndex` and (possibly) `toIndex` values.
      *
+     * @param size the desired size of the resulting set.
+     * If `size <= 0` then `toIndex` will also be randomly-generated.
      * @param shuffled if `true` the [set] will be shuffled before extracting the subset
      */
     @JvmOverloads
@@ -300,6 +316,19 @@ class RandomService internal constructor(private val config: FakerConfig) {
             .toSet()
     }
 
+    /**
+     * Returns a portion of the [set]
+     * with pseudo-randomly generated `fromIndex` and (possibly) `toIndex` values.
+     *
+     * @param sizeRange the desired size range of the resulting list.
+     * The `size` of the returned list is the result of calling [nextInt] with the [sizeRange].
+     * IF `size <= 0` then `toIndex` will also be randomly-generated.
+     * @param shuffled if `true` the [set] will be shuffled before extracting the subset
+     */
+    fun <T> randomSubset(set: Set<T>, sizeRange: IntRange, shuffled: Boolean = false): Set<T> {
+        return randomSubset(set, nextInt(sizeRange), shuffled)
+    }
+
     private fun <T> Collection<T>.randomFromToIndices(s: Int): Pair<Int, Int> {
         val fromIndex = if (s > 0) {
             (0..size - s).random(random.asKotlinRandom())

core/src/test/kotlin/io/github/serpro69/kfaker/RandomServiceTest.kt

@@ -9,6 +9,7 @@ import io.kotest.matchers.collections.shouldContain
 import io.kotest.matchers.collections.shouldContainAll
 import io.kotest.matchers.collections.shouldHaveSize
 import io.kotest.matchers.collections.shouldNotBeSortedWith
+import io.kotest.matchers.ints.shouldBeInRange
 import io.kotest.matchers.should
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
@@ -246,10 +247,19 @@ internal class RandomServiceTest : DescribeSpec({
                         if (sublist.isNotEmpty()) sublist shouldBeSortedWith Comparator { o1, o2 -> o1.compareTo(o2) }
                     }
                 }
+
+                it("should return a random sublist of a size withing a given range run#$it") {
+                    val sublist = randomService.randomSublist(list, sizeRange = 12..42)
+                    assertSoftly {
+                        list shouldContainAll sublist
+                        sublist.size shouldBeInRange 12..42
+                        if (sublist.isNotEmpty()) sublist shouldBeSortedWith Comparator { o1, o2 -> o1.compareTo(o2) }
+                    }
+                }
             }
 
             it("should return a random shuffled sublist") {
-                val sublist = randomService.randomSublist(list, shuffled = true)
+                val sublist = randomService.randomSublist(list, size = 10, shuffled = true)
                 assertSoftly {
                     list shouldContainAll sublist
                     if (sublist.isNotEmpty()) sublist shouldNotBeSortedWith Comparator { o1, o2 -> o1.compareTo(o2) }
@@ -277,6 +287,14 @@ internal class RandomServiceTest : DescribeSpec({
                         if (subset.isNotEmpty()) subset shouldBeSortedWith Comparator { o1, o2 -> o1.compareTo(o2) }
                     }
                 }
+                it("should return a random subset of a size witing a given range run#$it") {
+                    val subset = randomService.randomSubset(set, sizeRange = 10..20)
+                    assertSoftly {
+                        set shouldContainAll subset
+                        subset.size shouldBeInRange 10..20
+                        if (subset.isNotEmpty()) subset shouldBeSortedWith Comparator { o1, o2 -> o1.compareTo(o2) }
+                    }
+                }
             }
 
             it("should return a random shuffled subset") {