From 80e813e9336396803bf165b3e770f0f3028ef6c5 Mon Sep 17 00:00:00 2001 From: Paul Campbell Date: Wed, 25 Jul 2018 11:00:53 +0100 Subject: [PATCH] Condition.{and(Condition),or(Condition),not()}: added Deprecate the whereNot(), andNot() and orNot() methods infavour of these new methods, which they all not use internally.. --- CHANGELOG | 10 ++ .../net/kemitix/conditional/Condition.java | 64 ++++++-- .../kemitix/conditional/FalseCondition.java | 11 ++ .../kemitix/conditional/TrueCondition.java | 10 ++ .../kemitix/conditional/ConditionalTest.java | 143 +++++++++++++++--- 5 files changed, 206 insertions(+), 32 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index 09046a8..2af9d3d 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,6 +1,16 @@ CHANGELOG ========= +0.6.0 +----- + +* Add `Condition.and(Condition)` +* Add `Condition.or(Condition)` +* Add `Condition.not()` +* Deprecate `Condition.whereNot(boolean)` +* Deprecate `Condition.andNot(boolean)` +* Deprecate `Condition.orNot(boolean)` + 0.5.0 ----- diff --git a/src/main/java/net/kemitix/conditional/Condition.java b/src/main/java/net/kemitix/conditional/Condition.java index aa4669b..8bfee11 100644 --- a/src/main/java/net/kemitix/conditional/Condition.java +++ b/src/main/java/net/kemitix/conditional/Condition.java @@ -35,7 +35,6 @@ public interface Condition { * Create a new {@code Condition} for the clause. * * @param clause the condition to test - * * @return the Condition */ static Condition where(final boolean clause) { @@ -49,59 +48,102 @@ public interface Condition { * Create a new {@code Condition} for the boolean opposite of the clause. * * @param clause the condition to test - * * @return the Condition + * @deprecated use {@link #not()} */ + @Deprecated static Condition whereNot(final boolean clause) { - return where(!clause); + return where(clause).not(); + } + + /** + * Checks if the Condition is true or not. + * + * @return true if the Condition is true + */ + boolean isTrue(); + + /** + * Checks of the Condition is false or not. + * + * @return true if the Condition is false + */ + boolean isFalse(); + + /** + * Negates the Condtion. + * + * @return a false Condition if the Condition is true, or a true Condition if the Condition is false. + */ + default Condition not() { + return Condition.where(isFalse()); } /** * Logically AND combine the current {@code Condition} with the clause. * * @param clause the condition to test - * * @return the Condition */ Condition and(Supplier clause); + /** + * Logicaly OR current {@code Condition} with the other {@code Condition}. + * + * @param other the other Condition + * @return true if both Conditions are true + */ + default Condition and(Condition other) { + return Condition.where(isTrue()).and(other::isTrue); + } + /** * Logically AND combine the current {@code Condition} with boolean opposite of the clause. * * @param clause the condition to test - * * @return the Condition + * @deprecated use {@link #not()} */ + @Deprecated default Condition andNot(final Supplier clause) { - return and(() -> !clause.get()); + return and(clause).not(); } /** * Logically OR combine the current {@code Condition} with the clause. * * @param clause the condition to test - * * @return the Condition */ @SuppressWarnings("PMD.ShortMethodName") Condition or(Supplier clause); + /** + * Logically OR the current {@code Condition} with the other {@code Condition}. + * + * @param other the other Condition + * @return true if either Condition is true + */ + default Condition or(Condition other) { + return where(isTrue()).or(other::isTrue); + } + /** * Logically OR combine the current {@code Condition} with the boolean opposite of the clause. * * @param clause the condition to test - * * @return the Condition + * @deprecated use {@link #not()} */ + @Deprecated default Condition orNot(final Supplier clause) { - return or(() -> !clause.get()); + return or(clause).not(); } /** * Perform this response if the {@code Condition} is {@code true}. * * @param response the response to perform - * * @return the Condition */ Condition then(Action response); @@ -117,7 +159,6 @@ public interface Condition { * Create a new {@code Condition} for the clause as a continuation to an existing {@code Condition}. * * @param clause the condition to test - * * @return the Condition */ default Condition otherwise(final Supplier clause) { @@ -141,4 +182,5 @@ public interface Condition { */ @SuppressWarnings(SuppressHelper.CS_ILLEGALTHROWS) void otherwiseThrow(Exception exception) throws Exception; + } diff --git a/src/main/java/net/kemitix/conditional/FalseCondition.java b/src/main/java/net/kemitix/conditional/FalseCondition.java index f47d8a4..b98f058 100644 --- a/src/main/java/net/kemitix/conditional/FalseCondition.java +++ b/src/main/java/net/kemitix/conditional/FalseCondition.java @@ -62,4 +62,15 @@ final class FalseCondition implements Condition { public void otherwiseThrow(final Exception exception) throws Exception { throw exception; } + + @Override + public boolean isTrue() { + return false; + } + + @Override + public boolean isFalse() { + return true; + } + } diff --git a/src/main/java/net/kemitix/conditional/TrueCondition.java b/src/main/java/net/kemitix/conditional/TrueCondition.java index 3597cb3..a261441 100644 --- a/src/main/java/net/kemitix/conditional/TrueCondition.java +++ b/src/main/java/net/kemitix/conditional/TrueCondition.java @@ -64,4 +64,14 @@ final class TrueCondition implements Condition { // do nothing } + @Override + public boolean isTrue() { + return true; + } + + @Override + public boolean isFalse() { + return false; + } + } diff --git a/src/test/java/net/kemitix/conditional/ConditionalTest.java b/src/test/java/net/kemitix/conditional/ConditionalTest.java index 7cc8465..423b930 100644 --- a/src/test/java/net/kemitix/conditional/ConditionalTest.java +++ b/src/test/java/net/kemitix/conditional/ConditionalTest.java @@ -7,18 +7,21 @@ import org.junit.Test; import java.io.IOException; import java.util.concurrent.atomic.AtomicInteger; +import static net.kemitix.conditional.Condition.where; + /** * @author Paul Campbell (pcampbell@kemitix.net). */ public class ConditionalTest implements WithAssertions { private Action thenResponse; - private Action otherwiseResponse; - private boolean thenFlag; - private boolean otherwiseFlag; + private final org.assertj.core.api.Condition trueCondition = + new org.assertj.core.api.Condition<>(Condition::isTrue, "is true"); + private final org.assertj.core.api.Condition falseCondition = + new org.assertj.core.api.Condition<>(Condition::isFalse, "is false"); @Before public void setUp() { @@ -77,7 +80,7 @@ public class ConditionalTest implements WithAssertions { @Test public void whereTrueThenDoSomethingAndThenDoSomethingElse() { //when - Condition.where(true) + where(true) .then(thenResponse) .and(() -> true) .then(otherwiseResponse); @@ -139,7 +142,7 @@ public class ConditionalTest implements WithAssertions { @Test public void whereTrueAndNotFalseThenRuns() { //when - Condition.where(true) + where(true) .andNot(() -> false) .then(thenResponse); //then @@ -149,7 +152,7 @@ public class ConditionalTest implements WithAssertions { @Test public void whereTrueAndNotTrueThenOtherwiseRuns() { //when - Condition.where(true) + where(true) .andNot(() -> true) .then(thenResponse) .otherwise(otherwiseResponse); @@ -160,7 +163,7 @@ public class ConditionalTest implements WithAssertions { @Test public void whereFalseOrNotFalseThenRuns() { //when - Condition.where(false) + where(false) .orNot(() -> false) .then(thenResponse); //then @@ -170,7 +173,7 @@ public class ConditionalTest implements WithAssertions { @Test public void whereFalseOrNotTrueThenOtherwiseRuns() { //when - Condition.where(false) + where(false) .orNot(() -> true) .then(thenResponse) .otherwise(otherwiseResponse); @@ -181,7 +184,7 @@ public class ConditionalTest implements WithAssertions { @Test public void whereFalseElseTrueThenOtherwiseRuns() { //when - Condition.where(false) + where(false) .then(thenResponse) .otherwise(() -> true) .then(otherwiseResponse); @@ -192,7 +195,7 @@ public class ConditionalTest implements WithAssertions { @Test public void whereFalseElseFalseThenNothingRuns() { //when - Condition.where(false) + where(false) .then(thenResponse) .otherwise(() -> false) .then(otherwiseResponse); @@ -203,7 +206,7 @@ public class ConditionalTest implements WithAssertions { @Test public void whereTrueChainedThensBothRuns() { //when - Condition.where(true) + where(true) .then(thenResponse) .then(otherwiseResponse); //then @@ -213,7 +216,7 @@ public class ConditionalTest implements WithAssertions { @Test public void whereFalseChainedThensNothingRuns() { //when - Condition.where(false) + where(false) .then(thenResponse) .then(otherwiseResponse); //then @@ -261,7 +264,7 @@ public class ConditionalTest implements WithAssertions { } private void when(final boolean clause) { - Condition.where(clause) + where(clause) .then(thenResponse) .otherwise(otherwiseResponse); } @@ -270,7 +273,7 @@ public class ConditionalTest implements WithAssertions { final boolean firstClause, final boolean secondClause ) { - Condition.where(firstClause) + where(firstClause) .and(() -> secondClause) .then(thenResponse) .otherwise(otherwiseResponse); @@ -280,7 +283,7 @@ public class ConditionalTest implements WithAssertions { final boolean firstClause, final boolean secondClause ) { - Condition.where(firstClause) + where(firstClause) .or(() -> secondClause) .then(thenResponse) .otherwise(otherwiseResponse); @@ -291,7 +294,7 @@ public class ConditionalTest implements WithAssertions { //given final AtomicInteger atomicInteger = new AtomicInteger(); //when - Condition.where(true) + where(true) .or(() -> atomicInteger.compareAndSet(0, 2)) .then(thenResponse); //then @@ -304,7 +307,7 @@ public class ConditionalTest implements WithAssertions { //given final AtomicInteger atomicInteger = new AtomicInteger(); //when - Condition.where(false) + where(false) .and(() -> atomicInteger.compareAndSet(0, 2)) .then(thenResponse); //then @@ -316,14 +319,14 @@ public class ConditionalTest implements WithAssertions { public void whereTrueThenThrowException() { //given assertThatExceptionOfType(IOException.class) - .isThrownBy(() -> Condition.where(true) + .isThrownBy(() -> where(true) .thenThrow(new IOException())); } @Test public void whereFalseThenDoNotThrowException() throws Exception { assertThatCode(() -> - Condition.where(false) + where(false) .thenThrow(new IOException())) .doesNotThrowAnyException(); } @@ -332,15 +335,113 @@ public class ConditionalTest implements WithAssertions { public void whereFalseOtherwiseThenThrowException() { //given assertThatExceptionOfType(IOException.class) - .isThrownBy(() -> Condition.where(false) + .isThrownBy(() -> where(false) .otherwiseThrow(new IOException())); } @Test public void whereTrueOtherwiseThenDoNotThrowException() throws Exception { assertThatCode(() -> - Condition.where(true) + where(true) .otherwiseThrow(new IOException())) .doesNotThrowAnyException(); } + + @Test + public void whereTrueConditionAndTrueConditionThenTrueCondition() { + //given + final Condition condition1 = Condition.where(true); + final Condition condition2 = Condition.where(true); + //when + final Condition result = condition1.and(condition2); + //then + assertThat(result).is(trueCondition); + } + + @Test + public void whereTrueConditionAndFalseConditionThenFalseCondition() { + //given + final Condition condition1 = Condition.where(true); + final Condition condition2 = Condition.where(false); + //when + final Condition result = condition1.and(condition2); + //then + assertThat(result).is(falseCondition); + } + + @Test + public void whereFalseConditionAndTrueConditionThenFalseCondition() { + //given + final Condition condition1 = Condition.where(false); + final Condition condition2 = Condition.where(true); + //when + final Condition result = condition1.and(condition2); + //then + assertThat(result).is(falseCondition); + } + + @Test + public void whereFalseConditionAndFalseConditionThenFalseCondition() { + //given + final Condition condition1 = Condition.where(false); + final Condition condition2 = Condition.where(false); + //when + final Condition result = condition1.and(condition2); + //then + assertThat(result).is(falseCondition); + } + + @Test + public void whereTrueConditionOrTrueConditionThenTrueCondition() { + //given + final Condition condition1 = Condition.where(true); + final Condition condition2 = Condition.where(true); + //when + final Condition result = condition1.or(condition2); + //then + assertThat(result).is(trueCondition); + } + + @Test + public void whereTrueConditionOrFalseConditionThenTrueCondition() { + //given + final Condition condition1 = Condition.where(true); + final Condition condition2 = Condition.where(false); + //when + final Condition result = condition1.or(condition2); + //then + assertThat(result).is(trueCondition); + } + + @Test + public void whereFalseConditionOrTrueConditionThenTrueCondition() { + //given + final Condition condition1 = Condition.where(false); + final Condition condition2 = Condition.where(true); + //when + final Condition result = condition1.or(condition2); + //then + assertThat(result).is(trueCondition); + } + + @Test + public void whereFalseConditionOrFalseConditionThenFalseCondition() { + //given + final Condition condition1 = Condition.where(false); + final Condition condition2 = Condition.where(false); + //when + final Condition result = condition1.or(condition2); + //then + assertThat(result).is(falseCondition); + } + + @Test + public void whereTrueWhenNotThenFalse() { + assertThat(Condition.where(true).not()).is(falseCondition); + } + + @Test + public void whereFalseWhenNotThenTriue() { + assertThat(Condition.where(false).not()).is(trueCondition); + } }