Java tutorial
/* * Copyright (c) 2009 - 2012 by Oli B. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express orimplied. * See the License for the specific language governing permissions and * limitations under the License. * * (c)reated 19.10.2009 by Oli B. (ob@aosd.de) */ package gdv.xport.satz; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import gdv.xport.annotation.FelderInfo; import gdv.xport.feld.AlphaNumFeld; import gdv.xport.feld.Bezeichner; import gdv.xport.feld.Feld; import gdv.xport.feld.NumFeld; import gdv.xport.satz.feld.Feld200; import gdv.xport.satz.feld.MetaFeldInfo; import gdv.xport.satz.feld.common.Feld1bis7; import gdv.xport.satz.feld.sparte10.Feld220Wagnis0; import gdv.xport.satz.feld.sparte53.Feld220; import gdv.xport.satz.model.SatzX; import gdv.xport.util.SatzNummer; import java.io.*; import java.util.List; import net.sf.oval.ConstraintViolation; import org.apache.commons.io.FileUtils; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.junit.Test; import patterntesting.runtime.junit.ObjectTester; /** * Test-Klasse fuer Satz. * * @author oliver * @since 19.10.2009 */ public final class SatzTest extends AbstractSatzTest { private static final Logger LOG = LogManager.getLogger(SatzTest.class); private static final String INPUT_SATZ_123 = "0123Hello 007 " + " " + " " + " 1" + "\n"; private final Satz satz = new Datensatz(123); /** * Hier erzeugen wir einen Satz zum Testen. * * @return Satz zum Testen * @see gdv.xport.satz.AbstractSatzTest#getSatz() */ @Override protected Satz getSatz() { return new Datensatz(123); } /** * Ein einfacher Test, der lediglich die Satzart ueberprueft. */ @Test public void testSatz() { Satz satz100 = new Datensatz(100, 1); assertEquals(satz100.getSatzart(), 100); } /** * Test method for {@link gdv.xport.satz.Satz#add(gdv.xport.feld.Feld)}. * Falls ein Feld hinzugefuegt wird, das ein anderes Feld (teilweise) * ueberschreiben wuerde, sollte eine Exception geworfen werden. */ @Test(expected = IllegalArgumentException.class) public void testAdd() { satz.add(new AlphaNumFeld(new Bezeichner(Bezeichner.NAME_NAME1), 30, 44)); satz.add(new AlphaNumFeld(new Bezeichner("Bumm"), 4, 50)); } /** * Test method for * {@link gdv.xport.satz.Satz#set(java.lang.String, java.lang.String)}. Es * kann nur ein Feld gesetzt werden, das vorher ueber "add(..)" hinzugefuegt * wurde. */ @Test(expected = IllegalArgumentException.class) public void testSet() { satz.set("gibtsnet", "plopp"); } /** * Test method for {@link gdv.xport.satz.Satz#get(java.lang.String)}. */ @Test public void testGet() { satz.add(new AlphaNumFeld(new Bezeichner(Bezeichner.NAME_ORT), 30, 50)); satz.set(Bezeichner.NAME_ORT, "Stuttgart"); assertEquals("Stuttgart", satz.get(Bezeichner.NAME_ORT).trim()); } /** * Test method for {@link gdv.xport.satz.Satz#getFeld(java.lang.String)}. * Fuer ein Feld, das nicht existiert, wird nicht mehr NULL_FELD als * Ergebnis erwartet sondern eine IllegalArgumentException. */ @Test(expected = IllegalArgumentException.class) public void testGetFeld() { Feld f = satz.getFeld("hemmernet"); assertSame(Feld.NULL_FELD, f); } /** * Ein Export mit einem Teildatensatz sollte aus genau 256 Bytes bestehen, * da in der SetUp-Methode das EOD-Zeichen auf "" gesetzt wurde. * * @throws IOException * sollte nicht auftreten, da wir mit StringWriter arbeiten */ @Test public void testExport() throws IOException { StringWriter swriter = new StringWriter(256); satz.export(swriter, ""); swriter.close(); String content = swriter.toString(); assertEquals(256, content.length()); assertEquals(satz.getSatzartFeld().getInhalt(), content.substring(0, 4)); } /** * Test-Methode fuer {@link Satz#export(File)}. * * @throws IOException Signals that an I/O exception has occurred. */ @Test public void testExportFile() throws IOException { File tmpFile = File.createTempFile("gdv", ".xport"); LOG.info("File \"" + tmpFile + "\" created."); try { satz.export(tmpFile); String exported = FileUtils.readFileToString(tmpFile); assertEquals(satz.toLongString(), exported); } finally { tmpFile.delete(); LOG.info("File \"" + tmpFile + "\" deleted."); } } /** * Ein einfach Import-Test. * * @throws IOException sollte eigenlich nicht passieren, da wir von einem * String lesen */ @Test public void testImport() throws IOException { Satz x = new Datensatz(123); x.add(new AlphaNumFeld(new Bezeichner("F1"), 5, 5)); x.importFrom(INPUT_SATZ_123); assertEquals(123, x.getSatzart()); assertEquals("Hello", x.getFeld("F1").getInhalt()); assertEquals(INPUT_SATZ_123.trim(), x.toLongString().trim()); } /** * Hier probieren wir jetzt den Import ueber einen Reader. * * @throws IOException sollte eigenlich nicht passieren, da wir von einem * String lesen */ @Test public void testImportFromReader() throws IOException { Satz x = new Datensatz(123, 7); Reader reader = new StringReader(INPUT_SATZ_123); try { checkImport(x, reader); } finally { reader.close(); } } /** * Hier probieren wir jetzt 2 Saetze ueber einen Reader einzulesen. * * @throws IOException sollte eigenlich nicht passieren, da wir von einem * String lesen */ @Test //@Ignore // Fehler ist noch nicht behoben public void testImportFromReaderTwice() throws IOException { Satz x = new Datensatz(123, 7); Reader reader = new StringReader(INPUT_SATZ_123 + INPUT_SATZ_123); try { checkImport(x, reader); checkImport(x, reader); } finally { reader.close(); } } private void checkImport(final Satz x, final Reader reader) throws IOException { x.importFrom(reader); assertEquals(INPUT_SATZ_123.trim(), x.toLongString().trim()); } /** * Test-Methode fuer {@link Satz#importFrom(File)}. * * @throws IOException Signals that an I/O exception has occurred. */ @Test public void testImportFile() throws IOException { File tmpFile = File.createTempFile("gdv", ".xport"); LOG.info("File \"" + tmpFile + "\" created."); try { String fileContent = satz.toLongString(); FileUtils.writeStringToFile(tmpFile, fileContent); satz.importFrom(tmpFile); assertEquals(fileContent, satz.toLongString()); } finally { tmpFile.delete(); LOG.info("File \"" + tmpFile + "\" deleted."); } } /** * Ein unbekannte Datensatz ist nicht valide. */ @Test public void testIsValid() { Satz a = new Datensatz("xxxx", 1); assertFalse("Diese Satzart gibt es nicht: " + a, a.isValid()); } /** * Ein (Daten-)Satz mit einem nicht validen Feld ist auch nicht valide. */ @Test public void testIsValidWithInvalidFeld() { NumFeld schrott = new NumFeld("schrott", "xxxx"); satz.add(schrott); assertFalse(satz + " has invalid fields!", satz.isValid()); } /** * Bei einem unbekannten Datensatz sollte die Validierung fehlschlagen. */ @Test public void testValidate() { Satz a = new Datensatz("xxxx", 1); assertFalse("Diese Satzart gibt es nicht: " + a, a.isValid()); List<ConstraintViolation> violations = a.validate(); for (ConstraintViolation violation : violations) { LOG.info("ConstraintViolation: " + violation); } assertEquals(2, violations.size()); } /** * Zwei gleiche Datensaetze muessen natuerlich auch den gleichen Hashcode * besitzen. */ @Test public void testIsEquals() { Satz a = new Datensatz(123); Satz b = new Datensatz(123); ObjectTester.assertEquals(a, b); b.add(new Feld("c", 55, 'c')); assertFalse(a + " differs from " + b, a.equals(b)); } /** * Hier testen wir das Enfernen von Teildatensaetze. * * @since 0.4 */ @Test public void testRemoveTeildatensatz() { Satz s = new Vorsatz(); int n = s.getTeildatensaetze().size(); s.removeTeildatensatz(n); assertEquals(n - 1, s.getTeildatensaetze().size()); s.removeTeildatensatz(1); assertEquals(n - 2, s.getTeildatensaetze().size()); } /** * Hier testen wir das Entfernen aller Teildatensaetze. * * @since 0.4 */ @Test public void testRemoveAllTeildatensaetze() { Satz s = new Vorsatz(); s.removeAllTeildatensaetze(2); assertEquals(1, s.getTeildatensaetze().size()); } /** * Test method for {@link Satz#getAsList(Enum[])}. */ @Test public void testGetAsListSimple() { List<MetaFeldInfo> feldInfos = Satz.getMetaFeldInfos(Feld200.values()); assertFalse("empty list", feldInfos.isEmpty()); LOG.info("Feld200 has " + feldInfos.size() + " FeldInfos."); assertTrue("Feld200 should have more than " + Feld200.values().length + " entries", feldInfos.size() >= Feld200.values().length); } /** * Test method for {@link Satz#getAsList(Enum[])}. */ @Test public void testGetAsListComposite() { List<MetaFeldInfo> feldInfos = Satz.getMetaFeldInfos(Feld220.values()); assertFalse("empty list", feldInfos.isEmpty()); LOG.info(Feld220.class.getName() + " has " + feldInfos.size() + " FeldInfos."); assertTrue("elements are missing", feldInfos.size() > Feld220.values().length); } /** * {@link Feld1bis7} ist ein Beispiel, wo kein Teildatensatz gesetzt ist. * Dieser wird z.B. beim {@link Feld200} ueber die {@link FelderInfo}- * Annotation gesetzt. Ob dieses Wert tatsaechlich gesetzt wird, wird * ueber diesen Test geprueft. */ @Test public void testGetAsListTeildatensatz() { List<MetaFeldInfo> metaFeldInfos = Satz.getMetaFeldInfos(Feld200.values()); int found = 0; for (MetaFeldInfo metaFeldInfo : metaFeldInfos) { if (metaFeldInfo.getName().equals("SATZART")) { found++; checkSatzart(metaFeldInfo, found); } } } private static void checkSatzart(final MetaFeldInfo satzart, final int found) { LOG.info(found + ". MetaFeldInfo: " + satzart); assertEquals(1, satzart.getNr()); assertEquals(found, satzart.getTeildatensatzNr()); } /** * Die Satzart ist im ersten Feld (Byte 1 - 4) enthalten und ist in jedem * Satz vorhanden (auch Vorsatz und Nachsatz). */ @Test public void testSatzartInhalt() { Feld satzart = satz.getFeld(Feld1bis7.SATZART); assertEquals("0123", satzart.getInhalt()); } /** * Test-Methode fuer {@link Satz#getSatzTyp()}. */ @Test public void testGetSatzTyp() { Satz satz220 = new SatzX(220, Feld220Wagnis0.class); assertEquals(new SatzNummer(220, 10, 0), satz220.getSatzTyp()); } }