001package edu.pdx.cs.joy.family;
002
003import org.junit.jupiter.api.Assertions;
004import org.junit.jupiter.api.Test;
005
006import java.io.PrintWriter;
007import java.io.StringReader;
008import java.io.StringWriter;
009
010import static org.junit.jupiter.api.Assertions.assertNotNull;
011import static org.junit.jupiter.api.Assertions.fail;
012
013/**
014 * This class tests the functionality of the <code>TextDumper</code>
015 * and <code>TextParser</code> classes.
016 */
017public class TextTest extends FamilyTreeConversionTestCase {
018
019
020  /**
021   * Converts a FamilyTree to text and returns the text as a String.
022   */
023  @Override
024  protected String getStringFor(FamilyTree tree) {
025    StringWriter sw = new StringWriter();
026    PrintWriter pw = new PrintWriter(sw, true);
027    Dumper dumper = new TextDumper(pw);
028    dumper.dump(tree);
029    String s = sw.toString();
030    if (Boolean.getBoolean("TextTest.DUMP_TEXT")) {
031      System.out.println(s);
032    }
033    return s;
034  }
035
036  /**
037   * Parsers a FamilyTree from a String containing XML
038   */
039  @Override
040  protected FamilyTree getFamilyTreeFor(String s)
041    throws FamilyTreeException {
042
043    // Parse the XML from the String
044    StringReader sr = new StringReader(s);
045    Parser parser = new TextParser(sr);
046    return parser.parse();
047  }
048
049  ////////  Additional test methods
050
051  /**
052   * Files contains person with same id multiple times
053   */
054  @Test
055  public void testSameIdMultipleTimes() {
056    StringWriter sw = new StringWriter();
057    PrintWriter pw = new PrintWriter(sw, true);
058    pw.println("P 1");
059    pw.println("id: 1");
060    pw.println("P 1");
061    pw.println("id: 1");
062    
063    try {
064      getFamilyTreeFor(sw.toString());
065      fail("Should have thrown a FamilyTreeException");
066
067    } catch (FamilyTreeException ex) {
068      assertContains(ex.getMessage(), "already has person 1");
069    }
070  }
071
072    @Test
073  public void testBadId() {
074    StringWriter sw = new StringWriter();
075    PrintWriter pw = new PrintWriter(sw, true);
076    pw.println("P 1");
077    pw.println("id: Q");
078    
079    try {
080      getFamilyTreeFor(sw.toString());
081      fail("Should have thrown a FamilyTreeException");
082
083    } catch (FamilyTreeException ex) {
084      assertContains(ex.getMessage(), "id: Q");
085    }
086  }
087
088    @Test
089  public void testGenderBeforeId() {
090    StringWriter sw = new StringWriter();
091    PrintWriter pw = new PrintWriter(sw, true);
092    pw.println("P 2");
093    pw.println("g: 1");
094    pw.println("id: 1");
095    
096    try {
097      getFamilyTreeFor(sw.toString());
098      fail("Should have thrown a FamilyTreeException");
099
100    } catch (FamilyTreeException ex) {
101      // pass...
102    }
103  }
104
105    @Test
106  public void testBadGender() {
107    StringWriter sw = new StringWriter();
108    PrintWriter pw = new PrintWriter(sw, true);
109    pw.println("P 2");
110    pw.println("id: 1");
111    pw.println("g: Q");
112    
113    try {
114      getFamilyTreeFor(sw.toString());
115      fail("Should have thrown a FamilyTreeException");
116
117    } catch (FamilyTreeException ex) {
118      // pass...
119    }
120  }
121
122    @Test
123  public void testInvalidGender() {
124    StringWriter sw = new StringWriter();
125    PrintWriter pw = new PrintWriter(sw, true);
126    pw.println("P 2");
127    pw.println("id: 1");
128    pw.println("g: 3");
129    
130    try {
131      getFamilyTreeFor(sw.toString());
132      fail("Should have thrown a FamilyTreeException");
133
134    } catch (FamilyTreeException ex) {
135      // pass...
136    }
137  }
138
139    @Test
140  public void testMissingGender() {
141    StringWriter sw = new StringWriter();
142    PrintWriter pw = new PrintWriter(sw, true);
143    pw.println("P 2");
144    pw.println("id: 1");
145    
146    try {
147      getFamilyTreeFor(sw.toString());
148      fail("Should have thrown a FamilyTreeException");
149
150    } catch (FamilyTreeException ex) {
151      // pass...
152    }
153  }
154
155    @Test
156  public void testFemaleGender() {
157    int id = 1;
158    Person.Gender gender = Person.FEMALE;
159
160    StringWriter sw = new StringWriter();
161    PrintWriter pw = new PrintWriter(sw, true);
162    pw.println("P 2");
163    pw.println("id: " + id);
164    pw.println("g: " + gender);
165    
166    FamilyTree tree = getFamilyTreeFor(sw.toString());
167    Person p = tree.getPerson(id);
168    assertNotNull(p);
169    Assertions.assertEquals(gender, p.getGender());
170  }
171
172    @Test
173  public void testMaleGender() {
174    int id = 1;
175    Person.Gender gender = Person.MALE;
176
177    StringWriter sw = new StringWriter();
178    PrintWriter pw = new PrintWriter(sw, true);
179    pw.println("P 2");
180    pw.println("id: " + id);
181    pw.println("g: " + gender);
182    
183    FamilyTree tree = getFamilyTreeFor(sw.toString());
184    Person p = tree.getPerson(id);
185    assertNotNull(p);
186    Assertions.assertEquals(gender, p.getGender());
187  }
188
189    @Test
190  public void testFirstNameBeforeId() {
191    StringWriter sw = new StringWriter();
192    PrintWriter pw = new PrintWriter(sw, true);
193    pw.println("P 2");
194    pw.println("fn: Test");
195    pw.println("id: 1");
196    
197    try {
198      getFamilyTreeFor(sw.toString());
199      fail("Should have thrown a FamilyTreeException");
200
201    } catch (FamilyTreeException ex) {
202      // pass...
203    }
204  }
205
206    @Test
207  public void testMiddleNameBeforeId() {
208    StringWriter sw = new StringWriter();
209    PrintWriter pw = new PrintWriter(sw, true);
210    pw.println("P 2");
211    pw.println("mn: Test");
212    pw.println("id: 1");
213    
214    try {
215      getFamilyTreeFor(sw.toString());
216      fail("Should have thrown a FamilyTreeException");
217
218    } catch (FamilyTreeException ex) {
219      // pass...
220    }
221  }
222
223    @Test
224  public void testLastNameBeforeId() {
225    StringWriter sw = new StringWriter();
226    PrintWriter pw = new PrintWriter(sw, true);
227    pw.println("P 2");
228    pw.println("ln: Test");
229    pw.println("id: 1");
230    
231    try {
232      getFamilyTreeFor(sw.toString());
233      fail("Should have thrown a FamilyTreeException");
234
235    } catch (FamilyTreeException ex) {
236      // pass...
237    }
238  }
239
240    @Test
241  public void testFatherBeforeId() {
242    StringWriter sw = new StringWriter();
243    PrintWriter pw = new PrintWriter(sw, true);
244    pw.println("P 2");
245    pw.println("f: 2");
246    pw.println("id: 1");
247    
248    try {
249      getFamilyTreeFor(sw.toString());
250      fail("Should have thrown a FamilyTreeException");
251
252    } catch (FamilyTreeException ex) {
253      // pass...
254    }
255  }
256
257    @Test
258  public void testBadFatherId() {
259    StringWriter sw = new StringWriter();
260    PrintWriter pw = new PrintWriter(sw, true);
261    pw.println("P 2");
262    pw.println("id: 1");
263    pw.println("f: Q");
264    
265    try {
266      getFamilyTreeFor(sw.toString());
267      fail("Should have thrown a FamilyTreeException");
268
269    } catch (FamilyTreeException ex) {
270      assertContains(ex.getMessage(), "father id: Q");
271    }
272  }
273
274    @Test
275  public void testNonExistentFatherId() {
276    StringWriter sw = new StringWriter();
277    PrintWriter pw = new PrintWriter(sw, true);
278    pw.println("P 2");
279    pw.println("id: 1");
280    pw.println("f: 3");
281    
282    try {
283      getFamilyTreeFor(sw.toString());
284      fail("Should have thrown a FamilyTreeException");
285
286    } catch (FamilyTreeException ex) {
287      assertContains(ex.getMessage(), "Father 3 does not exist");
288    }
289  }
290
291    @Test
292  public void testMotherBeforeId() {
293    StringWriter sw = new StringWriter();
294    PrintWriter pw = new PrintWriter(sw, true);
295    pw.println("P 2");
296    pw.println("m: 2");
297    pw.println("id: 1");
298    
299    try {
300      getFamilyTreeFor(sw.toString());
301      fail("Should have thrown a FamilyTreeException");
302
303    } catch (FamilyTreeException ex) {
304      // pass...
305    }
306  }
307
308    @Test
309  public void testBadMotherId() {
310    StringWriter sw = new StringWriter();
311    PrintWriter pw = new PrintWriter(sw, true);
312    pw.println("P 2");
313    pw.println("id: 1");
314    pw.println("m: Q");
315    
316    try {
317      getFamilyTreeFor(sw.toString());
318      fail("Should have thrown a FamilyTreeException");
319
320    } catch (FamilyTreeException ex) {
321      assertContains(ex.getMessage(), "mother id: Q");
322    }
323  }
324
325    @Test
326  public void testNonExistentMotherId() {
327    StringWriter sw = new StringWriter();
328    PrintWriter pw = new PrintWriter(sw, true);
329    pw.println("P 4");
330    pw.println("id: 1");
331    pw.println("g: " + Person.Gender.FEMALE);
332    pw.println("m: 3");
333    pw.println("f: 2");
334    pw.println("P 2");
335    pw.println("id: 2");
336    pw.println("g: " + Person.Gender.MALE);
337    
338    try {
339      getFamilyTreeFor(sw.toString());
340      fail("Should have thrown a FamilyTreeException");
341
342    } catch (FamilyTreeException ex) {
343      assertContains(ex.getMessage(), 
344                     ex.getMessage(), "Mother 3 does not exist");
345    }
346  }
347
348    @Test
349  public void testDOBBeforeId() {
350    StringWriter sw = new StringWriter();
351    PrintWriter pw = new PrintWriter(sw, true);
352    pw.println("P 2");
353    pw.println("dob: 12/30/1998 3:15 PM");
354    pw.println("id: 1");
355    
356    try {
357      getFamilyTreeFor(sw.toString());
358      fail("Should have thrown a FamilyTreeException");
359
360    } catch (FamilyTreeException ex) {
361      // pass...
362    }
363  }
364
365    @Test
366  public void testBadDOB() {
367    StringWriter sw = new StringWriter();
368    PrintWriter pw = new PrintWriter(sw, true);
369    pw.println("P 2");
370    pw.println("id: 1");
371    pw.println("dob: Q");
372    
373    try {
374      getFamilyTreeFor(sw.toString());
375      fail("Should have thrown a FamilyTreeException");
376
377    } catch (FamilyTreeException ex) {
378      assertContains(ex.getMessage(), "date of birth: Q");
379    }
380  }
381
382    @Test
383  public void testDODBeforeId() {
384    StringWriter sw = new StringWriter();
385    PrintWriter pw = new PrintWriter(sw, true);
386    pw.println("P 2");
387    pw.println("dod: 12/30/1998 3:15 PM");
388    pw.println("id: 1");
389    
390    try {
391      getFamilyTreeFor(sw.toString());
392      fail("Should have thrown a FamilyTreeException");
393
394    } catch (FamilyTreeException ex) {
395      // pass...
396    }
397  }
398
399    @Test
400  public void testBadDOD() {
401    StringWriter sw = new StringWriter();
402    PrintWriter pw = new PrintWriter(sw, true);
403    pw.println("P 2");
404    pw.println("id: 1");
405    pw.println("dod: Q");
406    
407    try {
408      getFamilyTreeFor(sw.toString());
409      fail("Should have thrown a FamilyTreeException");
410
411    } catch (FamilyTreeException ex) {
412      assertContains(ex.getMessage(), "date of death: Q");
413    }
414  }
415
416}