Java: Change test implementation to avoid failing CFG dead end consistency test.

michaelnebel · michaelnebel · commit 5b65f5c185db · 2022-11-10T13:57:43.000+01:00
diff --git a/java/ql/test/utils/model-generator/typebasedflow/p/Stream.java b/java/ql/test/utils/model-generator/typebasedflow/p/Stream.java
@@ -11,154 +11,152 @@ public Iterator<T> iterator() {
     }
 
     public boolean allMatch(Predicate<? super T> predicate) {
-        throw null;
+        return false;
     }
 
     public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
-        throw null;
+        return null;
     }
 
     // Collector is not a functional interface, so this is not supported
     public <R, A> R collect(Collector<? super T, A, R> collector) {
-        throw null;
+        return null;
     }
 
     public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
-        throw null;
+        return null;
     }
 
     public Stream<T> distinct() {
-        throw null;
+        return null;
     }
 
     public static <T> Stream<T> empty() {
-        throw null;
+        return null;
     }
 
     public Stream<T> filter(Predicate<? super T> predicate) {
-        throw null;
+        return null;
     }
 
     public Optional<T> findAny() {
-        throw null;
+        return null;
     }
 
     public Optional<T> findFirst() {
-        throw null;
+        return null;
     }
 
     // public <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends
     // R>> mapper) {
-    // throw null;
+    // return null;
     // }
 
     public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
-        throw null;
+        return null;
     }
 
     public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
-        throw null;
+        return null;
     }
 
     public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
-        throw null;
+        return null;
     }
 
     public void forEach(Consumer<? super T> action) {
-        throw null;
     }
 
     public void forEachOrdered(Consumer<? super T> action) {
-        throw null;
     }
 
     public static <T> Stream<T> generate(Supplier<T> s) {
-        throw null;
+        return null;
     }
 
     // Model generator adds a couple of extra models, which can't be
     // dismissed based on the type information.
     public static <T> Stream<T> iterate(T seed, UnaryOperator<T> f) {
-        throw null;
+        return null;
     }
 
     public Stream<T> limit(long maxSize) {
-        throw null;
+        return null;
     }
 
     public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
-        throw null;
+        return null;
     }
 
     public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
-        throw null;
+        return null;
     }
 
     public IntStream mapToInt(ToIntFunction<? super T> mapper) {
-        throw null;
+        return null;
     }
 
     public LongStream mapToLong(ToLongFunction<? super T> mapper) {
-        throw null;
+        return null;
     }
 
     public Optional<T> max(Comparator<? super T> comparator) {
-        throw null;
+        return null;
     }
 
     public Optional<T> min(Comparator<? super T> comparator) {
-        throw null;
+        return null;
     }
 
     public boolean noneMatch(Predicate<? super T> predicate) {
-        throw null;
+        return false;
     }
 
     // Issue with model generator. ... is not supported.
     // public static <T> Stream<T> of(T... t) {
-    // throw null;
+    // return null;
     // }
 
     public static <T> Stream<T> of(T t) {
-        throw null;
+        return null;
     }
 
     public Stream<T> peek(Consumer<? super T> action) {
-        throw null;
+        return null;
     }
 
     // Model generator yields a couple of extra results as models are generated for
     // writing to the stream.
     public Optional<T> reduce(BinaryOperator<T> accumulator) {
-        throw null;
+        return null;
     }
 
     // Model generator yields a couple of extra results as models are generated for
     // writing to the stream.
     public T reduce(T identity, BinaryOperator<T> accumulator) {
-        throw null;
+        return null;
     }
 
     public <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
-        throw null;
+        return null;
     }
 
     public Stream<T> skip(long n) {
-        throw null;
+        return null;
     }
 
     public Stream<T> sorted() {
-        throw null;
+        return null;
     }
 
     public Stream<T> sorted(Comparator<? super T> comparator) {
-        throw null;
+        return null;
     }
 
     // Models can never be generated correctly based on the type information
     // as it involves downcasting.
     public Object[] toArray() {
-        throw null;
+        return null;
     }
 
     // Issue with model generator - no models are generated.
diff --git a/java/ql/test/utils/model-generator/typebasedflow/p/TypeBasedCollection.java b/java/ql/test/utils/model-generator/typebasedflow/p/TypeBasedCollection.java
@@ -6,18 +6,16 @@
 public class TypeBasedCollection<T> extends ArrayList<T> {
 
     public void addT(T x) {
-        throw null;
     }
 
     public void addManyT(List<T> xs) {
-        throw null;
     }
 
     public T firstT() {
-        throw null;
+        return null;
     }
 
     public List<T> getManyT() {
-        throw null;
+        return null;
     }
 }
diff --git a/java/ql/test/utils/model-generator/typebasedflow/p/TypeBasedComplex.java b/java/ql/test/utils/model-generator/typebasedflow/p/TypeBasedComplex.java
@@ -6,54 +6,52 @@
 public class TypeBasedComplex<T> {
 
     public void addMany(List<T> xs) {
-        throw null;
     }
 
     public List<T> getMany() {
-        throw null;
+        return null;
     }
 
     public Integer apply(Function<T, Integer> f) {
-        throw null;
+        return null;
     }
 
     public <T1, T2> T2 apply2(T1 x, Function<T1, T2> f) {
-        throw null;
+        return null;
     }
 
     public TypeBasedComplex<T> flatMap(Function<T, List<T>> f) {
-        throw null;
+        return null;
     }
 
     public <S> TypeBasedComplex<S> flatMap2(Function<T, List<S>> f) {
-        throw null;
+        return null;
     }
 
     public <S> S map(Function<T, S> f) {
-        throw null;
+        return null;
     }
 
     public <S> TypeBasedComplex<S> mapComplex(Function<T, S> f) {
-        throw null;
+        return null;
     }
 
     public TypeBasedComplex<T> returnComplex(Function<T, TypeBasedComplex<T>> f) {
-        throw null;
+        return null;
     }
 
     public void set(Integer x, Function<Integer, T> f) {
-        throw null;
     }
 
     public Integer applyMyFunction(MyFunction<T, Integer, T> f, Integer x) {
-        throw null;
+        return null;
     }
 
     public <S1, S2> S2 applyMyFunctionGeneric(MyFunction<T, S1, S2> f, S1 x) {
-        throw null;
+        return null;
     }
 
     public <S1, S2, S3> S3 applyMyFunctionGeneric(MyFunction<S1, S2, S3> f, S1 x, S2 y) {
-        throw null;
+        return null;
     }
 }
diff --git a/java/ql/test/utils/model-generator/typebasedflow/p/TypeBasedSimple.java b/java/ql/test/utils/model-generator/typebasedflow/p/TypeBasedSimple.java
@@ -2,34 +2,30 @@
 
 public class TypeBasedSimple<T> {
     public TypeBasedSimple(T t) {
-        throw null;
     }
 
     public T get() {
-        throw null;
+        return null;
     }
 
     public T get(Object o) {
         return null;
     }
 
     public T id(T x) {
-        throw null;
+        return null;
     }
 
     public <S> S id2(S x) {
-        throw null;
+        return null;
     }
 
     public void set(T x) {
-        throw null;
     }
 
     public void set(int x, T y) {
-        throw null;
     }
 
     public <S> void set2(S x) { // No summary as S is unrelated to T
-        throw null;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -11,154 +11,152 @@ public Iterator<T> iterator() {`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`public boolean allMatch(Predicate<? super T> predicate) {`
`14`		`- throw null;`
	`14`	`+ return false;`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {`
`18`		`- throw null;`
	`18`	`+ return null;`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`// Collector is not a functional interface, so this is not supported`
`22`	`22`	`public <R, A> R collect(Collector<? super T, A, R> collector) {`
`23`		`- throw null;`
	`23`	`+ return null;`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {`
`27`		`- throw null;`
	`27`	`+ return null;`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`public Stream<T> distinct() {`
`31`		`- throw null;`
	`31`	`+ return null;`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`public static <T> Stream<T> empty() {`
`35`		`- throw null;`
	`35`	`+ return null;`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`public Stream<T> filter(Predicate<? super T> predicate) {`
`39`		`- throw null;`
	`39`	`+ return null;`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`public Optional<T> findAny() {`
`43`		`- throw null;`
	`43`	`+ return null;`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`public Optional<T> findFirst() {`
`47`		`- throw null;`
	`47`	`+ return null;`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`// public <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends`
`51`	`51`	`// R>> mapper) {`
`52`		`- // throw null;`
	`52`	`+ // return null;`
`53`	`53`	`// }`
`54`	`54`
`55`	`55`	`public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {`
`56`		`- throw null;`
	`56`	`+ return null;`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {`
`60`		`- throw null;`
	`60`	`+ return null;`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {`
`64`		`- throw null;`
	`64`	`+ return null;`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`public void forEach(Consumer<? super T> action) {`
`68`		`- throw null;`
`69`	`68`	`}`
`70`	`69`
`71`	`70`	`public void forEachOrdered(Consumer<? super T> action) {`
`72`		`- throw null;`
`73`	`71`	`}`
`74`	`72`
`75`	`73`	`public static <T> Stream<T> generate(Supplier<T> s) {`
`76`		`- throw null;`
	`74`	`+ return null;`
`77`	`75`	`}`
`78`	`76`
`79`	`77`	`// Model generator adds a couple of extra models, which can't be`
`80`	`78`	`// dismissed based on the type information.`
`81`	`79`	`public static <T> Stream<T> iterate(T seed, UnaryOperator<T> f) {`
`82`		`- throw null;`
	`80`	`+ return null;`
`83`	`81`	`}`
`84`	`82`
`85`	`83`	`public Stream<T> limit(long maxSize) {`
`86`		`- throw null;`
	`84`	`+ return null;`
`87`	`85`	`}`
`88`	`86`
`89`	`87`	`public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {`
`90`		`- throw null;`
	`88`	`+ return null;`
`91`	`89`	`}`
`92`	`90`
`93`	`91`	`public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {`
`94`		`- throw null;`
	`92`	`+ return null;`
`95`	`93`	`}`
`96`	`94`
`97`	`95`	`public IntStream mapToInt(ToIntFunction<? super T> mapper) {`
`98`		`- throw null;`
	`96`	`+ return null;`
`99`	`97`	`}`
`100`	`98`
`101`	`99`	`public LongStream mapToLong(ToLongFunction<? super T> mapper) {`
`102`		`- throw null;`
	`100`	`+ return null;`
`103`	`101`	`}`
`104`	`102`
`105`	`103`	`public Optional<T> max(Comparator<? super T> comparator) {`
`106`		`- throw null;`
	`104`	`+ return null;`
`107`	`105`	`}`
`108`	`106`
`109`	`107`	`public Optional<T> min(Comparator<? super T> comparator) {`
`110`		`- throw null;`
	`108`	`+ return null;`
`111`	`109`	`}`
`112`	`110`
`113`	`111`	`public boolean noneMatch(Predicate<? super T> predicate) {`
`114`		`- throw null;`
	`112`	`+ return false;`
`115`	`113`	`}`
`116`	`114`
`117`	`115`	`// Issue with model generator. ... is not supported.`
`118`	`116`	`// public static <T> Stream<T> of(T... t) {`
`119`		`- // throw null;`
	`117`	`+ // return null;`
`120`	`118`	`// }`
`121`	`119`
`122`	`120`	`public static <T> Stream<T> of(T t) {`
`123`		`- throw null;`
	`121`	`+ return null;`
`124`	`122`	`}`
`125`	`123`
`126`	`124`	`public Stream<T> peek(Consumer<? super T> action) {`
`127`		`- throw null;`
	`125`	`+ return null;`
`128`	`126`	`}`
`129`	`127`
`130`	`128`	`// Model generator yields a couple of extra results as models are generated for`
`131`	`129`	`// writing to the stream.`
`132`	`130`	`public Optional<T> reduce(BinaryOperator<T> accumulator) {`
`133`		`- throw null;`
	`131`	`+ return null;`
`134`	`132`	`}`
`135`	`133`
`136`	`134`	`// Model generator yields a couple of extra results as models are generated for`
`137`	`135`	`// writing to the stream.`
`138`	`136`	`public T reduce(T identity, BinaryOperator<T> accumulator) {`
`139`		`- throw null;`
	`137`	`+ return null;`
`140`	`138`	`}`
`141`	`139`
`142`	`140`	`public <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {`
`143`		`- throw null;`
	`141`	`+ return null;`
`144`	`142`	`}`
`145`	`143`
`146`	`144`	`public Stream<T> skip(long n) {`
`147`		`- throw null;`
	`145`	`+ return null;`
`148`	`146`	`}`
`149`	`147`
`150`	`148`	`public Stream<T> sorted() {`
`151`		`- throw null;`
	`149`	`+ return null;`
`152`	`150`	`}`
`153`	`151`
`154`	`152`	`public Stream<T> sorted(Comparator<? super T> comparator) {`
`155`		`- throw null;`
	`153`	`+ return null;`
`156`	`154`	`}`
`157`	`155`
`158`	`156`	`// Models can never be generated correctly based on the type information`
`159`	`157`	`// as it involves downcasting.`
`160`	`158`	`public Object[] toArray() {`
`161`		`- throw null;`
	`159`	`+ return null;`
`162`	`160`	`}`
`163`	`161`
`164`	`162`	`// Issue with model generator - no models are generated.`
Original file line number	Diff line number	Diff line change
`@@ -6,18 +6,16 @@`
`6`	`6`	`public class TypeBasedCollection<T> extends ArrayList<T> {`
`7`	`7`
`8`	`8`	`public void addT(T x) {`
`9`		`- throw null;`
`10`	`9`	`}`
`11`	`10`
`12`	`11`	`public void addManyT(List<T> xs) {`
`13`		`- throw null;`
`14`	`12`	`}`
`15`	`13`
`16`	`14`	`public T firstT() {`
`17`		`- throw null;`
	`15`	`+ return null;`
`18`	`16`	`}`
`19`	`17`
`20`	`18`	`public List<T> getManyT() {`
`21`		`- throw null;`
	`19`	`+ return null;`
`22`	`20`	`}`
`23`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,54 +6,52 @@`
`6`	`6`	`public class TypeBasedComplex<T> {`
`7`	`7`
`8`	`8`	`public void addMany(List<T> xs) {`
`9`		`- throw null;`
`10`	`9`	`}`
`11`	`10`
`12`	`11`	`public List<T> getMany() {`
`13`		`- throw null;`
	`12`	`+ return null;`
`14`	`13`	`}`
`15`	`14`
`16`	`15`	`public Integer apply(Function<T, Integer> f) {`
`17`		`- throw null;`
	`16`	`+ return null;`
`18`	`17`	`}`
`19`	`18`
`20`	`19`	`public <T1, T2> T2 apply2(T1 x, Function<T1, T2> f) {`
`21`		`- throw null;`
	`20`	`+ return null;`
`22`	`21`	`}`
`23`	`22`
`24`	`23`	`public TypeBasedComplex<T> flatMap(Function<T, List<T>> f) {`
`25`		`- throw null;`
	`24`	`+ return null;`
`26`	`25`	`}`
`27`	`26`
`28`	`27`	`public <S> TypeBasedComplex<S> flatMap2(Function<T, List<S>> f) {`
`29`		`- throw null;`
	`28`	`+ return null;`
`30`	`29`	`}`
`31`	`30`
`32`	`31`	`public <S> S map(Function<T, S> f) {`
`33`		`- throw null;`
	`32`	`+ return null;`
`34`	`33`	`}`
`35`	`34`
`36`	`35`	`public <S> TypeBasedComplex<S> mapComplex(Function<T, S> f) {`
`37`		`- throw null;`
	`36`	`+ return null;`
`38`	`37`	`}`
`39`	`38`
`40`	`39`	`public TypeBasedComplex<T> returnComplex(Function<T, TypeBasedComplex<T>> f) {`
`41`		`- throw null;`
	`40`	`+ return null;`
`42`	`41`	`}`
`43`	`42`
`44`	`43`	`public void set(Integer x, Function<Integer, T> f) {`
`45`		`- throw null;`
`46`	`44`	`}`
`47`	`45`
`48`	`46`	`public Integer applyMyFunction(MyFunction<T, Integer, T> f, Integer x) {`
`49`		`- throw null;`
	`47`	`+ return null;`
`50`	`48`	`}`
`51`	`49`
`52`	`50`	`public <S1, S2> S2 applyMyFunctionGeneric(MyFunction<T, S1, S2> f, S1 x) {`
`53`		`- throw null;`
	`51`	`+ return null;`
`54`	`52`	`}`
`55`	`53`
`56`	`54`	`public <S1, S2, S3> S3 applyMyFunctionGeneric(MyFunction<S1, S2, S3> f, S1 x, S2 y) {`
`57`		`- throw null;`
	`55`	`+ return null;`
`58`	`56`	`}`
`59`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,34 +2,30 @@`
`2`	`2`
`3`	`3`	`public class TypeBasedSimple<T> {`
`4`	`4`	`public TypeBasedSimple(T t) {`
`5`		`- throw null;`
`6`	`5`	`}`
`7`	`6`
`8`	`7`	`public T get() {`
`9`		`- throw null;`
	`8`	`+ return null;`
`10`	`9`	`}`
`11`	`10`
`12`	`11`	`public T get(Object o) {`
`13`	`12`	`return null;`
`14`	`13`	`}`
`15`	`14`
`16`	`15`	`public T id(T x) {`
`17`		`- throw null;`
	`16`	`+ return null;`
`18`	`17`	`}`
`19`	`18`
`20`	`19`	`public <S> S id2(S x) {`
`21`		`- throw null;`
	`20`	`+ return null;`
`22`	`21`	`}`
`23`	`22`
`24`	`23`	`public void set(T x) {`
`25`		`- throw null;`
`26`	`24`	`}`
`27`	`25`
`28`	`26`	`public void set(int x, T y) {`
`29`		`- throw null;`
`30`	`27`	`}`
`31`	`28`
`32`	`29`	`public <S> void set2(S x) { // No summary as S is unrelated to T`
`33`		`- throw null;`
`34`	`30`	`}`
`35`	`31`	`}`