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;
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
@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>");
}
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
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
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
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
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
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
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) {
.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]));
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);
.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");
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);
}
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;
}
}