test/java/com/google/devtools/build/android/desugar/DefaultMethodClassFixerTest.java

// Copyright 2017 The Bazel Authors. All rights reserved.
//
// 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.google.devtools.build.android.desugar;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.truth.Truth.assertThat;
import static com.google.devtools.build.android.desugar.DefaultMethodClassFixer.InterfaceComparator.INSTANCE;

import com.google.common.collect.ImmutableList;
import com.google.common.io.Closer;
import com.google.devtools.build.android.desugar.Desugar.ThrowingClassLoader;
import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.TreeSet;
import java.util.concurrent.Callable;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.InsnNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;

/** Unit Test for {@link DefaultMethodClassFixer} */
@RunWith(JUnit4.class)
public class DefaultMethodClassFixerTest {

  private ClassReaderFactory classpathReader;
  private ClassReaderFactory bootclassPath;
  private ClassLoader classLoader;
  private Closer closer;

  @Before
  public void setup() throws IOException {
    closer = Closer.create();
    CoreLibraryRewriter rewriter = new CoreLibraryRewriter("");

    IndexedInputs indexedInputs =
        toIndexedInputs(closer, System.getProperty("DefaultMethodClassFixerTest.input"));
    IndexedInputs indexedClasspath =
        toIndexedInputs(closer, System.getProperty("DefaultMethodClassFixerTest.classpath"));
    IndexedInputs indexedBootclasspath =
        toIndexedInputs(closer, System.getProperty("DefaultMethodClassFixerTest.bootclasspath"));

    bootclassPath = new ClassReaderFactory(indexedBootclasspath, rewriter);
    IndexedInputs indexedClasspathAndInputFiles = indexedClasspath.withParent(indexedInputs);
    classpathReader = new ClassReaderFactory(indexedClasspathAndInputFiles, rewriter);
    ClassLoader bootclassloader =
        new HeaderClassLoader(indexedBootclasspath, rewriter, new ThrowingClassLoader());
    classLoader = new HeaderClassLoader(indexedClasspathAndInputFiles, rewriter, bootclassloader);
  }

  @After
  public void teardown() throws IOException {
    closer.close();
  }

  private static IndexedInputs toIndexedInputs(Closer closer, String stringPathList)
      throws IOException {
    final List<Path> pathList = readPathListFromString(stringPathList);
    return new IndexedInputs(Desugar.toRegisteredInputFileProvider(closer, pathList));
  }

  private static List<Path> readPathListFromString(String pathList) {
    return Arrays.stream(checkNotNull(pathList).split(File.pathSeparator))
        .map(Paths::get)
        .collect(ImmutableList.toImmutableList());
  }

  private byte[] desugar(String classname) {
    ClassReader reader = classpathReader.readIfKnown(classname);
    return desugar(reader);
  }

  private byte[] desugar(ClassReader reader) {
    ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
    DefaultMethodClassFixer fixer =
        new DefaultMethodClassFixer(
            writer,
            classpathReader,
            DependencyCollector.NoWriteCollectors.FAIL_ON_MISSING,
            bootclassPath,
            classLoader);
    reader.accept(fixer, 0);
    return writer.toByteArray();
  }

  private byte[] desugar(byte[] classContent) {
    ClassReader reader = new ClassReader(classContent);
    return desugar(reader);
  }

  @Test
  public void testDesugaringDirectImplementation() {
    byte[] desugaredClass =
        desugar(
            ("com.google.devtools.build.android.desugar.testdata.java8."
                    + "DefaultInterfaceMethodWithStaticInitializer$TestInterfaceSetOne$C")
                .replace('.', '/'));
    checkClinitForDefaultInterfaceMethodWithStaticInitializerTestInterfaceSetOneC(desugaredClass);

    byte[] desugaredClassAgain = desugar(desugaredClass);
    checkClinitForDefaultInterfaceMethodWithStaticInitializerTestInterfaceSetOneC(
        desugaredClassAgain);

    desugaredClassAgain = desugar(desugaredClassAgain);
    checkClinitForDefaultInterfaceMethodWithStaticInitializerTestInterfaceSetOneC(
        desugar(desugaredClassAgain));
  }

  private void checkClinitForDefaultInterfaceMethodWithStaticInitializerTestInterfaceSetOneC(
      byte[] classContent) {
    ClassReader reader = new ClassReader(classContent);
    reader.accept(
        new ClassVisitor(Opcodes.ASM5) {

          class ClinitMethod extends MethodNode {

            public ClinitMethod(
                int access, String name, String desc, String signature, String[] exceptions) {
              super(Opcodes.ASM5, access, name, desc, signature, exceptions);
            }
          }

          private ClinitMethod clinit;

          @Override
          public MethodVisitor visitMethod(
              int access, String name, String desc, String signature, String[] exceptions) {
            if ("<clinit>".equals(name)) {
              assertThat(clinit).isNull();
              clinit = new ClinitMethod(access, name, desc, signature, exceptions);
              return clinit;
            }
            return super.visitMethod(access, name, desc, signature, exceptions);
          }

          @Override
          public void visitEnd() {
            assertThat(clinit).isNotNull();
            assertThat(clinit.instructions.size()).isEqualTo(3);
            AbstractInsnNode instruction = clinit.instructions.getFirst();
            {
              assertThat(instruction).isInstanceOf(MethodInsnNode.class);
              MethodInsnNode field = (MethodInsnNode) instruction;
              assertThat(field.owner)
                  .isEqualTo(
                      "com/google/devtools/build/android/desugar/testdata/java8/"
                          + "DefaultInterfaceMethodWithStaticInitializer"
                          + "$TestInterfaceSetOne$I1$$CC");
              assertThat(field.name)
                  .isEqualTo(InterfaceDesugaring.COMPANION_METHOD_TO_TRIGGER_INTERFACE_CLINIT_NAME);
              assertThat(field.desc)
                  .isEqualTo(InterfaceDesugaring.COMPANION_METHOD_TO_TRIGGER_INTERFACE_CLINIT_DESC);
            }
            {
              instruction = instruction.getNext();
              assertThat(instruction).isInstanceOf(MethodInsnNode.class);
              MethodInsnNode field = (MethodInsnNode) instruction;
              assertThat(field.owner)
                  .isEqualTo(
                      "com/google/devtools/build/android/desugar/testdata/java8/"
                          + "DefaultInterfaceMethodWithStaticInitializer"
                          + "$TestInterfaceSetOne$I2$$CC");
              assertThat(field.name)
                  .isEqualTo(InterfaceDesugaring.COMPANION_METHOD_TO_TRIGGER_INTERFACE_CLINIT_NAME);
              assertThat(field.desc)
                  .isEqualTo(InterfaceDesugaring.COMPANION_METHOD_TO_TRIGGER_INTERFACE_CLINIT_DESC);
            }
            {
              instruction = instruction.getNext();
              assertThat(instruction).isInstanceOf(InsnNode.class);
              assertThat(instruction.getOpcode()).isEqualTo(Opcodes.RETURN);
            }
          }
        },
        0);
  }

  @Test
  public void testInterfaceComparator() {
    assertThat(INSTANCE.compare(Runnable.class, Runnable.class)).isEqualTo(0);
    assertThat(INSTANCE.compare(Runnable.class, MyRunnable1.class)).isEqualTo(1);
    assertThat(INSTANCE.compare(MyRunnable2.class, Runnable.class)).isEqualTo(-1);
    assertThat(INSTANCE.compare(MyRunnable3.class, Runnable.class)).isEqualTo(-1);
    assertThat(INSTANCE.compare(MyRunnable1.class, MyRunnable3.class)).isEqualTo(1);
    assertThat(INSTANCE.compare(MyRunnable3.class, MyRunnable2.class)).isEqualTo(-1);
    assertThat(INSTANCE.compare(MyRunnable2.class, MyRunnable1.class)).isGreaterThan(0);
    assertThat(INSTANCE.compare(Runnable.class, Serializable.class)).isGreaterThan(0);
    assertThat(INSTANCE.compare(Serializable.class, Runnable.class)).isLessThan(0);

    TreeSet<Class<?>> orderedSet = new TreeSet<>(INSTANCE);
    orderedSet.add(Serializable.class);
    orderedSet.add(Runnable.class);
    orderedSet.add(MyRunnable2.class);
    orderedSet.add(Callable.class);
    orderedSet.add(Serializable.class);
    orderedSet.add(MyRunnable1.class);
    orderedSet.add(MyRunnable3.class);
    assertThat(orderedSet)
        .containsExactly(
            MyRunnable3.class, // subtype before supertype(s)
            MyRunnable1.class,
            MyRunnable2.class,
            Serializable.class, // java... comes textually after com.google...
            Runnable.class,
            Callable.class)
        .inOrder();
  }

  private static interface MyRunnable1 extends Runnable {}

  private static interface MyRunnable2 extends Runnable {}

  private static interface MyRunnable3 extends MyRunnable1, MyRunnable2 {}
}