Spring/spring-statemachine
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Port samples tests to assertj

Browse Source
This commit is contained in:
Janne Valkealahti
2020-11-28 14:26:11 +00:00
parent 4965a4f980
commit b4c2f1849a
8 changed files with 222 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
build.gradle
View File

@@ -565,8 +565,6 @@ configure(sampleProjects()) {
}
testCompile 'org.springframework.boot:spring-boot-test'
testCompile 'org.springframework:spring-test'
testCompile 'org.hamcrest:hamcrest-core'
testCompile 'org.hamcrest:hamcrest-library'
testCompile("org.junit.jupiter:junit-jupiter-api")
testCompile("org.junit.jupiter:junit-jupiter-engine")
}

153
spring-statemachine-samples/cdplayer/src/test/java/demo/cdplayer/CdPlayerTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2015-2019 the original author or authors.
* Copyright 2015-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,12 +15,7 @@
*/
package demo.cdplayer;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.hamcrest.Matchers.startsWith;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.statemachine.TestUtils.doStartAndAssert;
import static org.springframework.statemachine.TestUtils.doStopAndAssert;
@@ -63,9 +58,9 @@ public class CdPlayerTests {
@Test
public void testInitialState() throws InterruptedException {
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(2));
assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(2);
assertThat(machine.getState().getIds()).containsExactly(States.IDLE, States.CLOSED);
assertLcdStatusStartsWith("No CD");
}
@@ -73,34 +68,34 @@ public class CdPlayerTests {
public void testEjectTwice() throws Exception {
listener.reset(1, 0, 0);
player.eject();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(machine.getState().getIds(), contains(States.IDLE, States.OPEN));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
assertThat(machine.getState().getIds()).containsExactly(States.IDLE, States.OPEN);
listener.reset(1, 0, 0);
player.eject();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
assertThat(machine.getState().getIds()).containsExactly(States.IDLE, States.CLOSED);
}
@Test
public void testPlayWithCdLoaded() throws Exception {
listener.reset(1, 0, 0);
player.eject();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
listener.reset(1, 0, 0);
player.load(library.getCollection().get(0));
player.eject();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
listener.reset(2, 0, 0);
player.play();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(2));
assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(2);
assertThat(machine.getState().getIds()).containsExactly(States.BUSY, States.PLAYING);
assertLcdStatusContains("cd1");
}
@@ -108,15 +103,15 @@ public class CdPlayerTests {
public void testPlayWithCdLoadedDeckOpen() throws Exception {
listener.reset(1, 0, 0);
player.eject();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
listener.reset(3, 0, 0);
player.load(library.getCollection().get(0));
player.play();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(3));
assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(3);
assertThat(machine.getState().getIds()).containsExactly(States.BUSY, States.PLAYING);
assertLcdStatusContains("cd1");
}
@@ -124,9 +119,9 @@ public class CdPlayerTests {
public void testPlayWithNoCdLoaded() throws Exception {
listener.reset(0, 0, 0);
player.play();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(0));
assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isZero();
assertThat(machine.getState().getIds()).containsExactly(States.IDLE, States.CLOSED);
assertLcdStatusStartsWith("No CD");
}
@@ -134,35 +129,35 @@ public class CdPlayerTests {
public void testPlayLcdTimeChanges() throws Exception {
listener.reset(1, 0, 0);
player.eject();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
listener.reset(1, 0, 0);
player.load(library.getCollection().get(0));
player.eject();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
listener.reset(2, 0, 0);
player.play();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(2));
assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(2);
assertThat(machine.getState().getIds()).containsExactly(States.BUSY, States.PLAYING);
assertLcdStatusContains("cd1");
listener.reset(0, 0, 0, 0, 1);
assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.transitionTimerCount, is(1));
assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.transitionTimerCount).isEqualTo(1);
assertLcdStatusContains("00:01");
listener.reset(0, 0, 0, 0, 1);
assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertLcdStatusContains("00:02");
assertThat(listener.transitionTimerCount, is(1));
assertThat(listener.transitionTimerCount).isEqualTo(1);
listener.reset(0, 0, 0, 0, 2);
assertThat(listener.transitionTimerLatch.await(4, TimeUnit.SECONDS), is(true));
assertThat(listener.transitionTimerCount, is(2));
assertThat(listener.transitionTimerLatch.await(4, TimeUnit.SECONDS)).isTrue();
assertThat(listener.transitionTimerCount).isEqualTo(2);
// ok we have some timing problems with
// this test, so for now just check it's
// not previous
@@ -173,45 +168,45 @@ public class CdPlayerTests {
public void testPlayPause() throws Exception {
listener.reset(1, 0, 0);
player.eject();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
listener.reset(1, 0, 0);
player.load(library.getCollection().get(0));
player.eject();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
listener.reset(2, 0, 0, 0, 1);
player.play();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(2));
assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.transitionTimerCount, is(1));
assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(2);
assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.transitionTimerCount).isEqualTo(1);
assertThat(machine.getState().getIds()).containsExactly(States.BUSY, States.PLAYING);
assertLcdStatusContains("cd1");
assertLcdStatusContains("00:01");
listener.reset(0, 0, 0, 1, 1);
assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertLcdStatusContains("00:02");
assertThat(listener.transitionTimerCount, is(1));
assertThat(listener.transitionTimerCount).isEqualTo(1);
listener.reset(1, 0, 0, 0);
player.pause();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
assertLcdStatusContains("00:02");
listener.reset(1, 0, 0, 1);
player.pause();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS)).isTrue();
listener.reset(0, 0, 0, 2, 2);
assertThat(listener.transitionTimerLatch.await(2100, TimeUnit.MILLISECONDS), is(true));
assertThat(listener.transitionTimerCount, is(2));
assertThat(listener.transitionTimerLatch.await(2100, TimeUnit.MILLISECONDS)).isTrue();
assertThat(listener.transitionTimerCount).isEqualTo(2);
assertLcdStatusNotContains("00:02");
}
@@ -219,26 +214,26 @@ public class CdPlayerTests {
public void testPlayStop() throws Exception {
listener.reset(1, 0, 0);
player.eject();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
listener.reset(1, 0, 0);
player.load(library.getCollection().get(0));
player.eject();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
listener.reset(2, 0, 0);
player.play();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(2));
assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(2);
assertThat(machine.getState().getIds()).containsExactly(States.BUSY, States.PLAYING);
listener.reset(2, 0, 0);
player.stop();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(2));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(2);
assertLcdStatusIs("cd1 ");
}
@@ -247,25 +242,25 @@ public class CdPlayerTests {
listener.reset(2, 0, 0);
player.eject();
player.play();
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(2));
assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED));
assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(2);
assertThat(machine.getState().getIds()).containsExactly(States.IDLE, States.CLOSED);
}
private void assertLcdStatusIs(String text) {
assertThat(player.getLdcStatus(), is(text));
assertThat(player.getLdcStatus()).isEqualTo(text);
}
private void assertLcdStatusStartsWith(String text) {
assertThat(player.getLdcStatus(), startsWith(text));
assertThat(player.getLdcStatus()).startsWith(text);
}
private void assertLcdStatusContains(String text) {
assertThat(player.getLdcStatus(), containsString(text));
assertThat(player.getLdcStatus()).contains(text);
}
private void assertLcdStatusNotContains(String text) {
assertThat(player.getLdcStatus(), not(containsString(text)));
assertThat(player.getLdcStatus()).doesNotContain(text);
}
@SuppressWarnings("unchecked")
@@ -279,7 +274,7 @@ public class CdPlayerTests {
library = context.getBean(Library.class);
listener = context.getBean(TestListener.class);
doStartAndAssert(machine);
assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true));
assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue();
}
@AfterEach

27
spring-statemachine-samples/persist/src/test/java/demo/persist/PersistTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2015-2019 the original author or authors.
* Copyright 2015-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,10 +15,7 @@
*/
package demo.persist;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.statemachine.TestUtils.doStartAndAssert;
import java.util.ArrayList;
@@ -56,7 +53,7 @@ public class PersistTests {
@Test
public void testNotStarted() throws Exception {
assertThat(commands.state(), is("No state"));
assertThat(commands.state()).isEqualTo("No state");
}
@Test
@@ -64,30 +61,30 @@ public class PersistTests {
TestListener listener = new TestListener();
machine.addStateListener(listener);
doStartAndAssert(machine);
assertThat(listener.stateChangedLatch.await(3, TimeUnit.SECONDS), is(true));
assertThat(listener.stateEnteredLatch.await(3, TimeUnit.SECONDS), is(true));
assertThat(machine.getState().getIds(), contains("PLACED"));
assertThat(listener.statesEntered.size(), is(1));
assertThat(listener.statesEntered.get(0).getId(), is("PLACED"));
assertThat(listener.statesExited.size(), is(0));
assertThat(listener.stateChangedLatch.await(3, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateEnteredLatch.await(3, TimeUnit.SECONDS)).isTrue();
assertThat(machine.getState().getIds()).containsExactly("PLACED");
assertThat(listener.statesEntered).hasSize(1);
assertThat(listener.statesEntered.get(0).getId()).isEqualTo("PLACED");
assertThat(listener.statesExited).isEmpty();
}
@Test
public void testInitialDbList() {
// dataOrder [id=1, state=PLACED]Order [id=2, state=PROCESSING]Order [id=3, state=SENT]Order [id=4, state=DELIVERED]
assertThat(persist.listDbEntries(), containsString("PLACED"));
assertThat(persist.listDbEntries()).contains("PLACED");
}
@Test
public void testUpdate1() {
persist.change(1, "PROCESS");
assertThat(persist.listDbEntries(), containsString("id=1, state=PROCESSING"));
assertThat(persist.listDbEntries()).contains("id=1, state=PROCESSING");
}
@Test
public void testUpdate2() {
persist.change(2, "SEND");
assertThat(persist.listDbEntries(), containsString("id=2, state=SENT"));
assertThat(persist.listDbEntries()).contains("id=2, state=SENT");
}
private static class TestListener extends StateMachineListenerAdapter<String, String> {

180
spring-statemachine-samples/showcase/src/test/java/demo/showcase/ShowcaseTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2015-2019 the original author or authors.
* Copyright 2015-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,9 +15,7 @@
*/
package demo.showcase;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.is;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll;
import static org.springframework.statemachine.TestUtils.doStartAndAssert;
import static org.springframework.statemachine.TestUtils.doStopAndAssert;
@@ -55,14 +53,14 @@ public class ShowcaseTests {
@Test
public void testInitialState() throws Exception {
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
assertThat(listener.statesEntered.size(), is(3));
assertThat(listener.statesEntered.get(0).getId(), is(States.S0));
assertThat(listener.statesEntered.get(1).getId(), is(States.S1));
assertThat(listener.statesEntered.get(2).getId(), is(States.S11));
assertThat(listener.statesExited.size(), is(0));
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
assertThat(listener.statesEntered).hasSize(3);
assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S0);
assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S1);
assertThat(listener.statesEntered.get(2).getId()).isEqualTo(States.S11);
assertThat(listener.statesExited).isEmpty();
}
@Test
@@ -72,10 +70,10 @@ public class ShowcaseTests {
doSendEventAndConsumeAll(machine, Events.A);
// machine.sendEvent(Events.A);
// variable foo is 0, guard denies transition
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(false));
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(false));
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(false));
assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isFalse();
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isFalse();
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isFalse();
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
}
@Test
@@ -83,12 +81,12 @@ public class ShowcaseTests {
testInitialState();
listener.reset(1, 2, 2);
doSendEventAndConsumeAll(machine, Events.B);
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.statesExited.size(), is(2));
assertThat(listener.statesEntered.size(), is(2));
assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.statesExited).hasSize(2);
assertThat(listener.statesEntered).hasSize(2);
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
}
@Test
@@ -106,14 +104,14 @@ public class ShowcaseTests {
listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
listener.stateExitedLatch.await(1, TimeUnit.SECONDS);
listener.transitionLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
assertThat(listener.statesEntered.size(), is(2));
assertThat(listener.statesEntered.get(0).getId(), is(States.S1));
assertThat(listener.statesEntered.get(1).getId(), is(States.S11));
assertThat(listener.statesExited.size(), is(2));
assertThat(listener.statesExited.get(0).getId(), is(States.S11));
assertThat(listener.statesExited.get(1).getId(), is(States.S1));
assertThat(listener.transitionCount, is(2));
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
assertThat(listener.statesEntered).hasSize(2);
assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S1);
assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S11);
assertThat(listener.statesExited).hasSize(2);
assertThat(listener.statesExited.get(0).getId()).isEqualTo(States.S11);
assertThat(listener.statesExited.get(1).getId()).isEqualTo(States.S1);
assertThat(listener.transitionCount).isEqualTo(2);
}
@Test
@@ -123,11 +121,11 @@ public class ShowcaseTests {
doSendEventAndConsumeAll(machine, Events.C);
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
assertThat(listener.statesEntered.size(), is(3));
assertThat(listener.statesEntered.get(0).getId(), is(States.S2));
assertThat(listener.statesEntered.get(1).getId(), is(States.S21));
assertThat(listener.statesEntered.get(2).getId(), is(States.S211));
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
assertThat(listener.statesEntered).hasSize(3);
assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S2);
assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S21);
assertThat(listener.statesEntered.get(2).getId()).isEqualTo(States.S211);
}
@Test
@@ -136,15 +134,15 @@ public class ShowcaseTests {
listener.reset(1, 3, 0);
doSendEventAndConsumeAll(machine, Events.C);
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
listener.reset(1, 2, 0);
doSendEventAndConsumeAll(machine, Events.C);
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
assertThat(listener.statesEntered.size(), is(2));
assertThat(listener.statesEntered.get(0).getId(), is(States.S1));
assertThat(listener.statesEntered.get(1).getId(), is(States.S11));
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
assertThat(listener.statesEntered).hasSize(2);
assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S1);
assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S11);
}
@Test
@@ -154,12 +152,12 @@ public class ShowcaseTests {
doSendEventAndConsumeAll(machine, Events.D);
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
assertThat(listener.statesEntered.size(), is(3));
assertThat(listener.statesEntered.get(0).getId(), is(States.S0));
assertThat(listener.statesEntered.get(1).getId(), is(States.S1));
assertThat(listener.statesEntered.get(2).getId(), is(States.S11));
assertThat(listener.statesExited.size(), is(3));
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
assertThat(listener.statesEntered).hasSize(3);
assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S0);
assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S1);
assertThat(listener.statesEntered.get(2).getId()).isEqualTo(States.S11);
assertThat(listener.statesExited).hasSize(3);
}
@Test
@@ -172,10 +170,10 @@ public class ShowcaseTests {
doSendEventAndConsumeAll(machine, Events.D);
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
assertThat(listener.statesEntered.size(), is(2));
assertThat(listener.statesEntered.get(0).getId(), is(States.S21));
assertThat(listener.statesEntered.get(1).getId(), is(States.S211));
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
assertThat(listener.statesEntered).hasSize(2);
assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S21);
assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S211);
}
@Test
@@ -186,11 +184,11 @@ public class ShowcaseTests {
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
listener.stateExitedLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S12));
assertThat(listener.statesEntered.size(), is(1));
assertThat(listener.statesEntered.get(0).getId(), is(States.S12));
assertThat(listener.statesExited.size(), is(1));
assertThat(listener.statesExited.get(0).getId(), is(States.S11));
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S12);
assertThat(listener.statesEntered).hasSize(1);
assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S12);
assertThat(listener.statesExited).hasSize(1);
assertThat(listener.statesExited.get(0).getId()).isEqualTo(States.S11);
}
@Test
@@ -199,21 +197,21 @@ public class ShowcaseTests {
listener.reset(1, 1, 1);
doSendEventAndConsumeAll(machine, Events.I);
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.statesEntered.size(), is(1));
assertThat(listener.statesExited.size(), is(1));
assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S12));
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.statesEntered).hasSize(1);
assertThat(listener.statesExited).hasSize(1);
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S12);
listener.reset(1, 3, 2);
doSendEventAndConsumeAll(machine, Events.I);
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.statesEntered.size(), is(3));
assertThat(listener.statesExited.size(), is(2));
assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S212));
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.statesEntered).hasSize(3);
assertThat(listener.statesExited).hasSize(2);
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S212);
}
@Test
@@ -222,8 +220,8 @@ public class ShowcaseTests {
listener.reset(0, 0, 0, 1);
doSendEventAndConsumeAll(machine, Events.H);
listener.transitionLatch.await(1, TimeUnit.SECONDS);
assertThat(listener.transitionCount, is(1));
assertThat(listener.transitions.get(0).getSource().getId(), is(States.S1));
assertThat(listener.transitionCount).isEqualTo(1);
assertThat(listener.transitions.get(0).getSource().getId()).isEqualTo(States.S1);
}
@Test
@@ -233,8 +231,8 @@ public class ShowcaseTests {
listener.reset(0, 0, 0, 1);
doSendEventAndConsumeAll(machine, Events.H);
listener.transitionLatch.await(1, TimeUnit.SECONDS);
assertThat(listener.transitionCount, is(1));
assertThat(listener.transitions.get(0).getSource().getId(), is(States.S0));
assertThat(listener.transitionCount).isEqualTo(1);
assertThat(listener.transitions.get(0).getSource().getId()).isEqualTo(States.S0);
}
@Test
@@ -246,8 +244,8 @@ public class ShowcaseTests {
doSendEventAndConsumeAll(machine, Events.H);
doSendEventAndConsumeAll(machine, Events.A);
listener.transitionLatch.await(1, TimeUnit.SECONDS);
assertThat(listener.transitionCount, is(1));
assertThat(listener.transitions.get(0).getSource().getId(), is(States.S0));
assertThat(listener.transitionCount).isEqualTo(1);
assertThat(listener.transitions.get(0).getSource().getId()).isEqualTo(States.S0);
}
@Test
@@ -256,12 +254,12 @@ public class ShowcaseTests {
listener.reset(1, 4, 3, 0);
doSendEventAndConsumeAll(machine, Events.E);
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
assertThat(listener.statesExited.size(), is(3));
assertThat(listener.statesEntered.size(), is(4));
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
assertThat(listener.statesExited).hasSize(3);
assertThat(listener.statesEntered).hasSize(4);
}
@Test
@@ -269,12 +267,12 @@ public class ShowcaseTests {
testInitialState();
listener.reset(1, 3, 2, 0);
doSendEventAndConsumeAll(machine, Events.F);
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
assertThat(listener.statesExited.size(), is(2));
assertThat(listener.statesEntered.size(), is(3));
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
assertThat(listener.statesExited).hasSize(2);
assertThat(listener.statesEntered).hasSize(3);
}
@Test
@@ -282,12 +280,12 @@ public class ShowcaseTests {
testInitialState();
listener.reset(1, 3, 2, 0);
doSendEventAndConsumeAll(machine, Events.G);
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
assertThat(listener.statesExited.size(), is(2));
assertThat(listener.statesEntered.size(), is(3));
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
assertThat(listener.statesExited).hasSize(2);
assertThat(listener.statesEntered).hasSize(3);
}
static class Config {

52
spring-statemachine-samples/tasks/src/test/java/demo/tasks/TasksTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2015-2019 the original author or authors.
* Copyright 2015-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,9 +15,7 @@
*/
package demo.tasks;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.is;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.statemachine.TestUtils.doStartAndAssert;
import static org.springframework.statemachine.TestUtils.doStopAndAssert;
@@ -64,36 +62,36 @@ public class TasksTests {
@Test
public void testInitialState() throws InterruptedException {
Map<Object, Object> variables = machine.getExtendedState().getVariables();
assertThat(variables.size(), is(0));
assertThat(variables).isEmpty();
}
@Test
public void testRunOnce() throws InterruptedException {
listener.reset(8, 8, 0);
tasks.run();
assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS), is(true));
assertThat(machine.getState().getIds(), contains(States.READY));
assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS)).isTrue();
assertThat(machine.getState().getIds()).containsExactly(States.READY);
Map<Object, Object> variables = machine.getExtendedState().getVariables();
assertThat(variables.size(), is(3));
assertThat(variables).hasSize(3);
}
@Test
public void testRunTwice() throws InterruptedException {
listener.reset(8, 8, 0);
tasks.run();
assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS), is(true));
assertThat(machine.getState().getIds(), contains(States.READY));
assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS)).isTrue();
assertThat(machine.getState().getIds()).containsExactly(States.READY);
Map<Object, Object> variables = machine.getExtendedState().getVariables();
assertThat(variables.size(), is(3));
assertThat(variables).hasSize(3);
listener.reset(8, 8, 0);
tasks.run();
assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS), is(true));
assertThat(machine.getState().getIds(), contains(States.READY));
assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS)).isTrue();
assertThat(machine.getState().getIds()).containsExactly(States.READY);
variables = machine.getExtendedState().getVariables();
assertThat(variables.size(), is(3));
assertThat(variables).hasSize(3);
}
@Test
@@ -106,8 +104,8 @@ public class TasksTests {
boolean await = listener.stateEnteredLatch.await(8, TimeUnit.SECONDS);
String reason = "Machine was " + machine + " " + StringUtils.collectionToCommaDelimitedString(listener.statesEntered);
assertThat(reason , await, is(true));
assertThat(machine.getState().getIds(), contains(States.READY));
assertThat(await).isTrue().withFailMessage(reason);
assertThat(machine.getState().getIds()).containsExactly(States.READY);
log.info("testRunSmoke SMOKE STOP " + i);
}
}
@@ -117,9 +115,9 @@ public class TasksTests {
listener.reset(10, 0, 0);
tasks.fail("T1");
tasks.run();
assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(10));
assertThat(machine.getState().getIds(), contains(States.READY));
assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(10);
assertThat(machine.getState().getIds()).containsExactly(States.READY);
}
@Test
@@ -127,16 +125,16 @@ public class TasksTests {
listener.reset(10, 0, 0);
tasks.fail("T2");
tasks.run();
assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS)).isTrue();
Map<Object, Object> variables = machine.getExtendedState().getVariables();
assertThat(variables.size(), is(3));
assertThat(variables).hasSize(3);
assertThat(machine.getState().getIds(), contains(States.ERROR, States.MANUAL));
assertThat(machine.getState().getIds()).containsExactly(States.ERROR, States.MANUAL);
listener.reset(1, 0, 0);
tasks.fix();
assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS), is(true));
assertThat(machine.getState().getIds(), contains(States.READY));
assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS)).isTrue();
assertThat(machine.getState().getIds()).containsExactly(States.READY);
}
@SuppressWarnings("unchecked")
@@ -149,9 +147,9 @@ public class TasksTests {
tasks = context.getBean(Tasks.class);
listener = context.getBean(TestListener.class);
doStartAndAssert(machine);
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat(listener.stateChangedCount, is(1));
assertThat(machine.getState().getIds(), contains(States.READY));
assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
assertThat(listener.stateChangedCount).isEqualTo(1);
assertThat(machine.getState().getIds()).containsExactly(States.READY);
}
@AfterEach

16
spring-statemachine-samples/turnstile/src/test/java/demo/turnstile/TurnstileTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2015-2019 the original author or authors.
* Copyright 2015-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,9 +15,7 @@
*/
package demo.turnstile;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.is;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.statemachine.TestUtils.doStartAndAssert;
import static org.springframework.statemachine.TestUtils.doStopAndAssert;
@@ -56,7 +54,7 @@ public class TurnstileTests {
@Test
public void testNotStarted() throws Exception {
assertThat(commands.state(), is("No state"));
assertThat(commands.state()).isEqualTo("No state");
}
@Test
@@ -64,10 +62,10 @@ public class TurnstileTests {
doStartAndAssert(machine);
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.LOCKED));
assertThat(listener.statesEntered.size(), is(1));
assertThat(listener.statesEntered.get(0).getId(), is(States.LOCKED));
assertThat(listener.statesExited.size(), is(0));
assertThat(machine.getState().getIds()).containsExactly(States.LOCKED);
assertThat(listener.statesEntered).hasSize(1);
assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.LOCKED);
assertThat(listener.statesExited).isEmpty();
}
static class Config {

8
spring-statemachine-samples/turnstilereactive/src/test/java/demo/turnstilereactive/TurnstileReactiveTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2019 the original author or authors.
* Copyright 2019-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
*/
package demo.turnstilereactive;
import static org.hamcrest.CoreMatchers.containsString;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -41,7 +41,9 @@ public class TurnstileReactiveTests {
@Test
public void testState() {
webClient.get().uri("/state").exchange()
.expectBody(String.class).value(containsString("LOCKED"));
.expectBody(String.class).value(body -> {
assertThat(body).contains("LOCKED");
});
}
@Test

22
spring-statemachine-samples/washer/src/test/java/demo/washer/WasherTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2015-2019 the original author or authors.
* Copyright 2015-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -15,9 +15,7 @@
*/
package demo.washer;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.is;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll;
import static org.springframework.statemachine.TestUtils.doStartAndAssert;
import static org.springframework.statemachine.TestUtils.doStopAndAssert;
@@ -57,11 +55,11 @@ public class WasherTests {
public void testInitialState() throws Exception {
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.RUNNING, States.WASHING));
assertThat(listener.statesEntered.size(), is(2));
assertThat(listener.statesEntered.get(0).getId(), is(States.RUNNING));
assertThat(listener.statesEntered.get(1).getId(), is(States.WASHING));
assertThat(listener.statesExited.size(), is(0));
assertThat(machine.getState().getIds()).containsExactly(States.RUNNING, States.WASHING);
assertThat(listener.statesEntered).hasSize(2);
assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.RUNNING);
assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.WASHING);
assertThat(listener.statesExited).isEmpty();
}
@Test
@@ -69,7 +67,7 @@ public class WasherTests {
listener.reset(1, 0, 0);
doSendEventAndConsumeAll(machine, Events.RINSE);
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.RUNNING, States.RINSING));
assertThat(machine.getState().getIds()).containsExactly(States.RUNNING, States.RINSING);
}
@Test
@@ -81,7 +79,7 @@ public class WasherTests {
listener.reset(1, 0, 0);
doSendEventAndConsumeAll(machine, Events.CUTPOWER);
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.POWEROFF));
assertThat(machine.getState().getIds()).containsExactly(States.POWEROFF);
}
@Test
@@ -97,7 +95,7 @@ public class WasherTests {
listener.reset(1, 0, 0);
doSendEventAndConsumeAll(machine, Events.RESTOREPOWER);
listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
assertThat(machine.getState().getIds(), contains(States.RUNNING, States.RINSING));
assertThat(machine.getState().getIds()).containsExactly(States.RUNNING, States.RINSING);
}
static class Config {