Improve fuzzer with better annotation processing and related issues

[EgorkaKulikov]

Description

Consider we need to fuzz the instance of the following class representing entity https://github.com/spring-projects/spring-petclinic/blob/main/src/main/java/org/springframework/samples/petclinic/owner/Owner.java

We need to save it to database in our tests later, so we would like to obtain at least one instance that follows all restrictions from annotations. It seems to be impossible with the current implementation of our fuzzer.

The restrictions have the following form:

@NotEmpty
@Digits(fraction = 0, integer = 10)
private String telephone;

Expected behaviour

1. We need to be able to process an instance that satisfies all annotated restrictions

2. We suggest to construct an entity that satisfies restrictions on the construction phase and start mutating it only after that.

---

4. It is also suggested to allow to create a fuzzed instance without any mutations - it may be useful to increase the coverage.

[IlyaMuravjov]

In case of spring-petclinic, including something like exception.stackTraceToString().length / 5 in fuzzer feedback seems to be enough to get entities that pass validation. The division by 5 is added to stop exceptions that only differ in some numbers from producing too many unique feedbacks.

[alisevych]

Questions to discuss:

1. Do we need to support annotations for fields one by one? Let's list most common annotations.
2. Do these restrictions relate only to primitive types? Can Object have any restrictions?
3. Can we make some common interface to add restrictions for values?

[IlyaMuravjov]

Here's a test checking if fuzzing platform is able to generate values with no mutations, right now it fails.

@Test
fun `fuzzer can generate value without mutations`() {
    runBlocking {
            var seenEmpty = false
            withTimeout(1000) {
                runFuzzing(
                    { _, _ -> sequenceOf(Seed.Recursive<Unit, StringBuilder>(
                        construct = Routine.Create(emptyList()) { StringBuilder("") },
                        modify = sequenceOf(Routine.Call(emptyList()) { s, _ -> s.append("1") }),
                        empty = Routine.Empty { fail("Empty is called despite construct requiring no args") }
                    )) },
                    Description(listOf(Unit))
                ) { _, (s) ->
                    if (s.isEmpty()) {
                        seenEmpty = true
                        BaseFeedback(Unit, Control.STOP)
                    } else BaseFeedback(Unit, Control.CONTINUE)
                }
            }
            Assertions.assertTrue(seenEmpty) { "Unmodified empty string wasn't generated" }
    }
}

[alisevych]

@IlyaMuravjov As discussed with @Markoutte - It's a bug