Fix a few deprecation warnings

Migrate towards data.spi.node.ImmutableNodes in a few components.

Change-Id: I02b29e4a51acd5f979ba70b939ea1bbae351aa20
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/bgp/parser-spi/pom.xml b/bgp/parser-spi/pom.xml
index c956e07c98ec2791f7da2da0141c16cb236bd586..db26ac9f5d890770bc3b22332a236c4b99de6b89 100644 (file)
--- a/bgp/parser-spi/pom.xml
+++ b/bgp/parser-spi/pom.xml
@@ -105,7 +105,7 @@
         </dependency>
         <dependency>
             <groupId>org.opendaylight.yangtools</groupId>
-            <artifactId>yang-data-impl</artifactId>
+            <artifactId>yang-data-spi</artifactId>
             <scope>test</scope>
         </dependency>
     </dependencies>

diff --git a/bgp/parser-spi/src/test/java/org/opendaylight/protocol/bgp/parser/spi/PathIdUtilTest.java b/bgp/parser-spi/src/test/java/org/opendaylight/protocol/bgp/parser/spi/PathIdUtilTest.java
index c3ef82b5c3a596efb570d044ab4e6cd70309bea5..35c0723448529a7477ee2bc5c9defdd4ab78e68e 100644 (file)
--- a/bgp/parser-spi/src/test/java/org/opendaylight/protocol/bgp/parser/spi/PathIdUtilTest.java
+++ b/bgp/parser-spi/src/test/java/org/opendaylight/protocol/bgp/parser/spi/PathIdUtilTest.java
@@ -7,74 +7,65 @@
  */
 package org.opendaylight.protocol.bgp.parser.spi;
 
-import static org.opendaylight.protocol.bgp.parser.spi.PathIdUtil.NON_PATH_ID;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev200120.PathId;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.Uint32;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
 
-public class PathIdUtilTest {
-
-    private ByteBuf buffer;
-
-    @Before
-    public void setUp() {
-        this.buffer = Unpooled.buffer();
-    }
+class PathIdUtilTest {
+    private final ByteBuf buffer = Unpooled.buffer();
 
     @Test
-    public void testWritePathIdNull() {
-        PathIdUtil.writePathId(null, this.buffer);
-        Assert.assertEquals(0, this.buffer.readableBytes());
+    void testWritePathIdNull() {
+        PathIdUtil.writePathId(null, buffer);
+        assertEquals(0, buffer.readableBytes());
     }
 
     @Test
-    public void testWritePathIdZero() {
-        PathIdUtil.writePathId(NON_PATH_ID, this.buffer);
-        Assert.assertEquals(0, this.buffer.readableBytes());
+    void testWritePathIdZero() {
+        PathIdUtil.writePathId(PathIdUtil.NON_PATH_ID, buffer);
+        assertEquals(0, buffer.readableBytes());
     }
 
     @Test
-    public void testWritePathId() {
-        PathIdUtil.writePathId(new PathId(Uint32.TEN), this.buffer);
-        Assert.assertEquals(Integer.BYTES, this.buffer.readableBytes());
+    void testWritePathId() {
+        PathIdUtil.writePathId(new PathId(Uint32.TEN), buffer);
+        assertEquals(Integer.BYTES, buffer.readableBytes());
     }
 
     @Test
-    public void testReadPathId() {
-        this.buffer.writeInt(10);
-        final PathId pathId = PathIdUtil.readPathId(this.buffer);
-        Assert.assertEquals(Uint32.TEN, pathId.getValue());
+    void testReadPathId() {
+        buffer.writeInt(10);
+        final PathId pathId = PathIdUtil.readPathId(buffer);
+        assertEquals(Uint32.TEN, pathId.getValue());
     }
 
     @Test
-    public void testExtractPathId() {
+    void testExtractPathId() {
         final NodeIdentifier NII = new NodeIdentifier(QName.create("urn:opendaylight:params:xml:ns:yang:bgp-inet",
             "2015-03-05", "path-id").intern());
-        final ContainerNode cont = Builders.containerBuilder()
+        final ContainerNode cont = ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(NII)
             .addChild(ImmutableNodes.leafNode(NII, Uint32.ZERO))
             .build();
-        Assert.assertEquals(0L, PathIdUtil.extractPathId(cont, NII).longValue());
+        assertEquals(0L, PathIdUtil.extractPathId(cont, NII).longValue());
     }
 
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testReadPathIdBufferNull() {
-        PathIdUtil.readPathId(null);
+    @Test
+    void testReadPathIdBufferNull() {
+        assertThrows(IllegalArgumentException.class, () -> PathIdUtil.readPathId(null));
     }
 
-    @Test(expected = IllegalArgumentException.class)
-    public void testReadPathIdBufferEmpty() {
-        PathIdUtil.readPathId(this.buffer);
+    @Test
+    void testReadPathIdBufferEmpty() {
+        assertThrows(IllegalArgumentException.class, () -> PathIdUtil.readPathId(buffer));
     }
 }

diff --git a/bgp/path-selection-mode/pom.xml b/bgp/path-selection-mode/pom.xml
index 05d902ae54e409fb80b579cdfb0d1f9e6cd3b162..4350f08ac0346acbc66b168b1fefa2efe39be383 100644 (file)
--- a/bgp/path-selection-mode/pom.xml
+++ b/bgp/path-selection-mode/pom.xml
@@ -70,7 +70,7 @@
         </dependency>
         <dependency>
             <groupId>org.opendaylight.yangtools</groupId>
-            <artifactId>yang-data-impl</artifactId>
+            <artifactId>yang-data-spi</artifactId>
         </dependency>
         <dependency>
             <groupId>org.opendaylight.mdsal</groupId>

diff --git a/bgp/path-selection-mode/src/test/java/org/opendaylight/protocol/bgp/mode/impl/base/BasePathSelectorTest.java b/bgp/path-selection-mode/src/test/java/org/opendaylight/protocol/bgp/mode/impl/base/BasePathSelectorTest.java
index 1b7d6fb33181a6e33631fe63106c66bd39ff590d..31e0073046f33dc91b63276d12b084349b7e1b7b 100644 (file)
--- a/bgp/path-selection-mode/src/test/java/org/opendaylight/protocol/bgp/mode/impl/base/BasePathSelectorTest.java
+++ b/bgp/path-selection-mode/src/test/java/org/opendaylight/protocol/bgp/mode/impl/base/BasePathSelectorTest.java
@@ -29,8 +29,7 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdent
 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.builder.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
 
 public class BasePathSelectorTest {
     static final RouterId ROUTER_ID2 = RouterId.forPeerId(new PeerId("bgp://127.0.0.1"));
@@ -42,10 +41,10 @@ public class BasePathSelectorTest {
     private static final RouterId ROUTER_ID3 = RouterId.forPeerId(new PeerId("bgp://127.0.0.2"));
     private final BasePathSelector selector = new BasePathSelector(20L);
     private final BestPathStateImpl state = new BestPathStateImpl(createStateFromPrefMedOriginASPath().build());
-    private final BaseBestPath originBestPath = new BaseBestPath(ROUTER_ID, this.state);
+    private final BaseBestPath originBestPath = new BaseBestPath(ROUTER_ID, state);
 
     private static ContainerNode createStateFromPrefMedOrigin() {
-        return Builders.containerBuilder()
+        return ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(new NodeIdentifier(Attributes.QNAME))
             .withChild(lowerLocalPref())
             .withChild(lowerMultiExitDisc())
@@ -54,7 +53,7 @@ public class BasePathSelectorTest {
     }
 
     protected static DataContainerNodeBuilder<NodeIdentifier, ContainerNode> createStateFromPrefMedOriginASPath() {
-        return Builders.containerBuilder()
+        return ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(new NodeIdentifier(Attributes.QNAME))
             .withChild(higherLocalPref())
             .withChild(higherMultiExitDisc())
@@ -71,7 +70,7 @@ public class BasePathSelectorTest {
     }
 
     private static ContainerNode localPref(final Uint32 pref) {
-        return Builders.containerBuilder()
+        return ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(new NodeIdentifier(LocalPref.QNAME))
             .withChild(ImmutableNodes.leafNode(QName.create(LocalPref.QNAME, "pref"), pref))
             .build();
@@ -86,7 +85,7 @@ public class BasePathSelectorTest {
     }
 
     private static ContainerNode multiExitDisc(final Uint32 med) {
-        return Builders.containerBuilder()
+        return ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(new NodeIdentifier(MultiExitDisc.QNAME))
             .withChild(ImmutableNodes.leafNode(QName.create(MultiExitDisc.QNAME, "med"), med))
             .build();
@@ -101,22 +100,22 @@ public class BasePathSelectorTest {
     }
 
     private static ContainerNode origin(final BgpOrigin value) {
-        return Builders.containerBuilder()
+        return ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(new NodeIdentifier(Origin.QNAME))
             .withChild(ImmutableNodes.leafNode(QName.create(Origin.QNAME, "value"), value.getName()))
             .build();
     }
 
     private static ContainerNode asPath(final List<Uint32> segment) {
-        return Builders.containerBuilder()
+        return ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(new NodeIdentifier(AsPath.QNAME))
-            .withChild(Builders.unkeyedListBuilder()
+            .withChild(ImmutableNodes.newUnkeyedListBuilder()
                 .withNodeIdentifier(new NodeIdentifier(Segments.QNAME))
-                .withChild(Builders.unkeyedListEntryBuilder()
+                .withChild(ImmutableNodes.newUnkeyedListEntryBuilder()
                     .withNodeIdentifier(new NodeIdentifier(Segments.QNAME))
-                    .withChild(Builders.orderedLeafSetBuilder()
+                    .withChild(ImmutableNodes.newUserLeafSetBuilder()
                         .withNodeIdentifier(new NodeIdentifier(AS_SEQUENCE))
-                        .withValue(Lists.transform(segment, asn -> Builders.leafSetEntryBuilder()
+                        .withValue(Lists.transform(segment, asn -> ImmutableNodes.newLeafSetEntryBuilder()
                             .withNodeIdentifier(new NodeWithValue<>(AS_SEQUENCE, asn))
                             .withValue(asn)
                             .build()))
@@ -129,97 +128,97 @@ public class BasePathSelectorTest {
     @Test
     public void testBestPathWithHigherLocalPref() {
         // local-pref 123
-        this.selector.processPath(ROUTER_ID2, createStateFromPrefMedOrigin());
-        BaseBestPath processedPath = this.selector.result();
+        selector.processPath(ROUTER_ID2, createStateFromPrefMedOrigin());
+        BaseBestPath processedPath = selector.result();
         assertEquals(Uint32.valueOf(123), processedPath.getState().getLocalPref());
 
         // local-pref 321
-        this.selector.processPath(ROUTER_ID2, createStateFromPrefMedOriginASPath().build());
-        processedPath = this.selector.result();
+        selector.processPath(ROUTER_ID2, createStateFromPrefMedOriginASPath().build());
+        processedPath = selector.result();
         assertEquals(Uint32.valueOf(321), processedPath.getState().getLocalPref());
 
-        this.selector.processPath(ROUTER_ID2, Builders.containerBuilder()
+        selector.processPath(ROUTER_ID2, ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(new NodeIdentifier(Attributes.QNAME))
             // prefer path with higher LOCAL_PREF
             .withChild(lowerLocalPref())
             .build());
-        processedPath = this.selector.result();
+        processedPath = selector.result();
         assertEquals(Uint32.valueOf(321), processedPath.getState().getLocalPref());
     }
 
     @Test
     public void testBestPathForEquality() {
-        this.selector.processPath(ROUTER_ID2, createStateFromPrefMedOriginASPath().build());
-        final BaseBestPath processedPath = this.selector.result();
+        selector.processPath(ROUTER_ID2, createStateFromPrefMedOriginASPath().build());
+        final BaseBestPath processedPath = selector.result();
 
-        assertEquals(this.originBestPath.getPeerId(), processedPath.getPeerId());
-        assertEquals(this.originBestPath.getState().getLocalPref(), processedPath.getState().getLocalPref());
-        assertEquals(this.originBestPath.getState().getMultiExitDisc(), processedPath.getState().getMultiExitDisc());
-        assertEquals(this.originBestPath.getState().getOrigin(), processedPath.getState().getOrigin());
-        assertEquals(this.originBestPath.getState().getPeerAs(), processedPath.getState().getPeerAs());
-        assertEquals(this.originBestPath.getState().getAsPathLength(), processedPath.getState().getAsPathLength());
+        assertEquals(originBestPath.getPeerId(), processedPath.getPeerId());
+        assertEquals(originBestPath.getState().getLocalPref(), processedPath.getState().getLocalPref());
+        assertEquals(originBestPath.getState().getMultiExitDisc(), processedPath.getState().getMultiExitDisc());
+        assertEquals(originBestPath.getState().getOrigin(), processedPath.getState().getOrigin());
+        assertEquals(originBestPath.getState().getPeerAs(), processedPath.getState().getPeerAs());
+        assertEquals(originBestPath.getState().getAsPathLength(), processedPath.getState().getAsPathLength());
     }
 
     @Test
     public void testBestPathSelectionOptions() {
         DataContainerNodeBuilder<NodeIdentifier, ContainerNode> dataContBuilder = createStateFromPrefMedOriginASPath();
-        this.selector.processPath(ROUTER_ID2, dataContBuilder.build());
-        BaseBestPath processedPath = this.selector.result();
+        selector.processPath(ROUTER_ID2, dataContBuilder.build());
+        BaseBestPath processedPath = selector.result();
         assertEquals(BgpOrigin.Egp, processedPath.getState().getOrigin());
 
         // prefer the path with the lowest origin type
-        this.selector.processPath(ROUTER_ID2, dataContBuilder.withChild(igpOrigin()).build());
-        processedPath = this.selector.result();
+        selector.processPath(ROUTER_ID2, dataContBuilder.withChild(igpOrigin()).build());
+        processedPath = selector.result();
         assertEquals(BgpOrigin.Igp, processedPath.getState().getOrigin());
 
-        this.selector.processPath(ROUTER_ID2, dataContBuilder.withChild(egpOrigin()).build());
-        processedPath = this.selector.result();
+        selector.processPath(ROUTER_ID2, dataContBuilder.withChild(egpOrigin()).build());
+        processedPath = selector.result();
         assertEquals(BgpOrigin.Igp, processedPath.getState().getOrigin());
         assertEquals(4321L, processedPath.getState().getMultiExitDisc());
 
         // prefer the path with the lowest multi-exit discriminator (MED)
-        this.selector.processPath(ROUTER_ID2, dataContBuilder
+        selector.processPath(ROUTER_ID2, dataContBuilder
             .withChild(igpOrigin())
             .withChild(lowerMultiExitDisc())
             .build());
-        processedPath = this.selector.result();
+        processedPath = selector.result();
         assertEquals(1234L, processedPath.getState().getMultiExitDisc());
 
-        this.selector.processPath(ROUTER_ID2, dataContBuilder.withChild(higherMultiExitDisc()).build());
-        processedPath = this.selector.result();
+        selector.processPath(ROUTER_ID2, dataContBuilder.withChild(higherMultiExitDisc()).build());
+        processedPath = selector.result();
         assertEquals(1234L, processedPath.getState().getMultiExitDisc());
         assertEquals(1L, processedPath.getState().getPeerAs());
         assertEquals(3, processedPath.getState().getAsPathLength());
 
-        this.selector.processPath(ROUTER_ID2, dataContBuilder
+        selector.processPath(ROUTER_ID2, dataContBuilder
             .withChild(lowerMultiExitDisc())
             .withChild(asPath(SEQ_SEGMENT2))
             .build());
-        processedPath = this.selector.result();
+        processedPath = selector.result();
         assertEquals(1L, processedPath.getState().getPeerAs());
         assertEquals(3, processedPath.getState().getAsPathLength());
     }
 
     @Test
     public void testBestPathForNonEquality() {
-        this.selector.processPath(ROUTER_ID3, createStateFromPrefMedOrigin());
-        final BaseBestPath processedPath = this.selector.result();
+        selector.processPath(ROUTER_ID3, createStateFromPrefMedOrigin());
+        final BaseBestPath processedPath = selector.result();
 
-        assertNotEquals(this.originBestPath.getPeerId(), processedPath.getPeerId());
-        assertNotEquals(this.originBestPath.getState().getLocalPref(), processedPath.getState().getLocalPref());
-        assertNotEquals(this.originBestPath.getState().getMultiExitDisc(), processedPath.getState().getMultiExitDisc());
-        assertNotEquals(this.originBestPath.getState().getOrigin(), processedPath.getState().getOrigin());
-        assertNotEquals(this.originBestPath.getState().getPeerAs(), processedPath.getState().getPeerAs());
-        assertNotEquals(this.originBestPath.getState().getAsPathLength(), processedPath.getState().getAsPathLength());
+        assertNotEquals(originBestPath.getPeerId(), processedPath.getPeerId());
+        assertNotEquals(originBestPath.getState().getLocalPref(), processedPath.getState().getLocalPref());
+        assertNotEquals(originBestPath.getState().getMultiExitDisc(), processedPath.getState().getMultiExitDisc());
+        assertNotEquals(originBestPath.getState().getOrigin(), processedPath.getState().getOrigin());
+        assertNotEquals(originBestPath.getState().getPeerAs(), processedPath.getState().getPeerAs());
+        assertNotEquals(originBestPath.getState().getAsPathLength(), processedPath.getState().getAsPathLength());
     }
 
     @Test
     public void testBgpOrigin() {
-        this.selector.processPath(ROUTER_ID3, Builders.containerBuilder()
+        selector.processPath(ROUTER_ID3, ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(new NodeIdentifier(Attributes.QNAME))
             .withChild(origin(BgpOrigin.Incomplete))
             .build());
-        final BaseBestPath processedPathIncom = this.selector.result();
+        final BaseBestPath processedPathIncom = selector.result();
         assertEquals(BgpOrigin.Incomplete, processedPathIncom.getState().getOrigin());
     }
 }

diff --git a/bgp/rib-spi/pom.xml b/bgp/rib-spi/pom.xml
index 626ca9de23d1eac0980e49f108eae41153cebdf2..7fb1792d6cdbcf125bc22632ee4f898130baacf0 100644 (file)
--- a/bgp/rib-spi/pom.xml
+++ b/bgp/rib-spi/pom.xml
@@ -61,6 +61,10 @@
             <groupId>org.opendaylight.yangtools</groupId>
             <artifactId>yang-data-api</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.opendaylight.yangtools</groupId>
+            <artifactId>yang-data-spi</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.opendaylight.yangtools</groupId>
             <artifactId>yang-data-tree-api</artifactId>

diff --git a/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBNormalizedNodes.java b/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBNormalizedNodes.java
index 2cd86603067776887c7945be8d9b1ef583b2648c..c1661b0e66242163a1ba19d078ccb86d4caf461e 100644 (file)
--- a/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBNormalizedNodes.java
+++ b/bgp/rib-spi/src/main/java/org/opendaylight/protocol/bgp/rib/spi/RIBNormalizedNodes.java
@@ -13,8 +13,7 @@ import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.UPTODATE_
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
 
 /**
  * Utility constant {@link NormalizedNode}s.
@@ -25,9 +24,9 @@ public final class RIBNormalizedNodes {
     public static final LeafNode<Boolean> ATTRIBUTES_UPTODATE_TRUE = ImmutableNodes.leafNode(
         UPTODATE_NID, Boolean.TRUE);
 
-    public static final ContainerNode NOT_UPTODATE_ATTRIBUTES = Builders.containerBuilder()
+    public static final ContainerNode NOT_UPTODATE_ATTRIBUTES = ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(ATTRIBUTES_NID).withChild(ATTRIBUTES_UPTODATE_FALSE).build();
-    public static final ContainerNode UPTODATE_ATTRIBUTES = Builders.containerBuilder()
+    public static final ContainerNode UPTODATE_ATTRIBUTES = ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(ATTRIBUTES_NID).withChild(ATTRIBUTES_UPTODATE_TRUE).build();
 
     private RIBNormalizedNodes() {

diff --git a/bgp/rib-spi/src/test/java/org/opendaylight/protocol/bgp/rib/spi/RIBSupportTest.java b/bgp/rib-spi/src/test/java/org/opendaylight/protocol/bgp/rib/spi/RIBSupportTest.java
index 6aff5eb14a8b462aa352c8e9680e7cf4d91e7c9d..29c5d2a9268bf2dbdcc1be39f0788eb8871695ea 100644 (file)
--- a/bgp/rib-spi/src/test/java/org/opendaylight/protocol/bgp/rib/spi/RIBSupportTest.java
+++ b/bgp/rib-spi/src/test/java/org/opendaylight/protocol/bgp/rib/spi/RIBSupportTest.java
@@ -66,7 +66,7 @@ import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
 import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode;
 
 public class RIBSupportTest extends AbstractConcurrentDataBrokerTest {
@@ -114,7 +114,7 @@ public class RIBSupportTest extends AbstractConcurrentDataBrokerTest {
 
         tx = Mockito.mock(DOMDataTreeWriteTransaction.class);
         nlri = Mockito.mock(ContainerNode.class);
-        attributes = Builders.containerBuilder()
+        attributes = ImmutableNodes.newContainerBuilder()
                 .withNodeIdentifier(new NodeIdentifier(QName.create(Ipv4Routes.QNAME, Attributes.QNAME
                     .getLocalName().intern())))
                 .build();

diff --git a/config-loader/protocols-config-loader/pom.xml b/config-loader/protocols-config-loader/pom.xml
index 8537a56c30be222cc2315bdb7039486aa2e61194..d00841cc2acdf2f594003f1e7f4cb585b197f54b 100644 (file)
--- a/config-loader/protocols-config-loader/pom.xml
+++ b/config-loader/protocols-config-loader/pom.xml
@@ -51,7 +51,7 @@
         </dependency>
         <dependency>
             <groupId>org.opendaylight.yangtools</groupId>
-            <artifactId>yang-data-impl</artifactId>
+            <artifactId>yang-data-spi</artifactId>
         </dependency>
         <dependency>
             <groupId>org.opendaylight.mdsal</groupId>

diff --git a/config-loader/protocols-config-loader/src/main/java/org/opendaylight/bgpcep/config/loader/protocols/ProtocolsConfigFileProcessor.java b/config-loader/protocols-config-loader/src/main/java/org/opendaylight/bgpcep/config/loader/protocols/ProtocolsConfigFileProcessor.java
index 242b01e85ac09ebd440bf201faada1ec8a162afd..9e63a2b4e027970fa4c3acc8cf87d96119c7533a 100644 (file)
--- a/config-loader/protocols-config-loader/src/main/java/org/opendaylight/bgpcep/config/loader/protocols/ProtocolsConfigFileProcessor.java
+++ b/config-loader/protocols-config-loader/src/main/java/org/opendaylight/bgpcep/config/loader/protocols/ProtocolsConfigFileProcessor.java
@@ -31,8 +31,7 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdent
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
 
 @Singleton
@@ -81,7 +80,7 @@ public final class ProtocolsConfigFileProcessor extends AbstractConfigFileProces
         final DOMDataTreeWriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 
         // Ensure global-bgp exists
-        wtx.merge(LogicalDatastoreType.CONFIGURATION, GLOBAL_BGP_PATH, Builders.mapEntryBuilder()
+        wtx.merge(LogicalDatastoreType.CONFIGURATION, GLOBAL_BGP_PATH, ImmutableNodes.newMapEntryBuilder()
             .withNodeIdentifier(GLOBAL_BGP)
             .withChild(ImmutableNodes.leafNode(NAME, GLOBAL_BGP_NAME))
             .build());