From 01a735179ffc3c48048345e9b7f28b1fc490524f Mon Sep 17 00:00:00 2001 From: Jens Wille Date: Tue, 28 Jan 2025 16:56:48 +0100 Subject: [PATCH] Enable Checkstyle runs against test sources. (#577) --- build.gradle | 1 - config/checkstyle/checkstyle.xml | 4 +- .../biblio/AlephMabXmlHandlerTest.java | 6 +- .../metafacture/biblio/AseqDecoderTest.java | 26 +- .../biblio/ComarcXmlHandlerTest.java | 35 +-- .../metafacture/biblio/MabDecoderTest.java | 15 +- .../biblio/iso2709/DirectoryEntryTest.java | 84 +++--- .../biblio/iso2709/Iso646ByteBufferTest.java | 162 ++++++------ .../metafacture/biblio/iso2709/LabelTest.java | 66 ++--- .../biblio/iso2709/RecordBuilderTest.java | 161 ++++++------ .../biblio/iso2709/RecordFormatTest.java | 18 +- .../biblio/iso2709/RecordTest.java | 74 +++--- .../biblio/marc21/Marc21DecoderTest.java | 40 +-- .../biblio/marc21/Marc21EncoderTest.java | 52 ++-- .../biblio/marc21/MarcXmlEncoderTest.java | 245 +++++++++--------- .../biblio/marc21/MarcXmlHandlerTest.java | 65 ++--- .../biblio/pica/PicaDecoderTest.java | 118 +++++---- .../biblio/pica/PicaEncoderTest.java | 47 ++-- .../pica/PicaMultiscriptRemodelerTest.java | 45 ++-- .../org/metafacture/commons/RequireTest.java | 13 +- .../metafacture/commons/ResourceUtilTest.java | 39 ++- .../metafacture/commons/StringUtilTest.java | 47 ++-- .../org/metafacture/commons/TimeUtilTest.java | 34 +-- .../org/metafacture/commons/XmlUtilTest.java | 24 +- .../commons/tries/CharMapTest.java | 25 +- .../commons/tries/SetMatchTest.java | 18 +- .../commons/tries/SetReplaceTest.java | 16 +- .../commons/tries/SimpleRegexTrieTest.java | 12 +- .../commons/tries/SimpleTrieTest.java | 20 +- .../commons/tries/WildcardTrieTest.java | 101 ++++---- .../commons/types/ListMapTest.java | 40 +-- .../commons/types/NamedValueTest.java | 22 +- .../org/metafacture/csv/CsvDecoderTest.java | 15 +- .../org/metafacture/csv/CsvEncoderTest.java | 11 +- .../JsonToElasticsearchBulkTest.java | 12 +- .../flowcontrol/CloseSuppressorTest.java | 6 +- .../flowcontrol/ObjectBatchResetterTest.java | 49 ++-- .../ObjectExceptionCatcherTest.java | 13 +- .../flowcontrol/ObjectSleeperTest.java | 3 + .../flowcontrol/ObjectThreaderTest.java | 31 ++- .../flowcontrol/StreamBufferTest.java | 23 +- .../flowcontrol/StreamDeferrerTest.java | 25 +- .../org/metafacture/flux/FluxGrammarTest.java | 113 ++++---- .../metafacture/flux/FluxProgrammTest.java | 10 +- .../formeta/FormetaDecoderTest.java | 10 +- .../formeta/FormetaEncoderTest.java | 25 +- .../formeta/FormetaRecordsReaderTest.java | 46 ++-- ...erTest.java => AbstractFormatterTest.java} | 18 +- .../formatter/ConciseFormatterTest.java | 10 +- .../formatter/MultilineFormatterTest.java | 10 +- .../formatter/VerboseFormatterTest.java | 10 +- .../formeta/parser/FormetaParserTest.java | 36 +-- .../framework/helpers/DefaultSenderTest.java | 27 +- .../html/ElementExtractorTest.java | 26 +- .../org/metafacture/html/HtmlDecoderTest.java | 53 ++-- .../AbstractConfigurableObjectWriterTest.java | 17 +- .../io/ByteStreamFileWriterTest.java | 71 +++-- .../io/FileOpenerCompressionTest.java | 28 +- .../org/metafacture/io/FileOpenerTest.java | 5 +- .../org/metafacture/io/HttpOpenerTest.java | 38 +-- .../io/ObjectFileWriterCompressionTest.java | 46 ++-- .../metafacture/io/ObjectFileWriterTest.java | 18 +- .../io/ObjectStdoutWriterTest.java | 7 +- .../org/metafacture/io/RecordReaderTest.java | 58 ++--- .../java/org/metafacture/io/TestHelpers.java | 3 + .../javaintegration/MapToStreamTest.java | 34 +-- .../javaintegration/pojo/PojoDecoderTest.java | 81 ++++-- .../javaintegration/pojo/PojoEncoderTest.java | 166 +++++++----- .../org/metafacture/json/JsonDecoderTest.java | 53 ++-- .../org/metafacture/json/JsonEncoderTest.java | 38 +-- .../metafacture/json/JsonValidatorTest.java | 75 +++--- .../linkeddata/OreAggregationAdderTest.java | 10 +- .../mangling/DuplicateObjectFilterTest.java | 18 +- .../mangling/EntityPathTrackerTest.java | 82 +++--- .../mangling/LiteralToObjectTest.java | 23 +- .../metafacture/mangling/NullFilterTest.java | 20 +- .../mangling/ObjectToLiteralTest.java | 14 +- .../mangling/RecordIdChangerTest.java | 31 +-- .../mangling/RecordPathFilterTest.java | 6 +- .../mangling/RecordToEntityTest.java | 20 +- .../mangling/StreamEventDiscarderTest.java | 45 ++-- .../mangling/StreamFlattenerTest.java | 56 ++-- .../org/metafacture/mangling/TestHelpers.java | 4 + .../monitoring/ObjectTimerTest.java | 64 ++--- .../monitoring/StreamLoggerTest.java | 10 +- .../monitoring/StreamTimerTest.java | 70 ++--- .../plumbing/IdentityStreamPipeTest.java | 12 +- .../plumbing/StreamBatchMergerTest.java | 6 +- .../plumbing/StreamMergerTest.java | 12 +- .../metafacture/plumbing/StreamTeeTest.java | 10 +- .../CooccurrenceMetricCalculatorTest.java | 23 +- .../metafacture/statistics/HistogramTest.java | 59 ++--- .../statistics/UniformSamplerTest.java | 17 +- .../metafacture/strings/LineRecorderTest.java | 17 +- .../metafacture/strings/LineSplitterTest.java | 23 +- .../metafacture/strings/RegexDecoderTest.java | 43 ++- .../strings/StreamUnicodeNormalizerTest.java | 34 +-- .../metafacture/strings/StringFilterTest.java | 19 +- .../strings/StringMatcherTest.java | 14 +- .../strings/UnicodeNormalizerTest.java | 9 +- .../triples/AbstractTripleSortTest.java | 19 +- .../triples/StreamToTriplesTest.java | 8 +- .../triples/TripleCollectTest.java | 21 +- .../metafacture/triples/TripleFilterTest.java | 24 +- .../triples/TripleObjectRetrieverTest.java | 33 +-- .../triples/TripleObjectWriterTest.java | 34 +-- .../triples/TripleReaderWriterTest.java | 21 +- .../metafacture/triples/TripleSortTest.java | 5 +- .../org/metafacture/xml/CGXmlHandlerTest.java | 23 +- .../xml/GenericXMLHandlerTest.java | 32 +-- .../metafacture/xml/SimpleXmlEncoderTest.java | 67 ++--- .../org/metafacture/xml/XmlDecoderTest.java | 19 +- .../xml/XmlElementSplitterTest.java | 9 +- .../xml/XmlFilenameWriterTest.java | 18 +- .../org/metafacture/yaml/YamlDecoderTest.java | 5 +- .../org/metafacture/yaml/YamlEncoderTest.java | 3 + .../metamorph/test/FrameworkTest.java | 6 +- .../metamorph/test/MetamorphTestCaseTest.java | 14 +- .../test/TestCaseRunnerMetamorphTest.java | 16 +- .../test/validators/StreamValidatorTest.java | 16 +- .../validators/WellformednessCheckerTest.java | 49 ++-- .../metamorph/InlineMorphTest.java | 3 + .../metafacture/metamorph/MetamorphTest.java | 21 +- .../metafacture/metamorph/SplitterTest.java | 6 +- .../metafacture/metamorph/TestHelpers.java | 4 + .../metamorph/TestMetamorphBasics.java | 47 ++-- .../metamorph/TestMetamorphMacros.java | 10 +- .../metamorph/collectors/AllTest.java | 19 +- .../metamorph/collectors/AnyTest.java | 19 +- .../metamorph/collectors/ChooseTest.java | 25 +- .../metamorph/collectors/CombineTest.java | 19 +- .../metamorph/collectors/ConcatTest.java | 19 +- .../metamorph/collectors/EntityTest.java | 35 +-- .../collectors/EqualsFilterTest.java | 25 +- .../metamorph/collectors/GroupTest.java | 9 +- .../metamorph/collectors/NoneTest.java | 19 +- .../metamorph/collectors/RangeTest.java | 21 +- .../metamorph/collectors/SquareTest.java | 11 +- .../collectors/TestCollectorBasics.java | 16 +- .../metamorph/collectors/TestCollectorIf.java | 21 +- .../metamorph/collectors/TuplesTest.java | 13 +- .../metamorph/functions/DateFormatTest.java | 9 +- .../metamorph/functions/ISBNTest.java | 54 ++-- .../metamorph/functions/LookupTest.java | 26 +- .../functions/NormalizeUTF8Test.java | 9 +- .../metamorph/functions/RegexpTest.java | 13 +- .../metamorph/functions/ScriptTest.java | 9 +- .../metamorph/functions/SplitTest.java | 9 +- .../functions/StringOperationsTest.java | 25 +- .../functions/SwitchNameValueTest.java | 9 +- .../functions/TestFunctionBasics.java | 14 +- .../functions/TestVariousFunctions.java | 38 +-- .../metamorph/functions/URLEncodeTest.java | 39 +-- .../metamorph/functions/UniqueTest.java | 11 +- .../metamorph/maps/FileMapTest.java | 45 ++-- .../metamorph/maps/JavaMapTest.java | 9 +- .../metamorph/xml/DomLoaderTest.java | 82 +++--- 157 files changed, 2655 insertions(+), 2316 deletions(-) rename metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/{AbstactFormatterTest.java => AbstractFormatterTest.java} (81%) diff --git a/build.gradle b/build.gradle index cd2d49de2..1832a496d 100644 --- a/build.gradle +++ b/build.gradle @@ -166,7 +166,6 @@ subprojects { checkstyle { toolVersion '10.21.2' - checkstyleTest.enabled = false } test { diff --git a/config/checkstyle/checkstyle.xml b/config/checkstyle/checkstyle.xml index e7a3851fb..05a0d588c 100644 --- a/config/checkstyle/checkstyle.xml +++ b/config/checkstyle/checkstyle.xml @@ -86,7 +86,9 @@ - + + + diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/AlephMabXmlHandlerTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/AlephMabXmlHandlerTest.java index 418e8e9b5..0e6af8e33 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/AlephMabXmlHandlerTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/AlephMabXmlHandlerTest.java @@ -16,10 +16,11 @@ package org.metafacture.biblio; +import org.metafacture.framework.StreamReceiver; + import org.junit.Before; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.Mockito; @@ -44,6 +45,9 @@ public final class AlephMabXmlHandlerTest { private AlephMabXmlHandler mabXmlHandler; + public AlephMabXmlHandlerTest() { + } + @Before public void setup() { mabXmlHandler = new AlephMabXmlHandler(); diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/AseqDecoderTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/AseqDecoderTest.java index ac74bf3d2..3fcc2ed3d 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/AseqDecoderTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/AseqDecoderTest.java @@ -16,15 +16,14 @@ package org.metafacture.biblio; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.never; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -41,7 +40,7 @@ public final class AseqDecoderTest { private static final String FIELD_LDR = " LDR L 00235nM2.01000024------h"; - private static final String FIELD_001_a_TEST = " 001 L $$atest"; + private static final String FIELD_001_A_TEST = " 001 L $$atest"; private static final String FIELD_200_TEST = "001304760 200 L $$kAckermann-Gemeinde$$9(DE-588)39042-2"; @@ -52,6 +51,9 @@ public final class AseqDecoderTest { @Mock private StreamReceiver receiver; + public AseqDecoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -68,7 +70,7 @@ public void cleanup() { public void shouldReturnRecordId() { this.aseqDecoder.process(RECORD_ID + FIELD_LDR); - final InOrder ordered = inOrder(this.receiver); + final InOrder ordered = Mockito.inOrder(this.receiver); ordered.verify(this.receiver).startRecord(RECORD_ID); } @@ -76,7 +78,7 @@ public void shouldReturnRecordId() { public void testShouldParseRecordStartingWithRecordMarker() { this.aseqDecoder.process(RECORD_ID + FIELD_LDR); - final InOrder ordered = inOrder(this.receiver); + final InOrder ordered = Mockito.inOrder(this.receiver); ordered.verify(this.receiver).startRecord(RECORD_ID); verifyLdrTest(ordered); ordered.verify(this.receiver).endRecord(); @@ -84,26 +86,26 @@ public void testShouldParseRecordStartingWithRecordMarker() { @Test public void testShouldParseRecordWithTwoFields() { - this.aseqDecoder.process(RECORD_ID + FIELD_LDR + FIELD_MARKER - + RECORD_ID + FIELD_001_a_TEST + FIELD_MARKER + FIELD_200_TEST); - final InOrder ordered = inOrder(this.receiver); + this.aseqDecoder.process(RECORD_ID + FIELD_LDR + FIELD_MARKER + + RECORD_ID + FIELD_001_A_TEST + FIELD_MARKER + FIELD_200_TEST); + final InOrder ordered = Mockito.inOrder(this.receiver); ordered.verify(this.receiver).startRecord(RECORD_ID); verifyLdrTest(ordered); - verify001_a_Test(ordered); + verify001aTest(ordered); verify200(ordered); ordered.verify(this.receiver).endRecord(); } private void verify200(final InOrder ordered) { ordered.verify(this.receiver).startEntity("200"); - ordered.verify(this.receiver, never()) + ordered.verify(this.receiver, Mockito.never()) .literal("0", "01304760 200 L "); ordered.verify(this.receiver).literal("k", "Ackermann-Gemeinde"); ordered.verify(this.receiver).literal("9", "(DE-588)39042-2"); ordered.verify(this.receiver).endEntity(); } - private void verify001_a_Test(final InOrder ordered) { + private void verify001aTest(final InOrder ordered) { ordered.verify(this.receiver).startEntity("001"); ordered.verify(this.receiver).literal("a", "test"); ordered.verify(this.receiver).endEntity(); diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/ComarcXmlHandlerTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/ComarcXmlHandlerTest.java index 6f8ba61a5..bd423c5ce 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/ComarcXmlHandlerTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/ComarcXmlHandlerTest.java @@ -16,13 +16,13 @@ package org.metafacture.biblio; -import static org.mockito.Mockito.verify; - import org.metafacture.framework.StreamReceiver; + import org.junit.After; import org.junit.Before; import org.junit.Test; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.xml.sax.SAXException; import org.xml.sax.helpers.AttributesImpl; @@ -45,6 +45,9 @@ public final class ComarcXmlHandlerTest { @Mock private StreamReceiver receiver; + public ComarcXmlHandlerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -80,9 +83,9 @@ public void shouldSetIdFrom000SubfieldX() throws SAXException { this.comarcXmlHandler.endElement(NAMESPACE, DATAFIELD, ""); this.comarcXmlHandler.endElement(NAMESPACE, RECORD, ""); - verify(this.receiver).literal("x", fieldValue); - verify(this.receiver).startRecord(fieldValue); - verify(this.receiver).endRecord(); + Mockito.verify(this.receiver).literal("x", fieldValue); + Mockito.verify(this.receiver).startRecord(fieldValue); + Mockito.verify(this.receiver).endRecord(); } @Test @@ -114,10 +117,10 @@ public void shouldAcceptRepeatableSubfields() throws SAXException { this.comarcXmlHandler.endElement(NAMESPACE, DATAFIELD, ""); this.comarcXmlHandler.endElement(NAMESPACE, RECORD, ""); - verify(this.receiver).literal("x", fieldValue1); - verify(this.receiver).literal("x", fieldValue2); - verify(this.receiver).startRecord(fieldValue1); - verify(this.receiver).endRecord(); + Mockito.verify(this.receiver).literal("x", fieldValue1); + Mockito.verify(this.receiver).literal("x", fieldValue2); + Mockito.verify(this.receiver).startRecord(fieldValue1); + Mockito.verify(this.receiver).endRecord(); } @Test @@ -170,13 +173,13 @@ public void shouldReadTwoFields() throws SAXException { this.comarcXmlHandler.endElement(NAMESPACE, RECORD, ""); - verify(this.receiver).literal("x", fieldValue1); - verify(this.receiver).literal("x", fieldValue2); - verify(this.receiver).startRecord(fieldValue1); - verify(this.receiver).endRecord(); - verify(this.receiver).startEntity("000 "); - verify(this.receiver).startEntity("001 2"); - verify(this.receiver).literal("a", fieldValue1); + Mockito.verify(this.receiver).literal("x", fieldValue1); + Mockito.verify(this.receiver).literal("x", fieldValue2); + Mockito.verify(this.receiver).startRecord(fieldValue1); + Mockito.verify(this.receiver).endRecord(); + Mockito.verify(this.receiver).startEntity("000 "); + Mockito.verify(this.receiver).startEntity("001 2"); + Mockito.verify(this.receiver).literal("a", fieldValue1); } } diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/MabDecoderTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/MabDecoderTest.java index 51d477c9b..9c47e10e4 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/MabDecoderTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/MabDecoderTest.java @@ -16,15 +16,13 @@ package org.metafacture.biblio; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -41,6 +39,9 @@ public final class MabDecoderTest { private MabDecoder mabDecoder; + public MabDecoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -56,7 +57,7 @@ public void shouldParseMabRecord() { "705b\u001FcSubfield 3\u001FdSubfield 4\u001E" + "\u001D"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1234"); ordered.verify(receiver).literal("001", "1234"); ordered.verify(receiver).startEntity("705a"); @@ -75,8 +76,8 @@ public void shouldSkipWhitespaceOnlyInput() { mabDecoder.process(" "); mabDecoder.closeStream(); - verify(receiver).closeStream(); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).closeStream(); + Mockito.verifyNoMoreInteractions(receiver); } } diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/DirectoryEntryTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/DirectoryEntryTest.java index acfe63097..a343a48ad 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/DirectoryEntryTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/DirectoryEntryTest.java @@ -16,16 +16,13 @@ package org.metafacture.biblio.iso2709; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -import java.nio.charset.Charset; +import org.metafacture.commons.StringUtil; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; -import org.metafacture.commons.StringUtil; + +import java.nio.charset.Charset; /** * Tests for class {@link DirectoryEntry}. @@ -43,6 +40,9 @@ public class DirectoryEntryTest { private DirectoryEntry directoryEntry; + public DirectoryEntryTest() { + } + @Before public void createSystemUnderTest() { final RecordFormat recordFormat = RecordFormat.create() @@ -55,92 +55,92 @@ public void createSystemUnderTest() { } @Test - public void constructor_shouldSetFirstEntryAsCurrentEntry() { - assertArrayEquals("001".toCharArray(), directoryEntry.getTag()); + public void constructorShouldSetFirstEntryAsCurrentEntry() { + Assert.assertArrayEquals("001".toCharArray(), directoryEntry.getTag()); } @Test - public void gotoNext_shouldSetNextEntryAsCurrentEntry() { + public void gotoNextShouldSetNextEntryAsCurrentEntry() { directoryEntry.gotoNext(); - assertArrayEquals("002".toCharArray(), directoryEntry.getTag()); + Assert.assertArrayEquals("002".toCharArray(), directoryEntry.getTag()); } @Test - public void reset_shouldSetFirstEntryAsCurrentEntry() { + public void resetShouldSetFirstEntryAsCurrentEntry() { directoryEntry.gotoNext(); directoryEntry.rewind(); - assertArrayEquals("001".toCharArray(), directoryEntry.getTag()); + Assert.assertArrayEquals("001".toCharArray(), directoryEntry.getTag()); } @Test - public void endOfDirectoryReached_shouldReturnFalseIfNotAtEndOFDirectory() { - assertFalse(directoryEntry.endOfDirectoryReached()); + public void endOfDirectoryReachedShouldReturnFalseIfNotAtEndOFDirectory() { + Assert.assertFalse(directoryEntry.endOfDirectoryReached()); } @Test - public void endOfDirectoryReached_shouldReturnTrueIfAtEndOFDirectory() { + public void endOfDirectoryReachedShouldReturnTrueIfAtEndOFDirectory() { directoryEntry.gotoNext(); directoryEntry.gotoNext(); directoryEntry.gotoNext(); directoryEntry.gotoNext(); - assertTrue(directoryEntry.endOfDirectoryReached()); + Assert.assertTrue(directoryEntry.endOfDirectoryReached()); } @Test - public void getTag_shouldReturnTagFromCurrentEntry() { - assertArrayEquals("001".toCharArray(), directoryEntry.getTag()); + public void getTagShouldReturnTagFromCurrentEntry() { + Assert.assertArrayEquals("001".toCharArray(), directoryEntry.getTag()); directoryEntry.gotoNext(); - assertArrayEquals("002".toCharArray(), directoryEntry.getTag()); + Assert.assertArrayEquals("002".toCharArray(), directoryEntry.getTag()); } @Test - public void getFieldLength_shouldReturnFieldLengthFromCurrentEntry() { - assertEquals(2, directoryEntry.getFieldLength()); + public void getFieldLengthShouldReturnFieldLengthFromCurrentEntry() { + Assert.assertEquals(2, directoryEntry.getFieldLength()); directoryEntry.gotoNext(); - assertEquals(5, directoryEntry.getFieldLength()); + Assert.assertEquals(5, directoryEntry.getFieldLength()); } @Test - public void getFieldStart_shouldReturnFieldStartFromCurrentEntry() { - assertEquals(34, directoryEntry.getFieldStart()); + public void getFieldStartShouldReturnFieldStartFromCurrentEntry() { + Assert.assertEquals(34, directoryEntry.getFieldStart()); directoryEntry.gotoNext(); - assertEquals(67, directoryEntry.getFieldStart()); + Assert.assertEquals(67, directoryEntry.getFieldStart()); } @Test - public void getImplDefinedPart_shouldReturnImplDefinedPartFromCurrentEntry() { - assertArrayEquals("IMP".toCharArray(), directoryEntry.getImplDefinedPart()); + public void getImplDefinedPartShouldReturnImplDefinedPartFromCurrentEntry() { + Assert.assertArrayEquals("IMP".toCharArray(), directoryEntry.getImplDefinedPart()); directoryEntry.gotoNext(); - assertArrayEquals("LEM".toCharArray(), directoryEntry.getImplDefinedPart()); + Assert.assertArrayEquals("LEM".toCharArray(), directoryEntry.getImplDefinedPart()); } @Test - public void isRecordIdField_shouldReturnOnlyTrueIfTagIs001() { - assertTrue(directoryEntry.isRecordIdField()); + public void isRecordIdFieldShouldReturnOnlyTrueIfTagIs001() { + Assert.assertTrue(directoryEntry.isRecordIdField()); directoryEntry.gotoNext(); - assertFalse(directoryEntry.isRecordIdField()); + Assert.assertFalse(directoryEntry.isRecordIdField()); directoryEntry.gotoNext(); - assertFalse(directoryEntry.isRecordIdField()); + Assert.assertFalse(directoryEntry.isRecordIdField()); } @Test - public void isReferenceField_shouldReturnOnlyTrueIfTagStartsWith00() { - assertTrue(directoryEntry.isReferenceField()); + public void isReferenceFieldShouldReturnOnlyTrueIfTagStartsWith00() { + Assert.assertTrue(directoryEntry.isReferenceField()); directoryEntry.gotoNext(); - assertTrue(directoryEntry.isReferenceField()); + Assert.assertTrue(directoryEntry.isReferenceField()); directoryEntry.gotoNext(); - assertFalse(directoryEntry.isReferenceField()); + Assert.assertFalse(directoryEntry.isReferenceField()); } @Test - public void isContinuedField_shouldReturnTrueIfFieldHasZeroLength() { - assertFalse(directoryEntry.isContinuedField()); + public void isContinuedFieldShouldReturnTrueIfFieldHasZeroLength() { + Assert.assertFalse(directoryEntry.isContinuedField()); directoryEntry.gotoNext(); - assertFalse(directoryEntry.isContinuedField()); + Assert.assertFalse(directoryEntry.isContinuedField()); directoryEntry.gotoNext(); - assertTrue(directoryEntry.isContinuedField()); + Assert.assertTrue(directoryEntry.isContinuedField()); directoryEntry.gotoNext(); - assertFalse(directoryEntry.isContinuedField()); + Assert.assertFalse(directoryEntry.isContinuedField()); } private static byte[] asBytes(final String str) { diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/Iso646ByteBufferTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/Iso646ByteBufferTest.java index d575429e1..c65112f99 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/Iso646ByteBufferTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/Iso646ByteBufferTest.java @@ -16,13 +16,12 @@ package org.metafacture.biblio.iso2709; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; - -import java.nio.charset.StandardCharsets; +import org.metafacture.framework.FormatException; +import org.junit.Assert; import org.junit.Test; -import org.metafacture.framework.FormatException; + +import java.nio.charset.StandardCharsets; /** * Tests for class {@link Iso646ByteBuffer}. @@ -35,240 +34,243 @@ public final class Iso646ByteBufferTest { private Iso646ByteBuffer byteBuffer; + public Iso646ByteBufferTest() { + } + @Test - public void getLength_shouldReturnRecordLength() { + public void getLengthShouldReturnRecordLength() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - assertEquals(3, byteBuffer.getLength()); + Assert.assertEquals(3, byteBuffer.getLength()); } @Test - public void getFreeSpace_shouldReturnBufferLengthIfNothingWasWritten() { + public void getFreeSpaceShouldReturnBufferLengthIfNothingWasWritten() { byteBuffer = new Iso646ByteBuffer(5); - assertEquals(5, byteBuffer.getFreeSpace()); + Assert.assertEquals(5, byteBuffer.getFreeSpace()); } @Test - public void getFreeSpace_shouldReturnSpaceBetweenWritePositionAndBufferEnd() { + public void getFreeSpaceShouldReturnSpaceBetweenWritePositionAndBufferEnd() { byteBuffer = new Iso646ByteBuffer(5); byteBuffer.setWritePosition(2); - assertEquals(3, byteBuffer.getFreeSpace()); + Assert.assertEquals(3, byteBuffer.getFreeSpace()); } @Test - public void getFreeSpace_shouldReturnZeroIfBufferIsFull() { + public void getFreeSpaceShouldReturnZeroIfBufferIsFull() { byteBuffer = new Iso646ByteBuffer(5); byteBuffer.setWritePosition(5); - assertEquals(0, byteBuffer.getFreeSpace()); + Assert.assertEquals(0, byteBuffer.getFreeSpace()); } @Test - public void distanceTo_byte_shouldReturnDistanceToFirstMatchingByte() { + public void distanceToByteShouldReturnDistanceToFirstMatchingByte() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - assertEquals(2, byteBuffer.distanceTo((byte) 'x', 0)); + Assert.assertEquals(2, byteBuffer.distanceTo((byte) 'x', 0)); } @Test - public void distanceTo_byte_shouldReturnDistanceToEndOfBufferIfNoMatchFound() { + public void distanceToByteShouldReturnDistanceToEndOfBufferIfNoMatchFound() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - assertEquals(3, byteBuffer.distanceTo((byte) 'X', 0)); + Assert.assertEquals(3, byteBuffer.distanceTo((byte) 'X', 0)); } @Test - public void distanceTo_byte_shouldReturnZeroIfSearchStartsAtMatchingByte() { + public void distanceToByteShouldReturnZeroIfSearchStartsAtMatchingByte() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - assertEquals(0, byteBuffer.distanceTo((byte) 'T', 0)); + Assert.assertEquals(0, byteBuffer.distanceTo((byte) 'T', 0)); } @Test - public void distanceTo_byteArray_shouldReturnDistanceToFirstMatchingByte() { + public void distanceToByteArrayShouldReturnDistanceToFirstMatchingByte() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - assertEquals(2, byteBuffer.distanceTo(asBytes("x"), 0)); + Assert.assertEquals(2, byteBuffer.distanceTo(asBytes("x"), 0)); } @Test - public void distanceTo_byteArray_shouldReturnDistanceToEndOfBufferIfNoMatchFound() { + public void distanceToByteArrayShouldReturnDistanceToEndOfBufferIfNoMatchFound() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - assertEquals(3, byteBuffer.distanceTo(asBytes("X"), 0)); + Assert.assertEquals(3, byteBuffer.distanceTo(asBytes("X"), 0)); } @Test - public void distanceTo_byteArray_shouldReturnZeroIfSearchStartsAtMatchingByte() { + public void distanceToByteArrayShouldReturnZeroIfSearchStartsAtMatchingByte() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - assertEquals(0, byteBuffer.distanceTo(asBytes("T"), 0)); + Assert.assertEquals(0, byteBuffer.distanceTo(asBytes("T"), 0)); } @Test - public void distanceTo_byteArray_shouldReturnDistanceToFirstMatchingByteOfTheBytesArray() { + public void distanceToByteArrayShouldReturnDistanceToFirstMatchingByteOfTheBytesArray() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - assertEquals(1, byteBuffer.distanceTo(asBytes("xu"), 0)); + Assert.assertEquals(1, byteBuffer.distanceTo(asBytes("xu"), 0)); } @Test - public void stringAt_shouldReturnStringDecodedAsUtf8() { + public void stringAtShouldReturnStringDecodedAsUtf8() { byteBuffer = new Iso646ByteBuffer(asBytes("Tüx Tox")); - assertEquals("Tüx Tox", byteBuffer.stringAt(0, byteBuffer.getLength(), + Assert.assertEquals("Tüx Tox", byteBuffer.stringAt(0, byteBuffer.getLength(), StandardCharsets.UTF_8)); } @Test - public void stringAt_shouldReturnEmptyStringIfLengthIsZero() { + public void stringAtShouldReturnEmptyStringIfLengthIsZero() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - assertEquals("", byteBuffer.stringAt(0, 0, StandardCharsets.UTF_8)); + Assert.assertEquals("", byteBuffer.stringAt(0, 0, StandardCharsets.UTF_8)); } @Test - public void charAt_shouldReturnCharacterAtIndexDecodedAsIso646() { + public void charAtShouldReturnCharacterAtIndexDecodedAsIso646() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - assertEquals('T', byteBuffer.charAt(0)); + Assert.assertEquals('T', byteBuffer.charAt(0)); } @Test(expected = FormatException.class) - public void charAt_shouldThrowFormatExceptionIfByteValueIsNotInIso646() { + public void charAtShouldThrowFormatExceptionIfByteValueIsNotInIso646() { byteBuffer = new Iso646ByteBuffer(asBytes("ü")); - byteBuffer.charAt(0); // Exception expected + byteBuffer.charAt(0); // Exception expected } @Test - public void charsAt_shouldReturnBytesAsCharacterArrayDecodedAsIso646() { + public void charsAtShouldReturnBytesAsCharacterArrayDecodedAsIso646() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux Tox")); - assertArrayEquals("Tux".toCharArray(), byteBuffer.charsAt(0, 3)); + Assert.assertArrayEquals("Tux".toCharArray(), byteBuffer.charsAt(0, 3)); } @Test(expected = FormatException.class) - public void charsAt_shouldThrowFormatExceptionIfByteValueIsNotInIso646() { + public void charsAtShouldThrowFormatExceptionIfByteValueIsNotInIso646() { byteBuffer = new Iso646ByteBuffer(asBytes("Tüx Tox")); - byteBuffer.charsAt(0, 4); // Exception expected + byteBuffer.charsAt(0, 4); // Exception expected } @Test - public void charsAt_shouldReturnEmptyCharacterArrayIfLengthIsZero() { + public void charsAtShouldReturnEmptyCharacterArrayIfLengthIsZero() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - assertArrayEquals(new char[0], byteBuffer.charsAt(0, 0)); + Assert.assertArrayEquals(new char[0], byteBuffer.charsAt(0, 0)); } @Test - public void byteAt_shouldReturnByteAtIndex() { - byteBuffer = new Iso646ByteBuffer(new byte[] { 0x01, 0x02 }); - assertEquals(0x02, byteBuffer.byteAt(1)); + public void byteAtShouldReturnByteAtIndex() { + byteBuffer = new Iso646ByteBuffer(new byte[]{0x01, 0x02}); + Assert.assertEquals(0x02, byteBuffer.byteAt(1)); } @Test - public void parseIntAt_shouldReturnIntValueAtIndex() { + public void parseIntAtShouldReturnIntValueAtIndex() { byteBuffer = new Iso646ByteBuffer(asBytes("299")); - assertEquals(2, byteBuffer.parseIntAt(0)); + Assert.assertEquals(2, byteBuffer.parseIntAt(0)); } @Test(expected = NumberFormatException.class) - public void parseIntAt_shouldThrowFormatExceptionIfNotADigit() { + public void parseIntAtShouldThrowFormatExceptionIfNotADigit() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - byteBuffer.parseIntAt(0); // Exception expected + byteBuffer.parseIntAt(0); // Exception expected } @Test - public void parseIntAt_shouldReturnIntValueForRange() { + public void parseIntAtShouldReturnIntValueForRange() { byteBuffer = new Iso646ByteBuffer(asBytes("299")); - assertEquals(299, byteBuffer.parseIntAt(0, 3)); + Assert.assertEquals(299, byteBuffer.parseIntAt(0, 3)); } @Test - public void parseIntAt_shouldReturnZeroIfLengthIsZero() { + public void parseIntAtShouldReturnZeroIfLengthIsZero() { byteBuffer = new Iso646ByteBuffer(asBytes("123")); - assertEquals(0, byteBuffer.parseIntAt(0, 0)); + Assert.assertEquals(0, byteBuffer.parseIntAt(0, 0)); } @Test(expected = NumberFormatException.class) - public void parseIntAt_shouldThrowFormatExceptionIfNotANumber() { + public void parseIntAtShouldThrowFormatExceptionIfNotANumber() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux")); - byteBuffer.parseIntAt(0, 3); // Exception expected + byteBuffer.parseIntAt(0, 3); // Exception expected } @Test(expected = NumberFormatException.class) - public void parseIntAt_shouldThrowFormatExceptionIfNumberIsTooLarge() { + public void parseIntAtShouldThrowFormatExceptionIfNumberIsTooLarge() { byteBuffer = new Iso646ByteBuffer(asBytes("123456789123456789")); - byteBuffer.parseIntAt(0, 18); // Exception expected + byteBuffer.parseIntAt(0, 18); // Exception expected } @Test - public void writeChar_shouldWriteCharAtWritePosition() { + public void writeCharShouldWriteCharAtWritePosition() { byteBuffer = new Iso646ByteBuffer(3); byteBuffer.setWritePosition(1); byteBuffer.writeChar('c'); - assertArrayEquals(new byte[]{ 0x00, 0x63, 0x00 }, + Assert.assertArrayEquals(new byte[]{0x00, 0x63, 0x00}, byteBuffer.getByteArray()); - assertEquals(2, byteBuffer.getWritePosition()); + Assert.assertEquals(2, byteBuffer.getWritePosition()); } @Test - public void writeChars_shouldWriteCharArrayAtWritePosition() { + public void writeCharsShouldWriteCharArrayAtWritePosition() { byteBuffer = new Iso646ByteBuffer(4); byteBuffer.setWritePosition(1); - byteBuffer.writeChars(new char[]{ 'c', 'b' }); + byteBuffer.writeChars(new char[]{'c', 'b'}); - assertArrayEquals(new byte[]{ 0x00, 0x63, 0x62, 0x00 }, + Assert.assertArrayEquals(new byte[]{0x00, 0x63, 0x62, 0x00}, byteBuffer.getByteArray()); - assertEquals(3, byteBuffer.getWritePosition()); + Assert.assertEquals(3, byteBuffer.getWritePosition()); } @Test - public void writeByte_shouldWriteByteAtWritePosition() { + public void writeByteShouldWriteByteAtWritePosition() { byteBuffer = new Iso646ByteBuffer(3); byteBuffer.setWritePosition(1); byteBuffer.writeByte((byte) 0x61); - assertArrayEquals(new byte[]{ 0x00, 0x61, 0x00 }, + Assert.assertArrayEquals(new byte[]{0x00, 0x61, 0x00}, byteBuffer.getByteArray()); - assertEquals(2, byteBuffer.getWritePosition()); + Assert.assertEquals(2, byteBuffer.getWritePosition()); } @Test - public void writeBytes_shouldWriteByteArrayAtWritePosition() { + public void writeBytesShouldWriteByteArrayAtWritePosition() { byteBuffer = new Iso646ByteBuffer(4); byteBuffer.setWritePosition(1); byteBuffer.writeBytes(asBytes("cb")); - assertArrayEquals(new byte[]{ 0x00, 0x63, 0x62, 0x00 }, + Assert.assertArrayEquals(new byte[]{0x00, 0x63, 0x62, 0x00}, byteBuffer.getByteArray()); - assertEquals(3, byteBuffer.getWritePosition()); + Assert.assertEquals(3, byteBuffer.getWritePosition()); } @Test - public void writeInt_shouldWriteAsciiCodeOfSingleDigitAtWritePosition() { + public void writeIntShouldWriteAsciiCodeOfSingleDigitAtWritePosition() { byteBuffer = new Iso646ByteBuffer(3); byteBuffer.setWritePosition(1); byteBuffer.writeInt(3); - assertArrayEquals(new byte[]{ 0x00, 0x33, 0x00 }, + Assert.assertArrayEquals(new byte[]{0x00, 0x33, 0x00}, byteBuffer.getByteArray()); - assertEquals(2, byteBuffer.getWritePosition()); + Assert.assertEquals(2, byteBuffer.getWritePosition()); } @Test - public void writeInt_shouldWriteAsciiCodesOfDigitsAtWritePosition() { + public void writeIntShouldWriteAsciiCodesOfDigitsAtWritePosition() { byteBuffer = new Iso646ByteBuffer(5); byteBuffer.setWritePosition(1); byteBuffer.writeInt(123, 3); - assertArrayEquals(new byte[]{ 0x00, 0x31, 0x32, 0x33, 0x00 }, + Assert.assertArrayEquals(new byte[]{0x00, 0x31, 0x32, 0x33, 0x00}, byteBuffer.getByteArray()); - assertEquals(4, byteBuffer.getWritePosition()); + Assert.assertEquals(4, byteBuffer.getWritePosition()); } @Test - public void writeInt_shouldAddLeadingZerosIfNumberIsShorterThanDigits() { + public void writeIntShouldAddLeadingZerosIfNumberIsShorterThanDigits() { byteBuffer = new Iso646ByteBuffer(5); byteBuffer.setWritePosition(1); byteBuffer.writeInt(3, 3); - assertArrayEquals(new byte[]{ 0x00, 0x30, 0x30, 0x33, 0x00 }, + Assert.assertArrayEquals(new byte[]{0x00, 0x30, 0x30, 0x33, 0x00}, byteBuffer.getByteArray()); - assertEquals(4, byteBuffer.getWritePosition()); + Assert.assertEquals(4, byteBuffer.getWritePosition()); } @Test - public void toString_shouldReturnBufferContentDecodedAsISO646() { + public void toStringShouldReturnBufferContentDecodedAsISO646() { byteBuffer = new Iso646ByteBuffer(asBytes("Tux tüt")); - assertEquals("Tux t" + ASCII_UNMAPPABLE_CHAR + ASCII_UNMAPPABLE_CHAR + "t", + Assert.assertEquals("Tux t" + ASCII_UNMAPPABLE_CHAR + ASCII_UNMAPPABLE_CHAR + "t", byteBuffer.toString()); } diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/LabelTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/LabelTest.java index 7697f59d6..53765fa27 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/LabelTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/LabelTest.java @@ -16,10 +16,7 @@ package org.metafacture.biblio.iso2709; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; - +import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -33,10 +30,10 @@ public final class LabelTest { private static final int RECORD_LENGTH = 26; private static final char RECORD_STATUS = 'S'; - private static final char[] IMPL_CODES = { 'I', 'M', 'P', 'L' }; + private static final char[] IMPL_CODES = {'I', 'M', 'P', 'L'}; private static final int INDICATOR_LENGTH = 1; private static final int IDENTIFIER_LENGTH = 2; - private static final char[] SYSTEM_CHARS = { 'S', 'Y', 'S' }; + private static final char[] SYSTEM_CHARS = {'S', 'Y', 'S'}; private static final int FIELD_LENGTH_LENGTH = 3; private static final int FIELD_START_LENGTH = 4; private static final int IMPL_DEFINED_PART_LENGTH = 5; @@ -57,6 +54,9 @@ public final class LabelTest { private Label label; + public LabelTest() { + } + @Before public void createSystemUnderTest() { final byte[] recordLabelBytes = RECORD_LABEL.getBytes( @@ -66,10 +66,10 @@ public void createSystemUnderTest() { } @Test - public void getRecordFormat_shouldReturnRecordFormatObject() { + public void getRecordFormatShouldReturnRecordFormatObject() { final RecordFormat recordFormat = label.getRecordFormat(); - assertNotNull(recordFormat); + Assert.assertNotNull(recordFormat); final RecordFormat expectedFormat = RecordFormat.create() .withIndicatorLength(INDICATOR_LENGTH) .withIdentifierLength(IDENTIFIER_LENGTH) @@ -77,67 +77,67 @@ public void getRecordFormat_shouldReturnRecordFormatObject() { .withFieldLengthLength(FIELD_LENGTH_LENGTH) .withImplDefinedPartLength(IMPL_DEFINED_PART_LENGTH) .build(); - assertEquals(expectedFormat, recordFormat); + Assert.assertEquals(expectedFormat, recordFormat); } @Test - public void getRecordLength_shouldReturnRecordLength() { - assertEquals(RECORD_LENGTH, label.getRecordLength()); + public void getRecordLengthShouldReturnRecordLength() { + Assert.assertEquals(RECORD_LENGTH, label.getRecordLength()); } @Test - public void getRecordStatus_shouldReturnRecordStatus() { - assertEquals(RECORD_STATUS, label.getRecordStatus()); + public void getRecordStatusShouldReturnRecordStatus() { + Assert.assertEquals(RECORD_STATUS, label.getRecordStatus()); } @Test - public void getImplCodes_shouldReturnImplCodes() { - assertArrayEquals(IMPL_CODES, label.getImplCodes()); + public void getImplCodesShouldReturnImplCodes() { + Assert.assertArrayEquals(IMPL_CODES, label.getImplCodes()); } @Test - public void getIndicatorLength_shouldReturnIndicatorLength() { - assertEquals(INDICATOR_LENGTH, label.getIndicatorLength()); + public void getIndicatorLengthShouldReturnIndicatorLength() { + Assert.assertEquals(INDICATOR_LENGTH, label.getIndicatorLength()); } @Test - public void getIdentifierLength_shouldReturnIdentifierLength() { - assertEquals(IDENTIFIER_LENGTH, label.getIdentifierLength()); + public void getIdentifierLengthShouldReturnIdentifierLength() { + Assert.assertEquals(IDENTIFIER_LENGTH, label.getIdentifierLength()); } @Test - public void getBaseAddress_shouldReturnBaseAddress() { - assertEquals(BASE_ADDRESS, label.getBaseAddress()); + public void getBaseAddressShouldReturnBaseAddress() { + Assert.assertEquals(BASE_ADDRESS, label.getBaseAddress()); } @Test - public void getSystemChars_shouldReturnUserSystemChars() { - assertArrayEquals(SYSTEM_CHARS, label.getSystemChars()); + public void getSystemCharsShouldReturnUserSystemChars() { + Assert.assertArrayEquals(SYSTEM_CHARS, label.getSystemChars()); } @Test - public void getFieldLengthLength_shouldReturnFieldLengthLength() { - assertEquals(FIELD_LENGTH_LENGTH, label.getFieldLengthLength()); + public void getFieldLengthLengthShouldReturnFieldLengthLength() { + Assert.assertEquals(FIELD_LENGTH_LENGTH, label.getFieldLengthLength()); } @Test - public void getFieldStartLength_shouldReturnFieldStartLength() { - assertEquals(FIELD_START_LENGTH, label.getFieldStartLength()); + public void getFieldStartLengthShouldReturnFieldStartLength() { + Assert.assertEquals(FIELD_START_LENGTH, label.getFieldStartLength()); } @Test - public void getImplDefinedPartLength_shouldReturnImplDefinedPartLength() { - assertEquals(IMPL_DEFINED_PART_LENGTH, label.getImplDefinedPartLength()); + public void getImplDefinedPartLengthShouldReturnImplDefinedPartLength() { + Assert.assertEquals(IMPL_DEFINED_PART_LENGTH, label.getImplDefinedPartLength()); } @Test - public void getReservedChar_shouldReturnReservedChar() { - assertEquals(RESERVED_CHAR, label.getReservedChar()); + public void getReservedCharShouldReturnReservedChar() { + Assert.assertEquals(RESERVED_CHAR, label.getReservedChar()); } @Test - public void toString_shouldReturnRecordLabel() { - assertEquals(RECORD_LABEL, label.toString()); + public void toStringShouldReturnRecordLabel() { + Assert.assertEquals(RECORD_LABEL, label.toString()); } } diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordBuilderTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordBuilderTest.java index ec8c3d3f2..9821bcf8f 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordBuilderTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordBuilderTest.java @@ -16,15 +16,14 @@ package org.metafacture.biblio.iso2709; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - -import java.nio.charset.StandardCharsets; +import org.metafacture.commons.StringUtil; +import org.metafacture.framework.FormatException; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; -import org.metafacture.commons.StringUtil; -import org.metafacture.framework.FormatException; + +import java.nio.charset.StandardCharsets; /** * Tests for class {@link RecordBuilder}. @@ -37,6 +36,9 @@ public final class RecordBuilderTest { private RecordFormat format; private RecordBuilder builder; + public RecordBuilderTest() { + } + @Before public void createSystemUnderTest() { format = RecordFormat.create() @@ -63,12 +65,12 @@ public void shouldWriteRecordFormatToRecordLabel() { .withFieldLengthLength(5) .withImplDefinedPartLength(6) .build(); - final RecordBuilder builder = new RecordBuilder(format); + builder = new RecordBuilder(format); final byte[] record = builder.build(); - assertEquals("23", asString(record, 10, 12)); - assertEquals("546", asString(record, 20, 23)); + Assert.assertEquals("23", asString(record, 10, 12)); + Assert.assertEquals("546", asString(record, 20, 23)); } @Test @@ -77,22 +79,22 @@ public void shouldWriteRecordStatusToRecordLabel() { final byte[] record = builder.build(); - assertEquals(0x53, record[5]); + Assert.assertEquals(0x53, record[5]); } @Test public void shouldWriteSpaceIfRecordStatusNotSet() { final byte[] record = builder.build(); - assertEquals(0x20, record[5]); + Assert.assertEquals(0x20, record[5]); } - @Test(expected=IllegalArgumentException.class) + @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfRecordStatusIsNot7BitAscii() { builder.setRecordStatus('\u00df'); // Exception expected } - @Test(expected=IllegalArgumentException.class) + @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfRecordStatusIsInformationSeparator() { builder.setRecordStatus('\u001e'); // Exception expected } @@ -103,20 +105,20 @@ public void shouldWriteImplCodesToRecordLabel() { final byte[] record = builder.build(); - assertEquals(0x49, record[6]); - assertEquals(0x4d, record[7]); - assertEquals(0x50, record[8]); - assertEquals(0x4c, record[9]); + Assert.assertEquals(0x49, record[6]); + Assert.assertEquals(0x4d, record[7]); + Assert.assertEquals(0x50, record[8]); + Assert.assertEquals(0x4c, record[9]); } @Test public void shouldWriteSpacesIfImplCodesNotSet() { final byte[] record = builder.build(); - assertEquals(0x20, record[6]); - assertEquals(0x20, record[7]); - assertEquals(0x20, record[8]); - assertEquals(0x20, record[9]); + Assert.assertEquals(0x20, record[6]); + Assert.assertEquals(0x20, record[7]); + Assert.assertEquals(0x20, record[8]); + Assert.assertEquals(0x20, record[9]); } @Test(expected = IllegalArgumentException.class) @@ -129,7 +131,7 @@ public void shouldThrowExceptionIfLengthOfImplCodesIsGreaterThanFour() { builder.setImplCodes(asChars("12345")); // Exception expected } - @Test(expected=IllegalArgumentException.class) + @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfImplCodesAreNot7BitAscii() { builder.setImplCodes(asChars("12\u00df4")); // Exception expected } @@ -145,18 +147,18 @@ public void shouldWriteSystemCharsToRecordLabel() { final byte[] record = builder.build(); - assertEquals(0x55, record[17]); - assertEquals(0x53, record[18]); - assertEquals(0x43, record[19]); + Assert.assertEquals(0x55, record[17]); + Assert.assertEquals(0x53, record[18]); + Assert.assertEquals(0x43, record[19]); } @Test public void shouldWriteSpacesIfSystemCharsNotSet() { final byte[] record = builder.build(); - assertEquals(0x20, record[17]); - assertEquals(0x20, record[18]); - assertEquals(0x20, record[19]); + Assert.assertEquals(0x20, record[17]); + Assert.assertEquals(0x20, record[18]); + Assert.assertEquals(0x20, record[19]); } @Test(expected = IllegalArgumentException.class) @@ -169,12 +171,12 @@ public void shouldThrowExceptionIfLengthOfSystemCharsIsGreaterThanThree() { builder.setSystemChars(asChars("1234")); // Exception expected } - @Test(expected=IllegalArgumentException.class) + @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfSystemCharsAreNot7BitAscii() { builder.setSystemChars(asChars("1\u00df3")); // Exception expected } - @Test(expected=IllegalArgumentException.class) + @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfSystemCharIsInformationSeparator() { builder.setSystemChars(asChars("1\u001e3")); // Exception expected } @@ -192,10 +194,11 @@ public void shouldWriteSystemCharToRecordLabel() { final byte[] record = builder.build(); - assertEquals(0x55, record[17]); - assertEquals(0x53, record[18]); - assertEquals(0x43, record[19]); + Assert.assertEquals(0x55, record[17]); + Assert.assertEquals(0x53, record[18]); + Assert.assertEquals(0x43, record[19]); } + @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionIfSystemCharIndexGreaterThan2() { builder.setSystemChar(3, '1'); @@ -207,22 +210,22 @@ public void shouldWriteReserverdCharToRecordLabel() { final byte[] record = builder.build(); - assertEquals(0x52, record[23]); + Assert.assertEquals(0x52, record[23]); } @Test public void shouldWriteSpaceIfReservedCharNotSet() { final byte[] record = builder.build(); - assertEquals(0x20, record[23]); + Assert.assertEquals(0x20, record[23]); } - @Test(expected=IllegalArgumentException.class) + @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfReservedCharIsNot7BitAscii() { builder.setReservedChar('\u00df'); // Exception expected } - @Test(expected=IllegalArgumentException.class) + @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfReservedCharIsInformationSeparator() { builder.setReservedChar('\u001d'); // Exception expected } @@ -233,8 +236,8 @@ public void shouldAppendReferenceFieldToRecord() { final byte[] record = builder.build(); - assertEquals("00206000IM", asString(record, 24, 34)); - assertEquals("Value\u001e", asString(record, 35, 41)); + Assert.assertEquals("00206000IM", asString(record, 24, 34)); + Assert.assertEquals("Value\u001e", asString(record, 35, 41)); } @Test @@ -244,9 +247,9 @@ public void shouldWriteTwoDirectoryEntriesForReferenceFieldsWithLongValue() { final byte[] record = builder.build(); - assertEquals("00200000", asString(record, 24, 32)); - assertEquals("00212099", asString(record, 34, 42)); - assertEquals(longValue + '\u001e', asString(record, 45, 156)); + Assert.assertEquals("00200000", asString(record, 24, 32)); + Assert.assertEquals("00212099", asString(record, 34, 42)); + Assert.assertEquals(longValue + '\u001e', asString(record, 45, 156)); } @Test @@ -255,7 +258,7 @@ public void shouldFillImplDefinedPartOfReferenceFieldWithSpacesIfNotProvided() { final byte[] record = builder.build(); - assertEquals("00206000 ", asString(record, 24, 34)); + Assert.assertEquals("00206000 ", asString(record, 24, 34)); } @Test @@ -263,12 +266,12 @@ public void shouldAppendReferenceFieldWithoutImplDefinedPart() { format = RecordFormat.createFrom(format) .withImplDefinedPartLength(0) .build(); - final RecordBuilder builder = new RecordBuilder(format); + builder = new RecordBuilder(format); builder.appendReferenceField(asChars("002"), "Value"); final byte[] record = builder.build(); - assertEquals("00206000\u001e", asString(record, 24, 33)); + Assert.assertEquals("00206000\u001e", asString(record, 24, 33)); } @Test(expected = FormatException.class) @@ -343,8 +346,8 @@ public void shouldAppendDataFieldToRecord() { final byte[] record = builder.build(); - assertEquals("01003000IM", asString(record, 24, 34)); - assertEquals("IN\u001e", asString(record, 35, 38)); + Assert.assertEquals("01003000IM", asString(record, 24, 34)); + Assert.assertEquals("IN\u001e", asString(record, 35, 38)); } @Test @@ -354,7 +357,7 @@ public void shouldFillImplDefinedPartOfDataFieldWithSpacesIfNotProvided() { final byte[] record = builder.build(); - assertEquals("01203000 ", asString(record, 24, 34)); + Assert.assertEquals("01203000 ", asString(record, 24, 34)); } @Test(expected = IllegalArgumentException.class) @@ -388,7 +391,7 @@ public void shouldFillIndicatorsOfDataFieldWithSpacesIfNotProvided() { final byte[] record = builder.build(); - assertEquals(" \u001e", asString(record, 35, 38)); + Assert.assertEquals(" \u001e", asString(record, 35, 38)); } @Test(expected = IllegalArgumentException.class) @@ -448,7 +451,7 @@ public void shouldThrowExceptionIfBuildIsCalledWhileAppendingDataField() { builder.build(); // Exception expected } - @Test(expected=IllegalStateException.class) + @Test(expected = IllegalStateException.class) public void shouldNotAllowAppendingReferenceFieldAfterFinishingDataField() { builder.startDataField(asChars("020"), asChars("IN"), asChars("IM")); builder.endDataField(); @@ -466,8 +469,8 @@ public void shouldAppendSubfieldsToRecord() { final byte[] record = builder.build(); - assertEquals("02015000 ", asString(record, 24, 34)); - assertEquals("\u001fAval1\u001fBval2\u001e", asString(record, 37, 50)); + Assert.assertEquals("02015000 ", asString(record, 24, 34)); + Assert.assertEquals("\u001fAval1\u001fBval2\u001e", asString(record, 37, 50)); } @Test @@ -479,8 +482,8 @@ public void shouldCountStringLengthInBytes() { final byte[] record = builder.build(); - assertEquals("02010000 ", asString(record, 24, 34)); - assertEquals("\u001fAüber\u001e", asString(record, 37, 45)); + Assert.assertEquals("02010000 ", asString(record, 24, 34)); + Assert.assertEquals("\u001fAüber\u001e", asString(record, 37, 45)); } @Test @@ -494,8 +497,8 @@ public void shouldWriteTwoDirectoryEntriesForAFieldWithLongSubfields() { final byte[] record = builder.build(); - assertEquals("02000000 ", asString(record, 24, 34)); - assertEquals("02028099 ", asString(record, 34, 44)); + Assert.assertEquals("02000000 ", asString(record, 24, 34)); + Assert.assertEquals("02028099 ", asString(record, 34, 44)); } @Test(expected = IllegalArgumentException.class) @@ -552,8 +555,8 @@ public void shouldLeaveRecordInACleanStateIfAppendingDataFieldFailed() { final byte[] record = builder.build(); - assertTrue(exceptionThrown); - assertEquals("\u001e\u001d", asString(record, 24, 26)); + Assert.assertTrue(exceptionThrown); + Assert.assertEquals("\u001e\u001d", asString(record, 24, 26)); } @Test(expected = IllegalStateException.class) @@ -588,7 +591,7 @@ public void shouldFillIdentifierWithSpacesIfNotProvided() { final byte[] record = builder.build(); - assertEquals("\u001f Value", asString(record, 37, 44)); + Assert.assertEquals("\u001f Value", asString(record, 37, 44)); } @Test @@ -596,14 +599,14 @@ public void shouldWriteOnlyIdentifierMarkerIfIdentifierLengthIsOne() { format = RecordFormat.createFrom(format) .withIdentifierLength(1) .build(); - final RecordBuilder builder = new RecordBuilder(format); + builder = new RecordBuilder(format); builder.startDataField(asChars("200"), asChars("IN"), asChars("IM")); builder.appendSubfield("Value"); builder.endDataField(); final byte[] record = builder.build(); - assertEquals("\u001fValue", asString(record, 37, 43)); + Assert.assertEquals("\u001fValue", asString(record, 37, 43)); } @Test @@ -611,7 +614,7 @@ public void shouldWriteNoIdentifierMarkerIfIdentifierLengthIsZero() { format = RecordFormat.createFrom(format) .withIdentifierLength(0) .build(); - final RecordBuilder builder = new RecordBuilder(format); + builder = new RecordBuilder(format); builder.startDataField(asChars("200"), asChars("IN"), asChars("IM")); builder.appendSubfield("Ada"); builder.appendSubfield("Lovelace"); @@ -619,17 +622,17 @@ public void shouldWriteNoIdentifierMarkerIfIdentifierLengthIsZero() { final byte[] record = builder.build(); - assertEquals("AdaLovelace", asString(record, 37, 48)); + Assert.assertEquals("AdaLovelace", asString(record, 37, 48)); } @Test public void baseAddressShouldPointToEndOfDirectory() { - final RecordBuilder builder = new RecordBuilder(format); + builder = new RecordBuilder(format); builder.appendReferenceField(asChars("001"), asChars(" "), "value"); final byte[] record = builder.build(); - assertEquals("00035", asString(record, 12, 17)); + Assert.assertEquals("00035", asString(record, 12, 17)); } @Test(expected = FormatException.class) @@ -639,7 +642,7 @@ public void shouldThrowExceptionIfBaseAddressIsNotInAddressRange() { .withFieldStartLength(9) .withImplDefinedPartLength(9) .build(); - final RecordBuilder builder = new RecordBuilder(format); + builder = new RecordBuilder(format); final int dirEntries = Iso2709Constants.MAX_PAYLOAD_LENGTH / (9 * 3 + 3) + 1; for (int i = 0; i < dirEntries; ++i) { builder.appendReferenceField(asChars("002"), asChars("123456789"), ""); @@ -654,7 +657,7 @@ public void recordLengthShouldMatchLengthOfRecordString() { final byte[] record = builder.build(); - assertEquals(String.format("%05d", record.length), + Assert.assertEquals(String.format("%05d", record.length), asString(record, 0, 5)); } @@ -663,7 +666,7 @@ public void shouldThrowExceptionIfRecordLengthIsExceeded() { format = RecordFormat.createFrom(format) .withFieldLengthLength(9) .build(); - final RecordBuilder builder = new RecordBuilder(format); + builder = new RecordBuilder(format); final String longValue = StringUtil.repeatChars('C', 100000); builder.appendReferenceField(asChars("002"), asChars(" "), longValue); @@ -674,7 +677,7 @@ public void shouldThrowExceptionIfRecordLengthIsExceeded() { public void shouldEndWithRecordSeparator() { final byte[] record = builder.build(); - assertEquals('\u001d', record[record.length - 1]); + Assert.assertEquals('\u001d', record[record.length - 1]); } @Test @@ -687,16 +690,16 @@ public void shouldResetBuilder() { builder.reset(); final byte[] record = builder.build(); - assertEquals(26, record.length); - assertEquals(0x20, record[5]); - assertEquals(0x20, record[6]); - assertEquals(0x20, record[7]); - assertEquals(0x20, record[8]); - assertEquals(0x20, record[9]); - assertEquals(0x20, record[17]); - assertEquals(0x20, record[18]); - assertEquals(0x20, record[19]); - assertEquals(0x20, record[23]); + Assert.assertEquals(26, record.length); + Assert.assertEquals(0x20, record[5]); + Assert.assertEquals(0x20, record[6]); + Assert.assertEquals(0x20, record[7]); + Assert.assertEquals(0x20, record[8]); + Assert.assertEquals(0x20, record[9]); + Assert.assertEquals(0x20, record[17]); + Assert.assertEquals(0x20, record[18]); + Assert.assertEquals(0x20, record[19]); + Assert.assertEquals(0x20, record[23]); } private char[] asChars(final String value) { diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordFormatTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordFormatTest.java index 51cc95d9e..bdf85e19f 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordFormatTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordFormatTest.java @@ -16,8 +16,7 @@ package org.metafacture.biblio.iso2709; -import static org.junit.Assert.assertEquals; - +import org.junit.Assert; import org.junit.Test; /** @@ -28,6 +27,9 @@ */ public final class RecordFormatTest { + public RecordFormatTest() { + } + @Test public void shouldCreateRecordFormatFromValidValues() { final RecordFormat recordFormat = RecordFormat.create() @@ -37,12 +39,13 @@ public void shouldCreateRecordFormatFromValidValues() { .withFieldStartLength(1) .withImplDefinedPartLength(1) .build(); - assertEquals(1, recordFormat.getIndicatorLength()); - assertEquals(1, recordFormat.getIdentifierLength()); - assertEquals(1, recordFormat.getFieldLengthLength()); - assertEquals(1, recordFormat.getFieldStartLength()); - assertEquals(1, recordFormat.getImplDefinedPartLength()); + Assert.assertEquals(1, recordFormat.getIndicatorLength()); + Assert.assertEquals(1, recordFormat.getIdentifierLength()); + Assert.assertEquals(1, recordFormat.getFieldLengthLength()); + Assert.assertEquals(1, recordFormat.getFieldStartLength()); + Assert.assertEquals(1, recordFormat.getImplDefinedPartLength()); } + @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfIndicatorLengthLessThanZero() { RecordFormat.create().withIndicatorLength(-1); @@ -73,7 +76,6 @@ public void shouldThrowIllegalArgumentExceptionIfFieldStartLengthIsGreaterThanNi RecordFormat.create().withFieldStartLength(10); } - @Test(expected = IllegalArgumentException.class) public void shouldThrowIllegalArgumentExceptionIfFieldLengthLengthLessThanOne() { RecordFormat.create().withFieldLengthLength(0); diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordTest.java index a3722f116..9fa41afba 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/iso2709/RecordTest.java @@ -16,22 +16,19 @@ package org.metafacture.biblio.iso2709; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.never; - -import java.nio.charset.Charset; +import org.metafacture.framework.FormatException; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.FormatException; +import org.mockito.ArgumentMatchers; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.nio.charset.Charset; + /** * Tests for class {@link Record}. * @@ -44,69 +41,72 @@ public class RecordTest { private Record record; + public RecordTest() { + } + @Before public void initMocks() { MockitoAnnotations.initMocks(this); } @Test - public void constructor_shouldCreateRecordInstance() { + public void constructorShouldCreateRecordInstance() { final byte[] data = asBytes("00026SIMPL1200025SYS345R\u001e\u001d"); record = new Record(data); - assertNotNull(record); + Assert.assertNotNull(record); } @Test(expected = FormatException.class) - public void constructor_shouldThrowFormatExceptionIfSizeOfRecordDataIsLessThanMinRecordLength() { + public void constructorShouldThrowFormatExceptionIfSizeOfRecordDataIsLessThanMinRecordLength() { final byte[] data = asBytes("00005"); record = new Record(data); // Exception expected } @Test - public void getIdentifier_shouldReturnRecordIdentifier() { + public void getIdentifierShouldReturnRecordIdentifier() { final byte[] data = asBytes("00034SIMPL0000030SYS110R" + "00120\u001e" + "ID\u001e\u001d"); record = new Record(data); - assertEquals("ID", record.getRecordId()); + Assert.assertEquals("ID", record.getRecordId()); } @Test - public void getIdentifier_shouldReturnNullIfRecordHasNoIdentifier() { + public void getIdentifierShouldReturnNullIfRecordHasNoIdentifier() { final byte[] data = asBytes("00034SIMPL0000030SYS110R" + "00220\u001e" + "XY\u001e\u001d"); record = new Record(data); - assertNull(record.getRecordId()); + Assert.assertNull(record.getRecordId()); } @Test - public void processFields_shouldCallHandlerReferenceFieldForReferenceFields() { + public void processFieldsShouldCallHandlerReferenceFieldForReferenceFields() { final byte[] data = asBytes("00042SIMPL0000035SYS110R" + "00120" + "00223\u001e" + "ID\u001e" + "XY\u001e\u001d"); record = new Record(data); record.processFields(fieldHandler); - final InOrder ordered = inOrder(fieldHandler); + final InOrder ordered = Mockito.inOrder(fieldHandler); ordered.verify(fieldHandler).referenceField(asChars("001"), asChars(""), "ID"); ordered.verify(fieldHandler).referenceField(asChars("002"), asChars(""), "XY"); } @Test - public void processFields_shouldHandleDataFieldsInRecordWithoutIndicatorsAndIdentifiers() { + public void processFieldsShouldHandleDataFieldsInRecordWithoutIndicatorsAndIdentifiers() { final byte[] data = asBytes("00044SIMPL0000037SYS111R" + "01120X" + "01223Y\u001e" + "F1\u001e" + "F2\u001e\u001d"); record = new Record(data); record.processFields(fieldHandler); - final InOrder ordered = inOrder(fieldHandler); + final InOrder ordered = Mockito.inOrder(fieldHandler); ordered.verify(fieldHandler).startDataField(asChars("011"), asChars("X"), asChars("")); ordered.verify(fieldHandler).data(asChars(""), "F1"); @@ -118,14 +118,14 @@ record = new Record(data); } @Test - public void processFields_shouldHandleDataFieldsInRecordWithIndicatorsButWithoutIdentifiers() { + public void processFieldsShouldHandleDataFieldsInRecordWithIndicatorsButWithoutIdentifiers() { final byte[] data = asBytes("00044SIMPL1000035SYS110R" + "01130" + "01234\u001e" + "XF1\u001e" + "YF2\u001e\u001d"); record = new Record(data); record.processFields(fieldHandler); - final InOrder ordered = inOrder(fieldHandler); + final InOrder ordered = Mockito.inOrder(fieldHandler); ordered.verify(fieldHandler).startDataField(asChars("011"), asChars(""), asChars("X")); ordered.verify(fieldHandler).data(asChars(""), "F1"); @@ -137,14 +137,14 @@ record = new Record(data); } @Test - public void processFields_shouldHandleDataFieldsInRecordWithoutIndicatorsButWithTwoOctetIdentifiers() { + public void processFieldsShouldHandleDataFieldsInRecordWithoutIndicatorsButWithTwoOctetIdentifiers() { final byte[] data = asBytes("00050SIMPL0200035SYS110R" + "01150" + "01295\u001e" + "\u001fXF1\u001e" + "\u001fYF2\u001fZF3\u001e\u001d"); record = new Record(data); record.processFields(fieldHandler); - final InOrder ordered = inOrder(fieldHandler); + final InOrder ordered = Mockito.inOrder(fieldHandler); ordered.verify(fieldHandler).startDataField(asChars("011"), asChars(""), asChars("")); ordered.verify(fieldHandler).data(asChars("X"), "F1"); @@ -157,14 +157,14 @@ record = new Record(data); } @Test - public void processFields_shouldHandleDataFieldsInRecordWithoutIndicatorsButWithOneOctetIdentifiers() { + public void processFieldsShouldHandleDataFieldsInRecordWithoutIndicatorsButWithOneOctetIdentifiers() { final byte[] data = asBytes("00038SIMPL0100030SYS110R" + "01170\u001e" + "\u001fF1\u001fF2\u001e\u001d"); record = new Record(data); record.processFields(fieldHandler); - final InOrder ordered = inOrder(fieldHandler); + final InOrder ordered = Mockito.inOrder(fieldHandler); ordered.verify(fieldHandler).startDataField(asChars("011"), asChars(""), asChars("")); ordered.verify(fieldHandler).data(asChars(""), "F1"); @@ -173,29 +173,29 @@ record = new Record(data); } @Test - public void processFields_shouldHandleEmptyDataFieldInRecordWithoutIndicatorsButWithIdentifiers() { + public void processFieldsShouldHandleEmptyDataFieldInRecordWithoutIndicatorsButWithIdentifiers() { final byte[] data = asBytes("00032SIMPL0200030SYS110R" + "01110\u001e" + "\u001e\u001d"); record = new Record(data); record.processFields(fieldHandler); - final InOrder ordered = inOrder(fieldHandler); + final InOrder ordered = Mockito.inOrder(fieldHandler); ordered.verify(fieldHandler).startDataField(asChars("011"), asChars(""), asChars("")); - ordered.verify(fieldHandler, never()).data(any(char[].class), any(String.class)); + ordered.verify(fieldHandler, Mockito.never()).data(ArgumentMatchers.any(char[].class), ArgumentMatchers.any(String.class)); ordered.verify(fieldHandler).endDataField(); } @Test - public void processFields_shouldHandleDataFieldsWithoutContentInRecordWithoutIndicatorsButWithIdentifiers() { + public void processFieldsShouldHandleDataFieldsWithoutContentInRecordWithoutIndicatorsButWithIdentifiers() { final byte[] data = asBytes("00036SIMPL0200030SYS110R" + "01150\u001e" + "\u001fX\u001fY\u001e\u001d"); record = new Record(data); record.processFields(fieldHandler); - final InOrder ordered = inOrder(fieldHandler); + final InOrder ordered = Mockito.inOrder(fieldHandler); ordered.verify(fieldHandler).startDataField(asChars("011"), asChars(""), asChars("")); ordered.verify(fieldHandler).data(asChars("X"), ""); @@ -204,7 +204,7 @@ record = new Record(data); } @Test - public void processFields_shouldHandleDataFieldsInRecordWithIndicatorsAndOctetIdentifiers() { + public void processFieldsShouldHandleDataFieldsInRecordWithIndicatorsAndOctetIdentifiers() { final byte[] data = asBytes("00051SIMPL2200035SYS110R" + "01160" + "01296\u001e" + "AB\u001fX1\u001e" + "CD\u001fY2\u001fZ3\u001e" + "\u001d"); @@ -212,7 +212,7 @@ record = new Record(data); record.processFields(fieldHandler); - final InOrder ordered = inOrder(fieldHandler); + final InOrder ordered = Mockito.inOrder(fieldHandler); ordered.verify(fieldHandler).startDataField(asChars("011"), asChars(""), asChars("AB")); ordered.verify(fieldHandler).data(asChars("X"), "1"); @@ -225,14 +225,14 @@ record = new Record(data); } @Test - public void processFields_shouldConcatenateContinuedReferenceFieldsAndReportAllImplDefinedParts() { + public void processFieldsShouldConcatenateContinuedReferenceFieldsAndReportAllImplDefinedParts() { final byte[] data = asBytes("00062SIMPL0000046SYS121R" + "001000A" + "001309B" + "002312C\u001e" + "abcdefghijk\u001e" + "XY\u001e\u001d"); record = new Record(data); record.processFields(fieldHandler); - final InOrder ordered = inOrder(fieldHandler); + final InOrder ordered = Mockito.inOrder(fieldHandler); ordered.verify(fieldHandler).referenceField(asChars("001"), asChars("A"), "abcdefghijk"); ordered.verify(fieldHandler).additionalImplDefinedPart(asChars("B")); @@ -240,14 +240,14 @@ record = new Record(data); } @Test - public void processFields_shouldConcatenateContinuedFieldsAndReportAllImplDefinedParts() { + public void processFieldsShouldConcatenateContinuedFieldsAndReportAllImplDefinedParts() { final byte[] data = asBytes("00062SIMPL0000046SYS121R" + "011000A" + "011309B" + "012312C\u001e" + "abcdefghijk\u001e" + "XY\u001e\u001d"); record = new Record(data); record.processFields(fieldHandler); - final InOrder ordered = inOrder(fieldHandler); + final InOrder ordered = Mockito.inOrder(fieldHandler); ordered.verify(fieldHandler).startDataField(asChars("011"), asChars("A"), asChars("")); ordered.verify(fieldHandler).data(asChars(""), "abcdefghijk"); diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/Marc21DecoderTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/Marc21DecoderTest.java index e983c9973..61d647956 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/Marc21DecoderTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/Marc21DecoderTest.java @@ -16,16 +16,15 @@ package org.metafacture.biblio.marc21; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verifyZeroInteractions; +import org.metafacture.framework.FormatException; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.FormatException; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -43,25 +42,28 @@ public final class Marc21DecoderTest { private static final String RECORD_ID = "identifier"; private static final String CONTROLFIELD_VALUE = "controlfield"; - private static final String FIELD1 = "AB" + SUBFIELD_MARKER + "1" - + "value1"; - private static final String FIELD2 = "CD" + SUBFIELD_MARKER + "2" - + "value2" + SUBFIELD_MARKER + "3" + "value3"; + private static final String FIELD1 = "AB" + SUBFIELD_MARKER + "1" + + "value1"; + private static final String FIELD2 = "CD" + SUBFIELD_MARKER + "2" + + "value2" + SUBFIELD_MARKER + "3" + "value3"; private static final String RECORD_LABEL = "00128noa a2200073zu 4500"; - private static final String DIRECTORY = "001001100000" + "002001300011" - + "100001100024" + "200003100035"; - private static final String DATA = RECORD_ID + FIELD_SEPARATOR - + CONTROLFIELD_VALUE + FIELD_SEPARATOR + FIELD1 + FIELD_SEPARATOR - + FIELD2 + FIELD_SEPARATOR; - private static final String RECORD = RECORD_LABEL + DIRECTORY - + FIELD_SEPARATOR + DATA + RECORD_SEPARATOR; + private static final String DIRECTORY = "001001100000" + "002001300011" + + "100001100024" + "200003100035"; + private static final String DATA = RECORD_ID + FIELD_SEPARATOR + + CONTROLFIELD_VALUE + FIELD_SEPARATOR + FIELD1 + FIELD_SEPARATOR + + FIELD2 + FIELD_SEPARATOR; + private static final String RECORD = RECORD_LABEL + DIRECTORY + + FIELD_SEPARATOR + DATA + RECORD_SEPARATOR; private Marc21Decoder marc21Decoder; @Mock private StreamReceiver receiver; + public Marc21DecoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -78,7 +80,7 @@ public void cleanup() { public void shouldProcessMarc21Record() { marc21Decoder.process(RECORD); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).startEntity("leader"); ordered.verify(receiver).literal("status", "n"); @@ -105,13 +107,13 @@ public void shouldProcessMarc21Record() { @Test public void shouldIgnoreEmptyRecords() { marc21Decoder.process(""); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } @Test(expected = FormatException.class) public void shouldThrowFormatExceptionIfRecordIsNotMarc21() { - marc21Decoder.process("00026RIMPL1100024SYS3330" + FIELD_SEPARATOR - + RECORD_SEPARATOR); + marc21Decoder.process("00026RIMPL1100024SYS3330" + FIELD_SEPARATOR + + RECORD_SEPARATOR); } @Test(expected = FormatException.class) diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/Marc21EncoderTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/Marc21EncoderTest.java index c8677ff20..b427c7dee 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/Marc21EncoderTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/Marc21EncoderTest.java @@ -16,18 +16,15 @@ package org.metafacture.biblio.marc21; -import static org.metafacture.biblio.marc21.Marc21EventNames.LEADER_ENTITY; -import static org.metafacture.biblio.marc21.Marc21EventNames.RECORD_STATUS_LITERAL; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.matches; -import static org.mockito.Mockito.verify; +import org.metafacture.framework.FormatException; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.FormatException; -import org.metafacture.framework.ObjectReceiver; +import org.mockito.ArgumentMatchers; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -45,6 +42,9 @@ public final class Marc21EncoderTest { @Mock private ObjectReceiver receiver; + public Marc21EncoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -63,8 +63,8 @@ public void shouldOutputTopLevelLiteralsAsReferenceFields() { marc21Encoder.literal("001", "identifier"); marc21Encoder.endRecord(); - verify(receiver).process( - matches(".*001001100000\u001eidentifier\u001e.*")); + Mockito.verify(receiver).process( + ArgumentMatchers.matches(".*001001100000\u001eidentifier\u001e.*")); } @Test @@ -74,7 +74,7 @@ public void shouldOutputEntitiesAsDataFields() { marc21Encoder.endEntity(); marc21Encoder.endRecord(); - verify(receiver).process(matches(".*021000300000\u001ea \u001e.*")); + Mockito.verify(receiver).process(ArgumentMatchers.matches(".*021000300000\u001ea \u001e.*")); } @Test @@ -86,8 +86,8 @@ public void shouldOutputLiteralsInEntitiesAsSubfields() { marc21Encoder.endEntity(); marc21Encoder.endRecord(); - verify(receiver).process( - matches(".*021001700000\u001ea \u001fvFritz\u001fnBauer\u001e.*")); + Mockito.verify(receiver).process( + ArgumentMatchers.matches(".*021001700000\u001ea \u001fvFritz\u001fnBauer\u001e.*")); } @Test(expected = FormatException.class) @@ -102,57 +102,57 @@ public void issue231ShouldIgnoreTypeLiterals() { marc21Encoder.literal("type", "ignoreme"); marc21Encoder.endRecord(); - verify(receiver).process(any(String.class)); + Mockito.verify(receiver).process(ArgumentMatchers.any(String.class)); } @Test public void issue278ShouldNotFailWhenProcessingLeaderEntity() { marc21Encoder.startRecord(""); - marc21Encoder.startEntity(LEADER_ENTITY); - marc21Encoder.literal(RECORD_STATUS_LITERAL, "a"); + marc21Encoder.startEntity(Marc21EventNames.LEADER_ENTITY); + marc21Encoder.literal(Marc21EventNames.RECORD_STATUS_LITERAL, "a"); marc21Encoder.endEntity(); marc21Encoder.endRecord(); - verify(receiver).process(any(String.class)); + Mockito.verify(receiver).process(ArgumentMatchers.any(String.class)); } @Test public void issue454ShouldNotFailWhenProcessingEntityLeaderAsOneString() { marc21Encoder.startRecord(""); - marc21Encoder.startEntity(LEADER_ENTITY); - marc21Encoder.literal(LEADER_ENTITY, "02602pam a2200529 c 4500"); + marc21Encoder.startEntity(Marc21EventNames.LEADER_ENTITY); + marc21Encoder.literal(Marc21EventNames.LEADER_ENTITY, "02602pam a2200529 c 4500"); marc21Encoder.endEntity(); marc21Encoder.endRecord(); - verify(receiver).process(matches("00026pam a2200025 c 4500\u001e\u001d")); + Mockito.verify(receiver).process(ArgumentMatchers.matches("00026pam a2200025 c 4500\u001e\u001d")); } @Test public void issue454ShouldNotFailWhenProcessingLeaderAsOneString() { marc21Encoder.startRecord(""); - marc21Encoder.literal(LEADER_ENTITY, "02602pam a2200529 c 4500"); + marc21Encoder.literal(Marc21EventNames.LEADER_ENTITY, "02602pam a2200529 c 4500"); marc21Encoder.endRecord(); - verify(receiver).process(matches("00026pam a2200025 c 4500\u001e\u001d")); + Mockito.verify(receiver).process(ArgumentMatchers.matches("00026pam a2200025 c 4500\u001e\u001d")); } @Test public void issue524ShouldComputeValidLeader() { marc21Encoder.startRecord(""); - marc21Encoder.literal(LEADER_ENTITY, "00000pam a7777777 c 4444"); + marc21Encoder.literal(Marc21EventNames.LEADER_ENTITY, "00000pam a7777777 c 4444"); marc21Encoder.startEntity("021a "); marc21Encoder.literal("v", "Fritz"); marc21Encoder.literal("n", "Bauer"); marc21Encoder.endEntity(); marc21Encoder.endRecord(); - verify(receiver).process(matches("00055pam a2200037 c 4500021001700000\u001e.*\u001d")); + Mockito.verify(receiver).process(ArgumentMatchers.matches("00055pam a2200037 c 4500021001700000\u001e.*\u001d")); } @Test(expected = FormatException.class) public void issue567ShouldFailValidateLeaderAsDefault() { marc21Encoder.startRecord(""); - marc21Encoder.literal(LEADER_ENTITY, BAD_LEADER); + marc21Encoder.literal(Marc21EventNames.LEADER_ENTITY, BAD_LEADER); marc21Encoder.endRecord(); } @@ -161,10 +161,10 @@ public void issue567ShouldNotValidateLeader() { marc21Encoder.setValidateLeader(false); marc21Encoder.startRecord(""); - marc21Encoder.literal(LEADER_ENTITY, BAD_LEADER ); + marc21Encoder.literal(Marc21EventNames.LEADER_ENTITY, BAD_LEADER); marc21Encoder.endRecord(); - verify(receiver).process(matches("00026ny a22000253n 4500\u001e\u001d")); + Mockito.verify(receiver).process(ArgumentMatchers.matches("00026ny a22000253n 4500\u001e\u001d")); } } diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/MarcXmlEncoderTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/MarcXmlEncoderTest.java index 2e1c8df23..4f3e728ce 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/MarcXmlEncoderTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/MarcXmlEncoderTest.java @@ -21,13 +21,10 @@ import org.metafacture.framework.MissingIdException; import org.metafacture.framework.helpers.DefaultObjectReceiver; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertTrue; - /** * Tests for class {@link MarcXmlEncoder}. * @@ -35,18 +32,17 @@ * @author Pascal Christoph (dr0i) dug it up again * */ - public class MarcXmlEncoderTest { private static final String XML_DECLARATION = ""; private static final String XML_1_DECLARATION = ""; private static final String XML_16_DECLARATION = ""; - private static final String XML_ROOT_OPEN = ""; - private static final String XML_RECORD = "92005291" - + "92005291" - + ""; + private static final String XML_ROOT_OPEN = ""; + private static final String XML_RECORD = "92005291" + + "92005291" + + ""; private static final String XML_MARC_COLLECTION_END_TAG = ""; private static final String RECORD_ID = "92005291"; @@ -54,6 +50,9 @@ public class MarcXmlEncoderTest { private static int resultCollectorsResetStreamCount; private static MarcXmlEncoder encoder; + public MarcXmlEncoderTest() { + } + @Before public void setUp() { encoder = new MarcXmlEncoder(); @@ -63,16 +62,16 @@ public void setUp() { public void process(final String obj) { resultCollector.append(obj); } + @Override public void resetStream() { ++resultCollectorsResetStreamCount; } - }); resultCollector = new StringBuilder(); } - private void addOneRecord(final MarcXmlEncoder encoder) { + private void addOneRecord() { encoder.startRecord(RECORD_ID); encoder.literal("001", RECORD_ID); encoder.startEntity("010 "); @@ -84,43 +83,43 @@ private void addOneRecord(final MarcXmlEncoder encoder) { @Test public void doNotOmitXmlDeclaration() { encoder.omitXmlDeclaration(false); - addOneRecord(encoder); + addOneRecord(); encoder.closeStream(); - String actual = resultCollector.toString(); - assertTrue(actual.startsWith(XML_DECLARATION)); + final String actual = resultCollector.toString(); + Assert.assertTrue(actual.startsWith(XML_DECLARATION)); } @Test public void omitXmlDeclaration() { encoder.omitXmlDeclaration(true); - addOneRecord(encoder); + addOneRecord(); encoder.closeStream(); - String actual = resultCollector.toString(); - assertTrue(actual.startsWith("" + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + XML_ROOT_OPEN + "" + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test @@ -146,17 +145,17 @@ public void createARecordPrettyPrint() { encoder.endEntity(); encoder.endRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + "\n" + XML_ROOT_OPEN + "\n" - + "\t\n"// - + "\t\tdummy\n" - + "\t\t92005291\n"// - + "\t\t\n"// - + "\t\t\t92005291\n"// - + "\t\t\n" - + "\t\n"// - + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + "\n" + XML_ROOT_OPEN + "\n" + + "\t\n" + + "\t\tdummy\n" + + "\t\t92005291\n" + + "\t\t\n" + + "\t\t\t92005291\n" + + "\t\t\n" + + "\t\n" + + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test @@ -165,33 +164,33 @@ public void createARecordWithEscapedSequences() { encoder.literal("001", "&<>\""); encoder.endRecord(); encoder.onResetStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN + "" - + "&<>"" + "" - + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + XML_ROOT_OPEN + "" + + "&<>"" + "" + + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test public void createTwoRecordsInOneCollection() { - addOneRecord(encoder); - addOneRecord(encoder); + addOneRecord(); + addOneRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN + XML_RECORD + XML_RECORD + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + XML_ROOT_OPEN + XML_RECORD + XML_RECORD + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test public void issue403_shouldNotEmitNamespaceIfDisabled() { encoder.setEmitNamespace(false); - addOneRecord(encoder); - addOneRecord(encoder); + addOneRecord(); + addOneRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + "" - + XML_RECORD + XML_RECORD + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected.replace("marc:", ""), actual); + final String expected = XML_DECLARATION + "" + + XML_RECORD + XML_RECORD + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected.replace("marc:", ""), actual); } @Test(expected = MetafactureException.class) @@ -223,28 +222,28 @@ public void createRecordWithLeader() { encoder.endEntity(); encoder.endRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN - + "dummy" + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + XML_ROOT_OPEN + + "dummy" + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test(expected = FormatException.class) - public void createRecordWithLeader_ensureCorrectMarc21Xml() { + public void createRecordWithLeaderEnsureCorrectMarc21Xml() { encoder.setEnsureCorrectMarc21Xml(true); createRecordWithLeader(); } @Test - public void issue336_createRecordWithTopLevelLeader_dummy() { + public void issue336_createRecordWithTopLevelLeaderDummy() { encoder.startRecord("1"); encoder.literal(Marc21EventNames.LEADER_ENTITY, "dummy"); encoder.endRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN - + "dummy" + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + XML_ROOT_OPEN + + "dummy" + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test @@ -256,34 +255,34 @@ public void issue548_createRecordWithTypeAttributeInRecordTagAndLeader() { encoder.endEntity(); encoder.endRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN + "" + + final String expected = XML_DECLARATION + XML_ROOT_OPEN + "" + "dummy" + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test - public void issue336_createRecordWithTopLevelLeader_defaultMarc21Xml() { - issue336_createRecordWithTopLevelLeader(encoder, "00000naa a2200000uc 4500"); + public void issue336_createRecordWithTopLevelLeaderDefaultMarc21Xml() { + issue336_createRecordWithTopLevelLeader("00000naa a2200000uc 4500"); } @Test - public void issue336_createRecordWithTopLevelLeader_ensureCorrectMarc21Xml() { + public void issue336_createRecordWithTopLevelLeaderEnsureCorrectMarc21Xml() { encoder.setEnsureCorrectMarc21Xml(true); - issue336_createRecordWithTopLevelLeader(encoder, "00048naa a2200037uc 4500"); + issue336_createRecordWithTopLevelLeader("00048naa a2200037uc 4500"); } - private void issue336_createRecordWithTopLevelLeader(final MarcXmlEncoder encoder, final String expectedLeader) { + private void issue336_createRecordWithTopLevelLeader(final String expectedLeader) { encoder.startRecord("1"); encoder.literal("001", "8u3287432"); encoder.literal(Marc21EventNames.LEADER_ENTITY, "00000naa a2200000uc 4500"); encoder.endRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN - + "" + expectedLeader + "" + + final String expected = XML_DECLARATION + XML_ROOT_OPEN + + "" + expectedLeader + "" + "8u3287432" + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test @@ -293,11 +292,11 @@ public void issue548_failWhenLeaderIsNotFirst() { encoder.literal(Marc21EventNames.LEADER_ENTITY, "00000naa a2200000uc 4500"); encoder.endRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN - + "8u3287432" + + final String expected = XML_DECLARATION + XML_ROOT_OPEN + + "8u3287432" + "00000naa a2200000uc 4500" + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertNotEquals(expected, actual); + final String actual = resultCollector.toString(); + Assert.assertNotEquals(expected, actual); } @Test @@ -305,15 +304,15 @@ public void issue527_shouldEmitLeaderAlwaysAsWholeString() { createRecordWithLeader("1", "a", "o", "a", " ", "a", "z", "u", " "); createRecordWithLeader("2", "d", "u", "m", " ", "m", "y", "#", " "); encoder.closeStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN - + "aoa azu " - + "dum my# " + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + XML_ROOT_OPEN + + "aoa azu " + + "dum my# " + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test(expected = MissingIdException.class) - public void issue527_shouldEmitLeaderAlwaysAsWholeString_ensureCorrectMarc21Xml() { + public void issue527_shouldEmitLeaderAlwaysAsWholeStringEnsureCorrectMarc21Xml() { encoder.setEnsureCorrectMarc21Xml(true); issue527_shouldEmitLeaderAlwaysAsWholeString(); } @@ -323,18 +322,18 @@ public void sendDataAndClearWhenRecordStartedAndStreamResets() { encoder.startRecord("1"); encoder.onResetStream(); encoder.endRecord(); - String expected = XML_DECLARATION + XML_ROOT_OPEN + "" + XML_MARC_COLLECTION_END_TAG - + ""; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + XML_ROOT_OPEN + "" + XML_MARC_COLLECTION_END_TAG + + ""; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test public void sendAndClearDataWhenOnResetStream() { encoder.onResetStream(); - String expected = ""; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = ""; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test @@ -343,11 +342,11 @@ public void shouldIgnoreNullValueOfLiteral() { encoder.literal("data", null); encoder.endRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN - + "" - + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + XML_ROOT_OPEN + + "" + + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test @@ -356,11 +355,11 @@ public void shouldIgnoreNullValueOfTypeLiteral() { encoder.literal("type", null); encoder.endRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN - + "" - + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + XML_ROOT_OPEN + + "" + + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test @@ -369,11 +368,11 @@ public void issue402_shouldEncodeTypeLiteralAsAttribute() { encoder.literal("type", "value"); encoder.endRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN - + "" - + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + XML_ROOT_OPEN + + "" + + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test @@ -384,29 +383,29 @@ public void shouldNotEncodeNestedTypeLiteralAsAttribute() { encoder.endEntity(); encoder.endRecord(); encoder.closeStream(); - String expected = XML_DECLARATION + XML_ROOT_OPEN - + "" - + "" - + "value" - + "" - + "" - + XML_MARC_COLLECTION_END_TAG; - String actual = resultCollector.toString(); - assertEquals(expected, actual); + final String expected = XML_DECLARATION + XML_ROOT_OPEN + + "" + + "" + + "value" + + "" + + "" + + XML_MARC_COLLECTION_END_TAG; + final String actual = resultCollector.toString(); + Assert.assertEquals(expected, actual); } @Test public void issue543_shouldNotWriteFooterWhenRecordIsEmpty() { encoder.closeStream(); - String actual = resultCollector.toString(); - assertTrue(actual.isEmpty()); + final String actual = resultCollector.toString(); + Assert.assertTrue(actual.isEmpty()); } @Test public void issue543_shouldOnlyResetStreamOnce() { resultCollectorsResetStreamCount = 0; encoder.resetStream(); - assertEquals(resultCollectorsResetStreamCount, 1); + Assert.assertEquals(resultCollectorsResetStreamCount, 1); } @Test @@ -414,7 +413,7 @@ public void issue543_shouldOnlyResetStreamOnceUsingWrapper() { resultCollectorsResetStreamCount = 0; encoder.setEnsureCorrectMarc21Xml(true); encoder.resetStream(); - assertEquals(resultCollectorsResetStreamCount, 1); + Assert.assertEquals(resultCollectorsResetStreamCount, 1); } } diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/MarcXmlHandlerTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/MarcXmlHandlerTest.java index 16710f9b7..0a360658d 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/MarcXmlHandlerTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/marc21/MarcXmlHandlerTest.java @@ -16,13 +16,11 @@ package org.metafacture.biblio.marc21; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.Mockito; @@ -49,6 +47,9 @@ public final class MarcXmlHandlerTest { @Mock private StreamReceiver receiver; + public MarcXmlHandlerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -74,7 +75,7 @@ public void shouldFindTagAttributeAtSecondPositionInControlFieldElement() marcXmlHandler.characters(fieldValue.toCharArray(), 0, fieldValue.length()); marcXmlHandler.endElement(NAMESPACE, CONTROLFIELD, ""); - verify(receiver).literal("001", fieldValue); + Mockito.verify(receiver).literal("001", fieldValue); } @Test @@ -88,7 +89,7 @@ public void issue440_shouldNotRemoveWhitespaceFromControlFields() throws SAXExce marcXmlHandler.characters(fieldValue.toCharArray(), 0, fieldValue.length()); marcXmlHandler.endElement(NAMESPACE, CONTROLFIELD, ""); - verify(receiver).literal("008", fieldValue); + Mockito.verify(receiver).literal("008", fieldValue); } @Test @@ -101,7 +102,7 @@ public void issue233ShouldNotRemoveWhitespaceFromLeader() marcXmlHandler.characters(leaderValue.toCharArray(), 0, leaderValue.length()); marcXmlHandler.endElement(NAMESPACE, LEADER, ""); - verify(receiver).literal("leader", leaderValue); + Mockito.verify(receiver).literal("leader", leaderValue); } @Test @@ -112,11 +113,11 @@ public void shouldRecognizeRecordsWithNamespace() marcXmlHandler.startElement(NAMESPACE, RECORD, "", attributes); marcXmlHandler.endElement(NAMESPACE, RECORD, ""); - verify(receiver).startRecord(""); - verify(receiver).literal(TYPE, null); - verify(receiver).endRecord(); + Mockito.verify(receiver).startRecord(""); + Mockito.verify(receiver).literal(TYPE, null); + Mockito.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -127,7 +128,7 @@ public void shouldNotRecognizeRecordsWithoutNamespace() marcXmlHandler.startElement(null, RECORD, "", attributes); marcXmlHandler.endElement(null, RECORD, ""); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -139,11 +140,11 @@ public void issue330ShouldOptionallyRecognizeRecordsWithoutNamespace() marcXmlHandler.startElement(null, RECORD, "", attributes); marcXmlHandler.endElement(null, RECORD, ""); - verify(receiver).startRecord(""); - verify(receiver).literal(TYPE, null); - verify(receiver).endRecord(); + Mockito.verify(receiver).startRecord(""); + Mockito.verify(receiver).literal(TYPE, null); + Mockito.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -155,11 +156,11 @@ public void shouldRecognizeRecordsWithoutNamespace() marcXmlHandler.startElement("", RECORD, "", attributes); marcXmlHandler.endElement("", RECORD, ""); - verify(receiver).startRecord(""); - verify(receiver).literal(TYPE, null); - verify(receiver).endRecord(); + Mockito.verify(receiver).startRecord(""); + Mockito.verify(receiver).literal(TYPE, null); + Mockito.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -171,7 +172,7 @@ public void shouldNotRecognizeRecordsWithNamespaceWhenOptionallyWithoutNamespace marcXmlHandler.startElement(NAMESPACE, RECORD, "", attributes); marcXmlHandler.endElement(NAMESPACE, RECORD, ""); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -183,11 +184,11 @@ public void issue569ShouldRecognizeRecordsWithAndWithoutNamespace() marcXmlHandler.startElement(null, RECORD, "", attributes); marcXmlHandler.endElement(NAMESPACE, RECORD, ""); - verify(receiver).startRecord(""); - verify(receiver).literal(TYPE, null); - verify(receiver).endRecord(); + Mockito.verify(receiver).startRecord(""); + Mockito.verify(receiver).literal(TYPE, null); + Mockito.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -200,11 +201,11 @@ public void issue569ShouldRecognizeRecordsWithAndWithoutNamespaceOrderIndependen marcXmlHandler.startElement(null, RECORD, "", attributes); marcXmlHandler.endElement(NAMESPACE, RECORD, ""); - verify(receiver).startRecord(""); - verify(receiver).literal(TYPE, null); - verify(receiver).endRecord(); + Mockito.verify(receiver).startRecord(""); + Mockito.verify(receiver).literal(TYPE, null); + Mockito.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -216,9 +217,9 @@ public void issue569ShouldNotRecognizeRecordsWithAndWithoutNamespace() marcXmlHandler.startElement(null, RECORD, "", attributes); marcXmlHandler.endElement(NAMESPACE, RECORD, ""); - verify(receiver).endRecord(); + Mockito.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -234,7 +235,7 @@ public void shouldNotEncodeTypeAttributeAsMarkedLiteral() throws SAXException { ordered.verify(receiver).literal(TYPE, "bibliographic"); ordered.verify(receiver).endRecord(); ordered.verifyNoMoreInteractions(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -253,7 +254,7 @@ public void issue336_shouldEncodeTypeAttributeAsLiteralWithConfiguredMarker() th ordered.verify(receiver).literal(marker + TYPE, "bibliographic"); ordered.verify(receiver).endRecord(); ordered.verifyNoMoreInteractions(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } } diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaDecoderTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaDecoderTest.java index ea6f8bf40..28d6d6080 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaDecoderTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaDecoderTest.java @@ -16,17 +16,15 @@ package org.metafacture.biblio.pica; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.MissingIdException; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.MissingIdException; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -73,6 +71,9 @@ public final class PicaDecoderTest { @Mock private StreamReceiver receiver; + public PicaDecoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -91,8 +92,7 @@ public void shouldParseRecordStartingWithRecordMarker() { RECORD_MARKER + FIELD_001AT_0_TEST + FIELD_MARKER + FIELD_003AT_0_ID); - - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify001At0Test(ordered); verify003At0ID(ordered); @@ -105,8 +105,7 @@ public void shouldParseRecordStartingWithFieldMarker() { FIELD_MARKER + FIELD_001AT_0_TEST + FIELD_MARKER + FIELD_003AT_0_ID); - - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify001At0Test(ordered); verify003At0ID(ordered); @@ -119,7 +118,7 @@ public void shouldParseRecordStartingWithSubfieldMarker() { SUBFIELD_MARKER + NAME_A + VALUE_A + FIELD_MARKER + FIELD_003AT_0_ID); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).startEntity(""); ordered.verify(receiver).literal(NAME_A, VALUE_A); @@ -134,7 +133,7 @@ public void shouldParseRecordStartingWithEmptySubfield() { SUBFIELD_MARKER + FIELD_MARKER + FIELD_003AT_0_ID); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).endRecord(); @@ -146,8 +145,7 @@ public void shouldParseRecordStartingWithFieldEndMarker() { FIELD_END_MARKER + FIELD_001AT_0_TEST + FIELD_MARKER + FIELD_003AT_0_ID); - - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify001At0Test(ordered); verify003At0ID(ordered); @@ -160,8 +158,7 @@ public void shouldParseRecordStartingWithFieldName() { FIELD_001AT_0_TEST + FIELD_MARKER + FIELD_003AT_0_ID); - - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify001At0Test(ordered); verify003At0ID(ordered); @@ -174,7 +171,7 @@ public void shouldParseRecordEndingWithRecordMarker() { FIELD_003AT_0_ID + FIELD_MARKER + FIELD_001AT_0_TEST + RECORD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); verify001At0Test(ordered); @@ -187,7 +184,7 @@ public void shouldParseRecordEndingWithFieldMarker() { FIELD_003AT_0_ID + FIELD_MARKER + FIELD_001AT_0_TEST + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); verify001At0Test(ordered); @@ -203,7 +200,7 @@ public void shouldParseRecordEndingWithSubfieldMarker() { SUBFIELD_MARKER + NAME_D + VALUE_D + SUBFIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).startEntity(ENTITY_028A); @@ -221,7 +218,7 @@ public void shouldParseRecordEndingWithSubfieldName() { SUBFIELD_MARKER + NAME_A + VALUE_A + SUBFIELD_MARKER + NAME_D); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).startEntity(ENTITY_028A); @@ -241,7 +238,7 @@ public void shouldParseRecordEndingWithFieldName() { FIELD_003AT_0_ID + FIELD_MARKER + FIELD_028A); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).startEntity(ENTITY_028A); @@ -256,7 +253,7 @@ public void shouldParseMultiLineRecordFormat() { FIELD_MARKER + FIELD_001AT_0_TEST + FIELD_END_MARKER + FIELD_MARKER + FIELD_003AT_0_ID + FIELD_END_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify001At0Test(ordered); verify003At0ID(ordered); @@ -267,87 +264,87 @@ public void shouldParseMultiLineRecordFormat() { public void shouldExtractPicaProductionNumberAfterRecordMarkerAsRecordId() { picaDecoder.process(RECORD_MARKER + FIELD_003AT_0_ID); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } @Test public void shouldExtractPicaProductionNumberAfterFieldMarkerAsRecordId() { picaDecoder.process(FIELD_MARKER + FIELD_003AT_0_ID); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } @Test public void shouldExtractPicaProductionNumberAfterFieldEndMarkerAsRecordId() { picaDecoder.process(FIELD_END_MARKER + FIELD_003AT_0_ID); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } @Test public void shouldExtractPicaProductionNumberFollowedByRecordMarkerAsRecordId() { picaDecoder.process(FIELD_003AT_0_ID + RECORD_MARKER); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } @Test public void shouldExtractPicaProductionNumberFollowedByFieldMarkerAsRecordId() { picaDecoder.process(FIELD_003AT_0_ID + FIELD_MARKER); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } @Test public void shouldExtractPicaProductionNumberFollowedBySubfieldMarkerAsRecordId() { picaDecoder.process(FIELD_003AT_0_ID + SUBFIELD_MARKER); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } @Test public void shouldExtractPicaProductionNumberFollowedByFieldEndMarkerAsRecordId() { picaDecoder.process(FIELD_003AT_0_ID + FIELD_END_MARKER); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } @Test public void shouldExtractPicaProductionNumberAtRecordEndAsRecordId() { picaDecoder.process(FIELD_003AT_0_ID); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } @Test public void shouldExtractLocalProductionNumberAsRecordId() { picaDecoder.process(FIELD_107F_0_ID); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } @Test public void shouldExtractCopyControlNumberAsRecordId() { picaDecoder.process(FIELD_203AT_0_ID); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } @Test public void shouldExtractCopyControlNumberWithOccurrenceAsRecordId() { picaDecoder.process(FIELD_203AT_01_0_ID); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } @Test public void shouldExtractCopyControlNumberWithThreeDigitOccurrenceAsRecordId() { picaDecoder.process(FIELD_203AT_100_0_ID); - verify(receiver).startRecord(RECORD_ID); + Mockito.verify(receiver).startRecord(RECORD_ID); } - @Test(expected=MissingIdException.class) + @Test(expected = MissingIdException.class) public void shouldThrowMissingIdExceptionIfNoRecordIdIsFound() { picaDecoder.process(FIELD_001AT_0_TEST); // Exception expected @@ -359,7 +356,7 @@ public void shouldIgnoreMatchWithinFieldData() { picaDecoder.process(FIELD_001AT_0_TEST + FIELD_003AT_0_ID); - verify(receiver).startRecord(""); + Mockito.verify(receiver).startRecord(""); } @Test @@ -368,7 +365,7 @@ public void shouldIgnoreIncompleteMatch() { picaDecoder.process("003@ " + FIELD_MARKER + FIELD_001AT_0_TEST); - verify(receiver).startRecord(""); + Mockito.verify(receiver).startRecord(""); } @Test @@ -382,11 +379,11 @@ public void shouldSkipUnnamedFieldsWithNoSubFields() { FIELD_003AT_0_ID + FIELD_MARKER + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -400,11 +397,11 @@ public void shouldSkipUnnamedFieldsWithOnlyUnnamedSubFields() { FIELD_003AT_0_ID + FIELD_MARKER + SUBFIELD_MARKER + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -414,7 +411,7 @@ public void shouldNotSkipUnnamedFieldsWithSubFields() { SUBFIELD_MARKER + NAME_A + VALUE_A + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).startEntity(""); @@ -432,14 +429,14 @@ public void shouldSkipUnnamedSubfields() { SUBFIELD_MARKER + NAME_A + VALUE_A + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).startEntity(ENTITY_028A); ordered.verify(receiver).literal(NAME_A, VALUE_A); ordered.verify(receiver).endEntity(); ordered.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -448,11 +445,11 @@ public void shouldSkipEmptyFieldsByDefault() { FIELD_003AT_0_ID + FIELD_MARKER + FIELD_028A + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -463,11 +460,11 @@ public void shouldSkipFieldsWithOnlyUnnamedSubfieldsByDefault() { SUBFIELD_MARKER + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -478,7 +475,7 @@ public void shouldNotSkipEmptyFieldsIfConfigured() { FIELD_003AT_0_ID + FIELD_MARKER + FIELD_028A + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).startEntity(ENTITY_028A); @@ -496,7 +493,7 @@ public void shouldNotSkipFieldsWithOnlyUnnamedSubfieldsIfConfigured() { SUBFIELD_MARKER + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); ordered.verify(receiver).startEntity(ENTITY_028A); @@ -504,7 +501,7 @@ public void shouldNotSkipFieldsWithOnlyUnnamedSubfieldsIfConfigured() { ordered.verify(receiver).endRecord(); } - @Test(expected=MissingIdException.class) + @Test(expected = MissingIdException.class) public void shouldFailIfIdIsMissingByDefault() { picaDecoder.process( FIELD_001AT_0_TEST + FIELD_MARKER); @@ -517,7 +514,7 @@ public void shouldIgnoreMissingIdIfConfigured() { picaDecoder.process( FIELD_001AT_0_TEST + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); verify001At0Test(ordered); ordered.verify(receiver).endRecord(); @@ -529,7 +526,7 @@ public void shouldNotNormalizeUTF8ByDefault() { FIELD_003AT_0_ID + FIELD_MARKER + FIELD_021A_A_UEBER + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); verify021AAUeber(ordered, COMPOSED_UTF8); @@ -544,7 +541,7 @@ public void shouldNormalizeUTF8IfConfigured() { FIELD_003AT_0_ID + FIELD_MARKER + FIELD_021A_A_UEBER + FIELD_MARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verify003At0ID(ordered); verify021AAUeber(ordered, STANDARD_UTF8); @@ -557,7 +554,7 @@ public void shouldTrimWhitespaceInFieldNamesByDefault() { " fieldname " + SUBFIELD_MARKER + "0subfield" + FIELD_MARKER + FIELD_003AT_0_ID); - verify(receiver).startEntity("fieldname"); + Mockito.verify(receiver).startEntity("fieldname"); } @Test @@ -568,7 +565,7 @@ public void shouldNotTrimWhitespaceInFieldNamesIfConfigured() { " fieldname " + SUBFIELD_MARKER + "0subfield" + FIELD_MARKER + FIELD_003AT_0_ID); - verify(receiver).startEntity(" fieldname "); + Mockito.verify(receiver).startEntity(" fieldname "); } @Test @@ -580,11 +577,12 @@ public void nonNormalizedPica() { NONNORMALIZED_FIELD_003AT_0_ID + NONNORMALIZED_RECORD_MARKER); try { - verify(receiver).startEntity("001@"); - verify(receiver).literal("0", "test"); - verify(receiver).startEntity("003@"); - verify(receiver).literal("0", "2809"); - } finally { //ensure reset to the default used by the other tests + Mockito.verify(receiver).startEntity("001@"); + Mockito.verify(receiver).literal("0", "test"); + Mockito.verify(receiver).startEntity("003@"); + Mockito.verify(receiver).literal("0", "2809"); + } + finally { // ensure reset to the default used by the other tests picaDecoder.setNormalizedSerialization(true); } } diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaEncoderTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaEncoderTest.java index 2c83e392f..12954cc1f 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaEncoderTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaEncoderTest.java @@ -16,15 +16,15 @@ package org.metafacture.biblio.pica; -import static org.mockito.Mockito.verify; +import org.metafacture.framework.FormatException; +import org.metafacture.framework.MissingIdException; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.FormatException; -import org.metafacture.framework.MissingIdException; -import org.metafacture.framework.ObjectReceiver; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -40,6 +40,9 @@ public final class PicaEncoderTest { @Mock private ObjectReceiver receiver; + public PicaEncoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -65,7 +68,7 @@ public void testShouldWriteFieldAndSubfield() { picaEncoder.endEntity(); picaEncoder.endRecord(); - verify(receiver).process("003@ \u001f017709958X\u001e028@ \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); + Mockito.verify(receiver).process("003@ \u001f017709958X\u001e028@ \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); } @Test @@ -81,10 +84,10 @@ public void testShouldWriteFieldAndSubfield2() { picaEncoder.endEntity(); picaEncoder.endRecord(); - verify(receiver).process("003@ \u001f017709958X\u001e028@/30 \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); + Mockito.verify(receiver).process("003@ \u001f017709958X\u001e028@/30 \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); } - @Test(expected=FormatException.class) + @Test(expected = FormatException.class) public void testShouldFailOnInvalidFieldName() { picaEncoder.startRecord("17709958X"); picaEncoder.startEntity("003@"); @@ -97,10 +100,10 @@ public void testShouldFailOnInvalidFieldName() { picaEncoder.endEntity(); picaEncoder.endRecord(); - verify(receiver).process("003@ \u001f017709958X\u001e@028 \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); + Mockito.verify(receiver).process("003@ \u001f017709958X\u001e@028 \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); } - @Test(expected=FormatException.class) + @Test(expected = FormatException.class) public void testShouldFailOnInvalidFieldName2() { picaEncoder.startRecord("17709958X"); picaEncoder.startEntity("003@"); @@ -113,46 +116,46 @@ public void testShouldFailOnInvalidFieldName2() { picaEncoder.endEntity(); picaEncoder.endRecord(); - verify(receiver).process("003@ \u001f017709958X\u001e@028 \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); + Mockito.verify(receiver).process("003@ \u001f017709958X\u001e@028 \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); } - @Test(expected=FormatException.class) + @Test(expected = FormatException.class) public void testShouldFailOnInvalidSubfieldName() { picaEncoder.startRecord("17709958X"); picaEncoder.startEntity("003@"); picaEncoder.literal("0", "17709958X"); picaEncoder.endEntity(); picaEncoder.startEntity("028@"); - picaEncoder.literal("Pp", "Abläöübolo");//the subfieldname pattern not match! + picaEncoder.literal("Pp", "Abläöübolo"); // the subfieldname pattern not match! picaEncoder.literal("n", "VIX"); picaEncoder.literal("l", "Bapst"); picaEncoder.endEntity(); picaEncoder.endRecord(); - verify(receiver).process("003@ \u001f017709958X\u001e@028 \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); + Mockito.verify(receiver).process("003@ \u001f017709958X\u001e@028 \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); } - @Test(expected=FormatException.class) + @Test(expected = FormatException.class) public void testShouldFailOnLiteralOutOfEntity() { picaEncoder.startRecord("17709958X"); picaEncoder.startEntity("003@"); picaEncoder.literal("0", "17709958X"); picaEncoder.endEntity(); - picaEncoder.literal("P", "Abläöübolo");//the subfieldname out of entity! + picaEncoder.literal("P", "Abläöübolo"); // the subfieldname out of entity! picaEncoder.startEntity("028@"); picaEncoder.literal("n", "VIX"); picaEncoder.literal("l", "Bapst"); picaEncoder.endEntity(); picaEncoder.endRecord(); - verify(receiver).process("003@ \u001f017709958X\u001e@028 \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); + Mockito.verify(receiver).process("003@ \u001f017709958X\u001e@028 \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); } - @Test (expected=MissingIdException.class) + @Test(expected = MissingIdException.class) public void testShouldFailOnWrongRecordId() { picaEncoder.startRecord("17709958"); picaEncoder.startEntity("003@"); - picaEncoder.literal("0", "17709958X"); //RecordId not match! + picaEncoder.literal("0", "17709958X"); // RecordId not match! picaEncoder.endEntity(); picaEncoder.startEntity("028@"); picaEncoder.literal("P", "Abläöübolo"); @@ -161,15 +164,15 @@ public void testShouldFailOnWrongRecordId() { picaEncoder.endEntity(); picaEncoder.endRecord(); - verify(receiver).process("003@ \u001f017709958X\u001e028@ \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); + Mockito.verify(receiver).process("003@ \u001f017709958X\u001e028@ \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); } @Test public void testShouldIgnoreRecordId() { - picaEncoder.setIgnoreRecordId(true);//Set Ignore to true + picaEncoder.setIgnoreRecordId(true); // Set Ignore to true picaEncoder.startRecord("17709958"); picaEncoder.startEntity("003@"); - picaEncoder.literal("0", "17709958X"); //RecordId not match but should be ignored! + picaEncoder.literal("0", "17709958X"); // RecordId not match but should be ignored! picaEncoder.endEntity(); picaEncoder.startEntity("028@"); picaEncoder.literal("P", "Abläöübolo"); @@ -178,7 +181,7 @@ public void testShouldIgnoreRecordId() { picaEncoder.endEntity(); picaEncoder.endRecord(); - verify(receiver).process("003@ \u001f017709958X\u001e028@ \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); + Mockito.verify(receiver).process("003@ \u001f017709958X\u001e028@ \u001fPAbla\u0308o\u0308u\u0308bolo\u001fnVIX\u001flBapst\u001e"); } } diff --git a/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaMultiscriptRemodelerTest.java b/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaMultiscriptRemodelerTest.java index be0f8a48a..01909dfb0 100644 --- a/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaMultiscriptRemodelerTest.java +++ b/metafacture-biblio/src/test/java/org/metafacture/biblio/pica/PicaMultiscriptRemodelerTest.java @@ -16,15 +16,14 @@ package org.metafacture.biblio.pica; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.times; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -58,6 +57,9 @@ public class PicaMultiscriptRemodelerTest { @Mock private StreamReceiver receiver; + public PicaMultiscriptRemodelerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -83,7 +85,7 @@ public void shouldSimplyPassThroughNonMultiscriptFields() { remodeler.endEntity(); remodeler.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).startEntity(FIELD_003AT); ordered.verify(receiver).literal("0", RECORD_ID); @@ -103,7 +105,7 @@ public void shouldRemodelMultscriptField() { emitMultscriptField(FIELD_021A, "01", SCRIPT_GREEK, VALUE_1_GREEK); remodeler.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verifyMultiscriptField(ordered, FIELD_021A, "01", SCRIPT_LATIN, VALUE_1, SCRIPT_GREEK, VALUE_1_GREEK); @@ -119,7 +121,7 @@ public void shouldRemodelInterleafedMultscriptFields() { emitMultscriptField(FIELD_021C, "02", SCRIPT_GREEK, VALUE_2_GREEK); remodeler.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verifyMultiscriptField(ordered, FIELD_021C, "01", SCRIPT_LATIN, VALUE_1, SCRIPT_GREEK, VALUE_1_GREEK); @@ -134,7 +136,7 @@ public void shouldPassThroughSingleMultiscriptField() { emitMultscriptField(FIELD_021A, "01", SCRIPT_LATIN, VALUE_1); remodeler.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verifySingleMultiscriptField(ordered, FIELD_021A, "01", SCRIPT_LATIN, VALUE_1); @@ -149,7 +151,7 @@ public void shouldPassThroughSingleMultiscriptFieldFollowedByCompleteMultiscript emitMultscriptField(FIELD_021C, "02", SCRIPT_GREEK, VALUE_2_GREEK); remodeler.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verifySingleMultiscriptField(ordered, FIELD_021C, "01", SCRIPT_LATIN, VALUE_1); @@ -166,7 +168,7 @@ public void shouldPassThroughSingleMultiscriptFieldFollowedByCompleteMultiscript emitMultscriptField(FIELD_021C, "01", SCRIPT_GREEK, VALUE_2_GREEK); remodeler.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verifySingleMultiscriptField(ordered, FIELD_021A, "01", SCRIPT_LATIN, VALUE_1); @@ -184,7 +186,7 @@ public void shouldPassThroughSingleMultiscriptFieldFollowedByNonMultiscriptField remodeler.endEntity(); remodeler.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verifySingleMultiscriptField(ordered, FIELD_021A, "01", SCRIPT_LATIN, VALUE_1); @@ -207,7 +209,7 @@ public void shouldPassThroughIncompleteMultiscriptFields() { remodeler.endEntity(); remodeler.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).startEntity(FIELD_021C); ordered.verify(receiver).literal("T", "01"); @@ -227,7 +229,7 @@ public void shouldLabelArabicAsNonLatinRightToLeftScript() { emitMultscriptField(FIELD_021A, "01", SCRIPT_ARABIC, VALUE_1_ARABIC); remodeler.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verifyMultiscriptField(ordered, FIELD_021A, "01", SCRIPT_LATIN, VALUE_1, SCRIPT_ARABIC, VALUE_1_ARABIC); @@ -241,7 +243,7 @@ public void shouldLabelHebrewAsNonLatinRightToLeftScript() { emitMultscriptField(FIELD_021A, "01", SCRIPT_HEBREW, VALUE_1_HEBREW); remodeler.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); verifyMultiscriptField(ordered, FIELD_021A, "01", SCRIPT_LATIN, VALUE_1, SCRIPT_HEBREW, VALUE_1_HEBREW); @@ -257,7 +259,7 @@ public void shouldClearStateOnResetStream() { emitMultscriptField(FIELD_021A, "01", SCRIPT_GREEK, VALUE_1_GREEK); remodeler.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).resetStream(); ordered.verify(receiver).startRecord(RECORD_ID); @@ -275,7 +277,7 @@ private void emitMultscriptField(final String field, remodeler.endEntity(); } - private void verifyMultiscriptField(final InOrder ordered, + private void verifyMultiscriptField(final InOrder ordered, // checkstyle-disable-line ParameterNumber final String field, final String groupNumber, final String script1, final String value1, final String script2, final String value2) { @@ -289,7 +291,7 @@ private void verifyMultiscriptField(final InOrder ordered, ordered.verify(receiver).literal("T", groupNumber); ordered.verify(receiver).literal("U", script2); ordered.verify(receiver).literal("a", value2); - ordered.verify(receiver, times(2)).endEntity(); + ordered.verify(receiver, Mockito.times(2)).endEntity(); } private void verifySingleMultiscriptField(final InOrder ordered, @@ -304,14 +306,9 @@ private void verifySingleMultiscriptField(final InOrder ordered, } private String mapScriptToEntityName(final String script) { - if (SCRIPT_LATIN.equals(script)) { - return PicaMultiscriptRemodeler.ENTITY_NAME_FOR_LATIN; - } - else if (SCRIPT_ARABIC.equals(script) - || SCRIPT_HEBREW.equals(script)) { - return PicaMultiscriptRemodeler.ENTITY_NAME_FOR_NON_LATIN_RL; - } - return PicaMultiscriptRemodeler.ENTITY_NAME_FOR_NON_LATIN_LR; + return SCRIPT_LATIN.equals(script) ? PicaMultiscriptRemodeler.ENTITY_NAME_FOR_LATIN : + SCRIPT_ARABIC.equals(script) || SCRIPT_HEBREW.equals(script) ? PicaMultiscriptRemodeler.ENTITY_NAME_FOR_NON_LATIN_RL : + PicaMultiscriptRemodeler.ENTITY_NAME_FOR_NON_LATIN_LR; } } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/RequireTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/RequireTest.java index b08592b08..1a9f3d46b 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/RequireTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/RequireTest.java @@ -16,9 +16,7 @@ package org.metafacture.commons; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertSame; - +import org.junit.Assert; import org.junit.Test; /** @@ -29,6 +27,9 @@ */ public final class RequireTest { + public RequireTest() { + } + @Test(expected = IllegalArgumentException.class) public void notNullShouldThrowIllegalArgumentExceptionIfArgIsNull() { Require.notNull(null); @@ -37,7 +38,7 @@ public void notNullShouldThrowIllegalArgumentExceptionIfArgIsNull() { @Test public void notNullShouldReturnArgIfArgIsNotNull() { final Object obj = new Object(); - assertSame(obj, Require.notNull(obj)); + Assert.assertSame(obj, Require.notNull(obj)); } @Test(expected = IllegalArgumentException.class) @@ -47,7 +48,7 @@ public void notNegativeShouldThrowIllegalArgumentExceptionIfArgIsNegative() { @Test public void notNegativeShouldReturnArgIfArgIsNotNegative() { - assertEquals(0, Require.notNegative(0)); + Assert.assertEquals(0, Require.notNegative(0)); } @Test(expected = IllegalArgumentException.class) @@ -72,7 +73,7 @@ public void validArrayIndexShouldThrowIndexOutOfBoundsExceptionIfIndexIsGreaterT @Test public void validArrayIndexShouldDoNothingIfIndexIsWithinArrayBounds() { - assertEquals(1, Require.validArrayIndex(1, 2)); + Assert.assertEquals(1, Require.validArrayIndex(1, 2)); } @Test(expected = IndexOutOfBoundsException.class) diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/ResourceUtilTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/ResourceUtilTest.java index 11ba1173a..2b5434125 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/ResourceUtilTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/ResourceUtilTest.java @@ -16,17 +16,14 @@ package org.metafacture.commons; -import static java.util.stream.Collectors.joining; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.metafacture.commons.ResourceUtil.BUFFER_SIZE; +import org.junit.Assert; +import org.junit.Test; import java.io.IOException; import java.io.StringReader; +import java.util.stream.Collectors; import java.util.stream.IntStream; -import org.junit.Test; - /** * Tests for class {@link ResourceUtil}. * @@ -34,49 +31,51 @@ */ public class ResourceUtilTest { + public ResourceUtilTest() { + } + @Test - public void readAll_shouldReturnEmptyStringIfStreamIsEmpty() + public void readAllShouldReturnEmptyStringIfStreamIsEmpty() throws IOException { - final String result = ResourceUtil.readAll(new StringReader("")); - assertTrue(result.isEmpty()); + Assert.assertTrue(result.isEmpty()); } @Test - public void readAll_shouldReadStreamThatFitsIntoOneBuffer() + public void readAllShouldReadStreamThatFitsIntoOneBuffer() throws IOException { - final String input = repeat("a", BUFFER_SIZE - 1); + final String input = repeat("a", ResourceUtil.BUFFER_SIZE - 1); final String result = ResourceUtil.readAll(new StringReader(input)); - assertEquals(input, result); + Assert.assertEquals(input, result); } @Test - public void readAll_shouldReadStreamThatFitsExactlyIntoOneBuffer() + public void readAllShouldReadStreamThatFitsExactlyIntoOneBuffer() throws IOException { - final String input = repeat("b", BUFFER_SIZE); + final String input = repeat("b", ResourceUtil.BUFFER_SIZE); final String result = ResourceUtil.readAll(new StringReader(input)); - assertEquals(input, result); + Assert.assertEquals(input, result); } @Test - public void readAll_shouldReadStreamThatSpansMultipleBuffers() + public void readAllShouldReadStreamThatSpansMultipleBuffers() throws IOException { - final String input = repeat("c", BUFFER_SIZE * 2 + 1); + final String input = repeat("c", ResourceUtil.BUFFER_SIZE * 2 + 1); final String result = ResourceUtil.readAll(new StringReader(input)); - assertEquals(input, result); + Assert.assertEquals(input, result); } - private String repeat(String string, int times) { + private String repeat(final String string, final int times) { return IntStream.range(0, times) .mapToObj(i -> string) - .collect(joining()); + .collect(Collectors.joining()); } } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/StringUtilTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/StringUtilTest.java index 3b527e0a6..43db293c3 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/StringUtilTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/StringUtilTest.java @@ -16,15 +16,13 @@ package org.metafacture.commons; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; import java.util.HashMap; import java.util.Map; -import org.junit.Before; -import org.junit.Test; - /** * Tests for the static methods in {@link StringUtil}. * @@ -43,6 +41,9 @@ public final class StringUtilTest { private final Map vars = new HashMap(); + public StringUtilTest() { + } + @Before public void initvars() { vars.put("a", "Aloha"); @@ -57,7 +58,7 @@ public void copyToBufferShouldResizeBufferIfNecessary() { final char[] newBuffer = StringUtil.copyToBuffer(str, buffer); - assertTrue(newBuffer.length >= str.length()); + Assert.assertTrue(newBuffer.length >= str.length()); } @Test @@ -68,20 +69,20 @@ public void copyToBufferShouldReturnBufferContainingTheStringData() { buffer = StringUtil.copyToBuffer(str, buffer); - assertEquals(STRING_WITH_4_CHARS, String.valueOf(buffer, 0, bufferLen)); + Assert.assertEquals(STRING_WITH_4_CHARS, String.valueOf(buffer, 0, bufferLen)); } @Test public void testFormat() { - assertEquals(ALOHA_HAWAII, StringUtil.format("${a} ${b}", vars)); - assertEquals(ALOHAHAWAII, StringUtil.format("${a}${b}", vars)); - assertEquals("Aloha${b", StringUtil.format("${a}${b", vars)); - assertEquals("XAloha${b", StringUtil.format("X${a}${b", vars)); - assertEquals("XX", StringUtil.format("X${ab}X", vars)); - assertEquals(XHULAXHULAX, StringUtil.format("X${bb}X${bb}X", vars)); - assertEquals("{a}Hawaii", StringUtil.format("{a}${b}", vars)); - assertEquals("Hula$Hula", StringUtil.format("${bb}$${bb}", vars)); + Assert.assertEquals(ALOHA_HAWAII, StringUtil.format("${a} ${b}", vars)); + Assert.assertEquals(ALOHAHAWAII, StringUtil.format("${a}${b}", vars)); + Assert.assertEquals("Aloha${b", StringUtil.format("${a}${b", vars)); + Assert.assertEquals("XAloha${b", StringUtil.format("X${a}${b", vars)); + Assert.assertEquals("XX", StringUtil.format("X${ab}X", vars)); + Assert.assertEquals(XHULAXHULAX, StringUtil.format("X${bb}X${bb}X", vars)); + Assert.assertEquals("{a}Hawaii", StringUtil.format("{a}${b}", vars)); + Assert.assertEquals("Hula$Hula", StringUtil.format("${bb}$${bb}", vars)); } @@ -90,18 +91,18 @@ public void testCustomVarIndicators() { final String varStart = "VAR_START"; final String varEnd = "VAR_END"; - assertEquals(ALOHA_HAWAII, + Assert.assertEquals(ALOHA_HAWAII, StringUtil.format("VAR_STARTaVAR_END VAR_STARTbVAR_END", varStart, varEnd, vars)); - assertEquals(ALOHAHAWAII, StringUtil.format("VAR_STARTaVAR_ENDVAR_STARTbVAR_END", varStart, varEnd, vars)); - assertEquals("AlohaVAR_STARTb", StringUtil.format("VAR_STARTaVAR_ENDVAR_STARTb", varStart, varEnd, vars)); - assertEquals("XAlohaVAR_STARTb", StringUtil.format("XVAR_STARTaVAR_ENDVAR_STARTb", varStart, varEnd, vars)); - assertEquals("XX", StringUtil.format("XVAR_STARTabVAR_ENDX", varStart, varEnd, vars)); - assertEquals(XHULAXHULAX, + Assert.assertEquals(ALOHAHAWAII, StringUtil.format("VAR_STARTaVAR_ENDVAR_STARTbVAR_END", varStart, varEnd, vars)); + Assert.assertEquals("AlohaVAR_STARTb", StringUtil.format("VAR_STARTaVAR_ENDVAR_STARTb", varStart, varEnd, vars)); + Assert.assertEquals("XAlohaVAR_STARTb", StringUtil.format("XVAR_STARTaVAR_ENDVAR_STARTb", varStart, varEnd, vars)); + Assert.assertEquals("XX", StringUtil.format("XVAR_STARTabVAR_ENDX", varStart, varEnd, vars)); + Assert.assertEquals(XHULAXHULAX, StringUtil.format("XVAR_STARTbbVAR_ENDXVAR_STARTbbVAR_ENDX", varStart, varEnd, vars)); - assertEquals("{aVAR_ENDHawaii", StringUtil.format("{aVAR_ENDVAR_STARTbVAR_END", varStart, varEnd, vars)); + Assert.assertEquals("{aVAR_ENDHawaii", StringUtil.format("{aVAR_ENDVAR_STARTbVAR_END", varStart, varEnd, vars)); } - @Test(expected=IllegalArgumentException.class) + @Test(expected = IllegalArgumentException.class) public void testMissingVars() { StringUtil.format("${a}${x}", false, vars); } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/TimeUtilTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/TimeUtilTest.java index ef5cb7561..4c7aa84f9 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/TimeUtilTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/TimeUtilTest.java @@ -16,8 +16,7 @@ package org.metafacture.commons; -import static org.junit.Assert.assertEquals; - +import org.junit.Assert; import org.junit.Test; /** @@ -28,13 +27,16 @@ */ public final class TimeUtilTest { + public TimeUtilTest() { + } + @Test public void testShouldFormatNanoseconds() { final long duration = 29 * TimeUtil.NANOSECONDS; final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("29ns", formattedDuration); + Assert.assertEquals("29ns", formattedDuration); } @Test @@ -43,7 +45,7 @@ public void testShouldFormatMicroseconds() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("28µs", formattedDuration); + Assert.assertEquals("28µs", formattedDuration); } @Test @@ -52,7 +54,7 @@ public void testShouldFormatSeconds() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("10s", formattedDuration); + Assert.assertEquals("10s", formattedDuration); } @Test @@ -61,7 +63,7 @@ public void testShouldFormatMinutes() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("58min", formattedDuration); + Assert.assertEquals("58min", formattedDuration); } @Test @@ -70,7 +72,7 @@ public void testShouldFormatMicrosecondsPlusNanoseconds() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("28µs 9ns", formattedDuration); + Assert.assertEquals("28µs 9ns", formattedDuration); } @Test @@ -79,7 +81,7 @@ public void testShouldFormatSecondsPlusMilliseconds() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("10s 8ms", formattedDuration); + Assert.assertEquals("10s 8ms", formattedDuration); } @Test @@ -88,7 +90,7 @@ public void testShouldRoundDownIfRemainderLessThanHalf() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("23min 1s", formattedDuration); + Assert.assertEquals("23min 1s", formattedDuration); } @Test @@ -97,7 +99,7 @@ public void testShouldRoundDownIfNanosecondsLessThanHalf() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("23ms 1µs", formattedDuration); + Assert.assertEquals("23ms 1µs", formattedDuration); } @Test @@ -106,7 +108,7 @@ public void testShouldIgnoreSmallerQualifiersWhenRounding() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("23min 1s", formattedDuration); + Assert.assertEquals("23min 1s", formattedDuration); } @Test @@ -115,7 +117,7 @@ public void testShouldRoundUpIfRemainderGreaterThanHalf() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("42min 2s", formattedDuration); + Assert.assertEquals("42min 2s", formattedDuration); } @Test @@ -124,7 +126,7 @@ public void testShouldRoundDownIfNanosecondsGreaterThanHalf() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("42ms 2µs", formattedDuration); + Assert.assertEquals("42ms 2µs", formattedDuration); } @Test @@ -133,7 +135,7 @@ public void testShouldRoundUpIfRemainderIsMidway() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("42min 2s", formattedDuration); + Assert.assertEquals("42min 2s", formattedDuration); } @Test @@ -142,7 +144,7 @@ public void testShouldNotFailIfDurationIsZero() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("0s", formattedDuration); + Assert.assertEquals("0s", formattedDuration); } /** @@ -155,7 +157,7 @@ public void testShouldNotFailIfDurationNeedsLargestQuantifier() { final String formattedDuration = TimeUtil.formatDuration(duration); - assertEquals("1h 1min", formattedDuration); + Assert.assertEquals("1h 1min", formattedDuration); } } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/XmlUtilTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/XmlUtilTest.java index 715eb93e5..5ee63ab04 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/XmlUtilTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/XmlUtilTest.java @@ -16,8 +16,7 @@ package org.metafacture.commons; -import static org.junit.Assert.assertEquals; - +import org.junit.Assert; import org.junit.Test; /** @@ -27,39 +26,42 @@ */ public class XmlUtilTest { + public XmlUtilTest() { + } + @Test - public void escape_shouldEscapeXmlSpecialChars() { + public void shouldEscapeXmlSpecialChars() { final String unescaped = "< > ' & \""; final String result = XmlUtil.escape(unescaped); - assertEquals("< > ' & "", result); + Assert.assertEquals("< > ' & "", result); } @Test - public void escape_shouldNotEscapeAsciiChars() { - final String unescaped ="Kafka"; + public void shouldNotEscapeAsciiChars() { + final String unescaped = "Kafka"; final String result = XmlUtil.escape(unescaped); - assertEquals("Kafka", result); + Assert.assertEquals("Kafka", result); } @Test - public void escape_shouldEscapeAllNonAsciiChars() { + public void shouldEscapeAllNonAsciiChars() { final String unescaped = "K\u00f8benhavn"; final String result = XmlUtil.escape(unescaped); - assertEquals("København", result); + Assert.assertEquals("København", result); } @Test - public void issue267_escape_shouldEscapeSurrogatePairsAsSingleEntity() { + public void issue267_shouldEscapeSurrogatePairsAsSingleEntity() { final String unescaped = "Smile: \ud83d\ude09"; final String result = XmlUtil.escape(unescaped); - assertEquals("Smile: 😉", result); + Assert.assertEquals("Smile: 😉", result); } } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/tries/CharMapTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/tries/CharMapTest.java index 79a14a586..12698d88a 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/tries/CharMapTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/tries/CharMapTest.java @@ -16,13 +16,10 @@ package org.metafacture.commons.tries; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; - -import java.util.Map; - +import org.junit.Assert; import org.junit.Test; +import java.util.Map; /** * tests {@link CharMap} @@ -34,14 +31,16 @@ public final class CharMapTest { private static final String UML = "umlaut"; + public CharMapTest() { + } + @Test public void testEmptyMap() { final Map map = new CharMap(); for (byte i = Byte.MIN_VALUE; i < Byte.MAX_VALUE; ++i) { - assertNull(map.get(Byte.valueOf(i))); + Assert.assertNull(map.get(Byte.valueOf(i))); } - } @Test @@ -50,8 +49,7 @@ public void testSingleEntry() { final char beite = 'ü'; map.put(Character.valueOf(beite), UML); - assertEquals(UML,map.get(Character.valueOf(beite))); - + Assert.assertEquals(UML, map.get(Character.valueOf(beite))); } @Test @@ -63,21 +61,20 @@ public void testFullMap() { } for (char i = Character.MIN_VALUE; i < Character.MAX_VALUE; ++i) { - assertEquals(Integer.valueOf(i),map.get(Character.valueOf(i))); + Assert.assertEquals(Integer.valueOf(i), map.get(Character.valueOf(i))); } - } @Test public void testMixedMap() { final Map map = new CharMap(); - for (char i = 0; i < Character.MAX_VALUE-1; i+=2) { + for (char i = 0; i < Character.MAX_VALUE - 1; i += 2) { map.put(Character.valueOf(i), Integer.valueOf(i)); } - for (char i = 0; i < Character.MAX_VALUE-1; i+=2) { - assertEquals(Integer.valueOf(i),map.get(Character.valueOf(i))); + for (char i = 0; i < Character.MAX_VALUE - 1; i += 2) { + Assert.assertEquals(Integer.valueOf(i), map.get(Character.valueOf(i))); } } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/tries/SetMatchTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/tries/SetMatchTest.java index a82461d5a..96e22b848 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/tries/SetMatchTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/tries/SetMatchTest.java @@ -16,10 +16,8 @@ package org.metafacture.commons.tries; -import static org.junit.Assert.assertEquals; - +import org.junit.Assert; import org.junit.Test; -import org.metafacture.commons.tries.SetMatcher.Match; /** * tests {@link SetMatcher} @@ -29,13 +27,15 @@ */ public final class SetMatchTest { + public SetMatchTest() { + } + @Test public void testSetMatch() { final SetMatcher setMatch = new SetMatcher(); - final String[] cities = { "Perth", "York", "York Town", "München", "New York City", "New York", "Petersburg", - "ert", }; - final int[] matches = { 7, 0, 7, 5, 1, 4, 1, 1, 2, 3 }; + final String[] cities = {"Perth", "York", "York Town", "München", "New York City", "New York", "Petersburg", "ert"}; + final int[] matches = {7, 0, 7, 5, 1, 4, 1, 1, 2, 3}; final String text = "Pexrt Perth Peerth New York City York York Town München"; for (int i = 0; i < cities.length; ++i) { @@ -45,14 +45,14 @@ public void testSetMatch() { int index = 0; //System.out.println(text); - for (Match match : setMatch.match(text)) { + for (final SetMatcher.Match match : setMatch.match(text)) { //System.out.println(match.getValue() + " " + match.getStart()); - assertEquals(cities[matches[index]], match.getValue()); + Assert.assertEquals(cities[matches[index]], match.getValue()); ++index; } // setMatch.printDebug(System.err); - assertEquals("missing matches", matches.length, index); + Assert.assertEquals("missing matches", matches.length, index); } } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/tries/SetReplaceTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/tries/SetReplaceTest.java index 1376ea9f1..311366dca 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/tries/SetReplaceTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/tries/SetReplaceTest.java @@ -16,11 +16,9 @@ package org.metafacture.commons.tries; -import static org.junit.Assert.assertEquals; - +import org.junit.Assert; import org.junit.Test; - /** * tests {@link SetReplacer} * @@ -29,9 +27,11 @@ */ public final class SetReplaceTest { + public SetReplaceTest() { + } + @Test public void testReplace() { - final SetReplacer setReplace = new SetReplacer(); final String text = "auf sylt mit super krabben entsafter und apfel"; final String target = "auf hawaii mit Mai Tai und surfboard"; @@ -41,20 +41,18 @@ public void testReplace() { setReplace.addReplacement("krabben", "shirt"); setReplace.addReplacement("super krabben entsafter", "Mai Tai"); - assertEquals(target, setReplace.replaceIn(text)); + Assert.assertEquals(target, setReplace.replaceIn(text)); } @Test public void testReplaceWithInclusion() { - final SetReplacer setReplace = new SetReplacer(); - setReplace.addReplacement("fünf", "5"); setReplace.addReplacement("fünfzig", "50"); - assertEquals("50 äpfel", setReplace.replaceIn("fünfzig äpfel")); - assertEquals("5 äpfel", setReplace.replaceIn("fünf äpfel")); + Assert.assertEquals("50 äpfel", setReplace.replaceIn("fünfzig äpfel")); + Assert.assertEquals("5 äpfel", setReplace.replaceIn("fünf äpfel")); } } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/tries/SimpleRegexTrieTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/tries/SimpleRegexTrieTest.java index 46312a1b9..ea6f4d258 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/tries/SimpleRegexTrieTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/tries/SimpleRegexTrieTest.java @@ -15,8 +15,7 @@ package org.metafacture.commons.tries; -import static org.junit.Assert.assertTrue; - +import org.junit.Assert; import org.junit.Test; /** @@ -30,12 +29,15 @@ public final class SimpleRegexTrieTest { private static final String AACBB = "aacbb"; private static final String ABCBB = "abcbb"; + public SimpleRegexTrieTest() { + } + @Test public void testWithSimpleCharacterClass() { final SimpleRegexTrie trie = new SimpleRegexTrie(); trie.put("a[ab]cbb", "value"); - assertTrue("Expecting to find: " + AACBB, trie.get(AACBB).size() == 1); - assertTrue("Expecting to find: " + ABCBB, trie.get(ABCBB).size() == 1); + Assert.assertTrue("Expecting to find: " + AACBB, trie.get(AACBB).size() == 1); + Assert.assertTrue("Expecting to find: " + ABCBB, trie.get(ABCBB).size() == 1); } @Test @@ -44,6 +46,6 @@ public void testWithEmptyCharacterClass() { // Should not be treated as character class (used for JSON arrays): final String key = "a[].1.b[].1"; trie.put(key, "value"); - assertTrue("Expecting to find: " + key, trie.get(key).size() == 1); + Assert.assertTrue("Expecting to find: " + key, trie.get(key).size() == 1); } } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/tries/SimpleTrieTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/tries/SimpleTrieTest.java index 27263ed6b..e7c1fc9e0 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/tries/SimpleTrieTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/tries/SimpleTrieTest.java @@ -16,13 +16,10 @@ package org.metafacture.commons.tries; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; - -import java.util.Locale; - +import org.junit.Assert; import org.junit.Test; +import java.util.Locale; /** * tests {@link SimpleTrie} @@ -35,19 +32,22 @@ public final class SimpleTrieTest { private static final String KEY = "key"; private static final String VALUE = "value"; + public SimpleTrieTest() { + } + @Test public void testAdd() { final SimpleTrie trie = new SimpleTrie(); - assertNull(trie.get(KEY)); + Assert.assertNull(trie.get(KEY)); trie.put(KEY, VALUE); - assertEquals(VALUE, trie.get(KEY)); + Assert.assertEquals(VALUE, trie.get(KEY)); } @Test - public void testMultiAdd(){ + public void testMultiAdd() { final SimpleTrie trie = new SimpleTrie(); - final String[] megacities = { "Brisbane", "Sydney", "Melbourne", "Adelaide", "Perth", "Berlin", "Berlin Center", "Bremen", "Petersburg"}; + final String[] megacities = {"Brisbane", "Sydney", "Melbourne", "Adelaide", "Perth", "Berlin", "Berlin Center", "Bremen", "Petersburg"}; for (int i = 0; i < megacities.length; ++i) { final String city = megacities[i]; @@ -56,7 +56,7 @@ public void testMultiAdd(){ for (int i = 0; i < megacities.length; ++i) { final String city = megacities[i]; - assertEquals(city.toUpperCase(Locale.US), trie.get(city)); + Assert.assertEquals(city.toUpperCase(Locale.US), trie.get(city)); } } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/tries/WildcardTrieTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/tries/WildcardTrieTest.java index 5ad08b05f..af1f65a46 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/tries/WildcardTrieTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/tries/WildcardTrieTest.java @@ -17,9 +17,7 @@ package org.metafacture.commons.tries; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - +import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -47,6 +45,9 @@ public final class WildcardTrieTest { private WildcardTrie trie; + public WildcardTrieTest() { + } + @Before public void createSystemUnderTest() { trie = new WildcardTrie<>(); @@ -54,77 +55,77 @@ public void createSystemUnderTest() { @Test public void testWithQWildcard() { - assertTrue(trie.get("").isEmpty()); - assertTrue(trie.get("x").isEmpty()); + Assert.assertTrue(trie.get("").isEmpty()); + Assert.assertTrue(trie.get("x").isEmpty()); trie.put(ABC, ABC); - assertTrue(trie.get(ABC).contains(ABC)); + Assert.assertTrue(trie.get(ABC).contains(ABC)); trie.put(AAQBB, AAQBB); - assertTrue(trie.get(AACBB).contains(AAQBB)); - assertTrue(trie.get(AABB).isEmpty()); + Assert.assertTrue(trie.get(AACBB).contains(AAQBB)); + Assert.assertTrue(trie.get(AABB).isEmpty()); trie.put(AABB, AABB); - assertTrue(trie.get(AABB).contains(AABB)); - assertTrue(trie.get(AABB).size() == 1); + Assert.assertTrue(trie.get(AABB).contains(AABB)); + Assert.assertTrue(trie.get(AABB).size() == 1); trie.put(AACBB, AACBB); - assertTrue(trie.get(AACBB).contains(AACBB)); - assertTrue(trie.get(AACBB).contains(AAQBB)); + Assert.assertTrue(trie.get(AACBB).contains(AACBB)); + Assert.assertTrue(trie.get(AACBB).contains(AAQBB)); } @Test public void testWithStarWildcard() { trie.put(A_STAR_B, A_STAR_B); - assertTrue(AACBB + NOT_FOUND_BY + A_STAR_B, trie.get(AACBB).contains(A_STAR_B)); - assertTrue(AABB + NOT_FOUND_BY + A_STAR_B, trie.get(AABB).contains(A_STAR_B)); - assertTrue(AB + NOT_FOUND_BY + A_STAR_B, trie.get(AB).contains(A_STAR_B)); - assertTrue(ABC + FOUND_BY + A_STAR_B, trie.get(ABC).isEmpty()); - assertTrue(CCB + FOUND_BY + A_STAR_B, trie.get(CCB).isEmpty()); + Assert.assertTrue(AACBB + NOT_FOUND_BY + A_STAR_B, trie.get(AACBB).contains(A_STAR_B)); + Assert.assertTrue(AABB + NOT_FOUND_BY + A_STAR_B, trie.get(AABB).contains(A_STAR_B)); + Assert.assertTrue(AB + NOT_FOUND_BY + A_STAR_B, trie.get(AB).contains(A_STAR_B)); + Assert.assertTrue(ABC + FOUND_BY + A_STAR_B, trie.get(ABC).isEmpty()); + Assert.assertTrue(CCB + FOUND_BY + A_STAR_B, trie.get(CCB).isEmpty()); trie.put(AABB, AABB); - assertTrue(trie.get(AABB).contains(AABB)); - assertEquals(2, trie.get(AABB).size()); + Assert.assertTrue(trie.get(AABB).contains(AABB)); + Assert.assertEquals(2, trie.get(AABB).size()); trie.put(AACBB, AACBB); - assertTrue(trie.get(AACBB).contains(AACBB)); - assertTrue(trie.get(AACBB).contains(A_STAR_B)); + Assert.assertTrue(trie.get(AACBB).contains(AACBB)); + Assert.assertTrue(trie.get(AACBB).contains(A_STAR_B)); } @Test public void testWithTrailingStarWildcard() { trie.put(A_STAR, A_STAR); - assertTrue(AACBB + NOT_FOUND_BY + A_STAR, trie.get(AACBB).contains(A_STAR)); - assertTrue(AABB + NOT_FOUND_BY + A_STAR, trie.get(AABB).contains(A_STAR)); - assertTrue(AB + NOT_FOUND_BY + A_STAR, trie.get(AB).contains(A_STAR)); - assertTrue(ABC + NOT_FOUND_BY + A_STAR_B, trie.get(ABC).contains(A_STAR)); - assertTrue(CCB + FOUND_BY + A_STAR_B, trie.get(CCB).isEmpty()); + Assert.assertTrue(AACBB + NOT_FOUND_BY + A_STAR, trie.get(AACBB).contains(A_STAR)); + Assert.assertTrue(AABB + NOT_FOUND_BY + A_STAR, trie.get(AABB).contains(A_STAR)); + Assert.assertTrue(AB + NOT_FOUND_BY + A_STAR, trie.get(AB).contains(A_STAR)); + Assert.assertTrue(ABC + NOT_FOUND_BY + A_STAR_B, trie.get(ABC).contains(A_STAR)); + Assert.assertTrue(CCB + FOUND_BY + A_STAR_B, trie.get(CCB).isEmpty()); trie.put(AABB, AABB); - assertTrue(trie.get(AABB).contains(AABB)); - assertEquals(2, trie.get(AABB).size()); + Assert.assertTrue(trie.get(AABB).contains(AABB)); + Assert.assertEquals(2, trie.get(AABB).size()); trie.put(AACBB, AACBB); - assertTrue(trie.get(AACBB).contains(AACBB)); - assertTrue(trie.get(AACBB).contains(A_STAR)); + Assert.assertTrue(trie.get(AACBB).contains(AACBB)); + Assert.assertTrue(trie.get(AACBB).contains(A_STAR)); } @Test public void testWithInitialStarWildcard() { trie.put(STAR_B, STAR_B); - assertTrue(AACBB + NOT_FOUND_BY + STAR_B, trie.get(AACBB).contains(STAR_B)); - assertTrue(AABB + NOT_FOUND_BY + STAR_B, trie.get(AABB).contains(STAR_B)); + Assert.assertTrue(AACBB + NOT_FOUND_BY + STAR_B, trie.get(AACBB).contains(STAR_B)); + Assert.assertTrue(AABB + NOT_FOUND_BY + STAR_B, trie.get(AABB).contains(STAR_B)); - assertTrue(ABC + FOUND_BY + A_STAR_B, trie.get(ABC).isEmpty()); - assertTrue(CCB + NOT_FOUND_BY + A_STAR_B, trie.get(CCB).contains(STAR_B)); + Assert.assertTrue(ABC + FOUND_BY + A_STAR_B, trie.get(ABC).isEmpty()); + Assert.assertTrue(CCB + NOT_FOUND_BY + A_STAR_B, trie.get(CCB).contains(STAR_B)); trie.put(AABB, AABB); - assertTrue(trie.get(AABB).contains(AABB)); - assertEquals(2, trie.get(AABB).size()); + Assert.assertTrue(trie.get(AABB).contains(AABB)); + Assert.assertEquals(2, trie.get(AABB).size()); trie.put(AACBB, AACBB); - assertTrue(trie.get(AACBB).contains(AACBB)); - assertTrue(trie.get(AACBB).contains(STAR_B)); + Assert.assertTrue(trie.get(AACBB).contains(AACBB)); + Assert.assertTrue(trie.get(AACBB).contains(STAR_B)); } @Test @@ -133,15 +134,15 @@ public void testWithMultipleStarWildcards() { trie.put(A_STAR, A_STAR); trie.put(A_STAR_B, A_STAR_B); - assertEquals(3, trie.get(AACBB).size()); + Assert.assertEquals(3, trie.get(AACBB).size()); trie.put(AA_STAR_BB, AA_STAR_BB); - assertEquals(4, trie.get(AACBB).size()); + Assert.assertEquals(4, trie.get(AACBB).size()); - assertEquals(3, trie.get(AB).size()); - assertEquals(1, trie.get(CCB).size()); + Assert.assertEquals(3, trie.get(AB).size()); + Assert.assertEquals(1, trie.get(CCB).size()); - assertEquals(3, trie.get("acb").size()); + Assert.assertEquals(3, trie.get("acb").size()); } @Test @@ -149,25 +150,25 @@ public void testOverlapWithWildcard() { trie.put(ABC, ABC); trie.put(A_STAR_BC, A_STAR_BC); - assertEquals(2, trie.get(ABC).size()); - assertEquals(1, trie.get("abbc").size()); + Assert.assertEquals(2, trie.get(ABC).size()); + Assert.assertEquals(1, trie.get("abbc").size()); } @Test public void testEmptyKey() { trie.put("", ABC); - assertEquals(1, trie.get("").size()); + Assert.assertEquals(1, trie.get("").size()); } @Test public void testWithOrAndWildcard() { final String key = ABC + WildcardTrie.OR_STRING + CCB; trie.put(key, ""); - assertTrue(ABC + NOT_FOUND_BY + key, trie.get(ABC).contains("")); - assertTrue(CCB + NOT_FOUND_BY + key, trie.get(CCB).contains("")); + Assert.assertTrue(ABC + NOT_FOUND_BY + key, trie.get(ABC).contains("")); + Assert.assertTrue(CCB + NOT_FOUND_BY + key, trie.get(CCB).contains("")); - assertTrue(AABB + FOUND_BY + key, trie.get(AABB).isEmpty()); - assertTrue(AB + FOUND_BY + key, trie.get(AB).isEmpty()); + Assert.assertTrue(AABB + FOUND_BY + key, trie.get(AABB).isEmpty()); + Assert.assertTrue(AB + FOUND_BY + key, trie.get(AB).isEmpty()); } } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/types/ListMapTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/types/ListMapTest.java index cb8fd793c..9022016e3 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/types/ListMapTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/types/ListMapTest.java @@ -16,14 +16,9 @@ package org.metafacture.commons.types; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - +import org.junit.Assert; import org.junit.Test; - /** * Tests for class {@link ListMap}. * @@ -31,38 +26,43 @@ * */ public final class ListMapTest { + private static final String VALUE1 = "v1"; private static final String NAME1 = "n1"; private static final String VALUE2 = "v2"; private static final String NAME2 = "n2"; + public ListMapTest() { + } + @Test public void test() { final ListMap listMap = new ListMap(); - assertNull(listMap.getFirst(NAME1)); + Assert.assertNull(listMap.getFirst(NAME1)); listMap.add(NAME1, VALUE1); - assertNotNull(listMap.getFirst(NAME1)); - assertEquals(VALUE1, listMap.getFirst(NAME1)); + Assert.assertNotNull(listMap.getFirst(NAME1)); + Assert.assertEquals(VALUE1, listMap.getFirst(NAME1)); listMap.add(NAME1, VALUE2); - assertNotNull(listMap.getFirst(NAME1)); - assertEquals(VALUE1, listMap.getFirst(NAME1)); + Assert.assertNotNull(listMap.getFirst(NAME1)); + Assert.assertEquals(VALUE1, listMap.getFirst(NAME1)); - assertNotNull(listMap.get(NAME1)); - assertEquals(2, listMap.get(NAME1).size()); - assertTrue(listMap.get(NAME1).contains(VALUE2)); + Assert.assertNotNull(listMap.get(NAME1)); + Assert.assertEquals(2, listMap.get(NAME1).size()); + Assert.assertTrue(listMap.get(NAME1).contains(VALUE2)); - assertNotNull(listMap.get(NAME2)); - assertEquals(0, listMap.get(NAME2).size()); + Assert.assertNotNull(listMap.get(NAME2)); + Assert.assertEquals(0, listMap.get(NAME2).size()); listMap.add(NAME2, VALUE2); - assertNotNull(listMap.getFirst(NAME2)); + Assert.assertNotNull(listMap.getFirst(NAME2)); listMap.clearKey(NAME2); - assertNull(listMap.getFirst(NAME2)); - assertNotNull(listMap.getFirst(NAME1)); + Assert.assertNull(listMap.getFirst(NAME2)); + Assert.assertNotNull(listMap.getFirst(NAME1)); listMap.clearAllKeys(); - assertNull(listMap.getFirst(NAME1)); + Assert.assertNull(listMap.getFirst(NAME1)); } + } diff --git a/metafacture-commons/src/test/java/org/metafacture/commons/types/NamedValueTest.java b/metafacture-commons/src/test/java/org/metafacture/commons/types/NamedValueTest.java index fd405b747..bcde96ab0 100644 --- a/metafacture-commons/src/test/java/org/metafacture/commons/types/NamedValueTest.java +++ b/metafacture-commons/src/test/java/org/metafacture/commons/types/NamedValueTest.java @@ -19,13 +19,12 @@ import org.junit.Assert; import org.junit.Test; - /** * Tests for class {@link NamedValue}. * * @author Markus Michael Geipel */ -public final class NamedValueTest{ +public final class NamedValueTest { private static final String NAME = "name"; private static final String VALUE = "s234234ldkfj"; @@ -33,25 +32,25 @@ public final class NamedValueTest{ private static final String SMALL = "a"; private static final String BIG = "b"; - + public NamedValueTest() { + } @Test - public void testNamedValueCompare(){ + public void testNamedValueCompare() { final NamedValue namedValue1 = new NamedValue(SMALL, SMALL); final NamedValue namedValue2 = new NamedValue(SMALL, BIG); final NamedValue namedValue3 = new NamedValue(BIG, BIG); final NamedValue namedValue4 = new NamedValue(SMALL, SMALL); - Assert.assertTrue(namedValue1.compareTo(namedValue4)==0); + Assert.assertTrue(namedValue1.compareTo(namedValue4) == 0); - Assert.assertTrue(namedValue1.compareTo(namedValue2)==-1); - Assert.assertTrue(namedValue2.compareTo(namedValue1)==1); + Assert.assertTrue(namedValue1.compareTo(namedValue2) == -1); + Assert.assertTrue(namedValue2.compareTo(namedValue1) == 1); - Assert.assertTrue(namedValue2.compareTo(namedValue3)==-1); - Assert.assertTrue(namedValue3.compareTo(namedValue2)==1); + Assert.assertTrue(namedValue2.compareTo(namedValue3) == -1); + Assert.assertTrue(namedValue3.compareTo(namedValue2) == 1); - - Assert.assertTrue(namedValue1.compareTo(namedValue4)==0); + Assert.assertTrue(namedValue1.compareTo(namedValue4) == 0); } @Test @@ -72,4 +71,5 @@ public void testNamedValueEquals() { Assert.assertTrue(namedValue1.hashCode() == namedValue2.hashCode()); } + } diff --git a/metafacture-csv/src/test/java/org/metafacture/csv/CsvDecoderTest.java b/metafacture-csv/src/test/java/org/metafacture/csv/CsvDecoderTest.java index 4958775c3..e6402fd0c 100644 --- a/metafacture-csv/src/test/java/org/metafacture/csv/CsvDecoderTest.java +++ b/metafacture-csv/src/test/java/org/metafacture/csv/CsvDecoderTest.java @@ -16,14 +16,14 @@ package org.metafacture.csv; -import static org.mockito.Mockito.inOrder; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -39,6 +39,9 @@ public final class CsvDecoderTest { @Mock private StreamReceiver receiver; + public CsvDecoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -56,7 +59,7 @@ public void cleanup() { @Test public void testSimple() { decoder.process("a,b,c"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("h1", "a"); ordered.verify(receiver).literal("h2", "b"); @@ -67,7 +70,7 @@ public void testSimple() { @Test public void testQuoted() { decoder.process("a,\"b1,b2,b3\",c"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("h1", "a"); ordered.verify(receiver).literal("h2", "b1,b2,b3"); @@ -81,7 +84,7 @@ public void testTabSeparated() { decoder.setSeparator("\t"); decoder.process("a\tb\tc"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("h1", "a"); ordered.verify(receiver).literal("h2", "b"); @@ -97,7 +100,7 @@ public void testTabSeparated() { public void issue496_escaping() { decoder.setHasHeader(false); decoder.process("\"a\",\"b\t\",\"c\\t\",\"\\\",\"\\cd\\\""); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("0", "a"); ordered.verify(receiver).literal("1", "b\t"); diff --git a/metafacture-csv/src/test/java/org/metafacture/csv/CsvEncoderTest.java b/metafacture-csv/src/test/java/org/metafacture/csv/CsvEncoderTest.java index b37bb420b..e03d025a4 100644 --- a/metafacture-csv/src/test/java/org/metafacture/csv/CsvEncoderTest.java +++ b/metafacture-csv/src/test/java/org/metafacture/csv/CsvEncoderTest.java @@ -16,11 +16,10 @@ package org.metafacture.csv; -import org.junit.Rule; import org.metafacture.framework.ObjectReceiver; +import org.junit.Rule; import org.junit.Test; - import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.Mockito; @@ -40,8 +39,6 @@ */ public final class CsvEncoderTest { - @Mock - private ObjectReceiver receiver; private static final String LITERAL1 = "column 1"; private static final String LITERAL2 = "column 2"; private static final String RECORD_ID1 = "1"; @@ -57,6 +54,12 @@ public final class CsvEncoderTest { @Rule public MockitoRule rule = MockitoJUnit.rule(); + @Mock + private ObjectReceiver receiver; + + public CsvEncoderTest() { + } + @Test public void shouldReceiveSingleRecord() { assertEncode(i -> { diff --git a/metafacture-elasticsearch/src/test/java/org/metafacture/elasticsearch/JsonToElasticsearchBulkTest.java b/metafacture-elasticsearch/src/test/java/org/metafacture/elasticsearch/JsonToElasticsearchBulkTest.java index ae715271a..eed400d5c 100644 --- a/metafacture-elasticsearch/src/test/java/org/metafacture/elasticsearch/JsonToElasticsearchBulkTest.java +++ b/metafacture-elasticsearch/src/test/java/org/metafacture/elasticsearch/JsonToElasticsearchBulkTest.java @@ -16,14 +16,13 @@ package org.metafacture.elasticsearch; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -56,6 +55,9 @@ public final class JsonToElasticsearchBulkTest { @Mock private ObjectReceiver receiver; + public JsonToElasticsearchBulkTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -229,8 +231,8 @@ private void shouldExtractId(final String obj, final String idValue, final Strin final String metadata = String.format(METADATA, idValue != null ? ",'_id':" + idValue : ""); - verify(receiver).process(fixQuotes(metadata + "\n" + resultObj)); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(fixQuotes(metadata + "\n" + resultObj)); + Mockito.verifyNoMoreInteractions(receiver); } private void shouldExtractId(final String obj, final String idValue) { diff --git a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/CloseSuppressorTest.java b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/CloseSuppressorTest.java index f28c5b334..b77897005 100644 --- a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/CloseSuppressorTest.java +++ b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/CloseSuppressorTest.java @@ -16,9 +16,10 @@ package org.metafacture.flowcontrol; +import org.metafacture.framework.ObjectReceiver; + import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; @@ -38,6 +39,9 @@ public final class CloseSuppressorTest { @Mock private ObjectReceiver receiver; + public CloseSuppressorTest() { + } + @Test public void testSuppression() { final CloseSuppressor supressor = new CloseSuppressor<>(3); diff --git a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectBatchResetterTest.java b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectBatchResetterTest.java index e28ae2a52..cc629f135 100644 --- a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectBatchResetterTest.java +++ b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectBatchResetterTest.java @@ -16,17 +16,16 @@ package org.metafacture.flowcontrol; -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.ObjectReceiver; +import org.metafacture.framework.helpers.DefaultObjectReceiver; +import org.assertj.core.api.Assertions; import org.junit.Before; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; -import org.metafacture.framework.helpers.DefaultObjectReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -35,59 +34,63 @@ */ public class ObjectBatchResetterTest { + @Rule + public MockitoRule mockitoRule = MockitoJUnit.rule(); + + @Mock + private ObjectReceiver receiver; + private ObjectBatchResetter systemUnderTest; + public ObjectBatchResetterTest() { + } + @Before public void setupSystemUnderTest() { - systemUnderTest = new ObjectBatchResetter<>(); systemUnderTest.setReceiver(receiver); } @Test public void shouldEmitResetStreamAfterBatchSizeObjects() { - systemUnderTest.setBatchSize(3); systemUnderTest.process("1"); systemUnderTest.process("2"); systemUnderTest.process("3"); - InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process("1"); ordered.verify(receiver).process("2"); ordered.verify(receiver).process("3"); ordered.verify(receiver).resetStream(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test public void shouldIncreaseObjectCounterAfterEachObject() { - systemUnderTest.setBatchSize(3); systemUnderTest.process("1"); systemUnderTest.process("2"); - assertThat(systemUnderTest.getObjectCount()) + Assertions.assertThat(systemUnderTest.getObjectCount()) .isEqualTo(2); } @Test public void shouldResetObjectCountOnBatchCompletion() { - systemUnderTest.setBatchSize(2); systemUnderTest.process("1"); systemUnderTest.process("2"); - assertThat(systemUnderTest.getObjectCount()) + Assertions.assertThat(systemUnderTest.getObjectCount()) .isZero(); } @Test public void shouldIncreaseBatchCountAfterEachBatch() { - systemUnderTest.setBatchSize(2); systemUnderTest.process("1"); @@ -95,13 +98,12 @@ public void shouldIncreaseBatchCountAfterEachBatch() { systemUnderTest.process("3"); systemUnderTest.process("4"); - assertThat(systemUnderTest.getBatchCount()) + Assertions.assertThat(systemUnderTest.getBatchCount()) .isEqualTo(2); } @Test public void shouldResetCountsOnResetStream() { - systemUnderTest.setBatchSize(2); systemUnderTest.process("1"); @@ -109,21 +111,20 @@ public void shouldResetCountsOnResetStream() { systemUnderTest.process("3"); systemUnderTest.resetStream(); - assertThat(systemUnderTest.getBatchCount()) + Assertions.assertThat(systemUnderTest.getBatchCount()) .isZero(); - assertThat(systemUnderTest.getObjectCount()) + Assertions.assertThat(systemUnderTest.getObjectCount()) .isZero(); } @Test public void shouldEmitResetStreamEventAfterUpdatingCounts() { - systemUnderTest.setBatchSize(2); systemUnderTest.setReceiver(new DefaultObjectReceiver() { @Override public void resetStream() { - assertThat(systemUnderTest.getObjectCount()).isZero(); - assertThat(systemUnderTest.getBatchCount()).isEqualTo(1); + Assertions.assertThat(systemUnderTest.getObjectCount()).isZero(); + Assertions.assertThat(systemUnderTest.getBatchCount()).isEqualTo(1); } }); @@ -131,10 +132,4 @@ public void resetStream() { systemUnderTest.process("2"); } - @Rule - public MockitoRule mockitoRule = MockitoJUnit.rule(); - - @Mock - private ObjectReceiver receiver; - } diff --git a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectExceptionCatcherTest.java b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectExceptionCatcherTest.java index 3dd3681a8..57c7ee6c3 100644 --- a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectExceptionCatcherTest.java +++ b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectExceptionCatcherTest.java @@ -16,13 +16,13 @@ package org.metafacture.flowcontrol; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.Mockito.doThrow; +import org.metafacture.framework.ObjectReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; +import org.mockito.ArgumentMatchers; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -38,11 +38,14 @@ public final class ObjectExceptionCatcherTest { private ObjectExceptionCatcher exceptionCatcher; + public ObjectExceptionCatcherTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); - doThrow(new TestException("Exception Message")) - .when(exceptionThrowingModule).process(anyString()); + Mockito.doThrow(new TestException("Exception Message")) + .when(exceptionThrowingModule).process(ArgumentMatchers.anyString()); exceptionCatcher = new ObjectExceptionCatcher<>(); exceptionCatcher.setReceiver(exceptionThrowingModule); exceptionCatcher.setLogExceptionMessage(false); diff --git a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectSleeperTest.java b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectSleeperTest.java index ab87ee68e..ad0fbdbd1 100644 --- a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectSleeperTest.java +++ b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectSleeperTest.java @@ -41,6 +41,9 @@ public final class ObjectSleeperTest { @Mock private ObjectReceiver receiver; + public ObjectSleeperTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); diff --git a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectThreaderTest.java b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectThreaderTest.java index fc7c32b4f..ec24bcd3b 100644 --- a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectThreaderTest.java +++ b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/ObjectThreaderTest.java @@ -16,18 +16,13 @@ package org.metafacture.flowcontrol; -import static org.assertj.core.api.Assertions.assertThat; - -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.atMost; -import static org.mockito.Mockito.atLeast; +import org.metafacture.framework.ObjectReceiver; +import org.assertj.core.api.Assertions; import org.junit.Before; import org.junit.Test; -import org.metafacture.flowcontrol.ObjectThreader; -import org.metafacture.framework.ObjectReceiver; - import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -39,13 +34,17 @@ */ public final class ObjectThreaderTest { + private static final int ACTIVE_THREADS_AT_BEGINNING = Thread.getAllStackTraces().keySet().size(); + @Mock private ObjectReceiver receiverThread1; @Mock private ObjectReceiver receiverThread2; private final ObjectThreader objectThreader = new ObjectThreader<>(); - private static final int ACTIVE_THREADS_AT_BEGINNING = Thread.getAllStackTraces().keySet().size(); + + public ObjectThreaderTest() { + } @Before public void setup() { @@ -62,16 +61,16 @@ public void shouldSplitAllObjectsToAllThreadedDownStreamReceivers() throws Inter objectThreader.process("a"); objectThreader.process("c"); // check if two more threads were indeed created - assertThat(Thread.getAllStackTraces().keySet().size() - ACTIVE_THREADS_AT_BEGINNING).isEqualTo(2); + Assertions.assertThat(Thread.getAllStackTraces().keySet().size() - ACTIVE_THREADS_AT_BEGINNING).isEqualTo(2); objectThreader.closeStream(); // verify thread 1 - verify(receiverThread1, atLeast(2)).process("a"); - verify(receiverThread1, atMost(0)).process("b"); - verify(receiverThread1, atMost(0)).process("c"); + Mockito.verify(receiverThread1, Mockito.atLeast(2)).process("a"); + Mockito.verify(receiverThread1, Mockito.atMost(0)).process("b"); + Mockito.verify(receiverThread1, Mockito.atMost(0)).process("c"); // verify thread 2 - verify(receiverThread2, atMost(0)).process("a"); - verify(receiverThread2, atLeast(1)).process("b"); - verify(receiverThread2, atLeast(1)).process("c"); + Mockito.verify(receiverThread2, Mockito.atMost(0)).process("a"); + Mockito.verify(receiverThread2, Mockito.atLeast(1)).process("b"); + Mockito.verify(receiverThread2, Mockito.atLeast(1)).process("c"); } } diff --git a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/StreamBufferTest.java b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/StreamBufferTest.java index 4473c99f1..cc878b420 100644 --- a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/StreamBufferTest.java +++ b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/StreamBufferTest.java @@ -16,19 +16,15 @@ package org.metafacture.flowcontrol; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.mockito.Mockito.verifyZeroInteractions; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link StreamBuffer}. * @@ -43,6 +39,9 @@ public final class StreamBufferTest { private StreamBuffer streamBuffer; + public StreamBufferTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -58,11 +57,11 @@ public void shouldReplayRecordEvents() { streamBuffer.endEntity(); streamBuffer.endRecord(); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); streamBuffer.replay(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("l", "v"); ordered.verify(receiver).startEntity("e"); @@ -78,7 +77,7 @@ public void shouldReplayBufferMultipleTimes() { streamBuffer.replay(); streamBuffer.replay(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).endRecord(); ordered.verify(receiver).startRecord("1"); @@ -93,7 +92,7 @@ public void shouldClearBufferIfClearIsCalled() { streamBuffer.clear(); streamBuffer.replay(); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } @Test @@ -104,8 +103,8 @@ public void shouldClearBufferIfStreamIsReset() { streamBuffer.resetStream(); streamBuffer.replay(); - verify(receiver).resetStream(); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).resetStream(); + Mockito.verifyNoMoreInteractions(receiver); } } diff --git a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/StreamDeferrerTest.java b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/StreamDeferrerTest.java index ee5e27045..272834449 100644 --- a/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/StreamDeferrerTest.java +++ b/metafacture-flowcontrol/src/test/java/org/metafacture/flowcontrol/StreamDeferrerTest.java @@ -16,15 +16,13 @@ package org.metafacture.flowcontrol; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.verifyZeroInteractions; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -40,6 +38,9 @@ public class StreamDeferrerTest { private StreamDeferrer streamDeferrer; + public StreamDeferrerTest() { + } + @Before public void init() { MockitoAnnotations.initMocks(this); @@ -54,11 +55,11 @@ public void shouldDeferStreamEventsUntilEndRecordIsReceived() { streamDeferrer.startEntity("e"); streamDeferrer.endEntity(); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); streamDeferrer.endRecord(); - InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("l", "v"); ordered.verify(receiver).startEntity("e"); @@ -74,9 +75,9 @@ public void shouldDiscardDeferredEventsIfAnotherStartRecordIsReceived() { streamDeferrer.literal("l2", "v2"); streamDeferrer.endRecord(); - InOrder ordered = inOrder(receiver); - ordered.verify(receiver, never()).startRecord("1"); - ordered.verify(receiver, never()).literal("l1", "v1"); + final InOrder ordered = Mockito.inOrder(receiver); + ordered.verify(receiver, Mockito.never()).startRecord("1"); + ordered.verify(receiver, Mockito.never()).literal("l1", "v1"); ordered.verify(receiver).startRecord("2"); ordered.verify(receiver).literal("l2", "v2"); ordered.verify(receiver).endRecord(); @@ -89,9 +90,9 @@ public void shouldDiscardDeferredEventsOnResetStream() { streamDeferrer.resetStream(); streamDeferrer.endRecord(); - InOrder ordered = inOrder(receiver); - ordered.verify(receiver, never()).startRecord("1"); - ordered.verify(receiver, never()).literal("l", "v"); + final InOrder ordered = Mockito.inOrder(receiver); + ordered.verify(receiver, Mockito.never()).startRecord("1"); + ordered.verify(receiver, Mockito.never()).literal("l", "v"); ordered.verify(receiver).endRecord(); } diff --git a/metafacture-flux/src/test/java/org/metafacture/flux/FluxGrammarTest.java b/metafacture-flux/src/test/java/org/metafacture/flux/FluxGrammarTest.java index 58713cf1a..fdf84f81b 100644 --- a/metafacture-flux/src/test/java/org/metafacture/flux/FluxGrammarTest.java +++ b/metafacture-flux/src/test/java/org/metafacture/flux/FluxGrammarTest.java @@ -16,20 +16,20 @@ package org.metafacture.flux; -import static java.util.Collections.emptyMap; -import static org.junit.Assert.assertEquals; +import org.metafacture.commons.reflection.ReflectionException; +import org.metafacture.flux.parser.FluxProgramm; + +import org.antlr.runtime.RecognitionException; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.PrintStream; import java.nio.charset.StandardCharsets; - -import org.antlr.runtime.RecognitionException; -import org.junit.Before; -import org.junit.Test; -import org.metafacture.commons.reflection.ReflectionException; -import org.metafacture.flux.parser.FluxProgramm; +import java.util.Collections; /** * Tests for the Flux grammar. @@ -41,6 +41,9 @@ public final class FluxGrammarTest { private ByteArrayOutputStream stdoutBuffer; private ByteArrayOutputStream stderrBuffer; + public FluxGrammarTest() { + } + @Before public void setup() { // Redirect standard out: @@ -57,10 +60,10 @@ public void shouldAllowEmptyCommentInLastLineOfFile() throws RecognitionException, IOException { final String script = "\"test\"|print; //"; - FluxCompiler.compile(createInputStream(script), emptyMap()); + FluxCompiler.compile(createInputStream(script), Collections.emptyMap()); - assertEquals("", stderrBuffer.toString()); - assertEquals("", stdoutBuffer.toString()); + Assert.assertEquals("", stderrBuffer.toString()); + Assert.assertEquals("", stdoutBuffer.toString()); } @Test @@ -68,10 +71,10 @@ public void shouldAllowEmptyCommentInFile() throws RecognitionException, IOException { final String script = "\"test\"|print; //\n"; - FluxCompiler.compile(createInputStream(script), emptyMap()); + FluxCompiler.compile(createInputStream(script), Collections.emptyMap()); - assertEquals("", stderrBuffer.toString()); - assertEquals("", stdoutBuffer.toString()); + Assert.assertEquals("", stderrBuffer.toString()); + Assert.assertEquals("", stdoutBuffer.toString()); } @Test @@ -82,11 +85,11 @@ public void shouldReplaceJavaEscapeSequences() "|print;"; final FluxProgramm program = FluxCompiler.compile( - createInputStream(script), emptyMap()); + createInputStream(script), Collections.emptyMap()); program.start(); - assertEquals("", stderrBuffer.toString()); - assertEquals("quot=\" octal1=\7 octal2=0 octal3=C unicode=\u00f8 tab=[\t]\n", + Assert.assertEquals("", stderrBuffer.toString()); + Assert.assertEquals("quot=\" octal1=\7 octal2=0 octal3=C unicode=\u00f8 tab=[\t]\n", stdoutBuffer.toString()); } @@ -95,10 +98,11 @@ public void issue421_shouldThrowFluxParseExceptionWhenSemicolonInFlowIsMissing() throws RecognitionException, IOException { final String script = "\"test\"|print"; try { - FluxCompiler.compile(createInputStream(script), emptyMap()); - } catch (FluxParseException fpe) { - assertEquals("mismatched input '' expecting ';' in Flux", fpe.getMessage()); - throw fpe; + FluxCompiler.compile(createInputStream(script), Collections.emptyMap()); + } + catch (final FluxParseException e) { + Assert.assertEquals("mismatched input '' expecting ';' in Flux", e.getMessage()); + throw e; } } @@ -107,10 +111,11 @@ public void issue421_shouldThrowFluxParseExceptionWhenSemicolonInVarDefIsMissing throws RecognitionException, IOException { final String script = "foo=42"; try { - FluxCompiler.compile(createInputStream(script), emptyMap()); - } catch (FluxParseException re) { - assertEquals("mismatched input '' expecting ';' in Flux", re.getMessage()); - throw re; + FluxCompiler.compile(createInputStream(script), Collections.emptyMap()); + } + catch (final FluxParseException e) { + Assert.assertEquals("mismatched input '' expecting ';' in Flux", e.getMessage()); + throw e; } } @@ -119,10 +124,11 @@ public void issue421_shouldThrowReflectionExceptionWhenCommandIsNotFound() throws RecognitionException, IOException { final String script = "\"test\"|prin;"; try { - FluxCompiler.compile(createInputStream(script), emptyMap()); - } catch (ReflectionException re) { - assertEquals("Class not found: prin", re.getMessage()); - throw re; + FluxCompiler.compile(createInputStream(script), Collections.emptyMap()); + } + catch (final ReflectionException e) { + Assert.assertEquals("Class not found: prin", e.getMessage()); + throw e; } } @@ -131,10 +137,11 @@ public void issue421_shouldThrowFluxParseExceptionWhenInputIsMissingAfterPipe1() throws RecognitionException, IOException { final String script = "\"test\"|"; try { - FluxCompiler.compile(createInputStream(script), emptyMap()); - } catch (FluxParseException re) { - assertEquals("no viable alternative at input '' in Flux", re.getMessage()); - throw re; + FluxCompiler.compile(createInputStream(script), Collections.emptyMap()); + } + catch (final FluxParseException e) { + Assert.assertEquals("no viable alternative at input '' in Flux", e.getMessage()); + throw e; } } @@ -143,10 +150,11 @@ public void issue421_shouldThrowFluxParseExceptionWhenInputIsMissingAfterPipe2() throws RecognitionException, IOException { final String script = "\"test\"|;"; try { - FluxCompiler.compile(createInputStream(script), emptyMap()); - } catch (FluxParseException re) { - assertEquals("no viable alternative at input ';' in Flux", re.getMessage()); - throw re; + FluxCompiler.compile(createInputStream(script), Collections.emptyMap()); + } + catch (final FluxParseException e) { + Assert.assertEquals("no viable alternative at input ';' in Flux", e.getMessage()); + throw e; } } @@ -155,10 +163,11 @@ public void issue421_shouldThrowFluxParseExceptionWhenTeeStructureOccursWithouAT throws RecognitionException, IOException { final String script = "\"test\"|{print}{print} ;"; try { - FluxCompiler.compile(createInputStream(script), emptyMap()); - } catch (FluxParseException re) { - assertEquals("Flow cannot be split without a tee-element.", re.getMessage()); - throw re; + FluxCompiler.compile(createInputStream(script), Collections.emptyMap()); + } + catch (final FluxParseException e) { + Assert.assertEquals("Flow cannot be split without a tee-element.", e.getMessage()); + throw e; } } @@ -167,10 +176,11 @@ public void issue421_shouldThrowFluxParseExceptionWhenTeeIsNotASender() throws RecognitionException, IOException { final String script = "\"test\"|print|object-tee|{print}{print} ;"; try { - FluxCompiler.compile(createInputStream(script), emptyMap()); - } catch (FluxParseException re) { - assertEquals("org.metafacture.io.ObjectStdoutWriter is not a sender", re.getMessage()); - throw re; + FluxCompiler.compile(createInputStream(script), Collections.emptyMap()); + } + catch (final FluxParseException e) { + Assert.assertEquals("org.metafacture.io.ObjectStdoutWriter is not a sender", e.getMessage()); + throw e; } } @@ -179,15 +189,16 @@ public void issue421_shouldInsertMissingSymbolsWhenTeeIsStructurallyInvalid() throws RecognitionException, IOException { final String script = "\"test\"|object-tee|{object-tee{print{print} ;"; try { - FluxCompiler.compile(createInputStream(script), emptyMap()); - String tmp=stdoutBuffer.toString(); - } catch (FluxParseException re) { - assertEquals("missing '}' at '{' in Flux", re.getMessage()); - throw re; + FluxCompiler.compile(createInputStream(script), Collections.emptyMap()); + final String tmp = stdoutBuffer.toString(); + } + catch (final FluxParseException e) { + Assert.assertEquals("missing '}' at '{' in Flux", e.getMessage()); + throw e; } } - private ByteArrayInputStream createInputStream(String script) { + private ByteArrayInputStream createInputStream(final String script) { return new ByteArrayInputStream(script.getBytes(StandardCharsets.UTF_8)); } diff --git a/metafacture-flux/src/test/java/org/metafacture/flux/FluxProgrammTest.java b/metafacture-flux/src/test/java/org/metafacture/flux/FluxProgrammTest.java index 703f694c8..38df30db0 100644 --- a/metafacture-flux/src/test/java/org/metafacture/flux/FluxProgrammTest.java +++ b/metafacture-flux/src/test/java/org/metafacture/flux/FluxProgrammTest.java @@ -16,9 +16,10 @@ package org.metafacture.flux; -import org.junit.Test; import org.metafacture.flux.parser.FluxProgramm; +import org.junit.Test; + import java.io.IOException; import java.io.OutputStream; import java.io.PrintStream; @@ -29,20 +30,21 @@ * @author markus geipel * */ - public final class FluxProgrammTest { + public FluxProgrammTest() { + } + @Test public void testCommandRegistration() throws IOException { // all commands must properly load to print the help FluxProgramm.printHelp(discardOutput()); - } private PrintStream discardOutput() { return new PrintStream(new OutputStream() { @Override - public void write(int b) throws IOException { + public void write(final int b) throws IOException { // Do not write any output. } }); diff --git a/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaDecoderTest.java b/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaDecoderTest.java index 462ac4822..c233ed4ac 100644 --- a/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaDecoderTest.java +++ b/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaDecoderTest.java @@ -16,17 +16,16 @@ package org.metafacture.formeta; -import static org.mockito.Mockito.inOrder; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link FormetaDecoder}. * @@ -43,6 +42,9 @@ public final class FormetaDecoderTest { @Mock private StreamReceiver receiver; + public FormetaDecoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -59,7 +61,7 @@ public void cleanup() { public void testShouldProcessRecords() { decoder.process(RECORD); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("lit1", "value 1"); ordered.verify(receiver).startEntity(" ent1"); diff --git a/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaEncoderTest.java b/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaEncoderTest.java index 5d2872243..8bc01eb56 100644 --- a/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaEncoderTest.java +++ b/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaEncoderTest.java @@ -16,18 +16,16 @@ package org.metafacture.formeta; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.formeta.formatter.FormatterStyle; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.formeta.formatter.FormatterStyle; -import org.metafacture.framework.ObjectReceiver; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link FormetaEncoder}. * @@ -52,11 +50,14 @@ public final class FormetaEncoderTest { "\t'lit4': 'value \\'3\\''\n" + "}"; - private FormetaEncoder encoder; - @Mock private ObjectReceiver receiver; + private FormetaEncoder encoder; + + public FormetaEncoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -75,7 +76,7 @@ public void testShouldOutputConciseRecordRepresentation() { executeEvents(); - verify(receiver).process(CONCISE_RECORD); + Mockito.verify(receiver).process(CONCISE_RECORD); } @Test @@ -84,7 +85,7 @@ public void testShouldOutputVerboseRecordRepresentation() { executeEvents(); - verify(receiver).process(VERBOSE_RECORD); + Mockito.verify(receiver).process(VERBOSE_RECORD); } @Test @@ -93,7 +94,7 @@ public void testShouldOutputMultilineRecordRepresentation() { executeEvents(); - verify(receiver).process(MULTILINE_RECORD); + Mockito.verify(receiver).process(MULTILINE_RECORD); } @Test @@ -105,8 +106,8 @@ public void testShouldIgnoreIncompleteRecord() { encoder.startEntity("entity"); executeEvents(); - verify(receiver).process(CONCISE_RECORD); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(CONCISE_RECORD); + Mockito.verifyNoMoreInteractions(receiver); } private void executeEvents() { diff --git a/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaRecordsReaderTest.java b/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaRecordsReaderTest.java index ba8b9f2c0..41eaed9b4 100644 --- a/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaRecordsReaderTest.java +++ b/metafacture-formeta/src/test/java/org/metafacture/formeta/FormetaRecordsReaderTest.java @@ -16,25 +16,24 @@ package org.metafacture.formeta; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; - -import java.io.StringReader; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.io.StringReader; + /** * Tests for class {@link FormetaRecordsReader}. * * @author Christoph Böhme * */ -public final class FormetaRecordsReaderTest { +public final class FormetaRecordsReaderTest { private static final String SINGLE_RECORD = "l: v"; @@ -57,6 +56,9 @@ public final class FormetaRecordsReaderTest { @Mock private ObjectReceiver receiver; + public FormetaRecordsReaderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -75,8 +77,8 @@ public void shouldProcessSingleRecord() { formetaRecordsReader.process(reader); - verify(receiver).process(SINGLE_RECORD); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(SINGLE_RECORD); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -99,19 +101,19 @@ public void shouldSplitBetweenTopLevelElements() { formetaRecordsReader.process(reader); - verify(receiver).process(RECORD_LITERAL); - verify(receiver).process(RECORD_GROUP); - verify(receiver).process(RECORD_NESTED_GROUP); - verify(receiver).process(RECORD_QUOTED_LITERAL); - verify(receiver).process(RECORD_LEFT_BRACE_IN_QUOTES); - verify(receiver).process(RECORD_RIGHT_BRACE_IN_QUOTES); - verify(receiver).process(RECORD_COLON_IN_QUOTES); - verify(receiver).process(RECORD_COMMA_IN_QUOTES); - verify(receiver).process(RECORD_ESCAPED_LEFT_BRACE); - verify(receiver).process(RECORD_ESCAPED_RIGHT_BRACE); - verify(receiver).process(RECORD_ESCAPED_COLON); - verify(receiver).process(RECORD_ESCAPED_COMMA); - verify(receiver).process(RECORD_ESCAPED_QUOTE); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(RECORD_LITERAL); + Mockito.verify(receiver).process(RECORD_GROUP); + Mockito.verify(receiver).process(RECORD_NESTED_GROUP); + Mockito.verify(receiver).process(RECORD_QUOTED_LITERAL); + Mockito.verify(receiver).process(RECORD_LEFT_BRACE_IN_QUOTES); + Mockito.verify(receiver).process(RECORD_RIGHT_BRACE_IN_QUOTES); + Mockito.verify(receiver).process(RECORD_COLON_IN_QUOTES); + Mockito.verify(receiver).process(RECORD_COMMA_IN_QUOTES); + Mockito.verify(receiver).process(RECORD_ESCAPED_LEFT_BRACE); + Mockito.verify(receiver).process(RECORD_ESCAPED_RIGHT_BRACE); + Mockito.verify(receiver).process(RECORD_ESCAPED_COLON); + Mockito.verify(receiver).process(RECORD_ESCAPED_COMMA); + Mockito.verify(receiver).process(RECORD_ESCAPED_QUOTE); + Mockito.verifyNoMoreInteractions(receiver); } } diff --git a/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/AbstactFormatterTest.java b/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/AbstractFormatterTest.java similarity index 81% rename from metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/AbstactFormatterTest.java rename to metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/AbstractFormatterTest.java index b2d5ac98b..663a99328 100644 --- a/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/AbstactFormatterTest.java +++ b/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/AbstractFormatterTest.java @@ -16,11 +16,11 @@ package org.metafacture.formeta.formatter; -import static org.junit.Assert.assertEquals; +import org.metafacture.commons.StringUtil; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; -import org.metafacture.commons.StringUtil; /** * Tests for class {@link AbstractFormatter}. @@ -28,23 +28,29 @@ * @author Christoph Böhme * */ -public final class AbstactFormatterTest { +public final class AbstractFormatterTest { // checkstyle-disable-line AbstractClassName private AbstractFormatter abstractFormatter; + public AbstractFormatterTest() { + } + @Before public void setup() { abstractFormatter = new AbstractFormatter() { @Override - public void startGroup(final String name) {} + public void startGroup(final String name) { + } @Override - public void endGroup() {} + public void endGroup() { + } @Override public void literal(final String name, final String value) { } + @Override protected boolean shouldQuoteText(final char[] buffer, final int len) { return false; @@ -58,7 +64,7 @@ public void issue161() { abstractFormatter.escapeAndAppend(longValue); - assertEquals(longValue, abstractFormatter.toString()); + Assert.assertEquals(longValue, abstractFormatter.toString()); } } diff --git a/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/ConciseFormatterTest.java b/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/ConciseFormatterTest.java index cc5537d0b..c2d4cff6e 100644 --- a/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/ConciseFormatterTest.java +++ b/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/ConciseFormatterTest.java @@ -16,8 +16,7 @@ package org.metafacture.formeta.formatter; -import static org.junit.Assert.assertEquals; - +import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -43,6 +42,9 @@ public final class ConciseFormatterTest { private ConciseFormatter conciseFormatter; + public ConciseFormatterTest() { + } + @Before public void setup() { conciseFormatter = new ConciseFormatter(); @@ -59,7 +61,7 @@ public void testShouldBuildRecordRepresentation() { conciseFormatter.literal("lit4", "value '3'"); conciseFormatter.endGroup(); - assertEquals(CONCISE_RECORD, conciseFormatter.toString()); + Assert.assertEquals(CONCISE_RECORD, conciseFormatter.toString()); } @Test @@ -69,7 +71,7 @@ public void testShouldCorrectlyEscapeNestedRecords() { conciseFormatter.literal("note", "nested records"); conciseFormatter.endGroup(); - assertEquals(OUTER_RECORD, conciseFormatter.toString()); + Assert.assertEquals(OUTER_RECORD, conciseFormatter.toString()); } } diff --git a/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/MultilineFormatterTest.java b/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/MultilineFormatterTest.java index 2252cff8e..f76d45461 100644 --- a/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/MultilineFormatterTest.java +++ b/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/MultilineFormatterTest.java @@ -16,8 +16,7 @@ package org.metafacture.formeta.formatter; -import static org.junit.Assert.assertEquals; - +import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -50,6 +49,9 @@ public final class MultilineFormatterTest { private MultilineFormatter multilineFormatter; + public MultilineFormatterTest() { + } + @Before public void setup() { multilineFormatter = new MultilineFormatter(); @@ -66,7 +68,7 @@ public void testShouldBuildRecordRepresentation() { multilineFormatter.literal("lit4", "value '3'"); multilineFormatter.endGroup(); - assertEquals(MULTILINE_RECORD, multilineFormatter.toString()); + Assert.assertEquals(MULTILINE_RECORD, multilineFormatter.toString()); } @Test @@ -76,7 +78,7 @@ public void testShouldCorrectlyEscapeNestedRecords() { multilineFormatter.literal("note", "nested records"); multilineFormatter.endGroup(); - assertEquals(OUTER_RECORD, multilineFormatter.toString()); + Assert.assertEquals(OUTER_RECORD, multilineFormatter.toString()); } } diff --git a/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/VerboseFormatterTest.java b/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/VerboseFormatterTest.java index abc5a5ce7..11ddfe3de 100644 --- a/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/VerboseFormatterTest.java +++ b/metafacture-formeta/src/test/java/org/metafacture/formeta/formatter/VerboseFormatterTest.java @@ -16,8 +16,7 @@ package org.metafacture.formeta.formatter; -import static org.junit.Assert.assertEquals; - +import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -43,6 +42,9 @@ public final class VerboseFormatterTest { private VerboseFormatter verboseFormatter; + public VerboseFormatterTest() { + } + @Before public void setup() { verboseFormatter = new VerboseFormatter(); @@ -59,7 +61,7 @@ public void testShouldBuildRecordRepresentation() { verboseFormatter.literal("lit4", "value '3'"); verboseFormatter.endGroup(); - assertEquals(VERBOSE_RECORD, verboseFormatter.toString()); + Assert.assertEquals(VERBOSE_RECORD, verboseFormatter.toString()); } @Test @@ -69,7 +71,7 @@ public void testShouldCorrectlyEscapeNestedRecords() { verboseFormatter.literal("note", "nested records"); verboseFormatter.endGroup(); - assertEquals(OUTER_RECORD, verboseFormatter.toString()); + Assert.assertEquals(OUTER_RECORD, verboseFormatter.toString()); } } diff --git a/metafacture-formeta/src/test/java/org/metafacture/formeta/parser/FormetaParserTest.java b/metafacture-formeta/src/test/java/org/metafacture/formeta/parser/FormetaParserTest.java index 290b5ca09..3eb9eab45 100644 --- a/metafacture-formeta/src/test/java/org/metafacture/formeta/parser/FormetaParserTest.java +++ b/metafacture-formeta/src/test/java/org/metafacture/formeta/parser/FormetaParserTest.java @@ -16,17 +16,16 @@ package org.metafacture.formeta.parser; -import static org.mockito.Mockito.inOrder; +import org.metafacture.formeta.FormetaDecoder; +import org.metafacture.framework.FormatException; import org.junit.Before; import org.junit.Test; -import org.metafacture.formeta.FormetaDecoder; -import org.metafacture.framework.FormatException; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for {@link FormetaDecoder}. * @@ -74,6 +73,9 @@ public final class FormetaParserTest { @Mock private Emitter emitter; + public FormetaParserTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -85,7 +87,7 @@ public void setup() { public void testShouldParseConciselyFormattedRecords() { parser.parse(CONCISE_RECORD); - final InOrder ordered = inOrder(emitter); + final InOrder ordered = Mockito.inOrder(emitter); verifyRecord(ordered); } @@ -93,7 +95,7 @@ public void testShouldParseConciselyFormattedRecords() { public void testShouldParseVerboselyFormattedRecords() { parser.parse(VERBOSE_RECORD); - final InOrder ordered = inOrder(emitter); + final InOrder ordered = Mockito.inOrder(emitter); verifyRecord(ordered); } @@ -101,7 +103,7 @@ public void testShouldParseVerboselyFormattedRecords() { public void testShouldParseMultilineFormattedRecords() { parser.parse(MULTILINE_RECORD); - final InOrder ordered = inOrder(emitter); + final InOrder ordered = Mockito.inOrder(emitter); verifyRecord(ordered); } @@ -109,16 +111,16 @@ public void testShouldParseMultilineFormattedRecords() { public void testShouldIgnoreItemSeparatorAfterRecord() { parser.parse(CONCISE_RECORD + ", "); - final InOrder ordered = inOrder(emitter); + final InOrder ordered = Mockito.inOrder(emitter); verifyRecord(ordered); } - @Test(expected=FormatException.class) + @Test(expected = FormatException.class) public void testShouldFailOnDoubleCloseRecord() { parser.parse("1 { lit: val }}"); } - @Test(expected=FormatException.class) + @Test(expected = FormatException.class) public void testShouldFailOnGarbageAfterRecord() { parser.parse(CONCISE_RECORD + "Garbage"); } @@ -127,12 +129,12 @@ public void testShouldFailOnGarbageAfterRecord() { public void testShouldParseInputsContainingMoreThanOneRecord() { parser.parse(CONCISE_RECORD + CONCISE_RECORD); - final InOrder ordered = inOrder(emitter); + final InOrder ordered = Mockito.inOrder(emitter); verifyRecord(ordered); verifyRecord(ordered); } - @Test(expected=FormatException.class) + @Test(expected = FormatException.class) public void testShouldFailOnIncompleteRecords() { parser.parse(BROKEN_RECORD); } @@ -143,7 +145,7 @@ public void testShouldRecoverAfterIncompleteRecord() { try { parser.parse(BROKEN_RECORD); } - catch (FormatException e) { + catch (final FormatException e) { // The decoder should recover automatically } @@ -151,7 +153,7 @@ public void testShouldRecoverAfterIncompleteRecord() { // afterwards: parser.parse(CONCISE_RECORD); - final InOrder ordered = inOrder(emitter); + final InOrder ordered = Mockito.inOrder(emitter); verifyRecord(ordered); } @@ -159,7 +161,7 @@ public void testShouldRecoverAfterIncompleteRecord() { public void testShouldParseInputContainingNestedRecords() { parser.parse(OUTER_RECORD); - final InOrder ordered = inOrder(emitter); + final InOrder ordered = Mockito.inOrder(emitter); ordered.verify(emitter).startGroup("outer", 0); ordered.verify(emitter).literal("nested", INNER_RECORD, 1); ordered.verify(emitter).literal("note", "I can has nezted records", 1); @@ -170,11 +172,11 @@ public void testShouldParseInputContainingNestedRecords() { public void testPartialRecord() { parser.parse(PARTIAL_RECORD); - final InOrder ordered = inOrder(emitter); + final InOrder ordered = Mockito.inOrder(emitter); verifyRecordContents(ordered, 0); } - @Test(expected=FormatException.class) + @Test(expected = FormatException.class) public void testIncompletePartialRecord() { parser.parse(BROKEN_PARTIAL_RECORD); } diff --git a/metafacture-framework/src/test/java/org/metafacture/framework/helpers/DefaultSenderTest.java b/metafacture-framework/src/test/java/org/metafacture/framework/helpers/DefaultSenderTest.java index 2645e7032..894c87a66 100644 --- a/metafacture-framework/src/test/java/org/metafacture/framework/helpers/DefaultSenderTest.java +++ b/metafacture-framework/src/test/java/org/metafacture/framework/helpers/DefaultSenderTest.java @@ -16,15 +16,11 @@ package org.metafacture.framework.helpers; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; +import org.metafacture.framework.StreamReceiver; +import org.junit.Assert; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; +import org.mockito.Mockito; /** * Tests for class {@link DefaultSender}. @@ -35,23 +31,26 @@ */ public final class DefaultSenderTest { + public DefaultSenderTest() { + } + @Test public void shouldCallOnCloseStreamOnlyOnce() { final DefaultSender defaultSender = - spy(new DefaultSender<>()); + Mockito.spy(new DefaultSender<>()); - verify(defaultSender, never()).onCloseStream(); - assertFalse(defaultSender.isClosed()); + Mockito.verify(defaultSender, Mockito.never()).onCloseStream(); + Assert.assertFalse(defaultSender.isClosed()); defaultSender.closeStream(); - verify(defaultSender, times(1)).onCloseStream(); - assertTrue(defaultSender.isClosed()); + Mockito.verify(defaultSender, Mockito.times(1)).onCloseStream(); + Assert.assertTrue(defaultSender.isClosed()); defaultSender.closeStream(); - verify(defaultSender, times(1)).onCloseStream(); - assertTrue(defaultSender.isClosed()); + Mockito.verify(defaultSender, Mockito.times(1)).onCloseStream(); + Assert.assertTrue(defaultSender.isClosed()); } } diff --git a/metafacture-html/src/test/java/org/metafacture/html/ElementExtractorTest.java b/metafacture-html/src/test/java/org/metafacture/html/ElementExtractorTest.java index b8fb665c4..bfae4b871 100644 --- a/metafacture-html/src/test/java/org/metafacture/html/ElementExtractorTest.java +++ b/metafacture-html/src/test/java/org/metafacture/html/ElementExtractorTest.java @@ -16,18 +16,17 @@ package org.metafacture.html; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; - -import java.io.StringReader; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.io.StringReader; + /** * Tests for {@link ElementExtractor}. * @@ -36,17 +35,20 @@ */ public final class ElementExtractorTest { - private static final StringReader IN = new StringReader("" - + "" - + "" + + "")); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startEntity("script"); ordered.verify(receiver).literal("type", "application/ld+json"); ordered.verify(receiver).literal("value", "{\"id\":\"theId\"}"); // elements above plus body, html - ordered.verify(receiver, times(4)).endEntity(); + ordered.verify(receiver, Mockito.times(4)).endEntity(); } @Test public void htmlAttributesAsSubfieldsDefault() { htmlDecoder.process(new StringReader("")); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startEntity("meta"); ordered.verify(receiver).literal("language", "DE"); ordered.verify(receiver).literal("name", "language"); ordered.verify(receiver).literal("content", "DE"); - ordered.verify(receiver, times(4)).endEntity(); + ordered.verify(receiver, Mockito.times(4)).endEntity(); } @Test public void htmlAttributesAsSubfieldsCustom() { htmlDecoder.setAttrValsAsSubfields("mods:url.access"); htmlDecoder.process(new StringReader("file:///img.png")); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startEntity("mods:url"); ordered.verify(receiver).literal("preview", "file:///img.png"); - ordered.verify(receiver, never()).literal("value", "file:///img.png"); - ordered.verify(receiver, times(3)).endEntity(); + ordered.verify(receiver, Mockito.never()).literal("value", "file:///img.png"); + ordered.verify(receiver, Mockito.times(3)).endEntity(); } @Test public void htmlAttributesAsSubfieldsDefaultPlusCustom() { htmlDecoder.setAttrValsAsSubfields("&mods:url.access"); - htmlDecoder.process(new StringReader("" - + "file:///img.png")); - final InOrder ordered = inOrder(receiver); + htmlDecoder.process(new StringReader("" + + "file:///img.png")); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startEntity("meta"); ordered.verify(receiver).literal("language", "DE"); ordered.verify(receiver).startEntity("mods:url"); ordered.verify(receiver).literal("preview", "file:///img.png"); - ordered.verify(receiver, never()).literal("value", "file:///img.png"); - ordered.verify(receiver, times(3)).endEntity(); + ordered.verify(receiver, Mockito.never()).literal("value", "file:///img.png"); + ordered.verify(receiver, Mockito.times(3)).endEntity(); } } diff --git a/metafacture-io/src/test/java/org/metafacture/io/AbstractConfigurableObjectWriterTest.java b/metafacture-io/src/test/java/org/metafacture/io/AbstractConfigurableObjectWriterTest.java index a780d7273..568a64944 100644 --- a/metafacture-io/src/test/java/org/metafacture/io/AbstractConfigurableObjectWriterTest.java +++ b/metafacture-io/src/test/java/org/metafacture/io/AbstractConfigurableObjectWriterTest.java @@ -16,12 +16,11 @@ package org.metafacture.io; -import static org.junit.Assert.assertEquals; +import org.junit.Assert; +import org.junit.Test; import java.io.IOException; -import org.junit.Test; - /** * Tests shared by all back end implementations of {@link ObjectWriter}. * @@ -54,7 +53,7 @@ public final void testShouldAppendNewLinesByDefault() throws IOException { DATA2 + "\n" + DATA3 + "\n"; - assertEquals(getOutput(), expectedResult); + Assert.assertEquals(getOutput(), expectedResult); } @Test @@ -75,7 +74,7 @@ public final void testShouldOutputHeaderAtStreamStart() throws IOException { DATA3 + ObjectWriter.DEFAULT_FOOTER; - assertEquals(getOutput(), expectedResult); + Assert.assertEquals(getOutput(), expectedResult); } @Test @@ -96,7 +95,7 @@ public final void testShouldOutputFooterAtStreamEnd() throws IOException { DATA3 + FOOTER; - assertEquals(getOutput(), expectedResult); + Assert.assertEquals(getOutput(), expectedResult); } @Test @@ -117,7 +116,7 @@ public final void testShouldOutputSeparatorBetweenObjects() throws IOException { DATA3 + ObjectWriter.DEFAULT_FOOTER; - assertEquals(getOutput(), expectedResult); + Assert.assertEquals(getOutput(), expectedResult); } @Test @@ -136,7 +135,7 @@ public final void testShouldOutputNoSeparatorifOnlyOneObjectIsOutput() throws IO DATA1 + FOOTER; - assertEquals(getOutput(), expectedResult); + Assert.assertEquals(getOutput(), expectedResult); } @Test @@ -151,7 +150,7 @@ public final void testShouldOutputNothingIfNoObjectsAreProcessed() throws IOExce final String expectedResult = ""; - assertEquals(getOutput(), expectedResult); + Assert.assertEquals(getOutput(), expectedResult); } protected abstract ConfigurableObjectWriter getWriter(); diff --git a/metafacture-io/src/test/java/org/metafacture/io/ByteStreamFileWriterTest.java b/metafacture-io/src/test/java/org/metafacture/io/ByteStreamFileWriterTest.java index 6f64d0784..b576df7ce 100644 --- a/metafacture-io/src/test/java/org/metafacture/io/ByteStreamFileWriterTest.java +++ b/metafacture-io/src/test/java/org/metafacture/io/ByteStreamFileWriterTest.java @@ -1,14 +1,6 @@ package org.metafacture.io; -import static java.util.Arrays.asList; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.contentOf; - -import java.io.File; -import java.io.IOException; -import java.nio.charset.StandardCharsets; -import java.util.List; - +import org.assertj.core.api.Assertions; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -16,33 +8,48 @@ import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; +import java.io.File; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.List; + public class ByteStreamFileWriterTest { + private static final String SOME_DATA = "Nil desperandum"; + private static final String SOME_MORE_DATA = "De omnibus dubitandum"; + + @Rule + public TemporaryFolder tempFolder = new TemporaryFolder(); + + @Rule + public MockitoRule mockitoRule = MockitoJUnit.rule(); + private ByteStreamFileWriter byteStreamFileWriter; + public ByteStreamFileWriterTest() { + } + @Before public void setupSystemUnderTest() { - byteStreamFileWriter = new ByteStreamFileWriter(); } @Test public void shouldWriteBytesToFile() throws IOException { - - File outputFile = tempFolder.newFile(); + final File outputFile = tempFolder.newFile(); byteStreamFileWriter.setFileNameSupplier(() -> outputFile); byteStreamFileWriter.process(SOME_DATA.getBytes(StandardCharsets.UTF_8)); byteStreamFileWriter.closeStream(); - assertThat(outputFile).isFile(); - assertThat(contentOf(outputFile)).isEqualTo(SOME_DATA); + Assertions.assertThat(outputFile).isFile(); + Assertions.assertThat(Assertions.contentOf(outputFile)).isEqualTo(SOME_DATA); } @Test public void shouldStartNewOutputFileOnResetStreamEvent() throws IOException { - - List outputFiles = asList( + final List outputFiles = Arrays.asList( tempFolder.newFile(), tempFolder.newFile()); byteStreamFileWriter.setFileNameSupplier(outputFiles.iterator()::next); @@ -52,16 +59,15 @@ public void shouldStartNewOutputFileOnResetStreamEvent() throws IOException { byteStreamFileWriter.process(SOME_MORE_DATA.getBytes(StandardCharsets.UTF_8)); byteStreamFileWriter.closeStream(); - assertThat(outputFiles.get(0)).isFile(); - assertThat(contentOf(outputFiles.get(0))).isEqualTo(SOME_DATA); - assertThat(outputFiles.get(1)).isFile(); - assertThat(contentOf(outputFiles.get(1))).isEqualTo(SOME_MORE_DATA); + Assertions.assertThat(outputFiles.get(0)).isFile(); + Assertions.assertThat(Assertions.contentOf(outputFiles.get(0))).isEqualTo(SOME_DATA); + Assertions.assertThat(outputFiles.get(1)).isFile(); + Assertions.assertThat(Assertions.contentOf(outputFiles.get(1))).isEqualTo(SOME_MORE_DATA); } @Test public void shouldOverwriteExistingFilesByDefault() throws IOException { - - File outputFile = tempFolder.newFile(); + final File outputFile = tempFolder.newFile(); byteStreamFileWriter.setFileNameSupplier(() -> outputFile); byteStreamFileWriter.process(SOME_DATA.getBytes(StandardCharsets.UTF_8)); @@ -69,15 +75,13 @@ public void shouldOverwriteExistingFilesByDefault() throws IOException { byteStreamFileWriter.process(SOME_MORE_DATA.getBytes(StandardCharsets.UTF_8)); byteStreamFileWriter.closeStream(); - assertThat(outputFile).isFile(); - assertThat(contentOf(outputFile)).isEqualTo(SOME_MORE_DATA); + Assertions.assertThat(outputFile).isFile(); + Assertions.assertThat(Assertions.contentOf(outputFile)).isEqualTo(SOME_MORE_DATA); } @Test public void shouldAppendIfParameterAppendIfFileExistsIsSet() throws IOException { - - - File outputFile = tempFolder.newFile(); + final File outputFile = tempFolder.newFile(); byteStreamFileWriter.setFileNameSupplier(() -> outputFile); byteStreamFileWriter.setAppendIfFileExists(true); @@ -86,17 +90,8 @@ public void shouldAppendIfParameterAppendIfFileExistsIsSet() throws IOException byteStreamFileWriter.process(SOME_MORE_DATA.getBytes(StandardCharsets.UTF_8)); byteStreamFileWriter.closeStream(); - assertThat(outputFile).isFile(); - assertThat(contentOf(outputFile)).isEqualTo(SOME_DATA + SOME_MORE_DATA); + Assertions.assertThat(outputFile).isFile(); + Assertions.assertThat(Assertions.contentOf(outputFile)).isEqualTo(SOME_DATA + SOME_MORE_DATA); } - private static final String SOME_DATA = "Nil desperandum"; - private static final String SOME_MORE_DATA = "De omnibus dubitandum"; - - @Rule - public TemporaryFolder tempFolder = new TemporaryFolder(); - - @Rule - public MockitoRule mockitoRule = MockitoJUnit.rule(); - } diff --git a/metafacture-io/src/test/java/org/metafacture/io/FileOpenerCompressionTest.java b/metafacture-io/src/test/java/org/metafacture/io/FileOpenerCompressionTest.java index 8751b7194..548560393 100644 --- a/metafacture-io/src/test/java/org/metafacture/io/FileOpenerCompressionTest.java +++ b/metafacture-io/src/test/java/org/metafacture/io/FileOpenerCompressionTest.java @@ -68,20 +68,20 @@ public FileOpenerCompressionTest(final String resourcePath, final FileCompressio @Parameters public static Iterable data() { return Arrays.asList(new Object[][] { - { "compressed.txt", FileCompression.AUTO }, - { "compressed.txt.bgzf", FileCompression.AUTO }, - { "compressed.txt.bz2", FileCompression.AUTO }, - { "compressed.txt.bzip2", FileCompression.AUTO }, - { "compressed.txt.gz", FileCompression.AUTO }, - { "compressed.txt.gzip", FileCompression.AUTO }, - { "compressed.txt.xz", FileCompression.AUTO }, - { "compressed.txt", FileCompression.NONE }, - { "compressed.txt.bz2", FileCompression.BZIP2 }, - { "compressed.txt.bzip2", FileCompression.BZIP2 }, - { "compressed.txt.bgzf", FileCompression.GZIP }, - { "compressed.txt.gz", FileCompression.GZIP }, - { "compressed.txt.gzip", FileCompression.GZIP }, - { "compressed.txt.xz", FileCompression.XZ }, + {"compressed.txt", FileCompression.AUTO}, + {"compressed.txt.bgzf", FileCompression.AUTO}, + {"compressed.txt.bz2", FileCompression.AUTO}, + {"compressed.txt.bzip2", FileCompression.AUTO}, + {"compressed.txt.gz", FileCompression.AUTO}, + {"compressed.txt.gzip", FileCompression.AUTO}, + {"compressed.txt.xz", FileCompression.AUTO}, + {"compressed.txt", FileCompression.NONE}, + {"compressed.txt.bz2", FileCompression.BZIP2}, + {"compressed.txt.bzip2", FileCompression.BZIP2}, + {"compressed.txt.bgzf", FileCompression.GZIP}, + {"compressed.txt.gz", FileCompression.GZIP}, + {"compressed.txt.gzip", FileCompression.GZIP}, + {"compressed.txt.xz", FileCompression.XZ} }); } diff --git a/metafacture-io/src/test/java/org/metafacture/io/FileOpenerTest.java b/metafacture-io/src/test/java/org/metafacture/io/FileOpenerTest.java index 763ca58e7..541f332f6 100644 --- a/metafacture-io/src/test/java/org/metafacture/io/FileOpenerTest.java +++ b/metafacture-io/src/test/java/org/metafacture/io/FileOpenerTest.java @@ -59,6 +59,9 @@ public final class FileOpenerTest { @Mock private ObjectReceiver receiver; + public FileOpenerTest() { + } + @Test public void testUtf8IsDefaultEncoding() throws IOException { Assume.assumeFalse("Default encoding is UTF-8: It is not possible to test whether FileOpener sets " + @@ -83,7 +86,7 @@ private void testDecompressConcatenated(final boolean decompressConcatenated) th try (InputStreamReader r = new InputStreamReader(getClass().getResourceAsStream("compressed.txt"))) { final String data = ResourceUtil.readAll(r); - for (int i = 0; i < 1525; i++) { + for (int i = 0; i < 1525; ++i) { sb.append(data).append("\n"); } } diff --git a/metafacture-io/src/test/java/org/metafacture/io/HttpOpenerTest.java b/metafacture-io/src/test/java/org/metafacture/io/HttpOpenerTest.java index dd3bdbb1a..e9bf080c5 100644 --- a/metafacture-io/src/test/java/org/metafacture/io/HttpOpenerTest.java +++ b/metafacture-io/src/test/java/org/metafacture/io/HttpOpenerTest.java @@ -59,14 +59,15 @@ public final class HttpOpenerTest { private static final String REQUEST_BODY = "request body"; private static final String RESPONSE_BODY = "response bödy"; // UTF-8 - private static byte[] GZIPPED_RESPONSE_BODY; + private static byte[] gzippedResponseBody; + static { try (ByteArrayOutputStream out = new ByteArrayOutputStream()) { final GZIPOutputStream gzip = new GZIPOutputStream(out); gzip.write(RESPONSE_BODY.getBytes("UTF-8")); gzip.close(); - GZIPPED_RESPONSE_BODY = out.toByteArray(); + gzippedResponseBody = out.toByteArray(); } catch (final IOException e) { e.printStackTrace(); @@ -84,9 +85,12 @@ public final class HttpOpenerTest { @Mock private ObjectReceiver receiver; + public HttpOpenerTest() { + } + @Test public void shouldPerformGetRequestWithInputAsUrlByDefault() throws IOException { - shouldPerformRequest(TEST_URL, HttpOpener.Method.GET, (o, u) -> {}); + shouldPerformRequest(TEST_URL, HttpOpener.Method.GET, (o, u) -> { }); } @Test @@ -232,16 +236,6 @@ public void shouldPerformPostRequestWithContentTypeParameter() throws IOExceptio }, "Content-Type"); } - @Test - public void shouldPerformPostRequestWithCharsetParameter() throws IOException { - shouldPerformPostRequestWithCharsetParameter(null); - } - - @Test - public void shouldPerformPostRequestWithCharsetParameterAndContentTypeResponseHeader() throws IOException { - shouldPerformPostRequestWithCharsetParameter("expected: but was:"); - } - private void shouldPerformPostRequestWithCharsetParameter(final String expectedMessage) throws IOException { final String charset = "ISO-8859-1"; final String header = "Accept-Charset"; @@ -265,9 +259,19 @@ private void shouldPerformPostRequestWithCharsetParameter(final String expectedM Assert.assertEquals(expectedMessage, actualMessage); } + @Test + public void shouldPerformPostRequestWithCharsetParameter() throws IOException { + shouldPerformPostRequestWithCharsetParameter(null); + } + + @Test + public void shouldPerformPostRequestWithCharsetParameterAndContentTypeResponseHeader() throws IOException { + shouldPerformPostRequestWithCharsetParameter("expected: but was:"); + } + @Test public void shouldPerformGetRequestWithErrorResponse() throws IOException { - shouldPerformRequest(TEST_URL, HttpOpener.Method.GET, (o, u) -> {}, + shouldPerformRequest(TEST_URL, HttpOpener.Method.GET, (o, u) -> { }, null, null, WireMock.badRequest().withBody(RESPONSE_BODY), "ERROR: " + RESPONSE_BODY); } @@ -286,7 +290,7 @@ public void shouldPerformGetRequestWithErrorResponseAndWithoutErrorPrefixParamet @Test public void shouldPerformGetRequestWithGzippedContentEncoding() throws IOException { shouldPerformRequest(TEST_URL, HttpOpener.Method.GET, (o, u) -> o.setAcceptEncoding("gzip"), - null, null, WireMock.ok().withBody(GZIPPED_RESPONSE_BODY).withHeader(HttpOpener.CONTENT_ENCODING_HEADER, "gzip"), RESPONSE_BODY); + null, null, WireMock.ok().withBody(gzippedResponseBody).withHeader(HttpOpener.CONTENT_ENCODING_HEADER, "gzip"), RESPONSE_BODY); } private void shouldPerformRequest(final String input, final HttpOpener.Method method, final BiConsumer consumer, final String... headers) throws IOException { @@ -295,7 +299,7 @@ private void shouldPerformRequest(final String input, final HttpOpener.Method me q -> Arrays.stream(headers).forEach(h -> q.withHeader(h, TEST_VALUE)), null); } - private void shouldPerformRequest(final String input, final HttpOpener.Method method, final BiConsumer consumer, final Consumer stubConsumer, final Consumer requestConsumer, final Consumer responseConsumer) throws IOException { + private void shouldPerformRequest(final String input, final HttpOpener.Method method, final BiConsumer consumer, final Consumer stubConsumer, final Consumer requestConsumer, final Consumer responseConsumer) throws IOException { // checkstyle-disable-line ParameterNumber final ResponseDefinitionBuilder response = WireMock.ok().withBody(RESPONSE_BODY); if (responseConsumer != null) { responseConsumer.accept(response); @@ -306,7 +310,7 @@ private void shouldPerformRequest(final String input, final HttpOpener.Method me response, method.getResponseHasBody() ? RESPONSE_BODY : ""); } - private void shouldPerformRequest(final String input, final HttpOpener.Method method, final BiConsumer consumer, final Consumer stubConsumer, final Consumer requestConsumer, final ResponseDefinitionBuilder response, final String responseBody) throws IOException { + private void shouldPerformRequest(final String input, final HttpOpener.Method method, final BiConsumer consumer, final Consumer stubConsumer, final Consumer requestConsumer, final ResponseDefinitionBuilder response, final String responseBody) throws IOException { // checkstyle-disable-line ParameterNumber final String baseUrl = wireMockRule.baseUrl(); final String url = String.format(TEST_URL, baseUrl); diff --git a/metafacture-io/src/test/java/org/metafacture/io/ObjectFileWriterCompressionTest.java b/metafacture-io/src/test/java/org/metafacture/io/ObjectFileWriterCompressionTest.java index 6ed9580df..89a61c674 100644 --- a/metafacture-io/src/test/java/org/metafacture/io/ObjectFileWriterCompressionTest.java +++ b/metafacture-io/src/test/java/org/metafacture/io/ObjectFileWriterCompressionTest.java @@ -16,13 +16,7 @@ package org.metafacture.io; -import static org.junit.Assert.assertArrayEquals; - -import java.io.File; -import java.io.IOException; -import java.nio.file.Files; -import java.util.Arrays; - +import org.junit.Assert; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; @@ -30,6 +24,10 @@ import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameters; +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.util.Arrays; /** * @@ -51,10 +49,10 @@ public final class ObjectFileWriterCompressionTest { private static final String FILENAME_GZIP = "compressed.txt.gzip"; private static final String FILENAME_XZ = "compressed.txt.xz"; - private static final byte[] MAGIC_BYTES_NONE = { 'T', 'h', 'i', 's' }; - private static final byte[] MAGIC_BYTES_BZIP2 = { 'B', 'Z', 'h' }; - private static final byte[] MAGIC_BYTES_GZIP = { (byte)0x1f, (byte)0x8b }; - private static final byte[] MAGIC_BYTES_XZ = { (byte)0xfd, '7', 'z', 'X', 'Z', (byte)0x00 }; + private static final byte[] MAGIC_BYTES_NONE = {'T', 'h', 'i', 's'}; + private static final byte[] MAGIC_BYTES_BZIP2 = {'B', 'Z', 'h'}; + private static final byte[] MAGIC_BYTES_GZIP = {(byte) 0x1f, (byte) 0x8b}; + private static final byte[] MAGIC_BYTES_XZ = {(byte) 0xfd, '7', 'z', 'X', 'Z', (byte) 0x00}; @Rule public TemporaryFolder tempFolder = new TemporaryFolder(); @@ -73,18 +71,18 @@ public ObjectFileWriterCompressionTest(final String fileName, final FileCompress @Parameters public static Iterable data() { return Arrays.asList(new Object[][] { - { FILENAME_NONE, FileCompression.AUTO, MAGIC_BYTES_NONE }, - { FILENAME_BZ2, FileCompression.AUTO, MAGIC_BYTES_BZIP2 }, - { FILENAME_BZIP2, FileCompression.AUTO, MAGIC_BYTES_BZIP2 }, - { FILENAME_GZ, FileCompression.AUTO, MAGIC_BYTES_GZIP }, - { FILENAME_GZ_NOAUTO, FileCompression.AUTO, MAGIC_BYTES_NONE }, - { FILENAME_GZIP, FileCompression.AUTO, MAGIC_BYTES_GZIP }, - { FILENAME_XZ, FileCompression.AUTO, MAGIC_BYTES_XZ }, - { FILENAME_NONE, FileCompression.NONE, MAGIC_BYTES_NONE }, - { FILENAME_BZ2, FileCompression.BZIP2, MAGIC_BYTES_BZIP2 }, - { FILENAME_GZ, FileCompression.GZIP, MAGIC_BYTES_GZIP }, - { FILENAME_GZ_NOAUTO, FileCompression.GZIP, MAGIC_BYTES_GZIP }, - { FILENAME_XZ, FileCompression.XZ, MAGIC_BYTES_XZ }, + {FILENAME_NONE, FileCompression.AUTO, MAGIC_BYTES_NONE}, + {FILENAME_BZ2, FileCompression.AUTO, MAGIC_BYTES_BZIP2}, + {FILENAME_BZIP2, FileCompression.AUTO, MAGIC_BYTES_BZIP2}, + {FILENAME_GZ, FileCompression.AUTO, MAGIC_BYTES_GZIP}, + {FILENAME_GZ_NOAUTO, FileCompression.AUTO, MAGIC_BYTES_NONE}, + {FILENAME_GZIP, FileCompression.AUTO, MAGIC_BYTES_GZIP}, + {FILENAME_XZ, FileCompression.AUTO, MAGIC_BYTES_XZ}, + {FILENAME_NONE, FileCompression.NONE, MAGIC_BYTES_NONE}, + {FILENAME_BZ2, FileCompression.BZIP2, MAGIC_BYTES_BZIP2}, + {FILENAME_GZ, FileCompression.GZIP, MAGIC_BYTES_GZIP}, + {FILENAME_GZ_NOAUTO, FileCompression.GZIP, MAGIC_BYTES_GZIP}, + {FILENAME_XZ, FileCompression.XZ, MAGIC_BYTES_XZ} }); } @@ -100,7 +98,7 @@ public void shouldWriteCompressedFiles() throws IOException { writer.process(DATA); writer.closeStream(); - assertArrayEquals(magicBytes, readMagicBytes(file, magicBytes.length)); + Assert.assertArrayEquals(magicBytes, readMagicBytes(file, magicBytes.length)); } private byte[] readMagicBytes(final File file, final int magicBytesLength) diff --git a/metafacture-io/src/test/java/org/metafacture/io/ObjectFileWriterTest.java b/metafacture-io/src/test/java/org/metafacture/io/ObjectFileWriterTest.java index 77d9ad612..fe01eaf4c 100644 --- a/metafacture-io/src/test/java/org/metafacture/io/ObjectFileWriterTest.java +++ b/metafacture-io/src/test/java/org/metafacture/io/ObjectFileWriterTest.java @@ -16,15 +16,14 @@ package org.metafacture.io; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertTrue; -import static org.junit.Assume.assumeFalse; +import org.metafacture.commons.ResourceUtil; +import org.junit.Assert; +import org.junit.Assume; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.metafacture.commons.ResourceUtil; import java.io.File; import java.io.FileInputStream; @@ -51,6 +50,9 @@ public final class ObjectFileWriterTest private File file; private ObjectFileWriter writer; + public ObjectFileWriterTest() { + } + @Before public void setup() throws IOException { file = tempFolder.newFile(); @@ -59,7 +61,7 @@ public void setup() throws IOException { @Test public void shouldWriteUTF8EncodedOutput() throws IOException { - assumeFalse("Default encoding is UTF-8: It is not possible to test whether " + + Assume.assumeFalse("Default encoding is UTF-8: It is not possible to test whether " + "ObjectFileWriter sets the encoding to UTF-8 correctly.", StandardCharsets.UTF_8.equals(Charset.defaultCharset())); @@ -99,10 +101,10 @@ public void shouldIncrementCountOnResetBeforeStartingNewFile() throws IOExceptio final String pathWithVar = tempFolder.getRoot() + "/test-${i}"; writer = new ObjectFileWriter(pathWithVar); writer.process(DATA); - assertTrue(new File(tempFolder.getRoot(), "test-0").exists()); + Assert.assertTrue(new File(tempFolder.getRoot(), "test-0").exists()); writer.resetStream(); // increments count, starts new file writer.process(DATA); - assertTrue(new File(tempFolder.getRoot(), "test-1").exists()); + Assert.assertTrue(new File(tempFolder.getRoot(), "test-1").exists()); } @Test @@ -132,7 +134,7 @@ private void setWriter() { private void assertOutput(final String expected) throws IOException { final byte[] bytesWritten = Files.readAllBytes(file.toPath()); - assertArrayEquals(expected.getBytes(StandardCharsets.UTF_8), + Assert.assertArrayEquals(expected.getBytes(StandardCharsets.UTF_8), bytesWritten); // FileObjectWriter appends new lines } diff --git a/metafacture-io/src/test/java/org/metafacture/io/ObjectStdoutWriterTest.java b/metafacture-io/src/test/java/org/metafacture/io/ObjectStdoutWriterTest.java index 2d2db8a7c..93a383a67 100644 --- a/metafacture-io/src/test/java/org/metafacture/io/ObjectStdoutWriterTest.java +++ b/metafacture-io/src/test/java/org/metafacture/io/ObjectStdoutWriterTest.java @@ -16,12 +16,12 @@ package org.metafacture.io; +import org.junit.Before; + import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.PrintStream; -import org.junit.Before; - /** * Tests for class {@link ObjectStdoutWriter}. * @@ -35,6 +35,9 @@ public final class ObjectStdoutWriterTest private ByteArrayOutputStream stdoutBuffer; + public ObjectStdoutWriterTest() { + } + @Before public void setup() { writer = new ObjectStdoutWriter(); diff --git a/metafacture-io/src/test/java/org/metafacture/io/RecordReaderTest.java b/metafacture-io/src/test/java/org/metafacture/io/RecordReaderTest.java index 62569f905..20cc42d46 100644 --- a/metafacture-io/src/test/java/org/metafacture/io/RecordReaderTest.java +++ b/metafacture-io/src/test/java/org/metafacture/io/RecordReaderTest.java @@ -16,21 +16,18 @@ package org.metafacture.io; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.mockito.Mockito.verifyZeroInteractions; - -import java.io.StringReader; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.io.StringReader; + /** * Tests for {@link RecordReader}. * @@ -50,6 +47,9 @@ public final class RecordReaderTest { @Mock private ObjectReceiver receiver; + public RecordReaderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -70,10 +70,10 @@ public void testShouldProcessRecordsFollowedbySeparator() { RECORD1 + SEPARATOR + RECORD2 + SEPARATOR)); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(RECORD1); ordered.verify(receiver).process(RECORD2); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -84,10 +84,10 @@ public void testShouldProcessRecordsPrecededbySeparator() { SEPARATOR + RECORD1 + SEPARATOR + RECORD2)); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(RECORD1); ordered.verify(receiver).process(RECORD2); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -98,10 +98,10 @@ public void testShouldProcessRecordsSeparatedBySeparator() { RECORD1 + SEPARATOR + RECORD2)); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(RECORD1); ordered.verify(receiver).process(RECORD2); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -111,9 +111,9 @@ public void testShouldProcessSingleRecordWithoutSeparator() { recordReader.process(new StringReader( RECORD1)); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(RECORD1); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -126,7 +126,7 @@ public void testShouldNotEmitRecordIfInputIsEmpty() { recordReader.process(new StringReader( EMPTY_RECORD)); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } @Test @@ -138,10 +138,10 @@ public void testShouldSkipEmptyRecordsByDefault() { EMPTY_RECORD + SEPARATOR + RECORD2)); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(RECORD1); ordered.verify(receiver).process(RECORD2); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -154,11 +154,11 @@ public void testShouldOutputEmptyRecordsIfConfigured() { EMPTY_RECORD + SEPARATOR + RECORD2)); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(RECORD1); ordered.verify(receiver).process(EMPTY_RECORD); ordered.verify(receiver).process(RECORD2); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -171,11 +171,11 @@ public void testShouldOutputEmptyRecordsAtStartOfInputIfConfigured() { RECORD1 + SEPARATOR + RECORD2)); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(EMPTY_RECORD); ordered.verify(receiver).process(RECORD1); ordered.verify(receiver).process(RECORD2); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -188,11 +188,11 @@ public void testShouldOutputEmptyRecordsAtEndOfInputIfConfigured() { RECORD2 + SEPARATOR + EMPTY_RECORD)); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(RECORD1); ordered.verify(receiver).process(RECORD2); ordered.verify(receiver).process(EMPTY_RECORD); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -201,10 +201,10 @@ public void testShouldUseGlobalSeparatorAsDefaultSeparator() { RECORD1 + DEFAULT_SEPARATOR + RECORD2 + DEFAULT_SEPARATOR)); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(RECORD1); ordered.verify(receiver).process(RECORD2); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -218,11 +218,11 @@ public void testShouldProcessMultipleReaders() { RECORD2 + SEPARATOR + RECORD1)); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(RECORD1); - ordered.verify(receiver, times(2)).process(RECORD2); + ordered.verify(receiver, Mockito.times(2)).process(RECORD2); ordered.verify(receiver).process(RECORD1); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } diff --git a/metafacture-io/src/test/java/org/metafacture/io/TestHelpers.java b/metafacture-io/src/test/java/org/metafacture/io/TestHelpers.java index 722cefeb0..bdf84bec7 100644 --- a/metafacture-io/src/test/java/org/metafacture/io/TestHelpers.java +++ b/metafacture-io/src/test/java/org/metafacture/io/TestHelpers.java @@ -31,6 +31,9 @@ public final class TestHelpers { + private TestHelpers() { + } + public static void assertFile(final ObjectReceiver receiver, final String expected, final File file, final Consumer consumer) { assertReader(receiver, () -> { final FileOpener opener = new FileOpener(); diff --git a/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/MapToStreamTest.java b/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/MapToStreamTest.java index 276210e3b..5f5af39b4 100644 --- a/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/MapToStreamTest.java +++ b/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/MapToStreamTest.java @@ -16,19 +16,18 @@ package org.metafacture.javaintegration; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verify; - -import java.util.HashMap; -import java.util.Map; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.util.HashMap; +import java.util.Map; + /** * Tests for class {@link MapToStream}. * @@ -42,6 +41,9 @@ public final class MapToStreamTest { private MapToStream mapToStream; + public MapToStreamTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -53,7 +55,7 @@ public void setup() { public void shouldEmitEmptyRecordIfMapIsEmpty() { mapToStream.process(new HashMap<>()); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).endRecord(); } @@ -64,7 +66,7 @@ public void shouldEmitMapEntryAsLiteral() { map.put("key", "value"); mapToStream.process(map); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).literal("key", "value"); ordered.verify(receiver).endRecord(); @@ -77,8 +79,8 @@ public void shouldEmitAllMapEntriesAsLiterals() { map.put("key-2", "value-2"); mapToStream.process(map); - verify(receiver).literal("key-1", "value-1"); - verify(receiver).literal("key-2", "value-2"); + Mockito.verify(receiver).literal("key-1", "value-1"); + Mockito.verify(receiver).literal("key-2", "value-2"); } @Test @@ -89,7 +91,7 @@ public void shouldUseMapEntryWithIdKeyAsRecordId() { map.put("id", "id-1"); mapToStream.process(map); - verify(receiver).startRecord("id-1"); + Mockito.verify(receiver).startRecord("id-1"); } @Test @@ -98,7 +100,7 @@ public void shouldUseMapEntryWithDefaultIdNameAsRecordId() { map.put("_id", "id-1"); mapToStream.process(map); - verify(receiver).startRecord("id-1"); + Mockito.verify(receiver).startRecord("id-1"); } @Test @@ -107,7 +109,7 @@ public void shouldEmitEmptyRecordIdIfNoEntryWithIdKeyIsFoundInMap() { map.put("noid", "noid"); mapToStream.process(map); - verify(receiver).startRecord(""); + Mockito.verify(receiver).startRecord(""); } @Test @@ -120,9 +122,9 @@ public void shouldConvertObjectsInMapToStrings() { map.put(-1, 100); mapToStream.process(map); - verify(receiver).startRecord("100"); - verify(receiver).literal("1", "11"); - verify(receiver).literal("2", "12"); + Mockito.verify(receiver).startRecord("100"); + Mockito.verify(receiver).literal("1", "11"); + Mockito.verify(receiver).literal("2", "12"); } } diff --git a/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/pojo/PojoDecoderTest.java b/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/pojo/PojoDecoderTest.java index 47cbfcb80..4f12e3941 100644 --- a/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/pojo/PojoDecoderTest.java +++ b/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/pojo/PojoDecoderTest.java @@ -16,26 +16,24 @@ package org.metafacture.javaintegration.pojo; -import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verifyZeroInteractions; - -import java.util.Arrays; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; +import org.metafacture.framework.StreamReceiver; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.ArgumentCaptor; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + /** * Tests for class {@link PojoDecoder}. * @@ -43,11 +41,14 @@ * @author Christoph Böhme (refactored to Mockito) * */ -public class PojoDecoderTest { +public class PojoDecoderTest { // checkstyle-disable-line ClassDataAbstractionCoupling @Mock private StreamReceiver receiver; + public PojoDecoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -60,7 +61,7 @@ public void shouldDecodeNullObject() { pojoDecoder.process(null); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } @Test @@ -70,7 +71,7 @@ public void shouldDecodeEmptyPojo() { pojoDecoder.process(new EmptyPojo()); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).endRecord(); } @@ -85,7 +86,7 @@ public void shouldDecodeSimplePojo() { simplePojo.secondField = "value2"; pojoDecoder.process(simplePojo); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).literal("secondField", "value2"); ordered.verify(receiver).literal("firstField", "value1"); @@ -104,7 +105,7 @@ public void shouldDecodeNestedPojo() { nestedPojo.setInnerPojo(simplePojo); pojoDecoder.process(nestedPojo); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).startEntity("innerPojo"); ordered.verify(receiver).literal("secondField", "value2"); @@ -123,7 +124,7 @@ public void shouldDecodePojoWithMetafactureSource() { streamReceiver -> streamReceiver.literal("literal", "value")); pojoDecoder.process(mfSourcePojo); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).startEntity("metafactureSourceField"); ordered.verify(receiver).literal("literal", "value"); @@ -136,12 +137,12 @@ public void shouldDecodeSimpleArrayPojo() { final PojoDecoder pojoDecoder = new PojoDecoder<>(); pojoDecoder.setReceiver(receiver); - final String[] valueArray = { "array-value1", "array-value2"}; + final String[] valueArray = {"array-value1", "array-value2"}; final SimpleArrayPojo simpleArrayPojo = new SimpleArrayPojo(); simpleArrayPojo.setArrayField(valueArray); pojoDecoder.process(simpleArrayPojo); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).literal("arrayField", "array-value1"); ordered.verify(receiver).literal("arrayField", "array-value2"); @@ -158,7 +159,7 @@ public void shouldDecodeSimpleListPojo() { simpleListPojo.setListField(valueList); pojoDecoder.process(simpleListPojo); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).literal("listField", "list-value1"); ordered.verify(receiver).literal("listField", "list-value2"); @@ -176,7 +177,7 @@ public void shouldDecodeSimpleSetPojo() { simpleSetPojo.setSetField(valueSet); pojoDecoder.process(simpleSetPojo); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).literal("setField", "set-value1"); ordered.verify(receiver).literal("setField", "set-value2"); @@ -199,26 +200,34 @@ public void shouldDecodeSimpleMapPojo() { ArgumentCaptor.forClass(String.class); final ArgumentCaptor valueCaptor = ArgumentCaptor.forClass(String.class); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).startEntity("mapField"); - ordered.verify(receiver, times(2)).literal( + ordered.verify(receiver, Mockito.times(2)).literal( nameCaptor.capture(), valueCaptor.capture()); - assertEquals(mapField.get(nameCaptor.getAllValues().get(0)), + Assert.assertEquals(mapField.get(nameCaptor.getAllValues().get(0)), valueCaptor.getAllValues().get(0)); - assertEquals(mapField.get(nameCaptor.getAllValues().get(1)), + Assert.assertEquals(mapField.get(nameCaptor.getAllValues().get(1)), valueCaptor.getAllValues().get(1)); ordered.verify(receiver).endEntity(); ordered.verify(receiver).endRecord(); } private static class EmptyPojo { + + private EmptyPojo() { + } + } private static class SimplePojo { + public String secondField; // checkstyle-disable-line VisibilityModifier + private String firstField; - public String secondField; + + private SimplePojo() { + } public String getFirstField() { return firstField; @@ -234,6 +243,9 @@ private static class NestedPojo { private SimplePojo innerPojo; + private NestedPojo() { + } + public SimplePojo getInnerPojo() { return innerPojo; } @@ -247,6 +259,9 @@ private static class MetafactureSourcePojo { private MetafactureSource metafactureSourceField; + private MetafactureSourcePojo() { + } + public MetafactureSource getMetafactureSourceField() { return metafactureSourceField; } @@ -262,6 +277,9 @@ private static class SimpleArrayPojo { private String[] arrayField; + private SimpleArrayPojo() { + } + public String[] getArrayField() { return arrayField; } @@ -276,6 +294,9 @@ private static class SimpleListPojo { private List listField; + private SimpleListPojo() { + } + public List getListField() { return listField; } @@ -290,6 +311,9 @@ private static class SimpleSetPojo { private Set setField; + private SimpleSetPojo() { + } + public Set getSetField() { return setField; } @@ -304,6 +328,9 @@ private static class SimpleMapPojo { private Map mapField; + private SimpleMapPojo() { + } + public Map getMapField() { return mapField; } diff --git a/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/pojo/PojoEncoderTest.java b/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/pojo/PojoEncoderTest.java index 19a6e79d8..e42d33b92 100644 --- a/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/pojo/PojoEncoderTest.java +++ b/metafacture-javaintegration/src/test/java/org/metafacture/javaintegration/pojo/PojoEncoderTest.java @@ -16,18 +16,16 @@ package org.metafacture.javaintegration.pojo; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; - -import java.util.List; -import java.util.Map; +import org.metafacture.framework.ObjectReceiver; +import org.junit.Assert; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.ArgumentCaptor; +import org.mockito.ArgumentMatchers; +import org.mockito.Mockito; + +import java.util.List; +import java.util.Map; /** * Tests for class {@link PojoEncoder}. @@ -38,6 +36,9 @@ */ public class PojoEncoderTest { + public PojoEncoderTest() { + } + @Test public void shouldEncodeEmptyEntityStreamToEmptyPojo() { final ObjectReceiver receiver = createObjectReceiverMock(); @@ -48,7 +49,7 @@ public void shouldEncodeEmptyEntityStreamToEmptyPojo() { pojoEncoder.startRecord("identifier"); pojoEncoder.endRecord(); - verify(receiver).process(any(EmptyPojo.class)); + Mockito.verify(receiver).process(ArgumentMatchers.any(EmptyPojo.class)); } @Test @@ -67,13 +68,13 @@ public void shouldEncodeEntityStreamToSimplePojo() { final ArgumentCaptor objectCaptor = ArgumentCaptor.forClass(SimplePojo.class); - verify(receiver).process(objectCaptor.capture()); + Mockito.verify(receiver).process(objectCaptor.capture()); final SimplePojo encodedPojo = objectCaptor.getValue(); - assertNotNull(encodedPojo); - assertEquals("value1", encodedPojo.stringField1); - assertEquals("value2", encodedPojo.getStringField2()); - assertEquals(42, encodedPojo.intField1); - assertEquals(23, encodedPojo.getIntField2()); + Assert.assertNotNull(encodedPojo); + Assert.assertEquals("value1", encodedPojo.stringField1); + Assert.assertEquals("value2", encodedPojo.getStringField2()); + Assert.assertEquals(42, encodedPojo.intField1); + Assert.assertEquals(23, encodedPojo.getIntField2()); } @Test @@ -96,14 +97,14 @@ public void shouldEncodeEntityStreamToDoubleNestedPojo() { final ArgumentCaptor objectCaptor = ArgumentCaptor.forClass(DoubleNestedPojo.class); - verify(receiver).process(objectCaptor.capture()); + Mockito.verify(receiver).process(objectCaptor.capture()); final DoubleNestedPojo encodedPojo = objectCaptor.getValue(); - assertNotNull(encodedPojo); - assertNotNull(encodedPojo.nestedPojo); - assertEquals("value3", encodedPojo.nestedPojo.attribute); - assertNotNull(encodedPojo.nestedPojo.simplePojo); - assertEquals("value1", encodedPojo.nestedPojo.simplePojo.stringField1); - assertEquals("value2", encodedPojo.nestedPojo.simplePojo.getStringField2()); + Assert.assertNotNull(encodedPojo); + Assert.assertNotNull(encodedPojo.nestedPojo); + Assert.assertEquals("value3", encodedPojo.nestedPojo.attribute); + Assert.assertNotNull(encodedPojo.nestedPojo.simplePojo); + Assert.assertEquals("value1", encodedPojo.nestedPojo.simplePojo.stringField1); + Assert.assertEquals("value2", encodedPojo.nestedPojo.simplePojo.getStringField2()); } @Test @@ -123,14 +124,14 @@ public void shouldEncodeEntityStreamToPojoWithStringList() { final ArgumentCaptor objectCaptor = ArgumentCaptor.forClass(StringListPojo.class); - verify(receiver).process(objectCaptor.capture()); + Mockito.verify(receiver).process(objectCaptor.capture()); final StringListPojo encodedPojo = objectCaptor.getValue(); - assertNotNull(encodedPojo); - assertEquals("value3", encodedPojo.attribute); - assertNotNull(encodedPojo.stringList); - assertEquals(2, encodedPojo.stringList.size()); - assertEquals("value1", encodedPojo.stringList.get(0)); - assertEquals("value2", encodedPojo.stringList.get(1)); + Assert.assertNotNull(encodedPojo); + Assert.assertEquals("value3", encodedPojo.attribute); + Assert.assertNotNull(encodedPojo.stringList); + Assert.assertEquals(2, encodedPojo.stringList.size()); + Assert.assertEquals("value1", encodedPojo.stringList.get(0)); + Assert.assertEquals("value2", encodedPojo.stringList.get(1)); } @Test @@ -149,13 +150,13 @@ public void shouldEncodeEntityStreamToPojoWithIntegerList() { final ArgumentCaptor objectCaptor = ArgumentCaptor.forClass(IntegerListPojo.class); - verify(receiver).process(objectCaptor.capture()); + Mockito.verify(receiver).process(objectCaptor.capture()); final IntegerListPojo encodedPojo = objectCaptor.getValue(); - assertNotNull(encodedPojo); - assertNotNull(encodedPojo.integerList); - assertEquals(2, encodedPojo.integerList.size()); - assertEquals(42, encodedPojo.integerList.get(0).intValue()); - assertEquals(23, encodedPojo.integerList.get(1).intValue()); + Assert.assertNotNull(encodedPojo); + Assert.assertNotNull(encodedPojo.integerList); + Assert.assertEquals(2, encodedPojo.integerList.size()); + Assert.assertEquals(42, encodedPojo.integerList.get(0).intValue()); + Assert.assertEquals(23, encodedPojo.integerList.get(1).intValue()); } @Test @@ -180,14 +181,14 @@ public void shouldEncodeEntityStreamToPojoWithSimplePojoList() { final ArgumentCaptor objectCaptor = ArgumentCaptor.forClass(SimplePojoListPojo.class); - verify(receiver).process(objectCaptor.capture()); + Mockito.verify(receiver).process(objectCaptor.capture()); final SimplePojoListPojo encodedPojo = objectCaptor.getValue(); - assertNotNull(encodedPojo); - assertNotNull(encodedPojo.simplePojoList); - assertEquals(2, encodedPojo.simplePojoList.size()); - assertEquals("value1", encodedPojo.simplePojoList.get(0).stringField1); - assertEquals("value2", encodedPojo.simplePojoList.get(0).getStringField2()); - assertEquals("value3", encodedPojo.simplePojoList.get(1).stringField1); + Assert.assertNotNull(encodedPojo); + Assert.assertNotNull(encodedPojo.simplePojoList); + Assert.assertEquals(2, encodedPojo.simplePojoList.size()); + Assert.assertEquals("value1", encodedPojo.simplePojoList.get(0).stringField1); + Assert.assertEquals("value2", encodedPojo.simplePojoList.get(0).getStringField2()); + Assert.assertEquals("value3", encodedPojo.simplePojoList.get(1).stringField1); } @Test @@ -207,13 +208,13 @@ public void shouldEncodeEntityStreamToPojoWithStringMap() { final ArgumentCaptor objectCaptor = ArgumentCaptor.forClass(StringMapPojo.class); - verify(receiver).process(objectCaptor.capture()); + Mockito.verify(receiver).process(objectCaptor.capture()); final StringMapPojo encodedPojo = objectCaptor.getValue(); - assertNotNull(encodedPojo); - assertNotNull(encodedPojo.stringMap); - assertEquals(2, encodedPojo.stringMap.size()); - assertEquals("mapValue1", encodedPojo.stringMap.get("mapKey1")); - assertEquals("mapValue2", encodedPojo.stringMap.get("mapKey2")); + Assert.assertNotNull(encodedPojo); + Assert.assertNotNull(encodedPojo.stringMap); + Assert.assertEquals(2, encodedPojo.stringMap.size()); + Assert.assertEquals("mapValue1", encodedPojo.stringMap.get("mapKey1")); + Assert.assertEquals("mapValue2", encodedPojo.stringMap.get("mapKey2")); } @Test @@ -239,18 +240,18 @@ public void shouldEncodeEntityStreamToPojoWithSimplePojoMap() { final ArgumentCaptor objectCaptor = ArgumentCaptor.forClass(SimplePojoMapPojo.class); - verify(receiver).process(objectCaptor.capture()); + Mockito.verify(receiver).process(objectCaptor.capture()); final SimplePojoMapPojo encodedPojo = objectCaptor.getValue(); - assertNotNull(encodedPojo); - assertNotNull(encodedPojo.simplePojoMap); - assertEquals(2, encodedPojo.simplePojoMap.size()); - assertEquals("stringValueA1", encodedPojo.simplePojoMap.get("mapKeyA") + Assert.assertNotNull(encodedPojo); + Assert.assertNotNull(encodedPojo.simplePojoMap); + Assert.assertEquals(2, encodedPojo.simplePojoMap.size()); + Assert.assertEquals("stringValueA1", encodedPojo.simplePojoMap.get("mapKeyA") .stringField1); - assertEquals("stringValueA2", encodedPojo.simplePojoMap.get("mapKeyA") + Assert.assertEquals("stringValueA2", encodedPojo.simplePojoMap.get("mapKeyA") .stringField2); - assertEquals("stringValueB1", encodedPojo.simplePojoMap.get("mapKeyB") + Assert.assertEquals("stringValueB1", encodedPojo.simplePojoMap.get("mapKeyB") .stringField1); - assertEquals("stringValueB2", encodedPojo.simplePojoMap.get("mapKeyB") + Assert.assertEquals("stringValueB2", encodedPojo.simplePojoMap.get("mapKeyB") .stringField2); } @@ -258,23 +259,31 @@ public void shouldEncodeEntityStreamToPojoWithSimplePojoMap() { private ObjectReceiver createObjectReceiverMock() { // There is no type safe to create a mock with Mockito#mock(Class). // Hence, we have to use an unchecked cast here: - return (ObjectReceiver) mock(ObjectReceiver.class); + return (ObjectReceiver) Mockito.mock(ObjectReceiver.class); } public static class EmptyPojo { + public EmptyPojo() { + } + } public static class SimplePojo { - public String stringField1; + public String stringField1; // checkstyle-disable-line VisibilityModifier + public int intField1; // checkstyle-disable-line VisibilityModifier + private String stringField2; - public int intField1; private int intField2; + public SimplePojo() { + } + public void setStringField2(final String stringField2) { this.stringField2 = stringField2; } + public String getStringField2() { return stringField2; } @@ -291,27 +300,39 @@ public int getIntField2() { public static class NestedPojo { - public String attribute; - public SimplePojo simplePojo; + public String attribute; // checkstyle-disable-line VisibilityModifier + public SimplePojo simplePojo; // checkstyle-disable-line VisibilityModifier + + public NestedPojo() { + } } public static class DoubleNestedPojo { - public NestedPojo nestedPojo; + public NestedPojo nestedPojo; // checkstyle-disable-line VisibilityModifier + + public DoubleNestedPojo() { + } } public static class StringListPojo { - public List stringList; - public String attribute; + public List stringList; // checkstyle-disable-line VisibilityModifier + public String attribute; // checkstyle-disable-line VisibilityModifier + + public StringListPojo() { + } } public static class IntegerListPojo { - public List integerList; + public List integerList; // checkstyle-disable-line VisibilityModifier + + public IntegerListPojo() { + } } @@ -319,6 +340,9 @@ public static class SimplePojoListPojo { private List simplePojoList; + public SimplePojoListPojo() { + } + public void setSimplePojoList(final List simplePojoList) { this.simplePojoList = simplePojoList; } @@ -327,13 +351,19 @@ public void setSimplePojoList(final List simplePojoList) { public static class StringMapPojo { - public Map stringMap; + public Map stringMap; // checkstyle-disable-line VisibilityModifier + + public StringMapPojo() { + } } public static class SimplePojoMapPojo { - public Map simplePojoMap; + public Map simplePojoMap; // checkstyle-disable-line VisibilityModifier + + public SimplePojoMapPojo() { + } } diff --git a/metafacture-json/src/test/java/org/metafacture/json/JsonDecoderTest.java b/metafacture-json/src/test/java/org/metafacture/json/JsonDecoderTest.java index fdc372a59..d82b5efea 100644 --- a/metafacture-json/src/test/java/org/metafacture/json/JsonDecoderTest.java +++ b/metafacture-json/src/test/java/org/metafacture/json/JsonDecoderTest.java @@ -16,19 +16,17 @@ package org.metafacture.json; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verifyZeroInteractions; +import org.metafacture.framework.MetafactureException; +import org.metafacture.framework.StreamReceiver; import org.junit.Assert; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; -import org.metafacture.framework.MetafactureException; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -51,6 +49,9 @@ public final class JsonDecoderTest { private JsonDecoder jsonDecoder; + public JsonDecoderTest() { + } + @Before public void init() { jsonDecoder = new JsonDecoder(); @@ -61,7 +62,7 @@ public void init() { public void testShouldProcessEmptyStrings() { jsonDecoder.process(""); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } @Test @@ -77,7 +78,7 @@ public void testShouldProcessRecords() { "\"lit5\":null" + "}"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("lit1", "value 1"); ordered.verify(receiver).startEntity(" ent1"); @@ -111,7 +112,7 @@ public void testShouldProcessArrays() { "]" + "}"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).startEntity("arr1[]"); ordered.verify(receiver).literal("1", "val1"); @@ -124,16 +125,16 @@ public void testShouldProcessArrays() { ordered.verify(receiver).endEntity(); ordered.verify(receiver).startEntity("2"); ordered.verify(receiver).literal("lit3", "val3"); - ordered.verify(receiver, times(2)).endEntity(); + ordered.verify(receiver, Mockito.times(2)).endEntity(); ordered.verify(receiver).startEntity("arr3[]"); ordered.verify(receiver).startEntity("1[]"); ordered.verify(receiver).startEntity("1"); ordered.verify(receiver).literal("lit4", "val4"); - ordered.verify(receiver, times(2)).endEntity(); + ordered.verify(receiver, Mockito.times(2)).endEntity(); ordered.verify(receiver).startEntity("2[]"); ordered.verify(receiver).startEntity("1"); ordered.verify(receiver).literal("lit5", "val5"); - ordered.verify(receiver, times(3)).endEntity(); + ordered.verify(receiver, Mockito.times(3)).endEntity(); ordered.verify(receiver).endRecord(); } @@ -148,7 +149,7 @@ public void testShouldNotProcessBooleans() { "}" ); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("lit1", "false"); ordered.verify(receiver).literal("lit2", "true"); @@ -156,7 +157,7 @@ public void testShouldNotProcessBooleans() { ordered.verify(receiver).startEntity("1"); ordered.verify(receiver).literal("lit3", "true"); ordered.verify(receiver).literal("lit4", "false"); - ordered.verify(receiver, times(2)).endEntity(); + ordered.verify(receiver, Mockito.times(2)).endEntity(); ordered.verify(receiver).startEntity("arr2[]"); ordered.verify(receiver).literal("1", "false"); ordered.verify(receiver).literal("2", "true"); @@ -177,7 +178,7 @@ public void testShouldProcessBooleansIfEnabled() { "}" ); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("lit1~", "false"); ordered.verify(receiver).literal("lit2", "true"); @@ -185,7 +186,7 @@ public void testShouldProcessBooleansIfEnabled() { ordered.verify(receiver).startEntity("1"); ordered.verify(receiver).literal("lit3~", "true"); ordered.verify(receiver).literal("lit4", "false"); - ordered.verify(receiver, times(2)).endEntity(); + ordered.verify(receiver, Mockito.times(2)).endEntity(); ordered.verify(receiver).startEntity("arr2[]"); ordered.verify(receiver).literal("1~", "false"); ordered.verify(receiver).literal("2~", "true"); @@ -205,7 +206,7 @@ public void testShouldNotProcessNumbers() { "}" ); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("lit1", "23"); ordered.verify(receiver).literal("lit2", "4.2"); @@ -213,7 +214,7 @@ public void testShouldNotProcessNumbers() { ordered.verify(receiver).startEntity("1"); ordered.verify(receiver).literal("lit3", "4.2"); ordered.verify(receiver).literal("lit4", "23"); - ordered.verify(receiver, times(2)).endEntity(); + ordered.verify(receiver, Mockito.times(2)).endEntity(); ordered.verify(receiver).startEntity("arr2[]"); ordered.verify(receiver).literal("1", "23"); ordered.verify(receiver).literal("2", "4.2"); @@ -234,7 +235,7 @@ public void testShouldProcessNumbersIfEnabled() { "}" ); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("lit1#", "23"); ordered.verify(receiver).literal("lit2", "4.2"); @@ -242,7 +243,7 @@ public void testShouldProcessNumbersIfEnabled() { ordered.verify(receiver).startEntity("1"); ordered.verify(receiver).literal("lit3#", "4.2"); ordered.verify(receiver).literal("lit4", "23"); - ordered.verify(receiver, times(2)).endEntity(); + ordered.verify(receiver, Mockito.times(2)).endEntity(); ordered.verify(receiver).startEntity("arr2[]"); ordered.verify(receiver).literal("1#", "23"); ordered.verify(receiver).literal("2#", "4.2"); @@ -257,7 +258,7 @@ public void testShouldProcessConcatenatedRecords() { "{\"lit\": \"record 1\"}\n" + "{\"lit\": \"record 2\"}"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("lit", "record 1"); ordered.verify(receiver).endRecord(); @@ -273,7 +274,7 @@ public void testShouldProcessRecordsInArrayField() { "{\"data\":[" + "{\"lit\": \"record 1\"}," + "{\"lit\": \"record 2\"}" + "]}"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("lit", "record 1"); ordered.verify(receiver).endRecord(); @@ -289,7 +290,7 @@ public void testShouldProcessRecordsInArrayRoot() { "[" + "{\"lit\": \"record 1\"}," + "{\"lit\": \"record 2\"}" + "]"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("lit", "record 1"); ordered.verify(receiver).endRecord(); @@ -298,7 +299,7 @@ public void testShouldProcessRecordsInArrayRoot() { ordered.verify(receiver).endRecord(); } - @Test(expected=MetafactureException.class) + @Test(expected = MetafactureException.class) public void testRootArrayNoRecordPath() { jsonDecoder.process( "[" + "{\"lit\": \"record 1\"}," + @@ -310,7 +311,7 @@ public void testShouldProcessMultipleRecords() { jsonDecoder.process("{\"lit\": \"record 1\"}"); jsonDecoder.process("{\"lit\": \"record 2\"}"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("lit", "record 1"); ordered.verify(receiver).endRecord(); @@ -368,7 +369,7 @@ public void testShouldParseCommentsIfEnabled() { jsonDecoder.process("//{\"lit\":\"value\"}"); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } @Test @@ -388,7 +389,7 @@ public void testShouldParseInlineCommentsIfEnabled() { jsonDecoder.process("{\"lit\":/*comment*/\"value\"}"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("lit", "value"); ordered.verify(receiver).endRecord(); diff --git a/metafacture-json/src/test/java/org/metafacture/json/JsonEncoderTest.java b/metafacture-json/src/test/java/org/metafacture/json/JsonEncoderTest.java index b77eb3ca5..026669a8b 100644 --- a/metafacture-json/src/test/java/org/metafacture/json/JsonEncoderTest.java +++ b/metafacture-json/src/test/java/org/metafacture/json/JsonEncoderTest.java @@ -16,15 +16,14 @@ package org.metafacture.json; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verify; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -57,6 +56,9 @@ public final class JsonEncoderTest { @Mock private ObjectReceiver receiver; + public JsonEncoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -77,7 +79,7 @@ public void testShouldEncodeLiterals() { encoder.literal(LITERAL3, VALUE3); encoder.endRecord(); - verify(receiver).process(fixQuotes("{'L1':'V1','L2':'V2','L3':'V3'}")); + Mockito.verify(receiver).process(fixQuotes("{'L1':'V1','L2':'V2','L3':'V3'}")); } @Test @@ -93,7 +95,7 @@ public void testShouldEncodeEntities() { encoder.endEntity(); encoder.endRecord(); - verify(receiver).process(fixQuotes("{'En1':{'L1':'V1','L2':'V2'},'En2':{'L1':'V1','L2':'V2'}}")); + Mockito.verify(receiver).process(fixQuotes("{'En1':{'L1':'V1','L2':'V2'},'En2':{'L1':'V1','L2':'V2'}}")); } @Test @@ -106,7 +108,7 @@ public void testShouldEncodeNestedEntities() { encoder.endEntity(); encoder.endRecord(); - verify(receiver).process(fixQuotes("{'En1':{'En2':{'L1':'V1'}}}")); + Mockito.verify(receiver).process(fixQuotes("{'En1':{'En2':{'L1':'V1'}}}")); } @Test @@ -119,7 +121,7 @@ public void testShouldEncodeMarkedEntitiesAsList() { encoder.endEntity(); encoder.endRecord(); - verify(receiver).process(fixQuotes("{'Li1':['V1','V2','V3']}")); + Mockito.verify(receiver).process(fixQuotes("{'Li1':['V1','V2','V3']}")); } @Test @@ -137,7 +139,7 @@ public void testShouldEncodeEntitiesInLists() { encoder.endEntity(); encoder.endRecord(); - verify(receiver).process(fixQuotes("{'Li1':[{'L1':'V1','L2':'V2'},{'L3':'V3','L4':'V4'}]}")); + Mockito.verify(receiver).process(fixQuotes("{'Li1':[{'L1':'V1','L2':'V2'},{'L3':'V3','L4':'V4'}]}")); } @Test @@ -155,7 +157,7 @@ public void testShouldEncodeNestedLists() { encoder.endEntity(); encoder.endRecord(); - verify(receiver).process(fixQuotes("{'Li1':[['V1','V2'],['V3','V4']]}")); + Mockito.verify(receiver).process(fixQuotes("{'Li1':[['V1','V2'],['V3','V4']]}")); } @Test @@ -170,7 +172,7 @@ public void testShouldNotEncodeEntitiesWithDifferentMarkerAsList() { encoder.endEntity(); encoder.endRecord(); - verify(receiver).process(fixQuotes("{'Li1[]':{'L1':'V1','L2':'V2','L3':'V3'}}")); + Mockito.verify(receiver).process(fixQuotes("{'Li1[]':{'L1':'V1','L2':'V2','L3':'V3'}}")); } @Test @@ -186,7 +188,7 @@ public void testShouldEncodeMarkedEntitiesWithConfiguredMarkerAsList() { encoder.endEntity(); encoder.endRecord(); - verify(receiver).process(fixQuotes("{'Li1':['V1','V2','V3']}")); + Mockito.verify(receiver).process(fixQuotes("{'Li1':['V1','V2','V3']}")); } @Test @@ -207,7 +209,7 @@ public void testShouldNotEncodeBooleans() { encoder.endEntity(); encoder.endRecord(); - verify(receiver).process( + Mockito.verify(receiver).process( "{" + "\"lit1~\":\"false\"," + "\"lit2\":\"true\"," + @@ -237,7 +239,7 @@ public void testShouldEncodeBooleansIfEnabled() { encoder.endEntity(); encoder.endRecord(); - verify(receiver).process( + Mockito.verify(receiver).process( "{" + "\"lit1\":false," + "\"lit2\":\"true\"," + @@ -265,7 +267,7 @@ public void testShouldNotEncodeNumbers() { encoder.endEntity(); encoder.endRecord(); - verify(receiver).process( + Mockito.verify(receiver).process( "{" + "\"lit1#\":\"23\"," + "\"lit2\":\"4.2\"," + @@ -295,7 +297,7 @@ public void testShouldEncodeNumbersIfEnabled() { encoder.endEntity(); encoder.endRecord(); - verify(receiver).process( + Mockito.verify(receiver).process( "{" + "\"lit1\":23," + "\"lit2\":\"4.2\"," + @@ -312,7 +314,7 @@ public void testShouldOutputDuplicateNames() { encoder.literal(LITERAL1, VALUE2); encoder.endRecord(); - verify(receiver).process(fixQuotes("{'L1':'V1','L1':'V2'}")); + Mockito.verify(receiver).process(fixQuotes("{'L1':'V1','L1':'V2'}")); } @Test @@ -324,7 +326,7 @@ public void testIssue152ShouldNotPrefixOutputWithSpaces() { encoder.literal(LITERAL2, VALUE2); encoder.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(fixQuotes("{'L1':'V1'}")); ordered.verify(receiver).process(fixQuotes("{'L2':'V2'}")); } @@ -340,7 +342,7 @@ public void testShouldNotPrefixPrettyPrintedOutputWithSpaces() { encoder.literal(LITERAL2, VALUE2); encoder.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(useSystemSpecificLineSeparator(fixQuotes("{\n 'L1' : 'V1'\n}"))); ordered.verify(receiver).process(useSystemSpecificLineSeparator(fixQuotes("{\n 'L2' : 'V2'\n}"))); } diff --git a/metafacture-json/src/test/java/org/metafacture/json/JsonValidatorTest.java b/metafacture-json/src/test/java/org/metafacture/json/JsonValidatorTest.java index 35474b938..f6da6822b 100644 --- a/metafacture-json/src/test/java/org/metafacture/json/JsonValidatorTest.java +++ b/metafacture-json/src/test/java/org/metafacture/json/JsonValidatorTest.java @@ -13,42 +13,38 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.metafacture.json; -import static org.hamcrest.CoreMatchers.both; -import static org.hamcrest.CoreMatchers.containsString; -import static org.junit.Assert.assertThat; -import static com.github.tomakehurst.wiremock.client.WireMock.stubFor; -import static com.github.tomakehurst.wiremock.client.WireMock.request; +package org.metafacture.json; -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStreamReader; -import java.net.MalformedURLException; -import java.net.URL; -import java.nio.charset.StandardCharsets; -import java.util.Arrays; -import java.util.Collection; -import java.util.function.Function; -import java.util.stream.Collectors; +import org.metafacture.framework.MetafactureException; +import org.metafacture.framework.ObjectReceiver; +import com.github.tomakehurst.wiremock.client.WireMock; +import com.github.tomakehurst.wiremock.core.WireMockConfiguration; +import com.github.tomakehurst.wiremock.junit.WireMockRule; +import org.hamcrest.CoreMatchers; import org.junit.After; +import org.junit.Assert; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; -import org.metafacture.framework.MetafactureException; -import org.metafacture.framework.ObjectReceiver; import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.MockitoAnnotations; -import com.github.tomakehurst.wiremock.client.WireMock; -import com.github.tomakehurst.wiremock.core.WireMockConfiguration; -import com.github.tomakehurst.wiremock.junit.WireMockRule; - +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.net.MalformedURLException; +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Collection; +import java.util.function.Function; +import java.util.stream.Collectors; /** * Tests for {@link JsonValidator}. @@ -63,10 +59,14 @@ public final class JsonValidatorTest { private static final String ID_SCHEMA = "/schemas/id.json"; private static final String JSON_VALID = "{\"id\":\"http://example.org/\"}"; private static final String JSON_INVALID_MISSING_REQUIRED = "{}"; - private static final String JSON_INVALID_URI_FORMAT= "{\"id\":\"example.org/\"}"; + private static final String JSON_INVALID_URI_FORMAT = "{\"id\":\"example.org/\"}"; private static final String JSON_INVALID_DUPLICATE_KEY = "{\"id\":\"val\",\"id\":\"val\"}"; private static final String JSON_INVALID_SYNTAX_ERROR = "{\"id1\":\"val\",\"id2\":\"val\""; + @Rule + public WireMockRule wireMockRule = new WireMockRule(WireMockConfiguration.wireMockConfig() + .jettyAcceptors(Runtime.getRuntime().availableProcessors()).dynamicPort()); + private JsonValidator validator; @Mock @@ -74,36 +74,33 @@ public final class JsonValidatorTest { private InOrder inOrder; private Function schemaLocationGetter; - @Rule - public WireMockRule wireMockRule = new WireMockRule(WireMockConfiguration.wireMockConfig() - .jettyAcceptors(Runtime.getRuntime().availableProcessors()).dynamicPort()); + public JsonValidatorTest(final Function schemaLocationGetter) { + this.schemaLocationGetter = schemaLocationGetter; + } @Parameterized.Parameters(name = "{index}") public static Collection siteMaps() { - return Arrays.asList((Object[][]) (new Function[][] { // - // Pass the schema to each test as path on classpath, file url, and http url: - { (Object rule) -> MAIN_SCHEMA }, - { (Object rule) -> JsonValidatorTest.class.getResource(MAIN_SCHEMA).toString() }, - { (Object rule) -> ((WireMockRule) rule).baseUrl() + MAIN_SCHEMA } })); - } - - public JsonValidatorTest(Function schemaLocationGetter) { - this.schemaLocationGetter = schemaLocationGetter; + return Arrays.asList((Object[][]) (new Function[][] { + // Pass the schema to each test as path on classpath, file url, and http url: + {(Object rule) -> MAIN_SCHEMA}, + {(Object rule) -> JsonValidatorTest.class.getResource(MAIN_SCHEMA).toString()}, + {(Object rule) -> ((WireMockRule) rule).baseUrl() + MAIN_SCHEMA} + })); } @Before public void setup() throws IOException { MockitoAnnotations.initMocks(this); wireMock(MAIN_SCHEMA, ID_SCHEMA); - String schemaLocation = schemaLocationGetter.apply(wireMockRule); + final String schemaLocation = schemaLocationGetter.apply(wireMockRule); validator = new JsonValidator(schemaLocation); validator.setReceiver(receiver); inOrder = Mockito.inOrder(receiver); } private void wireMock(final String... schemaLocations) throws IOException { - for (String schemaLocation : schemaLocations) { - stubFor(request("GET", WireMock.urlEqualTo(schemaLocation)).willReturn( + for (final String schemaLocation : schemaLocations) { + WireMock.stubFor(WireMock.request("GET", WireMock.urlEqualTo(schemaLocation)).willReturn( WireMock.ok().withBody(readToString(getClass().getResource(schemaLocation))) .withHeader("Content-type", "application/json"))); } @@ -117,7 +114,7 @@ private String readToString(final URL url) throws IOException { @Test public void callWireMockSchema() throws MalformedURLException, IOException { final String schemaContent = readToString(new URL(wireMockRule.baseUrl() + MAIN_SCHEMA)); - assertThat(schemaContent, both(containsString("$schema")).and(containsString("$ref"))); + Assert.assertThat(schemaContent, CoreMatchers.both(CoreMatchers.containsString("$schema")).and(CoreMatchers.containsString("$ref"))); } @Test diff --git a/metafacture-linkeddata/src/test/java/org/metafacture/linkeddata/OreAggregationAdderTest.java b/metafacture-linkeddata/src/test/java/org/metafacture/linkeddata/OreAggregationAdderTest.java index 6626ca4b3..d22c583b9 100644 --- a/metafacture-linkeddata/src/test/java/org/metafacture/linkeddata/OreAggregationAdderTest.java +++ b/metafacture-linkeddata/src/test/java/org/metafacture/linkeddata/OreAggregationAdderTest.java @@ -16,16 +16,15 @@ package org.metafacture.linkeddata; -import static org.mockito.Mockito.inOrder; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link OreAggregationAdder} * @@ -40,6 +39,9 @@ public final class OreAggregationAdderTest { private OreAggregationAdder oreAggregationAdder; + public OreAggregationAdderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -58,7 +60,7 @@ public void shouldAddWebResource() { oreAggregationAdder.endEntity(); oreAggregationAdder.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).startEntity("edm:WebResource"); ordered.verify(receiver).literal("~rdf:about", "hawaii"); diff --git a/metafacture-mangling/src/test/java/org/metafacture/mangling/DuplicateObjectFilterTest.java b/metafacture-mangling/src/test/java/org/metafacture/mangling/DuplicateObjectFilterTest.java index c5a1b9ab5..2cfd1b8fb 100644 --- a/metafacture-mangling/src/test/java/org/metafacture/mangling/DuplicateObjectFilterTest.java +++ b/metafacture-mangling/src/test/java/org/metafacture/mangling/DuplicateObjectFilterTest.java @@ -14,20 +14,15 @@ * limitations under the License. */ -/** - * - */ - package org.metafacture.mangling; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -46,6 +41,9 @@ public final class DuplicateObjectFilterTest { @Mock private ObjectReceiver receiver; + public DuplicateObjectFilterTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -64,9 +62,9 @@ public void testShouldEliminateDuplicateObjects() { duplicateObjectFilter.process(OBJECT1); duplicateObjectFilter.process(OBJECT2); - verify(receiver).process(OBJECT1); - verify(receiver).process(OBJECT2); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(OBJECT1); + Mockito.verify(receiver).process(OBJECT2); + Mockito.verifyNoMoreInteractions(receiver); } } diff --git a/metafacture-mangling/src/test/java/org/metafacture/mangling/EntityPathTrackerTest.java b/metafacture-mangling/src/test/java/org/metafacture/mangling/EntityPathTrackerTest.java index 1c4a5bff9..ed25204a8 100644 --- a/metafacture-mangling/src/test/java/org/metafacture/mangling/EntityPathTrackerTest.java +++ b/metafacture-mangling/src/test/java/org/metafacture/mangling/EntityPathTrackerTest.java @@ -16,10 +16,7 @@ package org.metafacture.mangling; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - +import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -33,115 +30,118 @@ public class EntityPathTrackerTest { private EntityPathTracker pathTracker; + public EntityPathTrackerTest() { + } + @Before public void initSystemUnderTest() { pathTracker = new EntityPathTracker(); } @Test - public void getCurrentPath_shouldReturnEmptyPathIfProcessingHasNotStarted() { - assertTrue(pathTracker.getCurrentPath().isEmpty()); + public void getCurrentPathShouldReturnEmptyPathIfProcessingHasNotStarted() { + Assert.assertTrue(pathTracker.getCurrentPath().isEmpty()); } @Test - public void getCurrentPath_shouldReturnEmptyPathIfNotInRecord() { + public void getCurrentPathShouldReturnEmptyPathIfNotInRecord() { pathTracker.startRecord("1"); pathTracker.endRecord(); - assertTrue(pathTracker.getCurrentPath().isEmpty()); + Assert.assertTrue(pathTracker.getCurrentPath().isEmpty()); } @Test - public void getCurrentPath_shouldReturnPathToCurrentEntity() { + public void getCurrentPathShouldReturnPathToCurrentEntity() { pathTracker.startRecord("1"); - assertEquals("", pathTracker.getCurrentPath()); + Assert.assertEquals("", pathTracker.getCurrentPath()); pathTracker.startEntity("granny"); - assertEquals("granny", pathTracker.getCurrentPath()); + Assert.assertEquals("granny", pathTracker.getCurrentPath()); pathTracker.startEntity("mommy"); - assertEquals("granny.mommy", pathTracker.getCurrentPath()); + Assert.assertEquals("granny.mommy", pathTracker.getCurrentPath()); pathTracker.startEntity("me"); - assertEquals("granny.mommy.me", pathTracker.getCurrentPath()); + Assert.assertEquals("granny.mommy.me", pathTracker.getCurrentPath()); pathTracker.endEntity(); - assertEquals("granny.mommy", pathTracker.getCurrentPath()); + Assert.assertEquals("granny.mommy", pathTracker.getCurrentPath()); pathTracker.startEntity("my-sister"); - assertEquals("granny.mommy.my-sister", pathTracker.getCurrentPath()); + Assert.assertEquals("granny.mommy.my-sister", pathTracker.getCurrentPath()); pathTracker.endEntity(); - assertEquals("granny.mommy", pathTracker.getCurrentPath()); + Assert.assertEquals("granny.mommy", pathTracker.getCurrentPath()); pathTracker.endEntity(); - assertEquals("granny", pathTracker.getCurrentPath()); + Assert.assertEquals("granny", pathTracker.getCurrentPath()); pathTracker.endEntity(); - assertEquals("", pathTracker.getCurrentPath()); + Assert.assertEquals("", pathTracker.getCurrentPath()); } @Test - public void startRecord_shouldResetPath() { + public void startRecordShouldResetPath() { pathTracker.startRecord("1"); pathTracker.startEntity("entity"); - assertEquals("entity", pathTracker.getCurrentPath()); + Assert.assertEquals("entity", pathTracker.getCurrentPath()); pathTracker.startRecord("2"); - assertTrue(pathTracker.getCurrentPath().isEmpty()); + Assert.assertTrue(pathTracker.getCurrentPath().isEmpty()); } @Test - public void resetStream_shouldResetPath() { + public void resetStreamShouldResetPath() { pathTracker.startRecord("1"); pathTracker.startEntity("entity"); - assertEquals("entity", pathTracker.getCurrentPath()); + Assert.assertEquals("entity", pathTracker.getCurrentPath()); pathTracker.resetStream(); - assertTrue(pathTracker.getCurrentPath().isEmpty()); + Assert.assertTrue(pathTracker.getCurrentPath().isEmpty()); } @Test - public void closeStream_shouldResetPath() { + public void closeStreamShouldResetPath() { pathTracker.startRecord("1"); pathTracker.startEntity("entity"); - assertEquals("entity", pathTracker.getCurrentPath()); + Assert.assertEquals("entity", pathTracker.getCurrentPath()); pathTracker.closeStream(); - assertTrue(pathTracker.getCurrentPath().isEmpty()); + Assert.assertTrue(pathTracker.getCurrentPath().isEmpty()); } @Test - public void getCurrentPathWith_shouldAppendLiteralNameToPath() { + public void getCurrentPathWithShouldAppendLiteralNameToPath() { pathTracker.startRecord("1"); pathTracker.startEntity("entity"); - assertEquals("entity.literal", pathTracker.getCurrentPathWith("literal")); + Assert.assertEquals("entity.literal", pathTracker.getCurrentPathWith("literal")); } @Test - public void getCurrentPathWith_shouldReturnOnlyLiteralNameIfNotInEntity() { + public void getCurrentPathWithShouldReturnOnlyLiteralNameIfNotInEntity() { pathTracker.startRecord("1"); - assertEquals("literal", pathTracker.getCurrentPathWith("literal")); + Assert.assertEquals("literal", pathTracker.getCurrentPathWith("literal")); } @Test - public void getCurrentEntityName_shouldReturnNullIfProcessingNotStarted() { - assertNull(pathTracker.getCurrentEntityName()); + public void getCurrentEntityNameShouldReturnNullIfProcessingNotStarted() { + Assert.assertNull(pathTracker.getCurrentEntityName()); } @Test - public void getCurrentEntityName_shouldReturnNullIfNotInRecord() { + public void getCurrentEntityNameShouldReturnNullIfNotInRecord() { pathTracker.startRecord("1"); pathTracker.endRecord(); - assertNull(pathTracker.getCurrentEntityName()); + Assert.assertNull(pathTracker.getCurrentEntityName()); } @Test - public void getCurrentEntityName_shouldReturnNameOfCurrentEntity() { + public void getCurrentEntityNameShouldReturnNameOfCurrentEntity() { pathTracker.startRecord("1"); - assertNull(pathTracker.getCurrentEntityName()); + Assert.assertNull(pathTracker.getCurrentEntityName()); pathTracker.startEntity("grandad"); - assertEquals("grandad", pathTracker.getCurrentEntityName()); + Assert.assertEquals("grandad", pathTracker.getCurrentEntityName()); pathTracker.startEntity("daddy"); - assertEquals("daddy", pathTracker.getCurrentEntityName()); + Assert.assertEquals("daddy", pathTracker.getCurrentEntityName()); pathTracker.endEntity(); - assertEquals("grandad", pathTracker.getCurrentEntityName()); + Assert.assertEquals("grandad", pathTracker.getCurrentEntityName()); pathTracker.endEntity(); - assertNull(pathTracker.getCurrentEntityName()); + Assert.assertNull(pathTracker.getCurrentEntityName()); pathTracker.endRecord(); } diff --git a/metafacture-mangling/src/test/java/org/metafacture/mangling/LiteralToObjectTest.java b/metafacture-mangling/src/test/java/org/metafacture/mangling/LiteralToObjectTest.java index 7780413b7..f93edca0a 100644 --- a/metafacture-mangling/src/test/java/org/metafacture/mangling/LiteralToObjectTest.java +++ b/metafacture-mangling/src/test/java/org/metafacture/mangling/LiteralToObjectTest.java @@ -16,17 +16,15 @@ package org.metafacture.mangling; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link LiteralToObject}. * @@ -46,6 +44,9 @@ public final class LiteralToObjectTest { private LiteralToObject literalToObject; + public LiteralToObjectTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -68,8 +69,8 @@ public void shouldEmitLiteralValueAsObject() { literalToObject.literal("L2", "V2"); literalToObject.endRecord(); - verify(receiver).process(LITERAL_VALUE1); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(LITERAL_VALUE1); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -82,8 +83,8 @@ public void shouldEmitValueOfNestedLiteralsAsObject() { literalToObject.endEntity(); literalToObject.endRecord(); - verify(receiver).process(LITERAL_VALUE1); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(LITERAL_VALUE1); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -96,9 +97,9 @@ public void shouldUseRegExForMatchingLiteralNames() { literalToObject.literal("ex_2", LITERAL_VALUE2); literalToObject.endRecord(); - verify(receiver).process(LITERAL_VALUE1); - verify(receiver).process(LITERAL_VALUE2); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(LITERAL_VALUE1); + Mockito.verify(receiver).process(LITERAL_VALUE2); + Mockito.verifyNoMoreInteractions(receiver); } } diff --git a/metafacture-mangling/src/test/java/org/metafacture/mangling/NullFilterTest.java b/metafacture-mangling/src/test/java/org/metafacture/mangling/NullFilterTest.java index 1d9d64084..605bf2a31 100644 --- a/metafacture-mangling/src/test/java/org/metafacture/mangling/NullFilterTest.java +++ b/metafacture-mangling/src/test/java/org/metafacture/mangling/NullFilterTest.java @@ -16,15 +16,14 @@ package org.metafacture.mangling; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -45,6 +44,9 @@ public final class NullFilterTest { @Mock private StreamReceiver receiver; + public NullFilterTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -65,14 +67,14 @@ public void shouldForwardAllEvents() { nullFilter.endEntity(); nullFilter.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).startEntity(ENTITY_NAME); ordered.verify(receiver).literal(LITERAL_NAME, LITERAL_VALUE); ordered.verify(receiver).endEntity(); ordered.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -84,14 +86,14 @@ public void shouldDiscardNullValues() { nullFilter.endEntity(); nullFilter.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).startEntity(ENTITY_NAME); ordered.verify(receiver).literal(LITERAL_NAME, LITERAL_VALUE); ordered.verify(receiver).endEntity(); ordered.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -105,7 +107,7 @@ public void shouldReplaceNullValues() { nullFilter.endEntity(); nullFilter.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).startEntity(ENTITY_NAME); ordered.verify(receiver).literal(LITERAL_NAME, LITERAL_VALUE); @@ -113,7 +115,7 @@ public void shouldReplaceNullValues() { ordered.verify(receiver).endEntity(); ordered.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } } diff --git a/metafacture-mangling/src/test/java/org/metafacture/mangling/ObjectToLiteralTest.java b/metafacture-mangling/src/test/java/org/metafacture/mangling/ObjectToLiteralTest.java index 01ce9a0a0..f44524c02 100644 --- a/metafacture-mangling/src/test/java/org/metafacture/mangling/ObjectToLiteralTest.java +++ b/metafacture-mangling/src/test/java/org/metafacture/mangling/ObjectToLiteralTest.java @@ -16,17 +16,16 @@ package org.metafacture.mangling; -import static org.mockito.Mockito.inOrder; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link ObjectToLiteral}. * @@ -43,6 +42,9 @@ public final class ObjectToLiteralTest { @Mock private StreamReceiver receiver; + public ObjectToLiteralTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -60,7 +62,7 @@ public void testShouldUseObjectAsLiteralValue() { objectToLiteral.process(OBJ_DATA); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).literal(ObjectToLiteral.DEFAULT_LITERAL_NAME, OBJ_DATA); ordered.verify(receiver).endRecord(); @@ -72,7 +74,7 @@ public void testShouldUseCustomLiteralName() { objectToLiteral.process(OBJ_DATA); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).literal(LITERAL_NAME, OBJ_DATA); ordered.verify(receiver).endRecord(); @@ -85,7 +87,7 @@ public void testShouldSetRecordIds() { objectToLiteral.process(OBJ_DATA); objectToLiteral.process(OBJ_DATA); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("Record 1"); ordered.verify(receiver).literal(ObjectToLiteral.DEFAULT_LITERAL_NAME, OBJ_DATA); ordered.verify(receiver).endRecord(); diff --git a/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordIdChangerTest.java b/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordIdChangerTest.java index ae805cb8f..c664f6941 100644 --- a/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordIdChangerTest.java +++ b/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordIdChangerTest.java @@ -16,19 +16,17 @@ package org.metafacture.mangling; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.StandardEventNames; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StandardEventNames; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link RecordIdChanger}. * @@ -50,6 +48,9 @@ public final class RecordIdChangerTest { @Mock private StreamReceiver receiver; + public RecordIdChangerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -72,7 +73,7 @@ public void testShouldChangeIdsOfRecords() { recordIdChanger.literal(StandardEventNames.ID, NEW_RECORD_ID2); recordIdChanger.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(NEW_RECORD_ID1); ordered.verify(receiver).endRecord(); @@ -89,7 +90,7 @@ public void testShouldKeepRecordsWithoutIdLiteral() { recordIdChanger.literal(StandardEventNames.ID, NEW_RECORD_ID2); recordIdChanger.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(OLD_RECORD_ID1); ordered.verify(receiver).literal(LITERAL_NAME, LITERAL_VALUE); ordered.verify(receiver).endRecord(); @@ -108,10 +109,10 @@ public void testShouldRemoveRecordsWithoutIdLiteral() { recordIdChanger.literal(StandardEventNames.ID, NEW_RECORD_ID2); recordIdChanger.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(NEW_RECORD_ID2); ordered.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -122,7 +123,7 @@ public void testShouldNotUseNestedIdLiteralAsNewId() { recordIdChanger.endEntity(); recordIdChanger.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(OLD_RECORD_ID1); ordered.verify(receiver).startEntity(ENTITY); ordered.verify(receiver).literal(StandardEventNames.ID, NEW_RECORD_ID1); @@ -140,7 +141,7 @@ public void testShouldAcceptFullPathAsNewId() { recordIdChanger.endEntity(); recordIdChanger.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(NEW_RECORD_ID1); ordered.verify(receiver).startEntity(ENTITY); ordered.verify(receiver).endEntity(); @@ -155,10 +156,10 @@ public void testShouldNotKeepIdLiteralByDefault() { recordIdChanger.literal(StandardEventNames.ID, NEW_RECORD_ID1); recordIdChanger.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(NEW_RECORD_ID1); ordered.verify(receiver).endRecord(); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -170,7 +171,7 @@ public void testShouldKeepIdLiteralIfConfigured() { recordIdChanger.literal(StandardEventNames.ID, NEW_RECORD_ID1); recordIdChanger.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(NEW_RECORD_ID1); ordered.verify(receiver).literal(StandardEventNames.ID, NEW_RECORD_ID1); ordered.verify(receiver).endRecord(); @@ -183,7 +184,7 @@ public void testShouldUseLastIdLiteralAsNewId() { recordIdChanger.literal(StandardEventNames.ID, NEW_RECORD_ID2); recordIdChanger.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(NEW_RECORD_ID2); ordered.verify(receiver).endRecord(); } diff --git a/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordPathFilterTest.java b/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordPathFilterTest.java index f019dc4c2..269032586 100644 --- a/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordPathFilterTest.java +++ b/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordPathFilterTest.java @@ -16,9 +16,10 @@ package org.metafacture.mangling; +import org.metafacture.framework.StreamReceiver; + import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -34,6 +35,9 @@ public final class RecordPathFilterTest { @Mock private StreamReceiver receiver; + public RecordPathFilterTest() { + } + @Test public void shouldFilterRootPath() { assertFilter( diff --git a/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordToEntityTest.java b/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordToEntityTest.java index 426f50441..ed8d4d3ff 100644 --- a/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordToEntityTest.java +++ b/metafacture-mangling/src/test/java/org/metafacture/mangling/RecordToEntityTest.java @@ -16,14 +16,13 @@ package org.metafacture.mangling; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.times; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -39,6 +38,9 @@ public class RecordToEntityTest { private RecordToEntity recordToEntity; + public RecordToEntityTest() { + } + @Before public void init() { MockitoAnnotations.initMocks(this); @@ -55,38 +57,38 @@ public void shouldReplaceRecordEventsWithEntityEvents() { recordToEntity.endRecord(); recordToEntity.closeStream(); - InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver) .startEntity(RecordToEntity.DEFAULT_ENTITY_NAME); ordered.verify(receiver).literal("literal", "value"); ordered.verify(receiver).startEntity("entity"); - ordered.verify(receiver, times(2)).endEntity(); + ordered.verify(receiver, Mockito.times(2)).endEntity(); ordered.verify(receiver).closeStream(); } @Test - public void setEntityName_shouldChangeNameOfGeneratedEntity() { + public void setEntityNameShouldChangeNameOfGeneratedEntity() { recordToEntity.setEntityName("container"); recordToEntity.startRecord("1"); recordToEntity.endRecord(); recordToEntity.closeStream(); - InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startEntity("container"); ordered.verify(receiver).endEntity(); ordered.verify(receiver).closeStream(); } @Test - public void setIdLiteralName_shouldEnableOutputOfRecordIdAsLiteral() { + public void setIdLiteralNameShouldEnableOutputOfRecordIdAsLiteral() { recordToEntity.setIdLiteralName("record-id"); recordToEntity.startRecord("1"); receiver.endRecord(); receiver.closeStream(); - InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver) .startEntity(RecordToEntity.DEFAULT_ENTITY_NAME); ordered.verify(receiver).literal("record-id", "1"); diff --git a/metafacture-mangling/src/test/java/org/metafacture/mangling/StreamEventDiscarderTest.java b/metafacture-mangling/src/test/java/org/metafacture/mangling/StreamEventDiscarderTest.java index 69b4db53a..faef7e430 100644 --- a/metafacture-mangling/src/test/java/org/metafacture/mangling/StreamEventDiscarderTest.java +++ b/metafacture-mangling/src/test/java/org/metafacture/mangling/StreamEventDiscarderTest.java @@ -16,20 +16,18 @@ package org.metafacture.mangling; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; - -import java.util.EnumSet; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.mangling.StreamEventDiscarder.EventType; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; -import org.metafacture.mangling.StreamEventDiscarder.EventType; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.util.EnumSet; + /** * Tests for class {@link StreamEventDiscarder}. * @@ -43,6 +41,9 @@ public class StreamEventDiscarderTest { private StreamEventDiscarder discarder; + public StreamEventDiscarderTest() { + } + @Before public void init() { MockitoAnnotations.initMocks(this); @@ -60,7 +61,7 @@ public void shouldPassOnAllEventsByDefault() { discarder.resetStream(); discarder.closeStream(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).startEntity("entity"); ordered.verify(receiver).endEntity(); @@ -71,7 +72,7 @@ public void shouldPassOnAllEventsByDefault() { } @Test - public void setDiscardedEvents_shouldDiscardAllEventsIfAllFlagsAreSet() { + public void setDiscardedEventsShouldDiscardAllEventsIfAllFlagsAreSet() { discarder.setDiscardedEvents(EnumSet.allOf(EventType.class)); discarder.startRecord("1"); @@ -82,22 +83,22 @@ public void setDiscardedEvents_shouldDiscardAllEventsIfAllFlagsAreSet() { discarder.resetStream(); discarder.closeStream(); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } @Test - public void setDiscardedEvents_shouldWorkOnCopyOfThePassedEnumSet() { + public void setDiscardedEventsShouldWorkOnCopyOfThePassedEnumSet() { final EnumSet eventTypes = EnumSet.noneOf(EventType.class); discarder.setDiscardedEvents(eventTypes); eventTypes.add(EventType.RECORD); discarder.startRecord("1"); - verify(receiver).startRecord("1"); + Mockito.verify(receiver).startRecord("1"); } @Test - public void setDiscardRecordEvents_shouldDiscardStartRecordAndEndRecordIfTrue() { + public void setDiscardRecordEventsShouldDiscardStartRecordAndEndRecordIfTrue() { discarder.setDiscardRecordEvents(true); discarder.startRecord("1"); @@ -108,7 +109,7 @@ public void setDiscardRecordEvents_shouldDiscardStartRecordAndEndRecordIfTrue() discarder.resetStream(); discarder.closeStream(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startEntity("entity"); ordered.verify(receiver).endEntity(); ordered.verify(receiver).literal("literal", "value"); @@ -117,7 +118,7 @@ public void setDiscardRecordEvents_shouldDiscardStartRecordAndEndRecordIfTrue() } @Test - public void setDiscardEntityEvents_shouldDiscardStartEntityAndEndEntityIfTrue() { + public void setDiscardEntityEventsShouldDiscardStartEntityAndEndEntityIfTrue() { discarder.setDiscardEntityEvents(true); discarder.startRecord("1"); @@ -128,7 +129,7 @@ public void setDiscardEntityEvents_shouldDiscardStartEntityAndEndEntityIfTrue() discarder.resetStream(); discarder.closeStream(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("literal", "value"); ordered.verify(receiver).endRecord(); @@ -137,7 +138,7 @@ public void setDiscardEntityEvents_shouldDiscardStartEntityAndEndEntityIfTrue() } @Test - public void setDiscardLiteralEvents_shouldDiscardLiteralIfTrue() { + public void setDiscardLiteralEventsShouldDiscardLiteralIfTrue() { discarder.setDiscardLiteralEvents(true); discarder.startRecord("1"); @@ -148,7 +149,7 @@ public void setDiscardLiteralEvents_shouldDiscardLiteralIfTrue() { discarder.resetStream(); discarder.closeStream(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).startEntity("entity"); ordered.verify(receiver).endEntity(); @@ -158,7 +159,7 @@ public void setDiscardLiteralEvents_shouldDiscardLiteralIfTrue() { } @Test - public void setDiscardLifecycleEvents_shouldDiscardResetStreamAndCloseStreamIfTrue() { + public void setDiscardLifecycleEventsShouldDiscardResetStreamAndCloseStreamIfTrue() { discarder.setDiscardLifecycleEvents(true); discarder.startRecord("1"); @@ -169,7 +170,7 @@ public void setDiscardLifecycleEvents_shouldDiscardResetStreamAndCloseStreamIfTr discarder.resetStream(); discarder.closeStream(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).startEntity("entity"); ordered.verify(receiver).endEntity(); @@ -178,13 +179,13 @@ public void setDiscardLifecycleEvents_shouldDiscardResetStreamAndCloseStreamIfTr } @Test - public void getDiscardedEvents_shouldReturnCopyOfTheInternalEnumSet() { + public void getDiscardedEventsShouldReturnCopyOfTheInternalEnumSet() { final EnumSet discardedEvents = discarder.getDiscardedEvents(); discardedEvents.add(EventType.RECORD); discarder.startRecord("1"); - verify(receiver).startRecord("1"); + Mockito.verify(receiver).startRecord("1"); } } diff --git a/metafacture-mangling/src/test/java/org/metafacture/mangling/StreamFlattenerTest.java b/metafacture-mangling/src/test/java/org/metafacture/mangling/StreamFlattenerTest.java index c606d64bb..ff45141cd 100644 --- a/metafacture-mangling/src/test/java/org/metafacture/mangling/StreamFlattenerTest.java +++ b/metafacture-mangling/src/test/java/org/metafacture/mangling/StreamFlattenerTest.java @@ -16,15 +16,14 @@ package org.metafacture.mangling; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.mockito.Mockito.inOrder; +import org.metafacture.framework.StreamReceiver; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -40,6 +39,9 @@ public class StreamFlattenerTest { private StreamFlattener flattener; + public StreamFlattenerTest() { + } + @Before public void init() { MockitoAnnotations.initMocks(this); @@ -60,7 +62,7 @@ public void shouldFlattenEntitiesAndUseEntityPathForLiteralNames() { flattener.endRecord(); flattener.closeStream(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("granny.me", "value1"); ordered.verify(receiver).literal("granny.mommy.myself", "value2"); @@ -70,59 +72,59 @@ public void shouldFlattenEntitiesAndUseEntityPathForLiteralNames() { } @Test - public void getCurrentPath_shouldReturnPathToCurrentEntity() { + public void getCurrentPathShouldReturnPathToCurrentEntity() { flattener.startRecord("1"); - assertEquals("", flattener.getCurrentPath()); + Assert.assertEquals("", flattener.getCurrentPath()); flattener.startEntity("granny"); - assertEquals("granny", flattener.getCurrentPath()); + Assert.assertEquals("granny", flattener.getCurrentPath()); flattener.literal("me", "value1"); - assertEquals("granny", flattener.getCurrentPath()); + Assert.assertEquals("granny", flattener.getCurrentPath()); flattener.startEntity("mommy"); - assertEquals("granny.mommy", flattener.getCurrentPath()); + Assert.assertEquals("granny.mommy", flattener.getCurrentPath()); flattener.literal("myself", "value2"); - assertEquals("granny.mommy", flattener.getCurrentPath()); + Assert.assertEquals("granny.mommy", flattener.getCurrentPath()); flattener.endEntity(); - assertEquals("granny", flattener.getCurrentPath()); + Assert.assertEquals("granny", flattener.getCurrentPath()); flattener.endEntity(); - assertEquals("", flattener.getCurrentPath()); + Assert.assertEquals("", flattener.getCurrentPath()); flattener.literal("andI", "value3"); - assertEquals("", flattener.getCurrentPath()); + Assert.assertEquals("", flattener.getCurrentPath()); flattener.endRecord(); - assertEquals("", flattener.getCurrentPath()); + Assert.assertEquals("", flattener.getCurrentPath()); flattener.closeStream(); } @Test - public void getCurrentEntityName_shouldReturnNameOfCurrentEntity() { + public void getCurrentEntityNameShouldReturnNameOfCurrentEntity() { flattener.startRecord("1"); - assertNull(flattener.getCurrentEntityName()); + Assert.assertNull(flattener.getCurrentEntityName()); flattener.startEntity("granny"); - assertEquals("granny", flattener.getCurrentEntityName()); + Assert.assertEquals("granny", flattener.getCurrentEntityName()); flattener.literal("me", "value1"); - assertEquals("granny", flattener.getCurrentEntityName()); + Assert.assertEquals("granny", flattener.getCurrentEntityName()); flattener.startEntity("mommy"); - assertEquals("mommy", flattener.getCurrentEntityName()); + Assert.assertEquals("mommy", flattener.getCurrentEntityName()); flattener.literal("myself", "value2"); - assertEquals("mommy", flattener.getCurrentEntityName()); + Assert.assertEquals("mommy", flattener.getCurrentEntityName()); flattener.endEntity(); - assertEquals("granny", flattener.getCurrentEntityName()); + Assert.assertEquals("granny", flattener.getCurrentEntityName()); flattener.endEntity(); - assertNull(flattener.getCurrentEntityName()); + Assert.assertNull(flattener.getCurrentEntityName()); flattener.literal("andI", "value3"); - assertNull(flattener.getCurrentEntityName()); + Assert.assertNull(flattener.getCurrentEntityName()); flattener.endRecord(); - assertNull(flattener.getCurrentEntityName()); + Assert.assertNull(flattener.getCurrentEntityName()); flattener.closeStream(); } @Test - public void setEntityMarker_shouldChangeMarkerBetweenEntities() { + public void setEntityMarkerShouldChangeMarkerBetweenEntities() { flattener.setEntityMarker("-"); flattener.startRecord("1"); flattener.startEntity("granny"); flattener.startEntity("mommy"); - assertEquals("granny-mommy", flattener.getCurrentPath()); + Assert.assertEquals("granny-mommy", flattener.getCurrentPath()); } } diff --git a/metafacture-mangling/src/test/java/org/metafacture/mangling/TestHelpers.java b/metafacture-mangling/src/test/java/org/metafacture/mangling/TestHelpers.java index c5acf510e..72ff2c563 100644 --- a/metafacture-mangling/src/test/java/org/metafacture/mangling/TestHelpers.java +++ b/metafacture-mangling/src/test/java/org/metafacture/mangling/TestHelpers.java @@ -17,6 +17,7 @@ package org.metafacture.mangling; import org.metafacture.framework.StreamReceiver; + import org.mockito.InOrder; import org.mockito.Mockito; import org.mockito.exceptions.base.MockitoAssertionError; @@ -28,6 +29,9 @@ public final class TestHelpers { + private TestHelpers() { + } + public static void assertProcess(final StreamReceiver receiver, final Runnable process, final Consumer> out) { assertProcess(receiver, process, (s, f) -> out.accept(s)); } diff --git a/metafacture-monitoring/src/test/java/org/metafacture/monitoring/ObjectTimerTest.java b/metafacture-monitoring/src/test/java/org/metafacture/monitoring/ObjectTimerTest.java index 49cb1c46b..66534db45 100644 --- a/metafacture-monitoring/src/test/java/org/metafacture/monitoring/ObjectTimerTest.java +++ b/metafacture-monitoring/src/test/java/org/metafacture/monitoring/ObjectTimerTest.java @@ -16,10 +16,10 @@ package org.metafacture.monitoring; -import org.junit.Before; -import org.junit.Test; import org.metafacture.framework.helpers.DefaultObjectReceiver; +import org.junit.Before; +import org.junit.Test; /** * Tests for class {@link ObjectTimer}. @@ -29,15 +29,47 @@ */ public final class ObjectTimerTest { + private ObjectTimer objectTimer; + private BenchmarkedModule benchmarkedModule; + + public ObjectTimerTest() { + } + + @Before + public void setup() { + objectTimer = new ObjectTimer(); + benchmarkedModule = new BenchmarkedModule(); + objectTimer.setReceiver(benchmarkedModule); + } + + @Test + public void testShouldMeasureExecutionTime() { + + objectTimer.process(""); + objectTimer.process(""); + objectTimer.process(""); + objectTimer.process(""); + objectTimer.closeStream(); + } + + @Test + public void testShouldHandleImmediateCloseStreamWithNoProcessing() { + + objectTimer.closeStream(); + } + /** * A module with a slow process method. */ private static final class BenchmarkedModule extends DefaultObjectReceiver { - private static final long[] DURATIONS = { 150L, 20L, 30L, 202L }; + private static final long[] DURATIONS = {150L, 20L, 30L, 202L}; private int i; + private BenchmarkedModule() { + } + @Override public void process(final String obj) { try { @@ -59,30 +91,4 @@ private long getDuration() { } - private ObjectTimer objectTimer; - private BenchmarkedModule benchmarkedModule; - - @Before - public void setup() { - objectTimer = new ObjectTimer(); - benchmarkedModule = new BenchmarkedModule(); - objectTimer.setReceiver(benchmarkedModule); - } - - @Test - public void testShouldMeasureExecutionTime() { - - objectTimer.process(""); - objectTimer.process(""); - objectTimer.process(""); - objectTimer.process(""); - objectTimer.closeStream(); - } - - @Test - public void testShouldHandleImmediateCloseStreamWithNoProcessing() { - - objectTimer.closeStream(); - } - } diff --git a/metafacture-monitoring/src/test/java/org/metafacture/monitoring/StreamLoggerTest.java b/metafacture-monitoring/src/test/java/org/metafacture/monitoring/StreamLoggerTest.java index a885dc38d..d49edd9ba 100644 --- a/metafacture-monitoring/src/test/java/org/metafacture/monitoring/StreamLoggerTest.java +++ b/metafacture-monitoring/src/test/java/org/metafacture/monitoring/StreamLoggerTest.java @@ -16,16 +16,15 @@ package org.metafacture.monitoring; -import static org.mockito.Mockito.inOrder; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link StreamLogger}. * @@ -40,6 +39,9 @@ public final class StreamLoggerTest { private StreamLogger logger; + public StreamLoggerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -57,7 +59,7 @@ public void shouldForwardAllReceivedEvents() { logger.resetStream(); logger.closeStream(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).startEntity("entity"); ordered.verify(receiver).literal("literal", "value"); diff --git a/metafacture-monitoring/src/test/java/org/metafacture/monitoring/StreamTimerTest.java b/metafacture-monitoring/src/test/java/org/metafacture/monitoring/StreamTimerTest.java index 1f23d7ec8..b802692ed 100644 --- a/metafacture-monitoring/src/test/java/org/metafacture/monitoring/StreamTimerTest.java +++ b/metafacture-monitoring/src/test/java/org/metafacture/monitoring/StreamTimerTest.java @@ -16,10 +16,10 @@ package org.metafacture.monitoring; -import org.junit.Before; -import org.junit.Test; import org.metafacture.framework.helpers.DefaultStreamReceiver; +import org.junit.Before; +import org.junit.Test; /** * Tests for class {@link ObjectTimer}. @@ -29,39 +29,12 @@ */ public final class StreamTimerTest { - /** - * A module with a slow process method. - */ - private static final class BenchmarkedModule extends DefaultStreamReceiver { - - private static final long[] DURATIONS = { 150L, 20L, 30L, 202L }; - - private int i; - - @Override - public void startRecord(final String id) { - try { - Thread.sleep(getDuration()); - } - catch (final InterruptedException e) { - return; - } - } - - private long getDuration() { - final long duration = DURATIONS[i]; - i += 1; - if (i == DURATIONS.length) { - i = 0; - } - return duration; - } - - } - private StreamTimer streamTimer; private BenchmarkedModule benchmarkedModule; + public StreamTimerTest() { + } + @Before public void setup() { streamTimer = new StreamTimer(); @@ -90,4 +63,37 @@ public void testShouldHandleImmediateCloseStreamWithNoProcessing() { streamTimer.closeStream(); } + /** + * A module with a slow process method. + */ + private static final class BenchmarkedModule extends DefaultStreamReceiver { + + private static final long[] DURATIONS = {150L, 20L, 30L, 202L}; + + private int i; + + private BenchmarkedModule() { + } + + @Override + public void startRecord(final String id) { + try { + Thread.sleep(getDuration()); + } + catch (final InterruptedException e) { + return; + } + } + + private long getDuration() { + final long duration = DURATIONS[i]; + i += 1; + if (i == DURATIONS.length) { + i = 0; + } + return duration; + } + + } + } diff --git a/metafacture-plumbing/src/test/java/org/metafacture/plumbing/IdentityStreamPipeTest.java b/metafacture-plumbing/src/test/java/org/metafacture/plumbing/IdentityStreamPipeTest.java index 36f126923..9cfe09c6a 100644 --- a/metafacture-plumbing/src/test/java/org/metafacture/plumbing/IdentityStreamPipeTest.java +++ b/metafacture-plumbing/src/test/java/org/metafacture/plumbing/IdentityStreamPipeTest.java @@ -16,15 +16,14 @@ package org.metafacture.plumbing; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.times; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -48,6 +47,9 @@ public final class IdentityStreamPipeTest { @Mock private StreamReceiver receiver; + public IdentityStreamPipeTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -73,7 +75,7 @@ public void testShouldNotChangeTheStreamInAnyWay() { identityPipe.literal(LITERAL_NAME1, LITERAL_VALUE1); identityPipe.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID1); ordered.verify(receiver).literal(LITERAL_NAME1, LITERAL_VALUE1); ordered.verify(receiver).startEntity(ENTITY1); @@ -81,7 +83,7 @@ public void testShouldNotChangeTheStreamInAnyWay() { ordered.verify(receiver).endEntity(); ordered.verify(receiver).endRecord(); ordered.verify(receiver).startRecord(RECORD_ID2); - ordered.verify(receiver, times(2)).literal(LITERAL_NAME1, LITERAL_VALUE1); + ordered.verify(receiver, Mockito.times(2)).literal(LITERAL_NAME1, LITERAL_VALUE1); ordered.verify(receiver).endRecord(); } diff --git a/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamBatchMergerTest.java b/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamBatchMergerTest.java index 495ff6c51..2562251d9 100644 --- a/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamBatchMergerTest.java +++ b/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamBatchMergerTest.java @@ -16,9 +16,10 @@ package org.metafacture.plumbing; +import org.metafacture.framework.StreamReceiver; + import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.Mockito; @@ -37,6 +38,9 @@ public final class StreamBatchMergerTest { private StreamBatchMerger batchMerger; + public StreamBatchMergerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); diff --git a/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamMergerTest.java b/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamMergerTest.java index f79939397..c1150e236 100644 --- a/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamMergerTest.java +++ b/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamMergerTest.java @@ -16,16 +16,15 @@ package org.metafacture.plumbing; -import static org.mockito.Mockito.inOrder; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link StreamMerger}. * @@ -39,6 +38,9 @@ public final class StreamMergerTest { private StreamMerger streamMerger; + public StreamMergerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -60,7 +62,7 @@ public void shouldMergeSequencesOfRecordsWithTheSameId() { streamMerger.endRecord(); streamMerger.closeStream(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).startEntity("entity-1"); ordered.verify(receiver).endEntity(); @@ -81,7 +83,7 @@ public void shouldNoMergeRecordsWithDifferentIds() { streamMerger.endRecord(); streamMerger.closeStream(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).literal("literal-1", "value-1"); ordered.verify(receiver).endRecord(); diff --git a/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamTeeTest.java b/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamTeeTest.java index 6c328d2bc..dd376b3c4 100644 --- a/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamTeeTest.java +++ b/metafacture-plumbing/src/test/java/org/metafacture/plumbing/StreamTeeTest.java @@ -16,16 +16,15 @@ package org.metafacture.plumbing; -import static org.mockito.Mockito.inOrder; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link StreamTee}. * @@ -43,6 +42,9 @@ public final class StreamTeeTest { private StreamTee streamTee; + public StreamTeeTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -62,7 +64,7 @@ public void shouldForwardAllEventsToAllDownStreamReceivers() { streamTee.resetStream(); streamTee.closeStream(); - final InOrder ordered = inOrder(receiver1, receiver2); + final InOrder ordered = Mockito.inOrder(receiver1, receiver2); ordered.verify(receiver1).startRecord("1"); ordered.verify(receiver2).startRecord("1"); ordered.verify(receiver1).literal("literal", "value"); diff --git a/metafacture-statistics/src/test/java/org/metafacture/statistics/CooccurrenceMetricCalculatorTest.java b/metafacture-statistics/src/test/java/org/metafacture/statistics/CooccurrenceMetricCalculatorTest.java index 9dd56b86f..c6ef0cf10 100644 --- a/metafacture-statistics/src/test/java/org/metafacture/statistics/CooccurrenceMetricCalculatorTest.java +++ b/metafacture-statistics/src/test/java/org/metafacture/statistics/CooccurrenceMetricCalculatorTest.java @@ -16,12 +16,12 @@ package org.metafacture.statistics; -import static org.junit.Assert.assertEquals; - -import org.junit.Test; import org.metafacture.framework.ObjectReceiver; import org.metafacture.framework.helpers.DefaultObjectReceiver; import org.metafacture.framework.objects.Triple; + +import org.junit.Assert; +import org.junit.Test; import org.mockito.Mockito; /** @@ -44,32 +44,35 @@ public final class CooccurrenceMetricCalculatorTest { private static final double PRECISSION = 0.099; private static final double JACCARD = 0.0714; + public CooccurrenceMetricCalculatorTest() { + } + @Test public void testX2() { - assertEquals(X2, CooccurrenceMetricCalculator.Metric.X2.calculate(COUNT_A, COUNT_B, COUNT_A_AND_B, TOTAL), + Assert.assertEquals(X2, CooccurrenceMetricCalculator.Metric.X2.calculate(COUNT_A, COUNT_B, COUNT_A_AND_B, TOTAL), DELTA); } @Test public void testF() { - assertEquals(F, CooccurrenceMetricCalculator.Metric.F.calculate(COUNT_A, COUNT_B, COUNT_A_AND_B, TOTAL), DELTA); + Assert.assertEquals(F, CooccurrenceMetricCalculator.Metric.F.calculate(COUNT_A, COUNT_B, COUNT_A_AND_B, TOTAL), DELTA); } @Test public void testPrecission() { - assertEquals(PRECISSION, + Assert.assertEquals(PRECISSION, CooccurrenceMetricCalculator.Metric.PRECISSION.calculate(COUNT_A, COUNT_B, COUNT_A_AND_B, TOTAL), DELTA); } @Test public void testRecall() { - assertEquals(RECALL, + Assert.assertEquals(RECALL, CooccurrenceMetricCalculator.Metric.RECALL.calculate(COUNT_A, COUNT_B, COUNT_A_AND_B, TOTAL), DELTA); } @Test public void testJaccard() { - assertEquals(JACCARD, + Assert.assertEquals(JACCARD, CooccurrenceMetricCalculator.Metric.JACCARD.calculate(COUNT_A, COUNT_B, COUNT_A_AND_B, TOTAL), DELTA); } @@ -87,14 +90,12 @@ public void testAll() { Mockito.verify(receiver).process(new Triple("A&B", CooccurrenceMetricCalculator.Metric.X2.toString(), Double.toString(CooccurrenceMetricCalculator.Metric.X2.calculate(COUNT_A, COUNT_B, COUNT_A_AND_B, TOTAL)))); } - - @Test(expected=IllegalArgumentException.class) + @Test(expected = IllegalArgumentException.class) public void testIllegalArgument() { final CooccurrenceMetricCalculator calculator = new CooccurrenceMetricCalculator("X2"); calculator.setReceiver(new DefaultObjectReceiver()); calculator.process(new Triple("2:x&x", "", Integer.toString(COUNT_A_AND_B))); calculator.process(new Triple("1:x", "", Integer.toString(COUNT_B))); - } } diff --git a/metafacture-statistics/src/test/java/org/metafacture/statistics/HistogramTest.java b/metafacture-statistics/src/test/java/org/metafacture/statistics/HistogramTest.java index 33dd23e55..58683f75d 100644 --- a/metafacture-statistics/src/test/java/org/metafacture/statistics/HistogramTest.java +++ b/metafacture-statistics/src/test/java/org/metafacture/statistics/HistogramTest.java @@ -16,17 +16,12 @@ package org.metafacture.statistics; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +import org.junit.Assert; +import org.junit.Test; import java.util.HashMap; import java.util.Map; -import org.junit.Test; - - /** * Tests for class {@link Histogram}. * @@ -36,18 +31,21 @@ public final class HistogramTest { private static final String RECORD_ID = "1"; - private static final String[] ENTITIES = { "Entity 1", "Entity 2" }; - private static final String[] LITERALS = { "Literal 1", "Literal 2" }; - private static final String[] VALUES = { "Value A", "Value B" }; + private static final String[] ENTITIES = {"Entity 1", "Entity 2"}; + private static final String[] LITERALS = {"Literal 1", "Literal 2"}; + private static final String[] VALUES = {"Value A", "Value B"}; + + public HistogramTest() { + } @Test public void testCountEntities() { final Histogram histogram = new Histogram(); histogram.setCountEntities(true); - assertTrue(histogram.isCountEntities()); - assertFalse(histogram.isCountLiterals()); - assertNull(histogram.getCountField()); + Assert.assertTrue(histogram.isCountEntities()); + Assert.assertFalse(histogram.isCountLiterals()); + Assert.assertNull(histogram.getCountField()); histogram.startRecord(RECORD_ID); histogram.startEntity(ENTITIES[0]); @@ -64,7 +62,7 @@ public void testCountEntities() { expected.put(ENTITIES[0], Integer.valueOf(2)); expected.put(ENTITIES[1], Integer.valueOf(1)); - assertEquals(expected, histogram.getHistogram()); + Assert.assertEquals(expected, histogram.getHistogram()); } @Test @@ -72,9 +70,9 @@ public void testCountLiterals() { final Histogram histogram = new Histogram(); histogram.setCountLiterals(true); - assertFalse(histogram.isCountEntities()); - assertTrue(histogram.isCountLiterals()); - assertNull(histogram.getCountField()); + Assert.assertFalse(histogram.isCountEntities()); + Assert.assertTrue(histogram.isCountLiterals()); + Assert.assertNull(histogram.getCountField()); histogram.startRecord(RECORD_ID); histogram.startEntity(ENTITIES[0]); @@ -89,7 +87,7 @@ public void testCountLiterals() { expected.put(LITERALS[0], Integer.valueOf(2)); expected.put(LITERALS[1], Integer.valueOf(1)); - assertEquals(expected, histogram.getHistogram()); + Assert.assertEquals(expected, histogram.getHistogram()); } @Test @@ -97,9 +95,9 @@ public void testCountField() { final Histogram histogram = new Histogram(); histogram.setCountField(LITERALS[0]); - assertFalse(histogram.isCountEntities()); - assertFalse(histogram.isCountLiterals()); - assertEquals(LITERALS[0], histogram.getCountField()); + Assert.assertFalse(histogram.isCountEntities()); + Assert.assertFalse(histogram.isCountLiterals()); + Assert.assertEquals(LITERALS[0], histogram.getCountField()); histogram.startRecord(RECORD_ID); histogram.startEntity(ENTITIES[0]); @@ -115,28 +113,27 @@ public void testCountField() { expected.put(VALUES[0], Integer.valueOf(1)); expected.put(VALUES[1], Integer.valueOf(2)); - assertEquals(expected, histogram.getHistogram()); + Assert.assertEquals(expected, histogram.getHistogram()); } @Test public void testCountFieldConstructor() { final Histogram histogram = new Histogram(LITERALS[0]); - assertFalse(histogram.isCountEntities()); - assertFalse(histogram.isCountLiterals()); - assertEquals(LITERALS[0], histogram.getCountField()); + Assert.assertFalse(histogram.isCountEntities()); + Assert.assertFalse(histogram.isCountLiterals()); + Assert.assertEquals(LITERALS[0], histogram.getCountField()); } - @Test public void testResetStream() { final Histogram histogram = new Histogram(); histogram.setCountEntities(true); - assertTrue(histogram.isCountEntities()); - assertFalse(histogram.isCountLiterals()); - assertNull(histogram.getCountField()); + Assert.assertTrue(histogram.isCountEntities()); + Assert.assertFalse(histogram.isCountLiterals()); + Assert.assertNull(histogram.getCountField()); histogram.startRecord(RECORD_ID); histogram.startEntity(ENTITIES[0]); @@ -146,13 +143,13 @@ public void testResetStream() { final Map expected = new HashMap(); expected.put(ENTITIES[0], Integer.valueOf(1)); - assertEquals(expected, histogram.getHistogram()); + Assert.assertEquals(expected, histogram.getHistogram()); histogram.resetStream(); expected.clear(); - assertEquals(expected, histogram.getHistogram()); + Assert.assertEquals(expected, histogram.getHistogram()); } } diff --git a/metafacture-statistics/src/test/java/org/metafacture/statistics/UniformSamplerTest.java b/metafacture-statistics/src/test/java/org/metafacture/statistics/UniformSamplerTest.java index e958d8912..3ae2281c9 100644 --- a/metafacture-statistics/src/test/java/org/metafacture/statistics/UniformSamplerTest.java +++ b/metafacture-statistics/src/test/java/org/metafacture/statistics/UniformSamplerTest.java @@ -16,20 +16,19 @@ package org.metafacture.statistics; -import static org.mockito.Mockito.inOrder; - -import java.util.Arrays; +import org.metafacture.framework.ObjectReceiver; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameters; -import org.metafacture.framework.ObjectReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.util.Arrays; /** * Tests for class {@link UniformSampler}. @@ -62,8 +61,8 @@ public UniformSamplerTest(final int setSize, final String[] expected) { @Parameters public static Iterable data() { return Arrays.asList(new Object[][] { - { LARGE_SET, new String[] { "93", "43", "78", "35", "42" } }, - { SMALL_SET, new String[] { "0", "1", "2" } }, + {LARGE_SET, new String[]{"93", "43", "78", "35", "42"}}, + {SMALL_SET, new String[]{"0", "1", "2"}} }); } @@ -77,13 +76,13 @@ public void setup() { @Test public void testShouldEmitARandomSubsetOfTheInputObjects() { - for(int i = 0; i < setSize; ++i) { + for (int i = 0; i < setSize; ++i) { sampler.process(Integer.toString(i)); } sampler.closeStream(); - final InOrder ordered = inOrder(receiver); - for(int i = 0; i < expected.length; ++i) { + final InOrder ordered = Mockito.inOrder(receiver); + for (int i = 0; i < expected.length; ++i) { ordered.verify(receiver).process(expected[i]); } ordered.verify(receiver).closeStream(); diff --git a/metafacture-strings/src/test/java/org/metafacture/strings/LineRecorderTest.java b/metafacture-strings/src/test/java/org/metafacture/strings/LineRecorderTest.java index f77276a9f..2c0d04cfb 100644 --- a/metafacture-strings/src/test/java/org/metafacture/strings/LineRecorderTest.java +++ b/metafacture-strings/src/test/java/org/metafacture/strings/LineRecorderTest.java @@ -16,13 +16,13 @@ package org.metafacture.strings; -import static org.mockito.Mockito.inOrder; +import org.metafacture.framework.ObjectReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -52,6 +52,9 @@ public final class LineRecorderTest { @Mock private ObjectReceiver receiver; + public LineRecorderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -65,7 +68,7 @@ public void shouldEmitRecords() { lineRecorder.process(RECORD1_PART2); lineRecorder.process(RECORD1_ENDMARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process( RECORD1_PART1 + LINE_SEPARATOR + @@ -91,7 +94,7 @@ public void shouldEmitRecordWithNonDefaultRecordMarker() { lineRecorder.process(RECORD3_PART2); lineRecorder.process(RECORD3_ENDMARKER); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process( RECORD3_PART1 + LINE_SEPARATOR + @@ -105,7 +108,7 @@ public void shouldEmitLastRecordWithoutRecordMarkerWhenClosingStream() { lineRecorder.process(RECORD3_PART1); lineRecorder.process(RECORD3_PART2); lineRecorder.closeStream(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process( RECORD3_PART1 + LINE_SEPARATOR + @@ -117,8 +120,8 @@ public void shouldEmitLastRecordWithoutRecordMarkerWhenClosingStream() { @Test(expected = AssertionError.class) public void shouldEmitAsseertionErorWhenProcessingAfterStreamIsClosed() { - lineRecorder.closeStream(); - lineRecorder.process(""); + lineRecorder.closeStream(); + lineRecorder.process(""); } } diff --git a/metafacture-strings/src/test/java/org/metafacture/strings/LineSplitterTest.java b/metafacture-strings/src/test/java/org/metafacture/strings/LineSplitterTest.java index 6bba90086..9fff05a56 100644 --- a/metafacture-strings/src/test/java/org/metafacture/strings/LineSplitterTest.java +++ b/metafacture-strings/src/test/java/org/metafacture/strings/LineSplitterTest.java @@ -16,15 +16,13 @@ package org.metafacture.strings; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.ObjectReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -44,6 +42,9 @@ public final class LineSplitterTest { @Mock private ObjectReceiver receiver; + public LineSplitterTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -55,7 +56,7 @@ public void setup() { public void shouldSplitInputStringAtNewLines() { lineSplitter.process(PART1 + "\n" + PART2 + "\n" + PART3); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(PART1); ordered.verify(receiver).process(PART2); ordered.verify(receiver).process(PART3); @@ -66,15 +67,15 @@ public void shouldSplitInputStringAtNewLines() { public void shouldPassInputWithoutNewLinesUnchanged() { lineSplitter.process(PART1); - verify(receiver).process(PART1); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(PART1); + Mockito.verifyNoMoreInteractions(receiver); } @Test public void shouldOutputEmptyStringsForSequencesOfNewLines() { lineSplitter.process(PART1 + "\n\n" + PART2); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(PART1); ordered.verify(receiver).process(""); ordered.verify(receiver).process(PART2); @@ -85,7 +86,7 @@ public void shouldOutputEmptyStringsForSequencesOfNewLines() { public void shouldOutputEmptyStringForNewLinesAtStartOfTheInput() { lineSplitter.process("\n" + PART1); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(""); ordered.verify(receiver).process(PART1); ordered.verifyNoMoreInteractions(); @@ -95,8 +96,8 @@ public void shouldOutputEmptyStringForNewLinesAtStartOfTheInput() { public void shouldNotOutputEmptyStringForNewLinesAtEndOfTheInput() { lineSplitter.process(PART1 + "\n"); - verify(receiver).process(PART1); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(PART1); + Mockito.verifyNoMoreInteractions(receiver); } } diff --git a/metafacture-strings/src/test/java/org/metafacture/strings/RegexDecoderTest.java b/metafacture-strings/src/test/java/org/metafacture/strings/RegexDecoderTest.java index 5822d774b..82972393c 100644 --- a/metafacture-strings/src/test/java/org/metafacture/strings/RegexDecoderTest.java +++ b/metafacture-strings/src/test/java/org/metafacture/strings/RegexDecoderTest.java @@ -16,18 +16,14 @@ package org.metafacture.strings; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; +import org.mockito.ArgumentMatchers; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -42,6 +38,9 @@ public final class RegexDecoderTest { @Mock private StreamReceiver receiver; + public RegexDecoderTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -54,8 +53,8 @@ public void shouldEmitStartAndEndRecordForMatchingInput() { regexDecoder.process("matching input"); - final InOrder ordered = inOrder(receiver); - ordered.verify(receiver).startRecord(any()); + final InOrder ordered = Mockito.inOrder(receiver); + ordered.verify(receiver).startRecord(ArgumentMatchers.any()); ordered.verify(receiver).endRecord(); } @@ -66,7 +65,7 @@ public void shouldIgnoreNonMatchingInput() { regexDecoder.process("non-matching input"); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } @Test @@ -76,7 +75,7 @@ public void shouldUseCaptureGroupNamedIdAsRecordId() { regexDecoder.process("ID:id-123"); - verify(receiver).startRecord("id-123"); + Mockito.verify(receiver).startRecord("id-123"); } @Test @@ -86,10 +85,9 @@ public void shouldUseEmptyStringAsRecordIdIfNoRecordIdCaptureGroupExists() { regexDecoder.process("ID:id-123"); - verify(receiver).startRecord(""); + Mockito.verify(receiver).startRecord(""); } - @Test public void shouldUseEmptyStringAsRecordIdIfRecordIdCaptureGroupDoesNotMatch() { final RegexDecoder regexDecoder = new RegexDecoder("ID:(?[0-9]*).*"); @@ -97,7 +95,7 @@ public void shouldUseEmptyStringAsRecordIdIfRecordIdCaptureGroupDoesNotMatch() { regexDecoder.process("ID:id-123"); - verify(receiver).startRecord(""); + Mockito.verify(receiver).startRecord(""); } @Test @@ -108,7 +106,7 @@ public void shouldEmitLiteralContainingUnmodifiedInputIfRawInputLiteralIsSet() { regexDecoder.process("foo=1234,bar=abcd"); - verify(receiver).literal("input", "foo=1234,bar=abcd"); + Mockito.verify(receiver).literal("input", "foo=1234,bar=abcd"); } @Test @@ -119,12 +117,11 @@ public void shouldUseGroupNameAsLiteralNameForNamedCaptureGroups() { regexDecoder.process("foo=1234,bar=abcd"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).literal("foo", "1234"); ordered.verify(receiver).literal("bar", "abcd"); } - @Test public void shouldOutputLiteralsForEachMatchOfPattern() { final RegexDecoder regexDecoder = new RegexDecoder( @@ -133,7 +130,7 @@ public void shouldOutputLiteralsForEachMatchOfPattern() { regexDecoder.process("foo=1234,bar=abcd,foo=5678,bar=efgh"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).literal("foo", "1234"); ordered.verify(receiver).literal("bar", "abcd"); ordered.verify(receiver).literal("foo", "5678"); @@ -148,11 +145,11 @@ public void shouldIgnoreNonMatchingPartsOfInputString() { regexDecoder.process("foo=1234,bar=abcd,foo=5678,bar=efgh"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).literal("foo", "1234"); - ordered.verify(receiver, never()).literal("bar", "abcd"); + ordered.verify(receiver, Mockito.never()).literal("bar", "abcd"); ordered.verify(receiver).literal("foo", "5678"); - ordered.verify(receiver, never()).literal("bar", "efgh"); + ordered.verify(receiver, Mockito.never()).literal("bar", "efgh"); } @Test @@ -163,8 +160,8 @@ public void shouldIgnoreUnnamedCaptureGroups() { regexDecoder.process("foo=1234,bar=abcd,foo=5678,bar=efgh"); - verify(receiver, never()).literal(any(), eq("1234")); - verify(receiver, never()).literal(any(), eq("5678")); + Mockito.verify(receiver, Mockito.never()).literal(ArgumentMatchers.any(), ArgumentMatchers.eq("1234")); + Mockito.verify(receiver, Mockito.never()).literal(ArgumentMatchers.any(), ArgumentMatchers.eq("5678")); } } diff --git a/metafacture-strings/src/test/java/org/metafacture/strings/StreamUnicodeNormalizerTest.java b/metafacture-strings/src/test/java/org/metafacture/strings/StreamUnicodeNormalizerTest.java index 99ab2f3c7..de3753460 100644 --- a/metafacture-strings/src/test/java/org/metafacture/strings/StreamUnicodeNormalizerTest.java +++ b/metafacture-strings/src/test/java/org/metafacture/strings/StreamUnicodeNormalizerTest.java @@ -16,19 +16,18 @@ package org.metafacture.strings; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verify; - -import java.text.Normalizer; +import org.metafacture.framework.StreamReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.text.Normalizer; + /** * Tests for class {@link StreamUnicodeNormalizer}. * @@ -58,6 +57,9 @@ public final class StreamUnicodeNormalizerTest { @Mock private StreamReceiver receiver; + public StreamUnicodeNormalizerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -78,7 +80,7 @@ public void shouldForwardAllEvents() { streamUnicodeNormalizer.endEntity(); streamUnicodeNormalizer.endRecord(); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(RECORD_ID); ordered.verify(receiver).startEntity(ENTITY_NAME); ordered.verify(receiver).literal(LITERAL_NAME, LITERAL_VALUE); @@ -92,7 +94,7 @@ public void shouldNormalizeValuesToNFCByDefault() { streamUnicodeNormalizer.literal(LITERAL_NAME, VALUE_WITH_DIACRITICS); streamUnicodeNormalizer.endRecord(); - verify(receiver).literal(LITERAL_NAME, VALUE_WITH_PRECOMPOSED_CHARS); + Mockito.verify(receiver).literal(LITERAL_NAME, VALUE_WITH_PRECOMPOSED_CHARS); } @Test @@ -102,7 +104,7 @@ public void shouldNotNormalizeValuesIfConfigured() { streamUnicodeNormalizer.literal(LITERAL_NAME, VALUE_WITH_DIACRITICS); streamUnicodeNormalizer.endRecord(); - verify(receiver).literal(LITERAL_NAME, VALUE_WITH_DIACRITICS); + Mockito.verify(receiver).literal(LITERAL_NAME, VALUE_WITH_DIACRITICS); } @Test @@ -111,7 +113,7 @@ public void shouldIgnoreNullValues() { streamUnicodeNormalizer.literal(LITERAL_NAME, null); streamUnicodeNormalizer.endRecord(); - verify(receiver).literal(LITERAL_NAME, null); + Mockito.verify(receiver).literal(LITERAL_NAME, null); } @Test @@ -119,7 +121,7 @@ public void shouldNotNormalizeIdByDefault() { streamUnicodeNormalizer.startRecord(ID_WITH_DIACRITICS); streamUnicodeNormalizer.endRecord(); - verify(receiver).startRecord(ID_WITH_DIACRITICS); + Mockito.verify(receiver).startRecord(ID_WITH_DIACRITICS); } @Test @@ -128,7 +130,7 @@ public void shouldNormalizeIdToNFCIfConfigured() { streamUnicodeNormalizer.startRecord(ID_WITH_DIACRITICS); streamUnicodeNormalizer.endRecord(); - verify(receiver).startRecord(ID_WITH_PRECOMPOSED_CHARS); + Mockito.verify(receiver).startRecord(ID_WITH_PRECOMPOSED_CHARS); } @Test @@ -139,8 +141,8 @@ public void shouldNotNormalizeKeyByDefault() { streamUnicodeNormalizer.endEntity(); streamUnicodeNormalizer.endRecord(); - verify(receiver).literal(KEY_WITH_DIACRITICS, LITERAL_VALUE); - verify(receiver).startEntity(KEY_WITH_DIACRITICS); + Mockito.verify(receiver).literal(KEY_WITH_DIACRITICS, LITERAL_VALUE); + Mockito.verify(receiver).startEntity(KEY_WITH_DIACRITICS); } @Test @@ -152,8 +154,8 @@ public void shouldNormalizeKeysIfConfigured() { streamUnicodeNormalizer.endEntity(); streamUnicodeNormalizer.endRecord(); - verify(receiver).literal(KEY_WITH_PRECOMPOSED_CHARS, LITERAL_VALUE); - verify(receiver).startEntity(KEY_WITH_PRECOMPOSED_CHARS); + Mockito.verify(receiver).literal(KEY_WITH_PRECOMPOSED_CHARS, LITERAL_VALUE); + Mockito.verify(receiver).startEntity(KEY_WITH_PRECOMPOSED_CHARS); } @Test @@ -164,7 +166,7 @@ public void shouldNormalizeToNFDIfConfigured() { KEY_WITH_PRECOMPOSED_CHARS); streamUnicodeNormalizer.endRecord(); - verify(receiver).literal(LITERAL_NAME, KEY_WITH_DIACRITICS); + Mockito.verify(receiver).literal(LITERAL_NAME, KEY_WITH_DIACRITICS); } } diff --git a/metafacture-strings/src/test/java/org/metafacture/strings/StringFilterTest.java b/metafacture-strings/src/test/java/org/metafacture/strings/StringFilterTest.java index 391db14bd..ece399232 100644 --- a/metafacture-strings/src/test/java/org/metafacture/strings/StringFilterTest.java +++ b/metafacture-strings/src/test/java/org/metafacture/strings/StringFilterTest.java @@ -16,18 +16,16 @@ package org.metafacture.strings; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link StringFilter}. * @@ -39,7 +37,7 @@ public final class StringFilterTest { private static final String[] RECORDS = { "Record 1: Data", "Record 42: Data", - "Record 3: Data", + "Record 3: Data" }; private static final String PATTERN = "\\d\\d"; @@ -49,6 +47,9 @@ public final class StringFilterTest { @Mock private ObjectReceiver receiver; + public StringFilterTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -69,9 +70,9 @@ public void testShouldPassMatchingInput() { filter.process(RECORDS[1]); filter.process(RECORDS[2]); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(RECORDS[1]); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -82,10 +83,10 @@ public void testShouldPassNonMatchingInput() { filter.process(RECORDS[1]); filter.process(RECORDS[2]); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).process(RECORDS[0]); ordered.verify(receiver).process(RECORDS[2]); - verifyNoMoreInteractions(receiver); + Mockito.verifyNoMoreInteractions(receiver); } } diff --git a/metafacture-strings/src/test/java/org/metafacture/strings/StringMatcherTest.java b/metafacture-strings/src/test/java/org/metafacture/strings/StringMatcherTest.java index bc8d0df06..7d4dd5ee3 100644 --- a/metafacture-strings/src/test/java/org/metafacture/strings/StringMatcherTest.java +++ b/metafacture-strings/src/test/java/org/metafacture/strings/StringMatcherTest.java @@ -16,16 +16,15 @@ package org.metafacture.strings; -import static org.mockito.Mockito.verify; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; - /** * Tests for class {@link StringMatcher}. * @@ -42,6 +41,9 @@ public final class StringMatcherTest { @Mock private ObjectReceiver receiver; + public StringMatcherTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -61,7 +63,7 @@ public void testShouldReplaceAllMatchesWithReplacementString() { matcher.process("Hi PLACEHOLDER! -- Goodbye PLACEHOLDER!"); - verify(receiver).process("Hi Karl! -- Goodbye Karl!"); + Mockito.verify(receiver).process("Hi Karl! -- Goodbye Karl!"); } @Test @@ -71,7 +73,7 @@ public void testShouldHandleCaptureGroupReferencesInReplacementString() { matcher.process("important-bit but this can be ignored"); - verify(receiver).process("important-bit"); + Mockito.verify(receiver).process("important-bit"); } @Test @@ -80,7 +82,7 @@ public void testShouldRelayNonMatchingInput() { matcher.process(INPUT_STRING); - verify(receiver).process(INPUT_STRING); + Mockito.verify(receiver).process(INPUT_STRING); } } diff --git a/metafacture-strings/src/test/java/org/metafacture/strings/UnicodeNormalizerTest.java b/metafacture-strings/src/test/java/org/metafacture/strings/UnicodeNormalizerTest.java index 4e3e74f1d..14b71a1fd 100644 --- a/metafacture-strings/src/test/java/org/metafacture/strings/UnicodeNormalizerTest.java +++ b/metafacture-strings/src/test/java/org/metafacture/strings/UnicodeNormalizerTest.java @@ -16,13 +16,13 @@ package org.metafacture.strings; -import static org.mockito.Mockito.verify; +import org.metafacture.framework.ObjectReceiver; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -44,6 +44,9 @@ public final class UnicodeNormalizerTest { @Mock private ObjectReceiver receiver; + public UnicodeNormalizerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -60,7 +63,7 @@ public void cleanup() { public void testShouldReplaceDiacriticsWithPrecomposedChars() { normalizer.process(STRING_WITH_DIACRITICS); - verify(receiver).process(STRING_WITH_PRECOMPOSED_CHARS); + Mockito.verify(receiver).process(STRING_WITH_PRECOMPOSED_CHARS); } } diff --git a/metafacture-triples/src/test/java/org/metafacture/triples/AbstractTripleSortTest.java b/metafacture-triples/src/test/java/org/metafacture/triples/AbstractTripleSortTest.java index df815e546..a8b9d8f20 100644 --- a/metafacture-triples/src/test/java/org/metafacture/triples/AbstractTripleSortTest.java +++ b/metafacture-triples/src/test/java/org/metafacture/triples/AbstractTripleSortTest.java @@ -16,31 +16,34 @@ package org.metafacture.triples; -import static org.junit.Assert.assertTrue; - -import java.lang.ref.ReferenceQueue; -import java.lang.ref.WeakReference; +import org.metafacture.framework.objects.Triple; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.objects.Triple; + +import java.lang.ref.ReferenceQueue; +import java.lang.ref.WeakReference; /** * Tests for class {@link AbstractTripleSort}. * * @author Christoph Böhme */ -public final class AbstractTripleSortTest { +public final class AbstractTripleSortTest { // checkstyle-disable-line AbstractClassName private static final Triple T1 = new Triple("s", "p", "o"); private AbstractTripleSort tripleSort; + public AbstractTripleSortTest() { + } + @Before public void setup() { tripleSort = new AbstractTripleSort() { @Override - protected void sortedTriple(final Triple namedValue) {} + protected void sortedTriple(final Triple namedValue) { } }; } @@ -74,7 +77,7 @@ public void issue192ShouldUnregisterFromTheJVMToNotCauseMemoryLeak() throws Inte // Wait a tiny bit since GC Thread is not immediately done in Java 8 Thread.sleep(10); - assertTrue(weakRef.isEnqueued()); + Assert.assertTrue(weakRef.isEnqueued()); } } diff --git a/metafacture-triples/src/test/java/org/metafacture/triples/StreamToTriplesTest.java b/metafacture-triples/src/test/java/org/metafacture/triples/StreamToTriplesTest.java index 226c96384..b4761a05e 100644 --- a/metafacture-triples/src/test/java/org/metafacture/triples/StreamToTriplesTest.java +++ b/metafacture-triples/src/test/java/org/metafacture/triples/StreamToTriplesTest.java @@ -16,12 +16,13 @@ package org.metafacture.triples; -import org.junit.Before; -import org.junit.Test; import org.metafacture.framework.ObjectReceiver; import org.metafacture.framework.StandardEventNames; import org.metafacture.framework.objects.Triple; import org.metafacture.framework.objects.Triple.ObjectType; + +import org.junit.Before; +import org.junit.Test; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.MockitoAnnotations; @@ -40,6 +41,9 @@ public final class StreamToTriplesTest { private StreamToTriples streamToTriples; + public StreamToTriplesTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); diff --git a/metafacture-triples/src/test/java/org/metafacture/triples/TripleCollectTest.java b/metafacture-triples/src/test/java/org/metafacture/triples/TripleCollectTest.java index 389fa61e6..ebf8e009e 100644 --- a/metafacture-triples/src/test/java/org/metafacture/triples/TripleCollectTest.java +++ b/metafacture-triples/src/test/java/org/metafacture/triples/TripleCollectTest.java @@ -16,15 +16,13 @@ package org.metafacture.triples; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.verify; - -import org.junit.Before; -import org.junit.Test; import org.metafacture.formeta.Formeta; import org.metafacture.framework.StreamReceiver; import org.metafacture.framework.objects.Triple; import org.metafacture.framework.objects.Triple.ObjectType; + +import org.junit.Before; +import org.junit.Test; import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.Mockito; @@ -51,6 +49,9 @@ public final class TripleCollectTest { private TripleCollect collect; + public TripleCollectTest() { + } + @Before public void initMocks() { MockitoAnnotations.initMocks(this); @@ -78,9 +79,9 @@ public void testShouldBuildRecords() { @Test public void testShouldDecodeEntities() { - collect.process(new Triple(REC_ID, ENTITY_NAME, Formeta.GROUP_START +NAME + Formeta.NAME_VALUE_SEPARATOR + VALUE - + Formeta.ITEM_SEPARATOR + ENTITY_NAME + Formeta.GROUP_START + NAME - + Formeta.NAME_VALUE_SEPARATOR + VALUE + Formeta.GROUP_END + Formeta.GROUP_END, + collect.process(new Triple(REC_ID, ENTITY_NAME, Formeta.GROUP_START + NAME + Formeta.NAME_VALUE_SEPARATOR + VALUE + + Formeta.ITEM_SEPARATOR + ENTITY_NAME + Formeta.GROUP_START + NAME + + Formeta.NAME_VALUE_SEPARATOR + VALUE + Formeta.GROUP_END + Formeta.GROUP_END, ObjectType.ENTITY)); collect.closeStream(); @@ -99,14 +100,14 @@ public void testShouldDecodeEntities() { public void shouldNotEmitEndRecordOnCloseStreamIfNoTriplesWereReceived() { collect.closeStream(); - verify(receiver, never()).endRecord(); + Mockito.verify(receiver, Mockito.never()).endRecord(); } @Test public void shouldNotEmitEndRecordOnResetStreamIfNoTriplesWereReceived() { collect.resetStream(); - verify(receiver, never()).endRecord(); + Mockito.verify(receiver, Mockito.never()).endRecord(); } } diff --git a/metafacture-triples/src/test/java/org/metafacture/triples/TripleFilterTest.java b/metafacture-triples/src/test/java/org/metafacture/triples/TripleFilterTest.java index 746fcdb05..54abad2e3 100644 --- a/metafacture-triples/src/test/java/org/metafacture/triples/TripleFilterTest.java +++ b/metafacture-triples/src/test/java/org/metafacture/triples/TripleFilterTest.java @@ -16,15 +16,14 @@ package org.metafacture.triples; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoMoreInteractions; +import org.metafacture.framework.ObjectReceiver; +import org.metafacture.framework.objects.Triple; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.ObjectReceiver; -import org.metafacture.framework.objects.Triple; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; /** @@ -44,6 +43,9 @@ public final class TripleFilterTest { @Mock private ObjectReceiver receiver; + public TripleFilterTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -63,8 +65,8 @@ public void testShouldPassMatchingTripleByDefault() { tripleFilter.process(TRIPLE1); tripleFilter.process(TRIPLE2); - verify(receiver).process(TRIPLE1); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(TRIPLE1); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -75,8 +77,8 @@ public void testShouldPassNonMatchingTripleIfPassMatchesIsFalse() { tripleFilter.process(TRIPLE1); tripleFilter.process(TRIPLE2); - verify(receiver).process(TRIPLE2); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(TRIPLE2); + Mockito.verifyNoMoreInteractions(receiver); } @Test @@ -88,9 +90,9 @@ public void testShouldUseDisjunctionForPatterns() { tripleFilter.process(TRIPLE2); tripleFilter.process(TRIPLE3); - verify(receiver).process(TRIPLE1); - verify(receiver).process(TRIPLE3); - verifyNoMoreInteractions(receiver); + Mockito.verify(receiver).process(TRIPLE1); + Mockito.verify(receiver).process(TRIPLE3); + Mockito.verifyNoMoreInteractions(receiver); } } diff --git a/metafacture-triples/src/test/java/org/metafacture/triples/TripleObjectRetrieverTest.java b/metafacture-triples/src/test/java/org/metafacture/triples/TripleObjectRetrieverTest.java index 3207f614b..d19b01c73 100644 --- a/metafacture-triples/src/test/java/org/metafacture/triples/TripleObjectRetrieverTest.java +++ b/metafacture-triples/src/test/java/org/metafacture/triples/TripleObjectRetrieverTest.java @@ -16,25 +16,24 @@ package org.metafacture.triples; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; - -import java.io.File; -import java.io.FileWriter; -import java.io.IOException; -import java.io.Writer; +import org.metafacture.framework.ObjectReceiver; +import org.metafacture.framework.objects.Triple; +import org.metafacture.framework.objects.Triple.ObjectType; import org.junit.After; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.metafacture.framework.ObjectReceiver; -import org.metafacture.framework.objects.Triple; -import org.metafacture.framework.objects.Triple.ObjectType; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.io.Writer; + /** * Tests for class {@link TripleObjectRetriever}. * @@ -48,15 +47,17 @@ public final class TripleObjectRetrieverTest { private static final String OBJECT_VALUE = "object-data"; private static final String ENTITY = "{l=v}"; - private TripleObjectRetriever tripleObjectRetriever; + @Rule + public TemporaryFolder tempFolder = new TemporaryFolder(); @Mock private ObjectReceiver receiver; - @Rule - public TemporaryFolder tempFolder = new TemporaryFolder(); - private String objectUrl; + private TripleObjectRetriever tripleObjectRetriever; + + public TripleObjectRetrieverTest() { + } @Before public void setup() throws IOException { @@ -85,7 +86,7 @@ public void cleanup() { public void shouldReplaceObjectValueWithResourceContentRetrievedFromUrl() { tripleObjectRetriever.process(new Triple(SUBJECT, PREDICATE, objectUrl)); - verify(receiver).process(new Triple(SUBJECT, PREDICATE, OBJECT_VALUE)); + Mockito.verify(receiver).process(new Triple(SUBJECT, PREDICATE, OBJECT_VALUE)); } @Test @@ -93,7 +94,7 @@ public void shouldSkipTriplesWithObjectTypeEntity() { tripleObjectRetriever.process( new Triple(SUBJECT, PREDICATE, ENTITY, ObjectType.ENTITY)); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } } diff --git a/metafacture-triples/src/test/java/org/metafacture/triples/TripleObjectWriterTest.java b/metafacture-triples/src/test/java/org/metafacture/triples/TripleObjectWriterTest.java index 0b76c6d5c..947e075b6 100644 --- a/metafacture-triples/src/test/java/org/metafacture/triples/TripleObjectWriterTest.java +++ b/metafacture-triples/src/test/java/org/metafacture/triples/TripleObjectWriterTest.java @@ -16,19 +16,19 @@ package org.metafacture.triples; -import static org.junit.Assert.assertEquals; - -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; +import org.metafacture.framework.objects.Triple; import org.junit.After; +import org.junit.Assert; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.metafacture.framework.objects.Triple; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; /** * Tests for class {@link TripleObjectWriter}. @@ -47,12 +47,14 @@ public final class TripleObjectWriterTest { private static final String OBJECT1 = "object-data 1"; private static final String OBJECT2 = "object-data 2"; - private TripleObjectWriter tripleObjectWriter; - @Rule public TemporaryFolder tempFolder = new TemporaryFolder(); private Path baseDir; + private TripleObjectWriter tripleObjectWriter; + + public TripleObjectWriterTest() { + } @Before public void createSystemUnderTest() throws IOException { @@ -73,22 +75,22 @@ public void shouldWriteObjectOfTripleIntoFile() throws IOException { final Path file1 = baseDir.resolve(Paths.get(SUBJECT1, PREDICATE)); final Path file2 = baseDir.resolve(Paths.get(SUBJECT2, PREDICATE)); - assertEquals(OBJECT1, readFileContents(file1)); - assertEquals(OBJECT2, readFileContents(file2)); + Assert.assertEquals(OBJECT1, readFileContents(file1)); + Assert.assertEquals(OBJECT2, readFileContents(file2)); } @Test public void shouldMapStructuredSubjectsToDirectories() throws IOException { tripleObjectWriter.process(new Triple(STRUCTURED_SUBJECT, PREDICATE, OBJECT1)); - final Path file = baseDir.resolve(Paths.get(STRUCTURED_SUBJECT_A, - STRUCTURED_SUBJECT_B, PREDICATE)); - assertEquals(readFileContents(file), OBJECT1); + final Path file = baseDir.resolve(Paths.get(STRUCTURED_SUBJECT_A, + STRUCTURED_SUBJECT_B, PREDICATE)); + Assert.assertEquals(readFileContents(file), OBJECT1); } private String readFileContents(final Path file) throws IOException { - final byte[] data = Files.readAllBytes(file); - return new String(data, tripleObjectWriter.getEncoding()); + final byte[] data = Files.readAllBytes(file); + return new String(data, tripleObjectWriter.getEncoding()); } } diff --git a/metafacture-triples/src/test/java/org/metafacture/triples/TripleReaderWriterTest.java b/metafacture-triples/src/test/java/org/metafacture/triples/TripleReaderWriterTest.java index e2619a125..d9c0cb5ba 100644 --- a/metafacture-triples/src/test/java/org/metafacture/triples/TripleReaderWriterTest.java +++ b/metafacture-triples/src/test/java/org/metafacture/triples/TripleReaderWriterTest.java @@ -16,20 +16,20 @@ package org.metafacture.triples; -import static org.mockito.Mockito.verify; - -import java.io.File; -import java.io.IOException; +import org.metafacture.framework.ObjectReceiver; +import org.metafacture.framework.objects.Triple; +import org.metafacture.framework.objects.Triple.ObjectType; import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.metafacture.framework.ObjectReceiver; -import org.metafacture.framework.objects.Triple; -import org.metafacture.framework.objects.Triple.ObjectType; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.io.File; +import java.io.IOException; + /** * Tests for classes {@link TripleReader} and {@link TripleWriter}. * TODO: This test class should be split into two separated test classes. @@ -48,6 +48,9 @@ public final class TripleReaderWriterTest { @Mock private ObjectReceiver receiver; + public TripleReaderWriterTest() { + } + @Test public void testShouldWriteAndReadTriples() throws IOException { MockitoAnnotations.initMocks(this); @@ -63,8 +66,8 @@ public void testShouldWriteAndReadTriples() throws IOException { tripleReader.process(file.getAbsolutePath()); - verify(receiver).process(TRIPLE1); - verify(receiver).process(TRIPLE2); + Mockito.verify(receiver).process(TRIPLE1); + Mockito.verify(receiver).process(TRIPLE2); } } diff --git a/metafacture-triples/src/test/java/org/metafacture/triples/TripleSortTest.java b/metafacture-triples/src/test/java/org/metafacture/triples/TripleSortTest.java index 956570a79..87d4313ce 100644 --- a/metafacture-triples/src/test/java/org/metafacture/triples/TripleSortTest.java +++ b/metafacture-triples/src/test/java/org/metafacture/triples/TripleSortTest.java @@ -40,6 +40,9 @@ public final class TripleSortTest { @Mock private ObjectReceiver receiver; + public TripleSortTest() { + } + @Test public void shouldSortByIncreasingSubject() { assertSort( @@ -262,7 +265,7 @@ public void issue380_shouldOptionallySortNumericallyByDecreasingSubject() { ); } - @Test(expected=NumberFormatException.class) + @Test(expected = NumberFormatException.class) public void shouldFailToSortNumericallyWithInvalidNumber() { assertSort( t -> { diff --git a/metafacture-xml/src/test/java/org/metafacture/xml/CGXmlHandlerTest.java b/metafacture-xml/src/test/java/org/metafacture/xml/CGXmlHandlerTest.java index 602b22b3e..bc3da359b 100644 --- a/metafacture-xml/src/test/java/org/metafacture/xml/CGXmlHandlerTest.java +++ b/metafacture-xml/src/test/java/org/metafacture/xml/CGXmlHandlerTest.java @@ -16,16 +16,14 @@ package org.metafacture.xml; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; +import org.metafacture.framework.FormatException; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.FormatException; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.xml.sax.helpers.AttributesImpl; @@ -46,6 +44,9 @@ public final class CGXmlHandlerTest { private CGXmlHandler cgXmlHandler; + public CGXmlHandlerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -65,7 +66,7 @@ public void shouldAcceptCgXmlVersion1() { cgXmlHandler.startElement(CGXML_NS, "cgxml", "cgxml:cgxml", attributes); cgXmlHandler.endElement(CGXML_NS, "cgxml", "cgxml:cgxml"); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } @Test(expected = FormatException.class) @@ -82,7 +83,7 @@ public void shouldIgnoreRecordsElement() { cgXmlHandler.startElement(CGXML_NS, "records", "cgxml:records", attributes); cgXmlHandler.endElement(CGXML_NS, "records", "cgxml:records"); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } @Test @@ -91,7 +92,7 @@ public void shouldEmitStartAndEndRecordEventsForRecordElements() { cgXmlHandler.startElement(CGXML_NS, "record", "cgxml:record", attributes); cgXmlHandler.endElement(CGXML_NS, "record", "cgxml:record"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("1"); ordered.verify(receiver).endRecord(); } @@ -100,7 +101,7 @@ public void shouldEmitStartAndEndRecordEventsForRecordElements() { public void shouldEmitStartRecordWithEmptyIdIfIdAttributeIsMissing() { cgXmlHandler.startElement(CGXML_NS, "record", "cgxml:record", attributes); - verify(receiver).startRecord(""); + Mockito.verify(receiver).startRecord(""); } @Test @@ -109,7 +110,7 @@ public void shouldEmitStartAndEndEntityEventsForEntityElements() { cgXmlHandler.startElement(CGXML_NS, "entity", "cgxml:entity", attributes); cgXmlHandler.endElement(CGXML_NS, "entity", "cgxml:entity"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startEntity("e-name"); ordered.verify(receiver).endEntity(); } @@ -128,7 +129,7 @@ public void shouldEmitLiteralEventForLiteralElements() { cgXmlHandler.startElement(CGXML_NS, "literal", "cgxml:literal", attributes); cgXmlHandler.endElement(CGXML_NS, "literal", "cgxml:literal"); - verify(receiver).literal("l-name", "l-val"); + Mockito.verify(receiver).literal("l-name", "l-val"); } @Test(expected = FormatException.class) diff --git a/metafacture-xml/src/test/java/org/metafacture/xml/GenericXMLHandlerTest.java b/metafacture-xml/src/test/java/org/metafacture/xml/GenericXMLHandlerTest.java index 8c18b50fb..044a2dc2e 100644 --- a/metafacture-xml/src/test/java/org/metafacture/xml/GenericXMLHandlerTest.java +++ b/metafacture-xml/src/test/java/org/metafacture/xml/GenericXMLHandlerTest.java @@ -16,13 +16,10 @@ package org.metafacture.xml; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.Mockito; @@ -44,6 +41,9 @@ public final class GenericXMLHandlerTest { private AttributesImpl attributes; + public GenericXMLHandlerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -61,7 +61,7 @@ public void createHelperObjects() { public void shouldIgnoreElementsOutsideRecordElement() { genericXmlHandler.startElement("", "ignore-me", "ignore-me", attributes); - verifyZeroInteractions(receiver); + Mockito.verifyZeroInteractions(receiver); } @Test @@ -69,7 +69,7 @@ public void shouldEmitRecordElementAsStartAndEndRecordEvent() { genericXmlHandler.startElement("", "record", "record", attributes); genericXmlHandler.endElement("", "record", "record"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).endRecord(); } @@ -78,7 +78,7 @@ public void shouldEmitRecordElementAsStartAndEndRecordEvent() { public void shouldEmitEmptyStringIfRecordTagHasNoIdAttribute() { genericXmlHandler.startElement("", "record", "record", attributes); - verify(receiver).startRecord(""); + Mockito.verify(receiver).startRecord(""); } @Test @@ -86,7 +86,7 @@ public void shouldEmitValueOfIdAttribute() { attributes.addAttribute("", "id", "id", "CDATA", "theRecordID"); genericXmlHandler.startElement("", "record", "record", attributes); - verify(receiver).startRecord("theRecordID"); + Mockito.verify(receiver).startRecord("theRecordID"); } @Test @@ -94,7 +94,7 @@ public void shouldEmitAttributesOnRecordElementAsLiterals() { attributes.addAttribute("", "attr", "attr", "CDATA", "attr-value"); genericXmlHandler.startElement("", "record", "record", attributes); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).literal("attr", "attr-value"); } @@ -105,7 +105,7 @@ public void shouldEmitElementsAsStartAndEndEntityEvents() { genericXmlHandler.startElement("", "entity", "entity", attributes); genericXmlHandler.endElement("", "entity", "entity"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startEntity("entity"); ordered.verify(receiver).endEntity(); } @@ -116,7 +116,7 @@ public void shouldEmitAttributesOnEntityElementAsLiterals() { attributes.addAttribute("", "attr", "attr", "CDATA", "attr-value"); genericXmlHandler.startElement("", "entity", "entity", attributes); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startEntity("entity"); ordered.verify(receiver).literal("attr", "attr-value"); } @@ -129,7 +129,7 @@ public void shouldEmitPCDataAsALiteralNamedValue() { genericXmlHandler.characters(charData, 0, charData.length); genericXmlHandler.endElement("", "entity", "entity"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startEntity("entity"); ordered.verify(receiver).literal("value", "char-data"); } @@ -146,7 +146,7 @@ public void shouldEmitPCDataAsALiteralWithConfiguredValueTagName() { genericXmlHandler.endElement("", "entity", "entity"); genericXmlHandler.endElement("", "record", "record"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).startEntity("entity"); ordered.verify(receiver).literal(name, "char-data"); @@ -163,7 +163,7 @@ public void shouldEmitNamespaceOnEntityElementAndAttribute() { genericXmlHandler.startElement("", "record", "record", attributes); genericXmlHandler.startElement("", "entity", "ns:entity", attributes); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startEntity("ns:entity"); ordered.verify(receiver).literal("ns:attr", "attr-value"); } @@ -174,7 +174,7 @@ public void shouldNotEncodeAttributesAsMarkedLiterals() { genericXmlHandler.startElement("", "record", "record", attributes); genericXmlHandler.endElement("", "record", "record"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).literal("attr", "attr-value"); ordered.verify(receiver).endRecord(); @@ -196,7 +196,7 @@ public void issue379_shouldEncodeAttributesAsLiteralsWithConfiguredMarker() { genericXmlHandler.endElement("", "roleTerm", "roleTerm"); genericXmlHandler.endElement("", "record", "record"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(""); ordered.verify(receiver).startEntity("roleTerm"); ordered.verify(receiver).literal(marker + "authority", "marcrelator"); diff --git a/metafacture-xml/src/test/java/org/metafacture/xml/SimpleXmlEncoderTest.java b/metafacture-xml/src/test/java/org/metafacture/xml/SimpleXmlEncoderTest.java index 580a1ff5b..68d8c1b3c 100644 --- a/metafacture-xml/src/test/java/org/metafacture/xml/SimpleXmlEncoderTest.java +++ b/metafacture-xml/src/test/java/org/metafacture/xml/SimpleXmlEncoderTest.java @@ -16,18 +16,16 @@ package org.metafacture.xml; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - import org.metafacture.framework.helpers.DefaultObjectReceiver; import org.metafacture.framework.helpers.DefaultXmlPipe; -import java.util.HashMap; -import java.util.Map; - +import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import java.util.HashMap; +import java.util.Map; + /** * Tests for class {@link SimpleXmlEncoder}. * @@ -44,6 +42,9 @@ public final class SimpleXmlEncoderTest { private StringBuilder resultCollector; + public SimpleXmlEncoderTest() { + } + @Before public void initSystemUnderTest() { simpleXmlEncoder = new SimpleXmlEncoder(); @@ -61,23 +62,23 @@ public void process(final String obj) { public void issue249_shouldNotEmitClosingRootTagOnCloseStreamIfNoOutputWasGenerated() { simpleXmlEncoder.closeStream(); - assertTrue(getResultXml().isEmpty()); + Assert.assertTrue(getResultXml().isEmpty()); } @Test public void shouldNotEmitClosingRootTagOnResetStreamIfNoOutputWasGenerated() { simpleXmlEncoder.resetStream(); - assertTrue(getResultXml().isEmpty()); + Assert.assertTrue(getResultXml().isEmpty()); } @Test public void shouldOnlyEscapeXmlReservedCharacters() { final StringBuilder builder = new StringBuilder(); - SimpleXmlEncoder.writeEscaped(builder , "&<>'\" üäö"); + SimpleXmlEncoder.writeEscaped(builder, "&<>'\" üäö"); - assertEquals("&<>'" üäö", builder.toString()); + Assert.assertEquals("&<>'" üäö", builder.toString()); } @Test @@ -86,7 +87,7 @@ public void shouldWrapEachRecordInRootTagIfSeparateRootsIsTrue() { emitTwoRecords(); - assertEquals("valuevalue", + Assert.assertEquals("valuevalue", getResultXml()); } @@ -96,7 +97,7 @@ public void shouldWrapAllRecordsInOneRootTagtIfSeparateRootsIsFalse() { emitTwoRecords(); - assertEquals("valuevalue", + Assert.assertEquals("valuevalue", getResultXml()); } @@ -108,7 +109,7 @@ public void shouldAddNamespaceToRootElement() { emitEmptyRecord(); - assertEquals("", + Assert.assertEquals("", getResultXml()); } @@ -118,9 +119,10 @@ public void shouldAddMultipleNamespacesFromParameterToRootElement() { emitEmptyRecord(); - assertEquals("", + Assert.assertEquals("", getResultXml()); } + @Test public void shouldAddNamespaceWithEmptyKeyAsDefaultNamespaceToRootTag() { final Map namespaces = new HashMap(); @@ -129,7 +131,7 @@ public void shouldAddNamespaceWithEmptyKeyAsDefaultNamespaceToRootTag() { emitEmptyRecord(); - assertEquals("", + Assert.assertEquals("", getResultXml()); } @@ -141,7 +143,7 @@ public void shouldAddNamespaceWithDefaultKeyAsDefaultNamespaceToRootTag() { emitEmptyRecord(); - assertEquals("", + Assert.assertEquals("", getResultXml()); } @@ -151,7 +153,7 @@ public void shouldAddNamespaceWithEmptyKeyFromPropertiesFileAsDefaultNamespaceTo emitEmptyRecord(); - assertEquals("", + Assert.assertEquals("", getResultXml()); } @@ -161,7 +163,7 @@ public void shouldNotEmitRootTagIfWriteRootTagIsFalse() { emitEmptyRecord(); - assertEquals("", + Assert.assertEquals("", getResultXml()); } @@ -174,7 +176,7 @@ public void shouldAddNamespacesToRecordTagIfWriteRootTagIsFalse() { emitEmptyRecord(); - assertEquals("", + Assert.assertEquals("", getResultXml()); } @@ -187,7 +189,7 @@ public void shouldAddNamespaceWithEmptyKeyAsDefaultNamespaceToRecordTag() { emitEmptyRecord(); - assertEquals("", + Assert.assertEquals("", getResultXml()); } @@ -200,7 +202,7 @@ public void shouldAddNamespaceWithDefaultKeyAsDefaultNamespaceToRecordTag() { emitEmptyRecord(); - assertEquals("", + Assert.assertEquals("", getResultXml()); } @@ -211,9 +213,10 @@ public void shouldAddNamespaceWithEmptyKeyFromPropertiesFileAsDefaultNamespaceTo emitEmptyRecord(); - assertEquals("", + Assert.assertEquals("", getResultXml()); } + @Test public void shouldAddNamespaceWithEmptyKeyFromParameterAsDefaultNamespaceToRecordTag() { simpleXmlEncoder.setNamespaces("=http://example.org/ns"); @@ -221,7 +224,7 @@ public void shouldAddNamespaceWithEmptyKeyFromParameterAsDefaultNamespaceToRecor emitEmptyRecord(); - assertEquals("", + Assert.assertEquals("", getResultXml()); } @@ -232,7 +235,7 @@ public void testShouldEncodeUnnamedLiteralsAsText() { simpleXmlEncoder.endRecord(); simpleXmlEncoder.closeStream(); - assertEquals("" + + Assert.assertEquals("" + "" + "" + "value" + @@ -251,7 +254,7 @@ public void testShouldStillEncodeUnnamedLiteralsAsTextWithConfiguredValueTagName simpleXmlEncoder.closeStream(); // SimpleXmlEncoder.Element.writeElement() does not write child elements with empty name - assertEquals("" + + Assert.assertEquals("" + "" + "" + "value" + @@ -269,7 +272,7 @@ public void testShouldNotEncodeLiteralsWithDifferentValueTagNameAsText() { simpleXmlEncoder.endRecord(); simpleXmlEncoder.closeStream(); - assertEquals("" + + Assert.assertEquals("" + "" + "" + "value" + @@ -288,7 +291,7 @@ public void issue379_testShouldEncodeConfiguredValueLiteralsAsText() { simpleXmlEncoder.endRecord(); simpleXmlEncoder.closeStream(); - assertEquals("" + + Assert.assertEquals("" + "" + "" + "value" + @@ -304,7 +307,7 @@ public void issue379_testShouldNotEncodeUnconfiguredValueLiteralsAsText() { simpleXmlEncoder.endRecord(); simpleXmlEncoder.closeStream(); - assertEquals("" + + Assert.assertEquals("" + "" + "" + "value" + @@ -321,7 +324,7 @@ public void testShouldEncodeMarkedLiteralsAsAttributes() { simpleXmlEncoder.endRecord(); simpleXmlEncoder.closeStream(); - assertEquals("" + + Assert.assertEquals("" + "" + "" + "value" + @@ -341,7 +344,7 @@ public void testShouldNotEncodeMarkedEntitiesAsAttributes() { simpleXmlEncoder.endRecord(); simpleXmlEncoder.closeStream(); - assertEquals("" + + Assert.assertEquals("" + "" + "" + "<~entity>" + @@ -362,7 +365,7 @@ public void testShouldNotEncodeLiteralsWithDifferentMarkerAsAttributes() { simpleXmlEncoder.endRecord(); simpleXmlEncoder.closeStream(); - assertEquals("" + + Assert.assertEquals("" + "" + "" + "value" + @@ -383,7 +386,7 @@ public void testShouldEncodeMarkedLiteralsWithConfiguredMarkerAsAttributes() { simpleXmlEncoder.endRecord(); simpleXmlEncoder.closeStream(); - assertEquals("" + + Assert.assertEquals("" + "" + "" + "value" + diff --git a/metafacture-xml/src/test/java/org/metafacture/xml/XmlDecoderTest.java b/metafacture-xml/src/test/java/org/metafacture/xml/XmlDecoderTest.java index 7414aece7..319cb074f 100644 --- a/metafacture-xml/src/test/java/org/metafacture/xml/XmlDecoderTest.java +++ b/metafacture-xml/src/test/java/org/metafacture/xml/XmlDecoderTest.java @@ -16,9 +16,10 @@ package org.metafacture.xml; +import org.metafacture.framework.MetafactureException; + import org.junit.Before; import org.junit.Test; -import org.metafacture.framework.MetafactureException; import java.io.IOException; import java.io.Reader; @@ -31,10 +32,14 @@ */ public final class XmlDecoderTest { - private final String TEST_XML_WITH_TWO_ENTITIES = ">>"; + private static final String TEST_XML_WITH_TWO_ENTITIES = ">>"; + private XmlDecoder xmlDecoder; private final Reader reader = new StringReader(TEST_XML_WITH_TWO_ENTITIES); + public XmlDecoderTest() { + } + @Before public void initSystemUnderTest() { xmlDecoder = new XmlDecoder(); @@ -42,27 +47,27 @@ public void initSystemUnderTest() { @Test public void issue554_default() { - process(xmlDecoder); + process(); } @Test(expected = MetafactureException.class) public void issue554_shouldFail() { xmlDecoder.setTotalEntitySizeLimit("1"); - process(xmlDecoder); + process(); } @Test public void issue554_unlimitedEntities() { xmlDecoder.setTotalEntitySizeLimit("0"); - process(xmlDecoder); + process(); } - private void process(XmlDecoder xmlDecoder) { + private void process() { try { xmlDecoder.process(reader); reader.close(); } - catch (IOException e) { + catch (final IOException e) { throw new RuntimeException(e); } } diff --git a/metafacture-xml/src/test/java/org/metafacture/xml/XmlElementSplitterTest.java b/metafacture-xml/src/test/java/org/metafacture/xml/XmlElementSplitterTest.java index 792d84d8c..640a6996e 100644 --- a/metafacture-xml/src/test/java/org/metafacture/xml/XmlElementSplitterTest.java +++ b/metafacture-xml/src/test/java/org/metafacture/xml/XmlElementSplitterTest.java @@ -16,14 +16,14 @@ package org.metafacture.xml; -import static org.mockito.Mockito.inOrder; +import org.metafacture.framework.StreamReceiver; import org.junit.Before; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; import org.xml.sax.SAXException; @@ -49,6 +49,9 @@ public class XmlElementSplitterTest { private XmlElementSplitter xmlElementSplitter; + public XmlElementSplitterTest() { + } + @Before public void setup() { xmlElementSplitter = new XmlElementSplitter(); @@ -71,7 +74,7 @@ public void shouldSplitXmlAtDefinedElementName() throws SAXException { xmlElementSplitter.endElement(NAMESPACE, "Description", "rdf:Description"); xmlElementSplitter.endElement(NAMESPACE, "RDF", "rdf:RDF"); - final InOrder ordered = inOrder(receiver); + final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord("0"); ordered.verify(receiver).literal("Element", "1"); diff --git a/metafacture-xml/src/test/java/org/metafacture/xml/XmlFilenameWriterTest.java b/metafacture-xml/src/test/java/org/metafacture/xml/XmlFilenameWriterTest.java index 920d46039..8b2d793a9 100644 --- a/metafacture-xml/src/test/java/org/metafacture/xml/XmlFilenameWriterTest.java +++ b/metafacture-xml/src/test/java/org/metafacture/xml/XmlFilenameWriterTest.java @@ -16,18 +16,17 @@ package org.metafacture.xml; -import static org.junit.Assert.assertEquals; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TemporaryFolder; - /** * Extracts records from an xml file and writes single xml files into * filesystem. The name of the xml files are generated by extracting a value @@ -43,6 +42,9 @@ public class XmlFilenameWriterTest { private XmlFilenameWriter xmlFilenameWriter; + public XmlFilenameWriterTest() { + } + @Before public void createSystemUnderTest() { xmlFilenameWriter = new XmlFilenameWriter(); @@ -62,8 +64,8 @@ public void testPicaXmlSplits() throws IOException { xmlFilenameWriter.literal("Element", createXml("2")); xmlFilenameWriter.endRecord(); - assertEquals(createXml("1"), readFile("1/1.xml")); - assertEquals(createXml("2"), readFile("2/2.xml")); + Assert.assertEquals(createXml("1"), readFile("1/1.xml")); + Assert.assertEquals(createXml("2"), readFile("2/2.xml")); } private String readFile(final String fileName) throws IOException { diff --git a/metafacture-yaml/src/test/java/org/metafacture/yaml/YamlDecoderTest.java b/metafacture-yaml/src/test/java/org/metafacture/yaml/YamlDecoderTest.java index 59fd2838d..278df77a4 100644 --- a/metafacture-yaml/src/test/java/org/metafacture/yaml/YamlDecoderTest.java +++ b/metafacture-yaml/src/test/java/org/metafacture/yaml/YamlDecoderTest.java @@ -51,6 +51,9 @@ public final class YamlDecoderTest { @Mock private StreamReceiver receiver; + public YamlDecoderTest() { + } + @Test public void testShouldProcessEmptyStrings() { assertDecode( @@ -300,7 +303,7 @@ private void assertException(final String message, final Consumer i exception.expect(MetafactureException.class); exception.expectMessage(message); - assertDecode(in, o -> {}); + assertDecode(in, o -> { }); } private void assertDecode(final Consumer in, final Consumer> out) { diff --git a/metafacture-yaml/src/test/java/org/metafacture/yaml/YamlEncoderTest.java b/metafacture-yaml/src/test/java/org/metafacture/yaml/YamlEncoderTest.java index 648176bcc..c45692701 100644 --- a/metafacture-yaml/src/test/java/org/metafacture/yaml/YamlEncoderTest.java +++ b/metafacture-yaml/src/test/java/org/metafacture/yaml/YamlEncoderTest.java @@ -61,6 +61,9 @@ public final class YamlEncoderTest { @Mock private ObjectReceiver receiver; + public YamlEncoderTest() { + } + @Test public void testShouldEncodeLiterals() { assertEncode( diff --git a/metamorph-test/src/test/java/org/metafacture/metamorph/test/FrameworkTest.java b/metamorph-test/src/test/java/org/metafacture/metamorph/test/FrameworkTest.java index 39808460c..1bf5c69b1 100644 --- a/metamorph-test/src/test/java/org/metafacture/metamorph/test/FrameworkTest.java +++ b/metamorph-test/src/test/java/org/metafacture/metamorph/test/FrameworkTest.java @@ -18,7 +18,6 @@ import org.junit.runner.RunWith; - /** * Tests binding Metamorph-Test to JUnit. * @@ -26,6 +25,11 @@ */ @RunWith(MetamorphTestSuite.class) public final class FrameworkTest { + // This class serves only as a bonding // point for metamorph tests + + public FrameworkTest() { + } + } diff --git a/metamorph-test/src/test/java/org/metafacture/metamorph/test/MetamorphTestCaseTest.java b/metamorph-test/src/test/java/org/metafacture/metamorph/test/MetamorphTestCaseTest.java index 9a82ba96c..47e1082d7 100644 --- a/metamorph-test/src/test/java/org/metafacture/metamorph/test/MetamorphTestCaseTest.java +++ b/metamorph-test/src/test/java/org/metafacture/metamorph/test/MetamorphTestCaseTest.java @@ -16,16 +16,16 @@ package org.metafacture.metamorph.test; -import javax.xml.parsers.DocumentBuilder; -import javax.xml.parsers.DocumentBuilderFactory; -import javax.xml.parsers.ParserConfigurationException; - import org.junit.Before; import org.junit.Test; import org.junit.runners.model.InitializationError; import org.w3c.dom.Document; import org.w3c.dom.Element; +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; + /** * Test cases for class {@link MetamorphTestCase}. * @@ -41,6 +41,9 @@ public final class MetamorphTestCaseTest { private Document document; + public MetamorphTestCaseTest() { + } + @Before public void createXmlDocument() { final DocumentBuilderFactory docBuilderFactory = @@ -48,7 +51,8 @@ public void createXmlDocument() { final DocumentBuilder docBuilder; try { docBuilder = docBuilderFactory.newDocumentBuilder(); - } catch(final ParserConfigurationException e) { + } + catch (final ParserConfigurationException e) { throw new AssertionError( "No error expected when creating a standard document builder", e); } diff --git a/metamorph-test/src/test/java/org/metafacture/metamorph/test/TestCaseRunnerMetamorphTest.java b/metamorph-test/src/test/java/org/metafacture/metamorph/test/TestCaseRunnerMetamorphTest.java index 3569ab228..2e5ea4b43 100644 --- a/metamorph-test/src/test/java/org/metafacture/metamorph/test/TestCaseRunnerMetamorphTest.java +++ b/metamorph-test/src/test/java/org/metafacture/metamorph/test/TestCaseRunnerMetamorphTest.java @@ -16,8 +16,7 @@ package org.metafacture.metamorph.test; -import static org.junit.Assert.assertNotNull; - +import org.junit.Assert; import org.junit.Test; import org.junit.runner.Description; import org.junit.runners.model.InitializationError; @@ -29,16 +28,23 @@ */ public final class TestCaseRunnerMetamorphTest { + public TestCaseRunnerMetamorphTest() { + } + @Test public void issue213ShouldNotInitAnnotationsArrayWithNull() throws InitializationError { - final MetamorphTestRunner runner = new MetamorphTestRunner(Dummy.class, "/org/metafacture/metamorph/test/test-case-runner-test-dummy.xml"); final MetamorphTestCase metamorphTestCase = runner.getChildren().get(0); final Description description = runner.describeChild(metamorphTestCase); - assertNotNull(description.getAnnotations()); + Assert.assertNotNull(description.getAnnotations()); } - public static final class Dummy {}; + public static final class Dummy { + + public Dummy() { + } + + } } diff --git a/metamorph-test/src/test/java/org/metafacture/metamorph/test/validators/StreamValidatorTest.java b/metamorph-test/src/test/java/org/metafacture/metamorph/test/validators/StreamValidatorTest.java index e55c9c41e..0021690d7 100644 --- a/metamorph-test/src/test/java/org/metafacture/metamorph/test/validators/StreamValidatorTest.java +++ b/metamorph-test/src/test/java/org/metafacture/metamorph/test/validators/StreamValidatorTest.java @@ -16,18 +16,17 @@ package org.metafacture.metamorph.test.validators; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.atLeastOnce; -import static org.mockito.Mockito.verify; - -import java.util.function.Consumer; +import org.metafacture.javaintegration.EventList; import org.junit.Before; import org.junit.Test; -import org.metafacture.javaintegration.EventList; +import org.mockito.ArgumentMatchers; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.util.function.Consumer; + /** * Tests for class {@link StreamValidator}. * @@ -39,6 +38,9 @@ public final class StreamValidatorTest { @Mock private Consumer errorHandler; + public StreamValidatorTest() { + } + @Before public void initMocks() { MockitoAnnotations.initMocks(this); @@ -57,7 +59,7 @@ public void shouldFailIfEndRecordEventIsMissing() { validator.startRecord("1"); validator.closeStream(); - verify(errorHandler, atLeastOnce()).accept(any()); + Mockito.verify(errorHandler, Mockito.atLeastOnce()).accept(ArgumentMatchers.any()); } } diff --git a/metamorph-test/src/test/java/org/metafacture/metamorph/test/validators/WellformednessCheckerTest.java b/metamorph-test/src/test/java/org/metafacture/metamorph/test/validators/WellformednessCheckerTest.java index dc3a5a026..1a7175bd7 100644 --- a/metamorph-test/src/test/java/org/metafacture/metamorph/test/validators/WellformednessCheckerTest.java +++ b/metamorph-test/src/test/java/org/metafacture/metamorph/test/validators/WellformednessCheckerTest.java @@ -16,17 +16,15 @@ package org.metafacture.metamorph.test.validators; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; - -import java.util.function.Consumer; - import org.junit.Before; import org.junit.Test; +import org.mockito.ArgumentMatchers; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; +import java.util.function.Consumer; + /** * Tests for class {@link WellformednessChecker}. * @@ -40,6 +38,9 @@ public final class WellformednessCheckerTest { private WellformednessChecker wellformednessChecker; + public WellformednessCheckerTest() { + } + @Before public void setup() { MockitoAnnotations.initMocks(this); @@ -65,21 +66,21 @@ public void shouldAcceptValidStream() { wellformednessChecker.endRecord(); wellformednessChecker.closeStream(); - verifyZeroInteractions(errorHandler); + Mockito.verifyZeroInteractions(errorHandler); } @Test public void shouldAcceptEmptyStream() { wellformednessChecker.closeStream(); - verifyZeroInteractions(errorHandler); + Mockito.verifyZeroInteractions(errorHandler); } @Test public void shouldReportNullRecordId() { wellformednessChecker.startRecord(null); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } @Test @@ -87,7 +88,7 @@ public void shouldReportNullEntityName() { wellformednessChecker.startRecord("id1"); wellformednessChecker.startEntity(null); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } @Test @@ -95,31 +96,31 @@ public void shouldReportNullLiteralName() { wellformednessChecker.startRecord("id1"); wellformednessChecker.literal(null, "value1"); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } @Test public void shouldNotIgnoreStartRecordEventWithNullId() { wellformednessChecker.startRecord(null); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); wellformednessChecker.literal("literal", "value"); wellformednessChecker.endRecord(); - verifyZeroInteractions(errorHandler); + Mockito.verifyZeroInteractions(errorHandler); } @Test public void shouldNotIgnoreStartEntityEventWithNullName() { wellformednessChecker.startRecord("id"); wellformednessChecker.startEntity(null); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); wellformednessChecker.literal("literal", "value"); wellformednessChecker.endEntity(); wellformednessChecker.endRecord(); - verifyZeroInteractions(errorHandler); + Mockito.verifyZeroInteractions(errorHandler); } @Test @@ -127,28 +128,28 @@ public void shouldReportStartRecordInsideRecord() { wellformednessChecker.startRecord("id1"); wellformednessChecker.startRecord("id2"); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } @Test public void shouldReportEndRecordOutsideRecord() { wellformednessChecker.endRecord(); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } @Test public void shouldReportStartEntityOutsideRecord() { wellformednessChecker.startEntity("entity1"); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } @Test public void shouldReportEndEntityOutsideRecord() { wellformednessChecker.endEntity(); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } @Test @@ -156,14 +157,14 @@ public void shouldReportUnmatchedEndEntity() { wellformednessChecker.startRecord("id1"); wellformednessChecker.endEntity(); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } @Test public void shouldReportLiteralOutsideRecord() { wellformednessChecker.literal("literal1", "value1"); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } @Test @@ -171,7 +172,7 @@ public void shouldReportUnclosedRecord() { wellformednessChecker.startRecord("id1"); wellformednessChecker.closeStream(); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } @Test @@ -180,7 +181,7 @@ public void shouldReportUnclosedEntityAtEndRecord() { wellformednessChecker.startEntity("entity1"); wellformednessChecker.endRecord(); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } @Test @@ -189,7 +190,7 @@ public void shouldReportUnclosedEntityAtCloseStream() { wellformednessChecker.startEntity("entity1"); wellformednessChecker.closeStream(); - verify(errorHandler).accept(any()); + Mockito.verify(errorHandler).accept(ArgumentMatchers.any()); } } diff --git a/metamorph/src/test/java/org/metafacture/metamorph/InlineMorphTest.java b/metamorph/src/test/java/org/metafacture/metamorph/InlineMorphTest.java index 9b4ed8a24..16e839d09 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/InlineMorphTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/InlineMorphTest.java @@ -28,6 +28,9 @@ public final class InlineMorphTest { private static final String SUFFIX = "\n\n"; + public InlineMorphTest() { + } + @Test public void shouldProvideEmptyStringRepresentation() { Assert.assertEquals("", InlineMorph.in(this).toString()); diff --git a/metamorph/src/test/java/org/metafacture/metamorph/MetamorphTest.java b/metamorph/src/test/java/org/metafacture/metamorph/MetamorphTest.java index e2e8b146f..dcf722815 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/MetamorphTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/MetamorphTest.java @@ -17,15 +17,14 @@ package org.metafacture.metamorph; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; +import org.metafacture.framework.helpers.DefaultStreamReceiver; +import org.metafacture.metamorph.api.Maps; +import org.metafacture.metamorph.api.NamedValueReceiver; +import org.junit.Assert; import org.junit.Before; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.helpers.DefaultStreamReceiver; -import org.metafacture.metamorph.api.Maps; -import org.metafacture.metamorph.api.NamedValueReceiver; import org.mockito.ArgumentMatchers; import org.mockito.Mock; import org.mockito.Mockito; @@ -53,6 +52,9 @@ public final class MetamorphTest { private Metamorph metamorph; + public MetamorphTest() { + } + @Before public void createSystemUnderTest() { metamorph = new Metamorph(); @@ -96,6 +98,7 @@ public void shouldNotMapMatchingLiteralInNonMatchingEntity() { i.literal("testLiteral", "testValue"); }); } + @Test public void shouldNotMapLiteralWithoutMatchingEntity() { assertNamedValue(false, i -> { @@ -128,8 +131,8 @@ public void shouldReturnValueFromNestedMap() { metamorph.putMap("testMap", map); - assertNotNull(metamorph.getMap("testMap")); - assertEquals("testValue", metamorph.getValue("testMap", "outName")); + Assert.assertNotNull(metamorph.getMap("testMap")); + Assert.assertEquals("testValue", metamorph.getValue("testMap", "outName")); } @Test @@ -139,10 +142,10 @@ public void shouldReturnDefaultValueIfMapIsKnownButNameIsUnknown() { metamorph.putMap("testMap", map); - assertEquals("defaultValue", metamorph.getValue("testMap", "nameNotInMap")); + Assert.assertEquals("defaultValue", metamorph.getValue("testMap", "nameNotInMap")); } - @Test(expected=IllegalStateException.class) + @Test(expected = IllegalStateException.class) public void shouldThrowIllegalStateExceptionIfEntityIsNotClosed() { metamorph.startRecord(""); metamorph.startEntity("testEntity"); diff --git a/metamorph/src/test/java/org/metafacture/metamorph/SplitterTest.java b/metamorph/src/test/java/org/metafacture/metamorph/SplitterTest.java index d1afef6a4..a23bf8b2f 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/SplitterTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/SplitterTest.java @@ -16,9 +16,10 @@ package org.metafacture.metamorph; +import org.metafacture.framework.StreamReceiver; + import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.Mockito; @@ -48,6 +49,9 @@ public final class SplitterTest { @Mock private StreamReceiver receiver2; + public SplitterTest() { + } + @Test public void shouldPassRecordToReceiverWithMatchingKey() { assertSplitter( diff --git a/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java b/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java index 6d9694f94..187c3317f 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/TestHelpers.java @@ -17,6 +17,7 @@ package org.metafacture.metamorph; import org.metafacture.framework.StreamReceiver; + import org.mockito.InOrder; import org.mockito.Mockito; import org.mockito.exceptions.base.MockitoAssertionError; @@ -33,6 +34,9 @@ */ public final class TestHelpers { + private TestHelpers() { + } + public static void assertMorph(final StreamReceiver receiver, final String morphDef, final Consumer in, final Consumer> out) { assertMorph(receiver, morphDef, in, (s, f) -> out.accept(s)); } diff --git a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java index 6e631f3b2..c35543423 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphBasics.java @@ -16,11 +16,10 @@ package org.metafacture.metamorph; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -38,9 +37,12 @@ public final class TestMetamorphBasics { @Mock private StreamReceiver receiver; + public TestMetamorphBasics() { + } + @Test public void shouldUseCustomEntityMarker() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + @@ -64,7 +66,7 @@ public void shouldUseCustomEntityMarker() { @Test public void shouldHandleUnmatchedLiteralsInElseSource() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -97,7 +99,7 @@ public void shouldHandleUnmatchedLiteralsAndEntitiesInElseFlattenedSource() { } private void testElseData(final String elseKeyword) { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -136,9 +138,9 @@ private void testElseData(final String elseKeyword) { ); } - @Test + @Test // checkstyle-disable-line JavaNCSS public void issue338_shouldPreserveSameEntitiesInElseNestedSource() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + "", @@ -219,7 +221,7 @@ public void issue338_shouldPreserveSameEntitiesInElseNestedSource() { @Test public void issue374_shouldPropagateArrayMarkersInElseNestedSource() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + "", @@ -269,9 +271,9 @@ public void issue374_shouldPropagateArrayMarkersInElseNestedSource() { ); } - @Test + @Test // checkstyle-disable-line JavaNCSS public void issue378_shouldOutputMoreThanTwoLevelsInElseNestedSource() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + "", @@ -351,9 +353,9 @@ public void issue378_shouldOutputMoreThanTwoLevelsInElseNestedSource() { ); } - @Test + @Test // checkstyle-disable-line JavaNCSS public void shouldOutputMoreThanTwoLevelsInElseNestedSourceWithModifications() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -439,7 +441,7 @@ public void shouldOutputMoreThanTwoLevelsInElseNestedSourceWithModifications() { @Test public void shouldHandleUnmatchedLiteralsAndEntitiesInElseNestedSource() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -477,9 +479,9 @@ public void shouldHandleUnmatchedLiteralsAndEntitiesInElseNestedSource() { ); } - @Test + @Test // checkstyle-disable-line JavaNCSS public void shouldHandlePartiallyUnmatchedLiteralsAndEntitiesInElseNestedSource() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -590,7 +592,7 @@ else if (separatesFromEntity) { @Test public void shouldNotHandleDataByElseNestedSourceIfDataBelongingToEntityIsRuledByMorph() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -651,9 +653,9 @@ public void shouldNotHandleDataByElseNestedSourceIfDataBelongingToEntityIsRuledB } // https://github.com/hagbeck/metafacture-sandbox/tree/master/else-nested-entities - @Test + @Test // checkstyle-disable-line JavaNCSS public void shouldHandleUseCaseSandboxElseNestedEntities() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + "" + "" + @@ -758,10 +760,9 @@ public void shouldHandleUseCaseSandboxElseNestedEntities() { ); } - @Test public void shouldMatchCharacterWithQuestionMarkWildcard() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + "", @@ -783,7 +784,7 @@ public void shouldMatchCharacterWithQuestionMarkWildcard() { @Test public void shouldMatchCharactersInCharacterClass() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + "", @@ -805,7 +806,7 @@ public void shouldMatchCharactersInCharacterClass() { @Test public void shouldReplaceVariables() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -828,7 +829,7 @@ public void shouldReplaceVariables() { @Test public void shouldAllowTreatingEntityEndEventsAsLiterals() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java index 0c5c3ba2e..6e541c0a7 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/TestMetamorphMacros.java @@ -16,11 +16,10 @@ package org.metafacture.metamorph; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -38,9 +37,12 @@ public class TestMetamorphMacros { @Mock private StreamReceiver receiver; + public TestMetamorphMacros() { + } + @Test public void shouldReplaceCallMacroWithMacro() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -162,7 +164,7 @@ public void shouldSupportXPointer() { } private void testSingleLiteral(final boolean withEntity, final String morphDef) { - assertMorph(receiver, morphDef, + TestHelpers.assertMorph(receiver, morphDef, i -> { i.startRecord("1"); i.literal("Honolulu", "Aloha"); diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/AllTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/AllTest.java index 8f4513abb..4b08421ec 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/AllTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/AllTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -38,9 +38,12 @@ public final class AllTest { @Mock private StreamReceiver receiver; + public AllTest() { + } + @Test public void shouldFireOnlyIfAllElementsFire() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -68,7 +71,7 @@ public void shouldFireOnlyIfAllElementsFire() { @Test public void shouldSupportUserdefinedNameAndValue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -91,7 +94,7 @@ public void shouldSupportUserdefinedNameAndValue() { @Test public void shouldFireAgainIfValueChangesAndResetIsFalse() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -119,7 +122,7 @@ public void shouldFireAgainIfValueChangesAndResetIsFalse() { @Test public void shouldNotFireAgainIfOnlyOneValueChangesAndResetIsTrue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -147,7 +150,7 @@ public void shouldNotFireAgainIfOnlyOneValueChangesAndResetIsTrue() { @Test public void shouldNotFireIfFlushingAnIncompleteCollection() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -170,7 +173,7 @@ public void shouldNotFireIfFlushingAnIncompleteCollection() { @Test public void shouldResetWhenEntityChangesIfSameEntity() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/AnyTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/AnyTest.java index f76b64056..24ddf9594 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/AnyTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/AnyTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -38,9 +38,12 @@ public final class AnyTest { @Mock private StreamReceiver receiver; + public AnyTest() { + } + @Test public void shouldFireOnlyIfAtLeastOneElementFires() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -73,7 +76,7 @@ public void shouldFireOnlyIfAtLeastOneElementFires() { @Test public void shouldSupportUserdefinedNameAndValue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -95,7 +98,7 @@ public void shouldSupportUserdefinedNameAndValue() { @Test public void shouldNotFireAgainIfAdditionalValueIsReceivedAndResetIsFalse() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -119,7 +122,7 @@ public void shouldNotFireAgainIfAdditionalValueIsReceivedAndResetIsFalse() { @Test public void shouldFireAgainIfAdditionalValueIsReceivedAndResetIsTrue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -143,7 +146,7 @@ public void shouldFireAgainIfAdditionalValueIsReceivedAndResetIsTrue() { @Test public void shouldFireAgainAfterFlushing() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -170,7 +173,7 @@ public void shouldFireAgainAfterFlushing() { @Test public void shouldNotFireIfFlushingAnUntriggeredCollection() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/ChooseTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/ChooseTest.java index b3a9c068d..b77e34c1f 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/ChooseTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/ChooseTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -39,9 +39,12 @@ public final class ChooseTest { @Mock private StreamReceiver receiver; + public ChooseTest() { + } + @Test public void shouldChooseValueOfTopMostFiringStatement() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -77,7 +80,7 @@ public void shouldChooseValueOfTopMostFiringStatement() { @Test public void shouldMakeChooseDecisionOnFlushEvent() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -114,7 +117,7 @@ public void shouldMakeChooseDecisionOnFlushEvent() { @Test public void issue110_shouldOutputFallBackIfFlushedWithEntity() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -136,7 +139,7 @@ public void issue110_shouldOutputFallBackIfFlushedWithEntity() { @Test public void issue210_issue49_shouldRepeatedlyEmitNamedValueIfResetIsFalse() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -159,7 +162,7 @@ public void issue210_issue49_shouldRepeatedlyEmitNamedValueIfResetIsFalse() { @Test public void issue210_shouldResetAfterEmittingNamedValueIfResetIsTrue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -182,7 +185,7 @@ public void issue210_shouldResetAfterEmittingNamedValueIfResetIsTrue() { @Test public void issue210_shouldResetAfterEmittingNamedValueByDefault() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -205,7 +208,7 @@ public void issue210_shouldResetAfterEmittingNamedValueByDefault() { @Test public void issue250_shouldResetOnEntityChangeIfSameEntityIsTrue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -232,7 +235,7 @@ public void issue250_shouldResetOnEntityChangeIfSameEntityIsTrue() { @Test public void issue250_shouldNotResetOnEntityChangeIfSameEntityIsFalse() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -259,7 +262,7 @@ public void issue250_shouldNotResetOnEntityChangeIfSameEntityIsFalse() { @Test public void issue250_shouldNotResetOnEntityChangeByDefault() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/CombineTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/CombineTest.java index ce6b3e1ea..a808a5ed9 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/CombineTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/CombineTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -39,9 +39,12 @@ public final class CombineTest { @Mock private StreamReceiver receiver; + public CombineTest() { + } + @Test public void shouldCombineTwoValues() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -66,7 +69,7 @@ public void shouldCombineTwoValues() { @Test public void shouldOnlyCombineValuesFromTheSameEntityIfSet() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -103,7 +106,7 @@ public void shouldOnlyCombineValuesFromTheSameEntityIfSet() { @Test public void shouldResetCombinedValueIfResetIsTrue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -130,7 +133,7 @@ public void shouldResetCombinedValueIfResetIsTrue() { @Test public void shouldEmitCurrentValueOnFlushEvent() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -163,7 +166,7 @@ public void shouldEmitCurrentValueOnFlushEvent() { @Test public void shouldNotEmitCurrentValueOnFlushEventIfIncomplete() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -194,7 +197,7 @@ public void shouldNotEmitCurrentValueOnFlushEventIfIncomplete() { @Test public void shouldPostprocessCombinedValue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/ConcatTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/ConcatTest.java index c7036e3cb..a77ba3785 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/ConcatTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/ConcatTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -39,9 +39,12 @@ public final class ConcatTest { @Mock private StreamReceiver receiver; + public ConcatTest() { + } + @Test public void shouldConcatenateValues() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -73,7 +76,7 @@ public void shouldConcatenateValues() { @Test public void shouldEmitConcatenatedValueOnFlushEvent() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -105,7 +108,7 @@ public void shouldEmitConcatenatedValueOnFlushEvent() { @Test public void shouldEmitEmptyValues() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -129,7 +132,7 @@ public void shouldEmitEmptyValues() { @Test public void shouldReverseConcatenationIfReverseIsTrue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -153,7 +156,7 @@ public void shouldReverseConcatenationIfReverseIsTrue() { @Test public void prefixAndPostfixShouldWorkAsNormalIfReverseIsTrue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -177,7 +180,7 @@ public void prefixAndPostfixShouldWorkAsNormalIfReverseIsTrue() { @Test public void issue187_shouldUseEmptyDelimiterAsDefault() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/EntityTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/EntityTest.java index 4556f7c22..d0f92c2ba 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/EntityTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/EntityTest.java @@ -16,12 +16,12 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.Entity; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; -import org.metafacture.metamorph.Entity; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -40,9 +40,12 @@ public final class EntityTest { @Mock private StreamReceiver receiver; + public EntityTest() { + } + @Test public void shouldEmitEntities() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -80,7 +83,7 @@ public void shouldEmitEntities() { @Test public void shouldEmitEntityOnFlushEvent() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -116,7 +119,7 @@ public void shouldEmitEntityOnFlushEvent() { @Test public void shouldNotEmitEntityOnFlushEventIfIncomplete() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -149,7 +152,7 @@ public void shouldNotEmitEntityOnFlushEventIfIncomplete() { @Test public void shouldEmitEntityOnEachFlushEvent() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + @@ -188,7 +191,7 @@ public void shouldEmitEntityOnEachFlushEvent() { @Test public void shouldSupportNestedEntities() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -245,7 +248,7 @@ public void shouldSupportNestedEntities() { @Test public void shouldSupportMultipleNestedEntities() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -302,7 +305,7 @@ public void shouldSupportMultipleNestedEntities() { @Test public void shouldSupportDeeplyNestedEnities() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -340,7 +343,7 @@ public void shouldSupportDeeplyNestedEnities() { @Test public void shouldGetNameFromDataInEntityName() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -383,7 +386,7 @@ public void shouldGetNameFromDataInEntityName() { @Test public void shouldGetNameFromCollectInEntityName() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -427,7 +430,7 @@ public void shouldGetNameFromCollectInEntityName() { @Test public void shouldResetNameToNameAttribute() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -462,7 +465,7 @@ public void shouldResetNameToNameAttribute() { @Test public void shouldEmitEmptyStringIfEntityNameIsNotSet() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -485,7 +488,7 @@ public void shouldEmitEmptyStringIfEntityNameIsNotSet() { @Test public void shouldEmitEntityContentsAgainIfResetIsFalse() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -517,7 +520,7 @@ public void shouldEmitEntityContentsAgainIfResetIsFalse() { @Test public void shouldNotEmitEntityContentsAgainIfResetIsTrue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/EqualsFilterTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/EqualsFilterTest.java index e92b33cf0..38b17c120 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/EqualsFilterTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/EqualsFilterTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.ArgumentMatchers; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; @@ -40,9 +40,12 @@ public final class EqualsFilterTest { @Mock private StreamReceiver receiver; + public EqualsFilterTest() { + } + @Test public void shouldEmitValueIfAllReceivedValuesAreEqual() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -67,7 +70,7 @@ public void shouldEmitValueIfAllReceivedValuesAreEqual() { @Test public void shouldEmitNothingIfReceivedValuesDiffer() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -92,7 +95,7 @@ public void shouldEmitNothingIfReceivedValuesDiffer() { @Test public void shouldFireIfOnlyASingleValueIsReceived() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -113,7 +116,7 @@ public void shouldFireIfOnlyASingleValueIsReceived() { @Test public void shouldIgnoreLiteralsNotListedInStatements() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -137,7 +140,7 @@ public void shouldIgnoreLiteralsNotListedInStatements() { @Test public void shouldFireIfValuesInEntityAreEqual() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -164,7 +167,7 @@ public void shouldFireIfValuesInEntityAreEqual() { @Test public void shouldNotFireIfValuesInEntityAreNotEqual() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -190,7 +193,7 @@ public void shouldNotFireIfValuesInEntityAreNotEqual() { @Test public void shouldFireIfLiteralsInEntitiesAreReceivedThatAreNotListedInStatements() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -229,7 +232,7 @@ public void shouldFireIfLiteralsInEntitiesAreReceivedThatAreNotListedInStatement @Test public void shouldFireOnFlush() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -269,7 +272,7 @@ public void shouldFireOnFlush() { @Test public void shouldNotFireOnFlushIfIncomplete() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/GroupTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/GroupTest.java index 8a40704f1..e29cef6d1 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/GroupTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/GroupTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -39,9 +39,12 @@ public final class GroupTest { @Mock private StreamReceiver receiver; + public GroupTest() { + } + @Test public void shouldGroupToOverwriteNameAndValueOfContaintStatements() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/NoneTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/NoneTest.java index 31a4c58ac..4a1e6a53f 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/NoneTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/NoneTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -38,9 +38,12 @@ public final class NoneTest { @Mock private StreamReceiver receiver; + public NoneTest() { + } + @Test public void shouldFireOnlyifNoElementFired() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -72,7 +75,7 @@ public void shouldFireOnlyifNoElementFired() { @Test public void shouldSupportUserdefinedNameAndValue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -89,12 +92,12 @@ public void shouldSupportUserdefinedNameAndValue() { o.get().literal("NONE", "found none"); o.get().endRecord(); } - ); + ); } @Test public void shouldNotFireAgainIfFlushedTwoTimesAndResetIsFalse() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -120,7 +123,7 @@ public void shouldNotFireAgainIfFlushedTwoTimesAndResetIsFalse() { @Test public void shouldFireAgainIfFlushedTwoTimesAndTesetIsTrue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -146,7 +149,7 @@ public void shouldFireAgainIfFlushedTwoTimesAndTesetIsTrue() { @Test public void shouldResetWhenEntityChangesIfSameEntity() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/RangeTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/RangeTest.java index a706e0035..b305f6771 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/RangeTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/RangeTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -38,9 +38,12 @@ public final class RangeTest { @Mock private StreamReceiver receiver; + public RangeTest() { + } + @Test public void shouldOutputAllnNmbersbBetweenFirstAndLastInclusive() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -68,7 +71,7 @@ public void shouldOutputAllnNmbersbBetweenFirstAndLastInclusive() { @Test public void shouldOutputFirstIfLastEqualsFirst() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -86,12 +89,12 @@ public void shouldOutputFirstIfLastEqualsFirst() { o.get().literal("range", "1989"); o.get().endRecord(); } - ); + ); } @Test public void shouldOutputMultipleRanges() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -125,7 +128,7 @@ public void shouldOutputMultipleRanges() { @Test public void shouldRemoveDuplicateNumbersFromOverlappingRanges() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -153,7 +156,7 @@ public void shouldRemoveDuplicateNumbersFromOverlappingRanges() { @Test public void shouldUseUserdefinedIncrement() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -179,7 +182,7 @@ public void shouldUseUserdefinedIncrement() { @Test public void shouldAllowNegativeIncrements() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/SquareTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/SquareTest.java index 44f2fcd3d..f8638c752 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/SquareTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/SquareTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -39,9 +39,12 @@ public final class SquareTest { @Mock private StreamReceiver receiver; + public SquareTest() { + } + @Test public void shouldEmitSquaresOfInputValues() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -99,7 +102,7 @@ public void shouldEmitSquaresOfInputValues() { @Test public void shouldEmitSquaresOnFlushEvent() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/TestCollectorBasics.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/TestCollectorBasics.java index 408394ba4..4031c6a6b 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/TestCollectorBasics.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/TestCollectorBasics.java @@ -16,12 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; -import org.metafacture.metamorph.Metamorph; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -42,9 +41,12 @@ public final class TestCollectorBasics { @Mock private StreamReceiver receiver; + public TestCollectorBasics() { + } + @Test public void shouldSupportNestedCollectors() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -74,7 +76,7 @@ public void shouldSupportNestedCollectors() { @Test public void shouldSupportNestedSameEntity() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -116,7 +118,7 @@ public void shouldSupportNestedSameEntity() { @Test public void shouldAllowUsingAnArbitraryLiteralForFlush() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -145,7 +147,7 @@ public void shouldAllowUsingAnArbitraryLiteralForFlush() { @Test public void shouldReceiveFlushingLiteralBeforeFlushEvent() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/TestCollectorIf.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/TestCollectorIf.java index c026414ec..9334641e2 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/TestCollectorIf.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/TestCollectorIf.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -40,9 +40,12 @@ public final class TestCollectorIf { @Mock private StreamReceiver receiver; + public TestCollectorIf() { + } + @Test public void shouldOnlyFireIfConditionIsMet() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -76,7 +79,7 @@ public void shouldOnlyFireIfConditionIsMet() { @Test public void shouldAllowToUseSameSourceInbodyAndCondition() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -110,7 +113,7 @@ public void shouldAllowToUseSameSourceInbodyAndCondition() { @Test public void shouldAllowQuantorsInIfStatements() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -155,7 +158,7 @@ public void shouldAllowQuantorsInIfStatements() { @Test public void shouldResetConditionWithCollector() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -186,7 +189,7 @@ public void shouldResetConditionWithCollector() { @Test public void shouldResetConditionWithCollectorOnFlushWith() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -218,7 +221,7 @@ public void shouldResetConditionWithCollectorOnFlushWith() { @Test public void shouldResetConditionWithCollectorOnSameEntity() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -250,7 +253,7 @@ public void shouldResetConditionWithCollectorOnSameEntity() { @Test public void shouldResetOnFlushWithIfConditionWasNotMet() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java b/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java index 654f03dad..838ddc8b9 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/collectors/TuplesTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.collectors; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -39,9 +39,12 @@ public final class TuplesTest { @Mock private StreamReceiver receiver; + public TuplesTest() { + } + @Test public void shouldEmitTwoAndThreeTuples() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -88,7 +91,7 @@ public void shouldEmitTwoAndThreeTuples() { @Test public void shouldOnlyEmitTriplesWithMoreThanMinNValues() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -131,7 +134,7 @@ public void shouldOnlyEmitTriplesWithMoreThanMinNValues() { @Test public void shouldEmitTuplesWithMinNIfNotAllStatementsFired() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/functions/DateFormatTest.java b/metamorph/src/test/java/org/metafacture/metamorph/functions/DateFormatTest.java index 1b02157b4..bfe1999fc 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/functions/DateFormatTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/functions/DateFormatTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.functions; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -39,9 +39,12 @@ public final class DateFormatTest { @Mock private StreamReceiver receiver; + public DateFormatTest() { + } + @Test public void shouldMakeOutputFormatConfigurable() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/functions/ISBNTest.java b/metamorph/src/test/java/org/metafacture/metamorph/functions/ISBNTest.java index 1d295cafe..25f8a6517 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/functions/ISBNTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/functions/ISBNTest.java @@ -16,10 +16,7 @@ package org.metafacture.metamorph.functions; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - +import org.junit.Assert; import org.junit.Test; /** @@ -47,31 +44,34 @@ public final class ISBNTest { private static final String ISBN_INCORRECT_SIZE3 = "123456789"; private static final String ERROR = "invalid"; + public ISBNTest() { + } + @Test - public void testProcess(){ + public void testProcess() { final ISBN isbn = new ISBN(); isbn.setTo("isbn13"); - assertEquals(ISBN13A, isbn.process(ISBN10A)); + Assert.assertEquals(ISBN13A, isbn.process(ISBN10A)); isbn.setTo("isbn10"); - assertEquals(ISBN10A, isbn.process(ISBN13A)); + Assert.assertEquals(ISBN10A, isbn.process(ISBN13A)); isbn.setTo("cleanse"); - assertEquals(ISBN10A, isbn.process(ISBN10A_DIRTY)); + Assert.assertEquals(ISBN10A, isbn.process(ISBN10A_DIRTY)); } @Test public void testTo13() { - assertEquals(ISBN13A, ISBN.isbn10to13(ISBN10A)); + Assert.assertEquals(ISBN13A, ISBN.isbn10to13(ISBN10A)); } @Test public void testTo10() { - assertEquals(ISBN10A, ISBN.isbn13to10(ISBN13A)); + Assert.assertEquals(ISBN10A, ISBN.isbn13to10(ISBN13A)); } @Test public void testCleanse() { - assertEquals(ISBN10A, ISBN.cleanse(ISBN10A_DIRTY)); + Assert.assertEquals(ISBN10A, ISBN.cleanse(ISBN10A_DIRTY)); } @Test(expected = IllegalArgumentException.class) @@ -86,30 +86,30 @@ public void testInvalidInputTo10() { @Test public void testIsValid() { - assertFalse(ISBN.isValid(ISBN_INCORRECT_CHECK13)); - assertFalse(ISBN.isValid(ISBN_INCORRECT_CHECK10)); - assertFalse(ISBN.isValid(ISBN_INCORRECT_SIZE1)); - assertFalse(ISBN.isValid(ISBN_INCORRECT_SIZE2)); - assertFalse(ISBN.isValid(ISBN_INCORRECT_SIZE3)); - - assertTrue(ISBN.isValid(ISBN10B)); - assertTrue(ISBN.isValid(ISBN10A)); - assertTrue(ISBN.isValid(ISBN13A )); - assertTrue(ISBN.isValid(ISBN.cleanse(ISBN10C_DIRTY))); - assertTrue(ISBN.isValid(ISBN.cleanse(ISBN13D_DIRTY))); - assertTrue(ISBN.isValid(ISBN.cleanse(ISBN10F_DIRTY))); + Assert.assertFalse(ISBN.isValid(ISBN_INCORRECT_CHECK13)); + Assert.assertFalse(ISBN.isValid(ISBN_INCORRECT_CHECK10)); + Assert.assertFalse(ISBN.isValid(ISBN_INCORRECT_SIZE1)); + Assert.assertFalse(ISBN.isValid(ISBN_INCORRECT_SIZE2)); + Assert.assertFalse(ISBN.isValid(ISBN_INCORRECT_SIZE3)); + + Assert.assertTrue(ISBN.isValid(ISBN10B)); + Assert.assertTrue(ISBN.isValid(ISBN10A)); + Assert.assertTrue(ISBN.isValid(ISBN13A)); + Assert.assertTrue(ISBN.isValid(ISBN.cleanse(ISBN10C_DIRTY))); + Assert.assertTrue(ISBN.isValid(ISBN.cleanse(ISBN13D_DIRTY))); + Assert.assertTrue(ISBN.isValid(ISBN.cleanse(ISBN10F_DIRTY))); } - public void testCleanseException1(){ + public void testCleanseException1() { final ISBN isbn = new ISBN(); isbn.setErrorString(ERROR); - assertTrue(isbn.process(ISBN_INCORRECT_SIZE3).startsWith(ERROR)); + Assert.assertTrue(isbn.process(ISBN_INCORRECT_SIZE3).startsWith(ERROR)); } - public void testCleanseException2(){ + public void testCleanseException2() { final ISBN isbn = new ISBN(); isbn.setErrorString(ERROR); - assertTrue(isbn.process(ISBN_INCORRECT_SIZE1).startsWith(ERROR)); + Assert.assertTrue(isbn.process(ISBN_INCORRECT_SIZE1).startsWith(ERROR)); } } diff --git a/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java b/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java index 91162be4b..a27e91a7e 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/functions/LookupTest.java @@ -16,14 +16,13 @@ package org.metafacture.metamorph.functions; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; +import org.metafacture.metamorph.api.Maps; +import org.junit.Assert; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; -import org.metafacture.metamorph.api.Maps; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnit; @@ -53,6 +52,9 @@ public final class LookupTest { @Mock private StreamReceiver receiver; + public LookupTest() { + } + @Test public void shouldReturnNullIfMapNameDoesNotExist() { final Lookup lookup = new Lookup(); @@ -60,7 +62,7 @@ public void shouldReturnNullIfMapNameDoesNotExist() { lookup.setIn(MAP_NAME_WRONG); - assertNull(lookup.process(KEY)); + Assert.assertNull(lookup.process(KEY)); } @Test @@ -71,7 +73,7 @@ public void shouldReturnValueIfMapAndKeyExist() { lookup.setIn(MAP_NAME); Mockito.when(maps.getValue(MAP_NAME, KEY)).thenReturn(VALUE); - assertEquals(VALUE, lookup.process(KEY)); + Assert.assertEquals(VALUE, lookup.process(KEY)); } @Test @@ -81,12 +83,12 @@ public void shouldReturnNullIfKeyDoesNotExist() { lookup.setIn(MAP_NAME); - assertNull(lookup.process(KEY_WRONG)); + Assert.assertNull(lookup.process(KEY_WRONG)); } @Test public void shouldLookupValuesInLocalMap() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -119,7 +121,7 @@ public void shouldLookupValuesInLocalMap() { @Test public void shouldLookupValuesInReferencedMap() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -156,7 +158,7 @@ public void shouldLookupValuesInReferencedMap() { @Test public void shouldLookupValuesInMetadata() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " Hawaii" + "" + @@ -180,7 +182,7 @@ public void shouldLookupValuesInMetadata() { @Test public void issue372_shouldFilterMissingValue() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/functions/NormalizeUTF8Test.java b/metamorph/src/test/java/org/metafacture/metamorph/functions/NormalizeUTF8Test.java index a62a03419..f2b5c2e35 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/functions/NormalizeUTF8Test.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/functions/NormalizeUTF8Test.java @@ -16,8 +16,7 @@ package org.metafacture.metamorph.functions; -import static org.junit.Assert.assertEquals; - +import org.junit.Assert; import org.junit.Test; /** @@ -35,9 +34,13 @@ public final class NormalizeUTF8Test { private static final String OUTPUT_STR = "Bauer, Sigmund: Über den Einfluß der Ackergeräthe auf den Reinertrag."; + public NormalizeUTF8Test() { + } + @Test public void testProcess() { final NormalizeUTF8 normalize = new NormalizeUTF8(); - assertEquals("Normalization incorrect", OUTPUT_STR, normalize.process(INPUT_STR)); + Assert.assertEquals("Normalization incorrect", OUTPUT_STR, normalize.process(INPUT_STR)); } + } diff --git a/metamorph/src/test/java/org/metafacture/metamorph/functions/RegexpTest.java b/metamorph/src/test/java/org/metafacture/metamorph/functions/RegexpTest.java index 0177de29a..a0fdc3855 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/functions/RegexpTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/functions/RegexpTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.functions; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -39,9 +39,12 @@ public final class RegexpTest { @Mock private StreamReceiver receiver; + public RegexpTest() { + } + @Test public void shouldMatchAndReplaceUsingRegularExpressions() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -72,7 +75,7 @@ public void shouldMatchAndReplaceUsingRegularExpressions() { @Test public void shouldIgnoreEmptyMatchGroups() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + @@ -94,7 +97,7 @@ public void shouldIgnoreEmptyMatchGroups() { @Test public void shouldIgnoreNullValues() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + " " + diff --git a/metamorph/src/test/java/org/metafacture/metamorph/functions/ScriptTest.java b/metamorph/src/test/java/org/metafacture/metamorph/functions/ScriptTest.java index 09914f374..379e0477e 100644 --- a/metamorph/src/test/java/org/metafacture/metamorph/functions/ScriptTest.java +++ b/metamorph/src/test/java/org/metafacture/metamorph/functions/ScriptTest.java @@ -16,11 +16,11 @@ package org.metafacture.metamorph.functions; -import static org.metafacture.metamorph.TestHelpers.assertMorph; +import org.metafacture.framework.StreamReceiver; +import org.metafacture.metamorph.TestHelpers; import org.junit.Rule; import org.junit.Test; -import org.metafacture.framework.StreamReceiver; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -39,9 +39,12 @@ public final class ScriptTest { @Mock private StreamReceiver receiver; + public ScriptTest() { + } + @Test public void shouldExecuteJavascriptFunctions() { - assertMorph(receiver, + TestHelpers.assertMorph(receiver, "" + " " + "