test/com/facebook/buck/java/abi/MirrorTest.java - buck - Git at Google

 /*
  * Copyright 2014-present Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may
  * not use this file except in compliance with the License. You may obtain
  * a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations
  * under the License.
  */

 package com.facebook.buck.java.abi;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;

 import com.facebook.buck.io.ProjectFilesystem;
 import com.facebook.buck.zip.Unzip;
 import com.google.common.base.Joiner;
 import com.google.common.collect.FluentIterable;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Lists;
 import com.google.common.io.ByteStreams;

 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.tree.AnnotationNode;
 import org.objectweb.asm.tree.ClassNode;
 import org.objectweb.asm.tree.FieldNode;
 import org.objectweb.asm.tree.MethodNode;

 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.FileVisitResult;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.SimpleFileVisitor;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.List;
 import java.util.SortedSet;
 import java.util.jar.JarOutputStream;
 import java.util.zip.ZipEntry;

 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
 import javax.tools.StandardJavaFileManager;
 import javax.tools.ToolProvider;


 public class MirrorTest {

   private static final ImmutableSortedSet<Path> EMPTY_CLASSPATH = ImmutableSortedSet.of();

   @Rule
   public TemporaryFolder temp = new TemporaryFolder();

   private ProjectFilesystem filesystem;
   private Path stubJar;

   @Before
   public void createStubJar() throws IOException {
     File out = temp.newFolder();
     filesystem = new ProjectFilesystem(out.toPath());
     stubJar = Paths.get("stub.jar");
   }

   @Test
   public void emptyClass() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         "package com.example.buck; public class A {}");

     new StubJar(jar).writeTo(filesystem, stubJar);

     // Verify that the stub jar works by compiling some code that depends on A.
     compileToJar(
         ImmutableSortedSet.of(stubJar),
         "B.java",
         "package com.example.buck; public class B extends A {}");
   }

   @Test
   public void emptyClassWithAnnotation() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         "package com.example.buck; @Deprecated public class A {}");

     new StubJar(jar).writeTo(filesystem, stubJar);

     // Examine the jar to see if the "A" class is deprecated.
     ClassNode classNode = readClass(stubJar, "com/example/buck/A.class").getClassNode();
     assertNotEquals(0, classNode.access & Opcodes.ACC_DEPRECATED);
   }

   @Test
   public void classWithTwoMethods() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(ImmutableList.of(
             "package com.example.buck;",
             "public class A {",
             "  public String toString() { return null; }",
             "  public void eatCake() {}",
             "}")));

     new StubJar(jar).writeTo(filesystem, stubJar);

     // Verify that both methods are present and given in alphabetical order.
     ClassNode classNode = readClass(stubJar, "com/example/buck/A.class").getClassNode();
     List<MethodNode> methods = classNode.methods;
     // Index 0 is the <init> method. Skip that.
     assertEquals("eatCake", methods.get(1).name);
     assertEquals("toString", methods.get(2).name);
   }

   @Test
   public void genericClassSignaturesShouldBePreserved() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A<T> {",
                 "  public T get(String key) { return null; }",
                 "}"
             )));

     // With generic classes, there are typically two interesting things we want to keep an eye on.
     // First is the "descriptor", which is the signature of the method with type erasure complete.
     // Optionally, compilers (and the OpenJDK, Oracle and Eclipse compilers all do this) can also
     // include a "signature", which is the signature of the method before type erasure. See
     // http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3 for more.
     AbiClass original = readClass(jar, "com/example/buck/A.class");
     String classSig = original.getClassNode().signature;
     MethodNode originalGet = original.findMethod("get");

     new StubJar(jar).writeTo(filesystem, stubJar);

     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
     assertEquals(classSig, stubbed.getClassNode().signature);

     MethodNode stubbedGet = stubbed.findMethod("get");
     assertMethodEquals(originalGet, stubbedGet);
   }

   @Test
   public void shouldIgnorePrivateMethods() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  private void privateMethod() {}",
                 "  void packageMethod() {}",
                 "  protected void protectedMethod() {}",
                 "  public void publicMethod() {}",
                 "}"
             )));

     new StubJar(jar).writeTo(filesystem, stubJar);

     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
     for (MethodNode method : stubbed.getClassNode().methods) {
       assertFalse(method.name.contains("private"));
     }
   }

   @Test
   public void shouldPreserveAField() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  protected String protectedField;",
                 "}"
             )));

     new StubJar(jar).writeTo(filesystem, stubJar);

     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
     FieldNode field = stubbed.findField("protectedField");
     assertEquals("protectedField", field.name);
     assertTrue((field.access & Opcodes.ACC_PROTECTED) > 0);
   }

   @Test
   public void shouldIgnorePrivateFields() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  private String privateField;",
                 "}"
             )));

     new StubJar(jar).writeTo(filesystem, stubJar);

     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
     assertEquals(0, stubbed.getClassNode().fields.size());
   }

   @Test
   public void shouldPreserveGenericTypesOnFields() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A<T> {",
                 "  public T theField;",
                 "}")));

     new StubJar(jar).writeTo(filesystem, stubJar);

     AbiClass original = readClass(jar, "com/example/buck/A.class");
     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");

     FieldNode originalField = original.findField("theField");
     FieldNode stubbedField = stubbed.findField("theField");

     assertFieldEquals(originalField, stubbedField);
   }

   @Test
   public void shouldPreserveGenericTypesOnMethods() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A<T> {",
                 "  public T get(String key) { return null; }",
                 "  public <X extends Comparable<T>> X compareWith(T other) { return null; }",
                 "}")));

     new StubJar(jar).writeTo(filesystem, stubJar);

     AbiClass original = readClass(jar, "com/example/buck/A.class");
     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");

     MethodNode originalGet = original.findMethod("get");
     MethodNode stubbedGet = stubbed.findMethod("get");

     assertEquals(originalGet.signature, stubbedGet.signature);
     assertEquals(originalGet.desc, stubbedGet.desc);

     MethodNode originalCompare = original.findMethod("compareWith");
     MethodNode stubbedCompare = stubbed.findMethod("compareWith");

     assertEquals(originalCompare.signature, stubbedCompare.signature);
     assertEquals(originalCompare.desc, stubbedCompare.desc);
   }

   @Test
   public void preservesAnnotationsOnMethods() throws IOException {
     Path annotations = buildAnnotationJar();
     Path jar = compileToJar(
         ImmutableSortedSet.of(annotations),
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  @Foo",
                 "  public void cheese(String key) {}",
                 "}")));

     new StubJar(jar).writeTo(filesystem, stubJar);

     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
     MethodNode method = stubbed.findMethod("cheese");

     List<AnnotationNode> seen = method.visibleAnnotations;
     assertEquals(1, seen.size());
     assertEquals("Lcom/example/buck/Foo;", seen.get(0).desc);
   }

   @Test
   public void preservesAnnotationsOnFields() throws IOException {
     Path annotations = buildAnnotationJar();
     Path jar = compileToJar(
         ImmutableSortedSet.of(annotations),
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  @Foo",
                 "  public String name;",
                 "}")));

     new StubJar(jar).writeTo(filesystem, stubJar);

     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
     FieldNode field = stubbed.findField("name");

     List<AnnotationNode> seen = field.visibleAnnotations;
     assertEquals(1, seen.size());
     assertEquals("Lcom/example/buck/Foo;", seen.get(0).desc);
   }

   @Test
   public void preservesAnnotationsOnParameters() throws IOException {
     Path annotations = buildAnnotationJar();
     Path jar = compileToJar(
         ImmutableSortedSet.of(annotations),
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  public void peynir(@Foo String very, int tasty) {}",
                 "}")));

     new StubJar(jar).writeTo(filesystem, stubJar);

     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
     MethodNode method = stubbed.findMethod("peynir");

     List<AnnotationNode>[] parameterAnnotations = method.visibleParameterAnnotations;
     assertEquals(2, parameterAnnotations.length);
   }

   @Test
   public void stubsInnerClasses() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  public class B {",
                 "    public int count;",
                 "    public void foo() {}",
                 "  }",
                 "}"
             )));

     new StubJar(jar).writeTo(filesystem, stubJar);

     AbiClass original = readClass(jar, "com/example/buck/A$B.class");
     AbiClass stubbed = readClass(stubJar, "com/example/buck/A$B.class");

     MethodNode originalFoo = original.findMethod("foo");
     MethodNode stubbedFoo = stubbed.findMethod("foo");
     assertMethodEquals(originalFoo, stubbedFoo);

     FieldNode originalCount = original.findField("count");
     FieldNode stubbedCount = stubbed.findField("count");
     assertFieldEquals(originalCount, stubbedCount);
   }

   @Test
   public void abiSafeChangesResultInTheSameOutputJar() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  protected final static int count = 42;",
                 "  public String getGreeting() { return \"hello\"; }",
                 "  Class<?> clazz;",
                 "  public int other;",
                 "}"
             )));

     new StubJar(jar).writeTo(filesystem, stubJar);
     String originalHash = filesystem.computeSha1(stubJar);

     Path jar2 = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  Class<?> clazz = String.class;",
                 "  public String getGreeting() { return \"merhaba\"; }",
                 "  protected final static int count = 42;",
                 "  public int other = 32;",
                 "}"
             )));
     filesystem.deleteFileAtPath(stubJar);
     new StubJar(jar2).writeTo(filesystem, stubJar);
     String secondHash = filesystem.computeSha1(stubJar);

     assertEquals(originalHash, secondHash);
   }

   @Test
   public void shouldIncludeStaticFields() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  public static String foo;",
                 "  public final static int count = 42;",
                 "  protected static void method() {}",
                 "}")));

     new StubJar(jar).writeTo(filesystem, stubJar);
     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");

     stubbed.findMethod("method");  // Presence is enough
     stubbed.findField("foo");  // Presence is enough
     FieldNode count = stubbed.findField("count");
     assertEquals(42, count.value);
   }

   @Test
   public void innerClassesInStubsCanBeCompiledAgainst() throws IOException {
     Path original = compileToJar(
         EMPTY_CLASSPATH,
         "Outer.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class Outer {",
                 "  public class Inner {",
                 "    public String getGreeting() { return \"hola\"; }",
                 "  }",
                 "}")));

     new StubJar(original).writeTo(filesystem, stubJar);

     compileToJar(
         ImmutableSortedSet.of(stubJar),
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck2;",      // Note: different package
                 "import com.example.buck.Outer;",  // Inner class becomes available
                 "public class A {",
                 "  private Outer.Inner field;",    // Reference the inner class
                 "}")));
   }

   @Test
   public void shouldPreserveSynchronizedKeywordOnMethods() throws IOException {
     Path original = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  public synchronized void doMagic() {}",
                 "}")));

     new StubJar(original).writeTo(filesystem, stubJar);

     AbiClass stub = readClass(stubJar, "com/example/buck/A.class");
     MethodNode magic = stub.findMethod("doMagic");
     assertTrue((magic.access & Opcodes.ACC_SYNCHRONIZED) > 0);
   }

   @Test
   public void shouldKeepMultipleFieldsWithSameDescValue() throws IOException {
     Path original = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  public static final A SEVERE = new A();",
                 "  public static final A NOT_SEVERE = new A();",
                 "  public static final A QUITE_MILD = new A();",
                 "}")));

     new StubJar(original).writeTo(filesystem, stubJar);

     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
     stubbed.findField("SEVERE");
     stubbed.findField("NOT_SEVERE");
     stubbed.findField("QUITE_MILD");
   }

   @Test
   public void stubJarIsEquallyAtHomeWalkingADirectoryOfClassFiles() throws IOException {
     Path jar = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on("\n").join(
             ImmutableList.of(
                 "package com.example.buck;",
                 "public class A {",
                 "  public String toString() { return null; }",
                 "  public void eatCake() {}",
                 "}")));

     Path classDir = temp.newFolder().toPath();
     Unzip.extractZipFile(jar, classDir, true);

     new StubJar(classDir).writeTo(filesystem, stubJar);

     // Verify that both methods are present and given in alphabetical order.
     AbiClass classNode = readClass(stubJar, "com/example/buck/A.class");
     List<MethodNode> methods = classNode.getClassNode().methods;
     // Index 0 is the <init> method. Skip that.
     assertEquals("eatCake", methods.get(1).name);
     assertEquals("toString", methods.get(2).name);
   }

   @Test
   public void shouldIncludeBridgeMethods() throws IOException {
     Path original = compileToJar(
         EMPTY_CLASSPATH,
         "A.java",
         Joiner.on('\n').join(ImmutableList.of(
                 "package com.example.buck;",
                 "public class A implements Comparable<A> {",
                 "  public int compareTo(A other) {",
                 "    return 0;",
                 "  }",
                 "}")));

     new StubJar(original).writeTo(filesystem, stubJar);

     AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
     int count = 0;
     for (MethodNode method : stubbed.getClassNode().methods) {
       if ("compareTo".equals(method.name)) {
         count++;
       }
     }
     // One for the generics method, one for the bridge method from Comparable
     assertEquals(2, count);
   }

   private Path compileToJar(
       SortedSet<Path> classpath,
       String fileName,
       String source) throws IOException {
     File inputs = temp.newFolder();

     File file = new File(inputs, fileName);

     Files.write(file.toPath(), source.getBytes(StandardCharsets.UTF_8));

     JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
     StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
     Iterable<? extends JavaFileObject> sourceObjects =
         fileManager.getJavaFileObjectsFromFiles(ImmutableSet.of(file));

     final File outputDir = temp.newFolder();
     List<String> args = Lists.newArrayList("-g", "-d", outputDir.getAbsolutePath());

     if (!classpath.isEmpty()) {
       args.add("-classpath");
       args.add(Joiner.on(File.pathSeparator).join(FluentIterable.from(classpath)
                   .transform(filesystem.getAbsolutifier())));
     }

     JavaCompiler.CompilationTask compilation =
         compiler.getTask(null, fileManager, null, args, null, sourceObjects);

     Boolean result = compilation.call();

     fileManager.close();
     assertNotNull(result);
     assertTrue(result);

     File jar = new File(outputDir, "output.jar");

     try (
         FileOutputStream fos = new FileOutputStream(jar);
         final JarOutputStream os = new JarOutputStream(fos)) {
       SimpleFileVisitor<Path> visitor = new SimpleFileVisitor<Path>() {
         @Override
         public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
           if (file.getFileName().toString().endsWith(".class")) {
             ZipEntry entry = new ZipEntry(outputDir.toPath().relativize(file).toString());
             os.putNextEntry(entry);
             ByteStreams.copy(Files.newInputStream(file), os);
             os.closeEntry();
           }
           return FileVisitResult.CONTINUE;
         }
       };

       Files.walkFileTree(outputDir.toPath(), visitor);
     }

     return jar.toPath().toAbsolutePath();
   }

   private AbiClass readClass(Path pathToJar, String className) throws IOException {
     return AbiClass.extract(filesystem.getPathForRelativePath(pathToJar), className);
   }

   private Path buildAnnotationJar() throws IOException {
     return compileToJar(
         EMPTY_CLASSPATH,
         "Foo.java",
         Joiner.on("\n").join(ImmutableList.of(
             "package com.example.buck;",
             "import java.lang.annotation.*;",
             "import static java.lang.annotation.ElementType.*;",
             "@Retention(RetentionPolicy.RUNTIME)",
             "@Target(value={CONSTRUCTOR, FIELD, METHOD, PARAMETER, TYPE})",
             "public @interface Foo {}"
             )));
   }

   private void assertMethodEquals(MethodNode expected, MethodNode seen) {
     assertEquals(expected.access, seen.access);
     assertEquals(expected.desc, seen.desc);
     assertEquals(expected.signature, seen.signature);
   }

   private void assertFieldEquals(FieldNode expected, FieldNode seen) {
     assertEquals(expected.name, seen.name);
     assertEquals(expected.desc, seen.desc);
     assertEquals(expected.signature, seen.signature);
   }
 }
	/*
	* Copyright 2014-present Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may
	* not use this file except in compliance with the License. You may obtain
	* a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations
	* under the License.
	*/

	package com.facebook.buck.java.abi;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertNotEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertTrue;

	import com.facebook.buck.io.ProjectFilesystem;
	import com.facebook.buck.zip.Unzip;
	import com.google.common.base.Joiner;
	import com.google.common.collect.FluentIterable;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.ImmutableSortedSet;
	import com.google.common.collect.Lists;
	import com.google.common.io.ByteStreams;

	import org.junit.Before;
	import org.junit.Rule;
	import org.junit.Test;
	import org.junit.rules.TemporaryFolder;
	import org.objectweb.asm.Opcodes;
	import org.objectweb.asm.tree.AnnotationNode;
	import org.objectweb.asm.tree.ClassNode;
	import org.objectweb.asm.tree.FieldNode;
	import org.objectweb.asm.tree.MethodNode;

	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.nio.charset.StandardCharsets;
	import java.nio.file.FileVisitResult;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.nio.file.SimpleFileVisitor;
	import java.nio.file.attribute.BasicFileAttributes;
	import java.util.List;
	import java.util.SortedSet;
	import java.util.jar.JarOutputStream;
	import java.util.zip.ZipEntry;

	import javax.tools.JavaCompiler;
	import javax.tools.JavaFileObject;
	import javax.tools.StandardJavaFileManager;
	import javax.tools.ToolProvider;


	public class MirrorTest {

	private static final ImmutableSortedSet<Path> EMPTY_CLASSPATH = ImmutableSortedSet.of();

	@Rule
	public TemporaryFolder temp = new TemporaryFolder();

	private ProjectFilesystem filesystem;
	private Path stubJar;

	@Before
	public void createStubJar() throws IOException {
	File out = temp.newFolder();
	filesystem = new ProjectFilesystem(out.toPath());
	stubJar = Paths.get("stub.jar");
	}

	@Test
	public void emptyClass() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	"package com.example.buck; public class A {}");

	new StubJar(jar).writeTo(filesystem, stubJar);

	// Verify that the stub jar works by compiling some code that depends on A.
	compileToJar(
	ImmutableSortedSet.of(stubJar),
	"B.java",
	"package com.example.buck; public class B extends A {}");
	}

	@Test
	public void emptyClassWithAnnotation() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	"package com.example.buck; @Deprecated public class A {}");

	new StubJar(jar).writeTo(filesystem, stubJar);

	// Examine the jar to see if the "A" class is deprecated.
	ClassNode classNode = readClass(stubJar, "com/example/buck/A.class").getClassNode();
	assertNotEquals(0, classNode.access & Opcodes.ACC_DEPRECATED);
	}

	@Test
	public void classWithTwoMethods() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" public String toString() { return null; }",
	" public void eatCake() {}",
	"}")));

	new StubJar(jar).writeTo(filesystem, stubJar);

	// Verify that both methods are present and given in alphabetical order.
	ClassNode classNode = readClass(stubJar, "com/example/buck/A.class").getClassNode();
	List<MethodNode> methods = classNode.methods;
	// Index 0 is the <init> method. Skip that.
	assertEquals("eatCake", methods.get(1).name);
	assertEquals("toString", methods.get(2).name);
	}

	@Test
	public void genericClassSignaturesShouldBePreserved() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A<T> {",
	" public T get(String key) { return null; }",
	"}"
	)));

	// With generic classes, there are typically two interesting things we want to keep an eye on.
	// First is the "descriptor", which is the signature of the method with type erasure complete.
	// Optionally, compilers (and the OpenJDK, Oracle and Eclipse compilers all do this) can also
	// include a "signature", which is the signature of the method before type erasure. See
	// http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3 for more.
	AbiClass original = readClass(jar, "com/example/buck/A.class");
	String classSig = original.getClassNode().signature;
	MethodNode originalGet = original.findMethod("get");

	new StubJar(jar).writeTo(filesystem, stubJar);

	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
	assertEquals(classSig, stubbed.getClassNode().signature);

	MethodNode stubbedGet = stubbed.findMethod("get");
	assertMethodEquals(originalGet, stubbedGet);
	}

	@Test
	public void shouldIgnorePrivateMethods() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" private void privateMethod() {}",
	" void packageMethod() {}",
	" protected void protectedMethod() {}",
	" public void publicMethod() {}",
	"}"
	)));

	new StubJar(jar).writeTo(filesystem, stubJar);

	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
	for (MethodNode method : stubbed.getClassNode().methods) {
	assertFalse(method.name.contains("private"));
	}
	}

	@Test
	public void shouldPreserveAField() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" protected String protectedField;",
	"}"
	)));

	new StubJar(jar).writeTo(filesystem, stubJar);

	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
	FieldNode field = stubbed.findField("protectedField");
	assertEquals("protectedField", field.name);
	assertTrue((field.access & Opcodes.ACC_PROTECTED) > 0);
	}

	@Test
	public void shouldIgnorePrivateFields() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" private String privateField;",
	"}"
	)));

	new StubJar(jar).writeTo(filesystem, stubJar);

	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
	assertEquals(0, stubbed.getClassNode().fields.size());
	}

	@Test
	public void shouldPreserveGenericTypesOnFields() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A<T> {",
	" public T theField;",
	"}")));

	new StubJar(jar).writeTo(filesystem, stubJar);

	AbiClass original = readClass(jar, "com/example/buck/A.class");
	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");

	FieldNode originalField = original.findField("theField");
	FieldNode stubbedField = stubbed.findField("theField");

	assertFieldEquals(originalField, stubbedField);
	}

	@Test
	public void shouldPreserveGenericTypesOnMethods() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A<T> {",
	" public T get(String key) { return null; }",
	" public <X extends Comparable<T>> X compareWith(T other) { return null; }",
	"}")));

	new StubJar(jar).writeTo(filesystem, stubJar);

	AbiClass original = readClass(jar, "com/example/buck/A.class");
	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");

	MethodNode originalGet = original.findMethod("get");
	MethodNode stubbedGet = stubbed.findMethod("get");

	assertEquals(originalGet.signature, stubbedGet.signature);
	assertEquals(originalGet.desc, stubbedGet.desc);

	MethodNode originalCompare = original.findMethod("compareWith");
	MethodNode stubbedCompare = stubbed.findMethod("compareWith");

	assertEquals(originalCompare.signature, stubbedCompare.signature);
	assertEquals(originalCompare.desc, stubbedCompare.desc);
	}

	@Test
	public void preservesAnnotationsOnMethods() throws IOException {
	Path annotations = buildAnnotationJar();
	Path jar = compileToJar(
	ImmutableSortedSet.of(annotations),
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" @Foo",
	" public void cheese(String key) {}",
	"}")));

	new StubJar(jar).writeTo(filesystem, stubJar);

	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
	MethodNode method = stubbed.findMethod("cheese");

	List<AnnotationNode> seen = method.visibleAnnotations;
	assertEquals(1, seen.size());
	assertEquals("Lcom/example/buck/Foo;", seen.get(0).desc);
	}

	@Test
	public void preservesAnnotationsOnFields() throws IOException {
	Path annotations = buildAnnotationJar();
	Path jar = compileToJar(
	ImmutableSortedSet.of(annotations),
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" @Foo",
	" public String name;",
	"}")));

	new StubJar(jar).writeTo(filesystem, stubJar);

	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
	FieldNode field = stubbed.findField("name");

	List<AnnotationNode> seen = field.visibleAnnotations;
	assertEquals(1, seen.size());
	assertEquals("Lcom/example/buck/Foo;", seen.get(0).desc);
	}

	@Test
	public void preservesAnnotationsOnParameters() throws IOException {
	Path annotations = buildAnnotationJar();
	Path jar = compileToJar(
	ImmutableSortedSet.of(annotations),
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" public void peynir(@Foo String very, int tasty) {}",
	"}")));

	new StubJar(jar).writeTo(filesystem, stubJar);

	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
	MethodNode method = stubbed.findMethod("peynir");

	List<AnnotationNode>[] parameterAnnotations = method.visibleParameterAnnotations;
	assertEquals(2, parameterAnnotations.length);
	}

	@Test
	public void stubsInnerClasses() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" public class B {",
	" public int count;",
	" public void foo() {}",
	" }",
	"}"
	)));

	new StubJar(jar).writeTo(filesystem, stubJar);

	AbiClass original = readClass(jar, "com/example/buck/A$B.class");
	AbiClass stubbed = readClass(stubJar, "com/example/buck/A$B.class");

	MethodNode originalFoo = original.findMethod("foo");
	MethodNode stubbedFoo = stubbed.findMethod("foo");
	assertMethodEquals(originalFoo, stubbedFoo);

	FieldNode originalCount = original.findField("count");
	FieldNode stubbedCount = stubbed.findField("count");
	assertFieldEquals(originalCount, stubbedCount);
	}

	@Test
	public void abiSafeChangesResultInTheSameOutputJar() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" protected final static int count = 42;",
	" public String getGreeting() { return \"hello\"; }",
	" Class<?> clazz;",
	" public int other;",
	"}"
	)));

	new StubJar(jar).writeTo(filesystem, stubJar);
	String originalHash = filesystem.computeSha1(stubJar);

	Path jar2 = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" Class<?> clazz = String.class;",
	" public String getGreeting() { return \"merhaba\"; }",
	" protected final static int count = 42;",
	" public int other = 32;",
	"}"
	)));
	filesystem.deleteFileAtPath(stubJar);
	new StubJar(jar2).writeTo(filesystem, stubJar);
	String secondHash = filesystem.computeSha1(stubJar);

	assertEquals(originalHash, secondHash);
	}

	@Test
	public void shouldIncludeStaticFields() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" public static String foo;",
	" public final static int count = 42;",
	" protected static void method() {}",
	"}")));

	new StubJar(jar).writeTo(filesystem, stubJar);
	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");

	stubbed.findMethod("method"); // Presence is enough
	stubbed.findField("foo"); // Presence is enough
	FieldNode count = stubbed.findField("count");
	assertEquals(42, count.value);
	}

	@Test
	public void innerClassesInStubsCanBeCompiledAgainst() throws IOException {
	Path original = compileToJar(
	EMPTY_CLASSPATH,
	"Outer.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class Outer {",
	" public class Inner {",
	" public String getGreeting() { return \"hola\"; }",
	" }",
	"}")));

	new StubJar(original).writeTo(filesystem, stubJar);

	compileToJar(
	ImmutableSortedSet.of(stubJar),
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck2;", // Note: different package
	"import com.example.buck.Outer;", // Inner class becomes available
	"public class A {",
	" private Outer.Inner field;", // Reference the inner class
	"}")));
	}

	@Test
	public void shouldPreserveSynchronizedKeywordOnMethods() throws IOException {
	Path original = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" public synchronized void doMagic() {}",
	"}")));

	new StubJar(original).writeTo(filesystem, stubJar);

	AbiClass stub = readClass(stubJar, "com/example/buck/A.class");
	MethodNode magic = stub.findMethod("doMagic");
	assertTrue((magic.access & Opcodes.ACC_SYNCHRONIZED) > 0);
	}

	@Test
	public void shouldKeepMultipleFieldsWithSameDescValue() throws IOException {
	Path original = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" public static final A SEVERE = new A();",
	" public static final A NOT_SEVERE = new A();",
	" public static final A QUITE_MILD = new A();",
	"}")));

	new StubJar(original).writeTo(filesystem, stubJar);

	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
	stubbed.findField("SEVERE");
	stubbed.findField("NOT_SEVERE");
	stubbed.findField("QUITE_MILD");
	}

	@Test
	public void stubJarIsEquallyAtHomeWalkingADirectoryOfClassFiles() throws IOException {
	Path jar = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on("\n").join(
	ImmutableList.of(
	"package com.example.buck;",
	"public class A {",
	" public String toString() { return null; }",
	" public void eatCake() {}",
	"}")));

	Path classDir = temp.newFolder().toPath();
	Unzip.extractZipFile(jar, classDir, true);

	new StubJar(classDir).writeTo(filesystem, stubJar);

	// Verify that both methods are present and given in alphabetical order.
	AbiClass classNode = readClass(stubJar, "com/example/buck/A.class");
	List<MethodNode> methods = classNode.getClassNode().methods;
	// Index 0 is the <init> method. Skip that.
	assertEquals("eatCake", methods.get(1).name);
	assertEquals("toString", methods.get(2).name);
	}

	@Test
	public void shouldIncludeBridgeMethods() throws IOException {
	Path original = compileToJar(
	EMPTY_CLASSPATH,
	"A.java",
	Joiner.on('\n').join(ImmutableList.of(
	"package com.example.buck;",
	"public class A implements Comparable<A> {",
	" public int compareTo(A other) {",
	" return 0;",
	" }",
	"}")));

	new StubJar(original).writeTo(filesystem, stubJar);

	AbiClass stubbed = readClass(stubJar, "com/example/buck/A.class");
	int count = 0;
	for (MethodNode method : stubbed.getClassNode().methods) {
	if ("compareTo".equals(method.name)) {
	count++;
	}
	}
	// One for the generics method, one for the bridge method from Comparable
	assertEquals(2, count);
	}

	private Path compileToJar(
	SortedSet<Path> classpath,
	String fileName,
	String source) throws IOException {
	File inputs = temp.newFolder();

	File file = new File(inputs, fileName);

	Files.write(file.toPath(), source.getBytes(StandardCharsets.UTF_8));

	JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
	StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
	Iterable<? extends JavaFileObject> sourceObjects =
	fileManager.getJavaFileObjectsFromFiles(ImmutableSet.of(file));

	final File outputDir = temp.newFolder();
	List<String> args = Lists.newArrayList("-g", "-d", outputDir.getAbsolutePath());

	if (!classpath.isEmpty()) {
	args.add("-classpath");
	args.add(Joiner.on(File.pathSeparator).join(FluentIterable.from(classpath)
	.transform(filesystem.getAbsolutifier())));
	}

	JavaCompiler.CompilationTask compilation =
	compiler.getTask(null, fileManager, null, args, null, sourceObjects);

	Boolean result = compilation.call();

	fileManager.close();
	assertNotNull(result);
	assertTrue(result);

	File jar = new File(outputDir, "output.jar");

	try (
	FileOutputStream fos = new FileOutputStream(jar);
	final JarOutputStream os = new JarOutputStream(fos)) {
	SimpleFileVisitor<Path> visitor = new SimpleFileVisitor<Path>() {
	@Override
	public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
	if (file.getFileName().toString().endsWith(".class")) {
	ZipEntry entry = new ZipEntry(outputDir.toPath().relativize(file).toString());
	os.putNextEntry(entry);
	ByteStreams.copy(Files.newInputStream(file), os);
	os.closeEntry();
	}
	return FileVisitResult.CONTINUE;
	}
	};

	Files.walkFileTree(outputDir.toPath(), visitor);
	}

	return jar.toPath().toAbsolutePath();
	}

	private AbiClass readClass(Path pathToJar, String className) throws IOException {
	return AbiClass.extract(filesystem.getPathForRelativePath(pathToJar), className);
	}

	private Path buildAnnotationJar() throws IOException {
	return compileToJar(
	EMPTY_CLASSPATH,
	"Foo.java",
	Joiner.on("\n").join(ImmutableList.of(
	"package com.example.buck;",
	"import java.lang.annotation.*;",
	"import static java.lang.annotation.ElementType.*;",
	"@Retention(RetentionPolicy.RUNTIME)",
	"@Target(value={CONSTRUCTOR, FIELD, METHOD, PARAMETER, TYPE})",
	"public @interface Foo {}"
	)));
	}

	private void assertMethodEquals(MethodNode expected, MethodNode seen) {
	assertEquals(expected.access, seen.access);
	assertEquals(expected.desc, seen.desc);
	assertEquals(expected.signature, seen.signature);
	}

	private void assertFieldEquals(FieldNode expected, FieldNode seen) {
	assertEquals(expected.name, seen.name);
	assertEquals(expected.desc, seen.desc);
	assertEquals(expected.signature, seen.signature);
	}
	}