1 /*
   2  * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 import java.io.IOException;
  25 import java.io.PrintWriter;
  26 import java.io.StringWriter;
  27 import java.lang.reflect.Field;
  28 import java.lang.reflect.Method;
  29 import java.net.URL;
  30 import java.net.URLClassLoader;
  31 import java.nio.file.FileVisitResult;
  32 import java.nio.file.Files;
  33 import java.nio.file.Path;
  34 import java.nio.file.Paths;
  35 import java.nio.file.SimpleFileVisitor;
  36 import java.nio.file.attribute.BasicFileAttributes;
  37 import java.util.Objects;
  38 import java.util.spi.ToolProvider;
  39 
  40 import static org.testng.Assert.assertEquals;
  41 import static org.testng.Assert.assertNotEquals;
  42 import static org.testng.Assert.assertNotNull;
  43 import static org.testng.Assert.assertTrue;
  44 import static org.testng.Assert.fail;
  45 
  46 public class JextractToolRunner {
  47     private static String safeFileName(String filename) {

  48         int ext = filename.lastIndexOf('.');
  49         return ext != -1 ? filename.substring(0, ext) : filename;
  50     }
  51 
  52     // utilities to avoid hard-coding generated class, interface names everywhere
  53     public static String headerInterfaceName(String filename) {
  54         return safeFileName(filename) + "_h";
  55     }
  56 
  57     public static String staticForwarderName(String filename) {
  58         return safeFileName(filename) + "_lib";
  59     }
  60 
  61     // struct, enum and callback interfaces are nested types of header interface
  62     public static String structInterfaceName(String headerFileName, String structName) {
  63         return headerInterfaceName(headerFileName) + "$" + structName;
  64     }
  65 
  66     public static String enumInterfaceName(String headerFileName, String enumName) {
  67         return headerInterfaceName(headerFileName) + "$" + enumName;
  68     }
  69 
  70     public static String callbackInterfaceName(String headerFileName, String fiName) {
  71         return headerInterfaceName(headerFileName) + "$" + fiName;
  72     }
  73 
  74     public static String enumForwarderInterfaceName(String headerFileName, String enumName) {
  75         return staticForwarderName(headerFileName) + "$" + enumName;
  76     }
  77 
  78     private static final ToolProvider JEXTRACT_TOOL = ToolProvider.findFirst("jextract")
  79             .orElseThrow(() ->
  80                     new RuntimeException("jextract tool not found")
  81             );
  82 
  83     private final Path inputDir;
  84     private final Path outputDir;
  85 
  86     protected JextractToolRunner() {
  87         this(null, null);
  88     }
  89 
  90     protected JextractToolRunner(Path input, Path output) {
  91         inputDir = (input != null) ? input :
  92                 Paths.get(System.getProperty("test.src", "."));
  93         outputDir = (output != null) ? output :
  94                 Paths.get(System.getProperty("test.classes", "."));
  95     }
  96 
  97     protected Path getInputFilePath(String fileName) {
  98         return inputDir.resolve(fileName).toAbsolutePath();
  99     }
 100 
 101     protected Path getOutputFilePath(String fileName) {
 102         return outputDir.resolve(fileName).toAbsolutePath();
 103     }
 104 
 105     protected static class JextractResult {
 106         private int exitCode;
 107         private String output;
 108 
 109         JextractResult(int exitCode, String output) {
 110             this.exitCode = exitCode;
 111             this.output = output;
 112         }
 113 
 114         protected JextractResult checkSuccess() {
 115             assertEquals(exitCode, 0, "Sucess excepted, failed: " + exitCode);
 116             return this;
 117         }
 118 
 119         protected JextractResult checkFailure() {
 120             assertNotEquals(exitCode, 0, "Failure excepted, succeeded!");
 121             return this;
 122         }
 123 
 124         protected JextractResult checkContainsOutput(String expected) {
 125             Objects.requireNonNull(expected);
 126             assertTrue(output.contains(expected), "Output does not contain string: " + expected);
 127             return this;
 128         }
 129 
 130         protected JextractResult checkMatchesOutput(String regex) {
 131             Objects.requireNonNull(regex);
 132             assertTrue(output.trim().matches(regex), "Output does not match regex: " + regex);
 133             return this;
 134         }
 135     }
 136 
 137     protected static JextractResult run(String... options) {
 138         StringWriter writer = new StringWriter();
 139         PrintWriter pw = new PrintWriter(writer);
 140         String[] args = new String[options.length + 1];
 141         System.arraycopy(options, 0, args, 1, options.length);
 142         args[0] = "-C-nostdinc";
 143         int result = JEXTRACT_TOOL.run(pw, pw, options);
 144         String output = writer.toString();
 145         System.err.println(output);
 146         return new JextractResult(result, output);
 147     }
 148 
 149     protected static void deleteFile(Path path) {
 150         try {
 151             Files.deleteIfExists(path);
 152         } catch (IOException ioExp) {
 153             throw new RuntimeException(ioExp);
 154         }
 155     }
 156 
 157     protected static void deleteDir(Path path) {
 158         try {
 159             Files.walkFileTree(path, new SimpleFileVisitor<>() {
 160                 @Override
 161                 public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
 162                     deleteFile(file);
 163                     return FileVisitResult.CONTINUE;
 164                 }
 165 
 166                 @Override
 167                 public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
 168                     deleteFile(dir);
 169                     return FileVisitResult.CONTINUE;
 170                 }
 171             });
 172         } catch (IOException ioExp) {
 173             throw new RuntimeException(ioExp);
 174         }
 175     }
 176 
 177     protected static Loader classLoader(Path... paths) {
 178         try {
 179             URL[] urls = new URL[paths.length];
 180             for (int i = 0; i < paths.length; i++) {
 181                 urls[i] = paths[i].toUri().toURL();
 182             }
 183             URLClassLoader ucl = new URLClassLoader(urls, null);
 184             return new Loader(ucl);
 185         } catch (RuntimeException re) {
 186             throw re;
 187         } catch (Exception e) {
 188             throw new RuntimeException(e);
 189         }
 190     }
 191 
 192     protected static Field findField(Class<?> cls, String name) {
 193         try {
 194             return cls.getField(name);
 195         } catch (Exception e) {
 196             System.err.println(e);
 197             return null;
 198         }
 199     }
 200 
 201     protected static Method findMethod(Class<?> cls, String name, Class<?>... argTypes) {
 202         try {
 203             return cls.getMethod(name, argTypes);
 204         } catch (Exception e) {
 205             System.err.println(e);
 206             return null;
 207         }
 208     }
 209 
 210     protected static Method findStructFieldGet(Class<?> cls, String name) {
 211         return findMethod(cls, name + "$get");
 212     }
 213 
 214     protected static Method findStructFieldSet(Class<?> cls, String name, Class<?> type) {
 215         return findMethod(cls, name + "$set", type);
 216     }
 217 
 218     protected static Method findStructFieldPointerGet(Class<?> cls, String name) {
 219         return findMethod(cls, name + "$ptr");
 220     }
 221 
 222     protected static Method findGlobalVariableGet(Class<?> cls, String name) {
 223         return findMethod(cls, name + "$get");
 224     }
 225 
 226     protected static Method findGlobalVariableSet(Class<?> cls, String name, Class<?> type) {
 227         return findMethod(cls, name + "$set", type);
 228     }
 229 
 230     protected static Method findGlobalVariablePointerGet(Class<?> cls, String name) {
 231         return findMethod(cls, name + "$ptr");
 232     }
 233 
 234     protected static Method findEnumConstGet(Class<?> cls, String name) {
 235         return findMethod(cls, name);
 236     }
 237 
 238     protected static Method findFirstMethod(Class<?> cls, String name) {
 239         try {
 240             for (Method m : cls.getMethods()) {
 241                 if (name.equals(m.getName())) {
 242                     return m;
 243                 }
 244             }
 245             return null;
 246         } catch (Exception e) {
 247             System.err.println(e);
 248             return null;
 249         }
 250     }
 251 
 252     protected Field checkIntField(Class<?> cls, String name, int value) {
 253         Field field = findField(cls, name);
 254         assertNotNull(field);
 255         assertEquals(field.getType(), int.class);
 256         try {
 257             assertEquals((int)field.get(null), value);
 258         } catch (Exception exp) {
 259             System.err.println(exp);
 260             assertTrue(false, "should not reach here");
 261         }
 262         return field;
 263     }
 264 
 265     protected Class<?> findClass(Class<?>[] clz, String name) {
 266         for (Class<?> cls: clz) {
 267             if (cls.getSimpleName().equals(name)) {
 268                 return cls;
 269             }
 270         }
 271         return null;
 272     }
 273 
 274     protected Method checkMethod(Class<?> cls, String name, Class<?> returnType, Class<?>... args) {
 275         try {
 276             Method m = cls.getDeclaredMethod(name, args);
 277             assertTrue(m.getReturnType() == returnType);
 278             return m;
 279         } catch (NoSuchMethodException nsme) {
 280             fail("Expect method " + name);
 281         }
 282         return null;
 283     }
 284 
 285     protected static class Loader implements AutoCloseable {
 286 
 287         private final URLClassLoader loader;
 288 
 289         public Loader(URLClassLoader loader) {
 290             this.loader = loader;
 291         }
 292 
 293         public Class<?> loadClass(String className) {
 294             try {
 295                 return Class.forName(className, false, loader);
 296             } catch (ClassNotFoundException e) {
 297                 // return null so caller can check if class loading
 298                 // was successful with assertNotNull/assertNull
 299                 return null;
 300             }
 301         }
 302 
 303         @Override
 304         public void close() {
 305             try {
 306                 loader.close();
 307             } catch (IOException e) {
 308                 throw new RuntimeException(e);
 309             }
 310         }
 311     }
 312 }
--- EOF ---