Pelevin/improve java fuzzing type system

[Markoutte]

Description

Adds implementation for Iterator<*> type and improve type system to support recursive or dependent types like:

public static  <T extends Iterator<T>> int size(T some)

Type of Change

Breaking change (fix or feature that would cause existing functionality to not work as expected)

How Has This Been Tested?

Automated Testing

org.utbot.fuzzing.JavaFuzzingTest

Manual Scenario

Try to generate tests with only fuzzing for these functions:

public static  <T extends Iterator<T>> int size(T some) {
        int r = 0;
        while (some.hasNext()) {
            T next = some.next();
            while (next != null && next.hasNext()) {
                T n2 = next.next();
                while (n2 != null && n2.hasNext()) {
                    n2.next();
                    r++;
                }
                r++;
            }
            r++;
        }
        return r;
    }

public class ManyRecursiveCalls<T extends Map<String, Number>> {

    private final T[] value;


    public ManyRecursiveCalls(T[] value) {
        this.value = value;
    }

    public double getSum() {
        double sum = 0;
        for (T numbers : value) {
            for (Number number : numbers.values()) {
                if (number.doubleValue() > 0) {
                    sum += number.doubleValue();
                }
            }
        }
        if (sum == 0.0) {
            throw new IllegalStateException();
        }
        return sum;
    }
}

Checklist (remove irrelevant options):

This is the author self-check list

• The change followed the style guidelines of the UTBot project
• Self-review of the code is passed
• The change contains enough commentaries, particularly in hard-to-understand areas
• New documentation is provided or existed one is altered
• No new warnings
• New tests have been added
• All tests pass locally with my changes

[volivan239]

For third type parameter of the method below, toFuzzerType returns a finite type (see image below). Is this the expected behavior?

public static <A extends Iterable<B>, B extends List<A>, C extends List<? extends Iterable<A>>> A example(A c1, B c2, C c) {
    return c2.iterator().next();
}

[volivan239]

The name of the method is misleading, I think it should be something like Type.replaceWithUpperBoundUntilNotTypeVariable, also docs would be great here

[Markoutte]

Thx for the example! No, this is not expected, fixed