Skip to content

Commit 7c40619

Browse files
Stephan202Stephan202
authored
Extend AssertJStreamRules Refaster rule collection (#2051)
Some of the new rules are moved from the (untested) `AssertJRules` rules collection. While there, also extend some rules in the latter collection to cover `assertThat(Collection<T>)` overloads.
1 parent 9ebcdd2 commit 7c40619

File tree

5 files changed

+329
-67
lines changed

5 files changed

+329
-67
lines changed

‎error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJRules.java‎

Lines changed: 131 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010
import com.google.errorprone.refaster.annotation.NotMatches;
1111
import com.google.errorprone.refaster.annotation.Repeated;
1212
import com.google.errorprone.refaster.annotation.UseImportPolicy;
13+
import java.util.Collection;
1314
import java.util.List;
1415
import java.util.Map;
1516
import java.util.OptionalDouble;
@@ -311,7 +312,15 @@ IterableAssert<T> before(
311312
}
312313

313314
@BeforeTemplate
314-
ListAssert<T> before2(
315+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
316+
Stream<S> stream,
317+
Iterable<U> iterable,
318+
Collector<S, ?, ? extends Collection<T>> collector) {
319+
return assertThat(stream.collect(collector)).containsAnyElementsOf(iterable);
320+
}
321+
322+
@BeforeTemplate
323+
ListAssert<T> before3(
315324
Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
316325
return assertThat(stream.collect(collector)).containsAnyElementsOf(iterable);
317326
}
@@ -332,7 +341,13 @@ IterableAssert<T> before(
332341
}
333342

334343
@BeforeTemplate
335-
ListAssert<T> before2(
344+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
345+
Stream<S> stream, U[] array, Collector<S, ?, ? extends Collection<T>> collector) {
346+
return assertThat(stream.collect(collector)).containsAnyOf(array);
347+
}
348+
349+
@BeforeTemplate
350+
ListAssert<T> before3(
336351
Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
337352
return assertThat(stream.collect(collector)).containsAnyOf(array);
338353
}
@@ -355,7 +370,16 @@ IterableAssert<T> before(
355370

356371
@BeforeTemplate
357372
@SuppressWarnings("AssertThatStreamContainsAnyOf" /* Varargs converted to array. */)
358-
ListAssert<T> before2(
373+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
374+
Stream<S> stream,
375+
@Repeated U elements,
376+
Collector<S, ?, ? extends Collection<T>> collector) {
377+
return assertThat(stream.collect(collector)).containsAnyOf(Refaster.asVarargs(elements));
378+
}
379+
380+
@BeforeTemplate
381+
@SuppressWarnings("AssertThatStreamContainsAnyOf" /* Varargs converted to array. */)
382+
ListAssert<T> before3(
359383
Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
360384
return assertThat(stream.collect(collector)).containsAnyOf(Refaster.asVarargs(elements));
361385
}
@@ -377,7 +401,15 @@ IterableAssert<T> before(
377401
}
378402

379403
@BeforeTemplate
380-
ListAssert<T> before2(
404+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
405+
Stream<S> stream,
406+
Iterable<U> iterable,
407+
Collector<S, ?, ? extends Collection<T>> collector) {
408+
return assertThat(stream.collect(collector)).containsAll(iterable);
409+
}
410+
411+
@BeforeTemplate
412+
ListAssert<T> before3(
381413
Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
382414
return assertThat(stream.collect(collector)).containsAll(iterable);
383415
}
@@ -398,7 +430,13 @@ IterableAssert<T> before(
398430
}
399431

400432
@BeforeTemplate
401-
ListAssert<T> before2(
433+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
434+
Stream<S> stream, U[] array, Collector<S, ?, ? extends Collection<T>> collector) {
435+
return assertThat(stream.collect(collector)).contains(array);
436+
}
437+
438+
@BeforeTemplate
439+
ListAssert<T> before3(
402440
Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
403441
return assertThat(stream.collect(collector)).contains(array);
404442
}
@@ -421,7 +459,16 @@ IterableAssert<T> before(
421459

422460
@BeforeTemplate
423461
@SuppressWarnings("AssertThatStreamContains" /* Varargs converted to array. */)
424-
ListAssert<T> before2(
462+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
463+
Stream<S> stream,
464+
@Repeated U elements,
465+
Collector<S, ?, ? extends Collection<T>> collector) {
466+
return assertThat(stream.collect(collector)).contains(Refaster.asVarargs(elements));
467+
}
468+
469+
@BeforeTemplate
470+
@SuppressWarnings("AssertThatStreamContains" /* Varargs converted to array. */)
471+
ListAssert<T> before3(
425472
Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
426473
return assertThat(stream.collect(collector)).contains(Refaster.asVarargs(elements));
427474
}
@@ -634,7 +681,15 @@ IterableAssert<T> before(
634681
}
635682

636683
@BeforeTemplate
637-
ListAssert<T> before2(
684+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
685+
Stream<S> stream,
686+
Iterable<U> iterable,
687+
Collector<S, ?, ? extends Collection<T>> collector) {
688+
return assertThat(stream.collect(collector)).doesNotContainAnyElementsOf(iterable);
689+
}
690+
691+
@BeforeTemplate
692+
ListAssert<T> before3(
638693
Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
639694
return assertThat(stream.collect(collector)).doesNotContainAnyElementsOf(iterable);
640695
}
@@ -655,7 +710,13 @@ IterableAssert<T> before(
655710
}
656711

657712
@BeforeTemplate
658-
ListAssert<T> before2(
713+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
714+
Stream<S> stream, U[] array, Collector<S, ?, ? extends Collection<T>> collector) {
715+
return assertThat(stream.collect(collector)).doesNotContain(array);
716+
}
717+
718+
@BeforeTemplate
719+
ListAssert<T> before3(
659720
Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
660721
return assertThat(stream.collect(collector)).doesNotContain(array);
661722
}
@@ -678,7 +739,16 @@ IterableAssert<T> before(
678739

679740
@BeforeTemplate
680741
@SuppressWarnings("AssertThatStreamDoesNotContain" /* Varargs converted to array. */)
681-
ListAssert<T> before2(
742+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
743+
Stream<S> stream,
744+
@Repeated U elements,
745+
Collector<S, ?, ? extends Collection<T>> collector) {
746+
return assertThat(stream.collect(collector)).doesNotContain(Refaster.asVarargs(elements));
747+
}
748+
749+
@BeforeTemplate
750+
@SuppressWarnings("AssertThatStreamDoesNotContain" /* Varargs converted to array. */)
751+
ListAssert<T> before3(
682752
Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
683753
return assertThat(stream.collect(collector)).doesNotContain(Refaster.asVarargs(elements));
684754
}
@@ -738,7 +808,15 @@ IterableAssert<T> before(
738808
}
739809

740810
@BeforeTemplate
741-
ListAssert<T> before2(
811+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
812+
Stream<S> stream,
813+
Iterable<U> iterable,
814+
Collector<S, ?, ? extends Collection<T>> collector) {
815+
return assertThat(stream.collect(collector)).hasSameElementsAs(iterable);
816+
}
817+
818+
@BeforeTemplate
819+
ListAssert<T> before3(
742820
Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
743821
return assertThat(stream.collect(collector)).hasSameElementsAs(iterable);
744822
}
@@ -759,7 +837,13 @@ IterableAssert<T> before(
759837
}
760838

761839
@BeforeTemplate
762-
ListAssert<T> before2(
840+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
841+
Stream<S> stream, U[] array, Collector<S, ?, ? extends Collection<T>> collector) {
842+
return assertThat(stream.collect(collector)).containsOnly(array);
843+
}
844+
845+
@BeforeTemplate
846+
ListAssert<T> before3(
763847
Stream<S> stream, U[] array, Collector<S, ?, ? extends List<T>> collector) {
764848
return assertThat(stream.collect(collector)).containsOnly(array);
765849
}
@@ -782,7 +866,16 @@ IterableAssert<T> before(
782866

783867
@BeforeTemplate
784868
@SuppressWarnings("AssertThatStreamContainsOnly" /* Varargs converted to array. */)
785-
ListAssert<T> before2(
869+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
870+
Stream<S> stream,
871+
@Repeated U elements,
872+
Collector<S, ?, ? extends Collection<T>> collector) {
873+
return assertThat(stream.collect(collector)).containsOnly(Refaster.asVarargs(elements));
874+
}
875+
876+
@BeforeTemplate
877+
@SuppressWarnings("AssertThatStreamContainsOnly" /* Varargs converted to array. */)
878+
ListAssert<T> before3(
786879
Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
787880
return assertThat(stream.collect(collector)).containsOnly(Refaster.asVarargs(elements));
788881
}
@@ -809,13 +902,27 @@ IterableAssert<T> before(
809902
}
810903

811904
@BeforeTemplate
812-
ListAssert<T> before2(
905+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
906+
Stream<S> stream,
907+
Iterable<U> iterable,
908+
Collector<S, ?, ? extends Collection<T>> collector) {
909+
return assertThat(stream.collect(collector)).isSubsetOf(iterable);
910+
}
911+
912+
@BeforeTemplate
913+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
914+
Stream<S> stream, U[] iterable, Collector<S, ?, ? extends Collection<T>> collector) {
915+
return assertThat(stream.collect(collector)).isSubsetOf(iterable);
916+
}
917+
918+
@BeforeTemplate
919+
ListAssert<T> before3(
813920
Stream<S> stream, Iterable<U> iterable, Collector<S, ?, ? extends List<T>> collector) {
814921
return assertThat(stream.collect(collector)).isSubsetOf(iterable);
815922
}
816923

817924
@BeforeTemplate
818-
ListAssert<T> before2(
925+
ListAssert<T> before3(
819926
Stream<S> stream, U[] iterable, Collector<S, ?, ? extends List<T>> collector) {
820927
return assertThat(stream.collect(collector)).isSubsetOf(iterable);
821928
}
@@ -838,66 +945,24 @@ IterableAssert<T> before(
838945

839946
@BeforeTemplate
840947
@SuppressWarnings("AssertThatStreamIsSubsetOf" /* Varargs converted to array. */)
841-
ListAssert<T> before2(
842-
Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
948+
AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(
949+
Stream<S> stream,
950+
@Repeated U elements,
951+
Collector<S, ?, ? extends Collection<T>> collector) {
843952
return assertThat(stream.collect(collector)).isSubsetOf(Refaster.asVarargs(elements));
844953
}
845954

846-
@AfterTemplate
847-
@UseImportPolicy(STATIC_IMPORT_ALWAYS)
848-
ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
849-
return assertThat(stream).isSubsetOf(elements);
850-
}
851-
}
852-
853-
// XXX: This rule assumes the `collector` doesn't completely discard certain values.
854-
static final class AssertThatStreamIsEmpty<S, T extends S> {
855-
@BeforeTemplate
856-
void before(Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector) {
857-
assertThat(stream.collect(collector)).isEmpty();
858-
}
859-
860-
@BeforeTemplate
861-
void before2(Stream<S> stream, Collector<S, ?, ? extends List<T>> collector) {
862-
assertThat(stream.collect(collector)).isEmpty();
863-
}
864-
865-
@AfterTemplate
866-
@UseImportPolicy(STATIC_IMPORT_ALWAYS)
867-
void after(Stream<S> stream) {
868-
assertThat(stream).isEmpty();
869-
}
870-
}
871-
872-
// XXX: This rule assumes the `collector` doesn't completely discard certain values.
873-
static final class AssertThatStreamIsNotEmpty<S, T extends S> {
874-
@BeforeTemplate
875-
void before(Stream<S> stream, Collector<S, ?, ? extends Iterable<T>> collector) {
876-
assertThat(stream.collect(collector)).isNotEmpty();
877-
}
878-
879-
@BeforeTemplate
880-
void before2(Stream<S> stream, Collector<S, ?, ? extends List<T>> collector) {
881-
assertThat(stream.collect(collector)).isNotEmpty();
882-
}
883-
884-
@AfterTemplate
885-
@UseImportPolicy(STATIC_IMPORT_ALWAYS)
886-
void after(Stream<S> stream) {
887-
assertThat(stream).isNotEmpty();
888-
}
889-
}
890-
891-
static final class AssertThatStreamHasSize<T> {
892955
@BeforeTemplate
893-
void before(Stream<T> stream, int size) {
894-
assertThat(stream.count()).isEqualTo(size);
956+
@SuppressWarnings("AssertThatStreamIsSubsetOf" /* Varargs converted to array. */)
957+
ListAssert<T> before3(
958+
Stream<S> stream, @Repeated U elements, Collector<S, ?, ? extends List<T>> collector) {
959+
return assertThat(stream.collect(collector)).isSubsetOf(Refaster.asVarargs(elements));
895960
}
896961

897962
@AfterTemplate
898963
@UseImportPolicy(STATIC_IMPORT_ALWAYS)
899-
void after(Stream<T> stream, int size) {
900-
assertThat(stream).hasSize(size);
964+
ListAssert<S> after(Stream<S> stream, @Repeated U elements) {
965+
return assertThat(stream).isSubsetOf(elements);
901966
}
902967
}
903968

0 commit comments

Comments
 (0)