BUG-865: remove references to obsolete types

TypeDefinition subclasses in model.util are deprecated.
Use their model.util.type equivalents available through BaseTypes.

Added one negative test into NnToXmlTest.

Change-Id: Id5bda10663b12e782a24731bc73d3e771ea242f1
Signed-off-by: Jakub Toth <jatoth@cisco.com>

diff --git a/restconf/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/nn/to/xml/test/NnToXmlTest.java b/restconf/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/nn/to/xml/test/NnToXmlTest.java
index 0c5bdfa6de8c91c19fb719eb0fa096d66d3254d0..1c77de09b86186e0df039f88940a6c93aa6ca962 100644 (file)
--- a/restconf/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/nn/to/xml/test/NnToXmlTest.java
+++ b/restconf/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/nn/to/xml/test/NnToXmlTest.java
@@ -9,18 +9,19 @@ package org.opendaylight.controller.sal.restconf.impl.nn.to.xml.test;
 
 import static org.junit.Assert.assertTrue;
 
-import com.google.common.base.Optional;
+import com.google.common.base.VerifyException;
 import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
 import java.io.ByteArrayOutputStream;
 import java.io.OutputStream;
 import java.util.List;
 import javax.ws.rs.core.MediaType;
 import org.junit.BeforeClass;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ExpectedException;
 import org.mockito.Mockito;
-import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
 import org.opendaylight.controller.sal.rest.impl.test.providers.AbstractBodyReaderTest;
+import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
 import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
 import org.opendaylight.netconf.sal.restconf.impl.InstanceIdentifierContext;
 import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext;
@@ -36,34 +37,24 @@ import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
-import org.opendaylight.yangtools.yang.model.util.BinaryType;
-import org.opendaylight.yangtools.yang.model.util.BitsType;
-import org.opendaylight.yangtools.yang.model.util.BooleanType;
-import org.opendaylight.yangtools.yang.model.util.EmptyType;
-import org.opendaylight.yangtools.yang.model.util.EnumerationType;
-import org.opendaylight.yangtools.yang.model.util.Int16;
-import org.opendaylight.yangtools.yang.model.util.Int32;
-import org.opendaylight.yangtools.yang.model.util.Int64;
-import org.opendaylight.yangtools.yang.model.util.Int8;
-import org.opendaylight.yangtools.yang.model.util.StringType;
-import org.opendaylight.yangtools.yang.model.util.Uint16;
-import org.opendaylight.yangtools.yang.model.util.Uint32;
-import org.opendaylight.yangtools.yang.model.util.Uint64;
-import org.opendaylight.yangtools.yang.model.util.Uint8;
-import org.opendaylight.yangtools.yang.model.util.UnionType;
+import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
+import org.opendaylight.yangtools.yang.model.util.type.BitsTypeBuilder;
+import org.opendaylight.yangtools.yang.model.util.type.EnumerationTypeBuilder;
+import org.opendaylight.yangtools.yang.model.util.type.UnionTypeBuilder;
 
 public class NnToXmlTest extends AbstractBodyReaderTest {
 
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
     private final NormalizedNodeXmlBodyWriter xmlBodyWriter;
     private static SchemaContext schemaContext;
 
     public NnToXmlTest() throws NoSuchFieldException, SecurityException {
         super();
-        xmlBodyWriter = new NormalizedNodeXmlBodyWriter();
+        this.xmlBodyWriter = new NormalizedNodeXmlBodyWriter();
     }
 
     @BeforeClass
@@ -74,39 +65,45 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
 
     @Test
     public void nnAsYangIdentityrefToXMLTest() throws Exception {
-        final NormalizedNodeContext normalizedNodeContext = prepareIdrefData(null,
-                true);
-        nnToXml(normalizedNodeContext,
-                "<lf11 xmlns:x=\"referenced:module\">x:iden</lf11>");
+        final NormalizedNodeContext normalizedNodeContext = prepareIdrefData(null, true);
+        nnToXml(normalizedNodeContext, "<lf11 xmlns:x=\"referenced:module\">x:iden</lf11>");
     }
 
     @Test
     public void nnAsYangIdentityrefWithQNamePrefixToXMLTest() throws Exception {
-        final NormalizedNodeContext normalizedNodeContext = prepareIdrefData(
-                "prefix", true);
-        nnToXml(normalizedNodeContext, "<lf11 xmlns",
-                "=\"referenced:module\">", ":iden</lf11>");
+        final NormalizedNodeContext normalizedNodeContext = prepareIdrefData("prefix", true);
+        nnToXml(normalizedNodeContext, "<lf11 xmlns", "=\"referenced:module\">", ":iden</lf11>");
     }
 
     @Test
     public void nnAsYangIdentityrefWithPrefixToXMLTest() throws Exception {
-        final NormalizedNodeContext normalizedNodeContext = prepareIdrefData(
-                "prefix", false);
+        final NormalizedNodeContext normalizedNodeContext = prepareIdrefData("prefix", false);
         nnToXml(normalizedNodeContext, "<lf11>no qname value</lf11>");
     }
 
     @Test
     public void nnAsYangLeafrefWithPrefixToXMLTest() throws Exception {
         final NormalizedNodeContext normalizedNodeContext = prepareLeafrefData();
-        nnToXml(normalizedNodeContext, "<lfBoolean>true</lfBoolean>",
-                "<lfLfref>true</lfLfref>");
+        nnToXml(normalizedNodeContext, "<lfBoolean>true</lfBoolean>", "<lfLfref>true</lfLfref>");
+    }
+
+    /**
+     * Negative test when leaf of type leafref references to not-existing leaf.
+     * {@code VerifyException} is expected.
+     */
+    @Test
+    public void nnAsYangLeafrefWithPrefixToXMLNegativeTest() throws Exception {
+        final NormalizedNodeContext normalizedNodeContext = prepareLeafrefNegativeData();
+
+        thrown.expect(VerifyException.class);
+        nnToXml(normalizedNodeContext, "<not-existing>value</not-existing>",
+                "<lfLfrefNegative>value</lfLfrefnegative>");
     }
 
     @Test
     public void nnAsYangStringToXmlTest() throws Exception {
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(StringType.getInstance())
-                        .deserialize("lfStr value"), "lfStr");
+                TypeDefinitionAwareCodec.from(BaseTypes.stringType()).deserialize("lfStr value"), "lfStr");
         nnToXml(normalizedNodeContext, "<lfStr>lfStr value</lfStr>");
     }
 
@@ -115,10 +112,8 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
         final String elName = "lfInt8";
 
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(Int8.getInstance()).deserialize(
-                        "14"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">14</" + elName
-                + ">");
+                TypeDefinitionAwareCodec.from(BaseTypes.int8Type()).deserialize("14"), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">14</" + elName + ">");
     }
 
     @Test
@@ -126,10 +121,8 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
         final String elName = "lfInt16";
 
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(Int16.getInstance()).deserialize(
-                        "3000"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">3000</" + elName
-                + ">");
+                TypeDefinitionAwareCodec.from(BaseTypes.int16Type()).deserialize("3000"), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">3000</" + elName + ">");
     }
 
     @Test
@@ -137,10 +130,8 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
         final String elName = "lfInt32";
 
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(Int32.getInstance()).deserialize(
-                        "201234"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">201234</"
-                + elName + ">");
+                TypeDefinitionAwareCodec.from(BaseTypes.int32Type()).deserialize("201234"), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">201234</" + elName + ">");
     }
 
     @Test
@@ -148,10 +139,8 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
         final String elName = "lfInt64";
 
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(Int64.getInstance()).deserialize(
-                        "5123456789"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">5123456789</"
-                + elName + ">");
+                TypeDefinitionAwareCodec.from(BaseTypes.int64Type()).deserialize("5123456789"), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">5123456789</" + elName + ">");
     }
 
     @Test
@@ -159,10 +148,8 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
         final String elName = "lfUint8";
 
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(Uint8.getInstance()).deserialize(
-                        "200"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">200</" + elName
-                + ">");
+                TypeDefinitionAwareCodec.from(BaseTypes.uint8Type()).deserialize("200"), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">200</" + elName + ">");
     }
 
     @Test
@@ -170,10 +157,8 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
         final String elName = "lfUint16";
 
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(Uint16.getInstance())
-                        .deserialize("4000"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">4000</" + elName
-                + ">");
+                TypeDefinitionAwareCodec.from(BaseTypes.uint16Type()).deserialize("4000"), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">4000</" + elName + ">");
     }
 
     @Test
@@ -181,143 +166,116 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
         final String elName = "lfUint32";
 
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(Uint32.getInstance())
-                        .deserialize("4123456789"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">4123456789</"
-                + elName + ">");
+                TypeDefinitionAwareCodec.from(BaseTypes.uint32Type()).deserialize("4123456789"), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">4123456789</" + elName + ">");
     }
 
     @Test
     public void snAsYangUint64ToXmlTest() throws Exception {
         final String elName = "lfUint64";
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(Uint64.getInstance())
-                        .deserialize("5123456789"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">5123456789</"
-                + elName + ">");
+                TypeDefinitionAwareCodec.from(BaseTypes.uint64Type()).deserialize("5123456789"), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">5123456789</" + elName + ">");
     }
 
     @Test
     public void nnAsYangBinaryToXmlTest() throws Exception {
         final String elName = "lfBinary";
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec
-                        .from(BinaryType.getInstance())
-                        .deserialize(
-                                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567"),
+                TypeDefinitionAwareCodec.from(BaseTypes.binaryType())
+                        .deserialize("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567"),
                 elName);
-        nnToXml(
-                normalizedNodeContext,
-                "<"
-                        + elName
-                        + ">ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567</"
-                        + elName + ">");
+        nnToXml(normalizedNodeContext,
+                "<" + elName + ">ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567</" + elName + ">");
     }
 
     @Test
     public void nnAsYangBitsToXmlTest() throws Exception {
-        final BitsTypeDefinition.Bit mockBit1 = Mockito
-                .mock(BitsTypeDefinition.Bit.class);
+        final BitsTypeDefinition.Bit mockBit1 = Mockito.mock(BitsTypeDefinition.Bit.class);
         Mockito.when(mockBit1.getName()).thenReturn("one");
-        final BitsTypeDefinition.Bit mockBit2 = Mockito
-                .mock(BitsTypeDefinition.Bit.class);
+        Mockito.when(mockBit1.getPosition()).thenReturn(1l);
+        final BitsTypeDefinition.Bit mockBit2 = Mockito.mock(BitsTypeDefinition.Bit.class);
         Mockito.when(mockBit2.getName()).thenReturn("two");
-        final List<BitsTypeDefinition.Bit> bitList = Lists.newArrayList(
-                mockBit1, mockBit2);
+        Mockito.when(mockBit2.getPosition()).thenReturn(2l);
+        final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Mockito.mock(SchemaPath.class));
+        bitsTypeBuilder.addBit(mockBit1);
+        bitsTypeBuilder.addBit(mockBit2);
 
         final String elName = "lfBits";
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec
-                        .from(BitsType.create(Mockito.mock(SchemaPath.class),
-                                bitList)).deserialize("one two"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">one two</"
-                + elName + ">");
+                TypeDefinitionAwareCodec.from(bitsTypeBuilder.build()).deserialize("one two"), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">one two</" + elName + ">");
     }
 
     @Test
     public void nnAsYangEnumerationToXmlTest() throws Exception {
-        final EnumTypeDefinition.EnumPair mockEnum = Mockito
-                .mock(EnumTypeDefinition.EnumPair.class);
+        final EnumTypeDefinition.EnumPair mockEnum = Mockito.mock(EnumTypeDefinition.EnumPair.class);
         Mockito.when(mockEnum.getName()).thenReturn("enum2");
-        final List<EnumPair> enumList = Lists.newArrayList(mockEnum);
+
+        final EnumerationTypeBuilder enumerationTypeBuilder = BaseTypes
+                .enumerationTypeBuilder(Mockito.mock(SchemaPath.class));
+        enumerationTypeBuilder.addEnum(mockEnum);
 
         final String elName = "lfEnumeration";
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec
-                        .from(EnumerationType.create(
-                                Mockito.mock(SchemaPath.class), enumList,
-                                Optional.<EnumTypeDefinition.EnumPair> absent()))
-                        .deserialize("enum2"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">enum2</"
-                + elName + ">");
+                TypeDefinitionAwareCodec.from(enumerationTypeBuilder.build()).deserialize("enum2"), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">enum2</" + elName + ">");
     }
 
     @Test
     public void nnAsYangEmptyToXmlTest() throws Exception {
         final String elName = "lfEmpty";
         final NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(EmptyType.getInstance())
-                        .deserialize(null), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + "></" + elName
-                + ">");
+                TypeDefinitionAwareCodec.from(BaseTypes.emptyType()).deserialize(null), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + "></" + elName + ">");
     }
 
     @Test
     public void nnAsYangBooleanToXmlTest() throws Exception {
         final String elName = "lfBoolean";
         NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(BooleanType.getInstance())
-.deserialize("false"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">false</"
-                + elName + ">");
-
-        normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(BooleanType.getInstance())
-                        .deserialize("true"), elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">true</" + elName
-                + ">");
+                TypeDefinitionAwareCodec.from(BaseTypes.booleanType()).deserialize("false"), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">false</" + elName + ">");
+
+        normalizedNodeContext = prepareNNC(TypeDefinitionAwareCodec.from(BaseTypes.booleanType()).deserialize("true"),
+                elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">true</" + elName + ">");
     }
 
     @Test
     public void nnAsYangUnionToXmlTest() throws Exception {
-
-        final BitsTypeDefinition.Bit mockBit1 = Mockito
-                .mock(BitsTypeDefinition.Bit.class);
+        final BitsTypeDefinition.Bit mockBit1 = Mockito.mock(BitsTypeDefinition.Bit.class);
         Mockito.when(mockBit1.getName()).thenReturn("first");
-        final BitsTypeDefinition.Bit mockBit2 = Mockito
-                .mock(BitsTypeDefinition.Bit.class);
+        Mockito.when(mockBit1.getPosition()).thenReturn(1l);
+        final BitsTypeDefinition.Bit mockBit2 = Mockito.mock(BitsTypeDefinition.Bit.class);
         Mockito.when(mockBit2.getName()).thenReturn("second");
-        final List<BitsTypeDefinition.Bit> bitList = Lists.newArrayList(
-                mockBit1, mockBit2);
+        Mockito.when(mockBit2.getPosition()).thenReturn(2l);
+
+        final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Mockito.mock(SchemaPath.class));
+        bitsTypeBuilder.addBit(mockBit1);
+        bitsTypeBuilder.addBit(mockBit2);
 
-        final List<TypeDefinition<?>> types = Lists
-                .<TypeDefinition<?>> newArrayList(Int8.getInstance(), BitsType
-                        .create(Mockito.mock(SchemaPath.class), bitList),
-                        BooleanType.getInstance());
-        final UnionType unionType = UnionType.create(types);
+        final UnionTypeBuilder unionTypeBuilder = BaseTypes.unionTypeBuilder(Mockito.mock(SchemaPath.class));
+        unionTypeBuilder.addType(BaseTypes.int8Type());
+        unionTypeBuilder.addType(bitsTypeBuilder.build());
+        unionTypeBuilder.addType(BaseTypes.booleanType());
 
         final String elName = "lfUnion";
-        final String int8 = "15";
 
+        final String int8 = "15";
         NormalizedNodeContext normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(unionType).deserialize(int8),
-                elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">15</" + elName
-                + ">");
+                TypeDefinitionAwareCodec.from(unionTypeBuilder.build()).deserialize(int8), elName);
+        nnToXml(normalizedNodeContext, "<" + elName + ">15</" + elName + ">");
 
         final String bits = "first second";
-        normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(unionType).deserialize(bits),
+        normalizedNodeContext = prepareNNC(TypeDefinitionAwareCodec.from(unionTypeBuilder.build()).deserialize(bits),
                 elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">first second</"
-                + elName + ">");
+        nnToXml(normalizedNodeContext, "<" + elName + ">first second</" + elName + ">");
 
         final String bool = "true";
-        normalizedNodeContext = prepareNNC(
-                TypeDefinitionAwareCodec.from(unionType).deserialize(bool),
+        normalizedNodeContext = prepareNNC(TypeDefinitionAwareCodec.from(unionTypeBuilder.build()).deserialize(bool),
                 elName);
-        nnToXml(normalizedNodeContext, "<" + elName + ">true</" + elName
-                + ">");
+        nnToXml(normalizedNodeContext, "<" + elName + ">true</" + elName + ">");
     }
 
     private NormalizedNodeContext prepareNNC(final Object object, final String name) {
@@ -330,27 +288,21 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
                 .containerBuilder((ContainerSchemaNode) contSchema);
 
         final List<DataSchemaNode> instanceLf = ControllerContext
-                .findInstanceDataChildrenByName((DataNodeContainer) contSchema,
-                        lf.getLocalName());
+                .findInstanceDataChildrenByName((DataNodeContainer) contSchema, lf.getLocalName());
         final DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null);
 
-        contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
-                .withValue(object).build());
+        contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf).withValue(object).build());
 
         final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
-                new InstanceIdentifierContext<DataSchemaNode>(null, contSchema,
-                        null, schemaContext), contData.build());
+                new InstanceIdentifierContext<DataSchemaNode>(null, contSchema, null, schemaContext), contData.build());
 
         return testNormalizedNodeContext;
     }
 
-    private void nnToXml(
-            final NormalizedNodeContext normalizedNodeContext,
-            final String... xmlRepresentation)
- throws Exception {
+    private void nnToXml(final NormalizedNodeContext normalizedNodeContext, final String... xmlRepresentation)
+            throws Exception {
         final OutputStream output = new ByteArrayOutputStream();
-        xmlBodyWriter.writeTo(normalizedNodeContext, null, null, null,
-                    mediaType, null, output);
+        this.xmlBodyWriter.writeTo(normalizedNodeContext, null, null, null, this.mediaType, null, output);
 
         for (int i = 0; i < xmlRepresentation.length; i++) {
             assertTrue(output.toString().contains(xmlRepresentation[i]));
@@ -359,8 +311,7 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
 
     private NormalizedNodeContext prepareLeafrefData() {
         final QName cont = QName.create("basic:module", "2013-12-2", "cont");
-        final QName lfBoolean = QName
-                .create("basic:module", "2013-12-2", "lfBoolean");
+        final QName lfBoolean = QName.create("basic:module", "2013-12-2", "lfBoolean");
         final QName lfLfref = QName.create("basic:module", "2013-12-2", "lfLfref");
 
         final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
@@ -369,29 +320,42 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
                 .containerBuilder((ContainerSchemaNode) contSchema);
 
         List<DataSchemaNode> instanceLf = ControllerContext
-                .findInstanceDataChildrenByName((DataNodeContainer) contSchema,
-                        lfBoolean.getLocalName());
+                .findInstanceDataChildrenByName((DataNodeContainer) contSchema, lfBoolean.getLocalName());
         DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null);
 
-        contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
-                .withValue(Boolean.TRUE).build());
+        contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf).withValue(Boolean.TRUE).build());
 
-        instanceLf = ControllerContext.findInstanceDataChildrenByName(
-                (DataNodeContainer) contSchema, lfLfref.getLocalName());
+        instanceLf = ControllerContext.findInstanceDataChildrenByName((DataNodeContainer) contSchema,
+                lfLfref.getLocalName());
         schemaLf = Iterables.getFirst(instanceLf, null);
 
-        contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
-                .withValue("true").build());
+        contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf).withValue("true").build());
 
         final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
-                new InstanceIdentifierContext<DataSchemaNode>(null, contSchema,
-                        null, schemaContext), contData.build());
+                new InstanceIdentifierContext<DataSchemaNode>(null, contSchema, null, schemaContext), contData.build());
 
         return testNormalizedNodeContext;
     }
 
-    private NormalizedNodeContext prepareIdrefData(final String prefix,
-            final boolean valueAsQName) {
+    private NormalizedNodeContext prepareLeafrefNegativeData() {
+        final QName cont = QName.create("basic:module", "2013-12-2", "cont");
+        final QName lfLfref = QName.create("basic:module", "2013-12-2", "lfLfrefNegative");
+
+        final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
+        final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
+                .containerBuilder((ContainerSchemaNode) contSchema);
+
+        final List<DataSchemaNode> instanceLf = ControllerContext.findInstanceDataChildrenByName((DataNodeContainer)
+                contSchema, lfLfref.getLocalName());
+        final DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null);
+
+        contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf).withValue("value").build());
+
+        return new NormalizedNodeContext(
+                new InstanceIdentifierContext<>(null, contSchema, null, schemaContext), contData.build());
+    }
+
+    private NormalizedNodeContext prepareIdrefData(final String prefix, final boolean valueAsQName) {
         final QName cont = QName.create("basic:module", "2013-12-2", "cont");
         final QName cont1 = QName.create("basic:module", "2013-12-2", "cont1");
         final QName lf11 = QName.create("basic:module", "2013-12-2", "lf11");
@@ -401,8 +365,7 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
                 .containerBuilder((ContainerSchemaNode) contSchema);
 
-        final DataSchemaNode cont1Schema = ((ContainerSchemaNode) contSchema)
-                .getDataChildByName(cont1);
+        final DataSchemaNode cont1Schema = ((ContainerSchemaNode) contSchema).getDataChildByName(cont1);
 
         final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> cont1Data = Builders
                 .containerBuilder((ContainerSchemaNode) cont1Schema);
@@ -415,24 +378,20 @@ public class NnToXmlTest extends AbstractBodyReaderTest {
         }
 
         final List<DataSchemaNode> instanceLf = ControllerContext
-                .findInstanceDataChildrenByName(
-                        (DataNodeContainer) cont1Schema, lf11.getLocalName());
+                .findInstanceDataChildrenByName((DataNodeContainer) cont1Schema, lf11.getLocalName());
         final DataSchemaNode schemaLf = Iterables.getFirst(instanceLf, null);
 
-        cont1Data.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf)
-                .withValue(value).build());
+        cont1Data.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf).withValue(value).build());
 
         contData.withChild(cont1Data.build());
 
         final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
-                new InstanceIdentifierContext<DataSchemaNode>(null, contSchema,
-                        null, schemaContext), contData.build());
+                new InstanceIdentifierContext<DataSchemaNode>(null, contSchema, null, schemaContext), contData.build());
         return testNormalizedNodeContext;
     }
 
     @Override
     protected MediaType getMediaType() {
-        // TODO Auto-generated method stub
         return null;
     }
 }

diff --git a/restconf/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/RestCodecExceptionsTest.java b/restconf/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/RestCodecExceptionsTest.java
index 2dddacc90ecf2802eb6354b3b5f1f03c57794007..c448dfe51cdc972c870e25cef9da67d923746113 100644 (file)
--- a/restconf/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/RestCodecExceptionsTest.java
+++ b/restconf/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/RestCodecExceptionsTest.java
@@ -10,16 +10,13 @@ package org.opendaylight.controller.sal.restconf.impl.test;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.mockito.Mockito.mock;
-
-import java.util.Collections;
 import org.junit.Test;
 import org.opendaylight.netconf.sal.restconf.impl.RestCodec;
 import org.opendaylight.yangtools.concepts.Codec;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.BitsType;
+import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
 
 public class RestCodecExceptionsTest {
 
@@ -27,17 +24,17 @@ public class RestCodecExceptionsTest {
 
     @Test
     public void serializeExceptionTest() {
-        Codec<Object, Object> codec = RestCodec.from(BitsType.create(PATH, Collections.<Bit> emptyList()), null);
-        String serializedValue = (String) codec.serialize("incorrect value"); // set
+        final Codec<Object, Object> codec = RestCodec.from(BaseTypes.bitsTypeBuilder(PATH).build(), null);
+        final String serializedValue = (String) codec.serialize("incorrect value"); // set
                                                                               // expected
         assertEquals("incorrect value", serializedValue);
     }
 
     @Test
     public void deserializeExceptionTest() {
-        IdentityrefTypeDefinition mockedIidentityrefType = mock(IdentityrefTypeDefinition.class);
+        final IdentityrefTypeDefinition mockedIidentityrefType = mock(IdentityrefTypeDefinition.class);
 
-        Codec<Object, Object> codec = RestCodec.from(mockedIidentityrefType, null);
+        final Codec<Object, Object> codec = RestCodec.from(mockedIidentityrefType, null);
         assertNull(codec.deserialize("incorrect value"));
     }
 

diff --git a/restconf/sal-rest-connector/src/test/resources/nn-to-xml/yang/basic-module.yang b/restconf/sal-rest-connector/src/test/resources/nn-to-xml/yang/basic-module.yang
index 9c61d47b1fb6add79ea8ad0a9e82b0dc799b3aab..992c9af00ca9ff2d600c49566795625a01c45d57 100644 (file)
--- a/restconf/sal-rest-connector/src/test/resources/nn-to-xml/yang/basic-module.yang
+++ b/restconf/sal-rest-connector/src/test/resources/nn-to-xml/yang/basic-module.yang
@@ -97,10 +97,15 @@ module basic-module {
             }
         }
 
+        leaf lfLfrefNegative {
+            type leafref {
+                path "/cont/not-existing";
+            }
+        }
+
         leaf lfInIdentifier {
             type instance-identifier;
         }
 
     }
-
 }