import java.util.ArrayList;
import java.util.List;
import org.junit.Assert;
-import org.junit.runners.Parameterized.Parameter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-public abstract class AbstractSerializationTest {
-
- @Parameter(0)
- public NormalizedNodeStreamVersion version;
-
- final <T extends NormalizedNode> T assertEquals(final T node, final int expectedSize) {
- final ByteArrayOutputStream baos = new ByteArrayOutputStream();
- try (NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
+abstract class AbstractSerializationTest {
+ static final <T extends NormalizedNode> T assertEquals(final NormalizedNodeStreamVersion version, final T node,
+ final int expectedSize) {
+ final var baos = new ByteArrayOutputStream();
+ try (var nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
nnout.writeNormalizedNode(node);
} catch (IOException e) {
throw new AssertionError("Failed to serialize", e);
return node;
}
- final <T> T assertEquals(final T value, final int expectedSize) {
- return assertEquals(ImmutableNodes.leafNode(TestModel.TEST_QNAME, value), expectedSize).body();
+ static final <T> T assertEquals(final NormalizedNodeStreamVersion version, final T value, final int expectedSize) {
+ return assertEquals(version, ImmutableNodes.leafNode(TestModel.TEST_QNAME, value), expectedSize).body();
}
- final <T extends PathArgument> T assertEquals(final T arg, final int expectedSize) {
- final ByteArrayOutputStream baos = new ByteArrayOutputStream();
- try (NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
+ static final <T extends PathArgument> T assertEquals(final NormalizedNodeStreamVersion version, final T arg,
+ final int expectedSize) {
+ final var baos = new ByteArrayOutputStream();
+ try (var nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
nnout.writePathArgument(arg);
} catch (IOException e) {
throw new AssertionError("Failed to serialize", e);
return (T) deser;
}
- final void assertEqualsTwice(final PathArgument arg, final int expectedSize) {
- final ByteArrayOutputStream baos = new ByteArrayOutputStream();
- try (NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
+ static final void assertEqualsTwice(final NormalizedNodeStreamVersion version, final PathArgument arg,
+ final int expectedSize) {
+ final var baos = new ByteArrayOutputStream();
+ try (var nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
nnout.writePathArgument(arg);
nnout.writePathArgument(arg);
} catch (IOException e) {
Assert.assertEquals(expectedSize, bytes.length);
try {
- final NormalizedNodeDataInput in = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
+ final var in = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
Assert.assertEquals(arg, in.readPathArgument());
Assert.assertEquals(arg, in.readPathArgument());
} catch (IOException e) {
}
}
- final void assertSame(final Object value, final int expectedSize) {
- Assert.assertSame(value, assertEquals(value, expectedSize));
+ static final void assertSame(final NormalizedNodeStreamVersion version, final Object value,
+ final int expectedSize) {
+ Assert.assertSame(value, assertEquals(version, value, expectedSize));
}
- final void assertSame(final PathArgument arg, final int expectedSize) {
- Assert.assertSame(arg, assertEquals(arg, expectedSize));
+ static final void assertSame(final NormalizedNodeStreamVersion version, final PathArgument arg,
+ final int expectedSize) {
+ Assert.assertSame(arg, assertEquals(version, arg, expectedSize));
}
static final List<QName> generateQNames(final int size) {
- final List<QName> qnames = new ArrayList<>(size);
+ final var qnames = new ArrayList<QName>(size);
for (int i = 0; i < size; ++i) {
qnames.add(QName.create(TestModel.TEST_QNAME, "a" + Integer.toHexString(i)));
}
package org.opendaylight.yangtools.yang.data.codec.binfmt;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSet.Builder;
import com.google.common.io.ByteStreams;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
-import java.util.Collections;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
-import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-@RunWith(Parameterized.class)
-public class BitsSerializationTest extends AbstractSerializationTest {
- @Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.POTASSIUM, 96, 100, 226, 1_536, 456_764, 654_045 });
+class BitsSerializationTest extends AbstractSerializationTest {
+ @ParameterizedTest
+ @MethodSource
+ void testEmptyBytes(final NormalizedNodeStreamVersion version, final int size) {
+ assertSame(version, ImmutableSet.of(), size);
}
- @Parameter(1)
- public int emptySize;
- @Parameter(2)
- public int oneSize;
- @Parameter(3)
- public int size29;
- @Parameter(4)
- public int size285;
- @Parameter(5)
- public int size65821;
- @Parameter(6)
- public int twiceSize65821;
-
- @Test
- public void testEmptyBytes() {
- assertSame(ImmutableSet.of(), emptySize);
+ static List<Arguments> testEmptyBytes() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 96));
}
- @Test
- public void testOne() {
- assertEquals(ImmutableSet.of("a"), oneSize);
+ @ParameterizedTest
+ @MethodSource
+ void testOne(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, ImmutableSet.of("a"), size);
}
- @Test
- public void test29() {
- assertEquals(fillBits(29), size29);
+ static List<Arguments> testOne() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 100));
}
- @Test
- public void test285() {
- assertEquals(fillBits(285), size285);
+ @ParameterizedTest
+ @MethodSource
+ void test29(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, fillBits(29), size);
}
- @Test
- public void test65821() {
- assertEquals(fillBits(65821), size65821);
+ static List<Arguments> test29() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 226));
}
- @Test
- public void testTwice65536() {
- final LeafNode<ImmutableSet<String>> leaf = ImmutableNodes.leafNode(TestModel.TEST_QNAME, fillBits(65821));
+ @ParameterizedTest
+ @MethodSource
+ void test285(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, fillBits(285), size);
+ }
+
+ static List<Arguments> test285() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 1_536));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void test65821(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, fillBits(65821), size);
+ }
- final ByteArrayOutputStream baos = new ByteArrayOutputStream();
- try (NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
+ static List<Arguments> test65821() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 456_764));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void testTwice65536(final NormalizedNodeStreamVersion version, final int size) {
+ final var leaf = ImmutableNodes.leafNode(TestModel.TEST_QNAME, fillBits(65821));
+
+ final var baos = new ByteArrayOutputStream();
+ try (var nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
nnout.writeNormalizedNode(leaf);
nnout.writeNormalizedNode(leaf);
} catch (IOException e) {
}
final byte[] bytes = baos.toByteArray();
- Assert.assertEquals(twiceSize65821, bytes.length);
+ Assertions.assertEquals(size, bytes.length);
try {
- final NormalizedNodeDataInput input = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
- Assert.assertEquals(leaf, input.readNormalizedNode());
- Assert.assertEquals(leaf, input.readNormalizedNode());
+ final var input = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
+ Assertions.assertEquals(leaf, input.readNormalizedNode());
+ Assertions.assertEquals(leaf, input.readNormalizedNode());
} catch (IOException e) {
throw new AssertionError("Failed to deserialize", e);
}
}
+ static List<Arguments> testTwice65536() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 654_045));
+ }
+
private static ImmutableSet<String> fillBits(final int size) {
- final Builder<String> builder = ImmutableSet.builderWithExpectedSize(size);
+ final var builder = ImmutableSet.<String>builderWithExpectedSize(size);
for (int i = 0; i < size; ++i) {
builder.add(Integer.toHexString(i));
}
- final ImmutableSet<String> ret = builder.build();
- Assert.assertEquals(size, ret.size());
+ final var ret = builder.build();
+ Assertions.assertEquals(size, ret.size());
return ret;
}
}
*/
package org.opendaylight.yangtools.yang.data.codec.binfmt;
-import java.util.Collections;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
+import java.util.List;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
-@RunWith(Parameterized.class)
-public class BooleanSerializationTest extends AbstractSerializationTest {
- @Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.POTASSIUM, 96 });
+class BooleanSerializationTest extends AbstractSerializationTest {
+ @ParameterizedTest
+ @MethodSource("parameters")
+ void testTrue(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, Boolean.TRUE, size);
}
- @Parameter(1)
- public int size;
-
- @Test
- public void testTrue() {
- assertEquals(Boolean.TRUE, size);
+ @ParameterizedTest
+ @MethodSource("parameters")
+ void testFalse(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, Boolean.FALSE, size);
}
- @Test
- public void testFalse() {
- assertEquals(Boolean.FALSE, size);
+ private static List<Arguments> parameters() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 96));
}
}
*/
package org.opendaylight.yangtools.yang.data.codec.binfmt;
-import java.util.Collections;
+import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
-@RunWith(Parameterized.class)
-public class BytesSerializationTest extends AbstractSerializationTest {
- private static final byte[] BINARY_128 = randomBytes(128);
- private static final byte[] BINARY_384 = randomBytes(384);
- private static final byte[] BINARY_65920 = randomBytes(65920);
+class BytesSerializationTest extends AbstractSerializationTest {
+ @ParameterizedTest
+ @MethodSource
+ void testEmptyBytes(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, new byte[0], size);
+ }
+
+ static List<Arguments> testEmptyBytes() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 96));
+ }
- @Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.POTASSIUM, 96, 97, 225, 482, 66_020 });
+ @ParameterizedTest
+ @MethodSource
+ void testOne(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, randomBytes(1), size);
}
- @Parameter(1)
- public int emptySize;
- @Parameter(2)
- public int oneSize;
- @Parameter(3)
- public int size128;
- @Parameter(4)
- public int size384;
- @Parameter(5)
- public int size65920;
+ static List<Arguments> testOne() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 97));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void test128(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, randomBytes(128), size);
+ }
- @Test
- public void testEmptyBytes() {
- assertEquals(new byte[0], emptySize);
+ static List<Arguments> test128() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 225));
}
- @Test
- public void testOne() {
- assertEquals(randomBytes(1), oneSize);
+ @ParameterizedTest
+ @MethodSource
+ void test384(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, randomBytes(384), size);
}
- @Test
- public void test128() {
- assertEquals(BINARY_128, size128);
+ static List<Arguments> test384() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 482));
}
- @Test
- public void test384() {
- assertEquals(BINARY_384, size384);
+ @ParameterizedTest
+ @MethodSource
+ void test65920(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, randomBytes(65920), size);
}
- @Test
- public void test65920() {
- assertEquals(BINARY_65920, size65920);
+ static List<Arguments> test65920() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 66_020));
}
private static byte[] randomBytes(final int size) {
*/
package org.opendaylight.yangtools.yang.data.codec.binfmt;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
-import java.io.DataOutput;
import java.io.DataOutputStream;
-import java.io.IOException;
-import java.util.Collection;
-import java.util.Iterator;
import java.util.function.Consumer;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
-public class DataTreeCandidateInputOutputTest {
+class DataTreeCandidateInputOutputTest {
private static final QName FOO = QName.create("foo", "foo");
private static final QName BAR = QName.create(FOO, "bar");
private static final QName BAZ = QName.create(FOO, "baz");
private static EffectiveModelContext CONTEXT;
- private DataTree dataTree;
+ private final DataTree dataTree = new InMemoryDataTreeFactory()
+ .create(DataTreeConfiguration.DEFAULT_CONFIGURATION, CONTEXT);
- @BeforeClass
- public static void beforeClass() {
+ @BeforeAll
+ static void beforeAll() {
CONTEXT = YangParserTestUtils.parseYang("""
module foo {
namespace foo;
}""");
}
- @Before
- public void before() {
- dataTree = new InMemoryDataTreeFactory().create(DataTreeConfiguration.DEFAULT_CONFIGURATION, CONTEXT);
- }
-
@Test
- public void testWriteRoot() throws IOException {
+ void testWriteRoot() throws Exception {
assertSerialization(createCandidate(mod -> mod.write(YangInstanceIdentifier.of(),
ImmutableNodes.containerNode(SchemaContext.NAME))));
}
@Test
- public void testWrite() throws IOException {
+ void testWrite() throws Exception {
assertSerialization(createCandidate(mod -> mod.write(BAR_PATH, ImmutableNodes.containerNode(BAR))));
}
@Test
- public void testDelete() throws IOException {
+ void testDelete() throws Exception {
createCandidate(mod -> mod.write(BAR_PATH, ImmutableNodes.containerNode(BAR)));
assertSerialization(createCandidate(mod -> mod.delete(BAR_PATH)));
}
@Test
- public void testWriteAppear() throws IOException {
+ void testWriteAppear() throws Exception {
assertSerialization(createCandidate(mod -> mod.write(FOO_BAR_PATH, ImmutableNodes.leafNode(BAR, "value"))));
}
@Test
- public void testDeleteDisappear() throws IOException {
+ void testDeleteDisappear() throws Exception {
createCandidate(mod -> mod.write(FOO_BAR_PATH, ImmutableNodes.leafNode(BAR, "value")));
assertSerialization(createCandidate(mod -> mod.delete(FOO_BAR_PATH)));
}
@Test
- public void testUnmodifiedRoot() throws IOException {
+ void testUnmodifiedRoot() throws Exception {
assertSerialization(createCandidate(mod -> mod.merge(YangInstanceIdentifier.of(),
ImmutableNodes.containerNode(SchemaContext.NAME))));
}
@Test
- public void testUnmodifiedFoo() throws IOException {
+ void testUnmodifiedFoo() throws Exception {
assertSerialization(createCandidate(mod -> {
mod.write(FOO_BAR_PATH, ImmutableNodes.leafNode(BAR, "value"));
mod.delete(FOO_BAR_PATH);
}
private DataTreeCandidate createCandidate(final Consumer<DataTreeModification> function) {
- final DataTreeModification mod = dataTree.takeSnapshot().newModification();
+ final var mod = dataTree.takeSnapshot().newModification();
function.accept(mod);
mod.ready();
return ret;
}
- private static void assertSerialization(final DataTreeCandidate orig) throws IOException {
- final ByteArrayOutputStream bos = new ByteArrayOutputStream();
- final DataOutput dos = new DataOutputStream(bos);
-
- try (NormalizedNodeDataOutput out = NormalizedNodeStreamVersion.current().newDataOutput(dos)) {
+ private static void assertSerialization(final DataTreeCandidate orig) throws Exception {
+ final var bos = new ByteArrayOutputStream();
+ try (var out = NormalizedNodeStreamVersion.current().newDataOutput(new DataOutputStream(bos))) {
DataTreeCandidateInputOutput.writeDataTreeCandidate(out, orig);
}
- final DataTreeCandidate read = DataTreeCandidateInputOutput.readDataTreeCandidate(
+ final var read = DataTreeCandidateInputOutput.readDataTreeCandidate(
NormalizedNodeDataInput.newDataInput(new DataInputStream(new ByteArrayInputStream(bos.toByteArray()))));
assertEquals(orig.getRootPath(), read.getRootPath());
assertEqualMod(orig.getRootNode(), read.getRootNode());
// No children to verify
break;
default:
- final Collection<DataTreeCandidateNode> expectedChildren = expected.childNodes();
- final Collection<DataTreeCandidateNode> actualChildren = actual.childNodes();
+ final var expectedChildren = expected.childNodes();
+ final var actualChildren = actual.childNodes();
assertEquals(expectedChildren.size(), actualChildren.size());
- final Iterator<DataTreeCandidateNode> ait = actualChildren.iterator();
-
- for (DataTreeCandidateNode expectedChild : expectedChildren) {
+ final var ait = actualChildren.iterator();
+ for (var expectedChild : expectedChildren) {
assertEqualNodes(expectedChild, ait.next());
}
}
*/
package org.opendaylight.yangtools.yang.data.codec.binfmt;
-import java.util.Collections;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
+import java.util.List;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
-@RunWith(Parameterized.class)
-public class IntSerializationTest extends AbstractSerializationTest {
- @Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.POTASSIUM, 96, 97, 96, 98, 96, 98, 100, 96, 100, 104 });
+class IntSerializationTest extends AbstractSerializationTest {
+ @ParameterizedTest
+ @MethodSource
+ void testByte(final NormalizedNodeStreamVersion version, final int expectedByte, final int expectedByteOne) {
+ assertSame(version, (byte) 0, expectedByte);
+ assertSame(version, (byte) 1, expectedByteOne);
+ assertSame(version, Byte.MAX_VALUE, expectedByteOne);
}
- @Parameter(1)
- public int expectedByte;
- @Parameter(2)
- public int expectedByteOne;
- @Parameter(3)
- public int expectedShort;
- @Parameter(4)
- public int expectedShortOne;
- @Parameter(5)
- public int expectedInt;
- @Parameter(6)
- public int expectedIntOne;
- @Parameter(7)
- public int expectedIntMax;
- @Parameter(8)
- public int expectedLong;
- @Parameter(9)
- public int expectedLongOne;
- @Parameter(10)
- public int expectedLongMax;
+ static List<Arguments> testByte() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 96, 97));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void testShort(final NormalizedNodeStreamVersion version, final int expectedShort, final int expectedShortOne) {
+ assertSame(version, (short) 0, expectedShort);
+ assertSame(version, (short) 1, expectedShortOne);
+ assertSame(version, Short.MAX_VALUE, expectedShortOne);
+ }
+
+ static List<Arguments> testShort() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 96, 98));
+ }
- @Test
- public void testByte() {
- assertSame((byte) 0, expectedByte);
- assertSame((byte) 1, expectedByteOne);
- assertSame(Byte.MAX_VALUE, expectedByteOne);
+ @ParameterizedTest
+ @MethodSource
+ void testInt(final NormalizedNodeStreamVersion version, final int expectedInt, final int expectedIntOne,
+ final int expectedIntMax) {
+ assertSame(version, 0, expectedInt);
+ assertSame(version, 1, expectedIntOne);
+ assertSame(version, Integer.MAX_VALUE, expectedIntMax);
}
- @Test
- public void testShort() {
- assertSame((short) 0, expectedShort);
- assertSame((short) 1, expectedShortOne);
- assertSame(Short.MAX_VALUE, expectedShortOne);
+ static List<Arguments> testInt() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 96, 98, 100));
}
- @Test
- public void testInt() {
- assertSame(0, expectedInt);
- assertSame(1, expectedIntOne);
- assertSame(Integer.MAX_VALUE, expectedIntMax);
+ @ParameterizedTest
+ @MethodSource
+ void testLong(final NormalizedNodeStreamVersion version, final int expectedLong, final int expectedLongOne,
+ final int expectedLongMax) {
+ assertSame(version, 0L, expectedLong);
+ assertSame(version, 1L, expectedLongOne);
+ assertSame(version, Long.MAX_VALUE, expectedLongMax);
}
- @Test
- public void testLong() {
- assertSame(0L, expectedLong);
- assertSame(1L, expectedLongOne);
- assertSame(Long.MAX_VALUE, expectedLongMax);
+ static List<Arguments> testLong() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 96, 100, 104));
}
}
package org.opendaylight.yangtools.yang.data.codec.binfmt;
import com.google.common.collect.Maps;
-import java.util.Collections;
-import java.util.Map;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
+import java.util.List;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-@RunWith(Parameterized.class)
-public class MapEntrySerializationTest extends AbstractSerializationTest {
- @Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.POTASSIUM, 96, 110, 125, 3_927 });
+class MapEntrySerializationTest extends AbstractSerializationTest {
+ @ParameterizedTest
+ @MethodSource
+ void testEmptyIdentifier(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, createEntry(0), size);
}
- @Parameter(1)
- public int emptySize;
- @Parameter(2)
- public int oneSize;
- @Parameter(3)
- public int twoSize;
- @Parameter(4)
- public int size256;
+ static List<Arguments> testEmptyIdentifier() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 96));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void testOneIdentifier(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, createEntry(1), size);
+ }
+
+ static List<Arguments> testOneIdentifier() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 110));
+ }
- @Test
- public void testEmptyIdentifier() {
- assertEquals(createEntry(0), emptySize);
+ @ParameterizedTest
+ @MethodSource
+ void testTwoIdentifiers(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, createEntry(2), size);
}
- @Test
- public void testOneIdentifier() {
- assertEquals(createEntry(1), oneSize);
+ static List<Arguments> testTwoIdentifiers() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 125));
}
- @Test
- public void testTwoIdentifiers() {
- assertEquals(createEntry(2), twoSize);
+ @ParameterizedTest
+ @MethodSource
+ void test256(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, createEntry(256), size);
}
- @Test
- public void test256() {
- assertEquals(createEntry(256), size256);
+ static List<Arguments> test256() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 3_927));
}
private static MapEntryNode createEntry(final int size) {
- final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders.mapEntryBuilder();
- final Map<QName, Object> predicates = Maps.newHashMapWithExpectedSize(size);
- for (QName qname : generateQNames(size)) {
+ final var builder = Builders.mapEntryBuilder();
+ final var predicates = Maps.<QName, Object>newHashMapWithExpectedSize(size);
+ for (var qname : generateQNames(size)) {
builder.withChild(ImmutableNodes.leafNode(qname, "a"));
predicates.put(qname, "a");
}
import com.google.common.io.ByteStreams;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
-import java.util.Collections;
-import java.util.Map;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
-@RunWith(Parameterized.class)
-public class NipSerializationTest extends AbstractSerializationTest {
- @Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.POTASSIUM, 95, 107, 155, 252, 3_409, 982_867, 1_443_164 });
+class NipSerializationTest extends AbstractSerializationTest {
+ @ParameterizedTest
+ @MethodSource
+ void testEmptyIdentifier(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, createIdentifier(0), size);
}
- @Parameter(1)
- public int emptySize;
- @Parameter(2)
- public int oneSize;
- @Parameter(3)
- public int size5;
- @Parameter(4)
- public int size13;
- @Parameter(5)
- public int size256;
- @Parameter(6)
- public int size65792;
- @Parameter(7)
- public int twiceSize65792;
-
- @Test
- public void testEmptyIdentifier() {
- assertEquals(createIdentifier(0), emptySize);
+ static List<Arguments> testEmptyIdentifier() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 95));
}
- @Test
- public void testOneIdentifier() {
- assertEquals(createIdentifier(1), oneSize);
+ @ParameterizedTest
+ @MethodSource
+ void testOneIdentifier(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, createIdentifier(1), size);
}
- @Test
- public void test5() {
- assertEquals(createIdentifier(5), size5);
+ static List<Arguments> testOneIdentifier() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 107));
}
- @Test
- public void test13() {
- assertEquals(createIdentifier(13), size13);
+ @ParameterizedTest
+ @MethodSource
+ void test5(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, createIdentifier(5), size);
}
- @Test
- public void test256() {
- assertEquals(createIdentifier(256), size256);
+ static List<Arguments> test5() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 155));
}
- @Test
- public void test65536() {
- assertEquals(createIdentifier(65792), size65792);
+ @ParameterizedTest
+ @MethodSource
+ void test13(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, createIdentifier(13), size);
+ }
+
+ static List<Arguments> test13() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 252));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void test256(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, createIdentifier(256), size);
}
- @Test
- public void testTwice65792() {
- final NodeIdentifierWithPredicates nip = createIdentifier(65792);
- final ByteArrayOutputStream baos = new ByteArrayOutputStream();
- try (NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
+ static List<Arguments> test256() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 3_409));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void test65792(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, createIdentifier(65792), size);
+ }
+
+ static List<Arguments> test65792() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 982_867));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void testTwice65792(final NormalizedNodeStreamVersion version, final int size) {
+ final var nip = createIdentifier(65792);
+
+ final var baos = new ByteArrayOutputStream();
+ try (var nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
nnout.writePathArgument(nip);
nnout.writePathArgument(nip);
} catch (IOException e) {
}
final byte[] bytes = baos.toByteArray();
- Assert.assertEquals(twiceSize65792, bytes.length);
+ Assertions.assertEquals(size, bytes.length);
try {
- final NormalizedNodeDataInput input = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
- Assert.assertEquals(nip, input.readPathArgument());
- Assert.assertEquals(nip, input.readPathArgument());
+ final var input = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
+ Assertions.assertEquals(nip, input.readPathArgument());
+ Assertions.assertEquals(nip, input.readPathArgument());
} catch (IOException e) {
throw new AssertionError("Failed to deserialize", e);
}
}
+ static List<Arguments> testTwice65792() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 1_443_164));
+ }
+
private static NodeIdentifierWithPredicates createIdentifier(final int size) {
- final Map<QName, Object> predicates = Maps.newHashMapWithExpectedSize(size);
- for (QName qname : generateQNames(size)) {
+ final var predicates = Maps.<QName, Object>newHashMapWithExpectedSize(size);
+ for (var qname : generateQNames(size)) {
predicates.put(qname, "a");
}
return NodeIdentifierWithPredicates.of(TestModel.TEST_QNAME, predicates);
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.verify;
-import java.io.IOException;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.junit.jupiter.MockitoExtension;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-@RunWith(MockitoJUnitRunner.StrictStubs.class)
-public class NormalizedNodeDataOutputTest {
+@ExtendWith(MockitoExtension.class)
+class NormalizedNodeDataOutputTest {
@Mock
- public NormalizedNodeDataOutput output;
+ private NormalizedNodeDataOutput output;
- @Before
- public void before() throws IOException {
+ @BeforeEach
+ void before() throws Exception {
doCallRealMethod().when(output).writeOptionalNormalizedNode(any());
}
@Test
- public void testWriteOptionalNormalizedNodeAbsent() throws IOException {
+ void testWriteOptionalNormalizedNodeAbsent() throws Exception {
doNothing().when(output).writeBoolean(false);
output.writeOptionalNormalizedNode(null);
verify(output).writeBoolean(false);
}
@Test
- public void testWriteOptionalNormalizedNodePresent() throws IOException {
- final ContainerNode node = ImmutableNodes.containerNode(QName.create("test", "test"));
+ void testWriteOptionalNormalizedNodePresent() throws Exception {
+ final var node = ImmutableNodes.containerNode(QName.create("test", "test"));
doNothing().when(output).writeBoolean(true);
doNothing().when(output).writeNormalizedNode(node);
output.writeOptionalNormalizedNode(node);
import java.io.Serializable;
import java.io.StringReader;
import java.io.StringWriter;
-import java.util.Collections;
-import java.util.Optional;
+import java.util.List;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
-import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
-import org.w3c.dom.Node;
import org.xml.sax.InputSource;
-@RunWith(Parameterized.class)
-public class NormalizedNodeStreamReaderWriterTest {
- @Parameters(name = "{0} {1}")
- public static Iterable<Object[]> data() {
- return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.POTASSIUM, 1_049_587, 2_289_103, 139, 794, 103, 229, 99 });
- }
-
- @Parameter(0)
- public NormalizedNodeStreamVersion version;
- @Parameter(1)
- public int normalizedNodeStreamingSize;
- @Parameter(2)
- public int hugeEntriesSize;
- @Parameter(3)
- public int yiidStreamingSize;
- @Parameter(4)
- public int nnYiidStreamingSize;
- @Parameter(5)
- public int writePathArgumentSize;
- @Parameter(6)
- public int anyxmlStreamingSize;
- @Parameter(7)
- public int schemaPathSize;
-
- @Test
- public void testNormalizedNodeStreaming() throws IOException {
- ByteArrayOutputStream bos = new ByteArrayOutputStream();
- NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(bos));
+class NormalizedNodeStreamReaderWriterTest {
+ @ParameterizedTest
+ @MethodSource
+ void testNormalizedNodeStreaming(final NormalizedNodeStreamVersion version, final int size) throws Exception {
+ final var bos = new ByteArrayOutputStream();
+ final var nnout = version.newDataOutput(ByteStreams.newDataOutput(bos));
- ContainerNode testContainer = createTestContainer();
+ final var testContainer = createTestContainer();
nnout.writeNormalizedNode(testContainer);
- QName toaster = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","toaster");
- QName darknessFactor = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","darknessFactor");
- QName description = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","description");
- ContainerNode toasterNode = Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(toaster))
+ final var toaster = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","toaster");
+ final var darknessFactor = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","darknessFactor");
+ final var description = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","description");
+ final var toasterNode = Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(toaster))
.withChild(ImmutableNodes.leafNode(darknessFactor, "1000"))
.withChild(ImmutableNodes.leafNode(description, largeString(20))).build();
- ContainerNode toasterContainer = Builders.containerBuilder()
+ final var toasterContainer = Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(SchemaContext.NAME)).withChild(toasterNode).build();
nnout.writeNormalizedNode(toasterContainer);
final byte[] bytes = bos.toByteArray();
- assertEquals(normalizedNodeStreamingSize, bytes.length);
+ assertEquals(size, bytes.length);
- NormalizedNodeDataInput nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
+ final var nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
assertEquals(testContainer, nnin.readNormalizedNode());
assertEquals(toasterContainer, nnin.readNormalizedNode());
}
+ static List<Arguments> testNormalizedNodeStreaming() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 1_049_587));
+ }
+
private static ContainerNode createTestContainer() {
final byte[] bytes1 = {1, 2, 3};
final byte[] bytes2 = {};
.build();
}
- @Test
- public void testYangInstanceIdentifierStreaming() throws IOException {
- YangInstanceIdentifier path = YangInstanceIdentifier.builder(TestModel.TEST_PATH)
- .node(TestModel.OUTER_LIST_QNAME).nodeWithKey(
- TestModel.INNER_LIST_QNAME, TestModel.ID_QNAME, 10).build();
+ @ParameterizedTest
+ @MethodSource
+ void testYangInstanceIdentifierStreaming(final NormalizedNodeStreamVersion version, final int size)
+ throws Exception {
+ final var path = YangInstanceIdentifier.builder(TestModel.TEST_PATH).node(TestModel.OUTER_LIST_QNAME)
+ .nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.ID_QNAME, 10).build();
- ByteArrayOutputStream bos = new ByteArrayOutputStream();
- NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(bos));
+ final var bos = new ByteArrayOutputStream();
+ final var nnout = version.newDataOutput(ByteStreams.newDataOutput(bos));
nnout.writeYangInstanceIdentifier(path);
final byte[] bytes = bos.toByteArray();
- assertEquals(yiidStreamingSize, bytes.length);
+ assertEquals(size, bytes.length);
- NormalizedNodeDataInput nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
+ final var nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
assertEquals(path, nnin.readYangInstanceIdentifier());
}
- @Test
- public void testNormalizedNodeAndYangInstanceIdentifierStreaming() throws IOException {
- final NormalizedNode testContainer = TestModel.createBaseTestContainerBuilder().build();
- final YangInstanceIdentifier path = YangInstanceIdentifier.builder(TestModel.TEST_PATH)
+ static List<Arguments> testYangInstanceIdentifierStreaming() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 139));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void testNormalizedNodeAndYangInstanceIdentifierStreaming(final NormalizedNodeStreamVersion version, final int size)
+ throws Exception {
+ final var testContainer = TestModel.createBaseTestContainerBuilder().build();
+ final var path = YangInstanceIdentifier.builder(TestModel.TEST_PATH)
.node(TestModel.OUTER_LIST_QNAME)
.nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.ID_QNAME, 10)
.build();
- final ByteArrayOutputStream bos = new ByteArrayOutputStream();
- try (NormalizedNodeDataOutput writer = version.newDataOutput(ByteStreams.newDataOutput(bos))) {
+ final var bos = new ByteArrayOutputStream();
+ try (var writer = version.newDataOutput(ByteStreams.newDataOutput(bos))) {
writer.writeNormalizedNode(testContainer);
writer.writeYangInstanceIdentifier(path);
}
final byte[] bytes = bos.toByteArray();
- assertEquals(nnYiidStreamingSize, bytes.length);
+ assertEquals(size, bytes.length);
- final NormalizedNodeDataInput reader = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
+ final var reader = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
assertEquals(testContainer, reader.readNormalizedNode());
assertEquals(path, reader.readYangInstanceIdentifier());
}
+ static List<Arguments> testNormalizedNodeAndYangInstanceIdentifierStreaming() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 794));
+ }
+
@Test
- public void testInvalidNormalizedNodeStream() throws IOException {
- final InvalidNormalizedNodeStreamException ex = assertThrows(InvalidNormalizedNodeStreamException.class,
+ void testInvalidNormalizedNodeStream() throws Exception {
+ final var ex = assertThrows(InvalidNormalizedNodeStreamException.class,
() -> NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(new byte[] { 1, 2, 3})));
assertEquals("Invalid signature marker: 1", ex.getMessage());
}
- @Test
- public void testWithSerializable() {
- NormalizedNode input = TestModel.createTestContainer();
- SampleNormalizedNodeSerializable serializable = new SampleNormalizedNodeSerializable(version, input);
- SampleNormalizedNodeSerializable clone = clone(serializable);
+ @ParameterizedTest
+ @MethodSource
+ void testWithSerializable(final NormalizedNodeStreamVersion version) {
+ var input = TestModel.createTestContainer();
+ var serializable = new SampleNormalizedNodeSerializable(version, input);
+ var clone = clone(serializable);
assertEquals(input, clone.getInput());
}
- @Test
- public void testAnyXmlStreaming() throws Exception {
- String xml = "<foo xmlns=\"http://www.w3.org/TR/html4/\" x=\"123\"><bar>one</bar><bar>two</bar></foo>";
+ static List<Arguments> testWithSerializable() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void testAnyXmlStreaming(final NormalizedNodeStreamVersion version, final int size) throws Exception {
+ var xml = "<foo xmlns=\"http://www.w3.org/TR/html4/\" x=\"123\"><bar>one</bar><bar>two</bar></foo>";
final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(true);
- Node xmlNode = factory.newDocumentBuilder().parse(
+ final var xmlNode = factory.newDocumentBuilder().parse(
new InputSource(new StringReader(xml))).getDocumentElement();
assertEquals("http://www.w3.org/TR/html4/", xmlNode.getNamespaceURI());
- ContainerNode anyXmlContainer = Builders.containerBuilder()
+ final var anyXmlContainer = Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
.withChild(Builders.anyXmlBuilder()
.withNodeIdentifier(new NodeIdentifier(TestModel.ANY_XML_QNAME))
.build())
.build();
- ByteArrayOutputStream bos = new ByteArrayOutputStream();
- NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(bos));
+ final var bos = new ByteArrayOutputStream();
+ final var nnout = version.newDataOutput(ByteStreams.newDataOutput(bos));
nnout.writeNormalizedNode(anyXmlContainer);
final byte[] bytes = bos.toByteArray();
- assertEquals(anyxmlStreamingSize, bytes.length);
+ assertEquals(size, bytes.length);
- NormalizedNodeDataInput nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
+ final var nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
- ContainerNode deserialized = (ContainerNode)nnin.readNormalizedNode();
+ final var deserialized = (ContainerNode)nnin.readNormalizedNode();
- Optional<DataContainerChild> child = deserialized.findChildByArg(new NodeIdentifier(TestModel.ANY_XML_QNAME));
+ final var child = deserialized.findChildByArg(new NodeIdentifier(TestModel.ANY_XML_QNAME));
assertEquals("AnyXml child present", true, child.isPresent());
- StreamResult xmlOutput = new StreamResult(new StringWriter());
- Transformer transformer = TransformerFactory.newInstance().newTransformer();
+ final var xmlOutput = new StreamResult(new StringWriter());
+ final var transformer = TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
transformer.transform(((DOMSourceAnyxmlNode)child.orElseThrow()).body(), xmlOutput);
((DOMSourceAnyxmlNode)child.orElseThrow()).body().getNode().getNamespaceURI());
}
- @Test
- public void testSchemaPathSerialization() throws IOException {
- final Absolute expected = Absolute.of(TestModel.ANY_XML_QNAME);
+ static List<Arguments> testAnyXmlStreaming() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 229));
+ }
- ByteArrayOutputStream bos = new ByteArrayOutputStream();
- try (NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(bos))) {
+ @ParameterizedTest
+ @MethodSource
+ void testSchemaPathSerialization(final NormalizedNodeStreamVersion version, final int size) throws Exception {
+ final var expected = Absolute.of(TestModel.ANY_XML_QNAME);
+
+ final var bos = new ByteArrayOutputStream();
+ try (var nnout = version.newDataOutput(ByteStreams.newDataOutput(bos))) {
nnout.writeSchemaNodeIdentifier(expected);
}
final byte[] bytes = bos.toByteArray();
- assertEquals(schemaPathSize, bytes.length);
+ assertEquals(size, bytes.length);
- NormalizedNodeDataInput nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
+ var nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
assertEquals(expected, nnin.readSchemaNodeIdentifier());
}
- @Test
- public void testWritePathArgument() throws IOException {
- final NodeIdentifier expected = new NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME);
-
- ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ static List<Arguments> testSchemaPathSerialization() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 99));
+ }
- try (NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(bos))) {
+ @ParameterizedTest
+ @MethodSource
+ void testWritePathArgument(final NormalizedNodeStreamVersion version, final int size) throws Exception {
+ final var expected = new NodeIdentifier(TestModel.BOOLEAN_LEAF_QNAME);
+ final var bos = new ByteArrayOutputStream();
+ try (var nnout = version.newDataOutput(ByteStreams.newDataOutput(bos))) {
nnout.writePathArgument(expected);
}
final byte[] bytes = bos.toByteArray();
- assertEquals(writePathArgumentSize, bytes.length);
+ assertEquals(size, bytes.length);
- NormalizedNodeDataInput nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
+ final var nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
assertEquals(expected, nnin.readPathArgument());
}
+ static List<Arguments> testWritePathArgument() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 103));
+ }
+
/*
* This tests the encoding of a MapNode with a lot of entries, each of them having the key leaf (a string)
* and an integer.
*/
- @Test
- public void testHugeEntries() throws IOException {
+ @ParameterizedTest
+ @MethodSource
+ void testHugeEntries(final NormalizedNodeStreamVersion version, final int size) throws Exception {
final var mapBuilder = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME));
final var entryBuilder = Builders.mapEntryBuilder()
.withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, (byte) 42));
.build());
}
- final SystemMapNode expected = mapBuilder.build();
- final ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ final var expected = mapBuilder.build();
+ final var bos = new ByteArrayOutputStream();
- try (NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(bos))) {
+ try (var nnout = version.newDataOutput(ByteStreams.newDataOutput(bos))) {
nnout.writeNormalizedNode(expected);
}
final byte[] bytes = bos.toByteArray();
- assertEquals(hugeEntriesSize, bytes.length);
+ assertEquals(size, bytes.length);
- NormalizedNodeDataInput nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
+ var nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
assertEquals(expected, nnin.readNormalizedNode());
}
+ static List<Arguments> testHugeEntries() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 2_289_103));
+ }
+
private static <T extends Serializable> T clone(final T obj) {
- final ByteArrayOutputStream baos = new ByteArrayOutputStream(512);
- try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
+ final var baos = new ByteArrayOutputStream(512);
+ try (var oos = new ObjectOutputStream(baos)) {
oos.writeObject(obj);
} catch (IOException e) {
throw new AssertionError("Failed to serialize object", e);
}
final byte[] bytes = baos.toByteArray();
- try (ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
+ try (var ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
return (T) ois.readObject();
} catch (ClassNotFoundException | IOException e) {
throw new AssertionError("Failed to deserialize object", e);
}
private static String largeString(final int pow) {
- StringBuilder sb = new StringBuilder("X");
+ final var sb = new StringBuilder("X");
for (int i = 0; i < pow; i++) {
sb.append(sb);
}
*/
package org.opendaylight.yangtools.yang.data.codec.binfmt;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertSame;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertSame;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
-public class QNameFactoryTest {
+class QNameFactoryTest {
@Test
- public void testBasic() {
- QName expected = TestModel.AUG_NAME_QNAME;
- QName created = lookup(expected);
+ void testBasic() {
+ var expected = TestModel.AUG_NAME_QNAME;
+ var created = lookup(expected);
assertNotSame(expected, created);
assertEquals(expected, created);
- QName cached = lookup(expected);
+ var cached = lookup(expected);
assertSame(created, cached);
}
import java.io.Serializable;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public class SampleNormalizedNodeSerializable implements Serializable {
+class SampleNormalizedNodeSerializable implements Serializable {
+ @java.io.Serial
private static final long serialVersionUID = 1L;
private transient NormalizedNodeStreamVersion version;
private NormalizedNode input;
- public SampleNormalizedNodeSerializable(final NormalizedNodeStreamVersion version,
- final NormalizedNode input) {
+ SampleNormalizedNodeSerializable(final NormalizedNodeStreamVersion version, final NormalizedNode input) {
this.version = requireNonNull(version);
this.input = input;
}
- public NormalizedNode getInput() {
+ NormalizedNode getInput() {
return input;
}
+ @java.io.Serial
private void readObject(final ObjectInputStream stream) throws IOException {
- final NormalizedNodeDataInput in = NormalizedNodeDataInput.newDataInput(stream);
- this.input = in.readNormalizedNode();
- this.version = in.getVersion();
+ final var in = NormalizedNodeDataInput.newDataInput(stream);
+ input = in.readNormalizedNode();
+ version = in.getVersion();
}
+ @java.io.Serial
private void writeObject(final ObjectOutputStream stream) throws IOException {
version.newDataOutput(stream).writeNormalizedNode(input);
}
*/
package org.opendaylight.yangtools.yang.data.codec.binfmt;
-import java.util.Collections;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
-
-@RunWith(Parameterized.class)
-public class StringSerializationTest extends AbstractSerializationTest {
+import java.util.List;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class StringSerializationTest extends AbstractSerializationTest {
private static final String STR_MEDIUM = "a".repeat(32767);
private static final String STR_HUGE = "©".repeat(16777216);
- @Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.POTASSIUM, 96, 99, 32_865, 33_554_532 });
+ @ParameterizedTest
+ @MethodSource
+ void testEmptySame(final NormalizedNodeStreamVersion version, final int size) {
+ assertSame(version, "", size);
+ }
+
+ static List<Arguments> testEmptySame() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 96));
}
- @Parameter(1)
- public int emptySize;
- @Parameter(2)
- public int oneSize;
- @Parameter(3)
- public int mediumSize;
- @Parameter(4)
- public int hugeSize;
+ @ParameterizedTest
+ @MethodSource
+ public void testOne(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, "a", size);
+ }
+
+ static List<Arguments> testOne() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 99));
+ }
- @Test
- public void testEmptySame() {
- assertSame("", emptySize);
+ @ParameterizedTest
+ @MethodSource
+ void testMedium(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, STR_MEDIUM, size);
}
- @Test
- public void testOne() {
- assertEquals("a", oneSize);
+ static List<Arguments> testMedium() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 32_865));
}
- @Test
- public void testMedium() {
- assertEquals(STR_MEDIUM, mediumSize);
+ @ParameterizedTest
+ @MethodSource
+ void testHuge(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, STR_HUGE, size);
}
- @Test
- public void testHuge() {
- assertEquals(STR_HUGE, hugeSize);
+ static List<Arguments> testHuge() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 33_554_532));
}
}
*/
package org.opendaylight.yangtools.yang.data.codec.binfmt;
-import java.util.Collections;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import java.util.List;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
import org.opendaylight.yangtools.yang.common.Uint8;
-@RunWith(Parameterized.class)
-public class UintSerializationTest extends AbstractSerializationTest {
- @Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.POTASSIUM });
+class UintSerializationTest extends AbstractSerializationTest {
+ @ParameterizedTest
+ @MethodSource("versions")
+ void testUint8(final NormalizedNodeStreamVersion version) {
+ assertSame(version, Uint8.ZERO, 96);
+ assertSame(version, Uint8.ONE, 97);
}
- @Test
- public void testUint8() {
- assertSame(Uint8.ZERO, 96);
- assertSame(Uint8.ONE, 97);
+ @ParameterizedTest
+ @MethodSource("versions")
+ void testUint16(final NormalizedNodeStreamVersion version) {
+ assertSame(version, Uint16.ZERO, 96);
+ assertSame(version, Uint16.ONE, 98);
}
- @Test
- public void testUint16() {
- assertSame(Uint16.ZERO, 96);
- assertSame(Uint16.ONE, 98);
+ @ParameterizedTest
+ @MethodSource("versions")
+ void testUint32(final NormalizedNodeStreamVersion version) {
+ assertSame(version, Uint32.ZERO, 96);
+ assertSame(version, Uint32.ONE, 98);
+ assertEquals(version, Uint32.MAX_VALUE, 100);
}
- @Test
- public void testUint32() {
- assertSame(Uint32.ZERO, 96);
- assertSame(Uint32.ONE, 98);
- assertEquals(Uint32.MAX_VALUE, 100);
+ @ParameterizedTest
+ @MethodSource("versions")
+ void testUint64(final NormalizedNodeStreamVersion version) {
+ assertSame(version, Uint64.ZERO, 96);
+ assertSame(version, Uint64.ONE, 100);
+ assertEquals(version, Uint64.MAX_VALUE, 104);
}
- @Test
- public void testUint64() {
- assertSame(Uint64.ZERO, 96);
- assertSame(Uint64.ONE, 100);
- assertEquals(Uint64.MAX_VALUE, 104);
+ static List<Arguments> versions() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM));
}
-
}
import com.google.common.io.ByteStreams;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
-import java.util.Collections;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder;
-
-@RunWith(Parameterized.class)
-public class YiidSerializationTest extends AbstractSerializationTest {
- @Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.POTASSIUM,
- 96, 98, 158, 359, 164, 372, 612, 2_388, 131_684, 719_700, 916_815
- });
- }
-
- @Parameter(1)
- public int emptySize;
- @Parameter(2)
- public int oneSize;
- @Parameter(3)
- public int size31;
- @Parameter(4)
- public int uniqueSize31;
- @Parameter(5)
- public int size32;
- @Parameter(6)
- public int uniqueSize32;
- @Parameter(7)
- public int size256;
- @Parameter(8)
- public int uniqueSize256;
- @Parameter(9)
- public int size65792;
- @Parameter(10)
- public int uniqueSize65792;
- @Parameter(11)
- public int twiceSize65792;
-
- @Test
- public void testEmptyIdentifier() {
- assertSame(YangInstanceIdentifier.of(), emptySize);
- }
-
- @Test
- public void testOneIdentifier() {
- assertEquals(YangInstanceIdentifier.of(TestModel.TEST_QNAME), oneSize);
- }
-
- @Test
- public void test31() {
- assertEquals(fillIdentifier(31), size31);
- assertEquals(fillUniqueIdentifier(31), uniqueSize31);
- }
-
- @Test
- public void test32() {
- assertEquals(fillIdentifier(32), size32);
- assertEquals(fillUniqueIdentifier(32), uniqueSize32);
- }
-
- @Test
- public void test256() {
- assertEquals(fillIdentifier(256), size256);
- assertEquals(fillUniqueIdentifier(256), uniqueSize256);
- }
-
- @Test
- public void test65792() {
- assertEquals(fillIdentifier(65792), size65792);
- assertEquals(fillUniqueIdentifier(65792), uniqueSize65792);
- }
-
- @Test
- public void testTwice65536() {
- final YangInstanceIdentifier yiid = fillUniqueIdentifier(65792);
-
- final ByteArrayOutputStream baos = new ByteArrayOutputStream();
- try (NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
+
+class YiidSerializationTest extends AbstractSerializationTest {
+ @ParameterizedTest
+ @MethodSource
+ void testEmptyIdentifier(final NormalizedNodeStreamVersion version, final int size) {
+ assertSame(version, YangInstanceIdentifier.of(), size);
+ }
+
+ static List<Arguments> testEmptyIdentifier() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 96));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void testOneIdentifier(final NormalizedNodeStreamVersion version, final int size) {
+ assertEquals(version, YangInstanceIdentifier.of(TestModel.TEST_QNAME), size);
+ }
+
+ static List<Arguments> testOneIdentifier() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 98));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void test31(final NormalizedNodeStreamVersion version, final int size, final int uniqueSize) {
+ assertEquals(version, fillIdentifier(31), size);
+ assertEquals(version, fillUniqueIdentifier(31), uniqueSize);
+ }
+
+ static List<Arguments> test31() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 158, 359));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void test32(final NormalizedNodeStreamVersion version, final int size, final int uniqueSize) {
+ assertEquals(version, fillIdentifier(32), size);
+ assertEquals(version, fillUniqueIdentifier(32), uniqueSize);
+ }
+
+ static List<Arguments> test32() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 164, 372));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void test256(final NormalizedNodeStreamVersion version, final int size, final int uniqueSize) {
+ assertEquals(version, fillIdentifier(256), size);
+ assertEquals(version, fillUniqueIdentifier(256), uniqueSize);
+ }
+
+ static List<Arguments> test256() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 612, 2_388));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void test65792(final NormalizedNodeStreamVersion version, final int size, final int uniqueSize) {
+ assertEquals(version, fillIdentifier(65792), size);
+ assertEquals(version, fillUniqueIdentifier(65792), uniqueSize);
+ }
+
+ static List<Arguments> test65792() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 131_684, 719_700));
+ }
+
+ @ParameterizedTest
+ @MethodSource
+ void testTwice65536(final NormalizedNodeStreamVersion version, final int size) {
+ final var yiid = fillUniqueIdentifier(65792);
+
+ final var baos = new ByteArrayOutputStream();
+ try (var nnout = version.newDataOutput(ByteStreams.newDataOutput(baos))) {
nnout.writeYangInstanceIdentifier(yiid);
nnout.writeYangInstanceIdentifier(yiid);
} catch (IOException e) {
}
final byte[] bytes = baos.toByteArray();
- Assert.assertEquals(twiceSize65792, bytes.length);
+ Assertions.assertEquals(size, bytes.length);
try {
- final NormalizedNodeDataInput input = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
- Assert.assertEquals(yiid, input.readYangInstanceIdentifier());
- Assert.assertEquals(yiid, input.readYangInstanceIdentifier());
+ final var input = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
+ Assertions.assertEquals(yiid, input.readYangInstanceIdentifier());
+ Assertions.assertEquals(yiid, input.readYangInstanceIdentifier());
} catch (IOException e) {
throw new AssertionError("Failed to deserialize", e);
}
}
+ static List<Arguments> testTwice65536() {
+ return List.of(Arguments.of(NormalizedNodeStreamVersion.POTASSIUM, 916_815));
+ }
+
private static YangInstanceIdentifier fillIdentifier(final int size) {
- final InstanceIdentifierBuilder builder = YangInstanceIdentifier.builder();
+ final var builder = YangInstanceIdentifier.builder();
for (int i = 0; i < size; ++i) {
builder.node(TestModel.TEST_QNAME);
}
- final YangInstanceIdentifier ret = builder.build();
- Assert.assertEquals(size, ret.getPathArguments().size());
+ final var ret = builder.build();
+ Assertions.assertEquals(size, ret.getPathArguments().size());
return ret;
}
private static YangInstanceIdentifier fillUniqueIdentifier(final int size) {
- final InstanceIdentifierBuilder builder = YangInstanceIdentifier.builder();
+ final var builder = YangInstanceIdentifier.builder();
for (int i = 0; i < size; ++i) {
builder.node(QName.create(TestModel.TEST_QNAME, "a" + Integer.toHexString(i)));
}
- final YangInstanceIdentifier ret = builder.build();
- Assert.assertEquals(size, ret.getPathArguments().size());
+ final var ret = builder.build();
+ Assertions.assertEquals(size, ret.getPathArguments().size());
return ret;
}
}
Code Review / yangtools.git / commitdiff