/*
* Copyright (C) 2010 The Project Lombok Authors.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package lombok.bytecode;
import static org.junit.Assert.*;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import javax.tools.Diagnostic;
import javax.tools.DiagnosticListener;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.ToolProvider;
import lombok.Lombok;
import org.junit.Test;
public class TestClassFileMetaData {
private static ClassFileMetaData foo = create(new File("test/bytecode/resource/Foo.java"));
private static ClassFileMetaData bar = create(new File("test/bytecode/resource/Bar.java"));
private static ClassFileMetaData baz = create(new File("test/bytecode/resource/Baz.java"));
private static ClassFileMetaData buux = create(new File("test/bytecode/resource/Buux.java"));
@Test
public void testGetClassName() {
assertTrue(foo.containsUtf8("Foo"));
assertEquals("Foo", foo.getClassName());
assertTrue(bar.containsUtf8("Bar"));
assertEquals("Bar", bar.getClassName());
assertTrue(baz.containsUtf8("Baz"));
assertEquals("Baz", baz.getClassName());
}
@Test
public void testGetSuperClassName() {
assertTrue(foo.containsUtf8("java/lang/Object"));
assertEquals("java/lang/Object", foo.getSuperClassName());
assertEquals("java/lang/Object", bar.getSuperClassName());
assertEquals("java/lang/Object", baz.getSuperClassName());
assertEquals("java/util/ArrayList", buux.getSuperClassName());
}
@Test
public void testUsesClass() {
assertTrue(foo.usesClass("java/lang/System"));
// assertTrue(foo.usesClass("java/lang/String"));
}
@Test
public void testUsesField() {
assertTrue(foo.usesField("java/lang/System", "out"));
}
@Test
public void testUsesMethodWithName() {
assertTrue(foo.usesMethod("java/io/PrintStream", "print"));
assertTrue(buux.usesMethod("java/util/ArrayList", "<init>"));
assertTrue(buux.usesMethod("java/util/ArrayList", "add"));
assertTrue(buux.usesMethod("Buux", "addSomething"));
}
@Test
public void testUsesMethodWithNameAndDescriptor() {
assertTrue(foo.usesMethod("java/io/PrintStream", "print", "(Ljava/lang/String;)V"));
assertTrue(buux.usesMethod("java/util/ArrayList", "<init>", "(I)V"));
assertTrue(buux.usesMethod("java/util/ArrayList", "add", "(Ljava/lang/Object;)Z"));
assertTrue(buux.usesMethod("Buux", "addSomething", "()V"));
}
@Test
public void testGetInterfaces() {
assertTrue(foo.containsUtf8("java/util/RandomAccess"));
List<String> fooInterfaces = foo.getInterfaces();
assertEquals(1, fooInterfaces.size());
assertEquals("java/util/RandomAccess", fooInterfaces.get(0));
assertTrue(bar.containsUtf8("java/util/RandomAccess"));
assertTrue(bar.containsUtf8("java/util/Map"));
List<String> barInterfaces = bar.getInterfaces();
assertEquals(2, barInterfaces.size());
assertEquals("java/util/RandomAccess", barInterfaces.get(0));
assertEquals("java/util/Map", barInterfaces.get(1));
}
@Test
public void testContainsStringConstant() {
assertTrue(foo.containsStringConstant("Eén"));
assertTrue(foo.containsStringConstant("TwoFour"));
assertTrue(buux.containsStringConstant("H\u3404l\0"));
assertFalse(foo.containsStringConstant("Seven"));
}
@Test
public void testContainsDouble() {
assertTrue(foo.containsDouble(1.23));
assertTrue(foo.containsDouble(Double.NaN));
assertTrue(foo.containsDouble(Double.POSITIVE_INFINITY));
assertTrue(foo.containsDouble(Double.NEGATIVE_INFINITY));
assertFalse(foo.containsDouble(1.0));
assertFalse(buux.containsDouble(1.0));
assertFalse(buux.containsDouble(Double.NaN));
assertFalse(buux.containsDouble(Double.POSITIVE_INFINITY));
assertFalse(buux.containsDouble(Double.NEGATIVE_INFINITY));
}
@Test
public void testContainsFloat() {
assertTrue(foo.containsFloat(1.23F));
assertTrue(foo.containsFloat(Float.NaN));
assertTrue(foo.containsFloat(Float.POSITIVE_INFINITY));
assertTrue(foo.containsFloat(Float.NEGATIVE_INFINITY));
assertFalse(foo.containsFloat(1.0F));
assertFalse(buux.containsFloat(1.0F));
assertFalse(buux.containsFloat(Float.NaN));
assertFalse(buux.containsFloat(Float.POSITIVE_INFINITY));
assertFalse(buux.containsFloat(Float.NEGATIVE_INFINITY));
}
@Test
public void testContainsInteger() {
assertTrue(foo.containsInteger(123));
assertFalse(foo.containsInteger(1));
assertFalse(buux.containsInteger(1));
}
@Test
public void testContainsLong() {
assertTrue(foo.containsLong(123));
assertTrue(foo.containsLong(0x1FFFFFFFFL));
assertFalse(foo.containsLong(1));
assertFalse(buux.containsLong(1));
}
private static ClassFileMetaData create(File file) {
return new ClassFileMetaData(compile(file));
}
static byte[] compile(File file) {
try {
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
File tempDir = getTempDir();
tempDir.mkdirs();
List<String> options = Arrays.asList("-proc:none", "-d", tempDir.getAbsolutePath());
StringWriter captureWarnings = new StringWriter();
final StringBuilder compilerErrors = new StringBuilder();
DiagnosticListener<JavaFileObject> diagnostics = new DiagnosticListener<JavaFileObject>() {
@Override public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
compilerErrors.append(diagnostic.toString()).append("\n");
}
};
CompilationTask task = compiler.getTask(captureWarnings, null, diagnostics, options, null, Collections.singleton(new ContentBasedJavaFileObject(file.getPath(), readFileAsString(file))));
Boolean taskResult = task.call();
assertTrue("Compilation task didn't succeed: \n<Warnings and Errors>\n" + compilerErrors.toString() + "\n</Warnings and Errors>", taskResult);
return PostCompilerApp.readFile(new File(tempDir, file.getName().replaceAll("\\.java$", ".class")));
} catch (Exception e) {
throw Lombok.sneakyThrow(e);
}
}
private static File getTempDir() {
String[] rawDirs = {
System.getProperty("java.io.tmpdir"),
"/tmp",
"C:\\Windows\\Temp"
};
for (String dir : rawDirs) {
if (dir == null) continue;
File f = new File(dir);
if (!f.isDirectory()) continue;
return new File(f, "lombok.bytecode-test");
}
return new File("./build/tmp");
}
static class ContentBasedJavaFileObject extends SimpleJavaFileObject {
private final String content;
protected ContentBasedJavaFileObject(String name, String content) {
super(new File(name).toURI(), Kind.SOURCE);
this.content = content;
}
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
return content;
}
}
private static String readFileAsString(File file) {
try {
FileInputStream in = new FileInputStream(file);
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(in, "UTF-8"));
StringWriter writer = new StringWriter();
String line = reader.readLine();
while(line != null) {
writer.append(line).append("\n");
line = reader.readLine();
}
reader.close();
writer.close();
return writer.toString();
} finally {
in.close();
}
} catch (Exception e) {
throw Lombok.sneakyThrow(e);
}
}
}