From 92964cd7039a6c42e9c94113cf516e887a43c8fd Mon Sep 17 00:00:00 2001 From: Natalia Pozhidaeva Date: Sun, 17 Mar 2024 22:20:35 -0500 Subject: [PATCH] Fix style warnings, reformat assertions --- .../java/org/cactoos/list/SyncedTest.java | 18 ++-- .../java/org/cactoos/number/MinOfTest.java | 82 ++++++++++------- .../java/org/cactoos/number/SumOfTest.java | 69 ++++++++------ .../org/cactoos/scalar/AndInThreadsTest.java | 52 ++++++----- src/test/java/org/cactoos/scalar/AndTest.java | 48 ++++------ .../cactoos/scalar/InheritanceLevelTest.java | 17 ++-- src/test/java/org/cactoos/scalar/OrTest.java | 90 ++++++++----------- 7 files changed, 198 insertions(+), 178 deletions(-) diff --git a/src/test/java/org/cactoos/list/SyncedTest.java b/src/test/java/org/cactoos/list/SyncedTest.java index 09657b8dc..21321924e 100644 --- a/src/test/java/org/cactoos/list/SyncedTest.java +++ b/src/test/java/org/cactoos/list/SyncedTest.java @@ -26,6 +26,7 @@ import java.util.Collections; import org.hamcrest.MatcherAssert; import org.junit.jupiter.api.Test; +import org.llorllale.cactoos.matchers.Assertion; import org.llorllale.cactoos.matchers.RunsInThreads; /** @@ -38,29 +39,32 @@ final class SyncedTest { @Test - void behavesAsCollection() throws Exception { - MatcherAssert.assertThat( + void behavesAsCollection() { + new Assertion<>( "Can't behave as a list", new Synced<>(new ListOf<>(1, 0, -1, -1, 2)), new BehavesAsList<>(0) - ); + ).affirm(); } @Test void worksInThreads() { - MatcherAssert.assertThat( + new Assertion<>( + "should be run in threads", list -> !list.iterator().hasNext(), new RunsInThreads<>(new Synced<>(Collections.emptyList())) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "should work as list", list -> { MatcherAssert.assertThat( + "should behave as a list", list, new BehavesAsList<>(0) ); return true; }, new RunsInThreads<>(new Synced<>(new ListOf<>(1, 0, -1, -1, 2))) - ); + ).affirm(); } } diff --git a/src/test/java/org/cactoos/number/MinOfTest.java b/src/test/java/org/cactoos/number/MinOfTest.java index a2a36f141..6ea70d9b1 100644 --- a/src/test/java/org/cactoos/number/MinOfTest.java +++ b/src/test/java/org/cactoos/number/MinOfTest.java @@ -24,9 +24,9 @@ package org.cactoos.number; import org.cactoos.list.ListOf; -import org.hamcrest.MatcherAssert; import org.hamcrest.Matchers; import org.junit.jupiter.api.Test; +import org.llorllale.cactoos.matchers.Assertion; /** * Test case for {@link MinOf}. @@ -37,114 +37,130 @@ final class MinOfTest { @Test void withIntegerCollection() { - MatcherAssert.assertThat( + new Assertion<>( + "must select minimum integer of positive integers", new MinOf( new ListOf<>(1, 2, 3, 4).toArray(new Integer[4]) ).intValue(), Matchers.equalTo(1) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum long of positive integers", new MinOf( new ListOf<>(1, 2, 3, 4).toArray(new Integer[4]) ).longValue(), Matchers.equalTo(1L) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum double of positive integers", new MinOf( new ListOf<>(1, 2, 3, 4).toArray(new Integer[4]) ).doubleValue(), Matchers.equalTo(1.0d) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum float of positive integers", new MinOf( new ListOf<>(1, 2, 3, 4).toArray(new Integer[4]) ).floatValue(), Matchers.equalTo(1.0f) - ); + ).affirm(); } @Test void withLongCollection() { - MatcherAssert.assertThat( + new Assertion<>( + "must select minimum integer of positive longs", new MinOf( new ListOf<>(1L, 2L, 3L, 4L).toArray(new Long[4]) ).intValue(), Matchers.equalTo(1) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum long of positive longs", new MinOf( new ListOf<>(1L, 2L, 3L, 4L).toArray(new Long[4]) ).longValue(), Matchers.equalTo(1L) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum double of positive longs", new MinOf( new ListOf<>(1L, 2L, 3L, 4L).toArray(new Long[4]) ).doubleValue(), Matchers.equalTo(1.0d) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum float of positive longs", new MinOf( new ListOf<>(1L, 2L, 3L, 4L).toArray(new Long[4]) ).floatValue(), Matchers.equalTo(1.0f) - ); + ).affirm(); } @Test void withDoubleCollection() { - MatcherAssert.assertThat( + new Assertion<>( + "must select minimum integer of positive doubles", new MinOf( new ListOf<>(1.0d, 2.0d, 3.0d, 4.0d).toArray(new Double[4]) ).intValue(), Matchers.equalTo(1) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum long of positive doubles", new MinOf( new ListOf<>(1.0d, 2.0d, 3.0d, 4.0d).toArray(new Double[4]) ).longValue(), Matchers.equalTo(1L) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum double of positive doubles", new MinOf( new ListOf<>(1.0d, 2.0d, 3.0d, 4.0d).toArray(new Double[4]) ).doubleValue(), Matchers.equalTo(1.0d) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum float of positive doubles", new MinOf( new ListOf<>(1.0d, 2.0d, 3.0d, 4.0d).toArray(new Double[4]) ).floatValue(), Matchers.equalTo(1.0f) - ); + ).affirm(); } @Test void withFloatCollection() { - MatcherAssert.assertThat( + new Assertion<>( + "must select minimum integer of positive floats", new MinOf( new ListOf<>(1.0f, 2.0f, 3.0f, 4.0f).toArray(new Float[4]) ).intValue(), Matchers.equalTo(1) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum long of positive floats", new MinOf( new ListOf<>(1.0f, 2.0f, 3.0f, 4.0f).toArray(new Float[4]) ).longValue(), Matchers.equalTo(1L) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum float of positive floats", new MinOf( new ListOf<>(1.0f, 2.0f, 3.0f, 4.0f).toArray(new Float[4]) ).doubleValue(), Matchers.equalTo(1.0d) - ); - MatcherAssert.assertThat( + ).affirm(); + new Assertion<>( + "must select minimum float of positive floats", new MinOf( new ListOf<>(1.0f, 2.0f, 3.0f, 4.0f).toArray(new Float[4]) ).floatValue(), Matchers.equalTo(1.0f) - ); + ).affirm(); } } diff --git a/src/test/java/org/cactoos/number/SumOfTest.java b/src/test/java/org/cactoos/number/SumOfTest.java index 8d8d3429a..b1f2bf6af 100644 --- a/src/test/java/org/cactoos/number/SumOfTest.java +++ b/src/test/java/org/cactoos/number/SumOfTest.java @@ -26,9 +26,10 @@ import java.util.Collection; import org.cactoos.iterable.IterableOf; import org.cactoos.list.ListOf; -import org.hamcrest.MatcherAssert; +import org.cactoos.text.Joined; import org.hamcrest.core.IsEqual; import org.junit.jupiter.api.Test; +import org.llorllale.cactoos.matchers.Assertion; /** * Test case for {@link SumOf}. @@ -46,110 +47,126 @@ final class SumOfTest { @Test void withListOfNumbersInt() { - MatcherAssert.assertThat( + new Assertion<>( + "sum of integers should be calculated as integer", new SumOf(1, 2, 3).intValue(), new IsEqual<>(6) - ); + ).affirm(); } @Test void withListOfNumbersDouble() { - MatcherAssert.assertThat( + new Assertion<>( + "sum of doubles should be calculated as double", new SumOf(1.0d, 2.0d, 3.0d).doubleValue(), new IsEqual<>(6.0d) - ); + ).affirm(); } @Test void withListOfNumbersFloat() { - MatcherAssert.assertThat( + new Assertion<>( + "sum of floats should be calculated as float", new SumOf(1.0f, 2.0f, 3.0f).floatValue(), new IsEqual<>(6.0f) - ); + ).affirm(); } @Test void withListOfNumbersLong() { - MatcherAssert.assertThat( + new Assertion<>( + "sum of longs should be calculated as long", new SumOf(1L, 2L, 3L).longValue(), new IsEqual<>(6L) - ); + ).affirm(); } @Test void withCollectionLong() { - MatcherAssert.assertThat( + new Assertion<>( + "sum of longs should be calculated as long", new SumOf( new IterableOf<>(1, 2, 3, 4) ).longValue(), new IsEqual<>(10L) - ); + ).affirm(); } @Test void withCollectionInt() { - MatcherAssert.assertThat( + new Assertion<>( + "sum of longs should be calculated as integer", new SumOf( new IterableOf<>(1L, 2L, 3L, 4L) ).intValue(), new IsEqual<>(10) - ); + ).affirm(); } @Test void withCollectionFloat() { - MatcherAssert.assertThat( + new Assertion<>( + "sum of floats should be calculated as float", new SumOf( new IterableOf<>(1.0f, 2.0f, 3.0f, 4.0f) ).floatValue(), new IsEqual<>(10.0f) - ); + ).affirm(); } @Test void withCollectionDouble() { - MatcherAssert.assertThat( + new Assertion<>( + "sum of double should be calculated as double", new SumOf( new IterableOf<>(1.0d, 2.0d, 3.0d, 4.0d) ).doubleValue(), new IsEqual<>(10.0d) - ); + ).affirm(); } @Test void withIterableOfInts() { final Collection ints = new ListOf<>(1, 2, 3, 4); - MatcherAssert.assertThat( + new Assertion<>( + "sum of integers should be calculated as integer", new SumOf(ints).intValue(), new IsEqual<>(10) - ); + ).affirm(); } @Test void overflowIntFromLongValues() { - MatcherAssert.assertThat( + new Assertion<>( + "sum of longs should be calculated as integer without overflow error", new SumOf(2_147_483_647L + 1L << 1, 10L).intValue(), new IsEqual<>(10) - ); + ).affirm(); } @Test - void overflowIntFromLongValuesIncludingNegative() { - MatcherAssert.assertThat( + void overflowIntFromLongValuesIncludingNegative() throws Exception { + new Assertion<>( + new Joined( + "", + "sum of positive and negative longs should be calculated", + "as integer without overflow error" + ).asString(), new SumOf( 2_147_483_647L + 1L << 1, 10L, -(2_147_483_647L + 1L) << 1 ).intValue(), new IsEqual<>(10) - ); + ).affirm(); } @Test void overflowFloatFromLongValues() { - MatcherAssert.assertThat( + new Assertion<>( + "sum of longs should be calculated as float", new SumOf(2_147_483_647L + 1L << 1, 10L).floatValue(), new IsEqual<>(4_294_967_300.0f) - ); + ).affirm(); } } diff --git a/src/test/java/org/cactoos/scalar/AndInThreadsTest.java b/src/test/java/org/cactoos/scalar/AndInThreadsTest.java index ba295808f..cf0e3734b 100644 --- a/src/test/java/org/cactoos/scalar/AndInThreadsTest.java +++ b/src/test/java/org/cactoos/scalar/AndInThreadsTest.java @@ -33,7 +33,6 @@ import org.cactoos.list.ListOf; import org.cactoos.list.Synced; import org.cactoos.proc.ProcNoNulls; -import org.hamcrest.MatcherAssert; import org.hamcrest.Matchers; import org.hamcrest.collection.IsIterableContainingInAnyOrder; import org.hamcrest.core.IsEqual; @@ -49,7 +48,7 @@ final class AndInThreadsTest { @Test - void allTrue() throws Exception { + void allTrue() { new Assertion<>( "Each object must be True", new AndInThreads( @@ -62,7 +61,7 @@ void allTrue() throws Exception { } @Test - void oneFalse() throws Exception { + void oneFalse() { new Assertion<>( "One object must be False", new AndInThreads( @@ -75,7 +74,7 @@ void oneFalse() throws Exception { } @Test - void allFalse() throws Exception { + void allFalse() { new Assertion<>( "Each object must be False", new AndInThreads( @@ -90,7 +89,7 @@ void allFalse() throws Exception { } @Test - void emptyIterable() throws Exception { + void emptyIterable() { new Assertion<>( "Must iterate over empty iterable", new AndInThreads(new IterableOf<>()), @@ -124,27 +123,29 @@ void iteratesList() { } @Test - void worksWithFunc() throws Exception { - MatcherAssert.assertThat( + void worksWithFunc() { + new Assertion<>( + "Result should be calculated for integers", new AndInThreads( input -> input > 0, 1, -1, 0 ), new HasValue<>(false) - ); + ).affirm(); } @Test - void worksWithIterableScalarBoolean() throws Exception { - MatcherAssert.assertThat( + void worksWithIterableScalarBoolean() { + new Assertion<>( + "Result should be calculated from booleans", new AndInThreads( new ListOf>( new Constant<>(true), new Constant<>(true) ) - ).value(), - Matchers.equalTo(true) - ); + ), + new HasValue<>(true) + ).affirm(); } @Test @@ -156,7 +157,8 @@ void worksWithExecServiceProcValues() throws Exception { new ProcNoNulls(list::add), 1, 2 ).value(); - MatcherAssert.assertThat( + new Assertion<>( + "Result should be calculated for proc values", list, new IsIterableContainingInAnyOrder<>( new ListOf<>( @@ -164,7 +166,7 @@ void worksWithExecServiceProcValues() throws Exception { new IsEqual<>(2) ) ) - ); + ).affirm(); } @Test @@ -176,7 +178,8 @@ void worksWithExecServiceProcIterable() throws Exception { new ProcNoNulls(list::add), new ListOf<>(1, 2) ).value(); - MatcherAssert.assertThat( + new Assertion<>( + "Result should be calculated for proc iterables", list, new IsIterableContainingInAnyOrder<>( new ListOf<>( @@ -184,24 +187,26 @@ void worksWithExecServiceProcIterable() throws Exception { new IsEqual<>(2) ) ) - ); + ).affirm(); } @Test void worksWithExecServiceScalarBooleans() throws Exception { - MatcherAssert.assertThat( + new Assertion<>( + "Result should be calculated for threads booleans", new AndInThreads( Executors.newSingleThreadExecutor(), new Constant<>(false), new Constant<>(false) ).value(), Matchers.equalTo(false) - ); + ).affirm(); } @Test void worksWithExecServiceIterableScalarBoolean() throws Exception { - MatcherAssert.assertThat( + new Assertion<>( + "Result should be calculated for threads iterable booleans", new AndInThreads( Executors.newSingleThreadExecutor(), new ListOf>( @@ -210,17 +215,18 @@ void worksWithExecServiceIterableScalarBoolean() throws Exception { ) ).value(), Matchers.equalTo(false) - ); + ).affirm(); } @Test void worksWithEmptyIterableScalarBoolean() throws Exception { - MatcherAssert.assertThat( + new Assertion<>( + "Result should be calculated for empty iterable", new AndInThreads( new ListOf<>() ).value(), Matchers.equalTo(true) - ); + ).affirm(); } } diff --git a/src/test/java/org/cactoos/scalar/AndTest.java b/src/test/java/org/cactoos/scalar/AndTest.java index 33ec8c410..6644095b0 100644 --- a/src/test/java/org/cactoos/scalar/AndTest.java +++ b/src/test/java/org/cactoos/scalar/AndTest.java @@ -25,7 +25,6 @@ import org.cactoos.Scalar; import org.cactoos.iterable.IterableOf; -import org.hamcrest.MatcherAssert; import org.junit.jupiter.api.Test; import org.llorllale.cactoos.matchers.Assertion; import org.llorllale.cactoos.matchers.HasValue; @@ -39,7 +38,7 @@ final class AndTest { @Test - void allTrue() throws Exception { + void allTrue() { new Assertion<>( "Each object must be True", new And( @@ -52,7 +51,7 @@ void allTrue() throws Exception { } @Test - void oneFalse() throws Exception { + void oneFalse() { new Assertion<>( "One object must be False", new And( @@ -65,7 +64,7 @@ void oneFalse() throws Exception { } @Test - void allFalse() throws Exception { + void allFalse() { new Assertion<>( "Each object must be False", new And( @@ -80,7 +79,7 @@ void allFalse() throws Exception { } @Test - void emptyIterator() throws Exception { + void emptyIterator() { new Assertion<>( "Iterator must be empty", new And(new IterableOf>()), @@ -89,41 +88,32 @@ void emptyIterator() throws Exception { } @Test - void testFuncIterable() throws Exception { - MatcherAssert.assertThat( - new And( - input -> input > 0, - new IterableOf(1, -1, 0) - ), - new HasValue<>(false) - ); - } - - @Test - void testFuncIterator() throws Exception { - MatcherAssert.assertThat( + void testFuncIterable() { + new Assertion<>( + "lambda should be called for iterable", new And( input -> input > 0, - new IterableOf(1, -1, 0) + new IterableOf<>(1, -1, 0) ), new HasValue<>(false) - ); + ).affirm(); } @Test - void testFuncVarargs() throws Exception { - MatcherAssert.assertThat( + void testFuncVarargs() { + new Assertion<>( + "lambda should be called for varargs", new And( input -> input > 0, -1, -2, 0 ), new HasValue<>(false) - ); + ).affirm(); } @Test - void testMultipleFuncConditionTrue() throws Exception { - MatcherAssert.assertThat( + void testMultipleFuncConditionTrue() { + new Assertion<>( "Can't compare subject with true conditions", new And( 3, @@ -132,12 +122,12 @@ void testMultipleFuncConditionTrue() throws Exception { input -> input > 4 ), new HasValue<>(false) - ); + ).affirm(); } @Test - void testMultipleFuncConditionFalse() throws Exception { - MatcherAssert.assertThat( + void testMultipleFuncConditionFalse() { + new Assertion<>( "Can't compare subject with false conditions", new And( "cactoos", @@ -145,6 +135,6 @@ void testMultipleFuncConditionFalse() throws Exception { input -> input.contains("static") ), new HasValue<>(false) - ); + ).affirm(); } } diff --git a/src/test/java/org/cactoos/scalar/InheritanceLevelTest.java b/src/test/java/org/cactoos/scalar/InheritanceLevelTest.java index 0c01a08b5..075d9c02c 100644 --- a/src/test/java/org/cactoos/scalar/InheritanceLevelTest.java +++ b/src/test/java/org/cactoos/scalar/InheritanceLevelTest.java @@ -24,8 +24,8 @@ package org.cactoos.scalar; import java.io.FileNotFoundException; -import org.hamcrest.MatcherAssert; import org.junit.jupiter.api.Test; +import org.llorllale.cactoos.matchers.Assertion; import org.llorllale.cactoos.matchers.HasValue; /** @@ -38,34 +38,37 @@ final class InheritanceLevelTest { @Test void twoInheritanceLevelsBetweenClasses() { - MatcherAssert.assertThat( + new Assertion<>( + "level should be calculated for inherited classes", new InheritanceLevel( FileNotFoundException.class, Exception.class ), new HasValue<>(2) - ); + ).affirm(); } @Test void classesAreNotRelated() { - MatcherAssert.assertThat( + new Assertion<>( + "level should be calculated for not related classes", new InheritanceLevel( FileNotFoundException.class, RuntimeException.class ), new HasValue<>(Integer.MIN_VALUE) - ); + ).affirm(); } @Test void classesAreIdentical() { - MatcherAssert.assertThat( + new Assertion<>( + "0 level should be calculated for equal classes", new InheritanceLevel( FileNotFoundException.class, FileNotFoundException.class ), new HasValue<>(0) - ); + ).affirm(); } } diff --git a/src/test/java/org/cactoos/scalar/OrTest.java b/src/test/java/org/cactoos/scalar/OrTest.java index 5e4c9c09f..c07b662c7 100644 --- a/src/test/java/org/cactoos/scalar/OrTest.java +++ b/src/test/java/org/cactoos/scalar/OrTest.java @@ -28,9 +28,9 @@ import org.cactoos.Proc; import org.cactoos.Scalar; import org.cactoos.iterable.IterableOf; -import org.hamcrest.MatcherAssert; import org.hamcrest.Matchers; import org.junit.jupiter.api.Test; +import org.llorllale.cactoos.matchers.Assertion; import org.llorllale.cactoos.matchers.HasValue; /** @@ -43,8 +43,9 @@ final class OrTest { @Test - void allFalse() throws Exception { - MatcherAssert.assertThat( + void allFalse() { + new Assertion<>( + "value should be calculated for all false", new Or( new False(), new False(), @@ -53,12 +54,13 @@ void allFalse() throws Exception { new False() ), new HasValue<>(false) - ); + ).affirm(); } @Test - void oneTrue() throws Exception { - MatcherAssert.assertThat( + void oneTrue() { + new Assertion<>( + "value should be calculated for all false except one", new Or( new False(), new True(), @@ -67,12 +69,13 @@ void oneTrue() throws Exception { new False() ), new HasValue<>(true) - ); + ).affirm(); } @Test - void allTrue() throws Exception { - MatcherAssert.assertThat( + void allTrue() { + new Assertion<>( + "value should be calculated for all true", new Or( new IterableOf>( new True(), @@ -83,15 +86,16 @@ void allTrue() throws Exception { ) ), new HasValue<>(true) - ); + ).affirm(); } @Test - void emptyIterator() throws Exception { - MatcherAssert.assertThat( + void emptyIterator() { + new Assertion<>( + "false should be a result for empty iterable", new Or(new IterableOf>()), new HasValue<>(false) - ); + ).affirm(); } @Test @@ -101,23 +105,11 @@ void testProcIterable() throws Exception { (Proc) list::add, new IterableOf<>(1, 2, 3, 4) ).value(); - MatcherAssert.assertThat( + new Assertion<>( + "proc iterable should collect list", list, Matchers.contains(1, 2, 3, 4) - ); - } - - @Test - void testProcIterator() throws Exception { - final List list = new LinkedList<>(); - new Or( - (Proc) list::add, - new IterableOf<>(1, 2, 3, 4) - ).value(); - MatcherAssert.assertThat( - list, - Matchers.contains(1, 2, 3, 4) - ); + ).affirm(); } @Test @@ -127,48 +119,40 @@ void testProcVarargs() throws Exception { (Proc) list::add, 2, 3, 4 ).value(); - MatcherAssert.assertThat( + new Assertion<>( + "proc iterable should collect list from varargs", list, Matchers.contains(2, 3, 4) - ); - } - - @Test - void testFuncIterable() throws Exception { - MatcherAssert.assertThat( - new Or( - input -> input > 0, - new IterableOf<>(-1, 1, 0) - ), - new HasValue<>(true) - ); + ).affirm(); } @Test - void testFuncIterator() throws Exception { - MatcherAssert.assertThat( + void testFuncIterable() { + new Assertion<>( + "function should be called for iterable", new Or( input -> input > 0, new IterableOf<>(-1, 1, 0) ), new HasValue<>(true) - ); + ).affirm(); } @Test - void testFuncVarargs() throws Exception { - MatcherAssert.assertThat( + void testFuncVarargs() { + new Assertion<>( + "function should be called for varargs", new Or( input -> input > 0, -1, -2, 0 ), new HasValue<>(false) - ); + ).affirm(); } @Test - void testMultipleFuncConditionTrue() throws Exception { - MatcherAssert.assertThat( + void testMultipleFuncConditionTrue() { + new Assertion<>( "Can't compare subject with true conditions", new Or( 3, @@ -177,12 +161,12 @@ void testMultipleFuncConditionTrue() throws Exception { input -> input > 4 ), new HasValue<>(true) - ); + ).affirm(); } @Test - void testMultipleFuncConditionFalse() throws Exception { - MatcherAssert.assertThat( + void testMultipleFuncConditionFalse() { + new Assertion<>( "Can't compare subject with false conditions", new Or( "cactoos", @@ -190,6 +174,6 @@ void testMultipleFuncConditionFalse() throws Exception { input -> input.contains("static") ), new HasValue<>(false) - ); + ).affirm(); } }