yang-test-util provides a convenient way to parse YANG files
into a SchemaContext, without relying on the internal layout
of the yang parser. Convert tests to use these utilities,
which simplifies test setup and allows the yang parser layout
to evolve without breaking the world.
Change-Id: Icbd0556b990ea9d5ff93c34330049a9683e04970
Signed-off-by: Robert Varga <rovarga@cisco.com>
29 files changed:
<scope>test</scope>
</dependency>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-test-util</artifactId>
+ </dependency>
+
</dependencies>
</project>
</dependencies>
</project>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-impl</artifactId>
- <scope>test</scope>
+ <artifactId>yang-test-util</artifactId>
</dependency>
</dependencies>
</dependency>
</dependencies>
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public abstract class AbstractYangTest {
protected SchemaContext context;
public abstract class AbstractYangTest {
protected SchemaContext context;
yangISs.addAll(getConfigApiYangInputStreams());
yangISs.addAll(getConfigApiYangInputStreams());
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- context = reactor.buildEffective(yangISs);
+ context = YangParserTestUtils.parseYangStreams(yangISs);
// close ISs
for (InputStream is : yangISs) {
is.close();
// close ISs
for (InputStream is : yangISs) {
is.close();
}
public static List<InputStream> getConfigApiYangInputStreams() {
}
public static List<InputStream> getConfigApiYangInputStreams() {
- return getStreams("/META-INF/yang/config.yang",
- "/META-INF/yang/rpc-context.yang");
+ return getStreams("/META-INF/yang/config.yang", "/META-INF/yang/rpc-context.yang");
- public Map<QName, IdentitySchemaNode> mapIdentitiesByQNames(Module module) {
+ public Map<QName, IdentitySchemaNode> mapIdentitiesByQNames(final Module module) {
Map<QName, IdentitySchemaNode> result = new HashMap<>();
for (IdentitySchemaNode identitySchemaNode : module.getIdentities()) {
QName qName = identitySchemaNode.getQName();
Map<QName, IdentitySchemaNode> result = new HashMap<>();
for (IdentitySchemaNode identitySchemaNode : module.getIdentities()) {
QName qName = identitySchemaNode.getQName();
- protected static List<InputStream> getStreams(String... paths) {
+ protected static List<InputStream> getStreams(final String... paths) {
List<InputStream> result = new ArrayList<>();
for (String path : paths) {
InputStream is = AbstractYangTest.class.getResourceAsStream(path);
List<InputStream> result = new ArrayList<>();
for (String path : paths) {
InputStream is = AbstractYangTest.class.getResourceAsStream(path);
- protected Map<QName, ServiceInterfaceEntry> loadThreadsServiceInterfaceEntries(String packageName) {
+ protected Map<QName, ServiceInterfaceEntry> loadThreadsServiceInterfaceEntries(final String packageName) {
Map<IdentitySchemaNode, ServiceInterfaceEntry> identitiesToSIs = new HashMap<>();
return ServiceInterfaceEntry.create(threadsModule, packageName,identitiesToSIs);
}
Map<IdentitySchemaNode, ServiceInterfaceEntry> identitiesToSIs = new HashMap<>();
return ServiceInterfaceEntry.create(threadsModule, packageName,identitiesToSIs);
}
- protected Map<String /* identity local name */, ModuleMXBeanEntry> loadThreadsJava(Map<QName, ServiceInterfaceEntry> modulesToSIEs, String packageName) {
+ protected Map<String /* identity local name */, ModuleMXBeanEntry> loadThreadsJava(
+ final Map<QName, ServiceInterfaceEntry> modulesToSIEs, final String packageName) {
Map<String /* identity local name */, ModuleMXBeanEntry> namesToMBEs = ModuleMXBeanEntry
.create(threadsJavaModule, modulesToSIEs, context, new TypeProviderWrapper(new TypeProviderImpl
(context)), packageName);
Map<String /* identity local name */, ModuleMXBeanEntry> namesToMBEs = ModuleMXBeanEntry
.create(threadsJavaModule, modulesToSIEs, context, new TypeProviderWrapper(new TypeProviderImpl
(context)), packageName);
import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.NameConflictException;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.YangModelSearchUtils;
import org.opendaylight.yangtools.sal.binding.yang.types.TypeProviderImpl;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.NameConflictException;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.YangModelSearchUtils;
import org.opendaylight.yangtools.sal.binding.yang.types.TypeProviderImpl;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
- private String getYangModuleName(String name) {
+ private static String getYangModuleName(final String name) {
int startIndex = 0;
int endIndex = name.indexOf(".yang");
return name.substring(startIndex, endIndex);
}
int startIndex = 0;
int endIndex = name.indexOf(".yang");
return name.substring(startIndex, endIndex);
}
- private Module loadYangs(File testedModule, String moduleName)
+ private Module loadYangs(final File testedModule, final String moduleName)
throws Exception {
List<InputStream> yangISs = new ArrayList<>();
yangISs.addAll(getStreams("/ietf-inet-types.yang"));
throws Exception {
List<InputStream> yangISs = new ArrayList<>();
yangISs.addAll(getStreams("/ietf-inet-types.yang"));
yangISs.addAll(getConfigApiYangInputStreams());
yangISs.addAll(getConfigApiYangInputStreams());
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- context = reactor.buildEffective(yangISs);
+ context = YangParserTestUtils.parseYangStreams(yangISs);
// close ISs
for (InputStream is : yangISs) {
is.close();
// close ISs
for (InputStream is : yangISs) {
is.close();
import org.opendaylight.controller.config.yangjmxgenerator.ConfigConstants;
import org.opendaylight.controller.config.yangjmxgenerator.ServiceInterfaceEntryTest;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.YangModelSearchUtils;
import org.opendaylight.controller.config.yangjmxgenerator.ConfigConstants;
import org.opendaylight.controller.config.yangjmxgenerator.ServiceInterfaceEntryTest;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.YangModelSearchUtils;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class UnknownExtensionTest extends ServiceInterfaceEntryTest {
public class UnknownExtensionTest extends ServiceInterfaceEntryTest {
.getResourceAsStream("test-ifcWithUnknownExtension.yang"));
yangISs.addAll(getConfigApiYangInputStreams());
try {
.getResourceAsStream("test-ifcWithUnknownExtension.yang"));
yangISs.addAll(getConfigApiYangInputStreams());
try {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- context = reactor.buildEffective(yangISs);
- namesToModules = YangModelSearchUtils.mapModulesByNames(context
- .getModules());
+ context = YangParserTestUtils.parseYangStreams(yangISs);
+ namesToModules = YangModelSearchUtils.mapModulesByNames(context.getModules());
configModule = namesToModules.get(ConfigConstants.CONFIG_MODULE);
configModule = namesToModules.get(ConfigConstants.CONFIG_MODULE);
- threadsModule = namesToModules
- .get(ConfigConstants.CONFIG_THREADS_MODULE);
+ threadsModule = namesToModules.get(ConfigConstants.CONFIG_THREADS_MODULE);
try {
super.testCreateFromIdentities();
fail();
} catch (IllegalStateException e) {
try {
super.testCreateFromIdentities();
fail();
} catch (IllegalStateException e) {
- assertTrue(
- e.getMessage(),
- e.getMessage().startsWith(
- "Unexpected unknown schema node."));
+ assertTrue(e.getMessage(),
+ e.getMessage().startsWith("Unexpected unknown schema node."));
}
} finally {
for (InputStream is : yangISs) {
}
} finally {
for (InputStream is : yangISs) {
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-impl</artifactId>
- </dependency>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
+ <version>1.17.3</version>
</dependency>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-generator-annprocess</artifactId>
</dependency>
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-generator-annprocess</artifactId>
+ <version>1.17.3</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-broker-impl</artifactId>
</dependency>
<dependency>
<artifactId>sal-broker-impl</artifactId>
</dependency>
<dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-simple</artifactId>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-test-util</artifactId>
+ <scope>compile</scope>
</dependency>
</dependencies>
</dependency>
</dependencies>
import org.openjdk.jmh.annotations.Warmup;
/**
import org.openjdk.jmh.annotations.Warmup;
/**
- * @author Lukas Sedlak <lsedlak@cisco.com>
*/
public abstract class AbstractInMemoryBrokerWriteTransactionBenchmark extends AbstractInMemoryWriteTransactionBenchmark {
*/
public abstract class AbstractInMemoryBrokerWriteTransactionBenchmark extends AbstractInMemoryWriteTransactionBenchmark {
import org.openjdk.jmh.annotations.Warmup;
/**
import org.openjdk.jmh.annotations.Warmup;
/**
- * @author Lukas Sedlak <lsedlak@cisco.com>
*/
public abstract class AbstractInMemoryDatastoreWriteTransactionBenchmark extends AbstractInMemoryWriteTransactionBenchmark {
*/
public abstract class AbstractInMemoryDatastoreWriteTransactionBenchmark extends AbstractInMemoryWriteTransactionBenchmark {
import java.io.InputStream;
import java.util.Collections;
import java.io.InputStream;
import java.util.Collections;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
/**
* Benchmark Model class loads the odl-datastore-test.yang model from resources.
/**
* Benchmark Model class loads the odl-datastore-test.yang model from resources.
* This class serves as facilitator class which holds several references to initialized yang model as static final
* members.
*
* This class serves as facilitator class which holds several references to initialized yang model as static final
* members.
*
- * @author Lukas Sedlak <lsedlak@cisco.com>
*/
public final class BenchmarkModel {
*/
public final class BenchmarkModel {
}
public static SchemaContext createTestContext() {
}
public static SchemaContext createTestContext() {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
final SchemaContext schemaContext;
final List<InputStream> streams = Collections.singletonList(getInputStream());
try {
final SchemaContext schemaContext;
final List<InputStream> streams = Collections.singletonList(getInputStream());
try {
- schemaContext = reactor.buildEffective(streams);
+ schemaContext = YangParserTestUtils.parseYangStreams(streams);
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
* of benchmark creates InMemoryDataStore with Data Change Listener Executor Service as Blocking Bounded Fast Thread Pool
* and DOM Store Executor Service as Same Thread Executor.
*
* of benchmark creates InMemoryDataStore with Data Change Listener Executor Service as Blocking Bounded Fast Thread Pool
* and DOM Store Executor Service as Same Thread Executor.
*
- * @author Lukas Sedlak <lsedlak@cisco.com>
*/
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
*/
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
* of benchmark creates InMemoryDataStore with Data Change Listener Executor Service as Same Thread Executor
* and DOM Store Executor Service as Same Thread Executor.
*
* of benchmark creates InMemoryDataStore with Data Change Listener Executor Service as Same Thread Executor
* and DOM Store Executor Service as Same Thread Executor.
*
- * @author Lukas Sedlak <lsedlak@cisco.com>
*/
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
*/
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
<artifactId>truth</artifactId>
<scope>test</scope>
</dependency>
<artifactId>truth</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-impl</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-impl</artifactId>
- <scope>test</scope>
+ <artifactId>yang-test-util</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
/**
* Test case for reported bug 560
/**
* Test case for reported bug 560
@Before
public void setUp() throws Exception {
final BindingBrokerTestFactory testFactory = new BindingBrokerTestFactory();
@Before
public void setUp() throws Exception {
final BindingBrokerTestFactory testFactory = new BindingBrokerTestFactory();
- testFactory.setExecutor(MoreExecutors.sameThreadExecutor());
+ testFactory.setExecutor(MoreExecutors.newDirectExecutorService());
testFactory.setStartWithParsedSchema(true);
testContext = testFactory.getTestContext();
testFactory.setStartWithParsedSchema(true);
testContext = testFactory.getTestContext();
assertNotNull(moduleStream);
final List<InputStream> rpcModels = Collections.singletonList(moduleStream);
assertNotNull(moduleStream);
final List<InputStream> rpcModels = Collections.singletonList(moduleStream);
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- schemaContext = reactor.buildEffective(rpcModels);
+ schemaContext = YangParserTestUtils.parseYangStreams(rpcModels);
}
private static org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier createBITllIdentifier(
}
private static org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier createBITllIdentifier(
private static InstanceIdentifier<TopLevelList> createBATllIdentifier(
final String mount) {
return InstanceIdentifier.builder(Top.class)
private static InstanceIdentifier<TopLevelList> createBATllIdentifier(
final String mount) {
return InstanceIdentifier.builder(Top.class)
- .child(TopLevelList.class, new TopLevelListKey(mount)).toInstance();
+ .child(TopLevelList.class, new TopLevelListKey(mount)).build();
<version>1.5.0-SNAPSHOT</version>
<scope>test</scope>
</dependency>
<version>1.5.0-SNAPSHOT</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-test-util</artifactId>
+ </dependency>
<!-- Akka -->
<dependency>
<!-- Akka -->
<dependency>
<artifactId>slf4j-simple</artifactId>
<scope>test</scope>
</dependency>
<artifactId>slf4j-simple</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-test-util</artifactId>
+ </dependency>
<!-- Apache -->
<dependency>
<!-- Apache -->
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-util</artifactId>
</dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-model-util</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-impl</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-api</artifactId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-api</artifactId>
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
return resolveSchemaContext(inputStreams);
}
return resolveSchemaContext(inputStreams);
}
- private static SchemaContext resolveSchemaContext(List<InputStream> streams) {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- final SchemaContext schemaContext;
-
+ private static SchemaContext resolveSchemaContext(final List<InputStream> streams) {
- schemaContext = reactor.buildEffective(streams);
+ return YangParserTestUtils.parseYangStreams(streams);
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
- public static NormalizedNode<?, ?> createDocumentOne(
- SchemaContext schemaContext) {
+ public static NormalizedNode<?, ?> createDocumentOne(final SchemaContext schemaContext) {
return ImmutableContainerNodeBuilder
.create()
.withNodeIdentifier(
return ImmutableContainerNodeBuilder
.create()
.withNodeIdentifier(
return createBaseTestContainerBuilder().build();
}
return createBaseTestContainerBuilder().build();
}
- public static MapEntryNode createAugmentedListEntry(int id, String name) {
+ public static MapEntryNode createAugmentedListEntry(final int id, final String name) {
Set<QName> childAugmentations = new HashSet<>();
childAugmentations.add(AUG_CONT_QNAME);
Set<QName> childAugmentations = new HashSet<>();
childAugmentations.add(AUG_CONT_QNAME);
<artifactId>commons-lang3</artifactId>
</dependency>
<artifactId>commons-lang3</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-test-util</artifactId>
+ </dependency>
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class CompositeModel {
public class CompositeModel {
inputStreams.add(getDatastoreAugInputStream());
inputStreams.add(getDatastoreTestNotificationInputStream());
inputStreams.add(getDatastoreAugInputStream());
inputStreams.add(getDatastoreTestNotificationInputStream());
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- final SchemaContext schemaContext;
-
- schemaContext = reactor.buildEffective(inputStreams);
+ return YangParserTestUtils.parseYangStreams(inputStreams);
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + inputStreams, e);
}
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + inputStreams, e);
}
- public static NormalizedNode<?, ?> createDocumentOne(SchemaContext schemaContext) {
+ public static NormalizedNode<?, ?> createDocumentOne(final SchemaContext schemaContext) {
return ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schemaContext.getQName()))
.withChild(createTestContainer()).build();
return ImmutableContainerNodeBuilder.create()
.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schemaContext.getQName()))
.withChild(createTestContainer()).build();
package org.opendaylight.controller.md.cluster.datastore.model;
package org.opendaylight.controller.md.cluster.datastore.model;
-import com.google.common.io.ByteSource;
-import com.google.common.io.Resources;
+import com.google.common.base.Throwables;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
-import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class SchemaContextHelper {
public class SchemaContextHelper {
return select(ODL_DATASTORE_TEST_YANG, PEOPLE_YANG, CARS_YANG);
}
return select(ODL_DATASTORE_TEST_YANG, PEOPLE_YANG, CARS_YANG);
}
- public static SchemaContext select(String... schemaFiles) {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- final SchemaContext schemaContext;
- List<InputStream> streams = new ArrayList<>();
+ public static SchemaContext select(final String... schemaFiles) {
+ List<InputStream> streams = new ArrayList<>(schemaFiles.length);
for (String schemaFile : schemaFiles) {
streams.add(getInputStream(schemaFile));
}
try {
for (String schemaFile : schemaFiles) {
streams.add(getInputStream(schemaFile));
}
try {
- schemaContext = reactor.buildEffective(streams);
+ return YangParserTestUtils.parseYangStreams(streams);
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
-
- return schemaContext;
}
public static SchemaContext entityOwners() {
}
public static SchemaContext entityOwners() {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- final SchemaContext schemaContext;
- File file = null;
-
- file = new File("src/main/yang/entity-owners.yang");
- final List<ByteSource> sources = Arrays.asList(Resources.asByteSource(file.toURI().toURL()));
- try {
- schemaContext = reactor.buildEffective(sources);
- } catch (IOException e1) {
- throw new ExceptionInInitializerError(e1);
- } catch (ReactorException e2) {
- throw new RuntimeException("Unable to build schema context from " + sources, e2);
- }
- return schemaContext;
- } catch (MalformedURLException e3) {
- throw new RuntimeException("Malformed URL detected in " + file, e3);
+ return YangParserTestUtils.parseYangSources(new File("src/main/yang/entity-owners.yang"));
+ } catch (IOException | ReactorException e) {
+ throw Throwables.propagate(e);
*/
package org.opendaylight.controller.md.cluster.datastore.model;
*/
package org.opendaylight.controller.md.cluster.datastore.model;
-import com.google.common.io.ByteSource;
import com.google.common.io.Resources;
import java.io.IOException;
import com.google.common.io.Resources;
import java.io.IOException;
+import java.io.InputStream;
import java.util.Collections;
import java.util.Collections;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public static final QName THREE_QNAME = QName.create(TEST_QNAME,"three");
public static SchemaContext createTestContext() {
public static final QName THREE_QNAME = QName.create(TEST_QNAME,"three");
public static SchemaContext createTestContext() {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- final SchemaContext schemaContext;
- final Set<ByteSource> sources = Collections
- .singleton(Resources.asByteSource(TestModel.class.getResource(DATASTORE_TEST_YANG)));
+ final List<InputStream> sources;
- schemaContext = reactor.buildEffective(sources);
+ sources = Collections.singletonList(
+ Resources.asByteSource(TestModel.class.getResource(DATASTORE_TEST_YANG)).openStream());
} catch (IOException e1) {
throw new ExceptionInInitializerError(e1);
} catch (IOException e1) {
throw new ExceptionInInitializerError(e1);
- } catch (ReactorException e2) {
- throw new RuntimeException("Unable to build schema context from " + sources, e2);
+
+ try {
+ return YangParserTestUtils.parseYangStreams(sources);
+ } catch (ReactorException e) {
+ throw new RuntimeException("Unable to build schema context from " + sources, e);
+ }
- public static DataContainerChild<?, ?> outerNode(int... ids) {
+ public static DataContainerChild<?, ?> outerNode(final int... ids) {
CollectionNodeBuilder<MapEntryNode, MapNode> outer = ImmutableNodes.mapNodeBuilder(OUTER_LIST_QNAME);
for (int id: ids) {
outer.addChild(ImmutableNodes.mapEntry(OUTER_LIST_QNAME, ID_QNAME, id));
CollectionNodeBuilder<MapEntryNode, MapNode> outer = ImmutableNodes.mapNodeBuilder(OUTER_LIST_QNAME);
for (int id: ids) {
outer.addChild(ImmutableNodes.mapEntry(OUTER_LIST_QNAME, ID_QNAME, id));
- public static DataContainerChild<?, ?> outerNode(MapEntryNode... entries) {
+ public static DataContainerChild<?, ?> outerNode(final MapEntryNode... entries) {
CollectionNodeBuilder<MapEntryNode, MapNode> outer = ImmutableNodes.mapNodeBuilder(OUTER_LIST_QNAME);
for (MapEntryNode e: entries) {
outer.addChild(e);
CollectionNodeBuilder<MapEntryNode, MapNode> outer = ImmutableNodes.mapNodeBuilder(OUTER_LIST_QNAME);
for (MapEntryNode e: entries) {
outer.addChild(e);
- public static DataContainerChild<?, ?> innerNode(String... names) {
+ public static DataContainerChild<?, ?> innerNode(final String... names) {
CollectionNodeBuilder<MapEntryNode, MapNode> outer = ImmutableNodes.mapNodeBuilder(INNER_LIST_QNAME);
for (String name: names) {
outer.addChild(ImmutableNodes.mapEntry(INNER_LIST_QNAME, NAME_QNAME, name));
CollectionNodeBuilder<MapEntryNode, MapNode> outer = ImmutableNodes.mapNodeBuilder(INNER_LIST_QNAME);
for (String name: names) {
outer.addChild(ImmutableNodes.mapEntry(INNER_LIST_QNAME, NAME_QNAME, name));
- public static MapEntryNode outerNodeEntry(int id, DataContainerChild<?, ?> inner) {
+ public static MapEntryNode outerNodeEntry(final int id, final DataContainerChild<?, ?> inner) {
return ImmutableNodes.mapEntryBuilder(OUTER_LIST_QNAME, ID_QNAME, id).addChild(inner).build();
}
return ImmutableNodes.mapEntryBuilder(OUTER_LIST_QNAME, ID_QNAME, id).addChild(inner).build();
}
- public static NormalizedNode<?, ?> testNodeWithOuter(int... ids) {
+ public static NormalizedNode<?, ?> testNodeWithOuter(final int... ids) {
return testNodeWithOuter(outerNode(ids));
}
return testNodeWithOuter(outerNode(ids));
}
- public static NormalizedNode<?, ?> testNodeWithOuter(DataContainerChild<?, ?> outer) {
+ public static NormalizedNode<?, ?> testNodeWithOuter(final DataContainerChild<?, ?> outer) {
return ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outer).build();
}
return ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(outer).build();
}
- public static NodeIdentifierWithPredicates outerEntryKey(int id) {
+ public static NodeIdentifierWithPredicates outerEntryKey(final int id) {
return new NodeIdentifierWithPredicates(OUTER_LIST_QNAME, ID_QNAME, id);
}
return new NodeIdentifierWithPredicates(OUTER_LIST_QNAME, ID_QNAME, id);
}
- public static YangInstanceIdentifier outerEntryPath(int id) {
+ public static YangInstanceIdentifier outerEntryPath(final int id) {
return OUTER_LIST_PATH.node(outerEntryKey(id));
}
return OUTER_LIST_PATH.node(outerEntryKey(id));
}
- public static NodeIdentifierWithPredicates innerEntryKey(String name) {
+ public static NodeIdentifierWithPredicates innerEntryKey(final String name) {
return new NodeIdentifierWithPredicates(INNER_LIST_QNAME, NAME_QNAME, name);
}
return new NodeIdentifierWithPredicates(INNER_LIST_QNAME, NAME_QNAME, name);
}
- public static YangInstanceIdentifier innerEntryPath(int id, String name) {
+ public static YangInstanceIdentifier innerEntryPath(final int id, final String name) {
return OUTER_LIST_PATH.node(outerEntryKey(id)).node(INNER_LIST_QNAME).node(innerEntryKey(name));
}
}
return OUTER_LIST_PATH.node(outerEntryKey(id)).node(INNER_LIST_QNAME).node(innerEntryKey(name));
}
}
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-impl</artifactId>
- </dependency>
<dependency>
<groupId>junit</groupId>
<dependency>
<groupId>junit</groupId>
<artifactId>slf4j-simple</artifactId>
<scope>test</scope>
</dependency>
<artifactId>slf4j-simple</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-test-util</artifactId>
+ </dependency>
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
}
public static SchemaContext createTestContext() {
}
public static SchemaContext createTestContext() {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- final SchemaContext schemaContext;
final List<InputStream> streams = Collections.singletonList(getInputStream());
try {
final List<InputStream> streams = Collections.singletonList(getInputStream());
try {
- schemaContext = reactor.buildEffective(streams);
+ return YangParserTestUtils.parseYangStreams(streams);
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-test-util</artifactId>
+ </dependency>
</dependencies>
<url>https://wiki.opendaylight.org/view/OpenDaylight_Controller:MD-SAL:XSQL</url>
</dependencies>
<url>https://wiki.opendaylight.org/view/OpenDaylight_Controller:MD-SAL:XSQL</url>
import org.opendaylight.controller.md.sal.dom.xsql.jdbc.JDBCServer;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.controller.md.sal.dom.xsql.jdbc.JDBCServer;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class XSQLTest {
private static final String DATASTORE_TEST_YANG = "/sal-persisted-dom-test.yang";
private XSQLBluePrint bluePrint = null;
public class XSQLTest {
private static final String DATASTORE_TEST_YANG = "/sal-persisted-dom-test.yang";
private XSQLBluePrint bluePrint = null;
- private static void parseTables(String sql,XSQLBluePrint bp,JDBCResultSet rs){
+ private static void parseTables(final String sql,final XSQLBluePrint bp,final JDBCResultSet rs){
try{
JDBCServer.parseTables(rs, bp);
log("Test Table parsing of \""+sql+"\" Passed!");
try{
JDBCServer.parseTables(rs, bp);
log("Test Table parsing of \""+sql+"\" Passed!");
- private static void parseFields(String sql,XSQLBluePrint bp,JDBCResultSet rs){
+ private static void parseFields(final String sql,final XSQLBluePrint bp,final JDBCResultSet rs){
try{
JDBCServer.parseFields(rs, bp);
log("Test Fields parsing of \""+sql+"\" Passed!");
try{
JDBCServer.parseFields(rs, bp);
log("Test Fields parsing of \""+sql+"\" Passed!");
- private static void log(String str) {
+ private static void log(final String str) {
System.out.print("*** XSQL Tests -");
System.out.println(str);
}
System.out.print("*** XSQL Tests -");
System.out.println(str);
}
}
public static SchemaContext createTestContext() {
}
public static SchemaContext createTestContext() {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- final SchemaContext schemaContext;
final List<InputStream> streams = Collections.singletonList(getInputStream());
try {
final List<InputStream> streams = Collections.singletonList(getInputStream());
try {
- schemaContext = reactor.buildEffective(streams);
+ return YangParserTestUtils.parseYangStreams(streams);
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-impl</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-test-model</artifactId>
<scope>test</scope>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-test-model</artifactId>
<scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-test-util</artifactId>
+ </dependency>
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
}
public static SchemaContext createTestContext() {
}
public static SchemaContext createTestContext() {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- final SchemaContext schemaContext;
final List<InputStream> streams = Collections.singletonList(getInputStream());
try {
final List<InputStream> streams = Collections.singletonList(getInputStream());
try {
- schemaContext = reactor.buildEffective(streams);
+ return YangParserTestUtils.parseYangStreams(streams);
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + streams, e);
}
<artifactId>slf4j-simple</artifactId>
<scope>test</scope>
</dependency>
<artifactId>slf4j-simple</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-parser-impl</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>com.google.collections</groupId>
<artifactId>google-collections</artifactId>
<version>1.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.google.collections</groupId>
<artifactId>google-collections</artifactId>
<version>1.0</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-test-util</artifactId>
+ </dependency>
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.testkit.JavaTestKit;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.testkit.JavaTestKit;
-import com.google.common.collect.Lists;
-import com.google.common.io.ByteSource;
-import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.io.InputStream;
import java.net.URI;
-import java.util.ArrayList;
import java.util.Collection;
import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
-import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
/**
* Base class for RPC tests.
/**
* Base class for RPC tests.
@Before
public void setUp() throws Exception {
@Before
public void setUp() throws Exception {
- final ByteSource byteSource = new ByteSource() {
- @Override
- public InputStream openStream() throws IOException {
- return AbstractRpcTest.this.getClass().getResourceAsStream("/test-rpc.yang");
- }
- };
-
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- final ArrayList<ByteSource> sources = Lists.newArrayList(byteSource);
+ final List<InputStream> sources = Collections.singletonList(
+ AbstractRpcTest.this.getClass().getResourceAsStream("/test-rpc.yang"));
- schemaContext = reactor.buildEffective(sources);
+ schemaContext = YangParserTestUtils.parseYangStreams(sources);
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + sources, e);
}
} catch (ReactorException e) {
throw new RuntimeException("Unable to build schema context from " + sources, e);
}