<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>2.1.8</version>
+ <version>3.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-netconf-api" version="${project.version}">
<feature version="[5,6)">odl-netty-4</feature>
- <feature version="[2.1,3)">odl-yangtools-parser-api</feature>
+ <feature version="[3,4)">odl-yangtools-parser-api</feature>
</feature>
</features>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>odl-yangtools-codec</artifactId>
- <version>2.1.8</version>
+ <version>3.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<configfile finalname="etc/netconf.cfg">
mvn:org.opendaylight.netconf/netconf-util/${project.version}/cfg/config
</configfile>
- <feature version="[2.1,3)">odl-yangtools-codec</feature>
+ <feature version="[3,4)">odl-yangtools-codec</feature>
</feature>
</features>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>2.1.8</version>
+ <version>3.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-netconf-${project.version}">
<feature name="odl-restconf-common" version="${project.version}">
<feature version="[5,6)">odl-karaf-feat-jetty</feature>
- <feature version="[2.1,3)">odl-yangtools-export</feature>
+ <feature version="[3,4)">odl-yangtools-export</feature>
</feature>
</features>
import org.opendaylight.netconf.topology.singleton.messages.transactions.NewReadWriteTransactionRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.NewWriteTransactionRequest;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory;
+import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
import scala.concurrent.duration.Duration;
public class NetconfNodeActor extends AbstractUntypedActor {
-
private final Duration writeTxIdleTimeout;
private final DOMMountPointService mountPointService;
return new ProxyDOMRpcService(setup.getActorSystem(), masterReference, id, actorResponseWaitTime);
}
- private SchemaContextFactory createSchemaContextFactory(final ActorRef masterReference) {
+ private EffectiveModelContextFactory createSchemaContextFactory(final ActorRef masterReference) {
final RemoteYangTextSourceProvider remoteYangTextSourceProvider =
new ProxyYangTextSourceProvider(masterReference, getContext().dispatcher(), actorResponseWaitTime);
final RemoteSchemaProvider remoteProvider = new RemoteSchemaProvider(remoteYangTextSourceProvider,
YangTextSchemaSource.class, PotentialSchemaSource.Costs.REMOTE_IO.getValue())))
.collect(Collectors.toList());
- return schemaRepository.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);
+ return schemaRepository.createEffectiveModelContextFactory();
}
- private void resolveSchemaContext(final SchemaContextFactory schemaContextFactory,
+ private void resolveSchemaContext(final EffectiveModelContextFactory schemaContextFactory,
final SlaveSalFacade localSlaveSalManager, final ActorRef masterReference, final int tries) {
- final ListenableFuture<SchemaContext> schemaContextFuture =
- schemaContextFactory.createSchemaContext(sourceIdentifiers);
+ final ListenableFuture<EffectiveModelContext> schemaContextFuture =
+ schemaContextFactory.createEffectiveModelContext(sourceIdentifiers);
Futures.addCallback(schemaContextFuture, new FutureCallback<SchemaContext>() {
@Override
public void onSuccess(final SchemaContext result) {
registeredSchemas = null;
}
}
-
}
import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory;
+import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
import org.opendaylight.yangtools.yang.model.repo.util.FilesystemSchemaSourceCache;
InMemorySchemaSourceCache.createSoftCache(DEFAULT_SCHEMA_REPOSITORY, ASTSchemaSource.class);
// The default factory for creating <code>SchemaContext</code> instances.
- public static final SchemaContextFactory DEFAULT_SCHEMA_CONTEXT_FACTORY =
- DEFAULT_SCHEMA_REPOSITORY.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);
+ public static final EffectiveModelContextFactory DEFAULT_SCHEMA_CONTEXT_FACTORY =
+ DEFAULT_SCHEMA_REPOSITORY.createEffectiveModelContextFactory();
/**
* Keeps track of initialized Schema resources. A Map is maintained in which the key represents the name
*/
private static NetconfDevice.SchemaResourcesDTO createSchemaResourcesDTO(final String moduleSchemaCacheDirectory) {
final SharedSchemaRepository repository = new SharedSchemaRepository(moduleSchemaCacheDirectory);
- final SchemaContextFactory schemaContextFactory
- = repository.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);
+ final EffectiveModelContextFactory schemaContextFactory
+ = repository.createEffectiveModelContextFactory();
final FilesystemSchemaSourceCache<YangTextSchemaSource> deviceCache =
createDeviceFilesystemCache(moduleSchemaCacheDirectory, repository);
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyCollection;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.after;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaResolutionException;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
private SchemaSourceRegistry mockRegistry;
@Mock
- private SchemaContextFactory mockSchemaContextFactory;
+ private EffectiveModelContextFactory mockSchemaContextFactory;
@Mock
private SchemaRepository mockSchemaRepository;
@Mock
- private SchemaContext mockSchemaContext;
+ private EffectiveModelContext mockSchemaContext;
@Before
public void setup() {
doReturn(mockSchemaSourceReg2).when(mockRegistry).registerSchemaSource(any(), withSourceId(SOURCE_IDENTIFIER2));
doReturn(mockSchemaContextFactory).when(mockSchemaRepository)
- .createSchemaContextFactory(any(SchemaSourceFilter.class));
+ .createEffectiveModelContextFactory();
}
@After
doReturn(mockSchemaSourceReg1).when(mockRegistry).registerSchemaSource(any(), withSourceId(SOURCE_IDENTIFIER1));
doReturn(mockSchemaContextFactory).when(mockSchemaRepository)
- .createSchemaContextFactory(any(SchemaSourceFilter.class));
+ .createEffectiveModelContextFactory();
final SchemaSourceRegistration<?> newMockSchemaSourceReg = mock(SchemaSourceRegistration.class);
- final SchemaContextFactory newMockSchemaContextFactory = mock(SchemaContextFactory.class);
+ final EffectiveModelContextFactory newMockSchemaContextFactory = mock(EffectiveModelContextFactory.class);
doReturn(Futures.immediateFuture(mockSchemaContext))
- .when(newMockSchemaContextFactory).createSchemaContext(any());
+ .when(newMockSchemaContextFactory).createEffectiveModelContext(anyCollection());
doAnswer(unused -> {
SettableFuture<SchemaContext> future = SettableFuture.create();
withSourceId(SOURCE_IDENTIFIER1));
doReturn(newMockSchemaContextFactory).when(mockSchemaRepository)
- .createSchemaContextFactory(any(SchemaSourceFilter.class));
+ .createEffectiveModelContextFactory();
slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1), masterRef),
testKit.getRef());
future.set(mockSchemaContext);
}).start();
return future;
- }).when(mockSchemaContextFactory).createSchemaContext(any());
+ }).when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection());
doReturn(mockSchemaContextFactory).when(mockSchemaRepository)
- .createSchemaContextFactory(any(SchemaSourceFilter.class));
+ .createEffectiveModelContextFactory();
slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1), masterRef), testKit.getRef());
verify(mockMountPointBuilder).addService(eq(DOMNotificationService.class), any());
verify(mockSchemaSourceReg1).close();
verify(mockRegistry, times(2)).registerSchemaSource(any(), withSourceId(SOURCE_IDENTIFIER1));
- verify(mockSchemaRepository, times(2)).createSchemaContextFactory(any(SchemaSourceFilter.class));
+ verify(mockSchemaRepository, times(2)).createEffectiveModelContextFactory();
verifyNoMoreInteractions(mockMountPointBuilder, newMockSchemaSourceReg);
// Stop the slave actor and verify schema source registrations are closed.
// Test unrecoverable failure.
doReturn(Futures.immediateFailedFuture(new SchemaResolutionException("mock")))
- .when(mockSchemaContextFactory).createSchemaContext(any());
+ .when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection());
slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2),
masterRef), testKit.getRef());
doReturn(Futures.immediateFailedFuture(new SchemaResolutionException("mock",
new AskTimeoutException("timeout"))))
.doReturn(Futures.immediateFuture(mockSchemaContext))
- .when(mockSchemaContextFactory).createSchemaContext(any());
+ .when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection());
slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2),
masterRef), testKit.getRef());
reset(mockSchemaSourceReg1, mockSchemaSourceReg2, mockSchemaRepository, mockSchemaContextFactory);
resetMountPointMocks();
- final SchemaContextFactory mockSchemaContextFactorySuccess = mock(SchemaContextFactory.class);
+ final EffectiveModelContextFactory mockSchemaContextFactorySuccess = mock(EffectiveModelContextFactory.class);
doReturn(Futures.immediateFuture(mockSchemaContext))
- .when(mockSchemaContextFactorySuccess).createSchemaContext(any());
+ .when(mockSchemaContextFactorySuccess).createEffectiveModelContext(anyCollection());
doAnswer(unused -> {
SettableFuture<SchemaContext> future = SettableFuture.create();
new Thread(() -> {
doReturn(mockSchemaContextFactorySuccess).when(mockSchemaRepository)
- .createSchemaContextFactory(any(SchemaSourceFilter.class));
+ .createEffectiveModelContextFactory();
slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2),
masterRef), testKit.getRef());
future.setException(new SchemaResolutionException("mock", new AskTimeoutException("timeout")));
}).start();
return future;
- }).when(mockSchemaContextFactory).createSchemaContext(any());
+ }).when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection());
- doReturn(mockSchemaContextFactory).when(mockSchemaRepository)
- .createSchemaContextFactory(any(SchemaSourceFilter.class));
+ doReturn(mockSchemaContextFactory).when(mockSchemaRepository).createEffectiveModelContextFactory();
slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2),
masterRef), testKit.getRef());
verify(mockMountPointBuilder, timeout(5000)).register();
- verify(mockSchemaRepository, times(2)).createSchemaContextFactory(any(SchemaSourceFilter.class));
+ verify(mockSchemaRepository, times(2)).createEffectiveModelContextFactory();
}
@Test
mockSchemaRepository, TIMEOUT, mockMountPointService));
doReturn(Futures.immediateFuture(mockSchemaContext))
- .when(mockSchemaContextFactory).createSchemaContext(any());
+ .when(mockSchemaContextFactory).createEffectiveModelContext(anyCollection());
slaveRef.tell(new RegisterMountPoint(ImmutableList.of(SOURCE_IDENTIFIER1, SOURCE_IDENTIFIER2),
masterRef), testKit.getRef());
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.credentials.credentials.login.pw.unencrypted.LoginPasswordUnencrypted;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory;
+import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactoryConfiguration;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
/**
* The default factory for creating <code>SchemaContext</code> instances.
*/
- private static final SchemaContextFactory DEFAULT_SCHEMA_CONTEXT_FACTORY =
- DEFAULT_SCHEMA_REPOSITORY.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);
+ private static final EffectiveModelContextFactory DEFAULT_SCHEMA_CONTEXT_FACTORY =
+ DEFAULT_SCHEMA_REPOSITORY.createEffectiveModelContextFactory(
+ SchemaContextFactoryConfiguration.getDefault());
/**
* Keeps track of initialized Schema resources. A Map is maintained in which the key represents the name
*/
private NetconfDevice.SchemaResourcesDTO createSchemaResourcesDTO(final String moduleSchemaCacheDirectory) {
final SharedSchemaRepository repository = new SharedSchemaRepository(moduleSchemaCacheDirectory);
- final SchemaContextFactory contextFactory
- = repository.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);
+ final EffectiveModelContextFactory contextFactory
+ = repository.createEffectiveModelContextFactory(SchemaContextFactoryConfiguration.getDefault());
setSchemaRegistry(repository);
setSchemaContextFactory(contextFactory);
final FilesystemSchemaSourceCache<YangTextSchemaSource> deviceCache =
@Override
void streamToWriter(final NormalizedNodeStreamWriter writer, final PathArgument first,
final Iterator<PathArgument> others) throws IOException {
- writer.anyxmlNode(getIdentifier(), null);
+ writer.startAnyxmlNode(getIdentifier());
+ // FIXME: why are we not emitting a value?
+ writer.endNode();
}
}
@Override
void streamToWriter(final NormalizedNodeStreamWriter writer, final PathArgument first,
final Iterator<PathArgument> others) throws IOException {
- writer.leafNode(getIdentifier(), null);
+ writer.startLeafNode(getIdentifier());
+ // FIXME: why are we not emitting a value?
+ writer.endNode();
}
}
final Iterator<PathArgument> others) throws IOException {
checkArgument(first instanceof NodeWithValue);
final NodeWithValue<?> identifier = (NodeWithValue<?>) first;
- writer.leafSetEntryNode(identifier.getNodeType(), identifier.getValue());
+ writer.startLeafSetEntryNode(identifier);
+ writer.scalarValue(identifier.getValue());
+ writer.endNode();
}
}
writer.startMapEntryNode(identifier, UNKNOWN_SIZE);
for (Entry<QName, Object> entry : identifier.getKeyValues().entrySet()) {
- writer.leafNode(new NodeIdentifier(entry.getKey()), entry.getValue());
+ writer.startLeafNode(new NodeIdentifier(entry.getKey()));
+ writer.scalarValue(entry.getValue());
+ writer.endNode();
}
}
}
import java.util.concurrent.ExecutionException;
import java.util.regex.Pattern;
import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMSource;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactory;
+import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
LIBRARY_CONTEXT = moduleInfoBackedContext.tryToCreateSchemaContext().get();
}
+ private static final JSONCodecFactory JSON_CODECS = JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02
+ .getShared(LIBRARY_CONTEXT);
+
private final Map<QName, URL> availableModels;
private static final YangInstanceIdentifier MODULES_STATE_MODULE_LIST =
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
- final JsonParserStream jsonParser = JsonParserStream.create(writer, LIBRARY_CONTEXT);
+ final JsonParserStream jsonParser = JsonParserStream.create(writer, JSON_CODECS);
final JsonReader reader = new JsonReader(new InputStreamReader(in, Charset.defaultCharset()));
jsonParser.parse(reader);
xmlParser.traverse(new DOMSource(doc.getDocumentElement()));
final NormalizedNode<?, ?> parsed = resultHolder.getResult();
return Optional.of(parsed);
- } catch (XMLStreamException | URISyntaxException | IOException | ParserConfigurationException
- | SAXException e) {
+ } catch (XMLStreamException | URISyntaxException | IOException | SAXException e) {
LOG.warn("Unable to parse yang library xml content", e);
}
import java.util.Collections;
import java.util.Map;
import java.util.Set;
-import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLStreamException;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
notificationAsContainerSchemaNode, strictParsing);
xmlParser.traverse(new DOMSource(element));
content = (ContainerNode) resultHolder.getResult();
- } catch (XMLStreamException | URISyntaxException | IOException | ParserConfigurationException
- | SAXException | UnsupportedOperationException e) {
+ } catch (XMLStreamException | URISyntaxException | IOException | SAXException
+ | UnsupportedOperationException e) {
throw new IllegalArgumentException(String.format("Failed to parse notification %s", element), e);
}
return new NetconfDeviceNotification(content, stripped.getKey());
strictParsing);
xmlParser.traverse(new DOMSource(xmlData));
dataNode = (ContainerNode) resultHolder.getResult();
- } catch (XMLStreamException | URISyntaxException | IOException | ParserConfigurationException
- | SAXException e) {
+ } catch (XMLStreamException | URISyntaxException | IOException | SAXException e) {
throw new IllegalArgumentException(String.format("Failed to parse data response %s", xmlData), e);
}
operationDefinition.getOutput(), strictParsing);
xmlParser.traverse(new DOMSource(element));
return resultHolder.getResult();
- } catch (XMLStreamException | URISyntaxException | IOException | ParserConfigurationException
- | SAXException e) {
+ } catch (XMLStreamException | URISyntaxException | IOException | SAXException e) {
throw new IllegalArgumentException(String.format("Failed to parse RPC response %s", element), e);
}
}
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.SchemaOrderedNormalizedNodeWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
.withNodeIdentifier(NodeIdentifier.create(CREATE_SUBSCRIPTION_RPC_QNAME)).build();
private static final NodeIdentifier NETCONF_FILTER_NODEID = NodeIdentifier.create(NETCONF_FILTER_QNAME);
- private static final Map<QName, String> SUBTREE_FILTER_ATTRIBUTES = ImmutableMap.of(NETCONF_TYPE_QNAME, SUBTREE);
public static final DataContainerChild<?, ?> EMPTY_FILTER;
static {
- final NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> anyXmlBuilder =
- Builders.anyXmlBuilder().withNodeIdentifier(NETCONF_FILTER_NODEID)
- .withAttributes(SUBTREE_FILTER_ATTRIBUTES);
-
final Element element = XmlUtil.createElement(BLANK_DOCUMENT, NETCONF_FILTER_QNAME.getLocalName(),
Optional.of(NETCONF_FILTER_QNAME.getNamespace().toString()));
element.setAttributeNS(NETCONF_FILTER_QNAME.getNamespace().toString(),
- NETCONF_TYPE_QNAME.getLocalName(), "subtree");
-
- anyXmlBuilder.withValue(new DOMSource(element));
+ NETCONF_TYPE_QNAME.getLocalName(), SUBTREE);
- EMPTY_FILTER = anyXmlBuilder.build();
+ EMPTY_FILTER = Builders.anyXmlBuilder().withNodeIdentifier(NETCONF_FILTER_NODEID)
+ .withValue(new DOMSource(element)).build();
}
public static DataContainerChild<?, ?> toFilterStructure(final YangInstanceIdentifier identifier,
final SchemaContext ctx) {
- final NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> anyXmlBuilder = Builders.anyXmlBuilder()
- .withNodeIdentifier(NETCONF_FILTER_NODEID).withAttributes(SUBTREE_FILTER_ATTRIBUTES);
final Element element = XmlUtil.createElement(BLANK_DOCUMENT, NETCONF_FILTER_QNAME.getLocalName(),
Optional.of(NETCONF_FILTER_QNAME.getNamespace().toString()));
element.setAttributeNS(NETCONF_FILTER_QNAME.getNamespace().toString(), NETCONF_TYPE_QNAME.getLocalName(),
- "subtree");
+ SUBTREE);
try {
NetconfUtil.writeFilter(identifier, new DOMResult(element), SchemaPath.ROOT, ctx);
} catch (IOException | XMLStreamException e) {
throw new IllegalStateException("Unable to serialize filter element for path " + identifier, e);
}
- anyXmlBuilder.withValue(new DOMSource(element));
- return anyXmlBuilder.build();
+ return Builders.anyXmlBuilder().withNodeIdentifier(NETCONF_FILTER_NODEID).withValue(new DOMSource(element))
+ .build();
}
public static void checkValidReply(final NetconfMessage input, final NetconfMessage output)
if this attribute is present.";
}
+ feature candidate;
+ feature startup;
+ feature writable-running;
+ feature url;
+
rpc edit-config {
description "The <edit-config> operation loads all or part of a specified
configuration to the specified target configuration.";
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
-import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
try {
//necessary for creating mdsal data stores and operations
- this.schemaContext = consumer.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT)
- .createSchemaContext(loadedSources).get();
+ this.schemaContext = consumer.createEffectiveModelContextFactory()
+ .createEffectiveModelContext(loadedSources).get();
} catch (final InterruptedException | ExecutionException e) {
throw new RuntimeException("Cannot parse schema context", e);
}
import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
-import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamAttributeWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
if (node instanceof LeafSetEntryNode) {
if (currentDepth < maxDepth) {
final LeafSetEntryNode<?> nodeAsLeafList = (LeafSetEntryNode<?>) node;
- if (writer instanceof NormalizedNodeStreamAttributeWriter) {
- ((NormalizedNodeStreamAttributeWriter) writer).leafSetEntryNode(nodeAsLeafList.getNodeType(),
- nodeAsLeafList.getValue(), nodeAsLeafList.getAttributes());
- } else {
- writer.leafSetEntryNode(nodeAsLeafList.getNodeType(), nodeAsLeafList.getValue());
- }
+ writer.startLeafSetEntryNode(nodeAsLeafList.getIdentifier());
+ writer.scalarValue(nodeAsLeafList.getValue());
+ writer.endNode();
}
return true;
} else if (node instanceof LeafNode) {
final LeafNode<?> nodeAsLeaf = (LeafNode<?>)node;
- if (writer instanceof NormalizedNodeStreamAttributeWriter) {
- ((NormalizedNodeStreamAttributeWriter) writer)
- .leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue(), nodeAsLeaf.getAttributes());
- } else {
- writer.leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue());
- }
+ writer.startLeafNode(nodeAsLeaf.getIdentifier());
+ writer.scalarValue(nodeAsLeaf.getValue());
+ writer.endNode();
return true;
} else if (node instanceof AnyXmlNode) {
final AnyXmlNode anyXmlNode = (AnyXmlNode)node;
- writer.anyxmlNode(anyXmlNode.getIdentifier(), anyXmlNode.getValue());
+ writer.startAnyxmlNode(anyXmlNode.getIdentifier());
+ writer.domSourceValue(anyXmlNode.getValue());
+ writer.endNode();
return true;
}
private void writeOnlyKeys(final Map<QName, Object> keyValues) throws IllegalArgumentException, IOException {
for (final Map.Entry<QName, Object> entry : keyValues.entrySet()) {
- writer.leafNode(new NodeIdentifier(entry.getKey()), entry.getValue());
+ writer.startLeafNode(new NodeIdentifier(entry.getKey()));
+ writer.scalarValue(entry.getValue());
+ writer.endNode();
}
writer.endNode();
}
protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
- if (writer instanceof NormalizedNodeStreamAttributeWriter) {
- ((NormalizedNodeStreamAttributeWriter) writer)
- .startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes());
- } else {
- writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
- }
+ writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
currentDepth++;
writeMapEntryChildren(node);
currentDepth--;
boolean processedAsCompositeNode = false;
if (node instanceof ContainerNode) {
final ContainerNode n = (ContainerNode) node;
- if (writer instanceof NormalizedNodeStreamAttributeWriter) {
- ((NormalizedNodeStreamAttributeWriter) writer)
- .startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()), n.getAttributes());
- } else {
- writer.startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()));
- }
+ writer.startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()));
currentDepth++;
processedAsCompositeNode = writeChildren(n.getValue());
currentDepth--;
@Override
protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
final NormalizedNodeStreamWriter writer = getWriter();
- if (writer instanceof NormalizedNodeStreamAttributeWriter) {
- ((NormalizedNodeStreamAttributeWriter) writer)
- .startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes());
- } else {
- writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
- }
+ writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
final Set<QName> qnames = node.getIdentifier().getKeyValues().keySet();
// Write out all the key children
// the schema has a ContainerSchemaNode so, to avoid an error, we override the leafNode behavior
// for error-info.
final NormalizedNodeStreamWriter streamWriter = new ForwardingNormalizedNodeStreamWriter() {
+ private boolean inOurLeaf;
+
@Override
protected NormalizedNodeStreamWriter delegate() {
return jsonStreamWriter;
}
@Override
- public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
+ public void startLeafNode(final NodeIdentifier name) throws IOException {
if (name.getNodeType().equals(Draft02.RestConfModule.ERROR_INFO_QNAME)) {
+ inOurLeaf = true;
jsonWriter.name(Draft02.RestConfModule.ERROR_INFO_QNAME.getLocalName());
+ } else {
+ super.startLeafNode(name);
+ }
+ }
+
+ @Override
+ public void scalarValue(final Object value) throws IOException {
+ if (inOurLeaf) {
jsonWriter.value(value.toString());
} else {
- super.leafNode(name, value);
+ super.scalarValue(value);
+ }
+ }
+
+ @Override
+ public void endNode() throws IOException {
+ if (inOurLeaf) {
+ inOurLeaf = false;
+ } else {
+ super.endNode();
}
}
};
// the schema has a ContainerSchemaNode so, to avoid an error, we override the leafNode behavior
// for error-info.
final NormalizedNodeStreamWriter streamWriter = new ForwardingNormalizedNodeStreamWriter() {
+ private boolean inOurLeaf;
+
@Override
protected NormalizedNodeStreamWriter delegate() {
return xmlStreamWriter;
}
@Override
- public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
+ public void startLeafNode(final NodeIdentifier name) throws IOException {
if (name.getNodeType().equals(Draft02.RestConfModule.ERROR_INFO_QNAME)) {
String ns = Draft02.RestConfModule.ERROR_INFO_QNAME.getNamespace().toString();
try {
xmlWriter.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX,
Draft02.RestConfModule.ERROR_INFO_QNAME.getLocalName(), ns);
+ } catch (XMLStreamException e) {
+ throw new IOException("Error writing error-info", e);
+ }
+ inOurLeaf = true;
+ } else {
+ super.startLeafNode(name);
+ }
+ }
+
+ @Override
+ public void scalarValue(final Object value) throws IOException {
+ if (inOurLeaf) {
+ try {
xmlWriter.writeCharacters(value.toString());
+ } catch (XMLStreamException e) {
+ throw new IOException("Error writing error-info", e);
+ }
+ } else {
+ super.scalarValue(value);
+ }
+ }
+
+ @Override
+ public void endNode() throws IOException {
+ if (inOurLeaf) {
+ try {
xmlWriter.writeEndElement();
} catch (XMLStreamException e) {
throw new IOException("Error writing error-info", e);
}
+ inOurLeaf = false;
} else {
- super.leafNode(name, value);
+ super.endNode();
}
}
};
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
private static final Logger LOG = LoggerFactory.getLogger(XmlNormalizedNodeBodyReader.class);
- public XmlNormalizedNodeBodyReader(ControllerContext controllerContext) {
+ public XmlNormalizedNodeBodyReader(final ControllerContext controllerContext) {
super(controllerContext);
}
final Object child = foundSchemaNodes.pop();
if (child instanceof AugmentationSchemaNode) {
final AugmentationSchemaNode augmentSchemaNode = (AugmentationSchemaNode) child;
- iiToDataList.add(SchemaUtils.getNodeIdentifierForAugmentation(augmentSchemaNode));
+ iiToDataList.add(DataSchemaContextNode.augmentationIdentifierFrom(augmentSchemaNode));
} else if (child instanceof DataSchemaNode) {
schemaNode = (DataSchemaNode) child;
iiToDataList.add(new YangInstanceIdentifier.NodeIdentifier(schemaNode.getQName()));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.sal.rest.impl;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.Collections;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
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.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class DepthAwareNormalizedNodeWriterTest {
@Mock
@Before
public void setUp() {
- MockitoAnnotations.initMocks(this);
-
// identifiers
containerNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "container"));
- Mockito.when(containerNodeData.getIdentifier()).thenReturn(containerNodeIdentifier);
+ when(containerNodeData.getIdentifier()).thenReturn(containerNodeIdentifier);
mapNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "list"));
- Mockito.when(mapNodeData.getIdentifier()).thenReturn(mapNodeIdentifier);
+ when(mapNodeData.getIdentifier()).thenReturn(mapNodeIdentifier);
final QName leafSetEntryNodeQName = QName.create("namespace", "leaf-set-entry");
leafSetEntryNodeValue = "leaf-set-value";
leafSetEntryNodeIdentifier = new NodeWithValue<>(leafSetEntryNodeQName, leafSetEntryNodeValue);
- Mockito.when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier);
- Mockito.when(leafSetEntryNodeData.getNodeType()).thenReturn(leafSetEntryNodeQName);
+ when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier);
leafSetNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "leaf-set"));
- Mockito.when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier);
+ when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier);
final QName mapEntryNodeKey = QName.create("namespace", "key-field");
keyLeafNodeIdentifier = NodeIdentifier.create(mapEntryNodeKey);
mapEntryNodeIdentifier = new YangInstanceIdentifier.NodeIdentifierWithPredicates(
QName.create("namespace", "list-entry"), Collections.singletonMap(mapEntryNodeKey, keyLeafNodeValue));
- Mockito.when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier);
- Mockito.when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData));
+ when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier);
+ when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData));
- Mockito.when(keyLeafNodeData.getValue()).thenReturn(keyLeafNodeValue);
- Mockito.when(keyLeafNodeData.getIdentifier()).thenReturn(keyLeafNodeIdentifier);
+ when(keyLeafNodeData.getValue()).thenReturn(keyLeafNodeValue);
+ when(keyLeafNodeData.getIdentifier()).thenReturn(keyLeafNodeIdentifier);
anotherLeafNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "another-field"));
anotherLeafNodeValue = "another-value";
- Mockito.when(anotherLeafNodeData.getValue()).thenReturn(anotherLeafNodeValue);
- Mockito.when(anotherLeafNodeData.getIdentifier()).thenReturn(anotherLeafNodeIdentifier);
+ when(anotherLeafNodeData.getValue()).thenReturn(anotherLeafNodeValue);
+ when(anotherLeafNodeData.getIdentifier()).thenReturn(anotherLeafNodeIdentifier);
// values
- Mockito.when(leafSetEntryNodeData.getValue()).thenReturn(leafSetEntryNodeValue);
+ when(leafSetEntryNodeData.getValue()).thenReturn(leafSetEntryNodeValue);
leafSetNodeValue = Collections.singletonList(leafSetEntryNodeData);
- Mockito.when(leafSetNodeData.getValue()).thenReturn(leafSetNodeValue);
+ when(leafSetNodeData.getValue()).thenReturn(leafSetNodeValue);
containerNodeValue = Collections.singleton(leafSetNodeData);
- Mockito.when(containerNodeData.getValue()).thenReturn(containerNodeValue);
+ when(containerNodeData.getValue()).thenReturn(containerNodeValue);
mapEntryNodeValue = Sets.newHashSet(keyLeafNodeData, anotherLeafNodeData);
- Mockito.when(mapEntryNodeData.getValue()).thenReturn(mapEntryNodeValue);
+ when(mapEntryNodeData.getValue()).thenReturn(mapEntryNodeValue);
mapNodeValue = Collections.singleton(mapEntryNodeData);
- Mockito.when(mapNodeData.getValue()).thenReturn(mapNodeValue);
+ when(mapNodeData.getValue()).thenReturn(mapNodeValue);
}
/**
depthWriter.write(containerNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
+ inOrder.verify(writer, times(1)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
depthWriter.write(containerNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
- leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
- inOrder.verify(writer, Mockito.times(2)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
+ inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
+ inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
+ inOrder.verify(writer, times(3)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
depthWriter.write(mapNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
- inOrder.verify(writer, Mockito.times(2)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
+ inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, times(3)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
depthWriter.write(mapNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
- inOrder.verify(writer, Mockito.times(2)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
+ inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, times(1)).endNode();
+ inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, times(1)).endNode();
+
// FIXME this assertion is not working because leaves are not written in expected order
- inOrder.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue);
- inOrder.verify(writer, Mockito.times(2)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(anotherLeafNodeValue);
+ inOrder.verify(writer, times(3)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
depthWriter.write(leafSetNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
+ inOrder.verify(writer, times(1)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
depthWriter.write(leafSetNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
- leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
+ inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
+ inOrder.verify(writer, times(2)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
depthWriter.write(leafSetEntryNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
- leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
+ inOrder.verify(writer, times(1)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
depthWriter.write(mapEntryNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
// write only the key
- inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, times(2)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
depthWriter.write(mapEntryNodeData);
// unordered
- Mockito.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
- Mockito.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
- Mockito.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue);
- Mockito.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
+ verify(writer, times(1)).scalarValue(keyLeafNodeValue);
+ verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
+ verify(writer, times(1)).scalarValue(anotherLeafNodeValue);
+ verify(writer, times(3)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
depthWriter.write(mapEntryNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, times(2)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
depthWriter.write(mapEntryNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
- inOrder.verify(writer, Mockito.times(2)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ inOrder.verify(writer, times(2)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, times(2)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, times(1)).endNode();
// FIXME this assertion is not working because leaves are not written in expected order
- inOrder.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue);
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
+ inOrder.verify(writer, times(2)).scalarValue(anotherLeafNodeValue);
+ inOrder.verify(writer, times(2)).endNode();
+ verifyNoMoreInteractions(writer);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
-import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamAttributeWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
if (node instanceof LeafSetEntryNode) {
if (selectedByParameters(node, false)) {
final LeafSetEntryNode<?> nodeAsLeafList = (LeafSetEntryNode<?>) node;
- if (writer instanceof NormalizedNodeStreamAttributeWriter) {
- ((NormalizedNodeStreamAttributeWriter) writer).leafSetEntryNode(nodeAsLeafList.getNodeType(),
- nodeAsLeafList.getValue(), nodeAsLeafList.getAttributes());
- } else {
- writer.leafSetEntryNode(nodeAsLeafList.getNodeType(), nodeAsLeafList.getValue());
- }
+ writer.startLeafSetEntryNode(nodeAsLeafList.getIdentifier());
+ writer.scalarValue(nodeAsLeafList.getValue());
+ writer.endNode();
}
return true;
} else if (node instanceof LeafNode) {
final LeafNode<?> nodeAsLeaf = (LeafNode<?>)node;
- if (writer instanceof NormalizedNodeStreamAttributeWriter) {
- ((NormalizedNodeStreamAttributeWriter) writer).leafNode(
- nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue(), nodeAsLeaf.getAttributes());
- } else {
- writer.leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue());
- }
+ writer.startLeafNode(nodeAsLeaf.getIdentifier());
+ writer.scalarValue(nodeAsLeaf.getValue());
+ writer.endNode();
return true;
} else if (node instanceof AnyXmlNode) {
final AnyXmlNode anyXmlNode = (AnyXmlNode)node;
- writer.anyxmlNode(anyXmlNode.getIdentifier(), anyXmlNode.getValue());
+ writer.startAnyxmlNode(anyXmlNode.getIdentifier());
+ writer.domSourceValue(anyXmlNode.getValue());
+ writer.endNode();
return true;
}
private void writeOnlyKeys(final Map<QName, Object> keyValues) throws IllegalArgumentException, IOException {
for (final Map.Entry<QName, Object> entry : keyValues.entrySet()) {
- writer.leafNode(new NodeIdentifier(entry.getKey()), entry.getValue());
+ writer.startLeafNode(new NodeIdentifier(entry.getKey()));
+ writer.scalarValue(entry.getValue());
+ writer.endNode();
}
writer.endNode();
}
protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
- if (writer instanceof NormalizedNodeStreamAttributeWriter) {
- ((NormalizedNodeStreamAttributeWriter) writer)
- .startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes());
- } else {
- writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
- }
+ writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
currentDepth++;
writeMapEntryChildren(node);
currentDepth--;
if (node instanceof ContainerNode) {
final ContainerNode n = (ContainerNode) node;
if (!n.getNodeType().withoutRevision().equals(ROOT_DATA_QNAME)) {
- if (writer instanceof NormalizedNodeStreamAttributeWriter) {
- ((NormalizedNodeStreamAttributeWriter) writer).startContainerNode(
- n.getIdentifier(), childSizeHint(n.getValue()), n.getAttributes());
- } else {
- writer.startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()));
- }
+ writer.startContainerNode(n.getIdentifier(), childSizeHint(n.getValue()));
currentDepth++;
processedAsCompositeNode = writeChildren(n.getValue(), false);
currentDepth--;
@Override
protected boolean writeMapEntryNode(final MapEntryNode node) throws IOException {
final NormalizedNodeStreamWriter writer = getWriter();
- if (writer instanceof NormalizedNodeStreamAttributeWriter) {
- ((NormalizedNodeStreamAttributeWriter) writer).startMapEntryNode(
- node.getIdentifier(), childSizeHint(node.getValue()), node.getAttributes());
- } else {
- writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
- }
+ writer.startMapEntryNode(node.getIdentifier(), childSizeHint(node.getValue()));
final Set<QName> qnames = node.getIdentifier().getKeyValues().keySet();
// Write out all the key children
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils;
+import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
public class XmlNormalizedNodeBodyReader extends AbstractNormalizedNodeBodyReader {
private static final Logger LOG = LoggerFactory.getLogger(XmlNormalizedNodeBodyReader.class);
- public XmlNormalizedNodeBodyReader(SchemaContextHandler schemaContextHandler,
- DOMMountPointServiceHandler mountPointServiceHandler) {
+ public XmlNormalizedNodeBodyReader(final SchemaContextHandler schemaContextHandler,
+ final DOMMountPointServiceHandler mountPointServiceHandler) {
super(schemaContextHandler, mountPointServiceHandler);
}
final Object child = foundSchemaNodes.pop();
if (child instanceof AugmentationSchemaNode) {
final AugmentationSchemaNode augmentSchemaNode = (AugmentationSchemaNode) child;
- iiToDataList.add(SchemaUtils.getNodeIdentifierForAugmentation(augmentSchemaNode));
+ iiToDataList.add(DataSchemaContextNode.augmentationIdentifierFrom(augmentSchemaNode));
} else if (child instanceof DataSchemaNode) {
schemaNode = (DataSchemaNode) child;
iiToDataList.add(new YangInstanceIdentifier.NodeIdentifier(schemaNode.getQName()));
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
/**
throw new UnsupportedOperationException("Operation not implemented.");
}
- @Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- throw new UnsupportedOperationException("Operation not implemented.");
- }
-
@Override
public Optional<SemVer> getSemanticVersion() {
throw new UnsupportedOperationException("Operation not implemented.");
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.restconf.nb.rfc8040.jersey.providers;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.Collections;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
/**
* Unit test for {@link ParameterAwareNormalizedNodeWriter} used with depth parameter.
*/
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class ParameterAwareNormalizedNodeWriterDepthTest {
@Mock
@Before
public void setUp() {
- MockitoAnnotations.initMocks(this);
-
// identifiers
containerNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "container"));
- Mockito.when(containerNodeData.getIdentifier()).thenReturn(containerNodeIdentifier);
- Mockito.when(containerNodeData.getNodeType()).thenReturn(containerNodeIdentifier.getNodeType());
+ when(containerNodeData.getIdentifier()).thenReturn(containerNodeIdentifier);
+ when(containerNodeData.getNodeType()).thenReturn(containerNodeIdentifier.getNodeType());
mapNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "list"));
- Mockito.when(mapNodeData.getIdentifier()).thenReturn(mapNodeIdentifier);
+ when(mapNodeData.getIdentifier()).thenReturn(mapNodeIdentifier);
final QName leafSetEntryNodeQName = QName.create("namespace", "leaf-set-entry");
leafSetEntryNodeValue = "leaf-set-value";
leafSetEntryNodeIdentifier = new NodeWithValue<>(leafSetEntryNodeQName, leafSetEntryNodeValue);
- Mockito.when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier);
- Mockito.when(leafSetEntryNodeData.getNodeType()).thenReturn(leafSetEntryNodeQName);
+ when(leafSetEntryNodeData.getIdentifier()).thenReturn(leafSetEntryNodeIdentifier);
leafSetNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "leaf-set"));
- Mockito.when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier);
+ when(leafSetNodeData.getIdentifier()).thenReturn(leafSetNodeIdentifier);
final QName mapEntryNodeKey = QName.create("namespace", "key-field");
keyLeafNodeIdentifier = NodeIdentifier.create(mapEntryNodeKey);
mapEntryNodeIdentifier = new YangInstanceIdentifier.NodeIdentifierWithPredicates(
QName.create("namespace", "list-entry"), Collections.singletonMap(mapEntryNodeKey, keyLeafNodeValue));
- Mockito.when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier);
- Mockito.when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData));
+ when(mapEntryNodeData.getIdentifier()).thenReturn(mapEntryNodeIdentifier);
+ when(mapEntryNodeData.getChild(keyLeafNodeIdentifier)).thenReturn(Optional.of(keyLeafNodeData));
- Mockito.when(keyLeafNodeData.getValue()).thenReturn(keyLeafNodeValue);
- Mockito.when(keyLeafNodeData.getIdentifier()).thenReturn(keyLeafNodeIdentifier);
+ when(keyLeafNodeData.getValue()).thenReturn(keyLeafNodeValue);
+ when(keyLeafNodeData.getIdentifier()).thenReturn(keyLeafNodeIdentifier);
anotherLeafNodeIdentifier = NodeIdentifier.create(QName.create("namespace", "another-field"));
anotherLeafNodeValue = "another-value";
- Mockito.when(anotherLeafNodeData.getValue()).thenReturn(anotherLeafNodeValue);
- Mockito.when(anotherLeafNodeData.getIdentifier()).thenReturn(anotherLeafNodeIdentifier);
+ when(anotherLeafNodeData.getValue()).thenReturn(anotherLeafNodeValue);
+ when(anotherLeafNodeData.getIdentifier()).thenReturn(anotherLeafNodeIdentifier);
// values
- Mockito.when(leafSetEntryNodeData.getValue()).thenReturn(leafSetEntryNodeValue);
+ when(leafSetEntryNodeData.getValue()).thenReturn(leafSetEntryNodeValue);
leafSetNodeValue = Collections.singletonList(leafSetEntryNodeData);
- Mockito.when(leafSetNodeData.getValue()).thenReturn(leafSetNodeValue);
+ when(leafSetNodeData.getValue()).thenReturn(leafSetNodeValue);
containerNodeValue = Collections.singleton(leafSetNodeData);
- Mockito.when(containerNodeData.getValue()).thenReturn(containerNodeValue);
+ when(containerNodeData.getValue()).thenReturn(containerNodeValue);
mapEntryNodeValue = Sets.newHashSet(keyLeafNodeData, anotherLeafNodeData);
- Mockito.when(mapEntryNodeData.getValue()).thenReturn(mapEntryNodeValue);
+ when(mapEntryNodeData.getValue()).thenReturn(mapEntryNodeValue);
mapNodeValue = Collections.singleton(mapEntryNodeData);
- Mockito.when(mapNodeData.getValue()).thenReturn(mapNodeValue);
+ when(mapNodeData.getValue()).thenReturn(mapNodeValue);
}
/**
parameterWriter.write(containerNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
+ inOrder.verify(writer, times(1)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
parameterWriter.write(containerNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
- leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
- inOrder.verify(writer, Mockito.times(2)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
+ inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
+ inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
+ inOrder.verify(writer, times(3)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
parameterWriter.write(mapNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
- inOrder.verify(writer, Mockito.times(2)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
+ inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ inOrder.verify(writer, times(2)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
parameterWriter.write(mapNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
- inOrder.verify(writer, Mockito.times(2)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
+ inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ inOrder.verify(writer, times(2)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, times(1)).endNode();
+ inOrder.verify(writer, times(2)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, times(2)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, times(2)).endNode();
// FIXME this assertion is not working because leaves are not written in expected order
- inOrder.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue);
- inOrder.verify(writer, Mockito.times(2)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(anotherLeafNodeValue);
+ inOrder.verify(writer, times(3)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
parameterWriter.write(leafSetNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
+ inOrder.verify(writer, times(1)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
parameterWriter.write(leafSetNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
- leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
+ inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
+ inOrder.verify(writer, times(2)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
parameterWriter.write(leafSetEntryNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
- leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(leafSetEntryNodeValue);
+ inOrder.verify(writer, times(1)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
parameterWriter.write(mapEntryNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
// write only the key
- inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, times(2)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
parameterWriter.write(mapEntryNodeData);
// unordered
- Mockito.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
- Mockito.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
- Mockito.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue);
- Mockito.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
+ verify(writer, times(1)).scalarValue(keyLeafNodeValue);
+ verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
+ verify(writer, times(1)).scalarValue(anotherLeafNodeValue);
+ verify(writer, times(3)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
parameterWriter.write(mapEntryNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ inOrder.verify(writer, times(1)).endNode();
+ verifyNoMoreInteractions(writer);
}
/**
parameterWriter.write(mapEntryNodeData);
- final InOrder inOrder = Mockito.inOrder(writer);
- inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
- inOrder.verify(writer, Mockito.times(2)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
+ final InOrder inOrder = inOrder(writer);
+ inOrder.verify(writer, times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
+ inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, times(1)).endNode();
+ inOrder.verify(writer, times(1)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, times(1)).endNode();
// FIXME this assertion is not working because leaves are not written in expected order
- inOrder.verify(writer, Mockito.times(1)).leafNode(anotherLeafNodeIdentifier, anotherLeafNodeValue);
- inOrder.verify(writer, Mockito.times(1)).endNode();
- Mockito.verifyNoMoreInteractions(writer);
+ inOrder.verify(writer, times(1)).startLeafNode(anotherLeafNodeIdentifier);
+ inOrder.verify(writer, times(1)).scalarValue(anotherLeafNodeValue);
+ inOrder.verify(writer, times(2)).endNode();
+ verifyNoMoreInteractions(writer);
}
}
\ No newline at end of file
final InOrder inOrder = Mockito.inOrder(writer);
inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
- leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
- inOrder.verify(writer, Mockito.times(2)).endNode();
+ inOrder.verify(writer, Mockito.times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
+ inOrder.verify(writer, Mockito.times(1)).scalarValue(leafSetEntryNodeValue);
+ inOrder.verify(writer, Mockito.times(3)).endNode();
Mockito.verifyNoMoreInteractions(writer);
}
final InOrder inOrder = Mockito.inOrder(writer);
inOrder.verify(writer, Mockito.times(1)).startMapNode(mapNodeIdentifier, mapNodeValue.size());
inOrder.verify(writer, Mockito.times(1)).startMapEntryNode(mapEntryNodeIdentifier, mapEntryNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).leafNode(keyLeafNodeIdentifier, keyLeafNodeValue);
- inOrder.verify(writer, Mockito.times(2)).endNode();
+ inOrder.verify(writer, Mockito.times(1)).startLeafNode(keyLeafNodeIdentifier);
+ inOrder.verify(writer, Mockito.times(1)).scalarValue(keyLeafNodeValue);
+ inOrder.verify(writer, Mockito.times(3)).endNode();
Mockito.verifyNoMoreInteractions(writer);
}
}
\ No newline at end of file
final InOrder inOrder = Mockito.inOrder(writer);
inOrder.verify(writer, Mockito.times(1)).startContainerNode(containerNodeIdentifier, containerNodeValue.size());
inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
- leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
- inOrder.verify(writer, Mockito.times(2)).endNode();
+ inOrder.verify(writer, Mockito.times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
+ inOrder.verify(writer, Mockito.times(1)).scalarValue(leafSetEntryNodeValue);
+ inOrder.verify(writer, Mockito.times(3)).endNode();
Mockito.verifyNoMoreInteractions(writer);
}
final InOrder inOrder = Mockito.inOrder(writer);
inOrder.verify(writer, Mockito.times(1)).startLeafSet(leafSetNodeIdentifier, leafSetNodeValue.size());
- inOrder.verify(writer, Mockito.times(1)).leafSetEntryNode(
- leafSetEntryNodeIdentifier.getNodeType(), leafSetEntryNodeValue);
- inOrder.verify(writer, Mockito.times(1)).endNode();
+ inOrder.verify(writer, Mockito.times(1)).startLeafSetEntryNode(leafSetEntryNodeIdentifier);
+ inOrder.verify(writer, Mockito.times(1)).scalarValue(leafSetEntryNodeValue);
+ inOrder.verify(writer, Mockito.times(2)).endNode();
Mockito.verifyNoMoreInteractions(writer);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.MandatoryAware;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
+import org.opendaylight.yangtools.yang.model.api.PathExpression;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
+import org.opendaylight.yangtools.yang.model.util.PathExpressionImpl;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private String processLeafRef(final DataSchemaNode node, final ObjectNode property,
final SchemaContext schemaContext, final TypeDefinition<?> leafTypeDef) {
- RevisionAwareXPath xpath = ((LeafrefTypeDefinition) leafTypeDef).getPathStatement();
+ PathExpression xpath = ((LeafrefTypeDefinition) leafTypeDef).getPathStatement();
final SchemaNode schemaNode;
- final String xPathString = STRIP_PATTERN.matcher(xpath.toString()).replaceAll("");
- xpath = new RevisionAwareXPathImpl(xPathString, xpath.isAbsolute());
+ final String xPathString = STRIP_PATTERN.matcher(xpath.getOriginalString()).replaceAll("");
+ xpath = new PathExpressionImpl(xPathString, xpath.isAbsolute());
final Module module;
if (xpath.isAbsolute()) {
Code Review / netconf.git / commitdiff