Java YangParserTestUtils.parseYangStreams方法代码示例

import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; //导入方法依赖的package包/类
private Module loadYangs(final File testedModule, final String moduleName)
        throws Exception {
    final List<InputStream> yangISs = new ArrayList<>();
    yangISs.addAll(getStreams("/ietf-inet-types.yang"));

    yangISs.add(new FileInputStream(testedModule));

    yangISs.addAll(getConfigApiYangInputStreams());

    this.context =  YangParserTestUtils.parseYangStreams(yangISs);
    // close ISs
    for (final InputStream is : yangISs) {
        is.close();
    }
    this.namesToModules = YangModelSearchUtils.mapModulesByNames(this.context
            .getModules());
    this.configModule = this.namesToModules.get(ConfigConstants.CONFIG_MODULE);
    final Module module = this.namesToModules.get(moduleName);
    Preconditions.checkNotNull(module, "Cannot get module %s from %s",
            moduleName, this.namesToModules.keySet());
    return module;
}
 

import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; //导入方法依赖的package包/类
@Test
public void testStopOnUnknownLanguageExtension() throws Exception {
    List<InputStream> yangISs = Lists.newArrayList(getClass()
            .getResourceAsStream("test-ifcWithUnknownExtension.yang"));
    yangISs.addAll(getConfigApiYangInputStreams());
    try {
        context = YangParserTestUtils.parseYangStreams(yangISs);
        namesToModules = YangModelSearchUtils.mapModulesByNames(context.getModules());
        configModule = namesToModules.get(ConfigConstants.CONFIG_MODULE);
        threadsModule = namesToModules.get(ConfigConstants.CONFIG_THREADS_MODULE);
        try {
            super.testCreateFromIdentities();
            fail();
        } catch (IllegalStateException e) {
            assertTrue(e.getMessage(),
                    e.getMessage().startsWith("Unexpected unknown schema node."));
        }
    } finally {
        for (InputStream is : yangISs) {
            is.close();
        }
    }
}
 

import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; //导入方法依赖的package包/类
public static SchemaContext createTestContext() {
    final List<InputStream> sources;

    try {
        sources = Collections.singletonList(
            Resources.asByteSource(TestModel.class.getResource(DATASTORE_TEST_YANG)).openStream());
    } catch (IOException e1) {
        throw new ExceptionInInitializerError(e1);
    }

    try {
        return YangParserTestUtils.parseYangStreams(sources);
    }  catch (ReactorException e) {
        throw new RuntimeException("Unable to build schema context from " + sources, e);
    }
}
 

import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; //导入方法依赖的package包/类
/**
 * @throws java.lang.Exception
 */
@Before
public void setUp() throws Exception {
    final BindingBrokerTestFactory testFactory = new BindingBrokerTestFactory();
    testFactory.setExecutor(MoreExecutors.newDirectExecutorService());
    testFactory.setStartWithParsedSchema(true);
    testContext = testFactory.getTestContext();

    testContext.start();
    domMountPointService = testContext.getDomMountProviderService();
    bindingMountPointService = testContext.getBindingMountPointService();
    assertNotNull(domMountPointService);

    final InputStream moduleStream = BindingReflections.getModuleInfo(
            OpendaylightTestRpcServiceService.class)
            .getModuleSourceStream();

    assertNotNull(moduleStream);
    final List<InputStream> rpcModels = Collections.singletonList(moduleStream);
    schemaContext = YangParserTestUtils.parseYangStreams(rpcModels);
}
 

import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; //导入方法依赖的package包/类
@Before
public void loadYangFiles() throws Exception {
    final List<InputStream> yangISs = new ArrayList<>();
    yangISs.addAll(getStreams("/test-config-threads.yang",
            "/test-config-threads-java.yang",
            "/config-bgp-listener-impl.yang", "/ietf-inet-types.yang",
            "/config-jmx-it.yang", "/config-jmx-it-impl.yang",
            "/test-config-files.yang", "/test-config-files1.yang"));

    yangISs.addAll(getConfigApiYangInputStreams());

    this.context = YangParserTestUtils.parseYangStreams(yangISs);
    // close ISs
    for (final InputStream is : yangISs) {
        is.close();
    }
    this.namesToModules = YangModelSearchUtils.mapModulesByNames(this.context
            .getModules());
    this.configModule = this.namesToModules.get(ConfigConstants.CONFIG_MODULE);
    this.rpcContextModule = this.namesToModules.get(ConfigConstants.CONFIG_MODULE);
    this.threadsModule = this.namesToModules
            .get(ConfigConstants.CONFIG_THREADS_MODULE);
    this.threadsJavaModule = this.namesToModules.get("config-threads-java");
    this.bgpListenerJavaModule = this.namesToModules.get("config-bgp-listener-impl");
    this.ietfInetTypesModule = this.namesToModules
            .get(ConfigConstants.IETF_INET_TYPES);
    this.jmxModule = this.namesToModules.get("config-jmx-it");
    this.jmxImplModule = this.namesToModules.get("config-jmx-it-impl");
    this.testFilesModule = this.namesToModules.get("test-config-files");
    this.testFiles1Module = this.namesToModules.get("test-config-files1");

}
 

import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; //导入方法依赖的package包/类
public static SchemaContext createTestContext() {
    final SchemaContext schemaContext;
    final List<InputStream> streams = Collections.singletonList(getInputStream());

    try {
        schemaContext = YangParserTestUtils.parseYangStreams(streams);
    } catch (ReactorException e) {
        throw new RuntimeException("Unable to build schema context from " + streams, e);
    }
    return schemaContext;
}
 

import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; //导入方法依赖的package包/类
public static SchemaContext createTestContext() {
    final List<InputStream> streams = Collections.singletonList(getInputStream());

    try {
        return YangParserTestUtils.parseYangStreams(streams);
    } catch (ReactorException e) {
        throw new RuntimeException("Unable to build schema context from " + streams, e);
    }
}
 

import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; //导入方法依赖的package包/类
public static SchemaContext select(final String... schemaFiles) {
    List<InputStream> streams = new ArrayList<>(schemaFiles.length);

    for (String schemaFile : schemaFiles) {
        streams.add(getInputStream(schemaFile));
    }

    try {
        return YangParserTestUtils.parseYangStreams(streams);
    } catch (ReactorException e) {
        throw new RuntimeException("Unable to build schema context from " + streams, e);
    }
}
 

import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; //导入方法依赖的package包/类
public static SchemaContext distributedShardedDOMDataTreeSchemaContext() {
    final List<InputStream> streams = new ArrayList<>();
    try {
        // we need prefix-shard-configuration and odl-datastore-test models
        // for DistributedShardedDOMDataTree tests
        streams.add(getInputStream(ODL_DATASTORE_TEST_YANG));
        streams.add(new FileInputStream("src/main/yang/prefix-shard-configuration.yang"));
        return YangParserTestUtils.parseYangStreams(streams);
    } catch (FileNotFoundException | ReactorException e) {
        throw new RuntimeException(e);
    }
}
 

import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; //导入方法依赖的package包/类
public static SchemaContext createTestContext() {
    List<InputStream> inputStreams = new ArrayList<>();
    inputStreams.add(getDatastoreTestInputStream());
    inputStreams.add(getDatastoreAugInputStream());
    inputStreams.add(getDatastoreTestNotificationInputStream());

    try {
        return YangParserTestUtils.parseYangStreams(inputStreams);
    } catch (ReactorException e) {
        throw new RuntimeException("Unable to build schema context from " + inputStreams, e);
    }
}
 

import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; //导入方法依赖的package包/类
private static SchemaContext resolveSchemaContext(final List<InputStream> streams) {
    try {
        return YangParserTestUtils.parseYangStreams(streams);
    } catch (ReactorException e) {
        throw new RuntimeException("Unable to build schema context from " + streams, e);
    }
}