Skip to content

Commit 81f0323

Browse files
VikiPeevaVikiPeeva
authored
Tested and adapted Place.from() for different scenarios
1 parent 2a696c5 commit 81f0323

File tree

2 files changed

+285
-5
lines changed
  • src/org/processmining/placebasedlpmdiscovery/model
  • tests/src/org/processmining/placebasedlpmdiscovery/model

2 files changed

+285
-5
lines changed

‎src/org/processmining/placebasedlpmdiscovery/model/Place.java‎

Lines changed: 23 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -35,14 +35,32 @@ public Place(String id) {
3535
this.isFinal = false;
3636
}
3737

38+
/**
39+
* Create a place from its string representation. The string representation differentiates input and output transitions
40+
* using a | character. For example, the string "a, b | c, d" represents a place with input transitions a and b,
41+
* and output transitions c and d. Each transition is represented by its label and is assumed to be visible.
42+
* Transitions are separated by commas. Whitespace around labels and the | character is ignored.
43+
* @param stringRepresentation the string representation of the place
44+
* @return a Place object corresponding to the string representation
45+
* @throws IllegalArgumentException if the string representation is invalid
46+
*/
3847
public static Place from(String stringRepresentation) {
3948
Place place = new Place();
40-
String[] transitions = stringRepresentation.split(" \\| ");
41-
for (String tr : transitions[0].split(" ")) {
42-
place.addInputTransition(new Transition(tr, false));
49+
String[] inoutTransitions = stringRepresentation.trim().split("\\s*\\|\\s*", -1);
50+
51+
if (inoutTransitions.length != 2) {
52+
throw new IllegalArgumentException("The place string should include a single |.");
53+
}
54+
55+
if (!inoutTransitions[0].trim().isEmpty()) {
56+
Arrays.stream(inoutTransitions[0].trim().split(","))
57+
.map(String::trim).filter(s -> !s.isEmpty())
58+
.forEach(label -> place.addInputTransition(new Transition(label, false)));
4359
}
44-
for (String tr : transitions[1].split(" ")) {
45-
place.addOutputTransition(new Transition(tr, false));
60+
if (!inoutTransitions[1].trim().isEmpty()) {
61+
Arrays.stream(inoutTransitions[1].trim().split(","))
62+
.map(String::trim).filter(s -> !s.isEmpty())
63+
.forEach(label -> place.addOutputTransition(new Transition(label, false)));
4664
}
4765
return place;
4866
}

‎tests/src/org/processmining/placebasedlpmdiscovery/model/PlaceTest.java‎

Lines changed: 262 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,262 @@
1+
package src.org.processmining.placebasedlpmdiscovery.model;
2+
3+
import org.assertj.core.api.Assertions;
4+
import org.junit.Assert;
5+
import org.junit.Test;
6+
import org.processmining.placebasedlpmdiscovery.model.Place;
7+
import org.processmining.placebasedlpmdiscovery.model.Transition;
8+
9+
public class PlaceTest {
10+
11+
@Test
12+
public void givenOneInOneOutSingleLetter_whenFrom_thenPlaceWithOneInOneOut() {
13+
// given
14+
String placeDescription = "a | b";
15+
String placeDescriptionWithComma = "a, | b";
16+
String placeDescriptionWithEnter = "a\n, | b";
17+
18+
// when
19+
Place placeActual = Place.from(placeDescription);
20+
Place placeActualWithComma = Place.from(placeDescriptionWithComma);
21+
Place placeActualWithEnter = Place.from(placeDescriptionWithEnter);
22+
23+
// then
24+
Assert.assertEquals(1, placeActual.getInputTransitions().size());
25+
Assert.assertEquals(1, placeActual.getOutputTransitions().size());
26+
Assertions.assertThat(placeActual.getInputTransitions())
27+
.containsExactly(new Transition("a", false));
28+
Assertions.assertThat(placeActual.getOutputTransitions())
29+
.containsExactly(new Transition("b", false));
30+
31+
Assert.assertEquals(1, placeActualWithComma.getInputTransitions().size());
32+
Assert.assertEquals(1, placeActualWithComma.getOutputTransitions().size());
33+
Assertions.assertThat(placeActualWithComma.getInputTransitions())
34+
.containsExactly(new Transition("a", false));
35+
Assertions.assertThat(placeActualWithComma.getOutputTransitions())
36+
.containsExactly(new Transition("b", false));
37+
38+
Assert.assertEquals(1, placeActualWithEnter.getInputTransitions().size());
39+
Assert.assertEquals(1, placeActualWithEnter.getOutputTransitions().size());
40+
Assertions.assertThat(placeActualWithEnter.getInputTransitions())
41+
.containsExactly(new Transition("a", false));
42+
Assertions.assertThat(placeActualWithEnter.getOutputTransitions())
43+
.containsExactly(new Transition("b", false));
44+
}
45+
46+
@Test
47+
public void givenOneInOneOutWords_whenFrom_thenPlaceWithOneInOneOut() {
48+
// given
49+
String placeDescription = "apple | banana";
50+
String placeDescriptionWithComma = "apple, | banana";
51+
52+
// when
53+
Place placeActual = Place.from(placeDescription);
54+
Place placeActualWithComma = Place.from(placeDescriptionWithComma);
55+
56+
// then
57+
Assert.assertEquals(1, placeActual.getInputTransitions().size());
58+
Assert.assertEquals(1, placeActual.getOutputTransitions().size());
59+
Assertions.assertThat(placeActual.getInputTransitions()).containsExactly(new Transition("apple", false));
60+
Assertions.assertThat(placeActual.getOutputTransitions()).containsExactly(new Transition("banana", false));
61+
62+
Assert.assertEquals(1, placeActualWithComma.getInputTransitions().size());
63+
Assert.assertEquals(1, placeActualWithComma.getOutputTransitions().size());
64+
Assertions.assertThat(placeActualWithComma.getInputTransitions()).containsExactly(new Transition("apple", false));
65+
Assertions.assertThat(placeActualWithComma.getOutputTransitions()).containsExactly(new Transition("banana", false));
66+
}
67+
68+
@Test
69+
public void givenOneInOneOutPhrases_whenFrom_thenPlaceWithOneInOneOut() {
70+
// given
71+
String placeDescription = "tasty apple | tasty banana";
72+
String placeDescriptionWithComma = "tasty apple, | tasty banana";
73+
74+
// when
75+
Place placeActual = Place.from(placeDescription);
76+
Place placeActualWithComma = Place.from(placeDescriptionWithComma);
77+
78+
// then
79+
Assert.assertEquals(1, placeActual.getInputTransitions().size());
80+
Assert.assertEquals(1, placeActual.getOutputTransitions().size());
81+
Assertions.assertThat(placeActual.getInputTransitions())
82+
.containsExactly(new Transition("tasty apple", false));
83+
Assertions.assertThat(placeActual.getOutputTransitions())
84+
.containsExactly(new Transition("tasty banana", false));
85+
86+
Assert.assertEquals(1, placeActualWithComma.getInputTransitions().size());
87+
Assert.assertEquals(1, placeActualWithComma.getOutputTransitions().size());
88+
Assertions.assertThat(placeActualWithComma.getInputTransitions())
89+
.containsExactly(new Transition("tasty apple", false));
90+
Assertions.assertThat(placeActualWithComma.getOutputTransitions())
91+
.containsExactly(new Transition("tasty banana", false));
92+
}
93+
94+
@Test
95+
public void givenOneInTwoOutSingleLetter_whenFrom_thenPlaceWithOneInTwoOut() {
96+
// given
97+
String placeDescription = "a | b, c";
98+
99+
// when
100+
Place placeActual = Place.from(placeDescription);
101+
102+
// then
103+
Assert.assertEquals(1, placeActual.getInputTransitions().size());
104+
Assert.assertEquals(2, placeActual.getOutputTransitions().size());
105+
Assertions.assertThat(placeActual.getInputTransitions())
106+
.containsExactly(new Transition("a", false));
107+
Assertions.assertThat(placeActual.getOutputTransitions())
108+
.containsExactlyInAnyOrder(new Transition("b", false),
109+
new Transition("c", false));
110+
}
111+
112+
@Test
113+
public void givenOneInTwoOutWords_whenFrom_thenPlaceWithOneInTwoOut() {
114+
// given
115+
String placeDescription = "apple | banana, cherry";
116+
117+
// when
118+
Place placeActual = Place.from(placeDescription);
119+
120+
// then
121+
Assert.assertEquals(1, placeActual.getInputTransitions().size());
122+
Assert.assertEquals(2, placeActual.getOutputTransitions().size());
123+
Assertions.assertThat(placeActual.getInputTransitions())
124+
.containsExactly(new Transition("apple", false));
125+
Assertions.assertThat(placeActual.getOutputTransitions())
126+
.containsExactlyInAnyOrder(new Transition("banana", false),
127+
new Transition("cherry", false));
128+
}
129+
130+
@Test
131+
public void givenOneInTwoOutPhrases_whenFrom_thenPlaceWithOneInTwoOut() {
132+
// given
133+
String placeDescription = "tasty apple | tasty banana, tasty cherry";
134+
135+
// when
136+
Place placeActual = Place.from(placeDescription);
137+
138+
// then
139+
Assert.assertEquals(1, placeActual.getInputTransitions().size());
140+
Assert.assertEquals(2, placeActual.getOutputTransitions().size());
141+
Assertions.assertThat(placeActual.getInputTransitions())
142+
.containsExactly(new Transition("tasty apple", false));
143+
Assertions.assertThat(placeActual.getOutputTransitions())
144+
.containsExactlyInAnyOrder(new Transition("tasty banana", false),
145+
new Transition("tasty cherry", false));
146+
}
147+
148+
@Test
149+
public void givenTwoInOneOutSingleLetter_whenFrom_thenPlaceWithTwoInOneOut() {
150+
// given
151+
String placeDescription = "a, b | c";
152+
153+
// when
154+
Place placeActual = Place.from(placeDescription);
155+
156+
// then
157+
Assert.assertEquals(2, placeActual.getInputTransitions().size());
158+
Assert.assertEquals(1, placeActual.getOutputTransitions().size());
159+
Assertions.assertThat(placeActual.getInputTransitions())
160+
.containsExactlyInAnyOrder(new Transition("a", false),
161+
new Transition("b", false));
162+
Assertions.assertThat(placeActual.getOutputTransitions())
163+
.containsExactly(new Transition("c", false));
164+
}
165+
166+
@Test
167+
public void givenOneInNoOutSingleLetter_whenFrom_thenPlaceWithOneInNoOut() {
168+
// given
169+
String placeDescriptionEmptySpace = "a | ";
170+
String placeDescriptionNoEndSpace = "a |";
171+
String placeDescriptionNoSpace = "a|";
172+
173+
// when
174+
Place placeActualEmptySpace = Place.from(placeDescriptionEmptySpace);
175+
Place placeActualNoEndSpace = Place.from(placeDescriptionNoEndSpace);
176+
Place placeActualNoSpace = Place.from(placeDescriptionNoSpace);
177+
178+
// then
179+
Assert.assertEquals(1, placeActualEmptySpace.getInputTransitions().size());
180+
Assert.assertEquals(0, placeActualEmptySpace.getOutputTransitions().size());
181+
Assertions.assertThat(placeActualEmptySpace.getInputTransitions())
182+
.containsExactly(new Transition("a", false));
183+
184+
Assert.assertEquals(1, placeActualNoEndSpace.getInputTransitions().size());
185+
Assert.assertEquals(0, placeActualNoEndSpace.getOutputTransitions().size());
186+
Assertions.assertThat(placeActualNoEndSpace.getInputTransitions())
187+
.containsExactly(new Transition("a", false));
188+
189+
Assert.assertEquals(1, placeActualNoSpace.getInputTransitions().size());
190+
Assert.assertEquals(0, placeActualNoSpace.getOutputTransitions().size());
191+
Assertions.assertThat(placeActualNoSpace.getInputTransitions())
192+
.containsExactly(new Transition("a", false));
193+
}
194+
195+
@Test
196+
public void givenNoInOneOutSingleLetter_whenFrom_thenPlaceWithNoInOneOut() {
197+
// given
198+
String placeDescriptionEmptySpace = " | a";
199+
String placeDescriptionNoEndSpace = "| a";
200+
String placeDescriptionNoSpace = "|a";
201+
202+
// when
203+
Place placeActualEmptySpace = Place.from(placeDescriptionEmptySpace);
204+
Place placeActualNoEndSpace = Place.from(placeDescriptionNoEndSpace);
205+
Place placeActualNoSpace = Place.from(placeDescriptionNoSpace);
206+
207+
// then
208+
Assert.assertEquals(0, placeActualEmptySpace.getInputTransitions().size());
209+
Assert.assertEquals(1, placeActualEmptySpace.getOutputTransitions().size());
210+
Assertions.assertThat(placeActualEmptySpace.getOutputTransitions())
211+
.containsExactly(new Transition("a", false));
212+
213+
Assert.assertEquals(0, placeActualNoEndSpace.getInputTransitions().size());
214+
Assert.assertEquals(1, placeActualNoEndSpace.getOutputTransitions().size());
215+
Assertions.assertThat(placeActualNoEndSpace.getOutputTransitions())
216+
.containsExactly(new Transition("a", false));
217+
218+
Assert.assertEquals(0, placeActualNoSpace.getInputTransitions().size());
219+
Assert.assertEquals(1, placeActualNoSpace.getOutputTransitions().size());
220+
Assertions.assertThat(placeActualNoSpace.getOutputTransitions())
221+
.containsExactly(new Transition("a", false));
222+
}
223+
224+
@Test
225+
public void givenMultipleDelimiters_whenFrom_thenThrowIllegalArgument() {
226+
// given
227+
String placeDescription = "a, b | c | d";
228+
229+
try { // when
230+
Place.from(placeDescription);
231+
}
232+
catch (IllegalArgumentException e) { // then
233+
Assert.assertTrue(e.getMessage().contains("The place string should include a single |."));
234+
}
235+
}
236+
237+
@Test
238+
public void givenNoDelimiters_whenFrom_thenThrowIllegalArgument() {
239+
// given
240+
String placeDescription = "a, b";
241+
242+
try { // when
243+
Place.from(placeDescription);
244+
}
245+
catch (IllegalArgumentException e) { // then
246+
Assert.assertTrue(e.getMessage().contains("The place string should include a single |."));
247+
}
248+
}
249+
250+
@Test
251+
public void givenEmptyString_whenFrom_thenThrowIllegalArgument() {
252+
// given
253+
String placeDescription = "";
254+
255+
try { // when
256+
Place.from(placeDescription);
257+
}
258+
catch (IllegalArgumentException e) { // then
259+
Assert.assertTrue(e.getMessage().contains("The place string should include a single |."));
260+
}
261+
}
262+
}

0 commit comments

Comments
 (0)