Skip to content

Commit 476f101

Browse files
jnapejnape
committed
Reformatting
1 parent 7d35b67 commit 476f101

File tree

6 files changed

+183
-168
lines changed

6 files changed

+183
-168
lines changed

‎src/test/java/com/jnape/palatable/lambda/functor/builtin/StateTest.java

Lines changed: 21 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,5 @@
11
package com.jnape.palatable.lambda.functor.builtin;
22

3-
import com.jnape.palatable.lambda.adt.Unit;
4-
import com.jnape.palatable.lambda.adt.hlist.Tuple2;
5-
import com.jnape.palatable.lambda.functions.Fn1;
63
import com.jnape.palatable.traitor.annotations.TestTraits;
74
import com.jnape.palatable.traitor.runners.Traits;
85
import org.junit.Test;
@@ -17,8 +14,12 @@
1714

1815
import static com.jnape.palatable.lambda.adt.Unit.UNIT;
1916
import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
17+
import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
2018
import static com.jnape.palatable.lambda.functions.builtin.fn2.Into.into;
21-
import static org.junit.Assert.assertEquals;
19+
import static org.junit.Assert.assertThat;
20+
import static testsupport.matchers.StateMatcher.whenEvaluated;
21+
import static testsupport.matchers.StateMatcher.whenExecuted;
22+
import static testsupport.matchers.StateMatcher.whenRun;
2223
import static testsupport.traits.Equivalence.equivalence;
2324

2425
@RunWith(Traits.class)
@@ -36,71 +37,65 @@ public Equivalence<State<String, Integer>> testSubject() {
3637

3738
@Test
3839
public void eval() {
39-
State<Integer, Unit> state = State.put(0);
40-
assertEquals(state.run(1)._1(), state.eval(1));
40+
assertThat(State.gets(id()), whenEvaluated(1, 1));
4141
}
4242

4343
@Test
4444
public void exec() {
45-
State<Integer, Unit> state = State.put(0);
46-
assertEquals(state.run(1)._2(), state.exec(1));
45+
assertThat(State.modify(x -> x + 1), whenExecuted(1, 2));
4746
}
4847

4948
@Test
5049
public void get() {
51-
assertEquals(tuple(1, 1), State.<Integer>get().run(1));
50+
assertThat(State.get(), whenRun(1, 1, 1));
5251
}
5352

5453
@Test
5554
public void put() {
56-
assertEquals(tuple(UNIT, 1), State.put(1).run(1));
55+
assertThat(State.put(1), whenRun(1, UNIT, 1));
5756
}
5857

5958
@Test
6059
public void gets() {
61-
assertEquals(tuple(0, "0"), State.<String, Integer>gets(Integer::parseInt).run("0"));
60+
assertThat(State.gets(Integer::parseInt), whenRun("0", 0, "0"));
6261
}
6362

6463
@Test
6564
public void modify() {
66-
assertEquals(tuple(UNIT, 1), State.<Integer>modify(x -> x + 1).run(0));
65+
assertThat(State.modify(x -> x + 1), whenRun(0, UNIT, 1));
6766
}
6867

6968
@Test
7069
public void state() {
71-
assertEquals(tuple(1, UNIT), State.<Unit, Integer>state(1).run(UNIT));
72-
assertEquals(tuple(1, -1), State.<Integer, Integer>state(x -> tuple(x + 1, x - 1)).run(0));
70+
assertThat(State.state(1), whenRun(UNIT, 1, UNIT));
71+
assertThat(State.state(x -> tuple(x + 1, x - 1)), whenRun(0, 1, -1));
7372
}
7473

7574
@Test
7675
public void stateAccumulation() {
77-
State<Integer, Integer> counter = State.<Integer>get().flatMap(i -> State.put(i + 1).discardL(State.state(i)));
78-
assertEquals(tuple(0, 1), counter.run(0));
76+
assertThat(State.<Integer>get().flatMap(i -> State.put(i + 1).discardL(State.state(i))),
77+
whenRun(0, 0, 1));
7978
}
8079

8180
@Test
8281
public void zipOrdering() {
83-
Tuple2<Integer, String> result = State.<String, Integer>state(s -> tuple(0, s + "1"))
84-
.zip(State.<String, Fn1<? super Integer, ? extends Integer>>state(s -> tuple(x -> x + 1, s + "2")))
85-
.run("_");
86-
assertEquals(tuple(1, "_12"), result);
82+
assertThat(State.<String, Integer>state(s -> tuple(0, s + "1"))
83+
.zip(State.state(s -> tuple(x -> x + 1, s + "2"))),
84+
whenRun("_", 1, "_12"));
8785
}
8886

8987
@Test
9088
public void withState() {
91-
State<Integer, Integer> modified = State.<Integer>get().withState(x -> x + 1);
92-
assertEquals(tuple(1, 1), modified.run(0));
89+
assertThat(State.<Integer>get().withState(x -> x + 1), whenRun(0, 1, 1));
9390
}
9491

9592
@Test
9693
public void mapState() {
97-
State<Integer, Integer> modified = State.<Integer>get().mapState(into((a, s) -> tuple(a + 1, s + 2)));
98-
assertEquals(tuple(1, 2), modified.run(0));
94+
assertThat(State.<Integer>get().mapState(into((a, s) -> tuple(a + 1, s + 2))), whenRun(0, 1, 2));
9995
}
10096

10197
@Test
10298
public void staticPure() {
103-
State<String, Integer> state = State.<String>pureState().apply(1);
104-
assertEquals(tuple(1, "foo"), state.run("foo"));
99+
assertThat(State.<String>pureState().apply(1), whenRun("foo", 1, "foo"));
105100
}
106101
}

‎src/test/java/com/jnape/palatable/lambda/matchers/StateMatcherTest.java

Lines changed: 10 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,34 +1,35 @@
11
package com.jnape.palatable.lambda.matchers;
22

3-
import com.jnape.palatable.lambda.adt.Either;
43
import org.junit.Test;
54

65
import static com.jnape.palatable.lambda.adt.Either.left;
6+
import static com.jnape.palatable.lambda.adt.Either.right;
77
import static com.jnape.palatable.lambda.functor.builtin.State.state;
88
import static org.hamcrest.MatcherAssert.assertThat;
99
import static org.hamcrest.core.IsEqual.equalTo;
1010
import static testsupport.matchers.LeftMatcher.isLeftThat;
1111
import static testsupport.matchers.RightMatcher.isRightThat;
12-
import static testsupport.matchers.StateMatcher.*;
12+
import static testsupport.matchers.StateMatcher.whenEvaluatedWith;
13+
import static testsupport.matchers.StateMatcher.whenExecutedWith;
14+
import static testsupport.matchers.StateMatcher.whenRunWith;
1315

1416
public class StateMatcherTest {
1517

1618
@Test
1719
public void whenEvalWithMatcher() {
18-
assertThat(state(Either.right(1)),
19-
whenEvaluatedWith("0", isRightThat(equalTo(1))));
20+
assertThat(state(right(1)),
21+
whenEvaluatedWith("0", isRightThat(equalTo(1))));
2022
}
2123

2224
@Test
2325
public void whenExecWithMatcher() {
24-
assertThat(state(Either.right(1)),
25-
whenExecutedWith(left("0"), isLeftThat(equalTo("0"))));
26+
assertThat(state(right(1)),
27+
whenExecutedWith(left("0"), isLeftThat(equalTo("0"))));
2628
}
2729

2830
@Test
2931
public void whenRunWithMatcher() {
30-
assertThat(state(Either.right(1)),
31-
whenRunWith(left("0"), isRightThat(equalTo(1)), isLeftThat(equalTo("0"))));
32+
assertThat(state(right(1)),
33+
whenRunWith(left("0"), isRightThat(equalTo(1)), isLeftThat(equalTo("0"))));
3234
}
33-
3435
}

‎src/test/java/com/jnape/palatable/lambda/matchers/StateTMatcherTest.java

Lines changed: 18 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,15 @@
11
package com.jnape.palatable.lambda.matchers;
22

3-
import com.jnape.palatable.lambda.adt.Either;
4-
import com.jnape.palatable.lambda.monad.transformer.builtin.StateT;
3+
import org.hamcrest.core.IsEqual;
54
import org.junit.Test;
6-
import testsupport.matchers.StateTMatcher;
75

86
import java.util.concurrent.atomic.AtomicInteger;
97

108
import static com.jnape.palatable.lambda.adt.Either.left;
119
import static com.jnape.palatable.lambda.adt.Either.right;
1210
import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
1311
import static com.jnape.palatable.lambda.io.IO.io;
12+
import static com.jnape.palatable.lambda.monad.transformer.builtin.StateT.gets;
1413
import static com.jnape.palatable.lambda.monad.transformer.builtin.StateT.stateT;
1514
import static org.hamcrest.CoreMatchers.not;
1615
import static org.hamcrest.MatcherAssert.assertThat;
@@ -19,62 +18,64 @@
1918
import static testsupport.matchers.IOMatcher.yieldsValue;
2019
import static testsupport.matchers.LeftMatcher.isLeftThat;
2120
import static testsupport.matchers.RightMatcher.isRightThat;
22-
import static testsupport.matchers.StateTMatcher.*;
21+
import static testsupport.matchers.StateTMatcher.whenEvaluatedWith;
22+
import static testsupport.matchers.StateTMatcher.whenExecutedWith;
23+
import static testsupport.matchers.StateTMatcher.whenRunWith;
24+
import static testsupport.matchers.StateTMatcher.whenRunWithBoth;
2325

2426
public class StateTMatcherTest {
2527

2628
@Test
2729
public void whenEvaluatedWithMatcher() {
2830
assertThat(stateT(right(1)),
29-
whenEvaluatedWith("0", isRightThat(equalTo(1))));
31+
whenEvaluatedWith("0", isRightThat(equalTo(1))));
3032
}
3133

3234
@Test
3335
public void whenEvaluatedWithMatcherOnObject() {
3436
assertThat(stateT(right(1)),
35-
whenEvaluatedWith("0", not(equalTo(new Object()))));
37+
whenEvaluatedWith("0", not(equalTo(new Object()))));
3638
}
3739

3840
@Test
3941
public void whenExecutedWithMatcher() {
4042
assertThat(stateT(right(1)),
41-
whenExecutedWith(left("0"), isRightThat(isLeftThat(equalTo("0")))));
43+
whenExecutedWith(left("0"), isRightThat(isLeftThat(equalTo("0")))));
4244
}
4345

44-
4546
@Test
4647
public void whenExecutedWithMatcherOnObject() {
4748
assertThat(stateT(right(1)),
48-
whenExecutedWith(left("0"), not(equalTo(new Object()))));
49+
whenExecutedWith(left("0"), not(equalTo(new Object()))));
4950
}
5051

5152
@Test
53+
@SuppressWarnings("RedundantTypeArguments")
5254
public void whenRunWithUsingTwoMatchers() {
53-
//noinspection RedundantTypeArguments
5455
assertThat(stateT(right(1)),
55-
StateTMatcher.<Either<String, Object>, Either<Object, ?>, Integer, Either<Object, Integer>, Either<Object, Either<String, Object>>>whenRunWithBoth(left("0"),
56-
isRightThat(equalTo(1)),
57-
isRightThat(isLeftThat(equalTo("0")))));
56+
whenRunWithBoth(left("0"),
57+
isRightThat(IsEqual.<Integer>equalTo(1)),
58+
isRightThat(isLeftThat(equalTo("0")))));
5859
}
5960

6061
@Test
6162
public void whenRunWithUsingOneTupleMatcher() {
6263
assertThat(stateT(right(1)),
63-
whenRunWith(left("0"),
64-
isRightThat(equalTo(tuple(1, left("0"))))));
64+
whenRunWith(left("0"),
65+
isRightThat(equalTo(tuple(1, left("0"))))));
6566
}
6667

6768
@Test
6869
public void whenRunWithUsingOneTupleMatcherOnObject() {
6970
assertThat(stateT(right(1)),
70-
whenRunWith(left("0"), not(equalTo(new Object()))));
71+
whenRunWith(left("0"), not(equalTo(new Object()))));
7172
}
7273

7374
@Test
7475
public void onlyRunsStateOnceWithTupleMatcher() {
7576
AtomicInteger count = new AtomicInteger(0);
7677

77-
assertThat(StateT.gets(s -> io(count::incrementAndGet)), whenRunWith(0, yieldsValue(equalTo(tuple(1, 0)))));
78+
assertThat(gets(s -> io(count::incrementAndGet)), whenRunWith(0, yieldsValue(equalTo(tuple(1, 0)))));
7879
assertEquals(1, count.get());
7980
}
8081
}

0 commit comments

Comments
 (0)