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

Port data tests to assertj

Browse Source
This commit is contained in:
Janne Valkealahti
2020-11-28 14:43:55 +00:00
parent d19b5d298a
commit 2fa227985c
4 changed files with 97 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
spring-statemachine-data/jpa/src/test/java/org/springframework/statemachine/data/jpa/JpaRepositoryTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2016-2019 the original author or authors.
* Copyright 2016-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 org.springframework.statemachine.data.jpa;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.hamcrest.MatcherAssert.assertThat;
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.resolveMachine;
@@ -65,24 +63,24 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
JpaStateRepository statesRepository = context.getBean(JpaStateRepository.class);
JpaRepositoryState stateS1 = new JpaRepositoryState("S1");
JpaRepositoryState stateS2 = new JpaRepositoryState("S2");
assertThat(statesRepository.count(), is(0l));
assertThat(statesRepository.count()).isEqualTo(0l);
statesRepository.save(stateS1);
statesRepository.save(stateS2);
assertThat(statesRepository.count(), is(2l));
assertThat(statesRepository.count()).isEqualTo(2l);
JpaTransitionRepository transitionsRepository = context.getBean(JpaTransitionRepository.class);
JpaRepositoryTransition transition = new JpaRepositoryTransition(stateS1, stateS2, "E1");
transition.setKind(TransitionKind.EXTERNAL);
transitionsRepository.save(transition);
assertThat(statesRepository.count(), is(2l));
assertThat(statesRepository.count()).isEqualTo(2l);
JpaRepositoryTransition transition2 = transitionsRepository.findAll().iterator().next();
assertThat(transition2.getSource().getState(), is("S1"));
assertThat(transition2.getTarget().getState(), is("S2"));
assertThat(transition2.getEvent(), is("E1"));
assertThat(transition2.getKind(), is(TransitionKind.EXTERNAL));
assertThat(transition2.getSource().getState()).isEqualTo("S1");
assertThat(transition2.getTarget().getState()).isEqualTo("S2");
assertThat(transition2.getEvent()).isEqualTo("E1");
assertThat(transition2.getKind()).isEqualTo(TransitionKind.EXTERNAL);
context.close();
}
@@ -101,16 +99,16 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
@SuppressWarnings("unchecked")
StateRepository<? extends RepositoryState> statesRepository2 = context.getBean(StateRepository.class);
Iterable<? extends RepositoryState> findAll = statesRepository2.findAll();
assertThat(findAll.iterator().next().getState(), is("S1"));
assertThat(findAll.iterator().next().getState()).isEqualTo("S1");
@SuppressWarnings("unchecked")
TransitionRepository<RepositoryTransition> transitionsRepository = context.getBean(TransitionRepository.class);
RepositoryTransition transition = new JpaRepositoryTransition(state1, state2, "E1");
transitionsRepository.save(transition);
RepositoryTransition transition2 = transitionsRepository.findAll().iterator().next();
assertThat(transition2.getSource().getState(), is("S1"));
assertThat(transition2.getTarget().getState(), is("S2"));
assertThat(transition2.getEvent(), is("E1"));
assertThat(transition2.getSource().getState()).isEqualTo("S1");
assertThat(transition2.getTarget().getState()).isEqualTo("S2");
assertThat(transition2.getEvent()).isEqualTo("E1");
context.close();
}
@@ -132,10 +130,10 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
List<JpaRepositoryState> findByMachineId1 = statesRepository.findByMachineId("machine1");
List<JpaRepositoryState> findByMachineId2 = statesRepository.findByMachineId("machine2");
assertThat(findByMachineId1.size(), is(2));
assertThat(findByMachineId2.size(), is(2));
assertThat(findByMachineId1.get(0).getMachineId(), is("machine1"));
assertThat(findByMachineId2.get(0).getMachineId(), is("machine2"));
assertThat(findByMachineId1).hasSize(2);
assertThat(findByMachineId2).hasSize(2);
assertThat(findByMachineId1.get(0).getMachineId()).isEqualTo("machine1");
assertThat(findByMachineId2.get(0).getMachineId()).isEqualTo("machine2");
JpaTransitionRepository transitionsRepository = context.getBean(JpaTransitionRepository.class);
@@ -146,10 +144,10 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
List<JpaRepositoryTransition> findByMachineId3 = transitionsRepository.findByMachineId("machine1");
List<JpaRepositoryTransition> findByMachineId4 = transitionsRepository.findByMachineId("machine2");
assertThat(findByMachineId3.size(), is(1));
assertThat(findByMachineId4.size(), is(1));
assertThat(findByMachineId3.get(0).getMachineId(), is("machine1"));
assertThat(findByMachineId4.get(0).getMachineId(), is("machine2"));
assertThat(findByMachineId3).hasSize(1);
assertThat(findByMachineId4).hasSize(1);
assertThat(findByMachineId3.get(0).getMachineId()).isEqualTo("machine1");
assertThat(findByMachineId4.get(0).getMachineId()).isEqualTo("machine2");
context.close();
}
@@ -165,10 +163,10 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
action1.setName("action1");
actionsRepository.save(action1);
assertThat(actionsRepository.count(), is(1l));
assertThat(actionsRepository.count()).isEqualTo(1l);
JpaRepositoryAction action11 = actionsRepository.findAll().iterator().next();
assertThat(action1.getSpel(), is(action11.getSpel()));
assertThat(action1.getName(), is(action11.getName()));
assertThat(action1.getSpel()).isEqualTo(action11.getSpel());
assertThat(action1.getName()).isEqualTo(action11.getName());
}
@Test
@@ -197,16 +195,16 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
transitionsRepository.save(transition);
JpaRepositoryTransition transition2 = transitionsRepository.findAll().iterator().next();
assertThat(transition2.getSource().getState(), is("S1"));
assertThat(transition2.getTarget().getState(), is("S2"));
assertThat(transition2.getEvent(), is("E1"));
assertThat(transition2.getSource().getState()).isEqualTo("S1");
assertThat(transition2.getTarget().getState()).isEqualTo("S2");
assertThat(transition2.getEvent()).isEqualTo("E1");
assertThat(actionsRepository.count(), is(1l));
assertThat(actionsRepository.count()).isEqualTo(1l);
JpaRepositoryAction action11 = actionsRepository.findAll().iterator().next();
assertThat(action1.getName(), is(action11.getName()));
assertThat(action1.getName()).isEqualTo(action11.getName());
assertThat(transition2.getActions().size(), is(1));
assertThat(transition2.getActions()).hasSize(1);
}
@Test
@@ -221,12 +219,12 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
JpaRepositoryAction action1 = new JpaRepositoryAction();
action1.setName("action1");
actionsRepository.save(action1);
assertThat(actionsRepository.count(), is(1l));
assertThat(actionsRepository.count()).isEqualTo(1l);
JpaRepositoryAction action2 = new JpaRepositoryAction();
action2.setName("action2");
actionsRepository.save(action2);
assertThat(actionsRepository.count(), is(2l));
assertThat(actionsRepository.count()).isEqualTo(2l);
JpaRepositoryState stateS1 = new JpaRepositoryState("S1");
stateS1.setEntryActions(new HashSet<>(Arrays.asList(action1, action2)));
@@ -244,12 +242,12 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
JpaRepositoryTransition transition1 = new JpaRepositoryTransition(stateS1, stateS2, "E1");
transition1.setActions(new HashSet<>(Arrays.asList(action1, action2)));
transitionsRepository.save(transition1);
assertThat(transitionsRepository.count(), is(1l));
assertThat(transitionsRepository.count()).isEqualTo(1l);
JpaRepositoryTransition transition2 = new JpaRepositoryTransition(stateS2, stateS3, "E2");
transition2.setActions(new HashSet<>(Arrays.asList(action1, action2)));
transitionsRepository.save(transition2);
assertThat(transitionsRepository.count(), is(2l));
assertThat(transitionsRepository.count()).isEqualTo(2l);
}
@Test
@@ -264,14 +262,14 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
machine1.setState("S1");
machine1.setStateMachineContext(new byte[] { 0 });
assertThat(stateMachineRepository.count(), is(0l));
assertThat(stateMachineRepository.count()).isEqualTo(0l);
stateMachineRepository.save(machine1);
assertThat(stateMachineRepository.count(), is(1l));
assertThat(stateMachineRepository.count()).isEqualTo(1l);
JpaRepositoryStateMachine machine1x = stateMachineRepository.findById("machine1").get();
assertThat(machine1x.getMachineId(), is(machine1.getMachineId()));
assertThat(machine1x.getState(), is(machine1.getState()));
assertThat(machine1x.getStateMachineContext().length, is(1));
assertThat(machine1x.getMachineId()).isEqualTo(machine1.getMachineId());
assertThat(machine1x.getState()).isEqualTo(machine1.getState());
assertThat(machine1x.getStateMachineContext().length).isEqualTo(1);
}
@Override
@@ -297,11 +295,11 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
StateMachine<String, String> stateMachine = resolveMachine(context);
doStartAndAssert(stateMachine);
assertThat(stateMachine.getState().getId(), is("S1"));
assertThat(stateMachine.getState().getId()).isEqualTo("S1");
doSendEventAndConsumeAll(stateMachine, "E1");
assertThat(stateMachine.getState().getId(), is("S2"));
assertThat(stateMachine.getState().getId()).isEqualTo("S2");
doSendEventAndConsumeAll(stateMachine, "E2");
assertThat(stateMachine.getState().getId(), is("S1"));
assertThat(stateMachine.getState().getId()).isEqualTo("S1");
}
@Test
@@ -311,11 +309,11 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
StateMachine<PersistTestStates, PersistTestEvents> stateMachine = resolveMachine(context);
doStartAndAssert(stateMachine);
assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1));
assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1);
doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E1);
assertThat(stateMachine.getState().getId(), is(PersistTestStates.S2));
assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S2);
doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E2);
assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1));
assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1);
}
@Test
@@ -327,18 +325,18 @@ public class JpaRepositoryTests extends AbstractRepositoryTests {
StateMachine<String, String> stateMachine = context.getBean(StateMachine.class);
doStartAndAssert(stateMachine);
assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S10", "S20"));
assertThat(stateMachine.getState().getIds()).containsOnly("S10", "S20");
doSendEventAndConsumeAll(stateMachine, "E1");
assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S11", "S21"));
assertThat(stateMachine.getState().getIds()).containsOnly("S11", "S21");
assertThat(stateMachineRepository.count(), is(3l));
assertThat(stateMachineRepository.count()).isEqualTo(3l);
List<String> ids = StreamSupport.stream(stateMachineRepository.findAll().spliterator(), false)
.map(jrsm -> jrsm.getMachineId()).collect(Collectors.toList());
assertThat(ids.size(), is(3));
assertThat(ids).hasSize(3);
// [null#238e8cc0-a932-4583-b696-2c057e5ebefe, null#486e20be-853e-4e4d-9a68-c62c061469ef, testid]
assertThat(ids, containsInAnyOrder("testid", "testid#R1", "testid#R2"));
assertThat(ids).containsOnly("testid", "testid#R1", "testid#R2");
}

44
spring-statemachine-data/mongodb/src/test/java/org/springframework/statemachine/data/mongodb/MongoDbRepositoryTests.java
View File

@@ -15,9 +15,7 @@
*/
package org.springframework.statemachine.data.mongodb;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.MatcherAssert.assertThat;
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.resolveMachine;
@@ -73,18 +71,18 @@ public class MongoDbRepositoryTests extends AbstractRepositoryTests {
MongoDbStateRepository stateRepository = context.getBean(MongoDbStateRepository.class);
MongoDbTransitionRepository transitionRepository = context.getBean(MongoDbTransitionRepository.class);
assertThat(stateRepository.count(), is(3l));
assertThat(transitionRepository.count(), is(3l));
assertThat(stateRepository.count()).isEqualTo(3l);
assertThat(transitionRepository.count()).isEqualTo(3l);
List<MongoDbRepositoryState> states = new ArrayList<>();
stateRepository.findAll().iterator().forEachRemaining(states::add);
List<MongoDbRepositoryTransition> transitions = new ArrayList<>();
transitionRepository.findAll().iterator().forEachRemaining(transitions::add);
assertThat(states.size(), is(3));
assertThat(transitions.size(), is(3));
assertThat(states).hasSize(3);
assertThat(transitions).hasSize(3);
MongoDbRepositoryTransition transition1 = transitions.get(0);
assertThat(transition1.getSource(), notNullValue());
assertThat(transition1.getTarget(), notNullValue());
assertThat(transition1.getSource()).isNotNull();
assertThat(transition1.getTarget()).isNotNull();
}
@Test
@@ -95,27 +93,27 @@ public class MongoDbRepositoryTests extends AbstractRepositoryTests {
MongoDbStateRepository statesRepository = context.getBean(MongoDbStateRepository.class);
MongoDbRepositoryState stateS1 = new MongoDbRepositoryState("S1");
MongoDbRepositoryState stateS2 = new MongoDbRepositoryState("S2");
assertThat(statesRepository.count(), is(0l));
assertThat(statesRepository.count()).isEqualTo(0l);
statesRepository.save(stateS1);
statesRepository.save(stateS2);
assertThat(statesRepository.count(), is(2l));
assertThat(statesRepository.count()).isEqualTo(2l);
MongoDbTransitionRepository transitionsRepository = context.getBean(MongoDbTransitionRepository.class);
MongoDbRepositoryTransition transition = new MongoDbRepositoryTransition(stateS1, stateS2, "E1");
transition.setKind(TransitionKind.EXTERNAL);
transitionsRepository.save(transition);
assertThat(statesRepository.count(), is(2l));
assertThat(statesRepository.count()).isEqualTo(2l);
MongoDbRepositoryTransition transition2 = transitionsRepository.findAll().iterator().next();
assertThat(transition2.getSource().getState(), is("S1"));
assertThat(transition2.getTarget().getState(), is("S2"));
assertThat(transition2.getEvent(), is("E1"));
assertThat(transition2.getKind(), is(TransitionKind.EXTERNAL));
assertThat(transition2.getSource().getState()).isEqualTo("S1");
assertThat(transition2.getTarget().getState()).isEqualTo("S2");
assertThat(transition2.getEvent()).isEqualTo("E1");
assertThat(transition2.getKind()).isEqualTo(TransitionKind.EXTERNAL);
List<MongoDbRepositoryState> findByMachineId = statesRepository.findByMachineId("");
assertThat(findByMachineId.size(), is(2));
assertThat(findByMachineId).hasSize(2);
context.close();
}
@@ -127,11 +125,11 @@ public class MongoDbRepositoryTests extends AbstractRepositoryTests {
StateMachine<String, String> stateMachine = resolveMachine(context);
doStartAndAssert(stateMachine);
assertThat(stateMachine.getState().getId(), is("S1"));
assertThat(stateMachine.getState().getId()).isEqualTo("S1");
doSendEventAndConsumeAll(stateMachine, "E1");
assertThat(stateMachine.getState().getId(), is("S2"));
assertThat(stateMachine.getState().getId()).isEqualTo("S2");
doSendEventAndConsumeAll(stateMachine, "E2");
assertThat(stateMachine.getState().getId(), is("S1"));
assertThat(stateMachine.getState().getId()).isEqualTo("S1");
}
@Test
@@ -141,11 +139,11 @@ public class MongoDbRepositoryTests extends AbstractRepositoryTests {
StateMachine<PersistTestStates, PersistTestEvents> stateMachine = resolveMachine(context);
doStartAndAssert(stateMachine);
assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1));
assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1);
doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E1);
assertThat(stateMachine.getState().getId(), is(PersistTestStates.S2));
assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S2);
doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E2);
assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1));
assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1);
}
@Override

44
spring-statemachine-data/redis/src/test/java/org/springframework/statemachine/data/redis/RedisRepositoryTests.java
View File

@@ -15,9 +15,7 @@
*/
package org.springframework.statemachine.data.redis;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.MatcherAssert.assertThat;
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.resolveMachine;
@@ -73,18 +71,18 @@ public class RedisRepositoryTests extends AbstractRepositoryTests {
RedisStateRepository stateRepository = context.getBean(RedisStateRepository.class);
RedisTransitionRepository transitionRepository = context.getBean(RedisTransitionRepository.class);
assertThat(stateRepository.count(), is(3l));
assertThat(transitionRepository.count(), is(3l));
assertThat(stateRepository.count()).isEqualTo(3l);
assertThat(transitionRepository.count()).isEqualTo(3l);
List<RedisRepositoryState> states = new ArrayList<>();
stateRepository.findAll().iterator().forEachRemaining(states::add);
List<RedisRepositoryTransition> transitions = new ArrayList<>();
transitionRepository.findAll().iterator().forEachRemaining(transitions::add);
assertThat(states.size(), is(3));
assertThat(transitions.size(), is(3));
assertThat(states).hasSize(3);
assertThat(transitions).hasSize(3);
RedisRepositoryTransition transition1 = transitions.get(0);
assertThat(transition1.getSource(), notNullValue());
assertThat(transition1.getTarget(), notNullValue());
assertThat(transition1.getSource()).isNotNull();
assertThat(transition1.getTarget()).isNotNull();
}
@Test
@@ -95,27 +93,27 @@ public class RedisRepositoryTests extends AbstractRepositoryTests {
RedisStateRepository statesRepository = context.getBean(RedisStateRepository.class);
RedisRepositoryState stateS1 = new RedisRepositoryState("S1");
RedisRepositoryState stateS2 = new RedisRepositoryState("S2");
assertThat(statesRepository.count(), is(0l));
assertThat(statesRepository.count()).isEqualTo(0l);
statesRepository.save(stateS1);
statesRepository.save(stateS2);
assertThat(statesRepository.count(), is(2l));
assertThat(statesRepository.count()).isEqualTo(2l);
RedisTransitionRepository transitionsRepository = context.getBean(RedisTransitionRepository.class);
RedisRepositoryTransition transition = new RedisRepositoryTransition(stateS1, stateS2, "E1");
transition.setKind(TransitionKind.EXTERNAL);
transitionsRepository.save(transition);
assertThat(statesRepository.count(), is(2l));
assertThat(statesRepository.count()).isEqualTo(2l);
RedisRepositoryTransition transition2 = transitionsRepository.findAll().iterator().next();
assertThat(transition2.getSource().getState(), is("S1"));
assertThat(transition2.getTarget().getState(), is("S2"));
assertThat(transition2.getEvent(), is("E1"));
assertThat(transition2.getKind(), is(TransitionKind.EXTERNAL));
assertThat(transition2.getSource().getState()).isEqualTo("S1");
assertThat(transition2.getTarget().getState()).isEqualTo("S2");
assertThat(transition2.getEvent()).isEqualTo("E1");
assertThat(transition2.getKind()).isEqualTo(TransitionKind.EXTERNAL);
List<RedisRepositoryState> findByMachineId = statesRepository.findByMachineId("");
assertThat(findByMachineId.size(), is(2));
assertThat(findByMachineId).hasSize(2);
context.close();
}
@@ -127,11 +125,11 @@ public class RedisRepositoryTests extends AbstractRepositoryTests {
StateMachine<String, String> stateMachine = resolveMachine(context);
doStartAndAssert(stateMachine);
assertThat(stateMachine.getState().getId(), is("S1"));
assertThat(stateMachine.getState().getId()).isEqualTo("S1");
doSendEventAndConsumeAll(stateMachine, "E1");
assertThat(stateMachine.getState().getId(), is("S2"));
assertThat(stateMachine.getState().getId()).isEqualTo("S2");
doSendEventAndConsumeAll(stateMachine, "E2");
assertThat(stateMachine.getState().getId(), is("S1"));
assertThat(stateMachine.getState().getId()).isEqualTo("S1");
}
@Test
@@ -141,11 +139,11 @@ public class RedisRepositoryTests extends AbstractRepositoryTests {
StateMachine<PersistTestStates, PersistTestEvents> stateMachine = resolveMachine(context);
doStartAndAssert(stateMachine);
assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1));
assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1);
doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E1);
assertThat(stateMachine.getState().getId(), is(PersistTestStates.S2));
assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S2);
doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E2);
assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1));
assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1);
}
@Override

12
spring-statemachine-data/src/test/java/org/springframework/statemachine/data/AbstractRepositoryTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2016 the original author or authors.
* Copyright 2016-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 org.springframework.statemachine.data;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.Iterator;
@@ -349,9 +347,9 @@ public abstract class AbstractRepositoryTests {
break;
}
}
assertThat(endState, notNullValue());
assertThat(endState.getPseudoState(), notNullValue());
assertThat(endState.getPseudoState().getKind(), is(PseudoStateKind.END));
assertThat(endState).isNotNull();
assertThat(endState.getPseudoState()).isNotNull();
assertThat(endState.getPseudoState().getKind()).isEqualTo(PseudoStateKind.END);
}
@SuppressWarnings("unchecked")