Port yang-parser-rfc7950 to JUnit 5

[yangtools.git] / parser / yang-parser-rfc7950 / src / test / java / org / opendaylight / yangtools / yang / stmt / YT1089Test.java

diff --git a/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/YT1089Test.java b/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/YT1089Test.java
index 91a224f7b317dfed54aa9f1d519a9f222217e588..41618176108d84af0d424a139d4e0f0b9b2f17b8 100644 (file)
--- a/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/YT1089Test.java
+++ b/parser/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/YT1089Test.java
@@ -7,14 +7,13 @@
  */
 package org.opendaylight.yangtools.yang.stmt;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 
 import com.google.common.collect.Iterables;
 import java.util.Iterator;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
@@ -26,28 +25,28 @@ import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveState
 import org.opendaylight.yangtools.yang.model.api.stmt.PrefixEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement;
 
-public class YT1089Test extends AbstractYangTest {
+class YT1089Test extends AbstractYangTest {
     @Test
-    public void testPlusLexing() {
+    void testPlusLexing() {
         final EffectiveModelContext ctx = assertEffectiveModel("/bugs/YT1089/foo.yang");
         assertEquals(1, ctx.getModuleStatements().size());
 
         final Iterator<? extends EffectiveStatement<?, ?>> it =
-                Iterables.getOnlyElement(ctx.getModuleStatements().values()).effectiveSubstatements().iterator();
+            Iterables.getOnlyElement(ctx.getModuleStatements().values()).effectiveSubstatements().iterator();
 
-        assertThat(it.next(), instanceOf(NamespaceEffectiveStatement.class));
-        assertThat(it.next(), instanceOf(PrefixEffectiveStatement.class));
+        assertInstanceOf(NamespaceEffectiveStatement.class, it.next());
+        assertInstanceOf(PrefixEffectiveStatement.class, it.next());
 
         EffectiveStatement<?, ?> stmt = it.next();
-        assertThat(stmt, instanceOf(DescriptionEffectiveStatement.class));
+        assertInstanceOf(DescriptionEffectiveStatement.class, stmt);
         assertEquals("+something", stmt.argument());
 
         stmt = it.next();
-        assertThat(stmt, instanceOf(ContactEffectiveStatement.class));
+        assertInstanceOf(ContactEffectiveStatement.class, stmt);
         assertEquals("contact++", stmt.argument());
 
         stmt = it.next();
-        assertThat(stmt, instanceOf(OrganizationEffectiveStatement.class));
+        assertInstanceOf(OrganizationEffectiveStatement.class, stmt);
         assertEquals("organiza++tion", stmt.argument());
 
         assertFoo(it.next());
@@ -58,11 +57,11 @@ public class YT1089Test extends AbstractYangTest {
     }
 
     private static void assertFoo(final EffectiveStatement<?, ?> stmt) {
-        assertThat(stmt, instanceOf(LeafEffectiveStatement.class));
+        assertInstanceOf(LeafEffectiveStatement.class, stmt);
         assertEquals(QName.create("urn:foo", "foo"), stmt.argument());
 
         final Iterator<? extends EffectiveStatement<?, ?>> it = stmt.effectiveSubstatements().iterator();
-        assertThat(it.next(), instanceOf(TypeEffectiveStatement.class));
+        assertInstanceOf(TypeEffectiveStatement.class, it.next());
         assertEquals("+", it.next().argument());
         assertEquals("squotdquot", it.next().argument());
         assertEquals("++", it.next().argument());
@@ -70,10 +69,10 @@ public class YT1089Test extends AbstractYangTest {
     }
 
     private static void assertBar(final EffectiveStatement<?, ?> stmt) {
-        assertThat(stmt, instanceOf(LeafEffectiveStatement.class));
+        assertInstanceOf(LeafEffectiveStatement.class, stmt);
         assertEquals(QName.create("urn:foo", "bar"), stmt.argument());
         final Iterator<? extends EffectiveStatement<?, ?>> it = stmt.effectiveSubstatements().iterator();
-        assertThat(it.next(), instanceOf(TypeEffectiveStatement.class));
+        assertInstanceOf(TypeEffectiveStatement.class, it.next());
         assertEquals("++", it.next().argument());
         assertEquals("+ + ++", it.next().argument());
         assertEquals("++ + +", it.next().argument());
@@ -81,10 +80,10 @@ public class YT1089Test extends AbstractYangTest {
     }
 
     private static void assertBaz(final EffectiveStatement<?, ?> stmt) {
-        assertThat(stmt, instanceOf(LeafEffectiveStatement.class));
+        assertInstanceOf(LeafEffectiveStatement.class, stmt);
         assertEquals(QName.create("urn:foo", "baz"), stmt.argument());
         final Iterator<? extends EffectiveStatement<?, ?>> it = stmt.effectiveSubstatements().iterator();
-        assertThat(it.next(), instanceOf(TypeEffectiveStatement.class));
+        assertInstanceOf(TypeEffectiveStatement.class, it.next());
         assertEquals("/", it.next().argument());
         assertEquals(":", it.next().argument());
         assertEquals("*", it.next().argument());
@@ -92,10 +91,10 @@ public class YT1089Test extends AbstractYangTest {
     }
 
     private static void assertXyzzy(final EffectiveStatement<?, ?> stmt) {
-        assertThat(stmt, instanceOf(LeafEffectiveStatement.class));
+        assertInstanceOf(LeafEffectiveStatement.class, stmt);
         assertEquals(QName.create("urn:foo", "xyzzy"), stmt.argument());
         final Iterator<? extends EffectiveStatement<?, ?>> it = stmt.effectiveSubstatements().iterator();
-        assertThat(it.next(), instanceOf(TypeEffectiveStatement.class));
+        assertInstanceOf(TypeEffectiveStatement.class, it.next());
         assertEquals("a weird concat", it.next().argument());
         assertEquals("another weird concat", it.next().argument());
         assertFalse(it.hasNext());