opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/test/java/org/opendaylight/controller/sal/java/api/generator/test/GeneratorJavaFileTest.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.sal.java.api.generator.test;
   9
  10 import org.junit.After;
  11 import org.junit.Before;
  12 import org.junit.Ignore;
  13 import org.junit.Test;
  14 import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
  15 import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator;
  16 import org.opendaylight.controller.sal.binding.generator.impl.BindingGeneratorImpl;
  17 import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
  18 import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
  19 import org.opendaylight.controller.sal.binding.model.api.Type;
  20 import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
  21 import org.opendaylight.controller.sal.java.api.generator.GeneratorJavaFile;
  22 import org.opendaylight.controller.sal.java.api.generator.InterfaceGenerator;
  23 import org.opendaylight.controller.yang.model.api.Module;
  24 import org.opendaylight.controller.yang.model.api.SchemaContext;
  25 import org.opendaylight.controller.yang.parser.impl.YangParserImpl;
  26
  27 import javax.tools.JavaCompiler;
  28 import javax.tools.JavaFileObject;
  29 import javax.tools.StandardJavaFileManager;
  30 import javax.tools.ToolProvider;
  31 import java.io.File;
  32 import java.io.IOException;
  33 import java.util.*;
  34
  35 import static org.junit.Assert.assertEquals;
  36 import static org.junit.Assert.assertTrue;
  37
  38 public class GeneratorJavaFileTest {
  39     private static final String FS = File.separator;
  40     private static final String PATH = "test-dir";
  41     private final File testDir = new File(PATH);
  42
  43     private static final String GENERATOR_OUTPUT_PATH = "src/test/resources/src";
  44     private static final File GENERATOR_OUTPUT = new File(GENERATOR_OUTPUT_PATH);
  45     private static final String COMPILER_OUTPUT_PATH = "src/test/resources/bin";
  46     private static final File COMPILER_OUTPUT = new File(COMPILER_OUTPUT_PATH);
  47
  48     @Before
  49     public void init() {
  50         assertTrue(testDir.mkdir());
  51         assertTrue(COMPILER_OUTPUT.mkdirs());
  52         assertTrue(GENERATOR_OUTPUT.mkdirs());
  53     }
  54
  55     @After
  56     public void cleanUp() {
  57         deleteTestDir(testDir);
  58         deleteTestDir(COMPILER_OUTPUT);
  59         deleteTestDir(GENERATOR_OUTPUT);
  60     }
  61
  62     @Test
  63     public void test() throws IOException {
  64         final Set<GeneratedType> types = new HashSet<GeneratedType>();
  65         GeneratedType t1 = createGeneratedType(
  66                 "org.opendaylight.controller.gen", "Type1");
  67         GeneratedType t2 = createGeneratedType(
  68                 "org.opendaylight.controller.gen", "Type2");
  69         GeneratedType t3 = createGeneratedType(
  70                 "org.opendaylight.controller.gen", "Type3");
  71         types.add(t1);
  72         types.add(t2);
  73         types.add(t3);
  74         GeneratorJavaFile generator = new GeneratorJavaFile(
  75                 new InterfaceGenerator(), types);
  76         generator.generateToFile(new File(PATH));
  77
  78         String[] files = new File(PATH + FS + "org" + FS + "opendaylight" + FS
  79                 + "controller" + FS + "gen").list();
  80         List<String> filesList = Arrays.asList(files);
  81
  82         assertEquals(3, files.length);
  83         assertTrue(filesList.contains("Type1.java"));
  84         assertTrue(filesList.contains("Type2.java"));
  85         assertTrue(filesList.contains("Type3.java"));
  86     }
  87
  88     @Ignore
  89     @Test
  90     public void compilationTest() throws Exception {
  91         final YangParserImpl parser = new YangParserImpl();
  92         final BindingGenerator bindingGenerator = new BindingGeneratorImpl();
  93
  94         final String resPath = getClass().getResource("/yang").getPath();
  95         final File sourcesDir = new File(resPath);
  96         final List<File> sourceFiles = new ArrayList<File>();
  97         final File[] fileArray = sourcesDir.listFiles();
  98
  99         for (int i = 0; i < fileArray.length; ++i) {
 100             sourceFiles.add(fileArray[i]);
 101         }
 102
 103         final Set<Module> modulesToBuild = parser.parseYangModels(sourceFiles);
 104
 105         final SchemaContext context = parser
 106                 .resolveSchemaContext(modulesToBuild);
 107         final List<Type> types = bindingGenerator.generateTypes(context);
 108         final Set<GeneratedType> typesToGenerate = new HashSet<GeneratedType>();
 109         final Set<GeneratedTransferObject> tosToGenerate = new HashSet<GeneratedTransferObject>();
 110         for (Type type : types) {
 111             if (type instanceof GeneratedType
 112                     && !(type instanceof GeneratedTransferObject)) {
 113                 typesToGenerate.add((GeneratedType) type);
 114             }
 115
 116             if (type instanceof GeneratedTransferObject) {
 117                 tosToGenerate.add((GeneratedTransferObject) type);
 118             }
 119         }
 120
 121         final GeneratorJavaFile generator = new GeneratorJavaFile(
 122                 typesToGenerate, tosToGenerate);
 123         generator.generateToFile(new File(GENERATOR_OUTPUT_PATH));
 124
 125         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
 126         StandardJavaFileManager fileManager = compiler.getStandardFileManager(
 127                 null, null, null);
 128
 129         List<File> filesList = getJavaFiles(new File(GENERATOR_OUTPUT_PATH));
 130         File current = new File(System.getProperty("user.dir"));
 131         File parentPath = current.getParentFile().getParentFile();
 132         File f = new File(parentPath,"yang/yang-binding/src/main/java/org/opendaylight/controller/yang/binding/DataObject.java"
 133         );
 134         filesList.add(f);
 135
 136         Iterable<? extends JavaFileObject> compilationUnits = fileManager
 137                 .getJavaFileObjectsFromFiles(filesList);
 138         Iterable<String> options = Arrays.asList(new String[]{"-d", COMPILER_OUTPUT_PATH});
 139         boolean compiled = compiler.getTask(null, null, null, options, null,
 140                 compilationUnits).call();
 141         assertTrue(compiled);
 142     }
 143
 144     private GeneratedType createGeneratedType(String pkgName, String name) {
 145         GeneratedTypeBuilder builder = new GeneratedTypeBuilderImpl(pkgName,
 146                 name);
 147         return builder.toInstance();
 148     }
 149
 150     private void deleteTestDir(File file) {
 151         if (file.isDirectory()) {
 152             for (File f : file.listFiles()) {
 153                 deleteTestDir(f);
 154             }
 155         }
 156         if (!file.delete()) {
 157             throw new RuntimeException("Failed to clean up after test");
 158         }
 159     }
 160
 161     /**
 162      * Search recursively given directory for *.java files.
 163      *
 164      * @param directory directory to search
 165      * @return List of java files found
 166      */
 167     private List<File> getJavaFiles(File directory) {
 168         List<File> result = new ArrayList<File>();
 169         for (File file : directory.listFiles()) {
 170             if (file.isDirectory()) {
 171                 result.addAll(getJavaFiles(file));
 172             } else {
 173                 String absPath = file.getAbsolutePath();
 174                 if (absPath.endsWith(".java")) {
 175                     result.add(file);
 176                 }
 177             }
 178         }
 179         return result;
 180     }
 181 }