Raw types and method which could be static.
Change-Id: I19dcd742674944877f4b7b53d11068f630c826db
Signed-off-by: Robert Varga <rovarga@cisco.com>
cleanUp(sourcesOutputDir, compiledOutputDir);
}
- private void generateTestSources(String resourceDirPath, File sourcesOutputDir) throws Exception {
+ private static void generateTestSources(final String resourceDirPath, final File sourcesOutputDir) throws Exception {
final List<File> sourceFiles = getSourceFiles(resourceDirPath);
final SchemaContext context = RetestUtils.parseYangSources(sourceFiles);
CodeGeneratorImpl codegen = new CodeGeneratorImpl();
codegen.generateSources(context, sourcesOutputDir, context.getModules());
}
- private static void testCompilation(File sourcesOutputDir, File compiledOutputDir) {
+ private static void testCompilation(final File sourcesOutputDir, final File compiledOutputDir) {
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
List<File> filesList = getJavaFiles(sourcesOutputDir);
assertTrue(compiled);
}
- private static List<File> getJavaFiles(File directory) {
+ private static List<File> getJavaFiles(final File directory) {
List<File> result = new ArrayList<>();
File[] filesToRead = directory.listFiles();
if (filesToRead != null) {
return result;
}
- private static List<File> getSourceFiles(String path) throws Exception {
+ private static List<File> getSourceFiles(final String path) throws Exception {
final URI resPath = YangModuleInfoCompilationTest.class.getResource(path).toURI();
final File sourcesDir = new File(resPath);
final URI currentDir = new File(System.getProperty("user.dir")).toURI();
}
}
- private static void deleteTestDir(File file) {
+ private static void deleteTestDir(final File file) {
if (file.isDirectory()) {
File[] filesToDelete = file.listFiles();
if (filesToDelete != null) {
}
}
- private static Method assertContainsMethod(Class<?> clazz, Class<?> returnType, String name, Class<?>... args) {
+ private static Method assertContainsMethod(final Class<?> clazz, final Class<?> returnType, final String name, final Class<?>... args) {
try {
Method m = clazz.getDeclaredMethod(name, args);
assertEquals(returnType, m.getReturnType());
}
}
- private static void cleanUp(File... resourceDirs) {
+ private static void cleanUp(final File... resourceDirs) {
for (File resourceDir : resourceDirs) {
if (resourceDir.exists()) {
deleteTestDir(resourceDir);
*/
package org.opendaylight.yangtools.sal.binding.yang.types;
+import com.google.common.base.Function;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
import java.util.List;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Function;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-
public class UnionDependencySort {
private static final Logger LOGGER = LoggerFactory.getLogger(UnionDependencySort.class);
/**
* Sorts union types by mutual dependencies.
- *
+ *
* At the beginning the union types are selected from
* <code>typeDefinitions</code> and wrapped to nodes. The nodes are sorted
* and then the wrapped payload is extracted.
- *
+ *
* @param typeDefinitions
* set of type definitions.
* @return list of extended type which are sorted by mutual dependencies
final List<Node> sortedNodes = TopologicalSort.sort(unsorted);
return Lists.transform(sortedNodes, new Function<Node, ExtendedType>() {
@Override
- public ExtendedType apply(Node input) {
+ public ExtendedType apply(final Node input) {
return (ExtendedType) (((NodeWrappedType) input).getWrappedType());
}
});
/**
* Extracts only union types from <code>typeDefinitions</code> set.
- *
+ *
* @param typeDefinitions
* set of all type definitions
* @return set of extended type which are union type definition
*/
- private Set<ExtendedType> unionsFromTypeDefinitions(final Set<TypeDefinition<?>> typeDefinitions) {
+ private static Set<ExtendedType> unionsFromTypeDefinitions(final Set<TypeDefinition<?>> typeDefinitions) {
final Set<ExtendedType> unions = Sets.newHashSet();
for (final TypeDefinition<?> typedef : typeDefinitions) {
/**
* Wraps every extended type which represents union to node type and adds to
* every node information about dependencies.
- *
+ *
* The mapping from union type to node is created. For every created node
* (next <i>nodeFrom</i>) is for its wrapped union type passed the list of
* inner types through and only those inner types which represent union type
* node (next as <i>nodeTo</i>). This dependency relationship between
* nodeFrom and all found nodesTo is modeled with creating of one edge from
* nodeFrom to nodeTo.
- *
- *
+ *
+ *
* @param extUnionTypes
* set of extended types which represents union types
* @return set of nodes which contains wrapped union types set of node where
* each one contains wrapped one union type
*/
- private Set<Node> unionTypesToNodes(final Set<ExtendedType> extUnionTypes) {
+ private static Set<Node> unionTypesToNodes(final Set<ExtendedType> extUnionTypes) {
final Map<ExtendedType, Node> nodeMap = Maps.newHashMap();
final Set<Node> resultNodes = Sets.newHashSet();
import static org.junit.Assert.assertNotNull;
import static org.opendaylight.yangtools.sal.binding.generator.impl.SupportTestUtil.containsInterface;
import static org.opendaylight.yangtools.sal.binding.generator.impl.SupportTestUtil.containsMethods;
-
import java.io.IOException;
import java.util.List;
-
import org.junit.Test;
import org.opendaylight.yangtools.sal.binding.generator.api.BindingGenerator;
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject;
super(ChoiceCaseGenTypesTest.class.getResource("/choice-case-type-test-models"));
}
- private GeneratedType checkGeneratedType(final List<Type> genTypes, final String genTypeName, final String packageName, final int occurences) {
+ private static GeneratedType checkGeneratedType(final List<Type> genTypes, final String genTypeName,
+ final String packageName, final int occurences) {
GeneratedType searchedGenType = null;
int searchedGenTypeCounter = 0;
for (Type type : genTypes) {
}
- private GeneratedType checkGeneratedType(final List<Type> genTypes, final String genTypeName, final String packageName) {
+ private static GeneratedType checkGeneratedType(final List<Type> genTypes, final String genTypeName,
+ final String packageName) {
return checkGeneratedType(genTypes, genTypeName, packageName, 1);
}
package org.opendaylight.yangtools.sal.binding.generator.impl;
import static org.junit.Assert.assertTrue;
-
import java.io.File;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
-
import org.junit.Test;
import org.opendaylight.yangtools.sal.binding.generator.api.BindingGenerator;
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedProperty;
public class GenerateInnerClassForBitsAndUnionInLeavesTest {
- private SchemaContext resolveSchemaContextFromFiles(final URI... yangFiles) throws Exception {
+ private static SchemaContext resolveSchemaContextFromFiles(final URI... yangFiles) throws Exception {
final YangContextParser parser = new YangParserImpl();
final List<File> inputFiles = new ArrayList<File>();
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.fail;
-
import com.google.common.io.ByteSource;
-
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.List;
import java.util.Set;
-
import org.junit.Test;
import org.opendaylight.yangtools.sal.binding.generator.api.BindingGenerator;
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedProperty;
return ctx.getModules();
}
- private SchemaContext resolveSchemaContextFromFiles(final URI... yangFiles) throws IOException {
+ private static SchemaContext resolveSchemaContextFromFiles(final URI... yangFiles) throws IOException {
final YangContextParser parser = new YangParserImpl();
final List<File> inputFiles = new ArrayList<File>();
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
-import static org.opendaylight.yangtools.sal.binding.generator.impl.stmt.parser.retest.SupportTestUtil.containsMethods;
import static org.opendaylight.yangtools.sal.binding.generator.impl.stmt.parser.retest.SupportTestUtil.containsInterface;
-
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
-
-import org.opendaylight.yangtools.sal.binding.generator.impl.BindingGeneratorImpl;
+import static org.opendaylight.yangtools.sal.binding.generator.impl.stmt.parser.retest.SupportTestUtil.containsMethods;
import java.io.IOException;
import java.util.List;
import org.junit.Test;
import org.opendaylight.yangtools.sal.binding.generator.api.BindingGenerator;
+import org.opendaylight.yangtools.sal.binding.generator.impl.BindingGeneratorImpl;
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
import org.opendaylight.yangtools.sal.binding.model.api.Type;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
public class ChoiceCaseGenTypesTest extends AbstractTypesTest {
super(ChoiceCaseGenTypesTest.class.getResource("/choice-case-type-test-models"));
}
- private GeneratedType checkGeneratedType(final List<Type> genTypes, final String genTypeName, final String packageName, final int occurences) {
+ private static GeneratedType checkGeneratedType(final List<Type> genTypes, final String genTypeName,
+ final String packageName, final int occurences) {
GeneratedType searchedGenType = null;
int searchedGenTypeCounter = 0;
for (Type type : genTypes) {
}
- private GeneratedType checkGeneratedType(final List<Type> genTypes, final String genTypeName, final String packageName) {
+ private static GeneratedType checkGeneratedType(final List<Type> genTypes, final String genTypeName,
+ final String packageName) {
return checkGeneratedType(genTypes, genTypeName, packageName, 1);
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-
-import org.opendaylight.yangtools.sal.binding.yang.types.BaseYangTypes;
-
-import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
-import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil;
import org.opendaylight.yangtools.sal.binding.generator.spi.TypeProvider;
import org.opendaylight.yangtools.sal.binding.model.api.Type;
+import org.opendaylight.yangtools.sal.binding.yang.types.BaseYangTypes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.ExtendedType;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
+import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
/**
* Test class for testing BaseYangTypes class.
private static EmptyTypeDefinition empty = null;
private static BooleanTypeDefinition bool = null;
- @SuppressWarnings("deprecation")
@BeforeClass
public static void setup() throws SourceException, ReactorException {
final List<InputStream> modelsToParse = Collections
* <li>if <code>typeDefinition</code> equals <code>null</code></li>
* </ul>
* @deprecated This method ignores typeDefinition argument and its result is only
- * <code>indingMapping.normalizePackageName(basePackageName)</code>.
+ * <code>BindingMapping.normalizePackageName(basePackageName)</code>.
* Aside from tests, there is not a single user in OpenDaylight codebase,
* hence it can be considered buggy and defunct. It is scheduled for removal
* in Boron release.
}
@SuppressWarnings("unchecked")
- private Map<InstanceIdentifier, DataContainer> readUsingIdentifiableItem(final Iterable<Identifiable> dataList,
+ private static Map<InstanceIdentifier, DataContainer> readUsingIdentifiableItem(final Iterable<Identifiable> dataList,
final IdentifiableItem childArgument, final InstanceIdentifier parentPath) {
final Identifier<?> key = childArgument.getKey();
for (Identifiable item : dataList) {
*/
package org.opendaylight.yangtools.yang.binding.util;
+import static org.junit.Assert.assertTrue;
import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.UnmodifiableIterator;
+import java.util.Map;
+import java.util.Map.Entry;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.test.mock.Nodes;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-
-import static org.junit.Assert.assertTrue;
-
public class DataObjectReadingUtilTest {
@Mock private InstanceIdentifier<? extends DataObject> pathNull;
@Mock private Map.Entry<InstanceIdentifier<? extends DataObject>, DataObject> entryNull;
MockitoAnnotations.initMocks(this);
path = InstanceIdentifier.builder(Nodes.class).build();
- ImmutableMap map = ImmutableMap.<InstanceIdentifier<? extends DataObject>,
- DataObject>builder().put(path, mockedDataObject).build();
+ ImmutableMap<InstanceIdentifier<? extends DataObject>, DataObject> map =
+ ImmutableMap.<InstanceIdentifier<? extends DataObject>, DataObject>builder()
+ .put(path, mockedDataObject).build();
- Set entries = map.entrySet();
- Iterator it = entries.iterator();
+ ImmutableSet<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> entries = map.entrySet();
+ UnmodifiableIterator<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> it = entries.iterator();
while(it.hasNext()) {
- entry = (Map.Entry)it.next();
+ entry = it.next();
}
}
+ @SuppressWarnings("unchecked")
@Test(expected = IllegalArgumentException.class)
public void testReadDataParentNull() {
- DataObjectReadingUtil.readData(entryNull.getValue(), (InstanceIdentifier) entryNull.getKey(), pathNull);
+ DataObjectReadingUtil.readData(entryNull.getValue(), (InstanceIdentifier<DataObject>) entryNull.getKey(), pathNull);
}
+ @SuppressWarnings("unchecked")
@Test(expected = IllegalArgumentException.class)
public void testReadDataParentPathNull() {
- DataObjectReadingUtil.readData(entry.getValue(), (InstanceIdentifier) entryNull.getKey(), pathNull);
+ DataObjectReadingUtil.readData(entry.getValue(), (InstanceIdentifier<DataObject>) entryNull.getKey(), pathNull);
}
+ @SuppressWarnings("unchecked")
@Test
public void testReadDataWithThreeParams() {
assertTrue("Check if contains key",
DataObjectReadingUtil.readData(entry.getValue(),
- (InstanceIdentifier) entry.getKey(), path).containsKey(entry.getKey()));
+ (InstanceIdentifier<DataObject>) entry.getKey(), path).containsKey(entry.getKey()));
assertTrue("Check if contains value",
DataObjectReadingUtil.readData(entry.getValue(),
- (InstanceIdentifier) entry.getKey(), path).containsValue(entry.getValue()));
+ (InstanceIdentifier<DataObject>) entry.getKey(), path).containsValue(entry.getValue()));
}
@Test(expected = NullPointerException.class)