diff options
Diffstat (limited to 'jack-tests')
20 files changed, 1165 insertions, 118 deletions
diff --git a/jack-tests/src/com/android/jack/test/helper/CheckDexStructureTestHelper.java b/jack-tests/src/com/android/jack/test/helper/CheckDexStructureTestHelper.java index d00d367..296f371 100644 --- a/jack-tests/src/com/android/jack/test/helper/CheckDexStructureTestHelper.java +++ b/jack-tests/src/com/android/jack/test/helper/CheckDexStructureTestHelper.java @@ -48,13 +48,13 @@ public class CheckDexStructureTestHelper extends SourceToDexComparisonTestHelper @Override @Nonnull - public CheckDexStructureTestHelper setCandidateClasspath(@Nonnull File[] classpath) { + public CheckDexStructureTestHelper setCandidateClasspath(@Nonnull File... classpath) { return (CheckDexStructureTestHelper) super.setCandidateClasspath(classpath); } @Override @Nonnull - public CheckDexStructureTestHelper setReferenceClasspath(@Nonnull File[] classpath) { + public CheckDexStructureTestHelper setReferenceClasspath(@Nonnull File... classpath) { return (CheckDexStructureTestHelper) super.setReferenceClasspath(classpath); } diff --git a/jack-tests/src/com/android/jack/test/helper/JackDexMergerTestHelper.java b/jack-tests/src/com/android/jack/test/helper/JackDexMergerTestHelper.java index 5c2b17c..3b2dfea 100644 --- a/jack-tests/src/com/android/jack/test/helper/JackDexMergerTestHelper.java +++ b/jack-tests/src/com/android/jack/test/helper/JackDexMergerTestHelper.java @@ -18,7 +18,6 @@ package com.android.jack.test.helper; import com.android.jack.Options; import com.android.jack.backend.dex.rop.CodeItemBuilder; -import com.android.jack.test.comparator.Comparator; import com.android.jack.test.comparator.ComparatorComposite; import com.android.jack.test.comparator.ComparatorDex; import com.android.jack.test.comparator.ComparatorDexAnnotations; @@ -75,9 +74,7 @@ public class JackDexMergerTestHelper extends SourceToDexComparisonTestHelper { return toolchain; } - @Override - @Nonnull - public Comparator createDexFileComparator() { + public void compare() throws Exception { ComparatorDex comparatorDex = new ComparatorDex(candidateDex, refDex); comparatorDex.setWithDebugInfo(false); comparatorDex.setStrict(true); @@ -87,10 +84,6 @@ public class JackDexMergerTestHelper extends SourceToDexComparisonTestHelper { ComparatorDexAnnotations comparatorAnnotations = new ComparatorDexAnnotations(candidateDex, refDex); ComparatorDiff comparatorDiff = new ComparatorDiff(candidateDex, refDex); - return new ComparatorComposite(comparatorDex, comparatorAnnotations, comparatorDiff); - } - - public void compare() throws Exception { - runTest(createDexFileComparator()); + runTest(new ComparatorComposite(comparatorDex, comparatorAnnotations, comparatorDiff)); } } diff --git a/jack-tests/src/com/android/jack/test/helper/SourceToDexComparisonTestHelper.java b/jack-tests/src/com/android/jack/test/helper/SourceToDexComparisonTestHelper.java index 87db1be..2f78c17 100644 --- a/jack-tests/src/com/android/jack/test/helper/SourceToDexComparisonTestHelper.java +++ b/jack-tests/src/com/android/jack/test/helper/SourceToDexComparisonTestHelper.java @@ -16,10 +16,10 @@ package com.android.jack.test.helper; -import com.android.jack.test.comparator.Comparator; import com.android.jack.test.comparator.ComparatorDex; import com.android.jack.test.toolchain.AbstractTestTools; import com.android.jack.test.toolchain.AndroidToolchain; +import com.android.jack.test.toolchain.Toolchain.SourceLevel; import java.io.File; @@ -55,6 +55,9 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper private File[] proguardFlagFiles = new File[0]; @Nonnull + private SourceLevel sourceLevel = SourceLevel.JAVA_6; + + @Nonnull private AndroidToolchain candidateTestTools; @Nonnull private AndroidToolchain referenceTestTools; @@ -103,13 +106,13 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper } @Nonnull - public SourceToDexComparisonTestHelper setCandidateClasspath(@Nonnull File[] classpath) { + public SourceToDexComparisonTestHelper setCandidateClasspath(@Nonnull File... classpath) { candidateClasspath = classpath; return this; } @Nonnull - public SourceToDexComparisonTestHelper setReferenceClasspath(@Nonnull File[] classpath) { + public SourceToDexComparisonTestHelper setReferenceClasspath(@Nonnull File... classpath) { referenceClasspath = classpath; return this; } @@ -120,6 +123,10 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper return this; } + public void setSourceLevel(SourceLevel sourceLevel) { + this.sourceLevel = sourceLevel; + } + public File getCandidateDex() { return candidateDex; } @@ -137,7 +144,7 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper } @Nonnull - public Comparator createDexFileComparator() { + public ComparatorDex createDexFileComparator() { ComparatorDex comparator = new ComparatorDex(candidateDex, refDex); comparator.setWithDebugInfo(withDebugInfos); comparator.setStrict(false); @@ -166,6 +173,7 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper candidateTestTools.setJarjarRules(jarjarRulesFile); } candidateTestTools.setWithDebugInfos(withDebugInfos); + candidateTestTools.setSourceLevel(sourceLevel); candidateTestTools.addProguardFlags(proguardFlagFiles).srcToExe( AbstractTestTools.getClasspathAsString(candidateClasspath), candidateDexDir, /* zipFile = */ false, filesOrSourceList); @@ -178,6 +186,7 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper referenceTestTools.setJarjarRules(jarjarRulesFile); } referenceTestTools.setWithDebugInfos(withDebugInfos); + referenceTestTools.setSourceLevel(sourceLevel); referenceTestTools.addProguardFlags(proguardFlagFiles).srcToExe( AbstractTestTools.getClasspathAsString(referenceClasspath), refDexDir, /* zipFile = */ false, filesOrSourceList); diff --git a/jack-tests/src/com/android/jack/test/toolchain/LegacyToolchain.java b/jack-tests/src/com/android/jack/test/toolchain/LegacyToolchain.java index 42e816b..289412a 100644 --- a/jack-tests/src/com/android/jack/test/toolchain/LegacyToolchain.java +++ b/jack-tests/src/com/android/jack/test/toolchain/LegacyToolchain.java @@ -212,6 +212,10 @@ public class LegacyToolchain extends AndroidToolchain { args.add("-verbose"); } addSourceLevel(sourceLevel, args); + + args.add("-encoding"); + args.add("utf8"); + args.add("-noExit"); args.add("-preserveAllLocals"); args.add("-d"); @@ -263,6 +267,9 @@ public class LegacyToolchain extends AndroidToolchain { addSourceLevel(sourceLevel, arguments); + arguments.add("-encoding"); + arguments.add("utf8"); + if (annotationProcessorClass != null) { arguments.add("-processor"); arguments.add(annotationProcessorClass.getName()); diff --git a/jack-tests/tests/com/android/jack/AllTests.java b/jack-tests/tests/com/android/jack/AllTests.java index 52e1362..1ad2bd6 100644 --- a/jack-tests/tests/com/android/jack/AllTests.java +++ b/jack-tests/tests/com/android/jack/AllTests.java @@ -37,7 +37,7 @@ import com.android.jack.invoke.InvokeTests; import com.android.jack.jarjar.JarjarTests; import com.android.jack.java7.Java7AllTest; import com.android.jack.label.LabelTest; -import com.android.jack.library.LibraryTest; +import com.android.jack.library.LibraryTests; import com.android.jack.lookup.LookupTests; import com.android.jack.multidex.MultiDexAllTests; import com.android.jack.newarray.NewarrayTests; @@ -105,7 +105,7 @@ import org.junit.runners.Suite.SuiteClasses; InvokeTests.class, Java7AllTest.class, LabelTest.class, - LibraryTest.class, + LibraryTests.class, LookupTests.class, MergerAllTests.class, MissingClassTest.class, diff --git a/jack-tests/tests/com/android/jack/classpath/ClasspathTests.java b/jack-tests/tests/com/android/jack/classpath/ClasspathTests.java index d563d35..7ec0a20 100644 --- a/jack-tests/tests/com/android/jack/classpath/ClasspathTests.java +++ b/jack-tests/tests/com/android/jack/classpath/ClasspathTests.java @@ -151,24 +151,16 @@ public class ClasspathTests { JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); String defaultClasspath = AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()); - File srcDir = AbstractTestTools.getTestRootDir("com.android.jack.classpath/test004"); + File srcDir = AbstractTestTools.getTestRootDir("com.android.jack.classpath.test004.jack"); String classpathWithMissingEntry = defaultClasspath + File.pathSeparator + new File(srcDir, "missing.jack").getAbsolutePath(); File testOut = AbstractTestTools.createTempFile("ClasspathTest", "missing"); - toolchain.srcToLib( - classpathWithMissingEntry, - testOut, - /* zipFiles = */ true, - srcDir); + toolchain.srcToLib(classpathWithMissingEntry, testOut, /* zipFiles = */ true, srcDir); toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); toolchain.addProperty(Jack.STRICT_CLASSPATH.getName(), "true"); try { - toolchain.srcToLib( - classpathWithMissingEntry, - testOut, - /* zipFiles = */ true, - srcDir); + toolchain.srcToLib(classpathWithMissingEntry, testOut, /* zipFiles = */ true, srcDir); Assert.fail(); } catch (JackAbortException e) { Assert.assertTrue(e.getCause() instanceof LibraryReadingException); @@ -186,26 +178,20 @@ public class ClasspathTests { private void compileWithInvalidClasspathEntry(File srcDir, File invalidJack) throws IOException, Exception { Assert.assertTrue(invalidJack.isFile()); + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); String classpathWithInvalidEntry = - AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + - File.pathSeparator + invalidJack.getAbsolutePath(); + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparator + invalidJack.getAbsolutePath(); File testOut = AbstractTestTools.createTempFile("ClasspathTest", "invalid"); - toolchain.srcToLib( - classpathWithInvalidEntry, - testOut, - /* zipFile = */ true, - srcDir); + toolchain.srcToLib(classpathWithInvalidEntry, testOut, /* zipFiles = */ true, srcDir); toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); toolchain.addProperty(Jack.STRICT_CLASSPATH.getName(), "true"); + try { - toolchain.srcToLib( - classpathWithInvalidEntry, - testOut, - /* zipFiles = */ true, - srcDir); + toolchain.srcToLib(classpathWithInvalidEntry, testOut, /* zipFiles = */ true, srcDir); Assert.fail(); } catch (JackAbortException e) { Assert.assertTrue(e.getCause() instanceof LibraryReadingException); diff --git a/jack-tests/tests/com/android/jack/compile/androidtree/AllTests.java b/jack-tests/tests/com/android/jack/compile/androidtree/AllTests.java new file mode 100644 index 0000000..ec3bacc --- /dev/null +++ b/jack-tests/tests/com/android/jack/compile/androidtree/AllTests.java @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * 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.android.jack.compile.androidtree; + +import com.android.jack.compile.androidtree.bouncycastle.BouncycastleCompilationTest; +import com.android.jack.compile.androidtree.core.CoreCompilationTest; +import com.android.jack.compile.androidtree.ext.ExtCompilationTest; +import com.android.jack.compile.androidtree.frameworks.FrameworksBaseCompilationTest; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses(value = {FrameworksBaseCompilationTest.class, CoreCompilationTest.class, + BouncycastleCompilationTest.class, ExtCompilationTest.class}) +public class AllTests { +}
\ No newline at end of file diff --git a/jack-tests/tests/com/android/jack/compile/androidtree/bouncycastle/BouncycastleCompilationTest.java b/jack-tests/tests/com/android/jack/compile/androidtree/bouncycastle/BouncycastleCompilationTest.java new file mode 100644 index 0000000..3768888 --- /dev/null +++ b/jack-tests/tests/com/android/jack/compile/androidtree/bouncycastle/BouncycastleCompilationTest.java @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * 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.android.jack.compile.androidtree.bouncycastle; + +import com.android.jack.JarJarRules; +import com.android.jack.TestTools; +import com.android.jack.category.RedundantTests; +import com.android.jack.category.SlowTests; +import com.android.jack.test.comparator.ComparatorDex; +import com.android.jack.test.helper.CheckDexStructureTestHelper; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.AndroidToolchain; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +@Ignore("Tree") +public class BouncycastleCompilationTest { + + private static File[] CLASSPATH; + private static File[] REF_CLASSPATH; + + private static File SOURCELIST; + + private static JarJarRules JARJAR_RULES; + + @BeforeClass + public static void setUpClass() { + BouncycastleCompilationTest.class.getClassLoader().setDefaultAssertionStatus(true); + CLASSPATH = new File[] { + TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/core-libart_intermediates/classes.jack") + }; + REF_CLASSPATH = new File[] { + TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/core-libart_intermediates/classes.jar") + }; + SOURCELIST = TestTools.getTargetLibSourcelist("bouncycastle"); + JARJAR_RULES = new JarJarRules( + TestTools.getFromAndroidTree("external/bouncycastle/jarjar-rules.txt")); + } + + @Test + @Category(RedundantTests.class) + public void compileBouncycastle() throws Exception { + File outDexFolder = AbstractTestTools.createTempDir(); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.disableDxOptimizations(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(CLASSPATH), + outDexFolder, + /* zipFile = */ false, + SOURCELIST); + } + + @Test + @Category(SlowTests.class) + public void compareBouncycastleStructure() throws Exception { + SourceToDexComparisonTestHelper helper = new CheckDexStructureTestHelper(SOURCELIST); + // TODO(jmhenaff): use setBootclasspath + helper.setCandidateClasspath(CLASSPATH); + helper.setReferenceClasspath(REF_CLASSPATH); + helper.setJarjarRulesFile(JARJAR_RULES); + + ComparatorDex comparator = helper.createDexFileComparator(); + comparator.setCompareDebugInfoBinary(false); + comparator.setCompareInstructionNumber(true); + comparator.setInstructionNumberTolerance(0.4f); + + helper.runTest(comparator); + } +} diff --git a/jack-tests/tests/com/android/jack/compile/androidtree/core/CoreCompilationTest.java b/jack-tests/tests/com/android/jack/compile/androidtree/core/CoreCompilationTest.java new file mode 100644 index 0000000..8d3631d --- /dev/null +++ b/jack-tests/tests/com/android/jack/compile/androidtree/core/CoreCompilationTest.java @@ -0,0 +1,116 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * 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.android.jack.compile.androidtree.core; + +import com.android.jack.DexAnnotationsComparator; +import com.android.jack.DexComparator; +import com.android.jack.Options; +import com.android.jack.TestTools; +import com.android.jack.backend.dex.DexFileWriter; +import com.android.jack.category.RedundantTests; +import com.android.jack.category.SlowTests; +import com.android.jack.config.id.JavaVersionPropertyId.JavaVersion; +import com.android.jack.test.comparator.ComparatorDex; +import com.android.jack.test.helper.CheckDexStructureTestHelper; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackBasedToolchain; +import com.android.jack.test.toolchain.Toolchain.SourceLevel; +import com.android.sched.vfs.Container; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +@Ignore("Tree") +public class CoreCompilationTest { + + private static File SOURCELIST; + + @BeforeClass + public static void setUpClass() { + CoreCompilationTest.class.getClassLoader().setDefaultAssertionStatus(true); + SOURCELIST = TestTools.getTargetLibSourcelist("core-libart"); + } + + @Test + @Category(RedundantTests.class) + public void compileCore() throws Exception { + File outDexFolder = AbstractTestTools.createTempDir(); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProperty(Options.JAVA_SOURCE_VERSION.getName(), JavaVersion.JAVA_7.toString()); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + outDexFolder, + /* zipFile = */ false, + SOURCELIST); + } + + @Test + public void compareLibCoreStructure() throws Exception { + SourceToDexComparisonTestHelper helper = new CheckDexStructureTestHelper(SOURCELIST); + helper.setCandidateClasspath(/* empty */); + helper.setReferenceClasspath(/* empty */); + helper.setSourceLevel(SourceLevel.JAVA_7); + + ComparatorDex comparator = helper.createDexFileComparator(); + comparator.setCompareDebugInfoBinary(false); + comparator.setCompareInstructionNumber(false); + comparator.setInstructionNumberTolerance(0.1f); + + helper.runTest(comparator); + } + + @Test + @Category(SlowTests.class) + public void compileCoreWithJackAndDex() throws Exception { + File coreDexFolderFromJava = AbstractTestTools.createTempDir(); + File coreDexFromJava = new File(coreDexFolderFromJava, DexFileWriter.DEX_FILENAME); + + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProperty(Options.GENERATE_JACK_LIBRARY.getName(), "true"); + + File outputFile = new File("/tmp/jackIncrementalOutput"); + + toolchain.addProperty( + Options.DEX_OUTPUT_CONTAINER_TYPE.getName(), Container.DIR.toString()); + toolchain.addProperty(Options.LIBRARY_OUTPUT_DIR.getName(), outputFile.getAbsolutePath()); + toolchain.addProperty( + Options.LIBRARY_OUTPUT_CONTAINER_TYPE.getName(), Container.DIR.toString()); + toolchain.setSourceLevel(SourceLevel.JAVA_7); + + toolchain.srcToExe( + /* classpath = */ null, + coreDexFolderFromJava, + /* zipFile = */ false, + SOURCELIST); + + File coreDexFolderFromJack = AbstractTestTools.createTempDir(); + File coreDexFromJack = new File(coreDexFolderFromJack, DexFileWriter.DEX_FILENAME); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.libToExe(outputFile, coreDexFolderFromJack, /* zipFile = */ false); + + // Compare dex files structures and number of instructions + new DexComparator(false /* withDebugInfo */, false /* strict */, + false /* compareDebugInfoBinary */, true /* compareInstructionNumber */, 0).compare( + coreDexFromJava, coreDexFromJack); + new DexAnnotationsComparator().compare(coreDexFromJava, coreDexFromJack); + } +} diff --git a/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/AllTests.java b/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/AllTests.java new file mode 100644 index 0000000..dab444a --- /dev/null +++ b/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/AllTests.java @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * 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.android.jack.compile.androidtree.dalvik; + + +import com.android.jack.compile.androidtree.dalvik.compilerregressions.CompilerRegressionsTest; +import com.android.jack.compile.androidtree.dalvik.finalizer.FinalizerTest; +import com.android.jack.compile.androidtree.dalvik.omnibus.OmnibusCompilationTest; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses(value = {CompilerRegressionsTest.class, + FinalizerTest.class, + OmnibusCompilationTest.class}) +public class AllTests { +} diff --git a/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/compilerregressions/CompilerRegressionsTest.java b/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/compilerregressions/CompilerRegressionsTest.java new file mode 100644 index 0000000..ab98c40 --- /dev/null +++ b/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/compilerregressions/CompilerRegressionsTest.java @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * 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.android.jack.compile.androidtree.dalvik.compilerregressions; + +import com.android.jack.TestTools; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.AndroidToolchain; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; + +import java.io.File; + +@Ignore("Tree") +public class CompilerRegressionsTest { + + private static File[] BOOTCLASSPATH; + + @BeforeClass + public static void setUpClass() { + CompilerRegressionsTest.class.getClassLoader().setDefaultAssertionStatus(true); + BOOTCLASSPATH = new File[] {TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/core-libart_intermediates/classes.jack")}; + } + + @Test + public void compileRegressions() throws Exception { + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(BOOTCLASSPATH), + AbstractTestTools.createTempFile("out", ".zip"), + /* zipFile = */ true, + TestTools.getArtTestFolder("083-compiler-regressions")); + } +} diff --git a/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/finalizer/FinalizerTest.java b/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/finalizer/FinalizerTest.java new file mode 100644 index 0000000..e5d2f45 --- /dev/null +++ b/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/finalizer/FinalizerTest.java @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * 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.android.jack.compile.androidtree.dalvik.finalizer; + +import com.android.jack.TestTools; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.AndroidToolchain; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; + +import java.io.File; + +@Ignore("Tree") +public class FinalizerTest { + + private static File[] BOOTCLASSPATH; + + @BeforeClass + public static void setUpClass() { + FinalizerTest.class.getClassLoader().setDefaultAssertionStatus(true); + BOOTCLASSPATH = new File[] {TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/core-libart_intermediates/classes.jack")}; + } + + @Test + public void compileFinalizer() throws Exception { + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(BOOTCLASSPATH), + AbstractTestTools.createTempFile("out", ".zip"), + /* zipFile = */ true, + TestTools.getArtTestFolder("036-finalizer")); + } +} diff --git a/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/omnibus/OmnibusCompilationTest.java b/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/omnibus/OmnibusCompilationTest.java new file mode 100644 index 0000000..6164b2d --- /dev/null +++ b/jack-tests/tests/com/android/jack/compile/androidtree/dalvik/omnibus/OmnibusCompilationTest.java @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * 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.android.jack.compile.androidtree.dalvik.omnibus; + +import com.android.jack.TestTools; +import com.android.jack.category.SlowTests; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.AndroidToolchain; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +@Ignore("Tree") +public class OmnibusCompilationTest { + + private static File[] BOOTCLASSPATH; + + @BeforeClass + public static void setUpClass() { + OmnibusCompilationTest.class.getClassLoader().setDefaultAssertionStatus(true); + BOOTCLASSPATH = new File[] {TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/core-libart_intermediates/classes.jack")}; + } + + @Test + @Category(SlowTests.class) + public void compileOmnibus() throws Exception { + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(BOOTCLASSPATH), + AbstractTestTools.createTempFile("out", ".zip"), + /* zipFile = */ true, + TestTools.getArtTestFolder("003-omnibus-opcodes")); + } +} diff --git a/jack-tests/tests/com/android/jack/compile/androidtree/ext/ExtCompilationTest.java b/jack-tests/tests/com/android/jack/compile/androidtree/ext/ExtCompilationTest.java new file mode 100644 index 0000000..55f1e03 --- /dev/null +++ b/jack-tests/tests/com/android/jack/compile/androidtree/ext/ExtCompilationTest.java @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * 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.android.jack.compile.androidtree.ext; + +import com.android.jack.TestTools; +import com.android.jack.category.RedundantTests; +import com.android.jack.category.SlowTests; +import com.android.jack.test.comparator.ComparatorDex; +import com.android.jack.test.helper.CheckDexStructureTestHelper; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.AndroidToolchain; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +@Ignore("Tree") +public class ExtCompilationTest { + + private static File[] CLASSPATH; + private static File[] REF_CLASSPATH; + + private static File SOURCELIST; + + @BeforeClass + public static void setUpClass() { + ExtCompilationTest.class.getClassLoader().setDefaultAssertionStatus(true); + CLASSPATH = new File[] { + TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/core-libart_intermediates/classes.jack") + }; + REF_CLASSPATH = new File[] { + TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/core-libart_intermediates/classes.jar") + }; + SOURCELIST = TestTools.getTargetLibSourcelist("ext"); + } + + @Test + @Category(RedundantTests.class) + public void compileExt() throws Exception { + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(CLASSPATH), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + SOURCELIST); + } + + @Test + @Category(SlowTests.class) + public void compareExtStructure() throws Exception { + // TODO(jmhenaff): use setBootclasspath + SourceToDexComparisonTestHelper helper = new CheckDexStructureTestHelper(SOURCELIST); + helper.setCandidateClasspath(CLASSPATH); + helper.setReferenceClasspath(REF_CLASSPATH); + + ComparatorDex comparator = helper.createDexFileComparator(); + comparator.setCompareDebugInfoBinary(false); + comparator.setCompareInstructionNumber(true); + comparator.setInstructionNumberTolerance(0.4f); + + helper.runTest(comparator); + } +} diff --git a/jack-tests/tests/com/android/jack/compile/androidtree/frameworks/FrameworksBaseCompilationTest.java b/jack-tests/tests/com/android/jack/compile/androidtree/frameworks/FrameworksBaseCompilationTest.java new file mode 100644 index 0000000..0ba3671 --- /dev/null +++ b/jack-tests/tests/com/android/jack/compile/androidtree/frameworks/FrameworksBaseCompilationTest.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * 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.android.jack.compile.androidtree.frameworks; + +import com.android.jack.TestTools; +import com.android.jack.backend.dex.DexFileWriter; +import com.android.jack.category.SlowTests; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackBasedToolchain; +import com.android.jack.test.toolchain.Toolchain.SourceLevel; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +@Ignore("Tree") +public class FrameworksBaseCompilationTest { + + private static File[] BOOTCLASSPATH; + + private static File[] CLASSPATH; + + private static File SOURCELIST; + + @BeforeClass + public static void setUpClass() { + FrameworksBaseCompilationTest.class.getClassLoader().setDefaultAssertionStatus(true); + BOOTCLASSPATH = new File[] { + TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/core-libart_intermediates/classes.jack") + }; + CLASSPATH = new File[] { + TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/conscrypt_intermediates/classes.jack"), + TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/okhttp_intermediates/classes.jack"), + TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/core-junit_intermediates/classes.jack"), + TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/bouncycastle_intermediates/classes.jack"), + TestTools.getFromAndroidTree( + "out/target/common/obj/JAVA_LIBRARIES/ext_intermediates/classes.jack")}; + SOURCELIST = TestTools.getTargetLibSourcelist("framework"); + } + + @Test + @Category(SlowTests.class) + public void compileFrameworks() throws Exception { + File outDexFolder = AbstractTestTools.createTempDir(); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.setSourceLevel(SourceLevel.JAVA_7); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex"); + toolchain.srcToExe( + AbstractTestTools.getClasspathsAsString(BOOTCLASSPATH, CLASSPATH), + outDexFolder, + /* zipFile = */ false, + SOURCELIST); + } +} diff --git a/jack-tests/tests/com/android/jack/library/LibraryTests.java b/jack-tests/tests/com/android/jack/library/LibraryTests.java new file mode 100644 index 0000000..eddf344 --- /dev/null +++ b/jack-tests/tests/com/android/jack/library/LibraryTests.java @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * 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.android.jack.library; + +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.AndroidToolchain; +import com.android.jack.test.toolchain.JackBasedToolchain; +import com.android.sched.util.RunnableHooks; +import com.android.sched.util.file.FileOrDirectory.ChangePermission; +import com.android.sched.util.file.FileOrDirectory.Existence; +import com.android.sched.util.file.InputZipFile; +import com.android.sched.vfs.InputVFS; +import com.android.sched.vfs.InputZipVFS; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; +import java.io.IOException; + +import javax.annotation.Nonnull; + +public class LibraryTests { + @BeforeClass + public static void setUpClass() { + LibraryTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void testEmptyLibraryInClassPath() throws Exception { + File emptyLib = createEmptyLibrary(); + + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparator + emptyLib.getPath(), + AbstractTestTools.createTempFile("library001", ".jack"), /* zipFile = */ + true, AbstractTestTools.getTestRootDir("com.android.jack.library.test001.jack")); + } + + @Test + public void testRscLibraryInClassPath() throws Exception { + File emptyLib = createRscLibrary(); + + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparator + emptyLib.getPath(), + AbstractTestTools.createTempFile("library001", ".jack"), /* zipFile = */ + true, AbstractTestTools.getTestRootDir("com.android.jack.library.test001.jack")); + } + + @Test + public void testImportEmptyLibrary() throws Exception { + File lib = createEmptyLibrary(); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.addStaticLibs(lib); + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempFile("library001", ".jack"), /* zipFile = */ + true, AbstractTestTools.getTestRootDir("com.android.jack.library.test001.jack")); + } + + @Test + public void testImportRscLibrary() throws Exception { + File lib = createRscLibrary(); + File out = AbstractTestTools.createTempFile("library001", ".jack"); + + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.addStaticLibs(lib); + toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + out, /* zipFile = */ + true, AbstractTestTools.getTestRootDir("com.android.jack.library.test001.jack")); + + RunnableHooks hooks = new RunnableHooks(); + InputVFS vfs = new InputZipVFS( + new InputZipFile(out.getPath(), hooks, Existence.MUST_EXIST, ChangePermission.NOCHANGE)); + try { + InputJackLibrary inputJackLibrary = JackLibraryFactory.getInputLibrary(vfs); + Assert.assertTrue(inputJackLibrary.containsFileType(FileType.RSC)); + } finally { + vfs.close(); + } + } + + @Nonnull + private File createEmptyLibrary() throws IOException, Exception { + File emptyLib = AbstractTestTools.createTempFile("empty", ".jack"); + + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToLib(/* classpath = */ null, emptyLib, /* zipFiles = */ true); + + return emptyLib; + } + + @Nonnull + private File createRscLibrary() throws IOException, Exception { + File emptyLib = AbstractTestTools.createTempFile("rsc", ".jack"); + + JackBasedToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addResource(AbstractTestTools.getTestRootDir("com.android.jack.library.test001.lib")); + toolchain.srcToLib(/* classpath = */ null, emptyLib, /* zipFiles = */ true); + + return emptyLib; + } +} diff --git a/jack-tests/tests/com/android/jack/multidex/MultiDexTests.java b/jack-tests/tests/com/android/jack/multidex/MultiDexTests.java index e462024..89bb95f 100644 --- a/jack-tests/tests/com/android/jack/multidex/MultiDexTests.java +++ b/jack-tests/tests/com/android/jack/multidex/MultiDexTests.java @@ -19,8 +19,6 @@ package com.android.jack.multidex; import com.google.common.io.Files; import com.android.jack.DifferenceFoundException; -import com.android.jack.Options; -import com.android.jack.TestTools; import com.android.jack.backend.dex.DexFileWriter; import com.android.jack.backend.dex.MultiDexLegacy; import com.android.jack.dx.io.ClassDef; @@ -37,6 +35,7 @@ import com.android.jack.test.toolchain.AbstractTestTools; import com.android.jack.test.toolchain.DummyToolchain; import com.android.jack.test.toolchain.IToolchain; import com.android.jack.test.toolchain.JackApiToolchain; +import com.android.jack.test.toolchain.JackBasedToolchain; import com.android.sched.util.TextUtils; import junit.framework.Assert; @@ -168,74 +167,61 @@ public class MultiDexTests { @Test public void versionedTest001a_withoutAnnotations() throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test001.jack"); + File out = AbstractTestTools.createTempDir(); + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-001.jpp")); - File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test001"); - File out = TestTools.createTempDir("out", ""); - Options app1Options = addCommonOptionsForMultiDex(new File(testFolder, "config-001.jpp")); - - app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex"); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex"); - TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultClasspathString() - + File.pathSeparator + frameworks.getPath(), - out, false); + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparator + frameworks.getPath(), out, /* zipFile = */false, testFolder); String outList = getListingOfDex(new File(out, "classes.dex")); ListingComparator.compare(new File(testFolder, "ref-list-001.txt"), outList); Assert.assertFalse(new File(out, "classes2.dex").exists()); - return; } @Test public void versionedTest001b_minimal_withoutAnnotations() throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test001.jack"); + File out = AbstractTestTools.createTempDir(); + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-001.jpp")); - File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test001"); - File out = TestTools.createTempDir("out", ""); - Options app1Options = addCommonOptionsForMultiDex(new File(testFolder, "config-001.jpp")); - - app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); - TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultClasspathString() - + File.pathSeparator + frameworks.getPath(), - out, false); + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparator + frameworks.getPath(), out, /* zipFile = */false, testFolder); String outList = getListingOfDex(new File(out, "classes.dex")); ListingComparator.compare(new File(testFolder, "ref-list-002-1.txt"), outList); String outList2 = getListingOfDex(new File(out, "classes2.dex")); ListingComparator.compare(new File(testFolder, "ref-list-002-2.txt"), outList2); Assert.assertFalse(new File(out, "classes3.dex").exists()); - return; } @Test public void versionedTest001c_withoutAnnotations() throws Exception { - File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test001"); - File out = TestTools.createTempDir("out", ""); - Options app1Options = addCommonOptionsForMultiDex(new File(testFolder, "config-003.jpp")); + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test001.jack"); + File out = AbstractTestTools.createTempDir(); + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-003.jpp")); - app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); - TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultClasspathString() - + File.pathSeparator + frameworks.getPath(), - out, false); + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparator + frameworks.getPath(), out, /* zipFile = */false, testFolder); String outList = getListingOfDex(new File(out, "classes.dex")); ListingComparator.compare(new File(testFolder, "ref-list-003-1.txt"), outList); String outList2 = getListingOfDex(new File(out, "classes2.dex")); ListingComparator.compare(new File(testFolder, "ref-list-003-2.txt"), outList2); Assert.assertFalse(new File(out, "classes3.dex").exists()); - return; } - private Options addCommonOptionsForMultiDex(@Nonnull File configFile) { - Options app1Options = new Options(); - app1Options.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true"); - app1Options.addProperty(PreProcessor.ENABLE.getName(), "true"); - app1Options.addProperty(PreProcessor.FILE.getName(), configFile.getAbsolutePath()); - return app1Options; - } - - private void addCommonOptionsForMultiDex(@Nonnull JackApiToolchain toolchain, + private void addCommonOptionsForMultiDex(@Nonnull JackBasedToolchain toolchain, @Nonnull File configFile) { toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true"); toolchain.addProperty(PreProcessor.ENABLE.getName(), "true"); @@ -409,16 +395,17 @@ public class MultiDexTests { @Test @Category(SlowTests.class) public void legacyAppTest002a_withoutAnnotations() throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test002.jack"); + File out = AbstractTestTools.createTempDir(); + + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + addCommonOptionsForMultiDex(toolchain, new File(testFolder,"config-001.jpp")); - File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test002"); - File out = TestTools.createTempDir("out", ""); - Options app1Options = addCommonOptionsForMultiDex( - new File(testFolder,"config-001.jpp")); - app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex"); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex"); - TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultClasspathString() - + File.pathSeparator + frameworks.getPath() - + File.pathSeparator + library.getPath(), out, false); + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparator + frameworks.getPath() + File.pathSeparator + library.getPath(), out, + /* zipFile = */ false, testFolder); File classesDex = new File(out, "classes.dex"); Assert.assertTrue(classesDex.exists()); @@ -428,23 +415,22 @@ public class MultiDexTests { Assert.assertFalse(classes3Dex.exists()); int totalTypeNumber = getTypeCountInDex(classesDex) + getTypeCountInDex(classes2Dex); Assert.assertEquals(100, totalTypeNumber); - return; } @Test @Category(SlowTests.class) public void legacyAppTest002b_withoutAnnotations() throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test002.jack"); + File out = AbstractTestTools.createTempDir(); - File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test002"); - File out = TestTools.createTempDir("out", ""); - Options app1Options = addCommonOptionsForMultiDex( - new File(testFolder,"config-001.jpp")); - app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); - app1Options.addImportedLibrary(library); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + addCommonOptionsForMultiDex(toolchain, new File(testFolder,"config-001.jpp")); - TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultClasspathString() - + File.pathSeparator + frameworks.getPath(), - out, false); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); + toolchain.addStaticLibs(library); + + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + File.pathSeparator + frameworks.getPath(), + out, /* zipFile = */ false, testFolder); String outList = getListingOfDex(new File(out, "classes.dex")); // The old toolchain is doing a little better than us here it seems to identify when @@ -455,28 +441,25 @@ public class MultiDexTests { ListingComparator.compare( new File(testFolder,"ref-list-002-2.txt"), outList2); Assert.assertFalse(new File(out, "classes3.dex").exists()); - return; } @Test public void legacyAppTest002b_auto_withoutAnnotations() throws Exception { - - File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test002"); + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test002.jack"); File autoLibrary = prepareLibrary(frameworks); setMetaIntoJackProperties(autoLibrary); File jackInf = new File(autoLibrary, FileType.JPP.getPrefix()); Assert.assertTrue(jackInf.mkdir()); Files.copy(new File(testFolder,"config-001.jpp"), new File(jackInf, "config-001.jpp")); - File out = TestTools.createTempDir("out", ""); - Options app1Options = new Options(); - app1Options.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true"); - app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); - app1Options.addImportedLibrary(autoLibrary); + File out = AbstractTestTools.createTempDir(); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true"); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); + toolchain.addStaticLibs(autoLibrary); - TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultClasspathString() - + File.pathSeparator + frameworks.getPath(), - out, false); + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparator + frameworks.getPath(), out, /* zipFile = */ false, testFolder); String outList = getListingOfDex(new File(out, "classes.dex")); // The old toolchain is doing a little better than us here it seems to identify when @@ -487,7 +470,6 @@ public class MultiDexTests { ListingComparator.compare( new File(testFolder,"ref-list-002-2.txt"), outList2); Assert.assertFalse(new File(out, "classes3.dex").exists()); - return; } /** @@ -495,17 +477,15 @@ public class MultiDexTests { */ @Test public void annotatedTest003() throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test003.jack"); + File out = AbstractTestTools.createTempDir(); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true"); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); - File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test003"); - - File out = TestTools.createTempDir("out", ""); - Options appOptions = new Options(); - appOptions.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true"); - appOptions.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); - - TestTools.compileSourceToDex(appOptions, testFolder, TestTools.getDefaultClasspathString() + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + File.pathSeparator + annotations.getPath() + File.pathSeparator + frameworks.getPath(), - out, false); + /* zipFile = */ out, false, testFolder); String outList = getListingOfDex(new File(out, "classes.dex")); ListingComparator.compare( @@ -514,6 +494,5 @@ public class MultiDexTests { ListingComparator.compare( new File(testFolder,"ref-list-003-2.txt"), outList2); Assert.assertFalse(new File(out, "classes3.dex").exists()); - return; } } diff --git a/jack-tests/tests/com/android/jack/noclasspath/NoClasspathTest.java b/jack-tests/tests/com/android/jack/noclasspath/NoClasspathTest.java new file mode 100644 index 0000000..ee11ba6 --- /dev/null +++ b/jack-tests/tests/com/android/jack/noclasspath/NoClasspathTest.java @@ -0,0 +1,206 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * 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.android.jack.noclasspath; + +import com.android.jack.JarJarRules; +import com.android.jack.Sourcelist; +import com.android.jack.TestTools; +import com.android.jack.backend.dex.DexFileWriter; +import com.android.jack.category.SlowTests; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.AndroidToolchain; +import com.android.jack.test.toolchain.JackBasedToolchain; +import com.android.jack.test.toolchain.Toolchain.SourceLevel; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +@Ignore("Tree") +@Category(SlowTests.class) +public class NoClasspathTest { + + private static Sourcelist CORE_SOURCELIST; + + private static Sourcelist BOUNCY_SOURCELIST; + + private static Sourcelist CONSCRYPT_SOURCELIST; + + private static Sourcelist OKHTTP_SOURCELIST; + + private static Sourcelist EXT_SOURCELIST; + + private static Sourcelist CORE_JUNIT_SOURCELIST; + + private static Sourcelist FRAMEWORK_SOURCELIST; + + protected static File FRAMEWORK_JAR ; + + private static File GUAVA_JAR; + + private static File SERVICES_JAR; + + private static File ARITY_JAR; + + private static File PLAY_SERVICE_JAR; + + private static String corePath; + + @BeforeClass + public static void setup() throws Exception { + CORE_SOURCELIST = TestTools.getTargetLibSourcelist("core-libart"); + BOUNCY_SOURCELIST = TestTools.getTargetLibSourcelist("bouncycastle"); + CONSCRYPT_SOURCELIST = TestTools.getTargetLibSourcelist("conscrypt"); + OKHTTP_SOURCELIST = TestTools.getTargetLibSourcelist("okhttp"); + EXT_SOURCELIST = TestTools.getTargetLibSourcelist("ext"); + CORE_JUNIT_SOURCELIST = + TestTools.getTargetLibSourcelist("core-junit"); + FRAMEWORK_SOURCELIST = + TestTools.getTargetLibSourcelist("framework"); + + FRAMEWORK_JAR = TestTools.getFromAndroidTree( + "/out/target/common/obj/JAVA_LIBRARIES/framework_intermediates/" + "classes.jack"); + + GUAVA_JAR = TestTools + .getFromAndroidTree("out/target/common/obj/JAVA_LIBRARIES/guava_intermediates/classes.jack"); + SERVICES_JAR = TestTools + .getFromAndroidTree("out/target/common/obj/JAVA_LIBRARIES/services_intermediates/" + + "classes.jack"); + ARITY_JAR = TestTools + .getFromAndroidTree("out/target/common/obj/JAVA_LIBRARIES/libarity_intermediates/" + + "classes.jack"); + PLAY_SERVICE_JAR = TestTools + .getFromAndroidTree("out/target/common/obj/JAVA_LIBRARIES/" + + "google-play-services-first-party_intermediates/classes.jack"); + + + // File coreOut = AbstractTestTools.createTempFile("core", ".jack"); + File coreOut = new File("/tmp/ + core.jack"); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.setSourceLevel(SourceLevel.JAVA_7); + toolchain.srcToLib( + /* classpath = */ null, + coreOut, + /* zipFile = */ true, + CORE_SOURCELIST); + corePath = coreOut.getAbsolutePath(); + } + + @Test + public void ext() throws Exception { + File extJack = AbstractTestTools.createTempFile("ext", ".jack"); + + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToLib(corePath, extJack, /* zipFiles = */ true, EXT_SOURCELIST); + + File extFolder = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToExe(extJack, extFolder, /* zipFile = */ false); + } + + @Test + public void frameworkFromJack() throws Exception { + File conscryptJack = AbstractTestTools.createTempFile("conscrypt", ".jack"); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib(corePath, conscryptJack, /* zipFiles = */ true, CONSCRYPT_SOURCELIST); + + File conscryptRenamedJack = AbstractTestTools.createTempFile("conscryptrenamed", ".jack"); + File conscyptRules = + new JarJarRules(TestTools.getFromAndroidTree("external/conscrypt/jarjar-rules.txt")); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.setJarjarRules(conscyptRules); + toolchain.libToLib(conscryptJack, conscryptRenamedJack, /* zipFiles = */ true); + + File okhttpJack = AbstractTestTools.createTempFile("okkttp", ".jack"); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib(corePath + File.pathSeparatorChar + conscryptRenamedJack.getAbsolutePath(), + okhttpJack, /* zipFiles = */ true, OKHTTP_SOURCELIST); + + File okhttpRenamedJack = AbstractTestTools.createTempFile("okhttprenamed", ".jack"); + File okhttpRules = + new JarJarRules(TestTools.getFromAndroidTree("external/okhttp/jarjar-rules.txt")); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.setJarjarRules(okhttpRules); + toolchain.libToLib(okhttpJack, okhttpRenamedJack, /* zipFiles = */ true); + + File extJack = AbstractTestTools.createTempFile("ext", ".jack"); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib(corePath, extJack, /* zipFiles = */ true, EXT_SOURCELIST); + + File bouncyCastleJack = AbstractTestTools.createTempFile("bouncyjack", ".jack"); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib(corePath, bouncyCastleJack, /* zipFiles = */ true, BOUNCY_SOURCELIST); + + File coreJunitJack = AbstractTestTools.createTempFile("corejunitjack", ".jack"); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib(corePath, coreJunitJack, /* zipFiles = */ true, CORE_JUNIT_SOURCELIST); + + File bouncyCastleRenamedJack = AbstractTestTools.createTempFile("bouncyjackrenamed", ".jack"); + File jarjarRules = + new JarJarRules(TestTools.getFromAndroidTree("external/bouncycastle/jarjar-rules.txt")); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.setJarjarRules(jarjarRules); + toolchain.libToLib(bouncyCastleJack, bouncyCastleRenamedJack, /* zipFiles = */ true); + + String classpath = corePath + File.pathSeparatorChar + conscryptRenamedJack.getAbsolutePath() + + File.pathSeparatorChar + okhttpRenamedJack.getAbsolutePath() + + File.pathSeparatorChar + extJack.getAbsolutePath() + + File.pathSeparatorChar + bouncyCastleRenamedJack.getAbsolutePath() + + File.pathSeparatorChar + coreJunitJack.getAbsolutePath(); + + File frameworkJackZip = AbstractTestTools.createTempFile("framework", ".jack"); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.setSourceLevel(SourceLevel.JAVA_7); + toolchain.srcToLib(classpath, frameworkJackZip, /* zipFiles = */ true, FRAMEWORK_SOURCELIST); + + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex"); + File frameworkDexFolder = TestTools.createTempDir("framework", "dex"); + toolchain.libToExe(frameworkJackZip, frameworkDexFolder, /* zipFile = */ false); + } + + @Test + public void guava() throws Exception { + File guavaDexFolder = AbstractTestTools.createTempDir(); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToExe(GUAVA_JAR, guavaDexFolder, /* zipFile = */ false); + } + + @Test + public void services() throws Exception { + File servicesDexFolder = AbstractTestTools.createTempDir(); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToExe(SERVICES_JAR, servicesDexFolder, /* zipFile = */ false); + } + + @Test + public void arity() throws Exception { + File arityDexFolder = AbstractTestTools.createTempDir(); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToExe(ARITY_JAR, arityDexFolder, /* zipFile = */ false); + } + + @Test + public void playservices() throws Exception { + File playServiceDexFolder = AbstractTestTools.createTempDir(); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToExe(PLAY_SERVICE_JAR, playServiceDexFolder, /* zipFile = */ false); + } +} diff --git a/jack-tests/tests/com/android/jack/shrob/FlattenPackageTests.java b/jack-tests/tests/com/android/jack/shrob/FlattenPackageTests.java index a07b3c9..c59e2d7 100644 --- a/jack-tests/tests/com/android/jack/shrob/FlattenPackageTests.java +++ b/jack-tests/tests/com/android/jack/shrob/FlattenPackageTests.java @@ -66,7 +66,7 @@ public class FlattenPackageTests extends AbstractTest { // TODO(jmhenaff): Find a way to avoid this line? // This removes JUnit from default cp, otherwise this tests seems endless - env.setCandidateClasspath(new File[] {toolchain.getDefaultBootClasspath()[0]}); + env.setCandidateClasspath(toolchain.getDefaultBootClasspath()[0]); env.runTest(new ComparatorMapping(refOutputMapping, candidateOutputMapping)); } diff --git a/jack-tests/tests/com/android/jack/toolchain/ToolchainTest.java b/jack-tests/tests/com/android/jack/toolchain/ToolchainTest.java new file mode 100644 index 0000000..6f13e90 --- /dev/null +++ b/jack-tests/tests/com/android/jack/toolchain/ToolchainTest.java @@ -0,0 +1,164 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * 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.android.jack.toolchain; + +import com.android.jack.ProguardFlags; +import com.android.jack.Sourcelist; +import com.android.jack.TestTools; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.AndroidToolchain; +import com.android.jack.test.toolchain.Toolchain.SourceLevel; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; + +import java.io.File; +import java.util.ArrayList; +import java.util.List; + +/** + * Tests that test different steps of the Jack toolchain. + * These tests only rely on the Android tree for source lists. + * They are supposed to be run in test-jack (ideally before each commit). + */ +@Ignore("Tree") +public class ToolchainTest { + + private static Sourcelist CORE_SOURCELIST; + + private static Sourcelist BOUNCY_SOURCELIST; + + private static Sourcelist JUNIT_SOURCELIST; + + private static File corePath; + + @BeforeClass + public static void setup() throws Exception { + CORE_SOURCELIST = TestTools.getTargetLibSourcelist("core-libart"); + BOUNCY_SOURCELIST = + TestTools.getTargetLibSourcelist("bouncycastle"); + JUNIT_SOURCELIST = TestTools.getHostLibSourcelist("junit4-hostdex-jack"); + + File coreOut = AbstractTestTools.createTempFile("core", ".jack"); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.setSourceLevel(SourceLevel.JAVA_7); + toolchain.srcToLib(/* classpath = */ null, coreOut, /* zipFiles = */ true, CORE_SOURCELIST); + corePath = coreOut; + } + + @Test + public void shrobTestNoZip() throws Exception { + File shrobTestJackOut = AbstractTestTools.createTempDir(); + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test001"); + File sourceDir = new File(testFolder, "jack"); + String classpath = corePath.getAbsolutePath(); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToLib(classpath, shrobTestJackOut, /* zipFiles = */ false, sourceDir); + + File shrobTestShrunkOut = AbstractTestTools.createTempDir(); + List<ProguardFlags> flagFiles = new ArrayList<ProguardFlags>(); + flagFiles.add(new ProguardFlags(testFolder, "proguard.flags001")); + flagFiles.add(new ProguardFlags(testFolder, "proguard.flags004")); + toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToLib(shrobTestJackOut, shrobTestShrunkOut, /* zipFiles = */ false); + + File shrobTestDexOutFolder = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToExe(shrobTestShrunkOut, shrobTestDexOutFolder, /* zipFile = */ false); + } + + @Test + public void shrobTestZip() throws Exception { + File shrobTestJackOut = AbstractTestTools.createTempFile("shrobtest", ".jack"); + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test001"); + File sourceDir = new File(testFolder, "jack"); + String classpath = corePath.getAbsolutePath(); + + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToLib(classpath, shrobTestJackOut, /* zipFiles = */ true, sourceDir); + + File shrobTestShrunkOut = AbstractTestTools.createTempFile("shrunk", ".jack"); + List<ProguardFlags> flagFiles = new ArrayList<ProguardFlags>(); + flagFiles.add(new ProguardFlags(testFolder, "proguard.flags001")); + flagFiles.add(new ProguardFlags(testFolder, "proguard.flags004")); + toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToLib(shrobTestJackOut, shrobTestShrunkOut, /* zipFiles = */ true); + + File shrobTestDexOut = AbstractTestTools.createTempFile("shrobbed", ".dex.zip"); + toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToExe(shrobTestShrunkOut, shrobTestDexOut, /* zipFile = */ true); + } + + @Test + public void bouncyCastle() throws Exception { + File bouncyCastleJack = AbstractTestTools.createTempFile("bouncyjack", ".jack"); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToLib(corePath.getAbsolutePath(), bouncyCastleJack, /* zipFiles = */ true, + BOUNCY_SOURCELIST); + + File bouncyCastleOutFolder = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToExe(bouncyCastleJack, bouncyCastleOutFolder, /* zipFile = */ false); + } + + @Test + public void core() throws Exception { + File coreOutFolder = AbstractTestTools.createTempDir(); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToExe(corePath, coreOutFolder, /* zipFile = */ false); + } + + @Test + public void junit() throws Exception { + File junitJack = AbstractTestTools.createTempFile("junit", ".zip"); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToLib(corePath.getAbsolutePath() + + File.pathSeparator + TestTools.getFromAndroidTree( + "out/host/common/obj/JAVA_LIBRARIES/hamcrest-core-hostdex-jack_intermediates/classes.jack"), + junitJack, /* zipFiles = */ true, JUNIT_SOURCELIST); + + File junitOutFolder = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToExe(junitJack, junitOutFolder, /* zipFile = */ false); + } + + @Test + public void jarjarTest() throws Exception { + File jarjarTestJackOut = AbstractTestTools.createTempFile("jarjartest", ".jack"); + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.jarjar.test003"); + File sourceDir = new File(testFolder, "jack"); + String classpath = corePath.getAbsolutePath(); + AndroidToolchain toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToLib(classpath, jarjarTestJackOut, /* zipFiles = */ true, sourceDir); + + File dalvikAnnotations = TestTools.getFromAndroidTree("libcore/dalvik/src/main/java/"); + File dalvikAnnotationsJackOut = AbstractTestTools.createTempFile("dalvikannotations", ".jack"); + toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.srcToLib(classpath, dalvikAnnotationsJackOut, /* zipFiles = */ true, dalvikAnnotations); + + File jarjarTestRenamedOut = AbstractTestTools.createTempFile("jarjartestrenamed", ".jack"); + File jarjarRules = new File(testFolder, "jarjar-rules.txt"); + toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.setJarjarRules(jarjarRules); + toolchain.libToLib(jarjarTestJackOut, jarjarTestRenamedOut, /* zipFiles = */ true); + + File jarjarTestDexOutFolder = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class); + toolchain.libToExe(jarjarTestRenamedOut, jarjarTestDexOutFolder, /* zipFile = */ false); + } +} |