import java.util.List;
import java.util.Map;
import java.util.Set;
+import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
import org.opendaylight.mdsal.binding.javav2.model.api.Type;
import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
+import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentable;
+import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentation;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
@SuppressWarnings({ "rawtypes" })
@Test
public void augmentationToGenTypesNullPckgNameTest() throws Exception {
- final Class[] parameterTypes = { String.class, AugmentationSchema.class, Module.class, SchemaContext.class,
+ final Class[] parameterTypes = { String.class, Map.Entry.class, Module.class, SchemaContext.class,
boolean.class, Map.class, Map.class, TypeProvider.class };
final Method generate = AugmentToGenType.class.getDeclaredMethod("augmentationToGenTypes", parameterTypes);
assertNotNull(generate);
generate.setAccessible(true);
final String augmPackName = null;
- final AugmentationSchema augmSchema = null;
+ final Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry = null;
final SchemaContext context = null;
final TypeProvider typeProvider = null;
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
final Module m = null;
- final Object[] args = { augmPackName, augmSchema, m, context, false, genCtx, genTypeBuilders, typeProvider };
+ final Object[] args = { augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx, genTypeBuilders, typeProvider };
try {
generate.invoke(AugmentToGenType.class, args);
fail();
@SuppressWarnings({ "rawtypes" })
@Test
public void augmentationToGenTypesNullAugSchemaTest() throws Exception {
- final Class[] parameterTypes = { String.class, AugmentationSchema.class, Module.class, SchemaContext.class,
+ final Class[] parameterTypes = { String.class, Map.Entry.class, Module.class, SchemaContext.class,
boolean.class, Map.class, Map.class, TypeProvider.class };
final Method generate = AugmentToGenType.class.getDeclaredMethod("augmentationToGenTypes", parameterTypes);
assertNotNull(generate);
generate.setAccessible(true);
final String augmPackName = "pckg.name";
- final AugmentationSchema augmSchema = null;
+ final Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry = null;
final SchemaContext context = null;
final TypeProvider typeProvider = null;
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
final Module m = null;
- final Object[] args = { augmPackName, augmSchema, m, context, false, genCtx, genTypeBuilders, typeProvider };
+ final Object[] args = { augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx, genTypeBuilders, typeProvider };
try {
generate.invoke(AugmentToGenType.class, args);
fail();
final Throwable cause = e.getCause();
assertNotNull(cause);
assertTrue(cause instanceof IllegalArgumentException);
- assertEquals("Augmentation Schema cannot be NULL.", cause.getMessage());
+ assertEquals("Augmentation List Entry cannot be NULL.", cause.getMessage());
}
}
@SuppressWarnings({ "rawtypes" })
@Test
public void augmentationToGenTypesNullAugSchemaTargetPathTest() throws Exception {
- final Class[] parameterTypes = { String.class, AugmentationSchema.class, Module.class, SchemaContext.class,
+ final Class[] parameterTypes = { String.class, Map.Entry.class, Module.class, SchemaContext.class,
boolean.class, Map.class, Map.class, TypeProvider.class };
final Method generate = AugmentToGenType.class.getDeclaredMethod("augmentationToGenTypes", parameterTypes);
assertNotNull(generate);
final AugmentationSchema augmSchema = mock(AugmentationSchema.class);
when(augmSchema.getTargetPath()).thenReturn(null);
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ final Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry = mock(Map.Entry.class);
+ when(schemaPathAugmentListEntry.getKey()).thenReturn(null);
+ when(schemaPathAugmentListEntry.getValue()).thenReturn(augmentationSchemaList);
+
final SchemaContext context = null;
final TypeProvider typeProvider = null;
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
final Module m = null;
- final Object[] args = { augmPackName, augmSchema, m, context, false, genCtx, genTypeBuilders, typeProvider };
+ final Object[] args = { augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx, genTypeBuilders, typeProvider };
try {
generate.invoke(AugmentToGenType.class, args);
fail();
final Throwable cause = e.getCause();
assertNotNull(cause);
assertTrue(cause instanceof IllegalStateException);
- assertEquals("Augmentation Schema does not contain Target Path (Target Path is NULL).", cause.getMessage());
+ assertEquals("Augmentation List Entry does not contain Target Path (Target Path is NULL).", cause.getMessage());
+ }
+ }
+
+ @SuppressWarnings({ "rawtypes" })
+ @Test
+ public void augmentationToGenTypesNullAugSchemaListTest() throws Exception {
+ final Class[] parameterTypes = { String.class, Map.Entry.class, Module.class, SchemaContext.class,
+ boolean.class, Map.class, Map.class, TypeProvider.class };
+ final Method generate = AugmentToGenType.class.getDeclaredMethod("augmentationToGenTypes", parameterTypes);
+ assertNotNull(generate);
+ generate.setAccessible(true);
+
+ final String augmPackName = "pckg.name";
+ final AugmentationSchema augmSchema = mock(AugmentationSchema.class);
+ final QName qnamePath = QName.create("test", "2017-04-04", "aug");
+ final SchemaPath path = SchemaPath.create(true, qnamePath);
+ when(augmSchema.getTargetPath()).thenReturn(path);
+
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ final Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry = mock(Map.Entry.class);
+ when(schemaPathAugmentListEntry.getKey()).thenReturn(path);
+ when(schemaPathAugmentListEntry.getValue()).thenReturn(augmentationSchemaList);
+
+ final SchemaContext context = null;
+ final TypeProvider typeProvider = null;
+ final Map<Module, ModuleContext> genCtx = new HashMap<>();
+ final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
+ final Module m = null;
+
+ final Object[] args = { augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx, genTypeBuilders, typeProvider };
+ try {
+ generate.invoke(AugmentToGenType.class, args);
+ fail();
+ } catch (final Exception e) {
+ assertNotNull(e);
+ assertTrue(e instanceof InvocationTargetException);
+ final Throwable cause = e.getCause();
+ assertNotNull(cause);
+ assertTrue(cause instanceof IllegalStateException);
+ assertEquals("Augmentation List cannot be empty.", cause.getMessage());
}
}
@SuppressWarnings({ "rawtypes" })
@Test
public void augmentationToGenTypesNullAugSchemaTargetNodeTest() throws Exception {
- final Class[] parameterTypes = { String.class, AugmentationSchema.class, Module.class, SchemaContext.class,
+ final Class[] parameterTypes = { String.class, Map.Entry.class, Module.class, SchemaContext.class,
boolean.class, Map.class, Map.class, TypeProvider.class };
final Method generate = AugmentToGenType.class.getDeclaredMethod("augmentationToGenTypes", parameterTypes);
assertNotNull(generate);
final Set<UsesNode> uses = new HashSet<>();
when(augmSchema.getUses()).thenReturn(uses);
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ augmentationSchemaList.add(augmSchema);
+ final Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry = mock(Map.Entry.class);
+ when(schemaPathAugmentListEntry.getKey()).thenReturn(path);
+ when(schemaPathAugmentListEntry.getValue()).thenReturn(augmentationSchemaList);
+
final SchemaContext context = mock(SchemaContext.class);
final Module moduleAug = mock(Module.class);
final DataSchemaNode schNode = null;
when(m.getNamespace()).thenReturn(qnamePath.getNamespace());
when(m.getRevision()).thenReturn(qnamePath.getRevision());
- final Object[] args = { augmPackName, augmSchema, m, context, false, genCtx, genTypeBuilders, typeProvider };
+ final Object[] args = { augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx, genTypeBuilders, typeProvider };
try {
generate.invoke(AugmentToGenType.class, args);
fail();
@SuppressWarnings({ "rawtypes" })
@Test
public void augmentationToGenTypesNullAugTargetGTBTest() throws Exception {
- final Class[] parameterTypes = { String.class, AugmentationSchema.class, Module.class, SchemaContext.class,
+ final Class[] parameterTypes = { String.class, Map.Entry.class, Module.class, SchemaContext.class,
boolean.class, Map.class, Map.class, TypeProvider.class };
final Method generate = AugmentToGenType.class.getDeclaredMethod("augmentationToGenTypes", parameterTypes);
assertNotNull(generate);
final Set<UsesNode> uses = new HashSet<>();
when(augmSchema.getUses()).thenReturn(uses);
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ augmentationSchemaList.add(augmSchema);
+ final Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry = mock(Map.Entry.class);
+ when(schemaPathAugmentListEntry.getKey()).thenReturn(path);
+ when(schemaPathAugmentListEntry.getValue()).thenReturn(augmentationSchemaList);
+
final SchemaContext context = mock(SchemaContext.class);
final Module moduleAug = mock(Module.class);
final DataSchemaNode schNode = mock(DataSchemaNode.class);
when(m.getNamespace()).thenReturn(qnamePath.getNamespace());
when(m.getRevision()).thenReturn(qnamePath.getRevision());
- final Object[] args = { augmPackName, augmSchema, m, context, false, genCtx, genTypeBuilders, typeProvider };
+ final Object[] args = { augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx, genTypeBuilders, typeProvider };
try {
generate.invoke(AugmentToGenType.class, args);
fail();
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void augmentationToGenTypesAugUsesNullOrigTargetTest() throws Exception {
- final Class[] parameterTypes = { String.class, AugmentationSchema.class, Module.class, SchemaContext.class,
+ final Class[] parameterTypes = { String.class, Map.Entry.class, Module.class, SchemaContext.class,
boolean.class, Map.class, Map.class, TypeProvider.class };
final Method generate = AugmentToGenType.class.getDeclaredMethod("augmentationToGenTypes", parameterTypes);
assertNotNull(generate);
final Set<UsesNode> uses = new HashSet<>();
when(augmSchema.getUses()).thenReturn(uses);
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ augmentationSchemaList.add(augmSchema);
+ final Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry = mock(Map.Entry.class);
+ when(schemaPathAugmentListEntry.getKey()).thenReturn(path);
+ when(schemaPathAugmentListEntry.getValue()).thenReturn(augmentationSchemaList);
+
final SchemaContext context = mock(SchemaContext.class);
final Module moduleAug = mock(Module.class);
final DerivableSchemaNode targetSchNode = mock(DerivableSchemaNode.class);
when(m.getNamespace()).thenReturn(qnamePath.getNamespace());
when(m.getRevision()).thenReturn(qnamePath.getRevision());
- final Object[] args = { augmPackName, augmSchema, m, context, false, genCtx, genTypeBuilders, typeProvider };
+ final Object[] args = { augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx, genTypeBuilders, typeProvider };
try {
generate.invoke(AugmentToGenType.class, args);
fail();
@SuppressWarnings({ "rawtypes" })
@Test
public void augmentationToGenTypesTargetChoicSchemaNodeTest() throws Exception {
- final Class[] parameterTypes = { String.class, AugmentationSchema.class, Module.class, SchemaContext.class,
+ final Class[] parameterTypes = { String.class, Map.Entry.class, Module.class, SchemaContext.class,
boolean.class, Map.class, Map.class, TypeProvider.class };
final Method generate = AugmentToGenType.class.getDeclaredMethod("augmentationToGenTypes", parameterTypes);
assertNotNull(generate);
final Set<UsesNode> uses = new HashSet<>();
when(augmSchema.getUses()).thenReturn(uses);
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ augmentationSchemaList.add(augmSchema);
+ final Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry = mock(Map.Entry.class);
+ when(schemaPathAugmentListEntry.getKey()).thenReturn(path);
+ when(schemaPathAugmentListEntry.getValue()).thenReturn(augmentationSchemaList);
+
final SchemaContext context = mock(SchemaContext.class);
final Module moduleAug = mock(Module.class);
final ChoiceSchemaNode targetSchNode = mock(ChoiceSchemaNode.class);
when(m.getNamespace()).thenReturn(qnamePath.getNamespace());
when(m.getRevision()).thenReturn(qnamePath.getRevision());
- final Object[] args = { augmPackName, augmSchema, m, context, false, genCtx, genTypeBuilders, typeProvider };
+ final Object[] args = { augmPackName, schemaPathAugmentListEntry, m, context, false, genCtx, genTypeBuilders, typeProvider };
final Map result = (Map) generate.invoke(AugmentToGenType.class, args);
assertNotNull(result);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void augmentationToGenTypesTest() throws Exception {
- final Class[] parameterTypes = { String.class, AugmentationSchema.class, Module.class, SchemaContext.class,
+ final Class[] parameterTypes = { String.class, Map.Entry.class, Module.class, SchemaContext.class,
boolean.class, Map.class, Map.class, TypeProvider.class };
final Method generate = AugmentToGenType.class.getDeclaredMethod("augmentationToGenTypes", parameterTypes);
assertNotNull(generate);
final List<UnknownSchemaNode> unknownSchemaNodes = new ArrayList<>();
when(augmSchema.getUnknownSchemaNodes()).thenReturn(unknownSchemaNodes);
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ augmentationSchemaList.add(augmSchema);
+ final Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry = mock(Map.Entry.class);
+ when(schemaPathAugmentListEntry.getKey()).thenReturn(path);
+ when(schemaPathAugmentListEntry.getValue()).thenReturn(augmentationSchemaList);
+
final SchemaContext context = mock(SchemaContext.class);
final Module moduleAug = mock(Module.class);
final DerivableSchemaNode targetSchNode = mock(DerivableSchemaNode.class);
when(moduleAug.getRevision()).thenReturn(qnamePath.getRevision());
final Object[] args =
- { augmPackName, augmSchema, moduleAug, context, false, genCtx, genTypeBuilders, typeProvider };
+ { augmPackName, schemaPathAugmentListEntry, moduleAug, context, false, genCtx, genTypeBuilders, typeProvider };
final Map<Module, ModuleContext> result =
(Map<Module, ModuleContext>) generate.invoke(AugmentToGenType.class, args);
assertNotNull(result);
final ModuleContext moduleContext = result.get(moduleAug);
assertTrue(moduleContext.getAugmentations().get(0).getName().contains("Augm"));
- assertEquals("pckg.name", moduleContext.getAugmentations().get(0).getPackageName());
+ assertEquals("pckg.name.data.aug", moduleContext.getAugmentations().get(0).getPackageName());
assertTrue(moduleContext.getChildNode(path).getName().contains("Augm"));
assertEquals("pckg.name", moduleContext.getChildNode(path).getPackageName());
}
@Test
public void usesAugmentationToGenTypesNullPckgNameTest() throws Exception {
try {
- AugmentToGenType.usesAugmentationToGenTypes(null, null, null, null, null, null, null, null, false, null);
+ AugmentToGenType.usesAugmentationToGenTypes(null, null, null, null, null, null, null, null, false, null, null);
} catch (final Exception e) {
assertNotNull(e);
assertTrue(e instanceof IllegalArgumentException);
}
@Test
- public void usesAugmentationToGenTypesNullAugSchemaNodeTest() throws Exception {
+ public void usesAugmentationToGenTypesNullAugSchemaListEntryTest() throws Exception {
try {
- AugmentToGenType.usesAugmentationToGenTypes(null, "", null, null, null, null, null, null, false, null);
+ AugmentToGenType.usesAugmentationToGenTypes(null, "", null, null, null, null, null, null, false, null, null);
} catch (final Exception e) {
assertNotNull(e);
assertTrue(e instanceof IllegalArgumentException);
- assertEquals(e.getMessage(), "Augmentation Schema cannot be NULL.");
+ assertEquals(e.getMessage(), "Augmentation Schema List Entry cannot be NULL.");
+ }
+ }
+
+ @Test
+ public void usesAugmentationToGenTypesEmptyAugSchemaListTest() throws Exception {
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ try {
+ AugmentToGenType.usesAugmentationToGenTypes(null, "", augmentationSchemaList, null, null, null, null, null,
+ false, null, null);
+ } catch (final Exception e) {
+ assertNotNull(e);
+ assertTrue(e instanceof IllegalStateException);
+ assertEquals(e.getMessage(), "Augmentation Schema List cannot be empty");
}
}
public void usesAugmentationToGenTypesNullAugSchemaNodeTargetPathTest() throws Exception {
final AugmentationSchema augmentationSchema = mock(AugmentationSchema.class);
when(augmentationSchema.getTargetPath()).thenReturn(null);
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ augmentationSchemaList.add(augmentationSchema);
try {
- AugmentToGenType.usesAugmentationToGenTypes(null, "", augmentationSchema, null, null, null, null, null,
- false, null);
+ AugmentToGenType.usesAugmentationToGenTypes(null, "", augmentationSchemaList, null, null, null, null, null,
+ false, null, null);
} catch (final Exception e) {
assertNotNull(e);
assertTrue(e instanceof IllegalStateException);
final Set<UsesNode> uses = new HashSet<>();
when(augmentationSchema.getUses()).thenReturn(uses);
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ augmentationSchemaList.add(augmentationSchema);
+
final SchemaContext context = mock(SchemaContext.class);
final Module moduleAug = mock(Module.class);
when(moduleAug.getName()).thenReturn("augm-module");
when(usesNode.getGroupingPath()).thenReturn(path);
try {
- AugmentToGenType.usesAugmentationToGenTypes(context, "pckg.test.augm", augmentationSchema, moduleAug,
- usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null);
+ AugmentToGenType.usesAugmentationToGenTypes(context, "pckg.test.augm", augmentationSchemaList, moduleAug,
+ usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null, null);
} catch (final Exception e) {
assertNotNull(e);
assertTrue(e instanceof IllegalArgumentException);
final Set<UsesNode> uses = new HashSet<>();
when(augmentationSchema.getUses()).thenReturn(uses);
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ augmentationSchemaList.add(augmentationSchema);
+
final SchemaContext context = mock(SchemaContext.class);
final Module moduleAug = mock(Module.class);
when(moduleAug.getName()).thenReturn("augm-module");
when(usesNode.getGroupingPath()).thenReturn(path);
try {
- AugmentToGenType.usesAugmentationToGenTypes(context, "pckg.test.augm", augmentationSchema, moduleAug,
- usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null);
+ AugmentToGenType.usesAugmentationToGenTypes(context, "pckg.test.augm", augmentationSchemaList, moduleAug,
+ usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null, null);
} catch (final Exception e) {
assertNotNull(e);
assertTrue(e instanceof NullPointerException);
final Set<UsesNode> uses = new HashSet<>();
when(augmentationSchema.getUses()).thenReturn(uses);
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ augmentationSchemaList.add(augmentationSchema);
+
final SchemaContext context = mock(SchemaContext.class);
final Module moduleAug = mock(Module.class);
when(moduleAug.getName()).thenReturn("augm-module");
when(usesNode.getGroupingPath()).thenReturn(path);
final Map<Module, ModuleContext> result = AugmentToGenType.usesAugmentationToGenTypes(context, "pckg.test.augm",
- augmentationSchema, moduleAug, usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null);
+ augmentationSchemaList, moduleAug, usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null,
+ BindingNamespaceType.Data);
assertNotNull(result);
}
final Set<UsesNode> uses = new HashSet<>();
when(augmentationSchema.getUses()).thenReturn(uses);
+ final List<AugmentationSchema> augmentationSchemaList = new ArrayList<>();
+ augmentationSchemaList.add(augmentationSchema);
+
final SchemaContext context = mock(SchemaContext.class);
final Module moduleAug = mock(Module.class);
when(moduleAug.getName()).thenReturn("augm-module");
when(usesNode.getGroupingPath()).thenReturn(path);
final Map<Module, ModuleContext> result = AugmentToGenType.usesAugmentationToGenTypes(context, "pckg.test.augm",
- augmentationSchema, moduleAug, usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null);
+ augmentationSchemaList, moduleAug, usesNode, usesNodeParent, genCtx, genTypeBuilders, false, null,
+ BindingNamespaceType.Data);
assertNotNull(result);
}
@Test
public void generateTypesFromAugmentedChoiceCasesNullPckgNameTest() throws Exception {
final Class[] parameterTypes =
- { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, Iterable.class,
- DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+ { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
+ DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+ BindingNamespaceType.class};
final Method generate =
AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
assertNotNull(generate);
final String pckgName = null;
final Type targetType = null;
final ChoiceSchemaNode targetNode = null;
- final Iterable augmentNodes = null;
+ final List<AugmentationSchema> schemaPathAugmentListEntry = null;
final DataNodeContainer usesNodeParent = null;
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
- final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, augmentNodes, usesNodeParent,
- genCtx, false, genTypeBuilder, null };
+ final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry,
+ usesNodeParent, genCtx, false, genTypeBuilder, null, BindingNamespaceType.Data };
try {
generate.invoke(AugmentToGenType.class, args);
fail();
@Test
public void generateTypesFromAugmentedChoiceCasesNullTargetType() throws Exception {
final Class[] parameterTypes =
- { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, Iterable.class,
- DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+ { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
+ DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+ BindingNamespaceType.class };
final Method generate =
AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
assertNotNull(generate);
final String pckgName = "";
final Type targetType = null;
final ChoiceSchemaNode targetNode = null;
- final Iterable augmentNodes = null;
+ final List<AugmentationSchema> schemaPathAugmentListEntry = null;
final DataNodeContainer usesNodeParent = null;
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
- final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, augmentNodes, usesNodeParent,
- genCtx, false, genTypeBuilder, null };
+ final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry,
+ usesNodeParent, genCtx, false, genTypeBuilder, null, BindingNamespaceType.Data };
try {
generate.invoke(AugmentToGenType.class, args);
fail();
@Test
public void generateTypesFromAugmentedChoiceCasesNullAugmentNodes() throws Exception {
final Class[] parameterTypes =
- { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, Iterable.class,
- DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+ { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
+ DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+ BindingNamespaceType.class };
final Method generate =
AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
assertNotNull(generate);
final String pckgName = "";
final Type targetType = mock(Type.class);
final ChoiceSchemaNode targetNode = null;
- final Iterable augmentNodes = null;
+ final List<AugmentationSchema> schemaPathAugmentListEntry = null;
final DataNodeContainer usesNodeParent = null;
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
- final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, augmentNodes, usesNodeParent,
- genCtx, false, genTypeBuilder, null };
+ final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, usesNodeParent,
+ genCtx, false, genTypeBuilder, null, BindingNamespaceType.Data };
try {
generate.invoke(AugmentToGenType.class, args);
fail();
@Test
public void generateTypesFromAugmentedChoiceCasesNullCaseNodeTest() throws Exception {
final Class[] parameterTypes =
- { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, Iterable.class,
- DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+ { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
+ DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+ BindingNamespaceType.class };
final Method generate =
AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
assertNotNull(generate);
final Set<DataSchemaNode> augmentNodes = new HashSet<>();
final DataSchemaNode caseNode = null;
augmentNodes.add(caseNode);
+
+ final AugmentationSchema augmentationSchema = mock(AugmentationSchema.class);
+ when(augmentationSchema.getChildNodes()).thenReturn(augmentNodes);
+ final List<AugmentationSchema> schemaPathAugmentListEntry = new ArrayList<>();
+ schemaPathAugmentListEntry.add(augmentationSchema);
+
final DataNodeContainer usesNodeParent = null;
final Map<Module, ModuleContext> genCtx = new HashMap<>();
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilder = new HashMap<>();
- final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, augmentNodes, usesNodeParent,
- genCtx, false, genTypeBuilder, null };
+ final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, usesNodeParent,
+ genCtx, false, genTypeBuilder, null, BindingNamespaceType.Data };
final Map<Module, ModuleContext> result =
(Map<Module, ModuleContext>) generate.invoke(AugmentToGenType.class, args);
assertEquals(genCtx, result);
@Test
public void generateTypesFromAugmentedChoiceCasesNullChildTest() throws Exception {
final Class[] parameterTypes =
- { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, Iterable.class,
- DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+ { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
+ DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+ BindingNamespaceType.class };
final Method generate =
AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
assertNotNull(generate);
when(module.getNamespace()).thenReturn(qnamePath.getNamespace());
final String pckgName = "test.augment.choice.cases";
final Type targetType = mock(Type.class);
+ when(targetType.getFullyQualifiedName()).thenReturn(Augmentable.class.getName());
final Set<DataSchemaNode> augmentNodes = new HashSet<>();
final ChoiceCaseNode caseNode = mock(ChoiceCaseNode.class);
when(caseNode.getPath()).thenReturn(path);
when(caseNode.getQName()).thenReturn(qnamePath);
augmentNodes.add(caseNode);
+
+ final AugmentationSchema augmentationSchema = mock(AugmentationSchema.class);
+ when(augmentationSchema.getChildNodes()).thenReturn(augmentNodes);
+ final List<AugmentationSchema> schemaPathAugmentListEntry = new ArrayList<>();
+ schemaPathAugmentListEntry.add(augmentationSchema);
+
final DataNodeContainer usesNodeParent = null;
final ChoiceSchemaNode targetNode = mock(ChoiceSchemaNode.class);
when(targetNode.getPath()).thenReturn(path);
when(schemaContext.findModuleByNamespaceAndRevision(qnamePath.getNamespace(), qnamePath.getRevision()))
.thenReturn(module);
- final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, augmentNodes, usesNodeParent,
- genCtx, false, genTypeBuilder, null };
+ final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, usesNodeParent,
+ genCtx, false, genTypeBuilder, null, BindingNamespaceType.Data };
try {
generate.invoke(AugmentToGenType.class, args);
fail();
@Test
public void generateTypesFromAugmentedChoiceCasesTest() throws Exception {
final Class[] parameterTypes =
- { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, Iterable.class,
- DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class };
+ { SchemaContext.class, Module.class, String.class, Type.class, ChoiceSchemaNode.class, List.class,
+ DataNodeContainer.class, Map.class, boolean.class, Map.class, TypeProvider.class,
+ BindingNamespaceType.class };
final Method generate =
AugmentToGenType.class.getDeclaredMethod("generateTypesFromAugmentedChoiceCases", parameterTypes);
assertNotNull(generate);
when(module.getNamespace()).thenReturn(qnamePath.getNamespace());
final String pckgName = "test.augment.choice.cases";
final Type targetType = mock(Type.class);
+ when(targetType.getFullyQualifiedName()).thenReturn(Augmentable.class.getName());
final Set<DataSchemaNode> augmentNodes = new HashSet<>();
final ChoiceCaseNode caseNode = mock(ChoiceCaseNode.class);
when(caseNode.getPath()).thenReturn(path);
when(caseNode.getQName()).thenReturn(qnamePath);
augmentNodes.add(caseNode);
+
+ final AugmentationSchema augmentationSchema = mock(AugmentationSchema.class);
+ when(augmentationSchema.getChildNodes()).thenReturn(augmentNodes);
+ final List<AugmentationSchema> schemaPathAugmentListEntry = new ArrayList<>();
+ schemaPathAugmentListEntry.add(augmentationSchema);
+
final DataNodeContainer usesNodeParent = null;
final ChoiceSchemaNode targetNode = mock(ChoiceSchemaNode.class);
when(targetNode.getPath()).thenReturn(path);
when(schemaContext.findModuleByNamespaceAndRevision(qnamePath.getNamespace(), qnamePath.getRevision()))
.thenReturn(module);
- final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, augmentNodes, usesNodeParent,
- genCtx, false, genTypeBuilder, null };
+ final Object[] args = { schemaContext, module, pckgName, targetType, targetNode, schemaPathAugmentListEntry, usesNodeParent,
+ genCtx, false, genTypeBuilder, null ,BindingNamespaceType.Data };
final Map<Module, ModuleContext> result =
(Map<Module, ModuleContext>) generate.invoke(AugmentToGenType.class, args);
assertNotNull(result);