diff options
author | Jean-Marie Henaff <jmhenaff@google.com> | 2014-10-15 12:07:58 +0200 |
---|---|---|
committer | Jean-Marie Henaff <jmhenaff@google.com> | 2014-12-02 16:54:47 +0100 |
commit | 8a2287c6a462fbd338086d0f3f819c4bd2469bd9 (patch) | |
tree | 0bb7547db282ab3413000bbbdc6c448085ba5cdc /jack-tests/tests/com/android | |
parent | 4a95fec33c3822eb6a7b8c6bb8144608ae161f41 (diff) | |
download | toolchain_jack-8a2287c6a462fbd338086d0f3f819c4bd2469bd9.tar.gz toolchain_jack-8a2287c6a462fbd338086d0f3f819c4bd2469bd9.tar.bz2 toolchain_jack-8a2287c6a462fbd338086d0f3f819c4bd2469bd9.zip |
Use new JUnit based test framework
Bug: 18547020
Change-Id: I5d02ebdecbf79bea035ae8a042d50a06aa7c2a62
Diffstat (limited to 'jack-tests/tests/com/android')
124 files changed, 12984 insertions, 264 deletions
diff --git a/jack-tests/tests/com/android/jack/AllTests.java b/jack-tests/tests/com/android/jack/AllTests.java index 091867be..e8579dc7 100644 --- a/jack-tests/tests/com/android/jack/AllTests.java +++ b/jack-tests/tests/com/android/jack/AllTests.java @@ -1,54 +1,133 @@ -/* - * 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; +import com.android.jack.analysis.dfa.reachingdefs.ReachingDefsTests; import com.android.jack.annotation.AnnotationTests; import com.android.jack.arithmetic.ArithmeticTests; -import com.android.jack.classpath.ClasspathTest; -import com.android.jack.enums.EnumTests; -import com.android.jack.error.AnnotationProcessorErrorTest; -import com.android.jack.error.CommandLineErrorTest; -import com.android.jack.error.FileAccessErrorTest; -import com.android.jack.experimenal.incremental.DependenciesTests005; +import com.android.jack.array.ArrayTests; +import com.android.jack.assertion.AssertionTests; +import com.android.jack.assign.AssignTests; +import com.android.jack.box.BoxTests; +import com.android.jack.bridge.BridgeTests; +import com.android.jack.cast.CastAllTests; +import com.android.jack.classpath.ClasspathTests; +import com.android.jack.clinit.ClinitTests; +import com.android.jack.comparison.ComparisonTests; +import com.android.jack.compiletime.CompileTimeTests; +import com.android.jack.conditional.ConditionalTests; +import com.android.jack.constant.ConstantTests; +import com.android.jack.debug.DebugTests; +import com.android.jack.dx.DxTests; +import com.android.jack.enums.EnumsTests; +import com.android.jack.error.ErrorHandlingAllTests; +import com.android.jack.experimental.incremental.DependencyAllTests; +import com.android.jack.external.ExternalTests; +import com.android.jack.fibonacci.FibonacciTests; +import com.android.jack.field.FieldTests; +import com.android.jack.fileconflict.FileConflictTests; +import com.android.jack.flow.FlowTests; +import com.android.jack.frontend.MissingClassTest; +import com.android.jack.generic.basic.GenericTests; +import com.android.jack.ifstatement.IfstatementTests; +import com.android.jack.imports.ImportTests; +import com.android.jack.init.InitTests; +import com.android.jack.inner.InnerTests; +import com.android.jack.instance.InstanceTest; +import com.android.jack.invoke.InvokeTests; import com.android.jack.jarjar.JarjarTests; -import com.android.jack.shrob.ObfuscationWithoutMappingTests; +import com.android.jack.java7.Java7AllTest; +import com.android.jack.label.LabelTest; +import com.android.jack.lookup.LookupTests; +import com.android.jack.multidex.MultiDexAllTests; +import com.android.jack.newarray.NewarrayTests; +import com.android.jack.nopackage.NoPackageTests; +import com.android.jack.opcodes.OpcodesTests; +import com.android.jack.optimizations.exprsimplifier.ExprsimplifierTests; +import com.android.jack.optimizations.notsimplifier.NotsimplifierTests; +import com.android.jack.optimizations.uselesscopy.UselessVariableCopyTest; +import com.android.jack.order.OrderTests; +import com.android.jack.preprocessor.PreProcessorTests; +import com.android.jack.resource.ResourceTests; +import com.android.jack.returnstatement.ReturnstatementTests; +import com.android.jack.shrob.ShrobAllTests; +import com.android.jack.string.StringTests; +import com.android.jack.switchstatement.SwitchstatementTests; +import com.android.jack.synchronize.SynchronizeTests; +import com.android.jack.threeaddress.ThreeaddressTests; +import com.android.jack.throwstatement.ThrowstatementTests; import com.android.jack.tools.merger.MergerAllTests; +import com.android.jack.trycatch.TrycatchTests; +import com.android.jack.tryfinally.TryfinallyTests; +import com.android.jack.type.TypeTests; +import com.android.jack.unary.UnaryTests; +import com.android.jack.verify.VerifyTests; +import com.android.jack.withphantom.WithPhantomTests; import org.junit.runner.RunWith; import org.junit.runners.Suite; import org.junit.runners.Suite.SuiteClasses; -/** - * Test suite containing all tests (except for regression tests that must be run from the command - * line). - */ @RunWith(Suite.class) @SuiteClasses(value = { AnnotationTests.class, ArithmeticTests.class, - ClasspathTest.class, - DependenciesTests005.class, - EnumTests.class, + ArrayTests.class, + AssertionTests.class, + AssignTests.class, + BoxTests.class, + BridgeTests.class, + CastAllTests.class, + ClasspathTests.class, + ClinitTests.class, + ComparisonTests.class, + CompileTimeTests.class, + ConditionalTests.class, + ConstantTests.class, + DebugTests.class, + DependencyAllTests.class, + DxTests.class, + EnumsTests.class, + ExternalTests.class, + ErrorHandlingAllTests.class, + FibonacciTests.class, + FieldTests.class, + FileConflictTests.class, + FlowTests.class, + GenericTests.class, JarjarTests.class, + IfstatementTests.class, + InitTests.class, + InnerTests.class, + InstanceTest.class, + ImportTests.class, + InvokeTests.class, + Java7AllTest.class, + LabelTest.class, + LookupTests.class, MergerAllTests.class, - ObfuscationWithoutMappingTests.class, - AnnotationProcessorErrorTest.class, - FileAccessErrorTest.class, - CommandLineErrorTest.class + MissingClassTest.class, + MultiDexAllTests.class, + NewarrayTests.class, + ExprsimplifierTests.class, + NotsimplifierTests.class, + NoPackageTests.class, + OrderTests.class, + OpcodesTests.class, + PreProcessorTests.class, + ReturnstatementTests.class, + ResourceTests.class, + ReachingDefsTests.class, + ShrobAllTests.class, + StringTests.class, + SwitchstatementTests.class, + SynchronizeTests.class, + ThreeaddressTests.class, + ThrowstatementTests.class, + TrycatchTests.class, + TryfinallyTests.class, + TypeTests.class, + UnaryTests.class, + UselessVariableCopyTest.class, + VerifyTests.class, + WithPhantomTests.class, }) -public class AllTests { -} +public class AllTests {} diff --git a/jack-tests/tests/com/android/jack/LongLastingTests.java b/jack-tests/tests/com/android/jack/LongLastingTests.java new file mode 100644 index 00000000..d0a3f406 --- /dev/null +++ b/jack-tests/tests/com/android/jack/LongLastingTests.java @@ -0,0 +1,40 @@ +/* + * 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; + + +import com.android.jack.test.category.KnownBugs; +import com.android.jack.test.category.SlowTests; + +import org.junit.experimental.categories.Categories; +import org.junit.experimental.categories.Categories.ExcludeCategory; +import org.junit.experimental.categories.Categories.IncludeCategory; +import org.junit.runner.RunWith; +import org.junit.runners.Suite.SuiteClasses; + + + +/** + * Test suite containing tests that are too time-consuming and cannot be run before submitting each + * CL. + */ +@RunWith(Categories.class) +@IncludeCategory(SlowTests.class) +@ExcludeCategory(KnownBugs.class) +@SuiteClasses(value = {AllTests.class}) +public class LongLastingTests { +} diff --git a/jack-tests/tests/com/android/jack/PreSubmitTests.java b/jack-tests/tests/com/android/jack/PreSubmitTests.java new file mode 100644 index 00000000..ac877716 --- /dev/null +++ b/jack-tests/tests/com/android/jack/PreSubmitTests.java @@ -0,0 +1,34 @@ +/* + * 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; + + +import com.android.jack.test.category.NonPreSubmitTests; + +import org.junit.experimental.categories.Categories; +import org.junit.experimental.categories.Categories.ExcludeCategory; +import org.junit.runner.RunWith; +import org.junit.runners.Suite.SuiteClasses; + +/** + * Test suite to run before submitting a CL (along with regression tests). + */ +@RunWith(Categories.class) +@ExcludeCategory(NonPreSubmitTests.class) +@SuiteClasses(value = {AllWithRegressionTests.class}) +public class PreSubmitTests { +} diff --git a/jack-tests/tests/com/android/jack/RegressionTests.java b/jack-tests/tests/com/android/jack/RegressionTests.java index 3a7ecc6a..5cc95a04 100644 --- a/jack-tests/tests/com/android/jack/RegressionTests.java +++ b/jack-tests/tests/com/android/jack/RegressionTests.java @@ -18,9 +18,46 @@ package com.android.jack; import com.android.jack.annotation.AnnotationTests; import com.android.jack.arithmetic.ArithmeticTests; +import com.android.jack.array.ArrayTests; +import com.android.jack.assertion.AssertionTests; +import com.android.jack.assign.AssignTests; +import com.android.jack.box.BoxTests; +import com.android.jack.bridge.BridgeTests; +import com.android.jack.cast.CastTests; +import com.android.jack.comparison.ComparisonTests; +import com.android.jack.conditional.ConditionalTests; +import com.android.jack.constant.ConstantTests; +import com.android.jack.debug.DebugTests; +import com.android.jack.dx.DxTests; +import com.android.jack.enums.EnumsTests; +import com.android.jack.external.ExternalTests; +import com.android.jack.fibonacci.FibonacciTests; +import com.android.jack.field.FieldTests; +import com.android.jack.flow.FlowTests; +import com.android.jack.ifstatement.IfstatementTests; +import com.android.jack.init.InitTests; +import com.android.jack.inner.InnerTests; +import com.android.jack.invoke.InvokeTests; +import com.android.jack.newarray.NewarrayTests; +import com.android.jack.opcodes.OpcodesTests; +import com.android.jack.optimizations.exprsimplifier.ExprsimplifierTests; +import com.android.jack.optimizations.notsimplifier.NotsimplifierTests; +import com.android.jack.order.OrderTests; +import com.android.jack.returnstatement.ReturnstatementTests; +import com.android.jack.shrob.ShrobRuntimeTests; +import com.android.jack.string.StringTests; +import com.android.jack.switchstatement.SwitchstatementTests; +import com.android.jack.synchronize.SynchronizeTests; import com.android.jack.test.helper.RuntimeTestHelper; import com.android.jack.test.runtime.RuntimeTest; import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.threeaddress.ThreeaddressTests; +import com.android.jack.throwstatement.ThrowstatementTests; +import com.android.jack.trycatch.TrycatchTests; +import com.android.jack.tryfinally.TryfinallyTests; +import com.android.jack.type.TypeTests; +import com.android.jack.unary.UnaryTests; +import com.android.jack.verify.VerifyTests; import org.junit.BeforeClass; import org.junit.Test; @@ -32,7 +69,44 @@ public class RegressionTests { public RuntimeTest[] tests = { new AnnotationTests(), - new ArithmeticTests() + new ArithmeticTests(), + new ArrayTests(), + new AssertionTests(), + new AssignTests(), + new BoxTests(), + new BridgeTests(), + new CastTests(), + new ComparisonTests(), + new ConditionalTests(), + new ConstantTests(), + new DebugTests(), + new DxTests(), + new EnumsTests(), + new ExprsimplifierTests(), + new ExternalTests(), + new FibonacciTests(), + new FieldTests(), + new FlowTests(), + new IfstatementTests(), + new InitTests(), + new InnerTests(), + new InvokeTests(), + new NewarrayTests(), + new NotsimplifierTests(), +// new OpcodesTests(), + new OrderTests(), + new ReturnstatementTests(), + new ShrobRuntimeTests(), + new StringTests(), + new SwitchstatementTests(), + new SynchronizeTests(), + new ThreeaddressTests(), + new ThrowstatementTests(), + new TrycatchTests(), + new TryfinallyTests(), + new TypeTests(), + new UnaryTests(), + new VerifyTests(), }; @BeforeClass diff --git a/jack-tests/tests/com/android/jack/analysis/dfa/reachingdefs/ReachingDefsTests.java b/jack-tests/tests/com/android/jack/analysis/dfa/reachingdefs/ReachingDefsTests.java new file mode 100644 index 00000000..9053198f --- /dev/null +++ b/jack-tests/tests/com/android/jack/analysis/dfa/reachingdefs/ReachingDefsTests.java @@ -0,0 +1,46 @@ +/* + * 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.analysis.dfa.reachingdefs; + +import com.android.jack.Options; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackApiToolchain; +import com.android.jack.util.filter.SignatureMethodFilter; + +import org.junit.Test; + +import java.io.File; + +public class ReachingDefsTests { + + @Test + public void testDfa001() throws Exception { + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + toolchain.addProperty(Options.METHOD_FILTER.getName(), "method-with-signature"); + toolchain.addProperty(SignatureMethodFilter.METHOD_SIGNATURE_FILTER.getName(), + "dfaWithSwitch(I)I"); + toolchain.addProperty(ReachingDefinitions.REACHING_DEFS_CHECKER.getName(), "test001Checker"); + + String classpath = AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()); + File dexOutDir = AbstractTestTools.createTempDir(); + File testSourceDir = AbstractTestTools.getTestRootDir("com.android.jack.analysis.dfa.reachingdefs.test001"); + + toolchain.srcToExe(classpath, dexOutDir, /* zipFile = */ false, testSourceDir); + } +} diff --git a/jack-tests/tests/com/android/jack/annotation/AnnotationTests.java b/jack-tests/tests/com/android/jack/annotation/AnnotationTests.java index e68228ef..9b1aa63b 100644 --- a/jack-tests/tests/com/android/jack/annotation/AnnotationTests.java +++ b/jack-tests/tests/com/android/jack/annotation/AnnotationTests.java @@ -1,28 +1,29 @@ /* - * 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. - */ +* 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.annotation; -import com.android.jack.Main; +import com.android.jack.test.category.KnownBugs; import com.android.jack.test.category.RuntimeRegressionTest; import com.android.jack.test.helper.CheckDexStructureTestHelper; import com.android.jack.test.helper.RuntimeTestHelper; import com.android.jack.test.runtime.RuntimeTest; import com.android.jack.test.runtime.RuntimeTestInfo; import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; import org.junit.BeforeClass; import org.junit.Test; @@ -32,35 +33,148 @@ import java.io.File; public class AnnotationTests extends RuntimeTest { + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.annotation.test001"), + "com.android.jack.annotation.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.annotation.test002"), + "com.android.jack.annotation.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.annotation.test003"), + "com.android.jack.annotation.test003.dx.Tests"); + + private RuntimeTestInfo TEST005 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.annotation.test005"), + "com.android.jack.annotation.test005.dx.Tests"); + + private RuntimeTestInfo TEST006 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.annotation.test006"), + "com.android.jack.annotation.test006.dx.Tests"); + + private RuntimeTestInfo TEST007 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.annotation.test007"), + "com.android.jack.annotation.test007.dx.Tests"); + + private RuntimeTestInfo TEST008 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.annotation.test008"), + "com.android.jack.annotation.test008.dx.Tests"); + + private RuntimeTestInfo TEST009 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.annotation.test009"), + "com.android.jack.annotation.test009.dx.Tests"); + private static final File ANNOTATION001_PATH = AbstractTestTools.getTestRootDir("com.android.jack.annotation.test001.jack"); - private RuntimeTestInfo TEST001 = new RuntimeTestInfo( - AbstractTestTools.getTestRootDir("com.android.jack.annotation.test001"), - "com.android.jack.annotation.test001.dx.Tests"); - @BeforeClass public static void setUpClass() { - Main.class.getClassLoader().setDefaultAssertionStatus(true); + AnnotationTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(/* checkStructure = */ true); } @Test - public void checkStructure() throws Exception { - CheckDexStructureTestHelper env = - new CheckDexStructureTestHelper(new File(ANNOTATION001_PATH, "Annotation2.java")); - env.setWithDebugInfo(true); - env.compare(); + public void test001_2() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + new File[] { + new File(ANNOTATION001_PATH, "Annotation8.java"), + new File(ANNOTATION001_PATH, "Annotated2.java")}); } + @Test @Category(RuntimeRegressionTest.class) - public void runtimeTest001() throws Exception { - new RuntimeTestHelper(TEST001).compileAndRunTest(); + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(/* checkStructure = */ true); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(/* checkStructure = */ true); + } + + @Test + public void test003_1() throws Exception { + CheckDexStructureTestHelper helper = new CheckDexStructureTestHelper( + AbstractTestTools.getTestRootDir("com.android.jack.annotation.test003.jack")); + helper.compare(); + } + + @Test + public void test004() throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.annotation.test004"); + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + testFolder); + } + + @Test + public void test004_1() throws Exception { + CheckDexStructureTestHelper helper = new CheckDexStructureTestHelper( + AbstractTestTools.getTestRootDir("com.android.jack.annotation.test004.jack")); + helper.compare(); + } + + @Test + // Annotation on package are not supported in dex format: http://code.google.com/p/android/issues/detail?id=16149 + @Category({RuntimeRegressionTest.class, KnownBugs.class}) + public void test005() throws Exception { + new RuntimeTestHelper(TEST005).compileAndRunTest(); + } + + @Test + public void test005_1() throws Exception { + CheckDexStructureTestHelper helper = new CheckDexStructureTestHelper( + AbstractTestTools.getTestRootDir("com.android.jack.annotation.test005.jack")); + helper.compare(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test006() throws Exception { + new RuntimeTestHelper(TEST006).compileAndRunTest(/* checkStructure = */ true); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test007() throws Exception { + new RuntimeTestHelper(TEST007).compileAndRunTest(/* checkStructure = */ true); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test008() throws Exception { + new RuntimeTestHelper(TEST008).compileAndRunTest(/* checkStructure = */ true); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test009() throws Exception { + new RuntimeTestHelper(TEST009).compileAndRunTest(/* checkStructure = */ true); } @Override protected void fillRtTestInfos() { rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); +// rtTestInfos.add(TEST005); // KnownBug + rtTestInfos.add(TEST006); + rtTestInfos.add(TEST007); + rtTestInfos.add(TEST008); + rtTestInfos.add(TEST009); } - } diff --git a/jack-tests/tests/com/android/jack/arithmetic/ArithmeticTests.java b/jack-tests/tests/com/android/jack/arithmetic/ArithmeticTests.java index 1b6ee1a0..28a42725 100644 --- a/jack-tests/tests/com/android/jack/arithmetic/ArithmeticTests.java +++ b/jack-tests/tests/com/android/jack/arithmetic/ArithmeticTests.java @@ -1,18 +1,18 @@ /* - * 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. - */ +* 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.arithmetic; @@ -29,22 +29,54 @@ import org.junit.experimental.categories.Category; public class ArithmeticTests extends RuntimeTest { private RuntimeTestInfo TEST001 = new RuntimeTestInfo( - AbstractTestTools.getTestRootDir("com.android.jack.arithmetic.test001"), - "com.android.jack.arithmetic.test001.dx.Tests"); + AbstractTestTools.getTestRootDir("com.android.jack.arithmetic.test001"), + "com.android.jack.arithmetic.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.arithmetic.test002"), + "com.android.jack.arithmetic.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.arithmetic.test003"), + "com.android.jack.arithmetic.test003.dx.Tests"); + + private RuntimeTestInfo TEST004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.arithmetic.test004"), + "com.android.jack.arithmetic.test004.dx.Tests"); @BeforeClass public static void setUpClass() { ArithmeticTests.class.getClassLoader().setDefaultAssertionStatus(true); } - @Test @Category(RuntimeRegressionTest.class) public void test001() throws Exception { new RuntimeTestHelper(TEST001).compileAndRunTest(); } + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test004() throws Exception { + new RuntimeTestHelper(TEST004).compileAndRunTest(); + } + @Override protected void fillRtTestInfos() { rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); + rtTestInfos.add(TEST004); } } diff --git a/jack-tests/tests/com/android/jack/array/ArrayTests.java b/jack-tests/tests/com/android/jack/array/ArrayTests.java new file mode 100644 index 00000000..db2a4e85 --- /dev/null +++ b/jack-tests/tests/com/android/jack/array/ArrayTests.java @@ -0,0 +1,49 @@ +/* +* 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.array; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class ArrayTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.array.test001"), + "com.android.jack.array.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + ArrayTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/assertion/AssertionTests.java b/jack-tests/tests/com/android/jack/assertion/AssertionTests.java new file mode 100644 index 00000000..be97229c --- /dev/null +++ b/jack-tests/tests/com/android/jack/assertion/AssertionTests.java @@ -0,0 +1,73 @@ +/* +* 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.assertion; + +import com.android.jack.test.category.KnownBugs; +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class AssertionTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.assertion.test001"), + "com.android.jack.assertion.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.assertion.test002"), + "com.android.jack.assertion.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.assertion.test003"), + "com.android.jack.assertion.test003.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + AssertionTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + // this test must be run with assertions enabled (for now, use dalvik) + @Category({RuntimeRegressionTest.class, KnownBugs.class}) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { +// rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); + } +} diff --git a/jack-tests/tests/com/android/jack/assign/AssignTests.java b/jack-tests/tests/com/android/jack/assign/AssignTests.java new file mode 100644 index 00000000..565996a4 --- /dev/null +++ b/jack-tests/tests/com/android/jack/assign/AssignTests.java @@ -0,0 +1,49 @@ +/* +* 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.assign; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class AssignTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.assign.test001"), + "com.android.jack.assign.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + AssignTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/assign/dx/Tests.java b/jack-tests/tests/com/android/jack/assign/test001/dx/Tests.java index 24e1d415..4ca76b91 100644 --- a/jack-tests/tests/com/android/jack/assign/dx/Tests.java +++ b/jack-tests/tests/com/android/jack/assign/test001/dx/Tests.java @@ -14,13 +14,13 @@ * limitations under the License. */ -package com.android.jack.assign.dx; +package com.android.jack.assign.test001.dx; + +import com.android.jack.assign.test001.jack.Assignments; import org.junit.Assert; import org.junit.Test; -import com.android.jack.assign.jack.Assignments; - /** * Tests Assignments. */ diff --git a/jack-tests/tests/com/android/jack/assign/jack/Assignments.java b/jack-tests/tests/com/android/jack/assign/test001/jack/Assignments.java index d2a03d2a..7718129e 100644 --- a/jack-tests/tests/com/android/jack/assign/jack/Assignments.java +++ b/jack-tests/tests/com/android/jack/assign/test001/jack/Assignments.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.jack.assign.jack; +package com.android.jack.assign.test001.jack; public class Assignments { public static int field = 5; diff --git a/jack-tests/tests/com/android/jack/box/BoxTests.java b/jack-tests/tests/com/android/jack/box/BoxTests.java new file mode 100644 index 00000000..9f8c94d6 --- /dev/null +++ b/jack-tests/tests/com/android/jack/box/BoxTests.java @@ -0,0 +1,49 @@ +/* +* 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.box; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class BoxTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.box.test001"), + "com.android.jack.box.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + BoxTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/bridge/BridgeTests.java b/jack-tests/tests/com/android/jack/bridge/BridgeTests.java new file mode 100644 index 00000000..0b4eab9c --- /dev/null +++ b/jack-tests/tests/com/android/jack/bridge/BridgeTests.java @@ -0,0 +1,161 @@ +/* +* 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.bridge; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +public class BridgeTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.bridge.test001"), + "com.android.jack.bridge.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.bridge.test002"), + "com.android.jack.bridge.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.bridge.test003"), + "com.android.jack.bridge.test003.dx.Tests"); + + private RuntimeTestInfo TEST004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.bridge.test004"), + "com.android.jack.bridge.test004.dx.Tests"); + + private RuntimeTestInfo TEST005 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.bridge.test005"), + "com.android.jack.bridge.test005.dx.Tests"); + + private RuntimeTestInfo TEST006 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.bridge.test006"), + "com.android.jack.bridge.test006.dx.Tests"); + + private RuntimeTestInfo TEST007 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.bridge.test007"), + "com.android.jack.bridge.test007.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + BridgeTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test004() throws Exception { + new RuntimeTestHelper(TEST004).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test005() throws Exception { + new RuntimeTestHelper(TEST005).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test006() throws Exception { + new RuntimeTestHelper(TEST006).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + // TODO(jmhenaff): reintroduce ExtraTests category for this one? + public void test007() throws Exception { + new RuntimeTestHelper(TEST007).compileAndRunTest(); + } + + @Test + public void test008() throws Exception { + + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + File srcFolder = AbstractTestTools.getTestRootDir("com.android.jack.bridge.test008.jack"); + File jackZipOfGenericPackageProtected = AbstractTestTools.createTempFile("tmpBridge", ".zip"); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + jackZipOfGenericPackageProtected, + /* zipFiles = */ true, + srcFolder); + + // Build jack file from PublicExtendsGeneric.java + toolchain = AbstractTestTools.getCandidateToolchain(); + File jackZipOfPublicExtendsGeneric = AbstractTestTools.createTempFile("tmpBridge", ".zip"); + toolchain.srcToLib( + AbstractTestTools.getClasspathsAsString(toolchain.getDefaultBootClasspath(), new File [] {jackZipOfGenericPackageProtected}), + jackZipOfPublicExtendsGeneric, + /* zipFiles = */ true, + new File(srcFolder, "sub/PublicExtendsGeneric.java")); + + // Build dex file representing Caller.java + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain = toolchain.addStaticLibs(jackZipOfPublicExtendsGeneric); + File outDexFolder = AbstractTestTools.createTempDir(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + outDexFolder, + /* zipFile = */ false, + new File(srcFolder, "Caller.java")); + } + + @Test + public void test009() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.bridge.test009")); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); + rtTestInfos.add(TEST004); + rtTestInfos.add(TEST005); + rtTestInfos.add(TEST006); + rtTestInfos.add(TEST007); + } +} diff --git a/jack-tests/tests/com/android/jack/cast/CastAllTests.java b/jack-tests/tests/com/android/jack/cast/CastAllTests.java new file mode 100644 index 00000000..803546b0 --- /dev/null +++ b/jack-tests/tests/com/android/jack/cast/CastAllTests.java @@ -0,0 +1,29 @@ +/* + * 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.cast; + +import org.junit.experimental.categories.Categories; +import org.junit.runner.RunWith; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Categories.class) +@SuiteClasses( +value = { + CastTests.class, + UselessCastRemoverTest.class + }) +public class CastAllTests { +}
\ No newline at end of file diff --git a/jack-tests/tests/com/android/jack/cast/CastTests.java b/jack-tests/tests/com/android/jack/cast/CastTests.java new file mode 100644 index 00000000..c0761f7f --- /dev/null +++ b/jack-tests/tests/com/android/jack/cast/CastTests.java @@ -0,0 +1,139 @@ +/* +* 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.cast; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import javax.annotation.Nonnull; + +public class CastTests extends RuntimeTest { + + private RuntimeTestInfo EXPLICIT001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.cast.explicit001"), + "com.android.jack.cast.explicit001.dx.Tests"); + + private RuntimeTestInfo IMPLICIT001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.cast.implicit001"), + "com.android.jack.cast.implicit001.dx.Tests"); + + private RuntimeTestInfo IMPLICIT002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.cast.implicit002"), + "com.android.jack.cast.implicit002.dx.Tests"); + + private RuntimeTestInfo IMPLICIT003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.cast.implicit003"), + "com.android.jack.cast.implicit003.dx.Tests"); + + private RuntimeTestInfo IMPLICIT004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.cast.implicit004"), + "com.android.jack.cast.implicit004.dx.Tests"); + + private RuntimeTestInfo USELESS001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.cast.useless001"), + "com.android.jack.cast.useless001.dx.Tests"); + + private RuntimeTestInfo USELESS002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.cast.useless002"), + "com.android.jack.cast.useless002.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + CastTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void explicit001() throws Exception { + new RuntimeTestHelper(EXPLICIT001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void implicit001() throws Exception { + new RuntimeTestHelper(IMPLICIT001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void implicit002() throws Exception { + new RuntimeTestHelper(IMPLICIT002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void implicit003() throws Exception { + new RuntimeTestHelper(IMPLICIT003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void implicit004() throws Exception { + new RuntimeTestHelper(IMPLICIT004).compileAndRunTest(); + } + + @Test + public void implicitCast005() throws Exception { + compileTest("implicit005"); + } + + @Test + public void implicitCast006() throws Exception { + compileTest("implicit006"); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void useless001() throws Exception { + new RuntimeTestHelper(USELESS001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void useless002() throws Exception { + new RuntimeTestHelper(USELESS002).compileAndRunTest(); + } + + /** + * Verifies that the test source can compile from source to dex file. + */ + private void compileTest(@Nonnull String name) throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */false, + AbstractTestTools.getTestRootDir("com.android.jack.cast." + name + ".jack")); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(EXPLICIT001); + rtTestInfos.add(IMPLICIT001); + rtTestInfos.add(IMPLICIT002); + rtTestInfos.add(IMPLICIT003); + rtTestInfos.add(IMPLICIT004); + rtTestInfos.add(USELESS001); + rtTestInfos.add(USELESS002); + } +} diff --git a/jack-tests/tests/com/android/jack/cast/UselessCastRemoverTest.java b/jack-tests/tests/com/android/jack/cast/UselessCastRemoverTest.java new file mode 100644 index 00000000..da117bde --- /dev/null +++ b/jack-tests/tests/com/android/jack/cast/UselessCastRemoverTest.java @@ -0,0 +1,101 @@ +/* + * 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.cast; + + +import com.android.jack.TestTools; +import com.android.jack.backend.dex.DexFileWriter; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import junit.framework.Assert; + +import org.jf.dexlib.CodeItem; +import org.jf.dexlib.DexFile; +import org.jf.dexlib.Code.Instruction; +import org.jf.dexlib.Code.Opcode; +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; + +import javax.annotation.Nonnull; + +public class UselessCastRemoverTest { + + @Nonnull + private static final String CAST = "com/android/jack/transformations/cast/jack/Data"; + + @Nonnull + private static final String CAST_USELESS002 = "com/android/jack/cast/useless002/jack/UselessCast"; + @Nonnull + private static final String CAST_USELESS003 = "com/android/jack/cast/useless003/jack/UselessCast"; + + @BeforeClass + public static void setUp() throws Exception { + UselessCastRemoverTest.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void test001() throws Exception { + compileAndCheckUselessCast("com.android.jack.cast.test001", + "Lcom/android/jack/cast/test001/jack/Test001;", "get", + "(Lcom/android/jack/cast/test001/jack/Test001;)I"); + } + + @Test + public void test002() throws Exception { + compileAndCheckUselessCast("com.android.jack.cast.test002", + "Lcom/android/jack/cast/test002/jack/Test002;", "get", + "(Lcom/android/jack/cast/test002/jack/Test002;)I"); + } + + @Test + public void test003() throws Exception { + compileAndCheckUselessCast("com.android.jack.cast.test003", + "Lcom/android/jack/cast/test003/jack/Test003;", "get", + "(Lcom/android/jack/cast/test003/jack/A;)I"); + } + + private void compileAndCheckUselessCast(@Nonnull String testPackage, @Nonnull String typeSig, + @Nonnull String methodName, @Nonnull String methSig) throws Exception { + File testFolder = AbstractTestTools.getTestRootDir(testPackage); + File outFolder = AbstractTestTools.createTempDir(); + File out = new File(outFolder, DexFileWriter.DEX_FILENAME); + + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + outFolder, + /* zipFile = */false, testFolder); + + DexFile dexFile = new DexFile(out); + CodeItem ci = TestTools.getEncodedMethod(dexFile, typeSig, methodName, methSig).codeItem; + + Assert.assertFalse(hasOpcode(ci, Opcode.CHECK_CAST)); + Assert.assertFalse(hasOpcode(ci, Opcode.CHECK_CAST_JUMBO)); + } + + private boolean hasOpcode(@Nonnull CodeItem codeItem, @Nonnull Opcode opcode) { + for (Instruction inst : codeItem.getInstructions()) { + if (inst.opcode == opcode) { + return true; + } + } + return false; + } + +}
\ No newline at end of file diff --git a/jack-tests/tests/com/android/jack/classpath/ClasspathTest.java b/jack-tests/tests/com/android/jack/classpath/ClasspathTest.java deleted file mode 100644 index 8fde0388..00000000 --- a/jack-tests/tests/com/android/jack/classpath/ClasspathTest.java +++ /dev/null @@ -1,77 +0,0 @@ -/* - * 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.classpath; - -import com.android.jack.test.toolchain.AbstractTestTools; -import com.android.jack.test.toolchain.IToolchain; - -import org.junit.BeforeClass; -import org.junit.Test; - -import java.io.File; - -public class ClasspathTest { - - @BeforeClass - public static void setUpClass() { - ClasspathTest.class.getClassLoader().setDefaultAssertionStatus(true); - } - - @Test - public void test001() throws Exception { - File libOut = AbstractTestTools.createTempDir(); - - IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); - toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), - libOut, false, - new File(AbstractTestTools.getTestRootDir("com.android.jack.classpath.test001"), "lib")); - - File testOut = AbstractTestTools.createTempDir(); - toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) - + File.pathSeparatorChar + libOut.getAbsolutePath(), testOut, false, - new File(AbstractTestTools.getTestRootDir("com.android.jack.classpath.test001"), "jack")); - } - - @Test - public void test002() throws Exception { - IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); - - File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.classpath.test002"); - File outFolder = AbstractTestTools.createTempDir(); - - File lib1Out = AbstractTestTools.createDir(outFolder, "lib1"); - toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), - lib1Out, - /* zipFiles = */ false, new File(testFolder, "lib1")); - - File lib1BisOut = AbstractTestTools.createDir(outFolder, "lib1override"); - toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), - lib1BisOut, - /* zipFiles = */false, new File(testFolder, "lib1override")); - - File lib2Out = AbstractTestTools.createDir(outFolder, "lib2"); - toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) - + File.pathSeparatorChar + lib1Out.getAbsolutePath(), lib2Out, - /* zipFiles = */false, new File(testFolder, "lib2")); - - toolchain.addStaticLibs(lib2Out); - toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) - + File.pathSeparatorChar + lib1BisOut.getAbsolutePath(), outFolder, - new File(testFolder, "jack")); - - } -} diff --git a/jack-tests/tests/com/android/jack/classpath/ClasspathTests.java b/jack-tests/tests/com/android/jack/classpath/ClasspathTests.java new file mode 100644 index 00000000..f43e3b05 --- /dev/null +++ b/jack-tests/tests/com/android/jack/classpath/ClasspathTests.java @@ -0,0 +1,202 @@ +/* + * 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.classpath; + +import com.android.jack.Jack; +import com.android.jack.JackAbortException; +import com.android.jack.Options; +import com.android.jack.TestTools; +import com.android.jack.library.FileType; +import com.android.jack.library.LibraryReadingException; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; +import java.io.IOException; + +public class ClasspathTests { + + @BeforeClass + public static void setUpClass() { + ClasspathTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void test001() throws Exception { + File libOut = AbstractTestTools.createTempDir(); + + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + libOut, false, + new File(AbstractTestTools.getTestRootDir("com.android.jack.classpath.test001"), "lib")); + + File testOut = AbstractTestTools.createTempDir(); + toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparatorChar + libOut.getAbsolutePath(), testOut, false, + new File(AbstractTestTools.getTestRootDir("com.android.jack.classpath.test001"), "jack")); + } + + @Test + public void test002() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + + String defaultBootCp = + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()); + + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.classpath.test002"); + File outFolder = AbstractTestTools.createTempDir(); + + File lib1Out = AbstractTestTools.createDir(outFolder, "lib1"); + toolchain.srcToLib(defaultBootCp, + lib1Out, + /* zipFiles = */ false, new File(testFolder, "lib1")); + + File lib1BisOut = AbstractTestTools.createDir(outFolder, "lib1override"); + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToLib(defaultBootCp, + lib1BisOut, + /* zipFiles = */ false, new File(testFolder, "lib1override")); + + File lib2Out = AbstractTestTools.createDir(outFolder, "lib2"); + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToLib(defaultBootCp + + File.pathSeparatorChar + lib1Out.getAbsolutePath(), lib2Out, + /* zipFiles = */ false, new File(testFolder, "lib2")); + + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.addStaticLibs(lib2Out); + toolchain.srcToExe(defaultBootCp + + File.pathSeparatorChar + lib1BisOut.getAbsolutePath(), outFolder, + /* zipFile = */ false, new File(testFolder, "jack")); + + } + + @Test + public void test003() throws Exception { + File testDir = AbstractTestTools.getTestRootDir("com.android.jack.classpath.test003"); + + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + File libOut = AbstractTestTools.createTempDir(); + File libSrc = new File(testDir, "lib"); + String defaultBootClasspath = + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()); + toolchain.srcToLib(defaultBootClasspath, libOut, /* zipFiles = */ false, libSrc); + + { + // reference compilation + toolchain = AbstractTestTools.getCandidateToolchain(); + File testOut = AbstractTestTools.createTempDir(); + File testSrc = new File(testDir, "jack"); + toolchain.srcToLib(defaultBootClasspath + File.pathSeparatorChar + libOut.getAbsolutePath(), + testOut, /* zipFiles = */ false, testSrc); + } + + { + // delete unused inner in classpath and check we can still compile with it + boolean deleted = + new File(libOut, FileType.JAYCE.getPrefix() + + "/com/android/jack/classpath/test003/lib/HasInnersClasses$InnerToDelete.jayce") + .delete(); + Assert.assertTrue(deleted); + toolchain = AbstractTestTools.getCandidateToolchain(); + File testOut = AbstractTestTools.createTempDir(); + File testSrc = new File(testDir, "jack"); + toolchain.srcToLib(defaultBootClasspath + File.pathSeparatorChar + libOut.getAbsolutePath(), + testOut, /* zipFiles = */ false, testSrc); + } + } + + @Test + public void libOfLib() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + String defaultClasspath = + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()); + File libOfLibOut = AbstractTestTools.createTempFile("libOfLibOut", ".zip"); + File sourceDir = AbstractTestTools.getTestRootDir("com.android.jack.liboflib.lib2"); + toolchain.srcToLib(defaultClasspath, libOfLibOut, /* zipFiles = */ true, sourceDir); + + toolchain = AbstractTestTools.getCandidateToolchain(); + File libOut = AbstractTestTools.createTempFile("libOut", ".zip"); + sourceDir = AbstractTestTools.getTestRootDir("com.android.jack.liboflib.lib"); + toolchain.srcToLib(defaultClasspath + File.pathSeparatorChar + libOfLibOut.getAbsolutePath(), + libOut, /* zipFiles = */ true, sourceDir); + + toolchain = AbstractTestTools.getCandidateToolchain(); + File mainOut = AbstractTestTools.createTempFile("mainOut", ".zip"); + sourceDir = AbstractTestTools.getTestRootDir("com.android.jack.liboflib.main"); + toolchain.srcToLib(defaultClasspath + File.pathSeparatorChar + libOut.getAbsolutePath(), + mainOut, /* zipFiles = */ true, sourceDir); + } + + @Test + public void testMissingClasspathEntry() throws Exception { + String defaultClasspath = TestTools.getDefaultBootclasspathString(); + File srcDir = TestTools.getJackTestsWithJackFolder("classpath/test004"); + String classpathWithMissingEntry = defaultClasspath + File.pathSeparator + + new File(srcDir, "missing.jack").getAbsolutePath(); + + File testOut = TestTools.createTempFile("ClasspathTest", "missing"); + TestTools.compileSourceToJack(new Options(), srcDir, classpathWithMissingEntry, + testOut, true); + + Options strict = new Options(); + strict.addProperty(Jack.STRICT_CLASSPATH.getName(), "true"); + try { + TestTools.compileSourceToJack(strict, srcDir, classpathWithMissingEntry, + testOut, true); + Assert.fail(); + } catch (JackAbortException e) { + Assert.assertTrue(e.getCause() instanceof LibraryReadingException); + } + } + + @Test + public void testInvalidClasspathEntry() throws Exception { + File srcDir = TestTools.getJackTestsWithJackFolder("classpath/test004"); + compileWithInvalidClasspathEntry(srcDir, new File(srcDir, "Classpath004.java")); + compileWithInvalidClasspathEntry(srcDir, new File(srcDir, "invalid.jack")); + compileWithInvalidClasspathEntry(srcDir, new File(srcDir, "notjack.zip")); + } + + private void compileWithInvalidClasspathEntry(File srcDir, File invalidJack) throws IOException, + Exception { + Assert.assertTrue(invalidJack.isFile()); + String classpathWithInvalidEntry = TestTools.getDefaultBootclasspathString() + + File.pathSeparator + invalidJack.getAbsolutePath(); + + File testOut = TestTools.createTempFile("ClasspathTest", "invalid"); + TestTools.compileSourceToJack(new Options(), srcDir, classpathWithInvalidEntry, + testOut, true); + + Options strict = new Options(); + strict.addProperty(Jack.STRICT_CLASSPATH.getName(), "true"); + try { + TestTools.compileSourceToJack(strict, srcDir, classpathWithInvalidEntry, + testOut, true); + Assert.fail(); + } catch (JackAbortException e) { + Assert.assertTrue(e.getCause() instanceof LibraryReadingException); + } + } + + +} diff --git a/jack-tests/tests/com/android/jack/clinit/ClinitTests.java b/jack-tests/tests/com/android/jack/clinit/ClinitTests.java new file mode 100644 index 00000000..be461e2d --- /dev/null +++ b/jack-tests/tests/com/android/jack/clinit/ClinitTests.java @@ -0,0 +1,46 @@ +/* + * 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.clinit; + +import com.android.jack.Main; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.Before; +import org.junit.Test; + +public class ClinitTests { + + public static final String CLASS_WITH_VARIABLE_INIT_BINARY_NAME + = "com/android/jack/clinit/jack/ClInitWithVariableInit"; + + @Before + public void setUp() throws Exception { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void testCompileWithClinit() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.clinit.jack")); + } + +} diff --git a/jack-tests/tests/com/android/jack/comparison/ComparisonTests.java b/jack-tests/tests/com/android/jack/comparison/ComparisonTests.java new file mode 100644 index 00000000..6a85530e --- /dev/null +++ b/jack-tests/tests/com/android/jack/comparison/ComparisonTests.java @@ -0,0 +1,50 @@ +/* +* 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.comparison; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class ComparisonTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.comparison.test001"), + "com.android.jack.comparison.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + ComparisonTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/compiletime/CompileTimeTests.java b/jack-tests/tests/com/android/jack/compiletime/CompileTimeTests.java new file mode 100644 index 00000000..878fd40d --- /dev/null +++ b/jack-tests/tests/com/android/jack/compiletime/CompileTimeTests.java @@ -0,0 +1,53 @@ +/* +* 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.compiletime; + +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.BeforeClass; +import org.junit.Test; + +public class CompileTimeTests { + + + @BeforeClass + public static void setUpClass() { + CompileTimeTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void test001() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.compiletime.test001.jack")); + } + + @Test + public void test002() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.compiletime.test002.jack")); + } + +} diff --git a/jack-tests/tests/com/android/jack/conditional/ConditionalTests.java b/jack-tests/tests/com/android/jack/conditional/ConditionalTests.java new file mode 100644 index 00000000..c7d42543 --- /dev/null +++ b/jack-tests/tests/com/android/jack/conditional/ConditionalTests.java @@ -0,0 +1,115 @@ +/* +* 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.conditional; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class ConditionalTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.conditional.test001"), + "com.android.jack.conditional.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.conditional.test002"), + "com.android.jack.conditional.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.conditional.test003"), + "com.android.jack.conditional.test003.dx.Tests"); + + private RuntimeTestInfo TEST004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.conditional.test004"), + "com.android.jack.conditional.test004.dx.Tests"); + + private RuntimeTestInfo TEST005 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.conditional.test005"), + "com.android.jack.conditional.test005.dx.Tests"); + + private RuntimeTestInfo TEST006 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.conditional.test006"), + "com.android.jack.conditional.test006.dx.Tests"); + + private RuntimeTestInfo TEST007 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.conditional.test007"), + "com.android.jack.conditional.test007.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + ConditionalTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test004() throws Exception { + new RuntimeTestHelper(TEST004).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test005() throws Exception { + new RuntimeTestHelper(TEST005).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test006() throws Exception { + new RuntimeTestHelper(TEST006).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test007() throws Exception { + new RuntimeTestHelper(TEST007).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); + rtTestInfos.add(TEST004); + rtTestInfos.add(TEST005); + rtTestInfos.add(TEST006); + rtTestInfos.add(TEST007); + } +} diff --git a/jack-tests/tests/com/android/jack/constant/ConstantTests.java b/jack-tests/tests/com/android/jack/constant/ConstantTests.java new file mode 100644 index 00000000..d60fb2f7 --- /dev/null +++ b/jack-tests/tests/com/android/jack/constant/ConstantTests.java @@ -0,0 +1,174 @@ +/* +* 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.constant; + +import com.android.jack.TestTools; +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.FileChecker; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import junit.framework.Assert; + +import org.jf.dexlib.CodeItem; +import org.jf.dexlib.DexFile; +import org.jf.dexlib.Code.Instruction; +import org.jf.dexlib.Code.Opcode; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; + +public class ConstantTests extends RuntimeTest { + + private RuntimeTestInfo CLAZZ = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.constant.clazz"), + "com.android.jack.constant.clazz.dx.Tests"); + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.constant.test001"), + "com.android.jack.constant.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.constant.test002"), + "com.android.jack.constant.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.constant.test003"), + "com.android.jack.constant.test003.dx.Tests"); + + private RuntimeTestInfo TEST004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.constant.test004"), + "com.android.jack.constant.test004.dx.Tests"); + + private RuntimeTestInfo TEST005 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.constant.test005"), + "com.android.jack.constant.test005.dx.Tests"); + + private RuntimeTestInfo TEST006 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.constant.test006"), + "com.android.jack.constant.test006.dx.Tests"); + + private RuntimeTestInfo TEST007 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.constant.test007"), + "com.android.jack.constant.test007.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + ConstantTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void clazz() throws Exception { + new RuntimeTestHelper(CLAZZ).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test004() throws Exception { + new RuntimeTestHelper(TEST004).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test005() throws Exception { + new RuntimeTestHelper(TEST005) + .addTestExeFileChecker(new FileChecker() { + + @Override + public void check(@Nonnull File file) throws Exception { + DexFile dexFile = new DexFile(file); + CodeItem ci = + TestTools.getEncodedMethod(dexFile, "Lcom/android/jack/constant/test005/jack/Constant005;", + "test", "()I").codeItem; + + Assert.assertEquals(7, countOpcode(ci, Opcode.CONST_4)); + } + }).compileAndRunTest(); + } + + @Nonnegative + private int countOpcode(@Nonnull CodeItem codeItem, @Nonnull Opcode opcode) { + int countOpcode = 0; + for (Instruction inst : codeItem.getInstructions()) { + if (inst.opcode == opcode) { + countOpcode++; + } + } + return countOpcode; + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test006() throws Exception { + new RuntimeTestHelper(TEST006).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test007() throws Exception { + new RuntimeTestHelper(TEST007).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test008() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.constant.test008")); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(CLAZZ); + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); + rtTestInfos.add(TEST004); + rtTestInfos.add(TEST005); + rtTestInfos.add(TEST006); + rtTestInfos.add(TEST007); + } +} diff --git a/jack-tests/tests/com/android/jack/debug/DebugTests.java b/jack-tests/tests/com/android/jack/debug/DebugTests.java new file mode 100644 index 00000000..2cfd0d2d --- /dev/null +++ b/jack-tests/tests/com/android/jack/debug/DebugTests.java @@ -0,0 +1,147 @@ +/* +* 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.debug; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.CheckDexStructureTestHelper; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import javax.annotation.Nonnull; + +public class DebugTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.debug.test001"), + "com.android.jack.debug.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.debug.test002"), + "com.android.jack.debug.test002.dx.Tests"); + + private RuntimeTestInfo TEST004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.debug.test004"), + "com.android.jack.debug.test004.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + DebugTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001) + .setWithDebugInfos(true).compileAndRunTest(/* checkStructure = */ true); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002) + .setWithDebugInfos(true).compileAndRunTest(/* checkStructure = */ true); + } + + @Test + public void test003() throws Exception { + checkStructure("003"); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test004() throws Exception { + new RuntimeTestHelper(TEST004) + .setWithDebugInfos(true).compileAndRunTest(/* checkStructure = */ true); + } + + @Test + public void test005() throws Exception { + checkStructure("005"); + } + + @Test + public void test006() throws Exception { + checkStructure("006"); + } + + @Test + public void test007() throws Exception { + checkStructure("007"); + } + + @Test + public void test008() throws Exception { + checkStructure("008"); + } + + @Test + public void test009() throws Exception { + checkStructure("009"); + } + + @Test + public void test010() throws Exception { + checkStructure("010"); + } + + @Test + public void test011() throws Exception { + checkStructure("011"); + } + + @Test + public void test012() throws Exception { + checkStructure("012"); + } + + @Test + public void test013() throws Exception { + checkStructure("013"); + } + + @Test + public void test014() throws Exception { + checkStructure("014"); + } + + @Test + @Ignore("Debug comparison fails because of local variable default initialization") + public void test019() throws Exception { + checkStructure("019"); + } + + private void checkStructure(@Nonnull String testNumber) throws Exception { + CheckDexStructureTestHelper helper = new CheckDexStructureTestHelper( + AbstractTestTools.getTestRootDir("com.android.jack.debug.test" + testNumber + ".jack")); + helper.setWithDebugInfo(true).compare(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST004); + } +} diff --git a/jack-tests/tests/com/android/jack/dx/DxTests.java b/jack-tests/tests/com/android/jack/dx/DxTests.java new file mode 100644 index 00000000..9e5e8155 --- /dev/null +++ b/jack-tests/tests/com/android/jack/dx/DxTests.java @@ -0,0 +1,171 @@ +/* +* 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.dx; + +import com.android.jack.TestTools; +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.FileChecker; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import junit.framework.Assert; + +import org.jf.dexlib.CodeItem; +import org.jf.dexlib.DexFile; +import org.jf.dexlib.ClassDataItem.EncodedMethod; +import org.jf.dexlib.Code.Instruction; +import org.jf.dexlib.Code.Opcode; +import org.jf.dexlib.Code.Analysis.AnalyzedInstruction; +import org.jf.dexlib.Code.Analysis.MethodAnalyzer; +import org.jf.dexlib.Code.Format.Instruction23x; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +import javax.annotation.Nonnull; + +public class DxTests extends RuntimeTest { + + private RuntimeTestInfo COMPILER = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.dx.compiler"), + "com.android.jack.dx.compiler.dx.Tests"); + + private RuntimeTestInfo OPTIMIZER = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.dx.optimizer"), + "com.android.jack.dx.optimizer.dx.Tests"); + + private RuntimeTestInfo OVERLAPPING = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.dx.overlapping"), + "com.android.jack.dx.overlapping.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + DxTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void compiler() throws Exception { + new RuntimeTestHelper(COMPILER).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void optimizer() throws Exception { + new RuntimeTestHelper(OPTIMIZER).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void overlapping() throws Exception { + new RuntimeTestHelper(OVERLAPPING) + .addTestExeFileChecker(new FileChecker() { + + @Override + public void check(@Nonnull File file) throws Exception { + DexFile dexFile = new DexFile(file); + EncodedMethod em = + TestTools.getEncodedMethod(dexFile, + "Lcom/android/jack/dx/overlapping/jack/Data;", "test002", + "(IJJ)J"); + + checkThatRegistersDoesNotOverlap(em); + } + + }) + .addTestExeFileChecker(new FileChecker() { + + @Override + public void check(@Nonnull File file) throws Exception { + DexFile dexFile = new DexFile(file); + EncodedMethod em = + TestTools.getEncodedMethod(dexFile, + "Lcom/android/jack/dx/overlapping/jack/Data;", "test001", + "(IJJ)J"); + + checkThatRegistersDoesNotOverlap(em); + } + + }) + .compileAndRunTest(); + } + + @Test + @Ignore("Dx register allocator use div_int instead of div_int_2addr in some cases.") + public void testRegallocator() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + File dexOutDir = AbstractTestTools.createTempDir(); + File outFile = new File(dexOutDir, "classes.dex"); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + dexOutDir, + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.dx.regallocator.jack")); + + DexFile dexFile = new DexFile(outFile); + + CodeItem ci = + TestTools.getEncodedMethod(dexFile, "Lcom/android/jack/dx/regallocator/jack/Data;", + "compute1", "(I)I").codeItem; + Assert.assertTrue(hasOpcode(ci, Opcode.DIV_INT_2ADDR)); + ci = + TestTools.getEncodedMethod(dexFile, "Lcom/android/jack/dx/regallocator/jack/Data;", + "compute2", "(I)I").codeItem; + Assert.assertTrue(hasOpcode(ci, Opcode.DIV_INT_2ADDR)); + } + + private boolean hasOpcode(@Nonnull CodeItem codeItem, @Nonnull Opcode opcode) { + for (Instruction inst : codeItem.getInstructions()) { + if (inst.opcode == opcode) { + return true; + } + } + return false; + } + + private void checkThatRegistersDoesNotOverlap(@Nonnull EncodedMethod em) { + MethodAnalyzer ma = new MethodAnalyzer(em, false, null); + for (AnalyzedInstruction ai : ma.getInstructions()) { + if (ai.getInstruction() instanceof Instruction23x) { + Instruction23x inst = (Instruction23x) ai.getInstruction(); + // Register overlaps in the following cases + // v0, v1 = ..., v1, v2 + // v0, v1 = v1, v2, ... + // v1, v2 = ..., v0, v1 + // v1, v2 = v0, v1, ... + if (inst.getRegisterA() + 1 == inst.getRegisterC() + || inst.getRegisterA() + 1 == inst.getRegisterB() + || inst.getRegisterA() == inst.getRegisterC() + 1 + || inst.getRegisterA() == inst.getRegisterB() + 1) { + Assert.fail("Register overlapping"); + } + } + } + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(COMPILER); + rtTestInfos.add(OPTIMIZER); + rtTestInfos.add(OVERLAPPING); + } +} diff --git a/jack-tests/tests/com/android/jack/enums/EnumsTests.java b/jack-tests/tests/com/android/jack/enums/EnumsTests.java new file mode 100644 index 00000000..0b6bb7d0 --- /dev/null +++ b/jack-tests/tests/com/android/jack/enums/EnumsTests.java @@ -0,0 +1,69 @@ +/* +* 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.enums; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class EnumsTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.enums.test001"), + "com.android.jack.enums.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.enums.test002"), + "com.android.jack.enums.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.enums.test003"), + "com.android.jack.enums.test003.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + EnumsTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + } +} diff --git a/jack-tests/tests/com/android/jack/error/AnnotationProcessorErrorTest.java b/jack-tests/tests/com/android/jack/error/AnnotationProcessorErrorTest.java index fea5b186..5cbd7a01 100644 --- a/jack-tests/tests/com/android/jack/error/AnnotationProcessorErrorTest.java +++ b/jack-tests/tests/com/android/jack/error/AnnotationProcessorErrorTest.java @@ -64,7 +64,7 @@ public class AnnotationProcessorErrorTest { public void testAnnotationProcessorError001() throws Exception { ErrorTestHelper te = new ErrorTestHelper(); - AbstractTestTools.createJavaFile(te.getSourceFolder(),"jack.incremental", "A.java", + AbstractTestTools.createFile(te.getSourceFolder(),"jack.incremental", "A.java", "package jack.incremental; \n"+ "public class A {} \n"); @@ -74,7 +74,7 @@ public class AnnotationProcessorErrorTest { try { jackApiToolchain.srcToExe( AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()), - te.getOutputDexFolder(), te.getSourceFolder()); + te.getOutputDexFolder(), /* zipFile = */ false, te.getSourceFolder()); Assert.fail(); } catch (JackUserException e) { // Failure is ok since output for annotation processor is not specify. @@ -110,7 +110,7 @@ public class AnnotationProcessorErrorTest { jackApiToolchain.srcToExe( AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()) - + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), te.getSourceFolder()); + + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), /* zipFile = */ false, te.getSourceFolder()); Assert.fail(); } catch (FrontendCompilationException e) { @@ -131,7 +131,7 @@ public class AnnotationProcessorErrorTest { buildAnnotationRequiredByAnnotationProc(te, new Class<?>[] {SourceAnnotationTest.class, SourceErrorAnnotationTest.class}); - AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n" + AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n" + "import " + SourceErrorAnnotationTest.class.getName() + ";\n" + "@" + SourceErrorAnnotationTest.class.getSimpleName() + "\n" + "public class A {}\n"); @@ -146,7 +146,7 @@ public class AnnotationProcessorErrorTest { try { jackApiToolchain.srcToExe( AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()) - + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), te.getSourceFolder()); + + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), /* zipFile = */ false, te.getSourceFolder()); Assert.fail(); } catch (FrontendCompilationException ex) { // Failure is ok since source generated by annotation processor does not compile. @@ -165,7 +165,7 @@ public class AnnotationProcessorErrorTest { buildAnnotationRequiredByAnnotationProc(te, new Class<?>[] {SourceAnnotationTest.class, SourceErrorAnnotationTest.class}); - AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n" + AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n" + "import " + SourceAnnotationTest.class.getName() + ";\n" + "@" + SourceAnnotationTest.class.getSimpleName() + "\n" + "public class A {}\n"); @@ -177,7 +177,7 @@ public class AnnotationProcessorErrorTest { File dexOutput = te.getOutputDexFolder(); jackApiToolchain.srcToExe( AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()) - + File.pathSeparator + te.getJackFolder(), dexOutput, te.getSourceFolder()); + + File.pathSeparator + te.getJackFolder(), dexOutput, /* zipFile = */ false, te.getSourceFolder()); DexFile dexFile = new DexFile(new File(dexOutput, jackApiToolchain.getBinaryFileName())); List<String> sourceFileInDex = new ArrayList<String>(); @@ -193,7 +193,7 @@ public class AnnotationProcessorErrorTest { buildAnnotationRequiredByAnnotationProc(te, new Class<?>[] {ResourceAnnotationTest.class}); - AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n" + AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n" + "import " + ResourceAnnotationTest.class.getName() + ";\n" + "@" + ResourceAnnotationTest.class.getSimpleName() + "\n" + "public class A {}\n"); @@ -204,7 +204,7 @@ public class AnnotationProcessorErrorTest { jackApiToolchain.srcToExe( AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()) - + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), te.getSourceFolder()); + + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), /* zipFile = */ false, te.getSourceFolder()); File discoverFile = new File(te.getTestingFolder(), ResourceAnnotationProcessor.FILENAME); Assert.assertTrue(discoverFile.exists()); diff --git a/jack-tests/tests/com/android/jack/error/CommandLineErrorTest.java b/jack-tests/tests/com/android/jack/error/CommandLineErrorTest.java index 3e72329e..d9551701 100644 --- a/jack-tests/tests/com/android/jack/error/CommandLineErrorTest.java +++ b/jack-tests/tests/com/android/jack/error/CommandLineErrorTest.java @@ -19,6 +19,8 @@ package com.android.jack.error; import com.android.jack.IllegalOptionsException; import com.android.jack.Main; import com.android.jack.NothingToDoException; +import com.android.jack.test.category.KnownBugs; +import com.android.jack.frontend.FrontendCompilationException; import com.android.jack.test.helper.ErrorTestHelper; import com.android.jack.test.toolchain.AbstractTestTools; import com.android.jack.test.toolchain.JackApiToolchain; @@ -27,6 +29,7 @@ import junit.framework.Assert; import org.junit.BeforeClass; import org.junit.Test; +import org.junit.experimental.categories.Category; import java.io.ByteArrayOutputStream; import java.io.File; @@ -56,7 +59,7 @@ public class CommandLineErrorTest { jackApiToolchain.srcToExe( AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()) + File.pathSeparator + ite.getJackFolder(), ite.getOutputDexFolder(), - ite.getSourceFolder()); + /* zipFile = */ false, ite.getSourceFolder()); Assert.fail(); } catch (IllegalOptionsException e) { // Failure is ok since a bad options is passed to ecj. @@ -82,7 +85,7 @@ public class CommandLineErrorTest { jackApiToolchain.srcToExe( AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()) + File.pathSeparator + ite.getJackFolder(), ite.getOutputDexFolder(), - ite.getSourceFolder()); + /* zipFile = */ false, ite.getSourceFolder()); Assert.fail(); } catch (NothingToDoException e) { // Failure is ok since there is no source files. @@ -92,4 +95,33 @@ public class CommandLineErrorTest { } } + /** + * Checks that compilation fails correctly when java.lang.Object does not exist on classpath. + */ + @Test + public void testCommandLineError003() throws Exception { + ErrorTestHelper ite = new ErrorTestHelper(); + + File sourceFile = AbstractTestTools.createFile(ite.getSourceFolder(), "jack.incremental", + "A.java", "package jack.incremental; \n" + "public class A {} \n"); + + JackApiToolchain jackApiToolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + ByteArrayOutputStream out = new ByteArrayOutputStream(); + jackApiToolchain.setErrorStream(errOut); + jackApiToolchain.setOutputStream(out); + + try { + jackApiToolchain.srcToExe(null, ite.getOutputDexFolder(), + /* zipFile = */ false, ite.getSourceFolder()); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Failure is ok, since java.lang.Object does not exists. + } finally { + Assert.assertEquals("", out.toString()); + Assert.assertTrue(errOut.toString().contains("The type java.lang.Object cannot be found in source files, " + + "imported jack libs or the classpath")); + } + } + } diff --git a/jack-tests/tests/com/android/jack/error/ConfigErrorTest.java b/jack-tests/tests/com/android/jack/error/ConfigErrorTest.java new file mode 100644 index 00000000..3e074f59 --- /dev/null +++ b/jack-tests/tests/com/android/jack/error/ConfigErrorTest.java @@ -0,0 +1,58 @@ +/* + * 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.error; + +import com.android.jack.test.helper.ErrorTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackApiToolchain; +import com.android.sched.util.config.UnknownPropertyNameException; + +import org.junit.Assert; +import org.junit.Test; + +import java.io.ByteArrayOutputStream; +import java.io.File; + +public class ConfigErrorTest { + + @Test + public void testUnknownProperty001() throws Exception { + ErrorTestHelper ite = new ErrorTestHelper(); + + JackApiToolchain jackApiToolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + jackApiToolchain.setErrorStream(errOut); + + File sourceFile = AbstractTestTools.createFile(ite.getSourceFolder(), "jack.config", "A.java", + "package jack.config; \n"+ + "public class A {} \n"); + + jackApiToolchain.addProperty("unknown", "true"); + + try { + jackApiToolchain.srcToExe( + AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()), + ite.getOutputDexFolder(), /* zipFile = */ true, ite.getSourceFolder()); + Assert.fail(); + } catch (UnknownPropertyNameException e) { + // Expected since we use an unknown property. + } finally { + Assert.assertEquals("", errOut.toString()); + } + } + +} diff --git a/jack-tests/tests/com/android/jack/error/ErrorHandlingAllTests.java b/jack-tests/tests/com/android/jack/error/ErrorHandlingAllTests.java new file mode 100644 index 00000000..f459d7a4 --- /dev/null +++ b/jack-tests/tests/com/android/jack/error/ErrorHandlingAllTests.java @@ -0,0 +1,34 @@ +/* + * 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.error; + +import org.junit.experimental.categories.Categories; +import org.junit.runner.RunWith; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Categories.class) +@SuiteClasses( +value = { + AnnotationProcessorErrorTest.class, + CommandLineErrorTest.class, + ConfigErrorTest.class, + ErrorTest.class, + FileAccessErrorTest.class, + JackFormatErrorTest.class, + SourceErrorTest.class + }) +public class ErrorHandlingAllTests { +}
\ No newline at end of file diff --git a/jack-tests/tests/com/android/jack/error/ErrorTest.java b/jack-tests/tests/com/android/jack/error/ErrorTest.java new file mode 100644 index 00000000..321780cb --- /dev/null +++ b/jack-tests/tests/com/android/jack/error/ErrorTest.java @@ -0,0 +1,72 @@ +/* + * 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.error; + +import com.android.jack.frontend.FrontendCompilationException; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackApiToolchain; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; + +import javax.annotation.Nonnull; + +/** + * JUnit checking that compilation failed properly. + */ +public class ErrorTest { + + @BeforeClass + public static void setUpClass() { + ErrorTest.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void testError001() throws Exception { + checkInternalCompilerException("error.test001"); + } + + @Test + public void testError002() throws Exception { + checkInternalCompilerException("error.test002"); + } + + private void checkInternalCompilerException(@Nonnull String testName) + throws Exception, IOException { + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream err = new ByteArrayOutputStream(); + toolchain.setErrorStream(err); + + try { + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack." + testName + ".jack")); + } catch (FrontendCompilationException e) { + Assert.assertTrue(!err.toString().contains("InternalCompilerException")); + } catch (RuntimeException e) { + Assert.fail(); + } + } +} diff --git a/jack-tests/tests/com/android/jack/error/FileAccessErrorTest.java b/jack-tests/tests/com/android/jack/error/FileAccessErrorTest.java index f9ce418a..5d52bced 100644 --- a/jack-tests/tests/com/android/jack/error/FileAccessErrorTest.java +++ b/jack-tests/tests/com/android/jack/error/FileAccessErrorTest.java @@ -16,14 +16,19 @@ package com.android.jack.error; +import com.android.jack.JackAbortException; import com.android.jack.JackUserException; import com.android.jack.Main; +import com.android.jack.backend.jayce.JayceFileImporter; import com.android.jack.frontend.FrontendCompilationException; +import com.android.jack.library.LibraryIOException; +import com.android.jack.library.LibraryReadingException; import com.android.jack.load.JackLoadingException; import com.android.jack.test.helper.ErrorTestHelper; import com.android.jack.test.toolchain.AbstractTestTools; import com.android.jack.test.toolchain.JackApiToolchain; import com.android.sched.util.config.PropertyIdException; +import com.android.sched.util.file.WrongPermissionException; import junit.framework.Assert; @@ -50,7 +55,7 @@ public class FileAccessErrorTest { public void testFileAccessError001() throws Exception { ErrorTestHelper te = new ErrorTestHelper(); - AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java", + AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental; \n"+ "public class A {} \n"); @@ -63,7 +68,7 @@ public class FileAccessErrorTest { try { jackApiToolchain.srcToLib( AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()), - jackOutputFile, false, te.getSourceFolder()); + jackOutputFile, /* zipFiles = */ false, te.getSourceFolder()); Assert.fail(); } catch (PropertyIdException e) { // Failure is ok since jack output folder is not readable @@ -75,13 +80,62 @@ public class FileAccessErrorTest { } /** + * Checks that compilation fails correctly when folder containing jack files is not readable. + */ + @Test + public void testFileAccessError002() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + File srcFile = AbstractTestTools.createFile(helper.getSourceFolder(), "jack.incremental", + "A.java", "package jack.incremental; \n" + "public class A {} \n"); + + JackApiToolchain jackApiToolchain = + AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + jackApiToolchain.srcToLib( + AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()), + helper.getJackFolder(), /* zipFiles = */ false, helper.getSourceFolder()); + + AbstractTestTools.deleteFile(srcFile); + + srcFile = AbstractTestTools.createFile(helper.getSourceFolder(), "jack.incremental", "B.java", + "package jack.incremental; \n" + "public class B extends A {} \n"); + + // Modify read permission of folder containing jack files + if (!helper.getJackFolder().setReadable(false)) { + Assert.fail("Fails to change file permissions of " + helper.getJackFolder().getAbsolutePath()); + } + + jackApiToolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + jackApiToolchain.setErrorStream(errOut); + jackApiToolchain.addStaticLibs(helper.getJackFolder()); + try { + jackApiToolchain.srcToExe( + AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()), + helper.getOutputDexFolder(), /* zipFile = */ false, helper.getSourceFolder()); + Assert.fail(); + } catch (JackAbortException e) { + // Failure is ok since Jack file could not be imported since folder is not readable + Assert.assertTrue(e.getCause() instanceof LibraryReadingException); + Assert.assertTrue(e.getCause().getCause() instanceof WrongPermissionException); + } finally { + Assert.assertTrue("", errOut.toString().contains("is not readable")); + if (!helper.getJackFolder().setReadable(true)) { + Assert.fail("Fails to change file permissions of " + helper.getJackFolder().getAbsolutePath()); + } + } + } + + /** * Checks that compilation fails correctly when source file is not readable. */ @Test public void testFileAccessError003() throws Exception { ErrorTestHelper te = new ErrorTestHelper(); - File a = AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java", + File a = AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental; \n"+ "public class A {} \n"); if (!a.setReadable(false)) { @@ -95,7 +149,7 @@ public class FileAccessErrorTest { try { jackApiToolchain.srcToExe( AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()), - te.getOutputDexFolder(), te.getSourceFolder()); + te.getOutputDexFolder(), /* zipFile = */ false, te.getSourceFolder()); Assert.fail(); } catch (FrontendCompilationException e) { // Failure is ok since source file is not readable @@ -114,7 +168,7 @@ public class FileAccessErrorTest { public void testFileAccessError004() throws Exception { ErrorTestHelper te = new ErrorTestHelper(); - AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java", + AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental; \n"+ "public class A {} \n"); @@ -126,29 +180,32 @@ public class FileAccessErrorTest { AbstractTestTools.deleteJavaFile(te.getSourceFolder(), "jack.incremental", "A.java"); - AbstractTestTools.createJavaFile(te.getSourceFolder(),"jack.incremental", "B.java", + AbstractTestTools.createFile(te.getSourceFolder(),"jack.incremental", "B.java", "package jack.incremental; \n"+ "public class B extends A {} \n"); ByteArrayOutputStream errOut = new ByteArrayOutputStream(); try { - for (File jackFile : AbstractTestTools.getFiles(te.getJackFolder(), ".jack")) { + for (File jackFile : AbstractTestTools.getFiles(te.getJackFolder(), JayceFileImporter.JAYCE_FILE_EXTENSION)) { if (!jackFile.setReadable(false)) { Assert.fail("Fails to change file permissions of " + jackFile.getAbsolutePath()); } } jackApiToolchain.setErrorStream(errOut); - jackApiToolchain.srcToLib( + jackApiToolchain.srcToExe( AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()) + File.pathSeparator + te.getJackFolder().getAbsolutePath(), AbstractTestTools.createTempDir(), false, te.getSourceFolder()); Assert.fail(); - } catch (JackLoadingException e) { - // Failure is ok since jack file is not readable + } catch (JackAbortException e) { + Assert.assertTrue(e.getCause() instanceof LibraryReadingException); + Assert.assertTrue(e.getCause().getCause() instanceof LibraryIOException); } finally { - Assert.assertEquals("", errOut.toString()); - for (File jackFile : AbstractTestTools.getFiles(te.getJackFolder(), ".jack")) { + String errOutput = errOut.toString(); + Assert.assertTrue(errOutput.contains("is an invalid library")); + Assert.assertTrue(errOutput.contains("is not readable")); + for (File jackFile : AbstractTestTools.getFiles(te.getJackFolder(), JayceFileImporter.JAYCE_FILE_EXTENSION)) { if (!jackFile.setReadable(true)) { Assert.fail("Fails to change file permissions of " + jackFile.getAbsolutePath()); } @@ -169,7 +226,7 @@ public class FileAccessErrorTest { jackApiToolchain.srcToExe( AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()), - te.getOutputDexFolder(), new File(te.getSourceFolder(), "A.java")); + te.getOutputDexFolder(), /* zipFile = */ false, new File(te.getSourceFolder(), "A.java")); Assert.fail(); } catch (JackUserException e) { diff --git a/jack-tests/tests/com/android/jack/error/JackFormatErrorTest.java b/jack-tests/tests/com/android/jack/error/JackFormatErrorTest.java new file mode 100644 index 00000000..c518e9f4 --- /dev/null +++ b/jack-tests/tests/com/android/jack/error/JackFormatErrorTest.java @@ -0,0 +1,188 @@ +/* + * 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.error; + +import com.android.jack.JackAbortException; +import com.android.jack.Main; +import com.android.jack.Options.VerbosityLevel; +import com.android.jack.jayce.JayceFormatException; +import com.android.jack.jayce.JayceProperties; +import com.android.jack.library.FileType; +import com.android.jack.library.JackLibrary; +import com.android.jack.library.JackLibraryFactory; +import com.android.jack.library.LibraryFormatException; +import com.android.jack.library.LibraryReadingException; +import com.android.jack.library.v0001.Version; +import com.android.jack.load.JackLoadingException; +import com.android.jack.test.helper.ErrorTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackApiToolchain; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.ByteArrayOutputStream; +import java.io.File; + +/** + * JUnit test checking Jack behavior on exceptions. + */ +public class JackFormatErrorTest { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Checks that compilation fails correctly when jayce file is corrupted. + */ + @Test + public void testJackFormatError001() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(new File(helper.getJackFolder(), FileType.JAYCE.getPrefix()), "jack.incremental", + "A.jayce", "jayce(" + JackLibraryFactory.DEFAULT_MAJOR_VERSION + "." + Version.MINOR + + ")Corrupted"); + AbstractTestTools.createFile(helper.getJackFolder(), "", "jack.properties", + JackLibrary.KEY_LIB_EMITTER + "=unknown\n" + + JackLibrary.KEY_LIB_EMITTER_VERSION + "=0\n" + + JackLibrary.KEY_LIB_MAJOR_VERSION + "=" + Version.MAJOR + "\n" + + JackLibrary.KEY_LIB_MINOR_VERSION + "=" + Version.MINOR + "\n" + + FileType.JAYCE.buildPropertyName(null /*suffix*/) + "=true\n" + + JayceProperties.KEY_JAYCE_MAJOR_VERSION + "=2\n" + + JayceProperties.KEY_JAYCE_MINOR_VERSION + "=14\n"); + + AbstractTestTools.createFile(helper.getSourceFolder(),"jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B extends A {} \n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + toolchain.setVerbosityLevel(VerbosityLevel.DEBUG); + + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setErrorStream(errOut); + + try { + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparatorChar + helper.getJackFolder().getAbsolutePath(), + helper.getOutputDexFolder(), /* zipFile= */ false, helper.getSourceFolder()); + Assert.fail(); + } catch (JackAbortException e) { + // Failure is ok since jack file is corrupted. + Assert.assertTrue(e.getCause() instanceof LibraryReadingException); + Assert.assertTrue(e.getCause().getCause() instanceof LibraryFormatException); + } finally { + Assert.assertTrue(errOut.toString().contains("is an invalid library")); + Assert.assertTrue(errOut.toString().contains( + "Unexpected node NForStatement, NDeclaredType was expected")); + } + } + + /** + * Checks that compilation fails correctly when jack file header is corrupted. + */ + @Test + public void testJackFormatError002() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(new File(helper.getJackFolder(), FileType.JAYCE.getPrefix()), "jack.incremental", + "A.jayce", "jayce()"); + AbstractTestTools.createFile(helper.getJackFolder(), "", "jack.properties", + JackLibrary.KEY_LIB_EMITTER + "=unknown\n" + + JackLibrary.KEY_LIB_EMITTER_VERSION + "=0\n" + + JackLibrary.KEY_LIB_MAJOR_VERSION + "=" + Version.MAJOR + "\n" + + JackLibrary.KEY_LIB_MINOR_VERSION + "=" + Version.MINOR + "\n" + + FileType.JAYCE.buildPropertyName(null /*suffix*/) + "=true\n" + + JayceProperties.KEY_JAYCE_MAJOR_VERSION + "=2\n" + + JayceProperties.KEY_JAYCE_MINOR_VERSION + "=14\n"); + + + AbstractTestTools.createFile(helper.getSourceFolder(),"jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B extends A {} \n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + toolchain.setVerbosityLevel(VerbosityLevel.DEBUG); + + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setErrorStream(errOut); + + try { + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparatorChar + helper.getJackFolder().getAbsolutePath(), + helper.getOutputDexFolder(), /* zipFile= */ false, helper.getSourceFolder()); + Assert.fail(); + } catch (JackAbortException e) { + // Failure is ok since jack file header is corrupted. + Assert.assertTrue(e.getCause() instanceof LibraryReadingException); + Assert.assertTrue(e.getCause().getCause() instanceof LibraryFormatException); + } finally { + Assert.assertTrue(errOut.toString().contains("is an invalid library")); + Assert.assertTrue(errOut.toString().contains("Invalid Jayce header")); + } + } + + /** + * Checks that compilation fails correctly when jack file is not longer supported. + */ + @Test + public void testJackFormatError003() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(new File(helper.getJackFolder(), FileType.JAYCE.getPrefix()), + "jack.incremental", + "A.jayce", "jayce()"); + AbstractTestTools.createFile(helper.getJackFolder(), "", "jack.properties", + JackLibrary.KEY_LIB_EMITTER + "=unknown\n" + + JackLibrary.KEY_LIB_EMITTER_VERSION + "=0\n" + + JackLibrary.KEY_LIB_MAJOR_VERSION + "=" + Version.MAJOR + "\n" + + JackLibrary.KEY_LIB_MINOR_VERSION + "=" + Version.MINOR + "\n" + + FileType.JAYCE.buildPropertyName(null /*suffix*/) + "=true\n" + + JayceProperties.KEY_JAYCE_MAJOR_VERSION + "=0\n" + + JayceProperties.KEY_JAYCE_MINOR_VERSION + "=0\n"); + + AbstractTestTools.createFile(helper.getSourceFolder(),"jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B extends A {} \n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + toolchain.setVerbosityLevel(VerbosityLevel.DEBUG); + + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setErrorStream(errOut); + + try { + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparatorChar + helper.getJackFolder().getAbsolutePath(), + helper.getOutputDexFolder(), /* zipFile= */ false, helper.getSourceFolder()); + Assert.fail(); + } catch (JackAbortException e) { + // Failure is ok since jack file header is corrupted. + Assert.assertTrue(e.getCause() instanceof LibraryReadingException); + Assert.assertTrue(e.getCause().getCause() instanceof LibraryFormatException); + } finally { + Assert.assertTrue(errOut.toString().contains("is an invalid library")); + Assert.assertTrue(errOut.toString().contains("Jayce version 0 not supported")); + } + } +} diff --git a/jack-tests/tests/com/android/jack/error/SourceErrorTest.java b/jack-tests/tests/com/android/jack/error/SourceErrorTest.java new file mode 100644 index 00000000..afee3fea --- /dev/null +++ b/jack-tests/tests/com/android/jack/error/SourceErrorTest.java @@ -0,0 +1,349 @@ +/* + * 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.error; + +import com.android.jack.frontend.FrontendCompilationException; +import com.android.jack.test.helper.ErrorTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; +import com.android.jack.test.toolchain.JackApiToolchain; + +import org.junit.Assert; +import org.junit.Test; + +import java.io.ByteArrayOutputStream; + +import javax.annotation.Nonnull; + +/** + * JUnit test checking Jack behavior with source errors. + */ +public class SourceErrorTest { + + /** + * Checks that compilation fails because of invalid "class" keyword. + */ + @Test + public void testInvalidSource001() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n" + + "public clas A {}\n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setErrorStream(errOut); + + try { + compile(toolchain, helper); + Assert.fail(); + } catch (FrontendCompilationException ex) { + // Failure is ok since source does not compile. + } finally { + Assert.assertTrue( + errOut.toString().contains("Syntax error on token \"clas\", class expected")); + } + } + + /** + * Checks that compilation fails because of invalid "public" keyword. + */ + @Test + public void testInvalidSource002() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n" + + "publi class A {}\n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setErrorStream(errOut); + + try { + compile(toolchain, helper); + Assert.fail(); + } catch (FrontendCompilationException ex) { + // Failure is ok since source does not compile. + } finally { + Assert.assertTrue( + errOut.toString().contains("Syntax error on token \"publi\", public expected")); + } + } + + /** + * Checks that compilation fails because of a class name that does not match the file name. + */ + @Test + public void testInvalidSource003() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n" + + "public class B {}\n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setErrorStream(errOut); + + try { + compile(toolchain, helper); + Assert.fail(); + } catch (FrontendCompilationException ex) { + // Failure is ok since source does not compile. + } finally { + Assert.assertTrue( + errOut.toString().contains("The public type B must be defined in its own file")); + } + } + + /** + * Checks that compilation fails because of an import of a class that is not on classpath. + */ + @Test + public void testInvalidSource004() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n" + + "import jack.invalidsource.B;\n" + + "public class A {}\n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setErrorStream(errOut); + + try { + compile(toolchain, helper); + Assert.fail(); + } catch (FrontendCompilationException ex) { + // Failure is ok since source does not compile. + } finally { + Assert.assertTrue( + errOut.toString().contains("The import jack.invalidsource.B cannot be resolved")); + } + } + + /** + * Checks that compilation fails because there are too many methods in a single class. + */ + @Test + public void testInvalidSource005() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + int methodCount = 65536; + StringBuilder content = + new StringBuilder("public class A {"); + // -1 due to implicit init method + for (int mthIdx = 0; mthIdx < methodCount - 1; mthIdx++) { + content.append("public void m" + mthIdx + "() {} \n"); + } + content.append("} \n"); + + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.overflow", "A.java", + "package jack.overflow; \n" + content.toString()); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setOutputStream(out); + toolchain.setErrorStream(errOut); + + try { + compile(toolchain, helper); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Failure is ok, since there are too many methods. + } finally { + Assert.assertEquals("", out.toString()); + Assert.assertTrue( + errOut.toString().contains("Too many methods for type A. Maximum is 65535")); + } + } + + /** + * Checks that compilation fails because of several source errors. + */ + @Test + public void testInvalidSource006() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n" + + "public class A { private voi m() {} } \n"); + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "B.java", "package jack.invalidsource;\n" + + "public class B { private void m(in a) {}; \n private void n(int a) {re}; } \n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setOutputStream(out); + toolchain.setErrorStream(errOut); + + try { + compile(toolchain, helper); + Assert.fail(); + } catch (FrontendCompilationException ex) { + // Failure is ok since source does not compile. + } finally { + Assert.assertEquals("", out.toString()); + String errorString = errOut.toString(); + Assert.assertTrue(errorString.contains("in cannot be resolved to a type")); + Assert.assertTrue(errorString.contains( + "Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration")); + Assert.assertTrue( + errorString.contains("Syntax error, insert \";\" to complete BlockStatements")); + Assert.assertTrue(errorString.contains("voi cannot be resolved to a type")); + } + } + + /** + * Checks that compilation fails because of a source error, with also some warnings. + */ + @Test + public void testInvalidSource007() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n" + + "public class A { private void m() {} } \n"); + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "B.java", "package jack.invalidsource;\n" + + "public class B { private void m(in a) {}; \n private void n(int a) {}; } \n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setOutputStream(out); + toolchain.setErrorStream(errOut); + + try { + compile(toolchain, helper); + Assert.fail(); + } catch (FrontendCompilationException ex) { + // Failure is ok since source does not compile. + } finally { + Assert.assertEquals("", out.toString()); + Assert.assertTrue(errOut.toString().contains("in cannot be resolved to a type")); + Assert.assertTrue(errOut.toString().contains( + "The method n(int) from the type B is never used locally")); + Assert.assertTrue( + errOut.toString().contains("The method m() from the type A is never used locally")); + } + } + + /** + * Checks that compilation succeeds but prints several warnings. + */ + @Test + public void testInvalidSource008() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n" + + "public class A { private void m() {} } \n"); + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "B.java", "package jack.invalidsource;\n" + + "public class B { private void m(int a) {}; \n private void n(int a) {}; } \n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setOutputStream(out); + toolchain.setErrorStream(errOut); + + try { + compile(toolchain, helper); + } finally { + Assert.assertEquals("", out.toString()); + Assert.assertTrue(errOut.toString().contains( + "The method m(int) from the type B is never used locally")); + Assert.assertTrue(errOut.toString().contains( + "The method n(int) from the type B is never used locally")); + Assert.assertTrue( + errOut.toString().contains("The method m() from the type A is never used locally")); + } + } + + /** + * Checks that compilation fails because of an invalid type. + * undefinedTypeId = typeRelatedCategory + 2 + */ + @Test + public void testInvalidSource009() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n" + + "public class A { private void m(in a) {}; } \n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setOutputStream(out); + toolchain.setErrorStream(errOut); + + try { + compile(toolchain, helper); + Assert.fail(); + } catch (FrontendCompilationException ex) { + // Failure is ok since source does not compile. + } finally { + Assert.assertEquals("", out.toString()); + Assert.assertTrue(errOut.toString().contains("in cannot be resolved to a type")); + } + } + + /** + * Checks that compilation fails because of a parsing error. + * parsingErrorInsertToCompleteId = syntaxCategory + internalCategory + 240 + */ + @Test + public void testInvalidSource010() throws Exception { + ErrorTestHelper helper = new ErrorTestHelper(); + + AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n" + + "public class A { private void n(int a) {re;} } \n"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ByteArrayOutputStream errOut = new ByteArrayOutputStream(); + toolchain.setOutputStream(out); + toolchain.setErrorStream(errOut); + + try { + compile(toolchain, helper); + Assert.fail(); + } catch (FrontendCompilationException ex) { + // Failure is ok since source does not compile. + } finally { + Assert.assertEquals("", out.toString()); + Assert.assertTrue(errOut.toString().contains( + "Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration")); + } + } + + private void compile(@Nonnull IToolchain toolchain, @Nonnull ErrorTestHelper helper) + throws Exception { + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + helper.getOutputDexFolder(), + /* zipFile = */ false, helper.getSourceFolder()); + } + +} diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest001.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest001.java new file mode 100644 index 00000000..3a0a93b9 --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest001.java @@ -0,0 +1,571 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.frontend.FrontendCompilationException; +import com.android.jack.test.helper.IncrementalTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.util.List; + +/** + * JUnit test checking dependencies between Java files. + */ +public class DependenciesTest001 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Checks that compilation failed due to deletion of B. + * Compilation must recompile A and failed since B does not longer exists. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(AbstractTestTools.createTempDir()); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A extends B {} \n"); + + File f = ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B {} \n"); + + ite.incrementalBuildFromFolder(); + + ite.deleteJavaFile(f); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Error is ok + } + } + + /** + * Checks that compilation failed due to deletion of I. + * Compilation must recompile A and failed since I does not longer exists. + */ + @Test + public void testDependency002() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_002")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A implements I {} \n"); + + File f = ite.addJavaFile("jack.incremental", "I.java", + "package jack.incremental; \n"+ + "public interface I {} \n"); + + ite.incrementalBuildFromFolder(); + + ite.deleteJavaFile(f); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Error is ok + } + } + + /** + * Check that only type A is recompiled since it was modified (extends of B removed). + */ + @Test + public void testDependency003() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(AbstractTestTools.createTempDir()); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A extends B {} \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B {} \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A {} \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(1, fqnOfRebuiltTypes.size()); + Assert.assertEquals("jack.incremental.A", fqnOfRebuiltTypes.get(0)); + } + + /** + * Check that no types are recompiled between two incremental build without modification. + */ + @Test + public void testDependency004() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_004")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A extends B {} \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B {} \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(0, fqnOfRebuiltTypes.size()); + } + + /** + * Check that B and C are recompiled since C is modified. + * B must also be recompiled since it used C. + */ + @Test + public void testDependency005() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_005")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A {} \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public void m(C c) {} } \n"); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C {} \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { public void m() {} } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C")); + } + + /** + * Check that B and C are recompiled since C is modified. + * B must also be recompiled since it used C. + */ + @Test + public void testDependency006() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_006")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A {} \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public void m() {C c = new C();} } \n"); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C {} \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { public void m() {} } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C")); + } + + /** + * Check that A, B and C are recompiled since C is modified. + * A, B must be recompiled since they are sub-type of C. + */ + @Test + public void testDependency007() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_007")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A extends B {} \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B extends C {} \n"); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C {} \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { public void m() {} } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(3, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C")); + } + + /** + * Check that compilation of A failed due to a modification into B. + */ + @Test + public void testDependency008() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_008")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public void test() {new B().m();}} \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public void m(){} } \n"); + + ite.incrementalBuildFromFolder(); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public void m(int i){} } \n"); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Error is ok + } + } + + /** + * Check that A and B are recompiled. + * A must be recompiled since it used a field of B. + */ + @Test + public void testDependency009() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_009")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public int getCst() {return B.i;} } \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static int i; } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static int i; public static int j; } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + } + + /** + * Check that A and B are recompiled. + * A must be recompiled since it used a method of B. + */ + @Test + public void testDependency010() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_010")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public void callTest() {B.test();} } \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static void test(){} } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static void test() {} public static void test1() {} } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + } + + /** + * Check that A is recompiled and that compilation failed since B does not longer exists. + */ + @Test + public void testDependency011() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_011")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public boolean callTest(Object o) { return o instanceof B;} } \n"); + + File f = ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B {} \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.deleteJavaFile(f); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Error is ok + } + } + + /** + * Check that A and B are recompiled. + * A must be recompiled since it used a constant from B. + */ + @Test + public void testDependency012() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_012")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public int getCst() {return B.i;} } \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static final int i = 10; } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static final int i = 12; } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + } + + /** + * Check that A and B are recompiled. + * A must be recompiled since it used a constant from B. + */ + @Test + public void testDependency013() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_013")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public int getCst() {return B.i1 + B.i2;} } \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static final int i1 = 10; public static final int i2 = 20; } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static final int i1 = 20; public static final int i2 = 20; } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + } + + /** + * Check that A and B are recompiled. + * A must be recompiled since it used a constant from B. + */ + @Test + public void testDependency014() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_014")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public int getCst() {return B.b + C.c;} } \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static final int b = 10; } \n"); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { public static final int c = 10; } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { public static final int c = 20; } \n"); + + ite.incrementalBuildFromFolder(); + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C")); + + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static final int b = 20; } \n"); + + ite.incrementalBuildFromFolder(); + fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + } + + /** + * Check that second and third compilation failed since I was modified but not B for the second + * compilation and not A for the third. Check that fourth compilation rebuilt A, B, I since I and + * B was modified. + */ + @Test + public void testDependency015() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_015")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A extends B { @Override public void m() {} } \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B implements I { @Override public void m() {} } \n"); + + ite.addJavaFile("jack.incremental", "I.java", + "package jack.incremental; \n"+ + "public interface I { public void m(); } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "I.java", + "package jack.incremental; \n"+ + "public interface I { public void m(int i); } \n"); + + ByteArrayOutputStream err = new ByteArrayOutputStream(); + ite.setErr(err); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Error is ok + Assert.assertTrue( + err.toString().contains("The type B must implement the inherited abstract method I.m(int)")); + Assert.assertTrue( + err.toString().contains("The method m() of type B must override or implement a supertype method")); + } + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B implements I { @Override public void m(int i) {} } \n"); + + err = new ByteArrayOutputStream(); + ite.setErr(err); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Error is ok + Assert.assertTrue(err.toString() + .contains("The method m() of type A must override or implement a supertype method")); + } + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A extends B { @Override public void m(int i) {} } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(3, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.I")); + } +} diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest002.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest002.java new file mode 100644 index 00000000..fcded878 --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest002.java @@ -0,0 +1,83 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.util.List; + +/** + * JUnit test checking dependencies between Java files. + */ +public class DependenciesTest002 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that adding a more precise method is well detected. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { } \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B extends A { public void call(E e) { System.out.println(\"E\"); } } \n"); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { public static void main(String[] args) {new B().call(new D()); } } \n"); + + ite.addJavaFile("jack.incremental", "D.java", + "package jack.incremental; \n"+ + "public class D extends E { } \n"); + + ite.addJavaFile("jack.incremental", "E.java", + "package jack.incremental; \n"+ + "public class E { } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public void call(D d) { System.out.println(\"D\"); } } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(3, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C")); + } +} diff --git a/jack-tests/tests/com/android/jack/experimenal/incremental/DependenciesTests005.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest003.java index 6b50799f..457cd49f 100644 --- a/jack-tests/tests/com/android/jack/experimenal/incremental/DependenciesTests005.java +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest003.java @@ -14,11 +14,11 @@ * limitations under the License. */ -package com.android.jack.experimenal.incremental; +package com.android.jack.experimental.incremental; import com.android.jack.Main; +import com.android.jack.TestTools; import com.android.jack.test.helper.IncrementalTestHelper; -import com.android.jack.test.toolchain.AbstractTestTools; import junit.framework.Assert; @@ -30,7 +30,7 @@ import java.util.List; /** * JUnit test checking dependencies between Java files. */ -public class DependenciesTests005 { +public class DependenciesTest003 { @BeforeClass public static void setUpClass() { @@ -38,33 +38,36 @@ public class DependenciesTests005 { } /** - * Check that runtime is correct after incremental compilation due to a constant modification. + * Check that file modification implying to transform an interface call to a virtual call is well + * detected. */ @Test public void testDependency001() throws Exception { IncrementalTestHelper ite = - new IncrementalTestHelper(AbstractTestTools.createTempDir()); + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"+ - "public class A { public static void main(String[] args) {" + - "System.out.print(C.str + B.str);} " + - "} \n"); + "public class A { public void test(B b) {b.call1().call2();} } \n"); ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"+ - "public class B { public static final String str = \"HELLO\"; } \n"); + "public class B { public I call1() {return new C();} } \n"); ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n"+ - "public class C { public static final String str = \"STRING:\"; } \n"); + "public class C implements I { @Override public void call2() { } } \n"); + + ite.addJavaFile("jack.incremental", "I.java", + "package jack.incremental; \n"+ + "public interface I { public void call2(); } \n"); ite.incrementalBuildFromFolder(); ite.snapshotJackFilesModificationDate(); ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"+ - "public class B { public static final String str = \"INCREMENTAL\"; } \n"); + "public class B { public C call1() {return new C();} } \n"); ite.incrementalBuildFromFolder(); @@ -72,9 +75,5 @@ public class DependenciesTests005 { Assert.assertEquals(2, fqnOfRebuiltTypes.size()); Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); - - Assert.assertEquals("STRING:INCREMENTAL", ite.run("jack.incremental.A")); } - - } diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest004.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest004.java new file mode 100644 index 00000000..2d3a962a --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest004.java @@ -0,0 +1,70 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.util.List; + +/** + * JUnit test checking dependencies between Java files. + */ +public class DependenciesTest004 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that changing a class into an interface is well detected. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public void test(B b) {b.call1();} } \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public void call1() {} } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public interface B { public void call1(); } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + } +} diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest005.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest005.java new file mode 100644 index 00000000..fffd2da3 --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest005.java @@ -0,0 +1,229 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; + +import java.util.List; + +/** + * JUnit test checking dependencies between Java files. + */ +@Ignore("Tree") +public class DependenciesTest005 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that runtime is correct after incremental compilation due to a constant modification. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public static void main(String[] args) {" + + "System.out.print(C.str + B.str);} " + + "} \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static final String str = \"HELLO\"; } \n"); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { public static final String str = \"STRING:\"; } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static final String str = \"INCREMENTAL\"; } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + + Assert.assertEquals("STRING:INCREMENTAL", ite.run("jack.incremental.A")); + } + + + /** + * Check that runtime is correct after incremental compilation due to a constant modification. + */ + @Test + public void testDependency002() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_002")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public static void main(String[] args) {" + + "System.out.print(B.str);} " + + "} \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static final String str = \"HELLO\" + C.str; } \n"); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { public static final String str = \" WORLD\"; } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { public static final String str = \" EVERYBODY\"; } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(3, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C")); + + Assert.assertEquals("HELLO EVERYBODY", ite.run("jack.incremental.A")); + } + + /** + * Check that runtime is correct after incremental compilation due to a constant modification. + */ + @Test + public void testDependency003() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_003")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { " + + " public static final String A = \"A\";" + + " public static final String AB = \"A\" + B.B;"+ + " public static void main(String[] args) { System.out.print(B.BA); } } \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { \n" + + " public static final String B = \"B\"; \n" + + " public static final String BA = \"B\" + A.A; }"); + + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + Assert.assertEquals("BA", ite.run("jack.incremental.A")); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { \n" + + " public static final String B = \"B\"; \n" + + " public static final String BA = \"B\" + A.AB; }"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + + Assert.assertEquals("BAB", ite.run("jack.incremental.A")); + } + + /** + * Check that runtime is correct after incremental compilation due to a constant modification. + */ + @Test + public void testDependency004() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_004")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public static void main(String[] args) {" + + "System.out.print(B.str);} " + + "} \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public static final String str = D.str + C.str; } \n"); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { public static final String str = \"WORLD\" + E.str; } \n"); + + ite.addJavaFile("jack.incremental", "D.java", + "package jack.incremental; \n"+ + "public class D { public static final String str = \"HELLO\" + E.str; } \n"); + + ite.addJavaFile("jack.incremental", "E.java", + "package jack.incremental; \n"+ + "public class E { public static final String str = \"/\"; } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { public static final String str = \"EVERYBODY\"; } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(3, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C")); + + Assert.assertEquals("HELLO/EVERYBODY", ite.run("jack.incremental.A")); + + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "E.java", + "package jack.incremental; \n"+ + "public class E { public static final String str = \" \"; } \n"); + + ite.incrementalBuildFromFolder(); + + fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(4, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.D")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.E")); + + Assert.assertEquals("HELLO EVERYBODY", ite.run("jack.incremental.A")); + } +} diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest006.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest006.java new file mode 100644 index 00000000..a27b2394 --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest006.java @@ -0,0 +1,96 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.frontend.FrontendCompilationException; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; + +import java.io.File; +import java.util.List; + +/** + * JUnit test checking dependencies between Java files. + */ +@Ignore("Tree") +public class DependenciesTest006 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that runtime is correct after class renaming. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public static void main(String[] args) {" + + "System.out.print(new B().getString());} " + + "} \n"); + + File f = ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public String getString() { return (\"B\"); } } \n"); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C { } \n"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.deleteJavaFile(f); + ite.addJavaFile("jack.incremental", "_B.java", + "package jack.incremental; \n"+ + "public class _B { public String getString() { return (\"_B\"); } } \n"); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Error is ok + } + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public static void main(String[] args) {" + + "System.out.print(new _B().getString());} " + + "} \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental._B")); + + Assert.assertEquals("_B", ite.run("jack.incremental.A")); + } +} diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest007.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest007.java new file mode 100644 index 00000000..329a3e3f --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest007.java @@ -0,0 +1,84 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; + +import java.util.List; + +/** + * JUnit test checking dependencies between Java files. + */ +@Ignore("Tree") +public class DependenciesTest007 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that runtime is correct after transformation of an interface call to a virtual call. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n"+ + "public class A { public static void main(String[] args) { new B().call1().call2();} } \n"); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public I call1() {return new C();} } \n"); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n"+ + "public class C implements I { @Override public void call2(){System.out.print(\"C\");}\n"+ + "} \n"); + + ite.addJavaFile("jack.incremental", "I.java", + "package jack.incremental; \n"+ + "public interface I { public void call2(); } \n"); + + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + + ite.addJavaFile("jack.incremental", "B.java", + "package jack.incremental; \n"+ + "public class B { public C call1() {return new C();} } \n"); + + ite.incrementalBuildFromFolder(); + + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + + Assert.assertEquals("C", ite.run("jack.incremental.A")); + } +} diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest008.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest008.java new file mode 100644 index 00000000..2ad9b836 --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest008.java @@ -0,0 +1,126 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.frontend.FrontendCompilationException; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +/** + * JUnit test checking dependencies between Java files. + */ +public class DependenciesTest008 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that jack files are deleted according to recompiled files. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n" + + "public class A { \n" + + " public static class B { public void m() {} } \n" + + " public static void main(String[] args) {new B().m();} } \n"); + + ite.incrementalBuildFromFolder(); + Assert.assertEquals(2, ite.getJackFiles().size()); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n" + + "public class A { \n" + + " public static void main(String[] args) {new B().m();} } \n"); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Error is ok + Assert.assertEquals(0, ite.getJackFiles().size()); + } + } + + /** + * Check that jack files are deleted according to recompiled files. + */ + @Test + public void testDependency002() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_002")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n" + + "public class A { } \n" + + "class B { } \n"); + + ite.incrementalBuildFromFolder(); + Assert.assertEquals(2, ite.getJackFiles().size()); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n" + + "public class A { }\n"); + + ite.incrementalBuildFromFolder(); + Assert.assertEquals(1, ite.getJackFiles().size()); + } + + /** + * Check that jack files are deleted according to recompiled files. + */ + @Test + public void testDependency003() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_003")); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n" + + "public class A { } \n" + + "class B { } \n"); + + ite.addJavaFile("jack.incremental", "C.java", + "package jack.incremental; \n" + + "public class C { public void test() {new B();} } \n"); + + ite.incrementalBuildFromFolder(); + Assert.assertEquals(3, ite.getJackFiles().size()); + + ite.addJavaFile("jack.incremental", "A.java", + "package jack.incremental; \n" + + "public class A { }\n"); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Error is ok + Assert.assertEquals(0, ite.getJackFiles().size()); + } + } +} diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest009.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest009.java new file mode 100644 index 00000000..a09a1c09 --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest009.java @@ -0,0 +1,77 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.experimental.incremental.CompilerState; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.util.Map; +import java.util.Set; + +/** + * JUnit test checking dependencies between Java files. + */ +public class DependenciesTest009 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that usages does not change during incremental compilation and that dependencies are + * identical. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A extends B { }"); + + ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B extends C { }"); + + ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n" + + "public class C { }"); + + ite.incrementalBuildFromFolder(); + + CompilerState csm = new CompilerState(ite.getCompilerStateFolder()); + csm.read(); + Map<String, Set<String>> dependencies1 = csm.computeDependencies(); + + ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A extends B { public int field;}"); + + ite.incrementalBuildFromFolder(); + + csm.read(); + Map<String, Set<String>> dependencies2 = csm.computeDependencies(); + + assert dependencies1.equals(dependencies2); + Assert.assertEquals(dependencies1, dependencies2); + } +} diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest010.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest010.java new file mode 100644 index 00000000..d5051bfb --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest010.java @@ -0,0 +1,185 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; + +import java.util.List; + +/** + * JUnit test checking dependencies between Java files. + */ +@Ignore("Tree") +public class DependenciesTest010 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that incremental compilation support switch on constant value. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A { " + + "public static void main(String[] args) {" + + " System.out.print(new A().test(2));" + + " }" + + " public int test(int value) {" + + " switch(value) {" + + " case B.val1: return 1;" + + " case B.val2: return 2;" + + " case B.val3: return 3;" + + " }" + + " return 0;" + + " } }"); + + ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B { \n" + + " public static final int val1 = 1;" + + " public static final int val2 = 2;" + + " public static final int val3 = val2 + C.val4;" + + "}"); + + ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n" + + "public class C { \n" + + " public static final int val4 = 1;" + + "}"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + Assert.assertEquals("2", ite.run("jack.incremental.A")); + + ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B { \n" + + " public static final int val1 =11;" + + " public static final int val2 =12;" + + " public static final int val3 =13;" + + "}"); + + ite.incrementalBuildFromFolder(); + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + Assert.assertEquals("0", ite.run("jack.incremental.A")); + + ite.snapshotJackFilesModificationDate(); + ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n" + + "public class C { \n" + + " public static final int val4 = 0;" + + "}"); + + ite.incrementalBuildFromFolder(); + fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(1, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C")); + Assert.assertEquals("0", ite.run("jack.incremental.A")); + + ite.snapshotJackFilesModificationDate(); + ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A { " + + "public static void main(String[] args) {" + + " System.out.print(new A().test(12));" + + " }" + + " public int test(int value) {" + + " switch(value) {" + + " case B.val1: return 1;" + + " case B.val2: return 2;" + + " case B.val3: return 3;" + + " }" + + " return 0;" + + " } }"); + + ite.incrementalBuildFromFolder(); + fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(1, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertEquals("2", ite.run("jack.incremental.A")); + } + + + /** + * Check that incremental compilation support switch on enum. + */ + @Test + public void testDependency002() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_002")); + + ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "import jack.incremental.B;" + + "public class A { " + + "public static void main(String[] args) {" + + " System.out.print(new A().test(B.VAL1));" + + " }" + + " public int test(B b) {" + + " switch(b) {" + + " case VAL1: return 1;" + + " case VAL2: return C.val4;" + + " case VAL3: return 3;" + + " }" + + " return 0;" + + " } }"); + + ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public enum B { \n" + + " VAL1," + + " VAL2," + + " VAL3" + + "}"); + + ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n" + + "public class C { \n" + + " public static final int val4 =2;" + + "}"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + Assert.assertEquals("1", ite.run("jack.incremental.A")); + + ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public enum B { \n" + + " VAL1," + + " VAL2," + + " VAL3," + + " VAL4" + + "}"); + + ite.incrementalBuildFromFolder(); + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(2, fqnOfRebuiltTypes.size()); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A")); + Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B")); + Assert.assertEquals("1", ite.run("jack.incremental.A")); + } + +} + diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest011.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest011.java new file mode 100644 index 00000000..fb05a072 --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest011.java @@ -0,0 +1,82 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.frontend.FrontendCompilationException; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; +import java.util.List; + +/** + * JUnit test checking dependencies between Java files. + */ +public class DependenciesTest011 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that incremental compilation support throws declaration. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + File f = ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A extends Exception { " + + "}"); + + ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B { \n" + + " public void m() throws A { }" + + "}"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + Assert.assertEquals(2, ite.getJackFiles().size()); + + ite.deleteJavaFile(f); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Ok + } + + ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B { \n" + + " public void m() { }" + + "}"); + + ite.incrementalBuildFromFolder(); + List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes(); + Assert.assertEquals(1, fqnOfRebuiltTypes.size()); + } +} + diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest012.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest012.java new file mode 100644 index 00000000..db6d6a3b --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest012.java @@ -0,0 +1,74 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.frontend.FrontendCompilationException; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; + +/** + * JUnit test checking dependencies between Java files. + */ +public class DependenciesTest012 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that incremental compilation support class literal usages. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A { \n" + + "public Class getClazz() { " + + " return B.class; " + + "} " + + "}"); + + File f = ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B { \n" + + "}"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + Assert.assertEquals(2, ite.getJackFiles().size()); + + ite.deleteJavaFile(f); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Ok + } + } +} + diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest013.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest013.java new file mode 100644 index 00000000..de6116e9 --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest013.java @@ -0,0 +1,166 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.frontend.FrontendCompilationException; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.ByteArrayOutputStream; +import java.io.File; + +/** + * JUnit test checking dependencies between Java files. + */ +public class DependenciesTest013 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that incremental compilation support array creation. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A { \n" + + "public int getLength() { " + + " return new B[1].length; " + + "} " + + "}"); + + File f = ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B { \n" + + "}"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + Assert.assertEquals(2, ite.getJackFiles().size()); + + ite.deleteJavaFile(f); + + ByteArrayOutputStream err = new ByteArrayOutputStream(); + ite.setErr(err); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Ok + } finally { + Assert.assertTrue(err.toString().contains("B cannot be resolved to a type")); + } + } + + /** + * Check that incremental compilation support array usages. + */ + @Test + public void testDependency002() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A { \n" + + "public int getLength() { " + + " return B.array.length; " + + "} " + + "}"); + + ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B { \n" + + "public static C []array; \n" + + "}"); + + File f = ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n" + + "public class C { \n" + + "}"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + Assert.assertEquals(3, ite.getJackFiles().size()); + + ite.deleteJavaFile(f); + + ByteArrayOutputStream err = new ByteArrayOutputStream(); + ite.setErr(err); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Ok + } finally { + Assert.assertTrue(err.toString().contains("C cannot be resolved to a type")); + } + } + + /** + * Check that incremental compilation support array usages. + */ + @Test + public void testDependency003() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A { \n" + + "public int getLength() { " + + " return B.array.length; " + + "} " + + "}"); + + ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B { \n" + + "public static C [][]array; \n" + + "}"); + + File f = ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n" + + "public class C { \n" + + "}"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + Assert.assertEquals(3, ite.getJackFiles().size()); + + ite.deleteJavaFile(f); + + ByteArrayOutputStream err = new ByteArrayOutputStream(); + ite.setErr(err); + + try { + ite.incrementalBuildFromFolder(); + Assert.fail(); + } catch (FrontendCompilationException e) { + // Ok + } finally { + Assert.assertTrue(err.toString().contains("C cannot be resolved to a type")); + } + } +} + diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest014.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest014.java new file mode 100644 index 00000000..8f768f08 --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest014.java @@ -0,0 +1,103 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.dx.io.DexBuffer; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; +import java.io.FileInputStream; + +/** + * JUnit test checking incremental support when files are deleted. + */ +public class DependenciesTest014 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that incremental compilation works when file without dependency is deleted. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A { \n" + "}"); + + File f = ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B { \n" + "}"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + Assert.assertEquals(2, ite.getJackFiles().size()); + + ite.deleteJavaFile(f); + ite.incrementalBuildFromFolder(); + DexBuffer db = new DexBuffer(new FileInputStream(ite.getDexFile())); + for (String typeName : db.typeNames()) { + if (typeName.equals("Ljack/incremental/B;")) { + Assert.fail(); + } + } + } + + /** + * Check that incremental compilation works when dependency file is deleted. + */ + @Test + public void testDependency002() throws Exception { + IncrementalTestHelper ite = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001")); + + ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A { \n" + "}"); + + File fB = ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B extends C { \n" + "}"); + + File fC = ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n" + + "public class C { \n" + "}"); + + ite.incrementalBuildFromFolder(); + ite.snapshotJackFilesModificationDate(); + Assert.assertEquals(3, ite.getJackFiles().size()); + + ite.deleteJavaFile(fB); + ite.deleteJavaFile(fC); + ite.incrementalBuildFromFolder(); + DexBuffer db = new DexBuffer(new FileInputStream(ite.getDexFile())); + for (String typeName : db.typeNames()) { + if (typeName.equals("Ljack/incremental/B;") || + typeName.equals("Ljack/incremental/C;")) { + Assert.fail(); + } + } + } +} + diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest015.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest015.java new file mode 100644 index 00000000..d6f0ae20 --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest015.java @@ -0,0 +1,141 @@ +/* + * 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.experimental.incremental; + +import com.android.jack.Main; +import com.android.jack.TestTools; +import com.android.jack.dx.io.DexBuffer; +import com.android.jack.frontend.FrontendCompilationException; +import com.android.jack.test.helper.IncrementalTestHelper; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.util.Arrays; +import java.util.List; + +/** + * JUnit test checking incremental support. + */ +public class DependenciesTest015 { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Check that incremental compilation works when library on classpath is modified. + */ + @Test + public void testDependency001() throws Exception { + IncrementalTestHelper iteLib = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001_lib")); + + File f = iteLib.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public abstract class A { \n" + "public abstract void m(); }"); + + iteLib.incrementalBuildFromFolder(); + iteLib.snapshotJackFilesModificationDate(); + List<File> jackFilesLib = iteLib.getJackFiles(); + Assert.assertEquals(1, jackFilesLib.size()); + + + IncrementalTestHelper iteProg = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001_prog")); + + iteProg.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B extends A { \n" + " @Override public void m(){} }"); + + iteProg.incrementalBuildFromFolder(new File[]{iteLib.getJackFolder()}); + iteProg.snapshotJackFilesModificationDate(); + Assert.assertEquals(1, iteProg.getJackFiles().size()); + + iteLib.deleteJavaFile(f); + iteLib.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public abstract class A { \n" + "public abstract int m(); }"); + iteLib.incrementalBuildFromFolder(); + iteLib.snapshotJackFilesModificationDate(); + jackFilesLib = iteLib.getJackFiles(); + Assert.assertEquals(1, jackFilesLib.size()); + + ByteArrayOutputStream err = new ByteArrayOutputStream(); + iteProg.setErr(err); + try { + iteProg.incrementalBuildFromFolder(new File[] {iteLib.getJackFolder()}); + Assert.fail(); + } catch (FrontendCompilationException e) { + Assert.assertTrue(err.toString().contains( + "The return type is incompatible with A.m()")); + } + } + + /** + * Check that incremental compilation works when library on import options is modified. + */ + @Test + public void testDependency002() throws Exception { + IncrementalTestHelper iteLib = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001_lib")); + + iteLib.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n" + + "public class A { \n" + "public void m() {} }"); + + iteLib.incrementalBuildFromFolder(); + iteLib.snapshotJackFilesModificationDate(); + List<File> jackFilesLib = iteLib.getJackFiles(); + Assert.assertEquals(1, jackFilesLib.size()); + + + IncrementalTestHelper iteProg = + new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001_prog")); + + iteProg.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n" + + "public class B { \n" + " public void m(){} }"); + + iteProg.incrementalBuildFromFolder(null /*classpath*/, Arrays.asList(iteLib.getJackFolder())); + iteProg.snapshotJackFilesModificationDate(); + Assert.assertEquals(2, iteProg.getJackFiles().size()); + + DexBuffer db = new DexBuffer(new FileInputStream(iteProg.getDexFile())); + Assert.assertTrue(db.typeNames().contains("Ljack/incremental/A;")); + Assert.assertTrue(db.typeNames().contains("Ljack/incremental/B;")); + + iteLib.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n" + + "public class C { \n" + "public void m() {} }"); + iteLib.incrementalBuildFromFolder(); + iteLib.snapshotJackFilesModificationDate(); + jackFilesLib = iteLib.getJackFiles(); + Assert.assertEquals(2, jackFilesLib.size()); + + + iteProg.incrementalBuildFromFolder(null, Arrays.asList(iteLib.getJackFolder())); + iteProg.snapshotJackFilesModificationDate(); + Assert.assertEquals(3, iteProg.getJackFiles().size()); + + db = new DexBuffer(new FileInputStream(iteProg.getDexFile())); + Assert.assertTrue(db.typeNames().contains("Ljack/incremental/A;")); + Assert.assertTrue(db.typeNames().contains("Ljack/incremental/B;")); + Assert.assertTrue(db.typeNames().contains("Ljack/incremental/C;")); + } +} + diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependencyAllTests.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependencyAllTests.java new file mode 100644 index 00000000..e8b42a86 --- /dev/null +++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependencyAllTests.java @@ -0,0 +1,15 @@ +package com.android.jack.experimental.incremental; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses(value = {DependenciesTest001.class, DependenciesTest002.class, + DependenciesTest003.class, DependenciesTest004.class, DependenciesTest005.class, + DependenciesTest006.class, DependenciesTest007.class, DependenciesTest008.class, + DependenciesTest009.class, DependenciesTest010.class, DependenciesTest011.class, + DependenciesTest012.class, DependenciesTest013.class, DependenciesTest014.class, + DependenciesTest015.class}) +public class DependencyAllTests { +}
\ No newline at end of file diff --git a/jack-tests/tests/com/android/jack/external/ExternalTests.java b/jack-tests/tests/com/android/jack/external/ExternalTests.java new file mode 100644 index 00000000..99838282 --- /dev/null +++ b/jack-tests/tests/com/android/jack/external/ExternalTests.java @@ -0,0 +1,49 @@ +/* +* 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.external; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class ExternalTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.external.test001"), + "com.android.jack.external.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + ExternalTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/fibonacci/FibonacciTests.java b/jack-tests/tests/com/android/jack/fibonacci/FibonacciTests.java new file mode 100644 index 00000000..cfbe2f96 --- /dev/null +++ b/jack-tests/tests/com/android/jack/fibonacci/FibonacciTests.java @@ -0,0 +1,68 @@ +/* +* 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.fibonacci; + +import com.android.jack.TestTools; +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.comparator.ComparatorDex; +import com.android.jack.test.helper.CheckDexStructureTestHelper; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +public class FibonacciTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.fibonacci.test001"), + "com.android.jack.fibonacci.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + FibonacciTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + /** + * Compiles FibonacciThreeAddress into a {@code DexFile} and compares it to a dex file created + * using a reference compiler and {@code dx}. + * @throws Exception + */ + @Test + public void testCompareFiboDexFile() throws Exception { + SourceToDexComparisonTestHelper helper = + new CheckDexStructureTestHelper(new File(TEST001.directory, "jack")); + helper.runTest(new ComparatorDex(helper.getCandidateDex(), helper.getReferenceDex())); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/fibonacci/dx/Tests.java b/jack-tests/tests/com/android/jack/fibonacci/test001/dx/Tests.java index 4bdf6f7b..a88c9cee 100644 --- a/jack-tests/tests/com/android/jack/fibonacci/dx/Tests.java +++ b/jack-tests/tests/com/android/jack/fibonacci/test001/dx/Tests.java @@ -14,9 +14,9 @@ * limitations under the License. */ -package com.android.jack.fibonacci.dx; +package com.android.jack.fibonacci.test001.dx; -import com.android.jack.fibonacci.jack.FibonacciThreeAddress; +import com.android.jack.fibonacci.test001.jack.FibonacciThreeAddress; import junit.framework.Assert; diff --git a/jack-tests/tests/com/android/jack/fibonacci/jack/Fibo.java b/jack-tests/tests/com/android/jack/fibonacci/test001/jack/Fibo.java index fdaf4be3..cb99b627 100644 --- a/jack-tests/tests/com/android/jack/fibonacci/jack/Fibo.java +++ b/jack-tests/tests/com/android/jack/fibonacci/test001/jack/Fibo.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.jack.fibonacci.jack; +package com.android.jack.fibonacci.test001.jack; /** * Fibonacci test. diff --git a/jack-tests/tests/com/android/jack/fibonacci/jack/FibonacciThreeAddress.java b/jack-tests/tests/com/android/jack/fibonacci/test001/jack/FibonacciThreeAddress.java index 099cbf12..9cf4927b 100644 --- a/jack-tests/tests/com/android/jack/fibonacci/jack/FibonacciThreeAddress.java +++ b/jack-tests/tests/com/android/jack/fibonacci/test001/jack/FibonacciThreeAddress.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.jack.fibonacci.jack; +package com.android.jack.fibonacci.test001.jack; /** * Fibonacci test in three-address style. diff --git a/jack-tests/tests/com/android/jack/field/FieldTests.java b/jack-tests/tests/com/android/jack/field/FieldTests.java new file mode 100644 index 00000000..87f20450 --- /dev/null +++ b/jack-tests/tests/com/android/jack/field/FieldTests.java @@ -0,0 +1,176 @@ +/* +* 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.field; + +import com.android.jack.TestTools; +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.comparator.ComparatorDex; +import com.android.jack.test.helper.CheckDexStructureTestHelper; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import javax.annotation.Nonnull; + +public class FieldTests extends RuntimeTest { + + private RuntimeTestInfo INSTANCE001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.field.instance001"), + "com.android.jack.field.instance001.dx.Tests"); + + private RuntimeTestInfo INSTANCE002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.field.instance002"), + "com.android.jack.field.instance002.dx.Tests"); + + private RuntimeTestInfo INSTANCE003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.field.instance003"), + "com.android.jack.field.instance003.dx.Tests"); + + private RuntimeTestInfo INSTANCE004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.field.instance004"), + "com.android.jack.field.instance004.dx.Tests"); + + private RuntimeTestInfo STATIC001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.field.static001"), + "com.android.jack.field.static001.dx.Tests"); + + private RuntimeTestInfo STATIC002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.field.static002"), + "com.android.jack.field.static002.dx.Tests"); + + private RuntimeTestInfo STATIC004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.field.static004"), + "com.android.jack.field.static004.dx.Tests"); + + private RuntimeTestInfo STATIC005 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.field.static005"), + "com.android.jack.field.static005.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + FieldTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void instance001() throws Exception { + new RuntimeTestHelper(INSTANCE001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void instance002() throws Exception { + new RuntimeTestHelper(INSTANCE002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void instance003() throws Exception { + new RuntimeTestHelper(INSTANCE003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void instance004() throws Exception { + new RuntimeTestHelper(INSTANCE004).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void static001() throws Exception { + new RuntimeTestHelper(STATIC001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void static002() throws Exception { + new RuntimeTestHelper(STATIC002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void static004() throws Exception { + new RuntimeTestHelper(STATIC004).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void static005() throws Exception { + new RuntimeTestHelper(STATIC005).compileAndRunTest(); + } + + @Test + public void testCompileInstance6() throws Exception { + compileTest("instance005"); + } + + @Test + public void testCompileStatic() throws Exception { + compileTest("static003"); + } + + /** + * Compiles StaticField.java into a {@code DexFile} and compares it to a dex file created + * using a reference compiler and {@code dx}. + */ + @Test + public void testStatic() throws Exception { + checkStructure("static003"); + } + + /** + * Compiles InstanceField.java into a {@code DexFile} and compares it to a dex file created + * using a reference compiler and {@code dx}. + */ + @Test + public void testInstance() throws Exception { + checkStructure("instance005"); + } + + private void compileTest(@Nonnull String test) throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.field." + test + ".jack")); + } + + private void checkStructure(@Nonnull String test) throws Exception { + SourceToDexComparisonTestHelper helper = new CheckDexStructureTestHelper( + AbstractTestTools.getTestRootDir("com.android.jack.field." + test + ".jack")); + helper.runTest(new ComparatorDex(helper.getCandidateDex(), helper.getReferenceDex())); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(INSTANCE001); + rtTestInfos.add(INSTANCE002); + rtTestInfos.add(INSTANCE003); + rtTestInfos.add(INSTANCE004); + rtTestInfos.add(STATIC001); + rtTestInfos.add(STATIC002); + rtTestInfos.add(STATIC004); + rtTestInfos.add(STATIC005); + } +} diff --git a/jack-tests/tests/com/android/jack/fileconflict/FileConflictTests.java b/jack-tests/tests/com/android/jack/fileconflict/FileConflictTests.java new file mode 100644 index 00000000..ccce9392 --- /dev/null +++ b/jack-tests/tests/com/android/jack/fileconflict/FileConflictTests.java @@ -0,0 +1,607 @@ +/* + * 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.fileconflict; + +import com.android.jack.Jack; +import com.android.jack.Options; +import com.android.jack.ProguardFlags; +import com.android.jack.TestTools; +import com.android.jack.backend.jayce.ImportConflictException; +import com.android.jack.backend.jayce.JayceFileImporter; +import com.android.jack.backend.jayce.ResourceImportConflictException; +import com.android.jack.test.category.KnownBugs; +import com.android.jack.library.FileType; +import com.android.jack.library.JackLibrary; +import com.android.jack.shrob.obfuscation.NameProviderFactory; +import com.android.jack.test.toolchain.AbstractTestTools; +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.stream.ByteStreamSucker; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; + +import javax.annotation.CheckForNull; +import javax.annotation.Nonnull; + +/** + * JUnit tests for resource support. + */ +public class FileConflictTests { + + @Nonnull + private static final String COMMON_PATH_001 = "com/android/jack/fileconflict/test001/jack/"; + @Nonnull + private static final String COMMON_PATH_002 = "com/android/jack/fileconflict/test002/jack/"; + @Nonnull + private static final String JACK_FILE_PATH_1 = + FileType.JAYCE.getPrefix() + "/" + COMMON_PATH_001 + "MyClass.jayce"; + @Nonnull + private static final String JACK_FILE_PATH_2 = + FileType.JAYCE.getPrefix() + "/" + COMMON_PATH_001 + "MyClass2.jayce"; + @Nonnull + private static final String JACK_FILE_PATH_3 = + FileType.JAYCE.getPrefix() + "/" + COMMON_PATH_001 + "MyClass3.jayce"; + @Nonnull + private static final String DEX_FILE_PATH_1 = + FileType.DEX.getPrefix() + "/" + COMMON_PATH_001 + "MyClass.dex"; + @Nonnull + private static final String DEX_FILE_PATH_2 = + FileType.DEX.getPrefix() + "/" + COMMON_PATH_001 + "MyClass2.dex"; + @Nonnull + private static final String DEX_FILE_PATH_3 = + FileType.DEX.getPrefix() + "/" + COMMON_PATH_001 + "MyClass3.dex"; + @Nonnull + private static final String JACK_FILE_PATH_002_1 = + FileType.JAYCE.getPrefix() + "/" + COMMON_PATH_002 + "IrrelevantForTest.jayce"; + @Nonnull + private static final String JACK_FILE_PATH_002_2 = + FileType.JAYCE.getPrefix() + "/" + COMMON_PATH_002 + "IrrelevantForTest2.jayce"; + @Nonnull + private static final String RESOURCE1_SHORTPATH = "Resource1"; + @Nonnull + private static final String RESOURCE2_SHORTPATH = "Resource2"; + @Nonnull + private static final String RESOURCE3_SHORTPATH = "Resource3"; + @Nonnull + private static final String RESOURCE1_LONGPATH = FileType.RSC.getPrefix() + "/" + + RESOURCE1_SHORTPATH; + @Nonnull + private static final String RESOURCE2_LONGPATH = FileType.RSC.getPrefix() + "/" + + RESOURCE2_SHORTPATH; + @Nonnull + private static final String RESOURCE3_LONGPATH = FileType.RSC.getPrefix() + "/" + + RESOURCE3_SHORTPATH; + + @Nonnull + private static final File TEST001_DIR = + AbstractTestTools.getTestRootDir("com.android.jack.fileconflict.test001.jack"); + + @Nonnull + private static final File TEST002_DIR = + AbstractTestTools.getTestRootDir("com.android.jack.fileconflict.test002.jack"); + + @BeforeClass + public static void setUpClass() { + FileConflictTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Test the behavior of Jack when importing 2 Jack folders containing conflicting Jack files, and + * outputting to a Jack folder, with no collision policy specified. + * @throws Exception + */ + @Test + public void test001a() throws Exception { + File jackOutput = AbstractTestTools.createTempDir(); + try { + runTest001(jackOutput, null); + Assert.fail(); + } catch (ImportConflictException e) { + } + } + + /** + * Test the behavior of Jack when importing 2 Jack folders containing conflicting Jack files, and + * outputting to a Jack folder, with the collision policy set to "fail". + * @throws Exception + */ + @Test + public void test001b() throws Exception { + File jackOutput = AbstractTestTools.createTempDir(); + try { + runTest001(jackOutput, "fail"); + Assert.fail(); + } catch (ImportConflictException e) { + } + } + + /** + * Test the behavior of Jack when importing 2 Jack folders containing conflicting Jack files, and + * outputting to a Jack folder, with the collision policy set to "keep-first". + * @throws Exception + */ + @Test + public void test001c() throws Exception { + File jackOutput = AbstractTestTools.createTempDir(); + runTest001(jackOutput, "keep-first"); + File myClass1 = new File(jackOutput, JACK_FILE_PATH_1); + File myClass2 = new File(jackOutput, JACK_FILE_PATH_2); + File myClass3 = new File(jackOutput, JACK_FILE_PATH_3); + Assert.assertTrue(myClass1.exists()); + Assert.assertTrue(myClass2.exists()); + Assert.assertTrue(myClass3.exists()); + } + + /** + * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and + * outputting to a Jack folder, with no collision policy specified. + * @throws Exception + */ + @Test + public void test002a() throws Exception { + File jackOutput = AbstractTestTools.createTempDir(); + try { + runTest002(jackOutput, false /* non-zipped */, null); + Assert.fail(); + } catch (ResourceImportConflictException e) { + } + } + + /** + * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and + * outputting to a Jack folder, with the collision policy set to "fail". + * @throws Exception + */ + @Test + public void test002b() throws Exception { + File jackOutput = AbstractTestTools.createTempDir(); + try { + runTest002(jackOutput, false /* non-zipped */, "fail"); + Assert.fail(); + } catch (ResourceImportConflictException e) { + } + } + + /** + * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and + * outputting to a Jack folder, with the collision policy set to "keep-first". + * @throws Exception + */ + @Test + public void test002c() throws Exception { + File jackOutput = AbstractTestTools.createTempDir(); + runTest002(jackOutput, false /* non-zipped */, "keep-first"); + checkResourceContent(jackOutput, RESOURCE1_LONGPATH, "Res1"); + checkResourceContent(jackOutput, RESOURCE2_LONGPATH, "Res2"); + checkResourceContent(jackOutput, RESOURCE3_LONGPATH, "Res3"); + } + + /** + * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and + * outputting to a Jack zip, with no collision policy specified. + * @throws Exception + */ + @Test + public void test002d() throws Exception { + File jackOutput = AbstractTestTools.createTempFile("jackoutput", ".zip"); + try { + runTest002(jackOutput, true /* zipped */, null); + Assert.fail(); + } catch (ResourceImportConflictException e) { + } + } + + /** + * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and + * outputting to a Jack zip, with the collision policy set to "fail". + * @throws Exception + */ + @Test + public void test002e() throws Exception { + File jackOutput = AbstractTestTools.createTempFile("jackoutput", ".zip"); + try { + runTest002(jackOutput, true /* zipped */, "fail"); + Assert.fail(); + } catch (ResourceImportConflictException e) { + } + } + + /** + * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and + * outputting to a Jack zip, with the collision policy set to "keep-first". + * @throws Exception + */ + @Test + public void test002f() throws Exception { + File jackOutput = AbstractTestTools.createTempFile("jackoutput", ".zip"); + runTest002(jackOutput, true /* zipped */, "keep-first"); + ZipFile zipFile = new ZipFile(jackOutput); + checkResourceContent(zipFile, RESOURCE1_LONGPATH, "Res1"); + checkResourceContent(zipFile, RESOURCE2_LONGPATH, "Res2"); + checkResourceContent(zipFile, RESOURCE3_LONGPATH, "Res3"); + } + + /** + * Test the behavior of Jack when outputting a Jack file to a Jack folder where a Jack file of the + * same name already exists. We expect the previous file to be overridden. + * @throws Exception + */ + @Test + public void test003a() throws Exception { + // compile source files to a Jack dir + File jackOutput = AbstractTestTools.createTempDir(); + File testSrcDir = AbstractTestTools.getTestRootDir("com.android.jack.fileconflict.test003"); + File tempJackFolder = AbstractTestTools.createTempDir(); + + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + tempJackFolder, + /* zipFiles = */ false, + testSrcDir); + + // get paths for Jack files + String jackFilePath = + FileType.JAYCE.getPrefix() + "/com/android/jack/fileconflict/test003/jack/MyClass.jayce"; + File myClass1 = new File(tempJackFolder, jackFilePath); + + // get paths for Dex files + String dexFilePath = + FileType.DEX.getPrefix() + "/com/android/jack/fileconflict/test003/jack/MyClass.dex"; + File myClass1Dex = new File(tempJackFolder, dexFilePath); + + String libPropName = JackLibrary.LIBRARY_PROPERTIES_VPATH.getPathAsString('/'); + File libProperties = new File(tempJackFolder, libPropName); + + // create Jack dirs to import + File jackImport1 = AbstractTestTools.createTempDir(); + copyFileToDir(libProperties, libPropName, jackImport1); + copyFileToDir(myClass1, jackFilePath, jackImport1); + copyFileToDir(myClass1Dex, dexFilePath, jackImport1); + + // copy Jack file to output dir + copyFileToDir(myClass1, jackFilePath, jackOutput); + copyFileToDir(myClass1Dex, dexFilePath, jackOutput); + + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.addProguardFlags(new File(testSrcDir, "proguard.flags")); + toolchain.libToLib(jackImport1, jackOutput, false); + } + + /** + * Test the behavior of Jack when outputting a resource to a Jack folder where a file of the + * same name already exists. We expect the previous file to be overridden. + * @throws Exception + */ + @Test + @Ignore("Now jack generate library, a previous file can not exists") + public void test003b() throws Exception { + File jackOutput = AbstractTestTools.createTempDir(); + + // compile source files to a Jack dir + File testSrcDir = AbstractTestTools.getTestRootDir("com.android.jack.fileconflict.test003.jack"); + File tempJackFolder = AbstractTestTools.createTempDir(); + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + tempJackFolder, + /* zipFiles = */ false, + testSrcDir); + + // get paths for Jack files + String jackFilePath = + FileType.JAYCE.getPrefix() + "/com/android/jack/fileconflict/test003/jack/MyClass.jayce"; + File myClass1 = new File(tempJackFolder, jackFilePath); + + String libPropName = JackLibrary.LIBRARY_PROPERTIES_VPATH.getPathAsString('/'); + File libProperties = new File(tempJackFolder, libPropName); + + // create Jack dirs to import + File jackImport1 = AbstractTestTools.createTempDir(); + String resourcePath = "com/android/jack/fileconflict/test003/jack/Resource"; + File resource = new File(testSrcDir, "Resource"); + copyFileToDir(libProperties, libPropName, jackImport1); + copyFileToDir(myClass1, jackFilePath, jackImport1); + copyFileToDir(resource, resourcePath, jackImport1); + + // copy a different resource to output dir with the same name + File resource2 = new File(testSrcDir, "Resource2"); + copyFileToDir(resource2, resourcePath, jackOutput); + + // run Jack on Jack dir + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.libToLib(jackImport1, jackOutput, /* zipFiles = */ false); + + checkResourceContent(jackOutput, resourcePath, "Res1"); + + } + + /** + * Test the behavior of Jack when renaming a Jack file along with the resource with a matching + * name, and when a resource with the same name (after renaming) already exists. + * @throws Exception + */ + @Test + @Category(KnownBugs.class) + public void test004() throws Exception { + File jackOutput = AbstractTestTools.createTempDir(); + + // compile source files to a Jack dir + File testSrcDir = AbstractTestTools.getTestRootDir("com.android.jack.fileconflict.test004.jack"); + File tempJackFolder = AbstractTestTools.createTempDir(); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + tempJackFolder, + /* zipFiles = */ false, + testSrcDir); + + // get paths for Jack files + String jackFilePath = + FileType.JAYCE.getPrefix() + "/com/android/jack/fileconflict/test004/jack/MyClass.jayce"; + File myClass1 = new File(tempJackFolder, jackFilePath); + + String libPropName = JackLibrary.LIBRARY_PROPERTIES_VPATH.getPathAsString('/'); + File libProperties = new File(tempJackFolder, libPropName); + + // create Jack dirs to import + File jackImport1 = AbstractTestTools.createTempDir(); + File resource = new File(testSrcDir, "MyClass.txt"); + copyFileToDir(libProperties, libPropName, jackImport1); + copyFileToDir(myClass1, jackFilePath, jackImport1); + copyFileToDir(resource, "com/android/jack/fileconflict/test004/jack/MyClass.txt", jackImport1); + System.out.println(jackImport1.getAbsolutePath()); + + // copy a different resource to output dir with the same name + File resource2 = new File(testSrcDir, "a.txt"); + copyFileToDir(resource2, "pcz/nbqfcvq/wnpx/svyrpcbsyvph/hrgh004/wnpx/ZmPyngg.txt", jackOutput); + + // run Jack on Jack dir + toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.addProguardFlags(new File(testSrcDir, "proguard.flags")); + toolchain.addProperty(NameProviderFactory.NAMEPROVIDER.getName(), "rot13"); + toolchain.libToLib(jackImport1, jackOutput, /* zipFiles = */ false); + + checkResourceContent(jackOutput, "pcz/nbqfcvq/wnpx/svyrpcbsyvph/hrgh004/wnpx/ZmPyngg.txt", + "MyClass"); + } + + private void runTest001(@Nonnull File jackOutput, @CheckForNull String collisionPolicy) + throws Exception { + // compile source files to a Jack dir + File tempJackFolder = AbstractTestTools.createTempDir(); + JackApiToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + tempJackFolder, + /* zipFile = */ false, + TEST001_DIR); + + // get paths for Jack files + File myClass1 = new File(tempJackFolder, JACK_FILE_PATH_1); + File myClass2 = new File(tempJackFolder, JACK_FILE_PATH_2); + File myClass3 = new File(tempJackFolder, JACK_FILE_PATH_3); + + // get paths for dex files + File myClass1Dex = new File(tempJackFolder, DEX_FILE_PATH_1); + File myClass2Dex = new File(tempJackFolder, DEX_FILE_PATH_2); + File myClass3Dex = new File(tempJackFolder, DEX_FILE_PATH_3); + + String libPropName = JackLibrary.LIBRARY_PROPERTIES_VPATH.getPathAsString('/'); + File libProperties = new File(tempJackFolder, libPropName); + + // create Jack dirs to import + File jackImport1 = AbstractTestTools.createTempDir(); + File jackImport2 = AbstractTestTools.createTempDir(); + copyFileToDir(libProperties, libPropName, jackImport1); + copyFileToDir(myClass1, JACK_FILE_PATH_1, jackImport1); + copyFileToDir(myClass1Dex, DEX_FILE_PATH_1, jackImport1); + copyFileToDir(myClass2, JACK_FILE_PATH_2, jackImport1); + copyFileToDir(myClass2Dex, DEX_FILE_PATH_2, jackImport1); + copyFileToDir(libProperties, libPropName, jackImport2); + copyFileToDir(myClass1, JACK_FILE_PATH_1, jackImport2); + copyFileToDir(myClass1Dex, DEX_FILE_PATH_1, jackImport2); + copyFileToDir(myClass3, JACK_FILE_PATH_3, jackImport2); + copyFileToDir(myClass3Dex, DEX_FILE_PATH_3, jackImport2); + + // run Jack on Jack dirs + toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.addProguardFlags(new File(TEST001_DIR, "proguard.flags")); + toolchain.addStaticLibs(jackImport1, jackImport2); + if (collisionPolicy != null) { + toolchain.addProperty(JayceFileImporter.COLLISION_POLICY.getName(), collisionPolicy); + } + toolchain.libToLib(new File [] {jackImport1, jackImport2}, jackOutput, /* zipFiles = */ false); + } + + private void runTest002(@Nonnull File jackOutput, boolean zip, + @CheckForNull String collisionPolicy) throws Exception { + // compile source files to a Jack dir + File jackImport1 = TestTools.createTempDir("jack", "dir"); + Options options = new Options(); + File lib1 = new File(TEST002_DIR, "lib1"); + options.addResource(new File(lib1, "rsc")); + TestTools.compileSourceToJack(options, lib1, TestTools.getDefaultBootclasspathString(), + jackImport1, false /* non-zipped */); + + File jackImport2 = TestTools.createTempDir("jack", "dir"); + options = new Options(); + File lib2 = new File(TEST002_DIR, "lib2"); + options.addResource(new File(lib2, "rsc")); + TestTools.compileSourceToJack(options, lib2, TestTools.getDefaultBootclasspathString(), + jackImport2, false /* non-zipped */); + + // run Jack on Jack dirs + ProguardFlags flags = new ProguardFlags(new File(TEST002_DIR, "proguard.flags")); + options = new Options(); + List<File> jayceImports = new ArrayList<File>(2); + jayceImports.add(jackImport1); + jayceImports.add(jackImport2); + options.setJayceImports(jayceImports); + options.setProguardFlagsFile(Collections.<File>singletonList(flags)); + if (zip) { + options.setJayceOutputZip(jackOutput); + } else { + options.setJayceOutputDir(jackOutput); + } + if (collisionPolicy != null) { + options.addProperty(JayceFileImporter.RESOURCE_COLLISION_POLICY.getName(), collisionPolicy); + } + Jack.run(options); + } + +// private void runTest002(@Nonnull File jackOutput, boolean zip, +// @CheckForNull String collisionPolicy) throws Exception { +// // compile source files to a Jack dir +// // TODO(jmhenaff): adapt this when resources are added to toolchain APIs +// File jackImport1 = TestTools.createTempDir("jack", "dir"); +// Options options = new Options(); +// File lib1 = new File(TEST002_DIR, "lib1"); +// options.addResource(new File(lib1, "rsc")); +// TestTools.compileSourceToJack(options, lib1, TestTools.getDefaultBootclasspathString(), +// jackImport1, false /* non-zipped */); +// +// File jackImport2 = TestTools.createTempDir("jack", "dir"); +// options = new Options(); +// File lib2 = new File(TEST002_DIR, "lib2"); +// options.addResource(new File(lib2, "rsc")); +// TestTools.compileSourceToJack(options, lib2, TestTools.getDefaultBootclasspathString(), +// jackImport2, false /* non-zipped */); +//// File tempJackFolder = AbstractTestTools.createTempDir(); +//// JackApiToolchain toolchain = +//// AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); +//// toolchain.srcToLib( +//// AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), +//// tempJackFolder, +//// /* zipFile = */ false, +//// TEST002_DIR); +//// +//// // get paths for Jack files +//// File myClass1 = new File(tempJackFolder, JACK_FILE_PATH_002_1); +//// File myClass2 = new File(tempJackFolder, JACK_FILE_PATH_002_2); +//// +//// // get paths for resources +//// File resource1 = new File(TEST002_DIR, RESOURCE1_SHORTPATH); +//// File resource2 = new File(TEST002_DIR, RESOURCE2_SHORTPATH); +//// File resource3 = new File(TEST002_DIR, RESOURCE3_SHORTPATH); +//// +//// // create Jack dirs to import +//// File jackImport1 = AbstractTestTools.createTempDir(); +//// File jackImport2 = AbstractTestTools.createTempDir(); +//// copyFileToDir(myClass1, JACK_FILE_PATH_002_1, jackImport1); +//// copyFileToDir(resource1, RESOURCE1_LONGPATH, jackImport1); +//// copyFileToDir(resource2, RESOURCE2_LONGPATH, jackImport1); +//// copyFileToDir(myClass2, JACK_FILE_PATH_002_2, jackImport2); +//// copyFileToDir(resource2, RESOURCE1_LONGPATH, jackImport2); +//// copyFileToDir(resource3, RESOURCE3_LONGPATH, jackImport2); +// +// // run Jack on Jack dirs +// toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); +// toolchain.addProguardFlags(new File(TEST002_DIR, "proguard.flags")); +// if (collisionPolicy != null) { +// toolchain.addProperty(JayceFileImporter.RESOURCE_COLLISION_POLICY.getName(), collisionPolicy); +// } +// toolchain.libToLib(new File [] {jackImport1, jackImport2}, jackOutput, zip); +// +// } + + private void copyFileToDir(@Nonnull File fileToCopy, @Nonnull String relativePath, + @Nonnull File dir) throws IOException { + FileOutputStream fos = null; + FileInputStream fis = null; + try { + fis = new FileInputStream(fileToCopy); + File copiedFile = new File(dir, relativePath); + File parentDir = copiedFile.getParentFile(); + if (!parentDir.exists()) { + boolean res = parentDir.mkdirs(); + if (!res) { + throw new AssertionError(); + } + } + try { + fos = new FileOutputStream(copiedFile); + ByteStreamSucker sucker = new ByteStreamSucker(fis, fos); + sucker.suck(); + } finally { + if (fos != null) { + fos.close(); + } + } + } finally { + if (fis != null) { + fis.close(); + } + } + } + + private void checkResourceContent(@Nonnull File dir, @Nonnull String path, + @Nonnull String expectedContent) throws IOException { + assert dir.isDirectory(); + File file = new File(dir, path); + Assert.assertTrue(file.exists()); + BufferedReader reader = null; + try { + InputStream in = new FileInputStream(file); + reader = new BufferedReader(new InputStreamReader(in)); + String line = reader.readLine(); + Assert.assertEquals(expectedContent, line); + } finally { + if (reader != null) { + reader.close(); + } + } + } + + private void checkResourceContent(@Nonnull ZipFile zipFile, @Nonnull String entryName, + @Nonnull String expectedContent) throws IOException { + ZipEntry entry = zipFile.getEntry(entryName); + Assert.assertNotNull(entry); + BufferedReader reader = null; + try { + InputStream in = zipFile.getInputStream(entry); + reader = new BufferedReader(new InputStreamReader(in)); + String line = reader.readLine(); + Assert.assertEquals(expectedContent, line); + } finally { + if (reader != null) { + reader.close(); + } + } + } +} diff --git a/jack-tests/tests/com/android/jack/flow/FlowTests.java b/jack-tests/tests/com/android/jack/flow/FlowTests.java new file mode 100644 index 00000000..527b3cb7 --- /dev/null +++ b/jack-tests/tests/com/android/jack/flow/FlowTests.java @@ -0,0 +1,60 @@ +/* +* 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.flow; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class FlowTests extends RuntimeTest { + + private RuntimeTestInfo CFG001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.flow.cfg001"), + "com.android.jack.flow.cfg001.dx.Tests"); + + private RuntimeTestInfo LOOP = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.flow.loop"), + "com.android.jack.flow.loop.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + FlowTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void cfg001() throws Exception { + new RuntimeTestHelper(CFG001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void loop() throws Exception { + new RuntimeTestHelper(LOOP).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(CFG001); + rtTestInfos.add(LOOP); + } +} diff --git a/jack-tests/tests/com/android/jack/frontend/MissingClassTest.java b/jack-tests/tests/com/android/jack/frontend/MissingClassTest.java new file mode 100644 index 00000000..b4c3efd1 --- /dev/null +++ b/jack-tests/tests/com/android/jack/frontend/MissingClassTest.java @@ -0,0 +1,61 @@ +/* + * 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.frontend; + +import com.android.jack.test.category.KnownBugs; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +public class MissingClassTest { + + @Test + @Category(KnownBugs.class) + public void test001() throws Exception { + File outJackTmpMissing = AbstractTestTools.createTempDir(); + File outJackTmpSuper = AbstractTestTools.createTempDir(); + File outJackTmpTest = AbstractTestTools.createTempDir(); + + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + outJackTmpMissing, + /* zipFiles= */ false, + AbstractTestTools.getTestRootDir("com.android.jack.frontend.test001.jack.missing")); + + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparatorChar + outJackTmpMissing.getPath(), + outJackTmpSuper, + /* zipFiles= */ false, + AbstractTestTools.getTestRootDir("com.android.jack.frontend.test001.jack.sub2")); + + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()) + + File.pathSeparatorChar + outJackTmpSuper.getPath(), + outJackTmpTest, + /* zipFiles= */ false, + AbstractTestTools.getTestRootDir("com.android.jack.frontend.test001.jack.test")); + + } + +} diff --git a/jack-tests/tests/com/android/jack/generic/basic/GenericTests.java b/jack-tests/tests/com/android/jack/generic/basic/GenericTests.java new file mode 100644 index 00000000..d8896917 --- /dev/null +++ b/jack-tests/tests/com/android/jack/generic/basic/GenericTests.java @@ -0,0 +1,47 @@ +/* + * 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.generic.basic; + +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.BeforeClass; +import org.junit.Test; + +/** + * JUnit test for compilation of generics. + */ +public class GenericTests { + + @BeforeClass + public static void setUpClass() { + GenericTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Verifies that the test source can compile from source to dex file. + */ + @Test + public void testCompileBasic() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.generic.basic.jack")); + } +} diff --git a/jack-tests/tests/com/android/jack/ifstatement/IfstatementTests.java b/jack-tests/tests/com/android/jack/ifstatement/IfstatementTests.java new file mode 100644 index 00000000..d831f17c --- /dev/null +++ b/jack-tests/tests/com/android/jack/ifstatement/IfstatementTests.java @@ -0,0 +1,82 @@ +/* +* 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.ifstatement; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class IfstatementTests extends RuntimeTest { + + private RuntimeTestInfo ADVANCEDTEST = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.ifstatement.advancedTest"), + "com.android.jack.ifstatement.advancedTest.dx.Tests"); + + private RuntimeTestInfo CFGTEST = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.ifstatement.cfgTest"), + "com.android.jack.ifstatement.cfgTest.dx.Tests"); + + private RuntimeTestInfo FASTPATH = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.ifstatement.fastpath"), + "com.android.jack.ifstatement.fastpath.dx.Tests"); + + private RuntimeTestInfo SIMPLETEST = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.ifstatement.simpleTest"), + "com.android.jack.ifstatement.simpleTest.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + IfstatementTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void advancedTest() throws Exception { + new RuntimeTestHelper(ADVANCEDTEST).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void cfgTest() throws Exception { + new RuntimeTestHelper(CFGTEST).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void fastpath() throws Exception { + new RuntimeTestHelper(FASTPATH).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void simpleTest() throws Exception { + new RuntimeTestHelper(SIMPLETEST).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(ADVANCEDTEST); + rtTestInfos.add(CFGTEST); + rtTestInfos.add(FASTPATH); + rtTestInfos.add(SIMPLETEST); + } +} diff --git a/jack-tests/tests/com/android/jack/imports/ImportTests.java b/jack-tests/tests/com/android/jack/imports/ImportTests.java new file mode 100644 index 00000000..79e9269f --- /dev/null +++ b/jack-tests/tests/com/android/jack/imports/ImportTests.java @@ -0,0 +1,172 @@ +/* + * 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.imports; + +import com.android.jack.backend.jayce.ImportConflictException; +import com.android.jack.backend.jayce.JayceFileImporter; +import com.android.jack.backend.jayce.TypeImportConflictException; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; +import com.android.jack.test.toolchain.JackApiToolchain; +import com.android.jack.test.toolchain.JackBasedToolchain; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; + +public class ImportTests { + + @BeforeClass + public static void setUpClass() { + ImportTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void testCompileNonConflictingSourceAndImport() throws Exception { + File jackOut = AbstractTestTools.createTempDir(); + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + jackOut, + /* zipFiles = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.fibonacci.test001.jack")); + + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.addStaticLibs(jackOut); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.threeaddress.test001.jack")); + } + + @Test + public void testCompileConflictingSourceAndImport() throws Exception { + File jackOut = AbstractTestTools.createTempDir(); + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + jackOut, + /* zipFiles = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.fibonacci.test001.jack")); + + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.addStaticLibs(jackOut); + try { + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.fibonacci.test001.jack")); + Assert.fail(); + } catch (ImportConflictException e) { + // expected + } + } + + @Test + public void testConflictingImport() throws Exception { + String testName = "com.android.jack.inner.test015"; + File lib = AbstractTestTools.createTempDir(); + JackBasedToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + lib, + /* zipFile = */ false, + AbstractTestTools.getTestRootDir(testName + ".lib")); + + + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addStaticLibs(lib); + toolchain.addProperty(JayceFileImporter.COLLISION_POLICY.getName(), "keep-first"); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempFile("inner15", ".zip"), + /* zipFile = */ true, + AbstractTestTools.getTestRootDir(testName + ".jack")); + } + + @Test + public void testConflictingImportWithFailPolicy1() throws Exception { + String testName = "com.android.jack.inner.test015"; + File lib = AbstractTestTools.createTempDir(); + JackApiToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + lib, + /* zipFile = */ false, + AbstractTestTools.getTestRootDir(testName + ".lib")); + + toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + // import twice the same lib + toolchain.addStaticLibs(lib, lib); + toolchain.addProperty(JayceFileImporter.COLLISION_POLICY.getName(), "fail"); + try { + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempFile("inner15", ".zip"), + /* zipFile = */ true, + AbstractTestTools.getTestRootDir(testName + ".jack")); + Assert.fail(); + } catch (TypeImportConflictException e) { + // Exception is ok + } + } + + @Test + public void testConflictingImportWithFailPolicy2() throws Exception { + String testName = "com.android.jack.inner.test015"; + File lib1 = AbstractTestTools.createTempDir(); + JackApiToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + lib1, + /* zipFile = */ false, + AbstractTestTools.getTestRootDir(testName + ".lib")); + + File lib2 = AbstractTestTools.createTempDir(); + toolchain = + AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + lib2, + /* zipFile = */ false, + AbstractTestTools.getTestRootDir(testName + ".lib")); + + toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + // import twice the same lib + toolchain.addStaticLibs(lib1, lib2); + toolchain.addProperty(JayceFileImporter.COLLISION_POLICY.getName(), "fail"); + + try { + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempFile("inner15", ".zip"), + /* zipFile = */ true, + AbstractTestTools.getTestRootDir(testName + ".jack")); + Assert.fail(); + } catch (TypeImportConflictException e) { + // Exception is ok + } + } +} diff --git a/jack-tests/tests/com/android/jack/init/InitTests.java b/jack-tests/tests/com/android/jack/init/InitTests.java new file mode 100644 index 00000000..c6215991 --- /dev/null +++ b/jack-tests/tests/com/android/jack/init/InitTests.java @@ -0,0 +1,61 @@ +/* +* 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.init; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class InitTests extends RuntimeTest { + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.init.test002"), + "com.android.jack.init.test002.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + InitTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void test001() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.init.test001.jack")); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST002); + } +} diff --git a/jack-tests/tests/com/android/jack/inner/InnerTests.java b/jack-tests/tests/com/android/jack/inner/InnerTests.java new file mode 100644 index 00000000..26b810a8 --- /dev/null +++ b/jack-tests/tests/com/android/jack/inner/InnerTests.java @@ -0,0 +1,349 @@ +/* +* 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.inner; + +import com.android.jack.TestTools; +import com.android.jack.test.category.RedundantTests; +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.comparator.ComparatorDex; +import com.android.jack.test.helper.CheckDexStructureTestHelper; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import javax.annotation.Nonnull; + +public class InnerTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test001"), + "com.android.jack.inner.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test002"), + "com.android.jack.inner.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test003"), + "com.android.jack.inner.test003.dx.Tests"); + + private RuntimeTestInfo TEST004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test004"), + "com.android.jack.inner.test004.dx.Tests"); + + private RuntimeTestInfo TEST005 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test005"), + "com.android.jack.inner.test005.dx.Tests"); + + private RuntimeTestInfo TEST006 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test006"), + "com.android.jack.inner.test006.dx.Tests"); + + private RuntimeTestInfo TEST007 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test007"), + "com.android.jack.inner.test007.dx.Tests"); + + private RuntimeTestInfo TEST008 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test008"), + "com.android.jack.inner.test008.dx.Tests"); + + private RuntimeTestInfo TEST009 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test009"), + "com.android.jack.inner.test009.dx.Tests"); + + private RuntimeTestInfo TEST010 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test010"), + "com.android.jack.inner.test010.dx.Tests"); + + private RuntimeTestInfo TEST011 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test011"), + "com.android.jack.inner.test011.dx.Tests"); + + private RuntimeTestInfo TEST012 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test012"), + "com.android.jack.inner.test012.dx.Tests"); + + private RuntimeTestInfo TEST013 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test013"), + "com.android.jack.inner.test013.dx.Tests"); + + private RuntimeTestInfo TEST014 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test014"), + "com.android.jack.inner.test014.dx.Tests"); + + private RuntimeTestInfo TEST015 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test015"), + "com.android.jack.inner.test015.dx.Tests"); + + private RuntimeTestInfo TEST016 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test016"), + "com.android.jack.inner.test016.dx.Tests"); + + private RuntimeTestInfo TEST017 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test017"), + "com.android.jack.inner.test017.dx.Tests"); + + private RuntimeTestInfo TEST018 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test018"), + "com.android.jack.inner.test018.dx.Tests"); + + private RuntimeTestInfo TEST019 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test019"), + "com.android.jack.inner.test019.dx.Tests"); + + private RuntimeTestInfo TEST020 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test020"), + "com.android.jack.inner.test020.dx.Tests"); + + private RuntimeTestInfo TEST021 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test021"), + "com.android.jack.inner.test021.dx.Tests"); + + private RuntimeTestInfo TEST022 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test022"), + "com.android.jack.inner.test022.dx.Tests"); + + private RuntimeTestInfo TEST023 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test023"), + "com.android.jack.inner.test023.dx.Tests"); + + private RuntimeTestInfo TEST024 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test024"), + "com.android.jack.inner.test024.dx.Tests"); + + private RuntimeTestInfo TEST026 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.inner.test026"), + "com.android.jack.inner.test026.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + InnerTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test004() throws Exception { + new RuntimeTestHelper(TEST004).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test005() throws Exception { + new RuntimeTestHelper(TEST005).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test006() throws Exception { + new RuntimeTestHelper(TEST006).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test007() throws Exception { + new RuntimeTestHelper(TEST007).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test008() throws Exception { + new RuntimeTestHelper(TEST008).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test009() throws Exception { + new RuntimeTestHelper(TEST009).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test010() throws Exception { + new RuntimeTestHelper(TEST010).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test011() throws Exception { + new RuntimeTestHelper(TEST011).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test012() throws Exception { + new RuntimeTestHelper(TEST012).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test013() throws Exception { + new RuntimeTestHelper(TEST013).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test014() throws Exception { + new RuntimeTestHelper(TEST014).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test015() throws Exception { + new RuntimeTestHelper(TEST015).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test016() throws Exception { + new RuntimeTestHelper(TEST016).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test017() throws Exception { + new RuntimeTestHelper(TEST017).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test018() throws Exception { + new RuntimeTestHelper(TEST018).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test019() throws Exception { + new RuntimeTestHelper(TEST019).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test020() throws Exception { + new RuntimeTestHelper(TEST020).compileAndRunTest(true); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test021() throws Exception { + new RuntimeTestHelper(TEST021).compileAndRunTest(true); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test022() throws Exception { + new RuntimeTestHelper(TEST022).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test023() throws Exception { + new RuntimeTestHelper(TEST023).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test024() throws Exception { + new RuntimeTestHelper(TEST024).compileAndRunTest(); + } + + @Test + public void test025() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.inner.test025.jack")); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test026() throws Exception { + new RuntimeTestHelper(TEST026).compileAndRunTest(); + } + + @Test + public void testCheckStructure20() throws Exception { + //TODO: find out why debug info check fails + checkStructure("test020"); + } + + @Test + @Category(RedundantTests.class) + public void testCompile21() throws Exception { + checkStructure("test021"); + } + + private void checkStructure(@Nonnull String test) throws Exception { + SourceToDexComparisonTestHelper helper = new CheckDexStructureTestHelper( + AbstractTestTools.getTestRootDir("com.android.jack.inner." + test + ".jack")); + helper.runTest(new ComparatorDex(helper.getCandidateDex(), helper.getReferenceDex())); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); + rtTestInfos.add(TEST004); + rtTestInfos.add(TEST005); + rtTestInfos.add(TEST006); + rtTestInfos.add(TEST007); + rtTestInfos.add(TEST008); + rtTestInfos.add(TEST009); + rtTestInfos.add(TEST010); + rtTestInfos.add(TEST011); + rtTestInfos.add(TEST012); + rtTestInfos.add(TEST013); + rtTestInfos.add(TEST014); + rtTestInfos.add(TEST015); + rtTestInfos.add(TEST016); + rtTestInfos.add(TEST017); + rtTestInfos.add(TEST018); + rtTestInfos.add(TEST019); + rtTestInfos.add(TEST020); + rtTestInfos.add(TEST021); + rtTestInfos.add(TEST022); + rtTestInfos.add(TEST023); + rtTestInfos.add(TEST024); + rtTestInfos.add(TEST026); + } +} diff --git a/jack-tests/tests/com/android/jack/instance/InstanceTest.java b/jack-tests/tests/com/android/jack/instance/InstanceTest.java new file mode 100644 index 00000000..e44111cf --- /dev/null +++ b/jack-tests/tests/com/android/jack/instance/InstanceTest.java @@ -0,0 +1,43 @@ +/* + * 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.instance; + +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.Before; +import org.junit.Test; + +import java.io.File; + +public class InstanceTest { + + @Before + public void setUp() throws Exception { + InstanceTest.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void testReturnThis() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + new File( AbstractTestTools.getTestRootDir("com.android.jack.instance.test001.jack"), + "Instance.java")); + } +} diff --git a/jack-tests/tests/com/android/jack/invoke/InvokeTests.java b/jack-tests/tests/com/android/jack/invoke/InvokeTests.java new file mode 100644 index 00000000..1db4e57b --- /dev/null +++ b/jack-tests/tests/com/android/jack/invoke/InvokeTests.java @@ -0,0 +1,115 @@ +/* +* 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.invoke; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class InvokeTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.invoke.test001"), + "com.android.jack.invoke.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.invoke.test002"), + "com.android.jack.invoke.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.invoke.test003"), + "com.android.jack.invoke.test003.dx.Tests"); + + private RuntimeTestInfo TEST004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.invoke.test004"), + "com.android.jack.invoke.test004.dx.Tests"); + + private RuntimeTestInfo TEST005 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.invoke.test005"), + "com.android.jack.invoke.test005.dx.Tests"); + + private RuntimeTestInfo TEST006 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.invoke.test006"), + "com.android.jack.invoke.test006.dx.Tests"); + + private RuntimeTestInfo TEST007 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.invoke.test007"), + "com.android.jack.invoke.test007.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + InvokeTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test004() throws Exception { + new RuntimeTestHelper(TEST004).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test005() throws Exception { + new RuntimeTestHelper(TEST005).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test006() throws Exception { + new RuntimeTestHelper(TEST006).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test007() throws Exception { + new RuntimeTestHelper(TEST007).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); + rtTestInfos.add(TEST004); + rtTestInfos.add(TEST005); + rtTestInfos.add(TEST006); + rtTestInfos.add(TEST007); + } +} diff --git a/jack-tests/tests/com/android/jack/jarjar/JarjarTests.java b/jack-tests/tests/com/android/jack/jarjar/JarjarTests.java index 6bac5cc2..dbfe543a 100644 --- a/jack-tests/tests/com/android/jack/jarjar/JarjarTests.java +++ b/jack-tests/tests/com/android/jack/jarjar/JarjarTests.java @@ -19,30 +19,71 @@ package com.android.jack.jarjar; import com.android.jack.test.helper.RuntimeTestHelper; import com.android.jack.test.runtime.RuntimeTestInfo; import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; +import com.tonicsystems.jarjar.PackageRemapper; +import com.tonicsystems.jarjar.PatternElement; +import com.tonicsystems.jarjar.Rule; +import com.tonicsystems.jarjar.Wildcard; + +import junit.framework.Assert; import org.junit.Before; import org.junit.Test; import java.io.File; +import java.util.Collections; import javax.annotation.Nonnull; public class JarjarTests { @Nonnull - private File baseDir; + private RuntimeTestInfo JARJAR001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.jarjar.test001"), + "com.android.jack.jarjar.test001.dx.Tests"); + + @Nonnull + private RuntimeTestInfo JARJAR003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.jarjar.test003"), + "com.android.jack.jarjar.test003.dx.Tests"); @Before public void setUp() { - baseDir = AbstractTestTools.getTestRootDir("com.android.jack.jarjar.test001"); + JarjarTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void jarjar001() throws Exception { + new RuntimeTestHelper(JARJAR001) + .setJarjarRulesFileName("jarjar-rules.txt") + .compileAndRunTest(); } @Test - public void compileAndRunTest() throws Exception { - RuntimeTestHelper rtEnv = new RuntimeTestHelper( - new RuntimeTestInfo(baseDir, "com.android.jack.jarjar.test001.dx.Tests")); - rtEnv.setJarjarRulesFileName("jarjar-rules.txt"); - rtEnv.compileAndRunTest(); + public void jarjar003() throws Exception { + new RuntimeTestHelper(JARJAR003) + .setJarjarRulesFileName("jarjar-rules.txt") + .compileAndRunTest(); + } + + @Test + public void jarjar003_1() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.setJarjarRules(new File(JARJAR003.directory, "jarjar-rules.txt")); + File lib = AbstractTestTools.createTempFile("jarjarTest003Jack", ".zip"); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + lib, + /* zipFiles = */ true, + new File(JARJAR003.directory, "jack")); + + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToLib( + AbstractTestTools.getClasspathsAsString(toolchain.getDefaultBootClasspath(), + new File [] {lib}), + AbstractTestTools.createTempFile("jarjarTest003dx", ".zip"), + /* zipFiles = */ true, + new File(JARJAR003.directory, "dontcompile/TestWithRelocatedReference.java")); } } diff --git a/jack-tests/tests/com/android/jack/java7/BoxingTest.java b/jack-tests/tests/com/android/jack/java7/BoxingTest.java new file mode 100644 index 00000000..8327f68e --- /dev/null +++ b/jack-tests/tests/com/android/jack/java7/BoxingTest.java @@ -0,0 +1,55 @@ +/* + * 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.java7; + +import com.android.jack.Main; +import com.android.jack.Options; +import com.android.jack.TestTools; +import com.android.jack.test.category.KnownBugs; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; +import com.android.jack.test.toolchain.JackBasedToolchain; +import com.android.jack.test.toolchain.Toolchain.SourceLevel; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +/** + * JUnit test for compilation of Java 7 features + */ +public class BoxingTest { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Category(KnownBugs.class) + @Test + public void java7Boxing001() throws Exception { + IToolchain toolchain = + AbstractTestTools.getCandidateToolchain(); + toolchain.setSourceLevel(SourceLevel.JAVA_7).srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.java7.boxing.test001.jack")); + } +} diff --git a/jack-tests/tests/com/android/jack/java7/ExceptionsTest.java b/jack-tests/tests/com/android/jack/java7/ExceptionsTest.java index ecbe578d..73d4ff8e 100644 --- a/jack-tests/tests/com/android/jack/java7/ExceptionsTest.java +++ b/jack-tests/tests/com/android/jack/java7/ExceptionsTest.java @@ -68,7 +68,7 @@ public class ExceptionsTest { AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); jackBasedToolchain.setSourceLevel(SourceLevel.JAVA_7).srcToExe( AbstractTestTools.getClasspathAsString(jackBasedToolchain.getDefaultBootClasspath()), - AbstractTestTools.createTempDir(), new File( + AbstractTestTools.createTempDir(), /* zipFile = */ false, new File( AbstractTestTools.getTestRootDir("com.android.jack.java7.exceptions." + name), "jack")); } } diff --git a/jack-tests/tests/com/android/jack/java7/Java7AllTest.java b/jack-tests/tests/com/android/jack/java7/Java7AllTest.java new file mode 100644 index 00000000..fe9cdb4c --- /dev/null +++ b/jack-tests/tests/com/android/jack/java7/Java7AllTest.java @@ -0,0 +1,35 @@ +/* + * 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.java7; + + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +/** + * JUnit test for compilation of Java 7 features + */ +@RunWith(Suite.class) +@SuiteClasses(value = { + SwitchesTest.class, + ExceptionsTest.class, + BoxingTest.class, + TryWithResourcesTests.class + }) +public class Java7AllTest { +} diff --git a/jack-tests/tests/com/android/jack/java7/SwitchesTest.java b/jack-tests/tests/com/android/jack/java7/SwitchesTest.java new file mode 100644 index 00000000..3fb13d3e --- /dev/null +++ b/jack-tests/tests/com/android/jack/java7/SwitchesTest.java @@ -0,0 +1,85 @@ +/* + * 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.java7; + +import com.android.jack.Main; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; +import com.android.jack.test.toolchain.Toolchain.SourceLevel; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; + +import javax.annotation.Nonnull; + +/** + * JUnit test for compilation of Java 7 features + */ +public class SwitchesTest { + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void java7Switches001() throws Exception { + compileJava7Test("test001"); + } + + @Test + public void java7Switches002() throws Exception { + compileJava7Test("test002"); + } + + @Test + public void java7Switches003() throws Exception { + compileJava7Test("test003"); + } + + @Test + public void java7Switches004() throws Exception { + + File jackZipFile = AbstractTestTools.createTempFile("tmp", ".zip"); + + IToolchain toolchain = + AbstractTestTools.getCandidateToolchain(); + toolchain.setSourceLevel(SourceLevel.JAVA_7).srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + jackZipFile, + /* zipFiles = */ true, + AbstractTestTools.getTestRootDir("com.android.jack.java7.switches.test001.jack")); + + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.setSourceLevel(SourceLevel.JAVA_7).libToExe( + jackZipFile, + AbstractTestTools.createTempDir(), + /* zipFile = */ false); + } + + private void compileJava7Test(@Nonnull String name) throws Exception { + IToolchain toolchain = + AbstractTestTools.getCandidateToolchain(); + toolchain.setSourceLevel(SourceLevel.JAVA_7).srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.java7.switches." + name + ".jack")); + } + +} diff --git a/jack-tests/tests/com/android/jack/java7/TryWithResourcesTests.java b/jack-tests/tests/com/android/jack/java7/TryWithResourcesTests.java new file mode 100644 index 00000000..0584b6d1 --- /dev/null +++ b/jack-tests/tests/com/android/jack/java7/TryWithResourcesTests.java @@ -0,0 +1,65 @@ +/* + * 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.java7; + +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; +import com.android.jack.test.toolchain.Toolchain.SourceLevel; + +import org.junit.BeforeClass; +import org.junit.Test; + +/** + * JUnit test for compilation of try-with-resources. + */ +public class TryWithResourcesTests { + + @BeforeClass + public static void setUpClass() { + TryWithResourcesTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + /** + * Verifies that the test source can compiled from source to dex file. + */ + @Test + public void testCompile() throws Exception { + IToolchain toolchain = + AbstractTestTools.getCandidateToolchain(); + toolchain.setSourceLevel(SourceLevel.JAVA_7) + .srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.java7.trywithresources.test001.jack")); + } + + /** + * Verifies that the test source can compiled from source to dex file. + */ + @Test + public void testCompile2() throws Exception { + IToolchain toolchain = + AbstractTestTools.getCandidateToolchain(); + toolchain.setSourceLevel(SourceLevel.JAVA_7) + .srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.java7.trywithresources.test002.jack")); + } +} diff --git a/jack-tests/tests/com/android/jack/enums/EnumTests.java b/jack-tests/tests/com/android/jack/label/LabelTest.java index 361e6a65..945a215e 100644 --- a/jack-tests/tests/com/android/jack/enums/EnumTests.java +++ b/jack-tests/tests/com/android/jack/label/LabelTest.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2014 The Android Open Source Project + * 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. @@ -14,30 +14,30 @@ * limitations under the License. */ -package com.android.jack.enums; +package com.android.jack.label; -import com.android.jack.test.helper.RuntimeTestHelper; -import com.android.jack.test.runtime.RuntimeTestInfo; import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; import org.junit.Before; import org.junit.Test; import java.io.File; -public class EnumTests { - - private File baseDir; +public class LabelTest { @Before - public void setUp() { - baseDir = AbstractTestTools.getTestRootDir("com.android.jack.enums.test003"); + public void setUp() throws Exception { + LabelTest.class.getClassLoader().setDefaultAssertionStatus(true); } @Test - public void compileAndRunTest() throws Exception { - new RuntimeTestHelper(new RuntimeTestInfo(baseDir, "com.android.jack.enums.test003.dx.Tests")) - .compileAndRunTest(); + public void labelMustNotBreakTree() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + new File(AbstractTestTools.getTestRootDir("com.android.jack.label.test001.jack"), "Label.java")); } - } diff --git a/jack-tests/tests/com/android/jack/lookup/LookupTests.java b/jack-tests/tests/com/android/jack/lookup/LookupTests.java new file mode 100644 index 00000000..a51615e9 --- /dev/null +++ b/jack-tests/tests/com/android/jack/lookup/LookupTests.java @@ -0,0 +1,62 @@ +/* + * 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.lookup; + +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.Test; + +import java.io.File; + +public class LookupTests { + + @Test + public void test001() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + File lib = AbstractTestTools.createTempDir(); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + lib, + /* zipFiles = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.lookup.test001.lib")); + + File libOverride = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + libOverride, + /* zipFiles = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.lookup.test001.liboverride")); + + File jacks = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToLib( + AbstractTestTools + .getClasspathsAsString(toolchain.getDefaultBootClasspath(), new File [] {lib}), + jacks, + /* zipFiles = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.lookup.test001.jack")); + + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.libToLib( + new File [] {jacks, libOverride}, + AbstractTestTools.createTempFile("Lookup001", ".zip"), + /* zipFiles = */ true); + } + +} diff --git a/jack-tests/tests/com/android/jack/multidex/MultiDexAllTests.java b/jack-tests/tests/com/android/jack/multidex/MultiDexAllTests.java new file mode 100644 index 00000000..957dbcf1 --- /dev/null +++ b/jack-tests/tests/com/android/jack/multidex/MultiDexAllTests.java @@ -0,0 +1,12 @@ +package com.android.jack.multidex; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses(value = { + MultiDexTests.class, + MultiDexOverflowTests.class}) +public class MultiDexAllTests { +} diff --git a/jack-tests/tests/com/android/jack/multidex/MultiDexOverflowTests.java b/jack-tests/tests/com/android/jack/multidex/MultiDexOverflowTests.java new file mode 100644 index 00000000..8152c207 --- /dev/null +++ b/jack-tests/tests/com/android/jack/multidex/MultiDexOverflowTests.java @@ -0,0 +1,180 @@ +/* + * 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.multidex; + +import com.android.jack.JackAbortException; +import com.android.jack.TestTools; +import com.android.jack.backend.dex.DexFileWriter; +import com.android.jack.backend.dex.DexWritingException; +import com.android.jack.backend.dex.MainDexOverflowException; +import com.android.jack.backend.dex.MultiDexLegacy; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackApiToolchain; +import com.android.jack.tools.merger.FieldIdOverflowException; +import com.android.jack.tools.merger.MethodIdOverflowException; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; + +import javax.annotation.Nonnegative; +import javax.annotation.Nonnull; + +public class MultiDexOverflowTests { + + private static File annotations; + + @Nonnull + private static final String EXPECTED_MESSAGE = + "Error during the dex writing phase: classes.dex has too many IDs"; + + @BeforeClass + public static void init() throws IOException, Exception { + annotations = MultiDexTests.prepareAnnotations(); + } + + @Test + public void testMinimalMainDexOverflowWithMethods() throws Exception { + File srcFolder = TestTools.createTempDir("src", "dir"); + File outFolder = TestTools.createTempDir("out", "dir"); + + int fileCount = 655; + for (int fileIdx = 0; fileIdx < fileCount; fileIdx++) { + generateJavaFileWithMethods(srcFolder, fileIdx, 100); + } + generateJavaFileWithMethods(srcFolder, fileCount, 36); + + JackApiToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true"); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + toolchain.setErrorStream(baos); + + try { + toolchain.srcToExe( + AbstractTestTools.getClasspathsAsString( + toolchain.getDefaultBootClasspath(), + new File[] {annotations}), + outFolder, + /* zipFile = */ false, + srcFolder); + Assert.fail(); + } catch (JackAbortException e) { + Throwable cause = e.getCause(); + Assert.assertTrue(cause instanceof DexWritingException); + Assert.assertTrue(cause.getCause() instanceof MainDexOverflowException); + Assert.assertTrue(cause.getCause().getCause() instanceof MethodIdOverflowException); + Assert.assertTrue(baos.toString().contains(EXPECTED_MESSAGE)); + } + } + + @Test + public void testStandardMainDexOverflowWithFields() throws Exception { + File srcFolder = TestTools.createTempDir("src", "dir"); + File outFolder = TestTools.createTempDir("out", "dir"); + + int fileCount = 655; + for (int fileIdx = 0; fileIdx < fileCount; fileIdx++) { + generateJavaFileWithFields(srcFolder, fileIdx, 100); + } + generateJavaFileWithFields(srcFolder, fileCount, 37); + + JackApiToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true"); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex"); + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + toolchain.setErrorStream(baos); + + try { + toolchain.srcToExe( + AbstractTestTools.getClasspathsAsString( + toolchain.getDefaultBootClasspath(), + new File[] {annotations}), + outFolder, + /* zipFile = */ false, + srcFolder); + Assert.fail(); + } catch (JackAbortException e) { + Throwable cause = e.getCause(); + Assert.assertTrue(cause instanceof DexWritingException); + Assert.assertTrue(cause.getCause() instanceof MainDexOverflowException); + Assert.assertTrue(cause.getCause().getCause() instanceof FieldIdOverflowException); + Assert.assertTrue(baos.toString().contains(EXPECTED_MESSAGE)); + } + } + + private void generateJavaFileWithMethods(@Nonnull File srcFolder, @Nonnegative int fileIdx, + @Nonnegative int methodCount) throws IOException, FileNotFoundException { + File javaFile = new File(srcFolder, "A" + fileIdx + ".java"); + if (!javaFile.createNewFile()) { + throw new IOException("Failed to create file " + javaFile.getAbsolutePath()); + } + FileOutputStream fos = null; + try { + fos = new FileOutputStream(javaFile); + StringBuilder content = new StringBuilder("package jack.merger; \n" + + "@com.android.jack.annotations.ForceInMainDex public class A" + fileIdx + " {\n"); + // -1 due to implicit init method + for (int mthIdx = 0; mthIdx < methodCount - 1; mthIdx++) { + content.append("public void m" + mthIdx + "() {} \n"); + } + content.append("} \n"); + fos.write(content.toString().getBytes()); + } finally { + if (fos != null) { + fos.close(); + } + } + } + + private void generateJavaFileWithFields(@Nonnull File srcFolder, @Nonnegative int fileIdx, + @Nonnegative int fieldCount) throws IOException, FileNotFoundException { + File javaFile = new File(srcFolder, "A" + fileIdx + ".java"); + if (!javaFile.createNewFile()) { + throw new IOException("Failed to create file " + javaFile.getAbsolutePath()); + } + FileOutputStream fos = null; + try { + fos = new FileOutputStream(javaFile); + StringBuilder content = new StringBuilder("package jack.merger; \n" + + "@com.android.jack.annotations.ForceInMainDex public class A" + fileIdx + " {\n"); + for (int fieldIdx = 0; fieldIdx < fieldCount; fieldIdx++) { + content.append("public int f" + fieldIdx + ";\n"); + } + content.append("} \n"); + fos.write(content.toString().getBytes()); + } finally { + if (fos != null) { + fos.close(); + } + } + } + +} diff --git a/jack-tests/tests/com/android/jack/multidex/MultiDexTests.java b/jack-tests/tests/com/android/jack/multidex/MultiDexTests.java new file mode 100644 index 00000000..983c882c --- /dev/null +++ b/jack-tests/tests/com/android/jack/multidex/MultiDexTests.java @@ -0,0 +1,546 @@ +/* + * 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.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.library.FileType; +import com.android.jack.preprocessor.PreProcessor; +import com.android.jack.shrob.ListingComparator; +import com.android.jack.test.comparator.Comparator; +import com.android.jack.test.comparator.ComparatorException; +import com.android.jack.test.comparator.ComparatorFile; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +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.util.ExecuteFile; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Properties; + +import javax.annotation.Nonnull; + +public class MultiDexTests { + + private static File annotations; + private static File frameworks; + private static File library; + + private class ComparatorMultiDexListing extends ComparatorFile { + + protected ComparatorMultiDexListing(File candidate, File reference) { + super(candidate, reference); + } + + @Override + public void compare() throws DifferenceFoundException, ComparatorException { + try { + ListingComparator.compare(reference, getListingOfDex(candidate)); + } catch (IOException e) { + throw new ComparatorException(e); + } + } + } + + @BeforeClass + public static void init() throws IOException, Exception { + MultiDexTests.class.getClassLoader().setDefaultAssertionStatus(true); + + annotations = prepareAnnotations(); + + frameworks = prepareFrameworks(); + + library = prepareLibrary(frameworks); + } + + @Test + public void versionedTest001a() throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test001.jack"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + + addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-001.jpp")); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex"); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(testFolder); + + env.setCandidateTestTools(toolchain); + + List<File> cp = new ArrayList<File>(); + cp.addAll(Arrays.asList(toolchain.getDefaultBootClasspath())); + cp.add(annotations); + cp.add(frameworks); + env.setCandidateClasspath(cp.toArray(new File[cp.size()])); + env.setReferenceTestTools(new DummyToolchain()); + + env.runTest(new ComparatorMultiDexListing(env.getCandidateDex(), new File(testFolder, "ref-list-001.txt"))); + + Assert.assertFalse(new File(env.getCandidateDexDir(), "classes2.dex").exists()); + } + + @Test + public void versionedTest001b() throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test001.jack"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-001.jpp")); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(testFolder); + env.setCandidateTestTools(toolchain); + List<File> cp = new ArrayList<File>(); + cp.addAll(Arrays.asList(toolchain.getDefaultBootClasspath())); + cp.add(annotations); + cp.add(frameworks); + env.setCandidateClasspath(cp.toArray(new File[cp.size()])); + env.setReferenceTestTools(new DummyToolchain()); + + Comparator c1 = new ComparatorMultiDexListing(env.getCandidateDex(), new File(testFolder, "ref-list-002-1.txt")); + Comparator c2 = new ComparatorMultiDexListing(new File(env.getCandidateDexDir(), "classes2.dex"), new File(testFolder, "ref-list-002-2.txt")); + env.runTest(c1, c2); + + Assert.assertFalse(new File(env.getCandidateDexDir(), "classes3.dex").exists()); + } + + @Test + public void versionedTest001c() throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test001.jack"); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-003.jpp")); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(testFolder); + env.setCandidateTestTools(toolchain); + List<File> cp = new ArrayList<File>(); + cp.addAll(Arrays.asList(toolchain.getDefaultBootClasspath())); + cp.add(annotations); + cp.add(frameworks); + env.setCandidateClasspath(cp.toArray(new File[cp.size()])); + env.setReferenceTestTools(new DummyToolchain()); + + Comparator c1 = new ComparatorMultiDexListing(env.getCandidateDex(), new File(testFolder, "ref-list-003-1.txt")); + Comparator c2 = new ComparatorMultiDexListing(new File(env.getCandidateDexDir(), "classes2.dex"), new File(testFolder, "ref-list-003-2.txt")); + env.runTest(c1, c2); + + Assert.assertFalse(new File(env.getCandidateDexDir(), "classes3.dex").exists()); + } + + @Test + public void versionedTest001a_withoutAnnotations() throws Exception { + + 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"); + + TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString() + + File.pathSeparator + frameworks.getPath(), + out, false); + + File 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__withoutAnnotations() throws Exception { + + 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"); + + TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString() + + File.pathSeparator + frameworks.getPath(), + out, false); + + File outList = getListingOfDex(new File(out, "classes.dex")); + ListingComparator.compare(new File(testFolder, "ref-list-002-1.txt"), outList); + File 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")); + + app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); + + TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString() + + File.pathSeparator + frameworks.getPath(), + out, false); + + File outList = getListingOfDex(new File(out, "classes.dex")); + ListingComparator.compare(new File(testFolder, "ref-list-003-1.txt"), outList); + File 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, + @Nonnull File configFile) { + toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true"); + toolchain.addProperty(PreProcessor.ENABLE.getName(), "true"); + toolchain.addProperty(PreProcessor.FILE.getName(), configFile.getAbsolutePath()); + } + + private File getListingOfDex(@Nonnull File dex) throws IOException, FileNotFoundException { + assert dex.isFile(); + ExecuteFile exec = + new ExecuteFile(new String[]{ + "bash", "-c", AbstractTestTools.getPrebuilt("dexdump").getAbsolutePath() + " " + + dex.getAbsolutePath() + + " | grep \" Class descriptor : \" | cut -d\\' -f2 | sed -e 's/$/:/'"}); + + File outList = TestTools.createTempFile("types", ".txt"); + + exec.setOut(outList); + Assert.assertTrue(exec.run()); + return outList; + } + + private int getTypeCountInDex(@Nonnull File dex) throws IOException, FileNotFoundException { + assert dex.isFile(); + ExecuteFile exec = + new ExecuteFile(new String[]{ + "bash", "-c", AbstractTestTools.getPrebuilt("dexdump").getAbsolutePath() + " " + + dex.getAbsolutePath() + + " | grep \" Class descriptor : \" | wc -l"}); + + File out = TestTools.createTempFile("typeNumber", ".txt"); + + exec.setOut(out); + Assert.assertTrue(exec.run()); + BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(out))); + try { + String readLine = reader.readLine(); + assert readLine != null; + return Integer.parseInt(readLine.trim()); + } finally { + reader.close(); + } + } + + @Nonnull + private static File prepareLib(@Nonnull File sources, @Nonnull File... classpath) throws Exception { + File outDir = AbstractTestTools.createTempDir(); + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToLib( + AbstractTestTools.getClasspathsAsString(toolchain.getDefaultBootClasspath(), classpath), + outDir, + /* zipFiles = */ false, + sources); + return outDir; + } + + @Nonnull + private static File prepareFrameworks() throws IOException, Exception { + return prepareLib(AbstractTestTools.getTestRootDir("com.android.jack.multidex.fakeframeworks")); +// File frameworks = TestTools.createTempDir("frameworks", ""); +// TestTools.compileSourceToJack(new Options(), +// TestTools.getJackTestFolder("multidex/fakeframeworks"), +// TestTools.getDefaultBootclasspathString(), frameworks, false); +// return frameworks; + } + + @Nonnull + protected static File prepareAnnotations() throws IOException, Exception { + return prepareLib(AbstractTestTools.getTestRootDir("com.android.jack.annotations")); +// File annotations = TestTools.createTempDir("multidexAnnotations", ""); +// TestTools.compileSourceToJack(new Options(), +// TestTools.getFromAndroidTree( +// "toolchain/jack/jack-tests/tests/com/android/jack/annotations/"), +// TestTools.getDefaultBootclasspathString(), annotations, false); +// return annotations; + } + + @Nonnull + private static File prepareLibrary(@Nonnull File frameworks) throws IOException, Exception { + return prepareLib(AbstractTestTools.getTestRootDir("com.android.jack.multidex.fakelibrary"), + frameworks); +// File library = TestTools.createTempDir("multidexLibrary", ""); +// TestTools.compileSourceToJack(new Options(), +// TestTools.getJackTestFolder("multidex/fakelibrary"), +// TestTools.getDefaultBootclasspathString() + File.pathSeparator + frameworks.getPath(), +// library, false); +// return library; + } + + private static void setMetaIntoJackProperties(@Nonnull File library) throws IOException { + File jackProperties = new File(library, "jack.properties"); + Properties libraryProperties = new Properties(); + FileInputStream fis = null; + FileOutputStream fos = null; + try { + fis = new FileInputStream(jackProperties); + libraryProperties.load(fis); + } catch (IOException e) { + Assert.fail(); + } finally { + if (fis != null) { + fis.close(); + } + } + try { + fos = new FileOutputStream(jackProperties); + libraryProperties.put(FileType.JPP.buildPropertyName(null /*suffix*/), "true"); + libraryProperties.store(fos, "Library properties"); + } catch (IOException e) { + Assert.fail(); + } finally { + if (fos != null) { + fos.close(); + } + } + } + + @Test + public void legacyAppTest002a() throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test002.jack"); + File out = AbstractTestTools.createTempDir(); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-001.jpp")); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex"); + + toolchain.srcToExe( + AbstractTestTools.getClasspathsAsString(toolchain.getDefaultBootClasspath(), new File [] {annotations, frameworks, library}), + out, + /* zipFile = */ false, + testFolder); + + File classesDex = new File(out, "classes.dex"); + Assert.assertTrue(classesDex.exists()); + File classes2Dex = new File(out, "classes2.dex"); + Assert.assertTrue(classes2Dex.exists()); + File classes3Dex = new File(out, "classes3.dex"); + Assert.assertFalse(classes3Dex.exists()); + int totalTypeNumber = getTypeCountInDex(classesDex) + getTypeCountInDex(classes2Dex); + Assert.assertEquals(100, totalTypeNumber); + return; + } + + @Test + public void legacyAppTest002b() throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test002.jack"); + File out = AbstractTestTools.createTempDir(); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-001.jpp")); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); + toolchain.addStaticLibs(library); + + toolchain.srcToExe( + AbstractTestTools.getClasspathsAsString(toolchain.getDefaultBootClasspath(), new File [] {annotations, frameworks}), + out, + /* zipFile = */ false, + testFolder); + + File outList = getListingOfDex(new File(out, "classes.dex")); + // The old toolchain is doing a little better than us here it seems to identify when + // InterfaceWithEnum.class instance is used or not. + ListingComparator.compare( + new File(testFolder,"ref-list-002-1.txt"), outList); + File 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 legacyAppTest002b_auto() throws Exception { + 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")); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true"); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex"); + toolchain.addStaticLibs(autoLibrary); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(testFolder); + env.setCandidateTestTools(toolchain); + List<File> cp = new ArrayList<File>(); + cp.addAll(Arrays.asList(toolchain.getDefaultBootClasspath())); + cp.add(annotations); + cp.add(frameworks); + env.setCandidateClasspath(cp.toArray(new File[cp.size()])); + env.setReferenceTestTools(new DummyToolchain()); + + Comparator c1 = new ComparatorMultiDexListing(env.getCandidateDex(), new File(testFolder, "ref-list-002-1.txt")); + Comparator c2 = new ComparatorMultiDexListing(new File(env.getCandidateDexDir(), "classes2.dex"), new File(testFolder, "ref-list-002-2.txt")); + env.runTest(c1, c2); + + Assert.assertFalse(new File(env.getCandidateDexDir(), "classes3.dex").exists()); + } + + @Test + public void legacyAppTest002a_withoutAnnotations() throws Exception { + + 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"); + + TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString() + + File.pathSeparator + frameworks.getPath() + + File.pathSeparator + library.getPath(), out, false); + + File classesDex = new File(out, "classes.dex"); + Assert.assertTrue(classesDex.exists()); + File classes2Dex = new File(out, "classes2.dex"); + Assert.assertTrue(classes2Dex.exists()); + File classes3Dex = new File(out, "classes3.dex"); + Assert.assertFalse(classes3Dex.exists()); + int totalTypeNumber = getTypeCountInDex(classesDex) + getTypeCountInDex(classes2Dex); + Assert.assertEquals(100, totalTypeNumber); + return; + } + + @Test + public void legacyAppTest002b_withoutAnnotations() throws Exception { + + 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.addJayceImport(library); + + TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString() + + File.pathSeparator + frameworks.getPath(), + out, false); + + File outList = getListingOfDex(new File(out, "classes.dex")); + // The old toolchain is doing a little better than us here it seems to identify when + // InterfaceWithEnum.class instance is used or not. + ListingComparator.compare( + new File(testFolder,"ref-list-002-1.txt"), outList); + File 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 legacyAppTest002b_auto_withoutAnnotations() throws Exception { + + File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test002"); + 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.addJayceImport(autoLibrary); + + TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString() + + File.pathSeparator + frameworks.getPath(), + out, false); + + File outList = getListingOfDex(new File(out, "classes.dex")); + // The old toolchain is doing a little better than us here it seems to identify when + // InterfaceWithEnum.class instance is used or not. + ListingComparator.compare( + new File(testFolder,"ref-list-002-1.txt"), outList); + File 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; + } + + /** + * Verifies that classes annotated with runtime visible annotations are put in main dex. + */ + @Test + public void legacyAppTest003() throws Exception { + + 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.getDefaultBootclasspathString() + + File.pathSeparator + annotations.getPath() + File.pathSeparator + frameworks.getPath(), + out, false); + + File outList = getListingOfDex(new File(out, "classes.dex")); + ListingComparator.compare( + new File(testFolder,"ref-list-003-1.txt"), outList); + File 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; + } +} diff --git a/jack-tests/tests/com/android/jack/newarray/NewarrayTests.java b/jack-tests/tests/com/android/jack/newarray/NewarrayTests.java new file mode 100644 index 00000000..94f84978 --- /dev/null +++ b/jack-tests/tests/com/android/jack/newarray/NewarrayTests.java @@ -0,0 +1,93 @@ +/* +* 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.newarray; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class NewarrayTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.newarray.test001"), + "com.android.jack.newarray.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.newarray.test002"), + "com.android.jack.newarray.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.newarray.test003"), + "com.android.jack.newarray.test003.dx.Tests"); + + private RuntimeTestInfo TEST004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.newarray.test004"), + "com.android.jack.newarray.test004.dx.Tests"); + + private RuntimeTestInfo TEST005 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.newarray.test005"), + "com.android.jack.newarray.test005.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + NewarrayTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test004() throws Exception { + new RuntimeTestHelper(TEST004).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test005() throws Exception { + new RuntimeTestHelper(TEST005).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); + rtTestInfos.add(TEST004); + rtTestInfos.add(TEST005); + } +} diff --git a/jack-tests/tests/com/android/jack/nopackage/NoPackageTests.java b/jack-tests/tests/com/android/jack/nopackage/NoPackageTests.java new file mode 100644 index 00000000..54c5978b --- /dev/null +++ b/jack-tests/tests/com/android/jack/nopackage/NoPackageTests.java @@ -0,0 +1,58 @@ +/* + * 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.nopackage; + +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; + +public class NoPackageTests { + + @BeforeClass + public static void setUpClass() { + NoPackageTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void test001() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.nopackage.test001.jack")); + } + + @Test + public void test001_throughJayce() throws Exception { + File tmpDir = AbstractTestTools.createTempDir(); + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + tmpDir, + /* zipFiles = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.nopackage.test001.jack")); + + toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.libToExe(tmpDir, AbstractTestTools.createTempDir(), /* zipFile = */ false); + } + +} diff --git a/jack-tests/tests/com/android/jack/nopackage/jack/ClassInDefaultPackage.java b/jack-tests/tests/com/android/jack/nopackage/test001/jack/ClassInDefaultPackage.java index 91e24242..91e24242 100644 --- a/jack-tests/tests/com/android/jack/nopackage/jack/ClassInDefaultPackage.java +++ b/jack-tests/tests/com/android/jack/nopackage/test001/jack/ClassInDefaultPackage.java diff --git a/jack-tests/tests/com/android/jack/nopackage/jack/InnerInDefaultPackage.java b/jack-tests/tests/com/android/jack/nopackage/test001/jack/InnerInDefaultPackage.java index 48e7c487..48e7c487 100644 --- a/jack-tests/tests/com/android/jack/nopackage/jack/InnerInDefaultPackage.java +++ b/jack-tests/tests/com/android/jack/nopackage/test001/jack/InnerInDefaultPackage.java diff --git a/jack-tests/tests/com/android/jack/opcodes/OpcodesTests.java b/jack-tests/tests/com/android/jack/opcodes/OpcodesTests.java new file mode 100644 index 00000000..0830306b --- /dev/null +++ b/jack-tests/tests/com/android/jack/opcodes/OpcodesTests.java @@ -0,0 +1,1740 @@ +/* +* 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.opcodes; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +import javax.annotation.Nonnull; + +public class OpcodesTests extends RuntimeTest { + + @Nonnull + private RuntimeTestInfo INVOKE_STATIC = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.invoke_static"), + "com.android.jack.opcodes.invoke_static.Test_invoke_static"); + + @Nonnull + private RuntimeTestInfo ARRAY_LENGTH = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.array_length"), + "com.android.jack.opcodes.array_length.Test_array_length"); + + @Nonnull + private RuntimeTestInfo NEG_FLOAT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.neg_float"), + "com.android.jack.opcodes.neg_float.Test_neg_float"); + + @Nonnull + private RuntimeTestInfo SUB_DOUBLE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sub_double"), + "com.android.jack.opcodes.sub_double.Test_sub_double"); + + @Nonnull + private RuntimeTestInfo AGET = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget"), + "com.android.jack.opcodes.aget.Test_aget"); + + @Nonnull + private RuntimeTestInfo APUT_BYTE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput_byte"), + "com.android.jack.opcodes.aput_byte.Test_aput_byte"); + + @Nonnull + private RuntimeTestInfo OPC_NEW = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_new"), + "com.android.jack.opcodes.opc_new.Test_opc_new"); + + @Nonnull + private RuntimeTestInfo CMPL_DOUBLE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.cmpl_double"), + "com.android.jack.opcodes.cmpl_double.Test_cmpl_double"); + + @Nonnull + private RuntimeTestInfo IF_GTZ = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_gtz"), + "com.android.jack.opcodes.if_gtz.Test_if_gtz"); + + @Nonnull + private RuntimeTestInfo FLOAT_TO_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.float_to_long"), + "com.android.jack.opcodes.float_to_long.Test_float_to_long"); + + @Nonnull + private RuntimeTestInfo ADD_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.add_long"), + "com.android.jack.opcodes.add_long.Test_add_long"); + + @Nonnull + private RuntimeTestInfo ADD_FLOAT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.add_float"), + "com.android.jack.opcodes.add_float.Test_add_float"); + + @Nonnull + private RuntimeTestInfo IPUT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.iput"), + "com.android.jack.opcodes.iput.Test_iput"); + + @Nonnull + private RuntimeTestInfo DIV_FLOAT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.div_float"), + "com.android.jack.opcodes.div_float.Test_div_float"); + + @Nonnull + private RuntimeTestInfo USHR_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.ushr_long"), + "com.android.jack.opcodes.ushr_long.Test_ushr_long"); + + @Nonnull + private RuntimeTestInfo CONST_WIDE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.const_wide"), + "com.android.jack.opcodes.const_wide.Test_const_wide"); + + @Nonnull + private RuntimeTestInfo XOR_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.xor_int"), + "com.android.jack.opcodes.xor_int.Test_xor_int"); + + @Nonnull + private RuntimeTestInfo AGET_OBJECT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget_object"), + "com.android.jack.opcodes.aget_object.Test_aget_object"); + + @Nonnull + private RuntimeTestInfo CONST4_16 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.const4_16"), + "com.android.jack.opcodes.const4_16.Test_const4_16"); + + @Nonnull + private RuntimeTestInfo REM_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.rem_long"), + "com.android.jack.opcodes.rem_long.Test_rem_long"); + + @Nonnull + private RuntimeTestInfo USHR_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.ushr_int"), + "com.android.jack.opcodes.ushr_int.Test_ushr_int"); + + @Nonnull + private RuntimeTestInfo IF_GE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_ge"), + "com.android.jack.opcodes.if_ge.Test_if_ge"); + + @Nonnull + private RuntimeTestInfo SUB_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sub_long"), + "com.android.jack.opcodes.sub_long.Test_sub_long"); + + @Nonnull + private RuntimeTestInfo FLOAT_TO_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.float_to_int"), + "com.android.jack.opcodes.float_to_int.Test_float_to_int"); + + @Nonnull + private RuntimeTestInfo INT_TO_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_long"), + "com.android.jack.opcodes.int_to_long.Test_int_to_long"); + + @Nonnull + private RuntimeTestInfo OR_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.or_long"), + "com.android.jack.opcodes.or_long.Test_or_long"); + + @Nonnull + private RuntimeTestInfo IF_GEZ = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_gez"), + "com.android.jack.opcodes.if_gez.Test_if_gez"); + + @Nonnull + private RuntimeTestInfo SHL_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.shl_int"), + "com.android.jack.opcodes.shl_int.Test_shl_int"); + + @Nonnull + private RuntimeTestInfo LONG_TO_FLOAT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.long_to_float"), + "com.android.jack.opcodes.long_to_float.Test_long_to_float"); + + @Nonnull + private RuntimeTestInfo DIV_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.div_int"), + "com.android.jack.opcodes.div_int.Test_div_int"); + + @Nonnull + private RuntimeTestInfo AND_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.and_long"), + "com.android.jack.opcodes.and_long.Test_and_long"); + + @Nonnull + private RuntimeTestInfo DOUBLE_TO_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.double_to_long"), + "com.android.jack.opcodes.double_to_long.Test_double_to_long"); + + @Nonnull + private RuntimeTestInfo MUL_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.mul_long"), + "com.android.jack.opcodes.mul_long.Test_mul_long"); + + @Nonnull + private RuntimeTestInfo DOUBLE_TO_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.double_to_int"), + "com.android.jack.opcodes.double_to_int.Test_double_to_int"); + + @Nonnull + private RuntimeTestInfo IF_NEZ = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_nez"), + "com.android.jack.opcodes.if_nez.Test_if_nez"); + + @Nonnull + private RuntimeTestInfo APUT_OBJECT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput_object"), + "com.android.jack.opcodes.aput_object.Test_aput_object"); + + @Nonnull + private RuntimeTestInfo IF_LT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_lt"), + "com.android.jack.opcodes.if_lt.Test_if_lt"); + + @Nonnull + private RuntimeTestInfo INT_TO_DOUBLE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_double"), + "com.android.jack.opcodes.int_to_double.Test_int_to_double"); + + @Nonnull + private RuntimeTestInfo MUL_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.mul_int"), + "com.android.jack.opcodes.mul_int.Test_mul_int"); + + @Nonnull + private RuntimeTestInfo SPUT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sput"), + "com.android.jack.opcodes.sput.Test_sput"); + + @Nonnull + private RuntimeTestInfo SHL_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.shl_long"), + "com.android.jack.opcodes.shl_long.Test_shl_long"); + + @Nonnull + private RuntimeTestInfo NEG_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.neg_long"), + "com.android.jack.opcodes.neg_long.Test_neg_long"); + + @Nonnull + private RuntimeTestInfo LONG_TO_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.long_to_int"), + "com.android.jack.opcodes.long_to_int.Test_long_to_int"); + + @Nonnull + private RuntimeTestInfo OPC_GOTO = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_goto"), + "com.android.jack.opcodes.opc_goto.Test_opc_goto"); + + @Nonnull + private RuntimeTestInfo INT_TO_FLOAT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_float"), + "com.android.jack.opcodes.int_to_float.Test_int_to_float"); + + @Nonnull + private RuntimeTestInfo XOR_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.xor_long"), + "com.android.jack.opcodes.xor_long.Test_xor_long"); + + @Nonnull + private RuntimeTestInfo MONITOR_ENTER = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.monitor_enter"), + "com.android.jack.opcodes.monitor_enter.Test_monitor_enter"); + + @Nonnull + private RuntimeTestInfo IF_EQZ = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_eqz"), + "com.android.jack.opcodes.if_eqz.Test_if_eqz"); + + @Nonnull + private RuntimeTestInfo INVOKE_DIRECT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.invoke_direct"), + "com.android.jack.opcodes.invoke_direct.Test_invoke_direct"); + + @Nonnull + private RuntimeTestInfo CMPL_FLOAT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.cmpl_float"), + "com.android.jack.opcodes.cmpl_float.Test_cmpl_float"); + + @Nonnull + private RuntimeTestInfo CHECK_CAST = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.check_cast"), + "com.android.jack.opcodes.check_cast.Test_check_cast"); + + @Nonnull + private RuntimeTestInfo OPC_THROW = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_throw"), + "com.android.jack.opcodes.opc_throw.Test_opc_throw"); + + @Nonnull + private RuntimeTestInfo INT_TO_SHORT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_short"), + "com.android.jack.opcodes.int_to_short.Test_int_to_short"); + + @Nonnull + private RuntimeTestInfo PACKED_SWITCH = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.packed_switch"), + "com.android.jack.opcodes.packed_switch.Test_packed_switch"); + + @Nonnull + private RuntimeTestInfo AGET_CHAR = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget_char"), + "com.android.jack.opcodes.aget_char.Test_aget_char"); + + @Nonnull + private RuntimeTestInfo RETURN_OBJECT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.return_object"), + "com.android.jack.opcodes.return_object.Test_return_object"); + + @Nonnull + private RuntimeTestInfo OPC_CONST = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_const"), + "com.android.jack.opcodes.opc_const.Test_opc_const"); + + @Nonnull + private RuntimeTestInfo SUB_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sub_int"), + "com.android.jack.opcodes.sub_int.Test_sub_int"); + + @Nonnull + private RuntimeTestInfo APUT_CHAR = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput_char"), + "com.android.jack.opcodes.aput_char.Test_aput_char"); + + @Nonnull + private RuntimeTestInfo NEG_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.neg_int"), + "com.android.jack.opcodes.neg_int.Test_neg_int"); + + @Nonnull + private RuntimeTestInfo MUL_DOUBLE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.mul_double"), + "com.android.jack.opcodes.mul_double.Test_mul_double"); + + @Nonnull + private RuntimeTestInfo DOUBLE_TO_FLOAT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.double_to_float"), + "com.android.jack.opcodes.double_to_float.Test_double_to_float"); + + @Nonnull + private RuntimeTestInfo INT_TO_BYTE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_byte"), + "com.android.jack.opcodes.int_to_byte.Test_int_to_byte"); + + @Nonnull + private RuntimeTestInfo IF_LE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_le"), + "com.android.jack.opcodes.if_le.Test_if_le"); + + @Nonnull + private RuntimeTestInfo INVOKE_VIRTUAL = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.invoke_virtual"), + "com.android.jack.opcodes.invoke_virtual.Test_invoke_virtual"); + + @Nonnull + private RuntimeTestInfo DIV_DOUBLE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.div_double"), + "com.android.jack.opcodes.div_double.Test_div_double"); + + @Nonnull + private RuntimeTestInfo IF_GT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_gt"), + "com.android.jack.opcodes.if_gt.Test_if_gt"); + + @Nonnull + private RuntimeTestInfo AGET_SHORT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget_short"), + "com.android.jack.opcodes.aget_short.Test_aget_short"); + + @Nonnull + private RuntimeTestInfo CONST_STRING = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.const_string"), + "com.android.jack.opcodes.const_string.Test_const_string"); + + @Nonnull + private RuntimeTestInfo OR_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.or_int"), + "com.android.jack.opcodes.or_int.Test_or_int"); + + @Nonnull + private RuntimeTestInfo REM_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.rem_int"), + "com.android.jack.opcodes.rem_int.Test_rem_int"); + + @Nonnull + private RuntimeTestInfo REM_DOUBLE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.rem_double"), + "com.android.jack.opcodes.rem_double.Test_rem_double"); + + @Nonnull + private RuntimeTestInfo LONG_TO_DOUBLE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.long_to_double"), + "com.android.jack.opcodes.long_to_double.Test_long_to_double"); + + @Nonnull + private RuntimeTestInfo IF_NE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_ne"), + "com.android.jack.opcodes.if_ne.Test_if_ne"); + + @Nonnull + private RuntimeTestInfo CMP_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.cmp_long"), + "com.android.jack.opcodes.cmp_long.Test_cmp_long"); + + @Nonnull + private RuntimeTestInfo SGET = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sget"), + "com.android.jack.opcodes.sget.Test_sget"); + + @Nonnull + private RuntimeTestInfo AGET_WIDE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget_wide"), + "com.android.jack.opcodes.aget_wide.Test_aget_wide"); + + @Nonnull + private RuntimeTestInfo IF_LTZ = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_ltz"), + "com.android.jack.opcodes.if_ltz.Test_if_ltz"); + + @Nonnull + private RuntimeTestInfo OPC_INSTANCEOF = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_instanceof"), + "com.android.jack.opcodes.opc_instanceof.Test_opc_instanceof"); + + @Nonnull + private RuntimeTestInfo NEG_DOUBLE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.neg_double"), + "com.android.jack.opcodes.neg_double.Test_neg_double"); + + @Nonnull + private RuntimeTestInfo RETURN_WIDE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.return_wide"), + "com.android.jack.opcodes.return_wide.Test_return_wide"); + + @Nonnull + private RuntimeTestInfo FLOAT_TO_DOUBLE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.float_to_double"), + "com.android.jack.opcodes.float_to_double.Test_float_to_double"); + + @Nonnull + private RuntimeTestInfo APUT_SHORT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput_short"), + "com.android.jack.opcodes.aput_short.Test_aput_short"); + + @Nonnull + private RuntimeTestInfo CMPG_DOUBLE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.cmpg_double"), + "com.android.jack.opcodes.cmpg_double.Test_cmpg_double"); + + @Nonnull + private RuntimeTestInfo IF_LEZ = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_lez"), + "com.android.jack.opcodes.if_lez.Test_if_lez"); + + @Nonnull + private RuntimeTestInfo IF_EQ = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_eq"), + "com.android.jack.opcodes.if_eq.Test_if_eq"); + + @Nonnull + private RuntimeTestInfo NEW_ARRAY = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.new_array"), + "com.android.jack.opcodes.new_array.Test_new_array"); + + @Nonnull + private RuntimeTestInfo SHR_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.shr_long"), + "com.android.jack.opcodes.shr_long.Test_shr_long"); + + @Nonnull + private RuntimeTestInfo ADD_DOUBLE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.add_double"), + "com.android.jack.opcodes.add_double.Test_add_double"); + + @Nonnull + private RuntimeTestInfo DIV_LONG = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.div_long"), + "com.android.jack.opcodes.div_long.Test_div_long"); + + @Nonnull + private RuntimeTestInfo SPARSE_SWITCH = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sparse_switch"), + "com.android.jack.opcodes.sparse_switch.Test_sparse_switch"); + + @Nonnull + private RuntimeTestInfo INVOKE_INTERFACE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.invoke_interface"), + "com.android.jack.opcodes.invoke_interface.Test_invoke_interface"); + + @Nonnull + private RuntimeTestInfo APUT_WIDE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput_wide"), + "com.android.jack.opcodes.aput_wide.Test_aput_wide"); + + @Nonnull + private RuntimeTestInfo AGET_BYTE = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget_byte"), + "com.android.jack.opcodes.aget_byte.Test_aget_byte"); + + @Nonnull + private RuntimeTestInfo APUT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput"), + "com.android.jack.opcodes.aput.Test_aput"); + + @Nonnull + private RuntimeTestInfo SHR_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.shr_int"), + "com.android.jack.opcodes.shr_int.Test_shr_int"); + + @Nonnull + private RuntimeTestInfo OPC_RETURN = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_return"), + "com.android.jack.opcodes.opc_return.Test_opc_return"); + + @Nonnull + private RuntimeTestInfo INVOKE_SUPER = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.invoke_super"), + "com.android.jack.opcodes.invoke_super.Test_invoke_super"); + + @Nonnull + private RuntimeTestInfo MUL_FLOAT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.mul_float"), + "com.android.jack.opcodes.mul_float.Test_mul_float"); + + @Nonnull + private RuntimeTestInfo SUB_FLOAT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sub_float"), + "com.android.jack.opcodes.sub_float.Test_sub_float"); + + @Nonnull + private RuntimeTestInfo ADD_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.add_int"), + "com.android.jack.opcodes.add_int.Test_add_int"); + + @Nonnull + private RuntimeTestInfo INT_TO_CHAR = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_char"), + "com.android.jack.opcodes.int_to_char.Test_int_to_char"); + + @Nonnull + private RuntimeTestInfo AND_INT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.and_int"), + "com.android.jack.opcodes.and_int.Test_and_int"); + + @Nonnull + private RuntimeTestInfo CMPG_FLOAT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.cmpg_float"), + "com.android.jack.opcodes.cmpg_float.Test_cmpg_float"); + + @Nonnull + private RuntimeTestInfo IGET = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.iget"), + "com.android.jack.opcodes.iget.Test_iget"); + + @Nonnull + private RuntimeTestInfo REM_FLOAT = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.opcodes.rem_float"), + "com.android.jack.opcodes.rem_float.Test_rem_float"); + + + @BeforeClass + public static void setUpClass() { + OpcodesTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + //@Category(RuntimeRegressionTest.class) + public void invoke_static() throws Exception { + new RuntimeTestHelper(INVOKE_STATIC) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void array_length() throws Exception { + new RuntimeTestHelper(ARRAY_LENGTH) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void neg_float() throws Exception { + new RuntimeTestHelper(NEG_FLOAT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void sub_double() throws Exception { + new RuntimeTestHelper(SUB_DOUBLE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aget() throws Exception { + new RuntimeTestHelper(AGET) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aput_byte() throws Exception { + new RuntimeTestHelper(APUT_BYTE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void opc_new() throws Exception { + new RuntimeTestHelper(OPC_NEW) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void cmpl_double() throws Exception { + new RuntimeTestHelper(CMPL_DOUBLE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_gtz() throws Exception { + new RuntimeTestHelper(IF_GTZ) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void float_to_long() throws Exception { + new RuntimeTestHelper(FLOAT_TO_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void add_long() throws Exception { + new RuntimeTestHelper(ADD_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void add_float() throws Exception { + new RuntimeTestHelper(ADD_FLOAT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void iput() throws Exception { + new RuntimeTestHelper(IPUT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void div_float() throws Exception { + new RuntimeTestHelper(DIV_FLOAT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void ushr_long() throws Exception { + new RuntimeTestHelper(USHR_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void const_wide() throws Exception { + new RuntimeTestHelper(CONST_WIDE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void xor_int() throws Exception { + new RuntimeTestHelper(XOR_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aget_object() throws Exception { + new RuntimeTestHelper(AGET_OBJECT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void const4_16() throws Exception { + new RuntimeTestHelper(CONST4_16) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void rem_long() throws Exception { + new RuntimeTestHelper(REM_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void ushr_int() throws Exception { + new RuntimeTestHelper(USHR_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_ge() throws Exception { + new RuntimeTestHelper(IF_GE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void sub_long() throws Exception { + new RuntimeTestHelper(SUB_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void float_to_int() throws Exception { + new RuntimeTestHelper(FLOAT_TO_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void int_to_long() throws Exception { + new RuntimeTestHelper(INT_TO_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void or_long() throws Exception { + new RuntimeTestHelper(OR_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_gez() throws Exception { + new RuntimeTestHelper(IF_GEZ) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void shl_int() throws Exception { + new RuntimeTestHelper(SHL_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void long_to_float() throws Exception { + new RuntimeTestHelper(LONG_TO_FLOAT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void div_int() throws Exception { + new RuntimeTestHelper(DIV_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void and_long() throws Exception { + new RuntimeTestHelper(AND_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void double_to_long() throws Exception { + new RuntimeTestHelper(DOUBLE_TO_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void mul_long() throws Exception { + new RuntimeTestHelper(MUL_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void double_to_int() throws Exception { + new RuntimeTestHelper(DOUBLE_TO_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_nez() throws Exception { + new RuntimeTestHelper(IF_NEZ) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aput_object() throws Exception { + new RuntimeTestHelper(APUT_OBJECT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_lt() throws Exception { + new RuntimeTestHelper(IF_LT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void int_to_double() throws Exception { + new RuntimeTestHelper(INT_TO_DOUBLE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void mul_int() throws Exception { + new RuntimeTestHelper(MUL_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void sput() throws Exception { + new RuntimeTestHelper(SPUT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void shl_long() throws Exception { + new RuntimeTestHelper(SHL_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void neg_long() throws Exception { + new RuntimeTestHelper(NEG_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void long_to_int() throws Exception { + new RuntimeTestHelper(LONG_TO_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void opc_goto() throws Exception { + new RuntimeTestHelper(OPC_GOTO) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void int_to_float() throws Exception { + new RuntimeTestHelper(INT_TO_FLOAT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void xor_long() throws Exception { + new RuntimeTestHelper(XOR_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void monitor_enter() throws Exception { + new RuntimeTestHelper(MONITOR_ENTER) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_eqz() throws Exception { + new RuntimeTestHelper(IF_EQZ) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void invoke_direct() throws Exception { + new RuntimeTestHelper(INVOKE_DIRECT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void cmpl_float() throws Exception { + new RuntimeTestHelper(CMPL_FLOAT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void check_cast() throws Exception { + new RuntimeTestHelper(CHECK_CAST) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void opc_throw() throws Exception { + new RuntimeTestHelper(OPC_THROW) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void int_to_short() throws Exception { + new RuntimeTestHelper(INT_TO_SHORT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void packed_switch() throws Exception { + new RuntimeTestHelper(PACKED_SWITCH) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aget_char() throws Exception { + new RuntimeTestHelper(AGET_CHAR) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void return_object() throws Exception { + new RuntimeTestHelper(RETURN_OBJECT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void opc_const() throws Exception { + new RuntimeTestHelper(OPC_CONST) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void sub_int() throws Exception { + new RuntimeTestHelper(SUB_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aput_char() throws Exception { + new RuntimeTestHelper(APUT_CHAR) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void neg_int() throws Exception { + new RuntimeTestHelper(NEG_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void mul_double() throws Exception { + new RuntimeTestHelper(MUL_DOUBLE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void double_to_float() throws Exception { + new RuntimeTestHelper(DOUBLE_TO_FLOAT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void int_to_byte() throws Exception { + new RuntimeTestHelper(INT_TO_BYTE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_le() throws Exception { + new RuntimeTestHelper(IF_LE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void invoke_virtual() throws Exception { + new RuntimeTestHelper(INVOKE_VIRTUAL) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void div_double() throws Exception { + new RuntimeTestHelper(DIV_DOUBLE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_gt() throws Exception { + new RuntimeTestHelper(IF_GT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aget_short() throws Exception { + new RuntimeTestHelper(AGET_SHORT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void const_string() throws Exception { + new RuntimeTestHelper(CONST_STRING) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void or_int() throws Exception { + new RuntimeTestHelper(OR_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void rem_int() throws Exception { + new RuntimeTestHelper(REM_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void rem_double() throws Exception { + new RuntimeTestHelper(REM_DOUBLE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void long_to_double() throws Exception { + new RuntimeTestHelper(LONG_TO_DOUBLE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_ne() throws Exception { + new RuntimeTestHelper(IF_NE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void cmp_long() throws Exception { + new RuntimeTestHelper(CMP_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void sget() throws Exception { + new RuntimeTestHelper(SGET) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aget_wide() throws Exception { + new RuntimeTestHelper(AGET_WIDE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_ltz() throws Exception { + new RuntimeTestHelper(IF_LTZ) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void opc_instanceof() throws Exception { + new RuntimeTestHelper(OPC_INSTANCEOF) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void neg_double() throws Exception { + new RuntimeTestHelper(NEG_DOUBLE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void return_wide() throws Exception { + new RuntimeTestHelper(RETURN_WIDE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void float_to_double() throws Exception { + new RuntimeTestHelper(FLOAT_TO_DOUBLE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aput_short() throws Exception { + new RuntimeTestHelper(APUT_SHORT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void cmpg_double() throws Exception { + new RuntimeTestHelper(CMPG_DOUBLE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_lez() throws Exception { + new RuntimeTestHelper(IF_LEZ) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void if_eq() throws Exception { + new RuntimeTestHelper(IF_EQ) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void new_array() throws Exception { + new RuntimeTestHelper(NEW_ARRAY) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void shr_long() throws Exception { + new RuntimeTestHelper(SHR_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void add_double() throws Exception { + new RuntimeTestHelper(ADD_DOUBLE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void div_long() throws Exception { + new RuntimeTestHelper(DIV_LONG) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void sparse_switch() throws Exception { + new RuntimeTestHelper(SPARSE_SWITCH) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void invoke_interface() throws Exception { + new RuntimeTestHelper(INVOKE_INTERFACE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aput_wide() throws Exception { + new RuntimeTestHelper(APUT_WIDE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aget_byte() throws Exception { + new RuntimeTestHelper(AGET_BYTE) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void aput() throws Exception { + new RuntimeTestHelper(APUT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void shr_int() throws Exception { + new RuntimeTestHelper(SHR_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void opc_return() throws Exception { + new RuntimeTestHelper(OPC_RETURN) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void invoke_super() throws Exception { + new RuntimeTestHelper(INVOKE_SUPER) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void mul_float() throws Exception { + new RuntimeTestHelper(MUL_FLOAT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void sub_float() throws Exception { + new RuntimeTestHelper(SUB_FLOAT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void add_int() throws Exception { + new RuntimeTestHelper(ADD_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void int_to_char() throws Exception { + new RuntimeTestHelper(INT_TO_CHAR) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void and_int() throws Exception { + new RuntimeTestHelper(AND_INT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void cmpg_float() throws Exception { + new RuntimeTestHelper(CMPG_FLOAT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void iget() throws Exception { + new RuntimeTestHelper(IGET) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + @Test + //@Category(RuntimeRegressionTest.class) + public void rem_float() throws Exception { + new RuntimeTestHelper(REM_FLOAT) + .setSrcDirName("jm") + .setRefDirName( ".") + .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java")) + .compileAndRunTest(); + } + + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(INVOKE_STATIC); + rtTestInfos.add(ARRAY_LENGTH); + rtTestInfos.add(NEG_FLOAT); + rtTestInfos.add(SUB_DOUBLE); + rtTestInfos.add(AGET); + rtTestInfos.add(APUT_BYTE); + rtTestInfos.add(OPC_NEW); + rtTestInfos.add(CMPL_DOUBLE); + rtTestInfos.add(IF_GTZ); + rtTestInfos.add(FLOAT_TO_LONG); + rtTestInfos.add(ADD_LONG); + rtTestInfos.add(ADD_FLOAT); + rtTestInfos.add(IPUT); + rtTestInfos.add(DIV_FLOAT); + rtTestInfos.add(USHR_LONG); + rtTestInfos.add(CONST_WIDE); + rtTestInfos.add(XOR_INT); + rtTestInfos.add(AGET_OBJECT); + rtTestInfos.add(CONST4_16); + rtTestInfos.add(REM_LONG); + rtTestInfos.add(USHR_INT); + rtTestInfos.add(IF_GE); + rtTestInfos.add(SUB_LONG); + rtTestInfos.add(FLOAT_TO_INT); + rtTestInfos.add(INT_TO_LONG); + rtTestInfos.add(OR_LONG); + rtTestInfos.add(IF_GEZ); + rtTestInfos.add(SHL_INT); + rtTestInfos.add(LONG_TO_FLOAT); + rtTestInfos.add(DIV_INT); + rtTestInfos.add(AND_LONG); + rtTestInfos.add(DOUBLE_TO_LONG); + rtTestInfos.add(MUL_LONG); + rtTestInfos.add(DOUBLE_TO_INT); + rtTestInfos.add(IF_NEZ); + rtTestInfos.add(APUT_OBJECT); + rtTestInfos.add(IF_LT); + rtTestInfos.add(INT_TO_DOUBLE); + rtTestInfos.add(MUL_INT); + rtTestInfos.add(SPUT); + rtTestInfos.add(SHL_LONG); + rtTestInfos.add(NEG_LONG); + rtTestInfos.add(LONG_TO_INT); + rtTestInfos.add(OPC_GOTO); + rtTestInfos.add(INT_TO_FLOAT); + rtTestInfos.add(XOR_LONG); + rtTestInfos.add(MONITOR_ENTER); + rtTestInfos.add(IF_EQZ); + rtTestInfos.add(INVOKE_DIRECT); + rtTestInfos.add(CMPL_FLOAT); + rtTestInfos.add(CHECK_CAST); + rtTestInfos.add(OPC_THROW); + rtTestInfos.add(INT_TO_SHORT); + rtTestInfos.add(PACKED_SWITCH); + rtTestInfos.add(AGET_CHAR); + rtTestInfos.add(RETURN_OBJECT); + rtTestInfos.add(OPC_CONST); + rtTestInfos.add(SUB_INT); + rtTestInfos.add(APUT_CHAR); + rtTestInfos.add(NEG_INT); + rtTestInfos.add(MUL_DOUBLE); + rtTestInfos.add(DOUBLE_TO_FLOAT); + rtTestInfos.add(INT_TO_BYTE); + rtTestInfos.add(IF_LE); + rtTestInfos.add(INVOKE_VIRTUAL); + rtTestInfos.add(DIV_DOUBLE); + rtTestInfos.add(IF_GT); + rtTestInfos.add(AGET_SHORT); + rtTestInfos.add(CONST_STRING); + rtTestInfos.add(OR_INT); + rtTestInfos.add(REM_INT); + rtTestInfos.add(REM_DOUBLE); + rtTestInfos.add(LONG_TO_DOUBLE); + rtTestInfos.add(IF_NE); + rtTestInfos.add(CMP_LONG); + rtTestInfos.add(SGET); + rtTestInfos.add(AGET_WIDE); + rtTestInfos.add(IF_LTZ); + rtTestInfos.add(OPC_INSTANCEOF); + rtTestInfos.add(NEG_DOUBLE); + rtTestInfos.add(RETURN_WIDE); + rtTestInfos.add(FLOAT_TO_DOUBLE); + rtTestInfos.add(APUT_SHORT); + rtTestInfos.add(CMPG_DOUBLE); + rtTestInfos.add(IF_LEZ); + rtTestInfos.add(IF_EQ); + rtTestInfos.add(NEW_ARRAY); + rtTestInfos.add(SHR_LONG); + rtTestInfos.add(ADD_DOUBLE); + rtTestInfos.add(DIV_LONG); + rtTestInfos.add(SPARSE_SWITCH); + rtTestInfos.add(INVOKE_INTERFACE); + rtTestInfos.add(APUT_WIDE); + rtTestInfos.add(AGET_BYTE); + rtTestInfos.add(APUT); + rtTestInfos.add(SHR_INT); + rtTestInfos.add(OPC_RETURN); + rtTestInfos.add(INVOKE_SUPER); + rtTestInfos.add(MUL_FLOAT); + rtTestInfos.add(SUB_FLOAT); + rtTestInfos.add(ADD_INT); + rtTestInfos.add(INT_TO_CHAR); + rtTestInfos.add(AND_INT); + rtTestInfos.add(CMPG_FLOAT); + rtTestInfos.add(IGET); + rtTestInfos.add(REM_FLOAT); + } +} diff --git a/jack-tests/tests/com/android/jack/optimizations/exprsimplifier/ExprsimplifierTests.java b/jack-tests/tests/com/android/jack/optimizations/exprsimplifier/ExprsimplifierTests.java new file mode 100644 index 00000000..2534c3ca --- /dev/null +++ b/jack-tests/tests/com/android/jack/optimizations/exprsimplifier/ExprsimplifierTests.java @@ -0,0 +1,49 @@ +/* +* 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.optimizations.exprsimplifier; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class ExprsimplifierTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.optimizations.exprsimplifier.test001"), + "com.android.jack.optimizations.exprsimplifier.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + ExprsimplifierTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/NotsimplifierTests.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/NotsimplifierTests.java new file mode 100644 index 00000000..0962ae2f --- /dev/null +++ b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/NotsimplifierTests.java @@ -0,0 +1,49 @@ +/* +* 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.optimizations.notsimplifier; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class NotsimplifierTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.optimizations.notsimplifier.test001"), + "com.android.jack.optimizations.notsimplifier.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + NotsimplifierTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/optimizations/uselesscopy/UselessVariableCopyTest.java b/jack-tests/tests/com/android/jack/optimizations/uselesscopy/UselessVariableCopyTest.java new file mode 100644 index 00000000..eaae6aee --- /dev/null +++ b/jack-tests/tests/com/android/jack/optimizations/uselesscopy/UselessVariableCopyTest.java @@ -0,0 +1,73 @@ +/* + * 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.optimizations.uselesscopy; + +import com.android.jack.TestTools; +import com.android.jack.test.category.KnownBugs; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackBasedToolchain; + +import junit.framework.Assert; + +import org.jf.dexlib.CodeItem; +import org.jf.dexlib.DexFile; +import org.jf.dexlib.Code.Instruction; +import org.jf.dexlib.Code.Opcode; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +import javax.annotation.Nonnull; + +public class UselessVariableCopyTest { + + /** + * Verify that generated dex does not contains useless 'mov' instructions. + */ + @Test + @Category(KnownBugs.class) + public void test001() throws Exception { + File out = AbstractTestTools.createTempDir(); + File outDex = new File(out, "classes.dex"); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.disableDxOptimizations(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + out, + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.optimizations.uselesscopy.test001.jack")); + + DexFile dexFile = new DexFile(outDex); + CodeItem ci = + TestTools.getEncodedMethod(dexFile, + "Lcom/android/jack/optimizations/uselesscopy/test001/jack/Test001;", "test", + "(Ljava/lang/Object;)Z").codeItem; + + Assert.assertFalse(hasOpcode(ci, Opcode.MOVE_OBJECT)); + } + + private boolean hasOpcode(@Nonnull CodeItem codeItem, @Nonnull Opcode opcode) { + for (Instruction inst : codeItem.getInstructions()) { + if (inst.opcode == opcode) { + return true; + } + } + return false; + } + +} diff --git a/jack-tests/tests/com/android/jack/order/OrderTests.java b/jack-tests/tests/com/android/jack/order/OrderTests.java new file mode 100644 index 00000000..c62c8003 --- /dev/null +++ b/jack-tests/tests/com/android/jack/order/OrderTests.java @@ -0,0 +1,49 @@ +/* +* 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.order; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class OrderTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.order.test001"), + "com.android.jack.order.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + OrderTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/order/dx/Tests.java b/jack-tests/tests/com/android/jack/order/test001/dx/Tests.java index 4c2243bf..9d272672 100644 --- a/jack-tests/tests/com/android/jack/order/dx/Tests.java +++ b/jack-tests/tests/com/android/jack/order/test001/dx/Tests.java @@ -14,9 +14,9 @@ * limitations under the License. */ -package com.android.jack.order.dx; +package com.android.jack.order.test001.dx; -import com.android.jack.order.jack.Order; +import com.android.jack.order.test001.jack.Order; import org.junit.Assert; import org.junit.Test; diff --git a/jack-tests/tests/com/android/jack/order/jack/Order.java b/jack-tests/tests/com/android/jack/order/test001/jack/Order.java index 47ee620f..770f9f9b 100644 --- a/jack-tests/tests/com/android/jack/order/jack/Order.java +++ b/jack-tests/tests/com/android/jack/order/test001/jack/Order.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.jack.order.jack; +package com.android.jack.order.test001.jack; /** * Evaluation order test. diff --git a/jack-tests/tests/com/android/jack/preprocessor/PreProcessorTests.java b/jack-tests/tests/com/android/jack/preprocessor/PreProcessorTests.java new file mode 100644 index 00000000..e5627bb7 --- /dev/null +++ b/jack-tests/tests/com/android/jack/preprocessor/PreProcessorTests.java @@ -0,0 +1,109 @@ +/* + * 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.preprocessor; + +import com.android.jack.Main; +import com.android.jack.Options; +import com.android.jack.TestTools; +import com.android.jack.ir.ast.JAnnotation; +import com.android.jack.ir.ast.JDefinedClassOrInterface; +import com.android.jack.ir.ast.JMethod; +import com.android.jack.ir.ast.JSession; +import com.android.jack.lookup.JNodeLookup; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackBasedToolchain; +import com.android.sched.util.RunnableHooks; + +import junit.framework.Assert; + +import org.antlr.runtime.ANTLRFileStream; +import org.antlr.runtime.CommonTokenStream; +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; +import java.util.Collection; + +public class PreProcessorTests { + + @BeforeClass + public static void setUpClass() throws Exception { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void test001_002() throws Exception { + File testDir = AbstractTestTools.getTestRootDir("com.android.jack.preprocessor.test001.jack"); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProperty(PreProcessor.ENABLE.getName(), "true"); + toolchain.addProperty(PreProcessor.FILE.getName(), + new File(testDir, "config.jpp").getAbsolutePath()); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempFile("annotationAdderTest", ".out.zip"), + /* zipFile = */ true, + testDir); + } + + @Test + public void test001_001() throws Exception { + File testDir = AbstractTestTools.getTestRootDir("com.android.jack.preprocessor.test001.jack"); + File tempDir = AbstractTestTools.createTempDir(); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + tempDir, + /* zipFiles = */ false, + testDir); + + Options args = TestTools.buildCommandLineArgs( + new File(testDir, "app1/ApplicationActivity1.java")); + args.setClasspath(tempDir.getPath()); + RunnableHooks hooks = new RunnableHooks(); + JSession session = TestTools.buildSession(args, hooks); + ANTLRFileStream in = new ANTLRFileStream(new File(testDir, "config.jpp").getAbsolutePath()); + PreProcessorLexer lexer = new PreProcessorLexer(in); + CommonTokenStream tokens = new CommonTokenStream(lexer); + PreProcessorParser parser = new PreProcessorParser(tokens); + Collection<Rule> rules = parser.rules(session); + Scope scope = new TypeToEmitScope(session); + for (Rule rule : rules) { + Context context = new Context(); + if (!rule.getSet().eval(scope, context).isEmpty()) { + context.getRequest(session).commit(); + } + } + + JAnnotation installerAnnotation = session.getPhantomLookup().getAnnotation( + "Lcom/android/jack/preprocessor/test001/jack/MultiDexInstaller;"); + JNodeLookup lookup = session.getLookup(); + { + JDefinedClassOrInterface coi = lookup.getClass( + "Lcom/android/jack/preprocessor/test001/jack/app1/ApplicationActivity1;"); + Assert.assertFalse(coi.getAnnotations(installerAnnotation).isEmpty()); + for (JMethod method : coi.getMethods()) { + if (method.getName().equals("noAnnotation")) { + Assert.assertTrue(method.getAnnotations(installerAnnotation).isEmpty()); + } else { + Assert.assertFalse(method.getAnnotations(installerAnnotation).isEmpty()); + } + } + } + + hooks.runHooks(); + } +} diff --git a/jack-tests/tests/com/android/jack/resource/ResourceTests.java b/jack-tests/tests/com/android/jack/resource/ResourceTests.java new file mode 100644 index 00000000..4a364b05 --- /dev/null +++ b/jack-tests/tests/com/android/jack/resource/ResourceTests.java @@ -0,0 +1,589 @@ +/* + * 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.resource; + +import com.android.jack.Options; +import com.android.jack.ProguardFlags; +import com.android.jack.TestTools; +import com.android.jack.test.category.KnownBugs; +import com.android.jack.library.FileType; +import com.android.jack.shrob.obfuscation.NameProviderFactory; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackBasedToolchain; +import com.android.sched.util.stream.ByteStreamSucker; + +import junit.framework.Assert; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.StringReader; +import java.util.Collections; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; + +import javax.annotation.Nonnull; + +/** + * JUnit tests for resource support. + */ +public class ResourceTests { + + @Nonnull + private static final String COMMON_PATH = "com/android/jack/resource/test001/jack/"; + @Nonnull + private static final String JACK_FILE_PATH = FileType.JAYCE.getPrefix() + "/" + COMMON_PATH + + "IrrelevantForTest.jayce"; + @Nonnull + private static final String DEX_FILE_PATH = FileType.DEX.getPrefix() + "/" + COMMON_PATH + + "IrrelevantForTest.dex"; + @Nonnull + private static final String RESOURCE1_SHORTPATH = "Resource1"; + @Nonnull + private static final String RESOURCE2_SHORTPATH = "Resource2"; + @Nonnull + private static final String RESOURCE3_SHORTPATH = "pack/Resource3"; + @Nonnull + private static final String RESOURCE4_SHORTPATH = "pack/Resource4"; + + @Nonnull + private static final File FILE = + AbstractTestTools.getTestRootDir("com.android.jack.resource.test001.jack"); + + @BeforeClass + public static void setUpClass() { + ResourceTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void testJackArchiveToDexDir() throws Exception { + // compile source file to a Jack archive and add resources + File jackAr = createJackArchiveWithResources(); + + // compile Jack archive to a dex dir + File dexDir = TestTools.createTempDir("resourcetestdex", "dir"); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.libToExe(jackAr, dexDir, /* zipFile = */ false); + + // check that resources are contained in dex dir + checkResourceContentFromDir(dexDir, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ false); + checkResourceContentFromDir(dexDir, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ false); + checkResourceContentFromDir(dexDir, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ false); + checkResourceContentFromDir(dexDir, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ false); + } + + @Test + public void testJackArchiveToDexArchive() throws Exception { + // compile source file to a Jack archive and add resources + File jackAr = createJackArchiveWithResources(); + + // compile Jack archive to dex archive + File dexAr = AbstractTestTools.createTempFile("resourcetestdex", ".zip"); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.libToExe(jackAr, dexAr, /* zipFile = */ true); + + // check that resources are contained in dex archive + ZipFile zipFile = new ZipFile(dexAr); + checkResourceContentFromZip(zipFile, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ false); + checkResourceContentFromZip(zipFile, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ false); + checkResourceContentFromZip(zipFile, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ false); + checkResourceContentFromZip(zipFile, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ false); + } + + @Test + public void testJackDirToDexArchive() throws Exception { + + // TODO(jmhenaff) adapt this after rebase. Add API for resources + + // compile source file to a Jack dir + File jackFolder = TestTools.createTempDir("tempjack", "dir"); + Options options = new Options(); + options.addResource(new File(FILE, "rsc")); + TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(), + jackFolder, false /* non-zipped */); + + // compile Jack dir to dex archive + File dexAr = TestTools.createTempFile("resourcetestdex", ".zip"); + TestTools.compileJackToDex(new Options(), jackFolder, dexAr, true /* zipped */); + + // check that resources are contained in dex archive + ZipFile zipFile = new ZipFile(dexAr); + checkResourceContentFromZip(zipFile, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ false); + checkResourceContentFromZip(zipFile, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ false); + checkResourceContentFromZip(zipFile, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ false); + checkResourceContentFromZip(zipFile, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ false); + +// // compile source file to a Jack dir +// File jackFolder = AbstractTestTools.createTempDir(); +// JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); +// toolchain.srcToLib( +// AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), +// jackFolder, +// /* zipFiles = */ false, +// FILE); +// +// // add resources to Jack dir +// copyFileToDir(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, jackFolder); +// +// // compile Jack dir to dex archive +// File dexAr = TestTools.createTempFile("resourcetestdex", ".zip"); +// toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); +// toolchain.libToDex(jackFolder, dexAr, /* zipFile = */ true); +// +// // check that resources are contained in dex archive +// ZipFile zipFile = new ZipFile(dexAr); +// checkResourceContent(zipFile, RESOURCE1_LONGPATH, "Res1"); +// checkResourceContent(zipFile, RESOURCE2_LONGPATH, "Res2"); +// checkResourceContent(zipFile, RESOURCE3_LONGPATH, "Res3"); +// checkResourceContent(zipFile, RESOURCE4_LONGPATH, "Res4"); + } + + @Test + public void testJackArchiveToJackArchive() throws Exception { + // compile source file to a Jack archive and add resources + File jackAr = createJackArchiveWithResources(); + + // run shrobbing from Jack archive to Jack archive + File shrobbedJackAr = AbstractTestTools.createTempFile("shrobbedJackAr", ".zip"); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProguardFlags(new File(FILE, "proguard.flags")); + toolchain.libToLib(jackAr, shrobbedJackAr, /* zipFiles = */ true); + + // check that resources are contained in dex archive + ZipFile zipFile = new ZipFile(shrobbedJackAr); + checkResourceContentFromZip(zipFile, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ true); + checkResourceContentFromZip(zipFile, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ true); + checkResourceContentFromZip(zipFile, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ true); + checkResourceContentFromZip(zipFile, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ true); + } + + @Test + public void testJackDirToJackArchive() throws Exception { + // compile source file to a Jack dir + File jackFolder = TestTools.createTempDir("tempjack", "dir"); + Options options = new Options(); + options.addResource(new File(FILE, "rsc")); + TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(), + jackFolder, false /* non-zipped */); + + // run shrobbing from Jack dir to Jack archive + File shrobbedJackAr = TestTools.createTempFile("shrobbedJackAr", ".zip"); + ProguardFlags flags = new ProguardFlags(new File(FILE, "proguard.flags")); + TestTools.shrobJackToJack(new Options(), + jackFolder, + null /* classpath */, + shrobbedJackAr, + Collections.singletonList(flags), + true /* zipped */); + + // check that resources are contained in Jack archive + ZipFile zipFile = new ZipFile(shrobbedJackAr); + checkResourceContentFromZip(zipFile, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ true); + checkResourceContentFromZip(zipFile, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ true); + checkResourceContentFromZip(zipFile, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ true); + checkResourceContentFromZip(zipFile, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ true); + +// // compile source file to a Jack dir +// File jackFolder = TestTools.createTempDir("tempjack", "dir"); +// JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); +// toolchain.srcToLib( +// AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), +// jackFolder, +// /* zipFiles = */ false, +// FILE); +// +// +// // add resources to Jack dir +// copyFileToDir(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, jackFolder); +// +// // run shrobbing from Jack dir to Jack archive +// File shrobbedJackAr = AbstractTestTools.createTempFile("shrobbedJackAr", ".zip"); +// toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); +// toolchain.addProguardFlags(new File(FILE, "proguard.flags")); +// toolchain.libToLib(jackFolder, shrobbedJackAr, /* zipFiles = */ true); +// +// // check that resources are contained in Jack archive +// ZipFile zipFile = new ZipFile(shrobbedJackAr); +// checkResourceContent(zipFile, RESOURCE1_LONGPATH, "Res1"); +// checkResourceContent(zipFile, RESOURCE2_LONGPATH, "Res2"); +// checkResourceContent(zipFile, RESOURCE3_LONGPATH, "Res3"); +// checkResourceContent(zipFile, RESOURCE4_LONGPATH, "Res4"); + } + + @Test + public void testJackArchiveToJackDir() throws Exception { + // compile source file to a Jack archive and add resources + File jackAr = createJackArchiveWithResources(); + + // run shrobbing from Jack archive to Jack dir + File shrobbedJackDir = AbstractTestTools.createTempDir(); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProguardFlags(new File(FILE, "proguard.flags")); + toolchain.libToLib(jackAr, shrobbedJackDir, /* zipFiles = */ false); + + // check that resources are contained in Jack dir + checkResourceContentFromDir(shrobbedJackDir, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ true); + checkResourceContentFromDir(shrobbedJackDir, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ true); + checkResourceContentFromDir(shrobbedJackDir, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ true); + checkResourceContentFromDir(shrobbedJackDir, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ true); + + } + + @Test + public void testJackDirToJackDir() throws Exception { + /// compile source file to a Jack dir + File jackFolder = TestTools.createTempDir("tempjack", "dir"); + Options options = new Options(); + options.addResource(new File(FILE, "rsc")); + TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(), + jackFolder, false /* non-zipped */); + + // run shrobbing from Jack dir to Jack dir + File shrobbedJackDir = TestTools.createTempDir("shrobbedJack", "dir"); + ProguardFlags flags = new ProguardFlags(new File(FILE, "proguard.flags")); + TestTools.shrobJackToJack(new Options(), + jackFolder, + null /* classpath */, + shrobbedJackDir, + Collections.singletonList(flags), + false /* non-zipped */); + + // check that resources are contained in Jack dir + checkResourceContentFromDir(shrobbedJackDir, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ true); + checkResourceContentFromDir(shrobbedJackDir, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ true); + checkResourceContentFromDir(shrobbedJackDir, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ true); + checkResourceContentFromDir(shrobbedJackDir, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ true); + + +// // compile source file to a Jack dir +// File jackFolder = AbstractTestTools.createTempDir(); +// JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); +// toolchain.srcToLib( +// AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), +// jackFolder, +// /* zipFiles = */ false, +// FILE); +// +// // add resources to Jack dir +// copyFileToDir(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, jackFolder); +// +// // run shrobbing from Jack dir to Jack dir +// File shrobbedJackDir = AbstractTestTools.createTempDir(); +// toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); +// toolchain.addProguardFlags(new File(FILE, "proguard.flags")); +// toolchain.libToLib(jackFolder, shrobbedJackDir, /* zipFiles = */ false); +// +// +// // check that resources are contained in Jack dir +// checkResourceContent(shrobbedJackDir, RESOURCE1_LONGPATH, "Res1"); +// checkResourceContent(shrobbedJackDir, RESOURCE2_LONGPATH, "Res2"); +// checkResourceContent(shrobbedJackDir, RESOURCE3_LONGPATH, "Res3"); +// checkResourceContent(shrobbedJackDir, RESOURCE4_LONGPATH, "Res4"); + } + + @Test + public void testJackDirToDexDir() throws Exception { + // compile source file to a Jack dir + File jackFolder = TestTools.createTempDir("tempjack", "dir"); + Options options = new Options(); + options.addResource(new File(FILE, "rsc")); + TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(), + jackFolder, false /* non-zipped */); + + // compile Jack dir to a dex dir + File dexDir = TestTools.createTempDir("resourcetestdex", "dir"); + TestTools.compileJackToDex(new Options(), jackFolder, dexDir, false /* zipped */); + + // check that resources are contained in dex dir + checkResourceContentFromDir(dexDir, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ false); + checkResourceContentFromDir(dexDir, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ false); + checkResourceContentFromDir(dexDir, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ false); + checkResourceContentFromDir(dexDir, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ false); + +// // compile source file to a Jack dir +// File jackFolder = AbstractTestTools.createTempDir(); +// JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); +// toolchain.srcToLib( +// AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), +// jackFolder, +// /* zipFiles = */ false, +// FILE); +// +// // add resources to Jack dir +// copyFileToDir(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, jackFolder); +// +// // compile Jack dir to a dex dir +// File dexDir = AbstractTestTools.createTempDir(); +// AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class) +// .libToDex(jackFolder, dexDir, /* zipFile = */ false); +// +// // check that resources are contained in dex dir +// checkResourceContent(dexDir, RESOURCE1_LONGPATH, "Res1"); +// checkResourceContent(dexDir, RESOURCE2_LONGPATH, "Res2"); +// checkResourceContent(dexDir, RESOURCE3_LONGPATH, "Res3"); +// checkResourceContent(dexDir, RESOURCE4_LONGPATH, "Res4"); + } + + @Test + @Category(KnownBugs.class) + public void testJackToDexInSameDir() throws Exception { + // compile source file to a Jack dir + File jackFolder = TestTools.createTempDir("tempjack", "dir"); + Options options = new Options(); + options.addResource(new File(FILE, "rsc")); + TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(), + jackFolder, false /* non-zipped */); + + // compile Jack dir to same dir + File dexDir = jackFolder; + TestTools.compileJackToDex(new Options(), jackFolder, dexDir, false /* zipped */); + + // check that resources are contained in dex dir + checkResourceContentFromDir(dexDir, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ false); + checkResourceContentFromDir(dexDir, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ false); + checkResourceContentFromDir(dexDir, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ false); + checkResourceContentFromDir(dexDir, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ false); + +// // compile source file to a Jack dir +// File jackFolder = AbstractTestTools.createTempDir(); +// JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); +// toolchain.srcToLib( +// AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), +// jackFolder, +// /* zipFiles = */ false, +// FILE); +// +// // add resources to Jack dir +// copyFileToDir(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, jackFolder); +// copyFileToDir(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, jackFolder); +// +// // compile Jack dir to same dir +// File dexDir = jackFolder; +// AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class) +// .libToDex(jackFolder, dexDir, /* zipFile = */ false); +// +// // check that resources are contained in dex dir +// checkResourceContent(dexDir, RESOURCE1_LONGPATH, "Res1"); +// checkResourceContent(dexDir, RESOURCE2_LONGPATH, "Res2"); +// checkResourceContent(dexDir, RESOURCE3_LONGPATH, "Res3"); +// checkResourceContent(dexDir, RESOURCE4_LONGPATH, "Res4"); + } + + @Test + @Category(KnownBugs.class) + public void testResourceContentAdaptation() throws Exception { + // compile source file to a Jack dir + File jackOutputFolder = AbstractTestTools.createTempDir(); + //String testName = "resource/test003"; + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.resource.test003"); + File jackTestFolder = AbstractTestTools.getTestRootDir("com.android.jack.resource.test003.jack"); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + jackOutputFolder, + /* zipFiles = */ false, + testFolder); + + String resource1LongPath = "com/android/jack/resource/test003/jack/A"; + String resource2LongPath = "com/android/jack/resource/test003/jack/A.txt"; + + // add resources to Jack dir + copyFileToDir(new File(jackTestFolder, "A.txt"), resource1LongPath, jackOutputFolder); + copyFileToDir(new File(jackTestFolder, "A.txt"), resource2LongPath, jackOutputFolder); + + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProperty(NameProviderFactory.NAMEPROVIDER.getName(), "rot13"); + File shrobbedJackDir = AbstractTestTools.createTempDir(); + toolchain.addProguardFlags(new File(testFolder, "proguard.flags001")); + toolchain.libToLib(jackOutputFolder, shrobbedJackDir, /* zipFiles = */ false); + + // check that resources are contained in Jack dir and check their contents + File referenceFileContent = new File(testFolder, "refs/A.txt"); + checkResourceContent(new File(shrobbedJackDir, "pcz/nbqfcvq/wnpx/frgcifpr/hrgh003/wnpx/A"), + referenceFileContent); + checkResourceContent(new File(shrobbedJackDir, "pcz/nbqfcvq/wnpx/frgcifpr/hrgh003/wnpx/N.txt"), + referenceFileContent); + } + + @Nonnull + private File createJackArchiveWithResources() throws Exception { + // compile source file to a Jack file + //File tempJackFolder = TestTools.createTempDir("jack", "dir"); + File jackAr = TestTools.createTempFile("resourcetestjack", ".zip"); + Options options = new Options(); + options.addResource(new File(FILE, "rsc")); + TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(), + jackAr, true /* non-zipped */); + + return jackAr; + +// // compile source file to a Jack file +// File tempJackFolder = AbstractTestTools.createTempDir(); +// JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); +// toolchain.srcToLib( +// AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), +// tempJackFolder, +// /* zipFiles = */ false, +// FILE); +// +// // create Jack archive with resources +// File singleJackFile = new File(tempJackFolder, JACK_FILE_PATH); +// File jackAr = AbstractTestTools.createTempFile("resourcetestjack", ".zip"); +// ZipOutputStream zos = null; +// try { +// zos = new ZipOutputStream(new FileOutputStream(jackAr)); +// +// copyFileToZip(singleJackFile, JACK_FILE_PATH, zos); +// copyFileToZip(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, zos); +// copyFileToZip(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, zos); +// copyFileToZip(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, zos); +// copyFileToZip(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, zos); +// } finally { +// if (zos != null) { +// zos.close(); +// } +// } +// return jackAr; + } + + private void checkResourceContentFromZip(@Nonnull ZipFile zipFile, @Nonnull String entryName, + @Nonnull String expectedContent, boolean isLib) throws IOException { + ZipEntry entry = zipFile.getEntry((isLib ? FileType.RSC.getPrefix() + '/' : "") + entryName); + Assert.assertNotNull(entry); + BufferedReader candidateReader = null; + BufferedReader referenceReader = null; + try { + InputStream in = zipFile.getInputStream(entry); + candidateReader = new BufferedReader(new InputStreamReader(in)); + referenceReader = new BufferedReader(new StringReader(expectedContent)); + compareReadLines(referenceReader, candidateReader); + } finally { + if (candidateReader != null) { + candidateReader.close(); + } + if (referenceReader != null) { + referenceReader.close(); + } + } + } + + private void checkResourceContentFromDir(@Nonnull File dir, @Nonnull String path, + @Nonnull String expectedContent, boolean isLib) throws IOException { + assert dir.isDirectory(); + File file = new File(isLib ? new File(dir, FileType.RSC.getPrefix()) : dir, path); + Assert.assertTrue(file.exists()); + BufferedReader candidateReader = null; + BufferedReader referenceReader = null; + try { + InputStream in = new FileInputStream(file); + candidateReader = new BufferedReader(new InputStreamReader(in)); + referenceReader = new BufferedReader(new StringReader(expectedContent)); + compareReadLines(referenceReader, candidateReader); + } finally { + if (candidateReader != null) { + candidateReader.close(); + } + if (referenceReader != null) { + referenceReader.close(); + } + } + } + + + private void checkResourceContent(@Nonnull File candidateFileContent, + @Nonnull File referenceFileContent) throws IOException { + Assert.assertTrue(candidateFileContent.exists()); + BufferedReader candidateReader = null; + BufferedReader referenceReader = null; + try { + candidateReader = new BufferedReader(new InputStreamReader(new FileInputStream(candidateFileContent))); + referenceReader = new BufferedReader(new InputStreamReader(new FileInputStream(referenceFileContent))); + compareReadLines(referenceReader, candidateReader); + } finally { + if (candidateReader != null) { + candidateReader.close(); + } + if (referenceReader != null) { + referenceReader.close(); + } + } + } + + private void compareReadLines(@Nonnull BufferedReader referenceReader, + @Nonnull BufferedReader candidateReader) throws IOException { + String referenceLine = referenceReader.readLine(); + while (referenceLine != null) { + String candidateLine = candidateReader.readLine(); + Assert.assertEquals(referenceLine, candidateLine); + referenceLine = referenceReader.readLine(); + } + Assert.assertNull(candidateReader.readLine()); + } + + private void copyFileToDir(@Nonnull File fileToCopy, @Nonnull String relativePath, + @Nonnull File dir) throws IOException { + FileOutputStream fos = null; + FileInputStream fis = null; + try { + fis = new FileInputStream(fileToCopy); + File copiedFile = new File(dir, relativePath); + File parentDir = copiedFile.getParentFile(); + if (!parentDir.exists()) { + boolean res = parentDir.mkdirs(); + if (!res) { + throw new AssertionError(); + } + } + try { + fos = new FileOutputStream(copiedFile); + ByteStreamSucker sucker = new ByteStreamSucker(fis, fos); + sucker.suck(); + } finally { + if (fos != null) { + fos.close(); + } + } + } finally { + if (fis != null) { + fis.close(); + } + } + } + +} diff --git a/jack-tests/tests/com/android/jack/returnstatement/ReturnstatementTests.java b/jack-tests/tests/com/android/jack/returnstatement/ReturnstatementTests.java new file mode 100644 index 00000000..1af46dc7 --- /dev/null +++ b/jack-tests/tests/com/android/jack/returnstatement/ReturnstatementTests.java @@ -0,0 +1,75 @@ +/* +* 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.returnstatement; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +public class ReturnstatementTests extends RuntimeTest { + + private RuntimeTestInfo RETURNS = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.returnstatement.returns"), + "com.android.jack.returnstatement.returns.dx.Tests"); + + private RuntimeTestInfo RETURNVOID = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.returnstatement.returnvoid"), + "com.android.jack.returnstatement.returnvoid.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + ReturnstatementTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void returns() throws Exception { + new RuntimeTestHelper(RETURNS).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void returnvoid() throws Exception { + new RuntimeTestHelper(RETURNVOID).compileAndRunTest(); + } + + @Test + public void ropBuildMethodWithSameReturnReg() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + + String classpath = AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()); + File dexOutDir = AbstractTestTools.createTempDir(); + File testSourceDir = AbstractTestTools.getTestRootDir("com.android.jack.analysis.dfa.reachingdefs.test001"); + + toolchain.srcToExe(classpath, dexOutDir, /* zipFile = */ false, testSourceDir); + + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(RETURNS); + rtTestInfos.add(RETURNVOID); + } +} diff --git a/jack-tests/tests/com/android/jack/shrob/AbstractTest.java b/jack-tests/tests/com/android/jack/shrob/AbstractTest.java index 319abaff..22896b6a 100644 --- a/jack-tests/tests/com/android/jack/shrob/AbstractTest.java +++ b/jack-tests/tests/com/android/jack/shrob/AbstractTest.java @@ -19,8 +19,8 @@ package com.android.jack.shrob; import com.android.jack.Main; import com.android.jack.ProguardFlags; import com.android.jack.TestTools; -import com.android.jack.category.KnownBugs; -import com.android.jack.category.SlowTests; +import com.android.jack.test.category.KnownBugs; +import com.android.jack.test.category.SlowTests; import org.junit.BeforeClass; import org.junit.Test; diff --git a/jack-tests/tests/com/android/jack/shrob/AnnotationsTest.java b/jack-tests/tests/com/android/jack/shrob/AnnotationsTest.java new file mode 100644 index 00000000..cf819021 --- /dev/null +++ b/jack-tests/tests/com/android/jack/shrob/AnnotationsTest.java @@ -0,0 +1,51 @@ +/* + * 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.shrob; + +import com.android.jack.ProguardFlags; +import com.android.jack.TestTools; +import com.android.jack.test.comparator.ComparatorDexAnnotations; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackBasedToolchain; + +import java.io.File; + +import javax.annotation.Nonnull; + +public class AnnotationsTest extends AbstractTest { + + @Override + protected void runTest( + @Nonnull String testNumber, + @Nonnull String flagNumber, + @Nonnull String mappingNumber) + throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(new File(testFolder, "jack")); + env.setCandidateTestTools(toolchain); + env.setProguardFlags( + generateApplyMapping(new File(testFolder,"proguard.flags" + flagNumber + ".mapping" + mappingNumber)), +// new ProguardFlags(TestTools.getJackTestFolder("shrob"),"keepDebugInfo.flags"), + new ProguardFlags(TestTools.getJackTestFolder("shrob"),"keepAllAttributes.flags"), + new ProguardFlags(testFolder,"proguard.flags" + flagNumber)); + env.runTest(new ComparatorDexAnnotations(env.getCandidateDex(), env.getReferenceDex())); + } +} diff --git a/jack-tests/tests/com/android/jack/shrob/FlattenPackageTests.java b/jack-tests/tests/com/android/jack/shrob/FlattenPackageTests.java new file mode 100644 index 00000000..a07b3c9f --- /dev/null +++ b/jack-tests/tests/com/android/jack/shrob/FlattenPackageTests.java @@ -0,0 +1,73 @@ +/* + * 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.shrob; + +import com.android.jack.Options; +import com.android.jack.test.category.SlowTests; +import com.android.jack.shrob.obfuscation.NameProviderFactory; +import com.android.jack.shrob.proguard.GrammarActions; +import com.android.jack.shrob.spec.Flags; +import com.android.jack.test.comparator.ComparatorMapping; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.DummyToolchain; +import com.android.jack.test.toolchain.JackApiToolchain; + +import org.junit.experimental.categories.Category; + +import java.io.File; + +import javax.annotation.Nonnull; + +@Category(SlowTests.class) +public class FlattenPackageTests extends AbstractTest { + + @Override + protected void runTest( + @Nonnull String testNumber, + @Nonnull String flagNumber, + @Nonnull String mappingNumber) + throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber); + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + Flags flags = new Flags(); + toolchain.setShrobFlags(flags); + GrammarActions.parse("proguard.flags" + flagNumber, testFolder.getAbsolutePath(), flags); + GrammarActions.parse("keepPackageName.flags", + AbstractTestTools.getTestRootDir("com.android.jack.shrob").getAbsolutePath(), flags); + flags.setPackageForFlatHierarchy("flatpackage"); + File candidateOutputMapping = AbstractTestTools.createTempFile("mapping", ".txt"); + File refFolder = new File(testFolder, "refsFlattenPackage"); + File refOutputMapping = new File(refFolder, "expected-" + flagNumber + ".txt"); + flags.setOutputMapping(candidateOutputMapping); + flags.setPrintMapping(true); + toolchain.addProperty(NameProviderFactory.NAMEPROVIDER.getName(), "rot13"); + toolchain.addProperty(Options.METHOD_FILTER.getName(), "supported-methods"); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(new File(testFolder, "jack")); + + env.setCandidateTestTools(toolchain); + env.setReferenceTestTools(new DummyToolchain()); + + // 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.runTest(new ComparatorMapping(refOutputMapping, candidateOutputMapping)); + } +} diff --git a/jack-tests/tests/com/android/jack/shrob/ObfuscationWithAttributesTests.java b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithAttributesTests.java new file mode 100644 index 00000000..5a1feaf7 --- /dev/null +++ b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithAttributesTests.java @@ -0,0 +1,65 @@ +/* + * 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.shrob; + +import com.android.jack.ProguardFlags; +import com.android.jack.test.comparator.ComparatorDex; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.AndroidToolchain; +import com.android.jack.test.toolchain.JackBasedToolchain; + +import org.junit.Test; + +import java.io.File; + +import javax.annotation.Nonnull; + +public class ObfuscationWithAttributesTests extends AbstractTest { + + @Override + @Test + public void test1_001() throws Exception { + super.test1_001(); + } + + @Override + protected void runTest( + @Nonnull String testNumber, + @Nonnull String flagNumber, + @Nonnull String mappingNumber) + throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber); + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + File [] proguardFlags = new File [] { + generateApplyMapping(new File(testFolder,"proguard.flags" + flagNumber + ".mapping" + mappingNumber)), + new ProguardFlags(AbstractTestTools.getTestRootDir("com.android.jack.shrob"),"keepAllAttributes.flags"), + new ProguardFlags(testFolder,"proguard.flags" + flagNumber) + }; + toolchain.addProguardFlags(proguardFlags); + + AndroidToolchain refToolchain = AbstractTestTools.getReferenceToolchain(AndroidToolchain.class); + refToolchain.addProguardFlags(proguardFlags); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(new File(testFolder, "jack")); + env.setCandidateTestTools(toolchain); + env.setReferenceTestTools(refToolchain); + env.setWithDebugInfo(true); + env.runTest(new ComparatorDex(env.getCandidateDex(), env.getReferenceDex())); + } +} diff --git a/jack-tests/tests/com/android/jack/shrob/ObfuscationWithDebugInfoTests.java b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithDebugInfoTests.java new file mode 100644 index 00000000..80eac52d --- /dev/null +++ b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithDebugInfoTests.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.shrob; + +import com.android.jack.ProguardFlags; +import com.android.jack.test.comparator.ComparatorDex; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; + +import java.io.File; + +import javax.annotation.Nonnull; + +public class ObfuscationWithDebugInfoTests extends AbstractTest { + + @Override + protected void runTest( + @Nonnull String testNumber, + @Nonnull String flagNumber, + @Nonnull String mappingNumber) + throws Exception { + + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(new File(testFolder, "jack")); + env.setWithDebugInfo(true); + env.setProguardFlags( + generateApplyMapping( + new File(testFolder, "proguard.flags" + flagNumber + ".mapping" + mappingNumber)), + new ProguardFlags(AbstractTestTools.getTestRootDir("com.android.jack.shrob"), + "keepDebugInfo.flags"), new ProguardFlags(testFolder, "proguard.flags" + flagNumber)); + + env.runTest(new ComparatorDex(env.getCandidateDex(), env.getReferenceDex())); + } +} diff --git a/jack-tests/tests/com/android/jack/shrob/ObfuscationWithMappingTests.java b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithMappingTests.java new file mode 100644 index 00000000..fb09d898 --- /dev/null +++ b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithMappingTests.java @@ -0,0 +1,90 @@ +/* + * 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.shrob; + +import com.android.jack.shrob.proguard.GrammarActions; +import com.android.jack.shrob.spec.Flags; +import com.android.jack.test.comparator.ComparatorMapping; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.DummyToolchain; +import com.android.jack.test.toolchain.JackApiToolchain; + +import org.junit.Test; + +import java.io.File; + +import javax.annotation.Nonnull; + +public class ObfuscationWithMappingTests extends AbstractTest { + + @Override + protected void runTest( + @Nonnull String testNumber, + @Nonnull String flagNumber, + @Nonnull String mappingNumber) + throws Exception { + + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber); + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + Flags flags = new Flags(); + toolchain.setShrobFlags(flags); + GrammarActions.parse("proguard.flags" + flagNumber, testFolder.getAbsolutePath(), flags); + File candidateOutputMapping = AbstractTestTools.createTempFile("mapping", ".txt"); + File refFolder = new File(testFolder, "refsObfuscationWithMapping"); + File refOutputMapping = new File(refFolder, "expected-" + flagNumber + ".txt"); + flags.setOutputMapping(candidateOutputMapping); + flags.setPrintMapping(true); + File inputMapping = + new File(testFolder, "proguard.flags" + flagNumber + ".mapping" + mappingNumber); + if (inputMapping.exists()) { + flags.setObfuscationMapping(inputMapping); + } + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(new File(testFolder, "jack")); + + env.setCandidateTestTools(toolchain); + env.setReferenceTestTools(new DummyToolchain()); + + env.runTest(new ComparatorMapping(candidateOutputMapping, refOutputMapping)); + } + + @Override + @Test + public void test33_001() throws Exception { + // Test 33 already has a partial mapping, it can't be used in this test suite. + } + + @Override + @Test + public void test33_002() throws Exception { + // Test 33 already has a partial mapping, it can't be used in this test suite. + } + + @Override + @Test + public void test34_001() throws Exception { + // Test 35 already has a partial mapping, it can't be used in this test suite. + } + + @Override + @Test + public void test35_001() throws Exception { + // Test 34 already has a partial mapping, it can't be used in this test suite. + } +} diff --git a/jack-tests/tests/com/android/jack/shrob/ObfuscationWithoutMappingTests.java b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithoutMappingTests.java index 26cba495..a17b9fe0 100644 --- a/jack-tests/tests/com/android/jack/shrob/ObfuscationWithoutMappingTests.java +++ b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithoutMappingTests.java @@ -17,7 +17,7 @@ package com.android.jack.shrob; import com.android.jack.Options; -import com.android.jack.category.KnownBugs; +import com.android.jack.test.category.KnownBugs; import com.android.jack.shrob.obfuscation.NameProviderFactory; import com.android.jack.shrob.proguard.GrammarActions; import com.android.jack.shrob.spec.Flags; @@ -43,8 +43,6 @@ public class ObfuscationWithoutMappingTests extends AbstractTest { @Nonnull String mappingNumber) throws Exception { - String testName = "shrob/test" + testNumber; - String testPackageName = "com.android.jack.shrob.test" + testNumber; File testFolder = AbstractTestTools.getTestRootDir(testPackageName); diff --git a/jack-tests/tests/com/android/jack/shrob/RepackagingTest.java b/jack-tests/tests/com/android/jack/shrob/RepackagingTest.java new file mode 100644 index 00000000..805d2c51 --- /dev/null +++ b/jack-tests/tests/com/android/jack/shrob/RepackagingTest.java @@ -0,0 +1,65 @@ +/* + * 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.shrob; + +import com.android.jack.Options; +import com.android.jack.shrob.obfuscation.NameProviderFactory; +import com.android.jack.shrob.proguard.GrammarActions; +import com.android.jack.shrob.spec.Flags; +import com.android.jack.test.comparator.ComparatorMapping; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.DummyToolchain; +import com.android.jack.test.toolchain.JackApiToolchain; + +import java.io.File; + +import javax.annotation.Nonnull; + +public class RepackagingTest extends AbstractTest { + + @Override + protected void runTest( + @Nonnull String testNumber, + @Nonnull String flagNumber, + @Nonnull String mappingNumber) + throws Exception { + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber); + Flags flags = new Flags(); + + GrammarActions.parse("proguard.flags" + flagNumber, testFolder.getAbsolutePath(), flags); + flags.setPackageForRenamedClasses(""); + File candidateOutputMapping = AbstractTestTools.createTempFile("mapping", ".txt"); + File refFolder = new File(testFolder, "refsRepackageClasses"); + File refOutputMapping = new File(refFolder, "expected-" + flagNumber + ".txt"); + flags.setOutputMapping(candidateOutputMapping); + flags.setPrintMapping(true); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.setShrobFlags(flags); + toolchain.addProperty(NameProviderFactory.NAMEPROVIDER.getName(), "rot13"); + toolchain.addProperty(Options.METHOD_FILTER.getName(), "supported-methods"); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(new File(testFolder, "jack")); + + env.setCandidateTestTools(toolchain); + env.setReferenceTestTools(new DummyToolchain()); + + env.runTest(new ComparatorMapping(candidateOutputMapping, refOutputMapping)); + } +} diff --git a/jack-tests/tests/com/android/jack/shrob/SeedTests.java b/jack-tests/tests/com/android/jack/shrob/SeedTests.java new file mode 100644 index 00000000..5b966fad --- /dev/null +++ b/jack-tests/tests/com/android/jack/shrob/SeedTests.java @@ -0,0 +1,66 @@ +/* + * 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.shrob; + +import com.android.jack.test.category.SlowTests; +import com.android.jack.shrob.proguard.GrammarActions; +import com.android.jack.shrob.spec.Flags; +import com.android.jack.test.comparator.ComparatorSeeds; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.DummyToolchain; +import com.android.jack.test.toolchain.JackApiToolchain; + +import org.junit.experimental.categories.Category; + +import java.io.File; + +import javax.annotation.Nonnull; + +@Category(SlowTests.class) +public class SeedTests extends AbstractTest { + + @Override + protected void runTest( + @Nonnull String testNumber, + @Nonnull String flagNumber, + @Nonnull String mappingNumber) + throws Exception { + + File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber); + Flags flags = new Flags(); + flags.setShrink(false); + flags.setObfuscate(false); + GrammarActions.parse("proguard.flags" + flagNumber, testFolder.getAbsolutePath(), flags); + File refFolder = new File(testFolder, "refsSeed"); + File candidateOutputSeeds = AbstractTestTools.createTempFile("seeds", ".txt"); + File refOutputSeeds = new File(refFolder, "expected-" + flagNumber + ".txt"); + flags.setSeedsFile(candidateOutputSeeds); + flags.setPrintSeeds(true); + + JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.setShrobFlags(flags); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(new File(testFolder, "jack")); + + env.setCandidateTestTools(toolchain); + env.setReferenceTestTools(new DummyToolchain()); + + env.runTest(new ComparatorSeeds(refOutputSeeds, candidateOutputSeeds)); + } +} diff --git a/jack-tests/tests/com/android/jack/shrob/ShrinkMultiDexTests.java b/jack-tests/tests/com/android/jack/shrob/ShrinkMultiDexTests.java new file mode 100644 index 00000000..b06855a5 --- /dev/null +++ b/jack-tests/tests/com/android/jack/shrob/ShrinkMultiDexTests.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.shrob; + +import com.android.jack.Main; +import com.android.jack.Options; +import com.android.jack.ProguardFlags; +import com.android.jack.backend.dex.DexFileWriter; +import com.android.jack.backend.dex.MultiDexLegacy; +import com.android.jack.preprocessor.PreProcessor; +import com.android.jack.shrob.shrink.ShrinkStructurePrinter; +import com.android.jack.test.comparator.ComparatorMapping; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackBasedToolchain; + +import org.junit.BeforeClass; + +import java.io.File; + +import javax.annotation.Nonnull; + +/** + * Tests for verifying that tracing for MultiDex does not disturb shrinking. + */ +public class ShrinkMultiDexTests extends AbstractTest { + + private static File shrobTestsDir = + AbstractTestTools.getTestRootDir("com.android.jack.shrob"); + + private static ProguardFlags dontObfuscateFlagFile = + new ProguardFlags(shrobTestsDir, "dontobfuscate.flags"); + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Override + protected void runTest( + @Nonnull String testNumber, + @Nonnull String flagNumber, + @Nonnull String mappingNumber) + throws Exception { + File testFolder = new File(shrobTestsDir, "test" + testNumber); + JackBasedToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + + File refFolder = new File(testFolder, "refsShrinking"); + toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex"); + toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true"); + toolchain.addProperty(PreProcessor.ENABLE.getName(), "true"); + toolchain.addProperty(PreProcessor.FILE.getName(), + new File(shrobTestsDir, "legacyMainDexClasses.jpp").getAbsolutePath()); + + File candidateNodeListing = AbstractTestTools.createTempFile("nodeListing", ".txt"); + toolchain.addProperty(ShrinkStructurePrinter.STRUCTURE_PRINTING.getName(), "true"); + toolchain.addProperty(ShrinkStructurePrinter.STRUCTURE_PRINTING_FILE.getName(), + candidateNodeListing.getPath()); + toolchain.addProperty(Options.METHOD_FILTER.getName(), "supported-methods"); + toolchain.disableDxOptimizations(); + + File out = AbstractTestTools.createTempFile("checklisting", ".zip"); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(new File(testFolder, "jack")); + env.setCandidateTestTools(toolchain); + env.setWithDebugInfo(true); + env.setProguardFlags(dontObfuscateFlagFile, + new ProguardFlags(shrobTestsDir, "keepAllAttributes.flags"), + new ProguardFlags(testFolder, "proguard.flags" + flagNumber)); + + env.runTest(new ComparatorMapping(new File(refFolder, "expected-" + flagNumber + ".txt"), + candidateNodeListing)); + } + +} diff --git a/jack-tests/tests/com/android/jack/shrob/ShrinkTests.java b/jack-tests/tests/com/android/jack/shrob/ShrinkTests.java new file mode 100644 index 00000000..175427c7 --- /dev/null +++ b/jack-tests/tests/com/android/jack/shrob/ShrinkTests.java @@ -0,0 +1,218 @@ +/* + * 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.shrob; + +import com.android.jack.Main; +import com.android.jack.Options; +import com.android.jack.ProguardFlags; +import com.android.jack.shrob.shrink.ShrinkStructurePrinter; +import com.android.jack.test.comparator.ComparatorMapping; +import com.android.jack.test.helper.SourceToDexComparisonTestHelper; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.DummyToolchain; +import com.android.jack.test.toolchain.JackApiToolchain; +import com.android.jack.test.toolchain.JackBasedToolchain; +import com.android.jack.util.TextUtils; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; + +import javax.annotation.Nonnull; + +public class ShrinkTests extends AbstractTest { + + private static File shrobTestsDir = + AbstractTestTools.getTestRootDir("com.android.jack.shrob"); + + private static ProguardFlags dontObfuscateFlagFile = + new ProguardFlags(shrobTestsDir, "dontobfuscate.flags"); + + @BeforeClass + public static void setUpClass() { + Main.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Override + protected void runTest( + @Nonnull String testNumber, + @Nonnull String flagNumber, + @Nonnull String mappingNumber) + throws Exception { + File testFolder = new File(shrobTestsDir, "test" + testNumber); + JackBasedToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + + File refFolder = new File(testFolder, "refsShrinking"); + + File candidateNodeListing = AbstractTestTools.createTempFile("nodeListing", ".txt"); + toolchain.addProperty(ShrinkStructurePrinter.STRUCTURE_PRINTING.getName(), "true"); + toolchain.addProperty(ShrinkStructurePrinter.STRUCTURE_PRINTING_FILE.getName(), + candidateNodeListing.getPath()); + toolchain.addProperty(Options.METHOD_FILTER.getName(), "supported-methods"); + toolchain.disableDxOptimizations(); + + File outFolder = AbstractTestTools.createTempDir(); + + SourceToDexComparisonTestHelper env = + new SourceToDexComparisonTestHelper(new File(testFolder, "jack")); + + env.setCandidateTestTools(toolchain); + env.setReferenceTestTools(new DummyToolchain()); + env.setProguardFlags( + dontObfuscateFlagFile, + new ProguardFlags(shrobTestsDir,"keepAllAttributes.flags"), + new ProguardFlags(testFolder, "proguard.flags" + flagNumber)); + + env.runTest(new ComparatorMapping( + new File(refFolder, "expected-" + flagNumber + ".txt"), + candidateNodeListing)); + } + + @Test + public void test020() throws Exception { + File libOut = AbstractTestTools.createTempDir(); + File testOut = null; + File shrinkOut = null; + + try { + JackApiToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + libOut, + /* zipFiles = */ false, + new File(shrobTestsDir, "test020/lib")); + + toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + testOut = AbstractTestTools.createTempDir(); + toolchain.srcToLib( + AbstractTestTools.getClasspathsAsString( + toolchain.getDefaultBootClasspath(), new File[] {libOut}), + testOut, + /* zipFiles = */ false, + new File(shrobTestsDir, "test020/jack")); + + shrinkOut = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.addProguardFlags( + dontObfuscateFlagFile, + new ProguardFlags(new File(shrobTestsDir, "test020"),"proguard.flags")); + toolchain.libToLib( + testOut, + shrinkOut, + /* zipFile = */ false); + } catch (Exception e) { + String message = "Not deleting temp files of failed test ShrinkTest.test20 in:" + + TextUtils.LINE_SEPARATOR + + "- " + libOut.getAbsolutePath(); + if (testOut != null) { + message += TextUtils.LINE_SEPARATOR + "- " + testOut.getAbsolutePath(); + } + if (shrinkOut != null) { + message += TextUtils.LINE_SEPARATOR + "- " + shrinkOut.getAbsolutePath(); + } + System.err.println(); + System.err.println(message); + throw e; + } + } + + @Test + public void test021() throws Exception { + File jackOut = AbstractTestTools.createTempDir(); + File shrinkOut = null; + File dexOut = null; + + try { + JackApiToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + jackOut, + /* zipFiles = */ false, + new File(shrobTestsDir, "test021/jack")); + + toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.addProguardFlags( + dontObfuscateFlagFile, + new ProguardFlags(new File( shrobTestsDir, "test021"),"proguard.flags001")); + shrinkOut = AbstractTestTools.createTempDir(); + toolchain.libToLib(jackOut, shrinkOut, /* zipFiles = */ false); + + dexOut = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); + toolchain.libToExe(shrinkOut, dexOut, /* zipFile = */ false); + + } catch (Exception e) { + String message = "Not deleting temp files of failed ShrinkTest.test20 in:\n" + + "- " + jackOut.getAbsolutePath(); + if (shrinkOut != null) { + message += "\n- " + shrinkOut.getAbsolutePath(); + } + if (dexOut != null) { + message += "\n- " + dexOut.getAbsolutePath(); + } + System.err.println(); + System.err.println(message); + throw e; + } + } + + /** + * The only purpose of this test is to use jack shrink capabilities and to have no reference to + * java/lang/Class. This test will make Jack fail if java/lang/Class methods like getField and + * getMethod cannot be looked up (i.e. at the time this test is written, if the structure of + * java/lang/Class has not been preloaded). + */ + @Test + public void test028() throws Exception { + File testFolder = new File(shrobTestsDir, "test028"); + File jackar = null; + File shrinkedjackar = null; + jackar = AbstractTestTools.createTempFile("jackar", ".zip"); + shrinkedjackar = AbstractTestTools.createTempFile("shrinkedjackar", ".zip"); + ProguardFlags flags = new ProguardFlags(testFolder, "proguard.flags001"); + + JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + String classpath = AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()); + toolchain.srcToLib( + classpath, + jackar, + /* zipFiles = */ true, + testFolder); + + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.libToLib(jackar, shrinkedjackar, /* zipFiles = */ true); + } + + @Test + public void test42_001() throws Exception { + runTest("042", "001", ""); + } + + @Test + public void test42_002() throws Exception { + runTest("042", "002", ""); + } + + @Test + public void test42_003() throws Exception { + runTest("042", "003", ""); + } +} diff --git a/jack-tests/tests/com/android/jack/shrob/ShrobAllTests.java b/jack-tests/tests/com/android/jack/shrob/ShrobAllTests.java new file mode 100644 index 00000000..fc8e0883 --- /dev/null +++ b/jack-tests/tests/com/android/jack/shrob/ShrobAllTests.java @@ -0,0 +1,22 @@ +package com.android.jack.shrob; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses(value = { +// AnnotationsTest.class, + FlattenPackageTests.class, +// ObfuscationWithAttributesTests.class, +// ObfuscationWithDebugInfoTests.class, + ObfuscationWithMappingTests.class, + ObfuscationWithoutMappingTests.class, + RepackagingTest.class, + SeedTests.class, + ShrinkMultiDexTests.class, + ShrinkTests.class, + ShrobRuntimeTests.class + }) +public class ShrobAllTests { +}
\ No newline at end of file diff --git a/jack-tests/tests/com/android/jack/shrob/ShrobRuntimeTests.java b/jack-tests/tests/com/android/jack/shrob/ShrobRuntimeTests.java new file mode 100644 index 00000000..e6a51804 --- /dev/null +++ b/jack-tests/tests/com/android/jack/shrob/ShrobRuntimeTests.java @@ -0,0 +1,90 @@ +/* + * 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.shrob; + +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.Test; + +import java.io.File; + +public class ShrobRuntimeTests extends RuntimeTest { + + private RuntimeTestInfo TEST011_1 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.shrob.test011"), + "com.android.jack.shrob.test011.dx.Tests"); + + private RuntimeTestInfo TEST011_2 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.shrob.test011"), + "com.android.jack.shrob.test011.dx.Tests2"); + + private RuntimeTestInfo TEST016 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.shrob.test016"), + "com.android.jack.shrob.test016.dx.Tests"); + + private RuntimeTestInfo TEST025 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.shrob.test025"), + "com.android.jack.shrob.test025.dx.Tests"); + + private RuntimeTestInfo TEST030 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.shrob.test030"), + "com.android.jack.shrob.test030.dx.Tests"); + + @Test + public void test011_1() throws Exception { + new RuntimeTestHelper(TEST011_1) + .setProguardFlagsFileNames(new String[] {"proguard.flags001", "../dontobfuscate.flags"}) + .compileAndRunTest(); + } + + @Test + public void test011_2() throws Exception { + new RuntimeTestHelper(TEST011_2) + .setProguardFlagsFileNames(new String[] {"proguard.flags002"}) + .compileAndRunTest(); + } + + @Test + public void test016() throws Exception { + new RuntimeTestHelper(TEST016) + .setProguardFlagsFileNames(new String[] {"proguard.flags001","applyMapping.flags"}) + .compileAndRunTest(); + } + + @Test + public void test025() throws Exception { + new RuntimeTestHelper(TEST025) + .setProguardFlagsFileNames(new String[] {"proguard.flags001"}) + .compileAndRunTest(); + } + + @Test + public void test030() throws Exception { + new RuntimeTestHelper(TEST030) + .setProguardFlagsFileNames(new String[] {new File(TEST030.directory, "proguard.flags001") + .getAbsolutePath()}) + .compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + } + +} diff --git a/jack-tests/tests/com/android/jack/string/StringTests.java b/jack-tests/tests/com/android/jack/string/StringTests.java new file mode 100644 index 00000000..92685369 --- /dev/null +++ b/jack-tests/tests/com/android/jack/string/StringTests.java @@ -0,0 +1,85 @@ +/* +* 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.string; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.IOException; + +public class StringTests extends RuntimeTest { + + private RuntimeTestInfo CONCAT001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.string.concat001"), + "com.android.jack.string.concat001.dx.Tests"); + + private RuntimeTestInfo CONCAT002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.string.concat002"), + "com.android.jack.string.concat002.dx.Tests"); + + private RuntimeTestInfo CONCAT003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.string.concat003"), + "com.android.jack.string.concat003.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + StringTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + + @Test + public void testCompileNewString() throws Exception { + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + AbstractTestTools.createTempDir(), + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.string.test001.jack")); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void concat001() throws Exception { + new RuntimeTestHelper(CONCAT001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void concat002() throws Exception { + new RuntimeTestHelper(CONCAT002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void concat003() throws Exception { + new RuntimeTestHelper(CONCAT003).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(CONCAT001); + rtTestInfos.add(CONCAT002); + rtTestInfos.add(CONCAT003); + } +} diff --git a/jack-tests/tests/com/android/jack/string001/jack/Strings.java b/jack-tests/tests/com/android/jack/string/test001/jack/Strings.java index 76abb8f7..a9cdcf19 100644 --- a/jack-tests/tests/com/android/jack/string001/jack/Strings.java +++ b/jack-tests/tests/com/android/jack/string/test001/jack/Strings.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.jack.string001.jack; +package com.android.jack.string.test001.jack; public class Strings { diff --git a/jack-tests/tests/com/android/jack/switchstatement/SwitchstatementTests.java b/jack-tests/tests/com/android/jack/switchstatement/SwitchstatementTests.java new file mode 100644 index 00000000..53f7e694 --- /dev/null +++ b/jack-tests/tests/com/android/jack/switchstatement/SwitchstatementTests.java @@ -0,0 +1,205 @@ +/* +* 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.switchstatement; + +import com.android.jack.TestTools; +import com.android.jack.backend.dex.DexFileWriter; +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; +import com.android.jack.test.toolchain.JackBasedToolchain; + +import junit.framework.Assert; + +import org.jf.dexlib.ClassDataItem.EncodedMethod; +import org.jf.dexlib.DexFile; +import org.jf.dexlib.Code.Analysis.AnalyzedInstruction; +import org.jf.dexlib.Code.Analysis.MethodAnalyzer; +import org.jf.dexlib.Code.Format.PackedSwitchDataPseudoInstruction; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +public class SwitchstatementTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test001"), + "com.android.jack.switchstatement.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test002"), + "com.android.jack.switchstatement.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test003"), + "com.android.jack.switchstatement.test003.dx.Tests"); + + private RuntimeTestInfo TEST004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test004"), + "com.android.jack.switchstatement.test004.dx.Tests"); + + private RuntimeTestInfo TEST005 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test005"), + "com.android.jack.switchstatement.test005.dx.Tests"); + + private RuntimeTestInfo TEST006 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test006"), + "com.android.jack.switchstatement.test006.dx.Tests"); + + private RuntimeTestInfo TEST007 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test007"), + "com.android.jack.switchstatement.test007.dx.Tests"); + + private RuntimeTestInfo TEST008 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test008"), + "com.android.jack.switchstatement.test008.dx.Tests"); + + private RuntimeTestInfo TEST010 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test010"), + "com.android.jack.switchstatement.test010.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + SwitchstatementTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + public void testCompile002AsJackThenDex() throws Exception { + File outJackTmp = AbstractTestTools.createTempDir(); + { + // build as jack + JackBasedToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), outJackTmp, + /* zipFiles = */false, + AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test002.jack")); + } + + { + // build dex from jack + JackBasedToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.libToExe(outJackTmp, AbstractTestTools.createTempDir(), /* zipFile = */false); + } + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test004() throws Exception { + new RuntimeTestHelper(TEST004).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test005() throws Exception { + new RuntimeTestHelper(TEST005).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test006() throws Exception { + new RuntimeTestHelper(TEST006).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test007() throws Exception { + new RuntimeTestHelper(TEST007).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test008() throws Exception { + new RuntimeTestHelper(TEST008).compileAndRunTest(); + } + + /** + * Test allowing to check that 'packed-switch-payload' into generated dex is as small as possible. + */ + @Test + public void testCompile9() throws Exception { + File outFolder = AbstractTestTools.createTempDir(); + File out = new File(outFolder, DexFileWriter.DEX_FILENAME); + + IToolchain toolchain = AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + outFolder, + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test009.jack")); + + DexFile dexFile = new DexFile(out); + EncodedMethod em = + TestTools.getEncodedMethod(dexFile, + "Lcom/android/jack/switchstatement/test009/jack/Switch;", "switch1", + "(Lcom/android/jack/switchstatement/test009/jack/Switch$Num;)Z"); + + MethodAnalyzer ma = new MethodAnalyzer(em, false, null); + boolean packedSwitchDataPseudo = false; + for (AnalyzedInstruction ai : ma.getInstructions()) { + if (ai.getInstruction() instanceof PackedSwitchDataPseudoInstruction) { + packedSwitchDataPseudo = true; + Assert.assertEquals(5, + ((PackedSwitchDataPseudoInstruction) ai.getInstruction()).getTargetCount()); + } + } + + Assert.assertTrue(packedSwitchDataPseudo); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test010() throws Exception { + new RuntimeTestHelper(TEST010).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); + rtTestInfos.add(TEST004); + rtTestInfos.add(TEST005); + rtTestInfos.add(TEST006); + rtTestInfos.add(TEST007); + rtTestInfos.add(TEST008); + rtTestInfos.add(TEST010); + } +} diff --git a/jack-tests/tests/com/android/jack/synchronize/SynchronizeTests.java b/jack-tests/tests/com/android/jack/synchronize/SynchronizeTests.java new file mode 100644 index 00000000..0ee6ed88 --- /dev/null +++ b/jack-tests/tests/com/android/jack/synchronize/SynchronizeTests.java @@ -0,0 +1,49 @@ +/* +* 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.synchronize; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class SynchronizeTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.synchronize.test001"), + "com.android.jack.synchronize.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + SynchronizeTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/threeaddress/ThreeaddressTests.java b/jack-tests/tests/com/android/jack/threeaddress/ThreeaddressTests.java new file mode 100644 index 00000000..6a172ebc --- /dev/null +++ b/jack-tests/tests/com/android/jack/threeaddress/ThreeaddressTests.java @@ -0,0 +1,49 @@ +/* +* 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.threeaddress; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class ThreeaddressTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.threeaddress.test001"), + "com.android.jack.threeaddress.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + ThreeaddressTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/threeaddress/dx/Tests.java b/jack-tests/tests/com/android/jack/threeaddress/test001/dx/Tests.java index eca3c3b6..af80d356 100644 --- a/jack-tests/tests/com/android/jack/threeaddress/dx/Tests.java +++ b/jack-tests/tests/com/android/jack/threeaddress/test001/dx/Tests.java @@ -14,16 +14,16 @@ * limitations under the License. */ -package com.android.jack.threeaddress.dx; +package com.android.jack.threeaddress.test001.dx; + +import com.android.jack.threeaddress.test001.jack.ThreeAddressCode001; +import com.android.jack.threeaddress.test001.jack.ThreeAddressCode002; +import com.android.jack.threeaddress.test001.jack.ThreeAddressCode003; import junit.framework.Assert; import org.junit.Test; -import com.android.jack.threeaddress.jack.ThreeAddressCode001; -import com.android.jack.threeaddress.jack.ThreeAddressCode002; -import com.android.jack.threeaddress.jack.ThreeAddressCode003; - public class Tests { @Test diff --git a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode001.java b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode001.java index a525ea0c..f5af349b 100644 --- a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode001.java +++ b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode001.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.jack.threeaddress.jack; +package com.android.jack.threeaddress.test001.jack; public class ThreeAddressCode001 { diff --git a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode002.java b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode002.java index ff201b69..1234ebfc 100644 --- a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode002.java +++ b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode002.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.jack.threeaddress.jack; +package com.android.jack.threeaddress.test001.jack; public class ThreeAddressCode002 { diff --git a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode003.java b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode003.java index bd9753d0..5b1b8d97 100644 --- a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode003.java +++ b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode003.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.jack.threeaddress.jack; +package com.android.jack.threeaddress.test001.jack; public class ThreeAddressCode003 { diff --git a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCodeUtil001.java b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCodeUtil001.java index e84e841e..0d2c4933 100644 --- a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCodeUtil001.java +++ b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCodeUtil001.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.jack.threeaddress.jack; +package com.android.jack.threeaddress.test001.jack; public abstract class ThreeAddressCodeUtil001 { public abstract int f(int a, int b); diff --git a/jack-tests/tests/com/android/jack/throwstatement/ThrowstatementTests.java b/jack-tests/tests/com/android/jack/throwstatement/ThrowstatementTests.java new file mode 100644 index 00000000..e1e0b870 --- /dev/null +++ b/jack-tests/tests/com/android/jack/throwstatement/ThrowstatementTests.java @@ -0,0 +1,49 @@ +/* +* 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.throwstatement; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class ThrowstatementTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.throwstatement.test001"), + "com.android.jack.throwstatement.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + ThrowstatementTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/tools/merger/MergerTestTools.java b/jack-tests/tests/com/android/jack/tools/merger/MergerTestTools.java index b163f5b0..b7f50871 100644 --- a/jack-tests/tests/com/android/jack/tools/merger/MergerTestTools.java +++ b/jack-tests/tests/com/android/jack/tools/merger/MergerTestTools.java @@ -20,11 +20,13 @@ import com.android.jack.Options; import com.android.jack.TestTools; import com.android.jack.backend.dex.DexFileWriter; import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackApiToolchain; import com.android.jack.test.toolchain.JackBasedToolchain; import com.android.sched.scheduler.ScheduleInstance; import java.io.File; import java.io.IOException; +import java.io.OutputStream; import javax.annotation.CheckForNull; import javax.annotation.Nonnull; @@ -33,9 +35,9 @@ public class MergerTestTools { @Nonnull protected File buildOneDexPerType(@CheckForNull String classpath, @Nonnull File sourceFolder, - boolean withDebug) throws Exception { - JackBasedToolchain toolchain = - AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + boolean withDebug, @CheckForNull OutputStream out, @CheckForNull OutputStream err) throws Exception { + JackApiToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackApiToolchain.class); try { File multiDexFolder = TestTools.createTempDir("multi", "dex"); File multiDex = new File(multiDexFolder, DexFileWriter.DEX_FILENAME); @@ -47,7 +49,14 @@ public class MergerTestTools { toolchain.addProperty(Options.INTERMEDIATE_DEX_DIR.getName(), multiDexOnTypePerTypeFolder.getAbsolutePath()); - toolchain.srcToExe(classpath, multiDexFolder, sourceFolder); + if (out != null) { + toolchain.setOutputStream(out); + } + if (err != null) { + toolchain.setErrorStream(err); + } + + toolchain.srcToExe(classpath, multiDexFolder, /* zipFile = */ false, sourceFolder); return multiDex; diff --git a/jack-tests/tests/com/android/jack/tools/merger/test011/MergerTest011.java b/jack-tests/tests/com/android/jack/tools/merger/test011/MergerTest011.java index f00da22b..fc593c5c 100644 --- a/jack-tests/tests/com/android/jack/tools/merger/test011/MergerTest011.java +++ b/jack-tests/tests/com/android/jack/tools/merger/test011/MergerTest011.java @@ -16,10 +16,13 @@ package com.android.jack.tools.merger.test011; +import com.android.jack.JackAbortException; import com.android.jack.JackUserException; import com.android.jack.Main; import com.android.jack.TestTools; -import com.android.jack.category.SlowTests; +import com.android.jack.backend.dex.DexWritingException; +import com.android.jack.backend.dex.SingleDexOverflowException; +import com.android.jack.test.category.SlowTests; import com.android.jack.tools.merger.FieldIdOverflowException; import com.android.jack.tools.merger.MergerTestTools; import com.android.jack.tools.merger.MethodIdOverflowException; @@ -31,6 +34,7 @@ import org.junit.BeforeClass; import org.junit.Test; import org.junit.experimental.categories.Category; +import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; @@ -46,8 +50,10 @@ public class MergerTest011 extends MergerTestTools { private static int fileCount = 655; - private static final String expectedExceptionMessage = - "Index overflow while merging dex files. Try using multidex"; + @Nonnull + private static final String EXPECTED_MESSAGE = + "Error during the dex writing phase: classes.dex has too many IDs. Try using multi-dex"; + @BeforeClass public static void setUpClass() { @@ -64,13 +70,18 @@ public class MergerTest011 extends MergerTestTools { } generateJavaFileWithMethods(srcFolder, fileCount, 36); + ByteArrayOutputStream err = new ByteArrayOutputStream(); + try { - buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder, false /* withDebug */); + buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder, + /* withDebug = */false, /* out = */ null, err); Assert.fail(); - } catch (JackUserException e) { - Assert.assertEquals(expectedExceptionMessage, e.getMessage()); + } catch (JackAbortException e) { Throwable cause = e.getCause(); - Assert.assertTrue(cause instanceof MethodIdOverflowException); + Assert.assertTrue(cause instanceof DexWritingException); + Assert.assertTrue(cause.getCause() instanceof SingleDexOverflowException); + Assert.assertTrue(cause.getCause().getCause() instanceof MethodIdOverflowException); + Assert.assertTrue(err.toString().contains(EXPECTED_MESSAGE)); } } @@ -83,13 +94,18 @@ public class MergerTest011 extends MergerTestTools { } generateJavaFileWithFields(srcFolder, fileCount, 37); + ByteArrayOutputStream err = new ByteArrayOutputStream(); + try { - buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder, false /* withDebug */); + buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder, + /* withDebug = */false, /* out = */ null, err); Assert.fail(); - } catch (JackUserException e) { - Assert.assertEquals(expectedExceptionMessage, e.getMessage()); + } catch (JackAbortException e) { Throwable cause = e.getCause(); - Assert.assertTrue(cause instanceof FieldIdOverflowException); + Assert.assertTrue(cause instanceof DexWritingException); + Assert.assertTrue(cause.getCause() instanceof SingleDexOverflowException); + Assert.assertTrue(cause.getCause().getCause() instanceof FieldIdOverflowException); + Assert.assertTrue(err.toString().contains(EXPECTED_MESSAGE)); } } @@ -103,13 +119,18 @@ public class MergerTest011 extends MergerTestTools { } generateJavaFileWithTypes(srcFolder, fileCount, 36); + ByteArrayOutputStream err = new ByteArrayOutputStream(); + try { - buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder, false /* withDebug */); + buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder, + /* withDebug = */false, /* out = */ null, err); Assert.fail(); - } catch (JackUserException e) { - Assert.assertEquals(expectedExceptionMessage, e.getMessage()); + } catch (JackAbortException e) { Throwable cause = e.getCause(); - Assert.assertTrue(cause instanceof TypeIdOverflowException); + Assert.assertTrue(cause instanceof DexWritingException); + Assert.assertTrue(cause.getCause() instanceof SingleDexOverflowException); + Assert.assertTrue(cause.getCause().getCause() instanceof TypeIdOverflowException); + Assert.assertTrue(err.toString().contains(EXPECTED_MESSAGE)); } } diff --git a/jack-tests/tests/com/android/jack/trycatch/TrycatchTests.java b/jack-tests/tests/com/android/jack/trycatch/TrycatchTests.java new file mode 100644 index 00000000..98694c8d --- /dev/null +++ b/jack-tests/tests/com/android/jack/trycatch/TrycatchTests.java @@ -0,0 +1,128 @@ +/* +* 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.trycatch; + +import com.android.jack.Options; +import com.android.jack.TestTools; +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.IToolchain; + +import junit.framework.Assert; + +import org.jf.dexlib.CodeItem; +import org.jf.dexlib.DexFile; +import org.jf.dexlib.Code.Instruction; +import org.jf.dexlib.Code.Opcode; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; + +import javax.annotation.Nonnull; + +public class TrycatchTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.trycatch.test001"), + "com.android.jack.trycatch.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.trycatch.test002"), + "com.android.jack.trycatch.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.trycatch.test003"), + "com.android.jack.trycatch.test003.dx.Tests"); + + private RuntimeTestInfo TEST005 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.trycatch.test005"), + "com.android.jack.trycatch.test005.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + TrycatchTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test005() throws Exception { + new RuntimeTestHelper(TEST005).compileAndRunTest(); + } + + /** + * Verify that generated dex does not contains useless 'mov' instructions. + */ + @Test + @Ignore("Generated dex contains useless 'mov' instructions") + public void uselessMovInstructions() throws Exception { + File out = AbstractTestTools.createTempFile("uselessMovInstructions", ".dex"); + IToolchain toolchain = + AbstractTestTools.getCandidateToolchain(); + toolchain.srcToExe( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + out, + /* zipFile = */ false, + AbstractTestTools.getTestRootDir("com.android.jack.trycatch.test004")); + + DexFile dexFile = new DexFile(out); + CodeItem ci = + TestTools.getEncodedMethod(dexFile, "Lcom/android/jack/trycatch/test004/jack/TryCatch;", + "setIconAndText", "(IIILjava/lang/String;II)V").codeItem; + + Assert.assertFalse(hasOpcode(ci, Opcode.MOVE_OBJECT)); + } + + private boolean hasOpcode(@Nonnull CodeItem codeItem, @Nonnull Opcode opcode) { + for (Instruction inst : codeItem.getInstructions()) { + if (inst.opcode == opcode) { + return true; + } + } + return false; + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); + rtTestInfos.add(TEST005); + } +} diff --git a/jack-tests/tests/com/android/jack/tryfinally/TryfinallyTests.java b/jack-tests/tests/com/android/jack/tryfinally/TryfinallyTests.java new file mode 100644 index 00000000..15357063 --- /dev/null +++ b/jack-tests/tests/com/android/jack/tryfinally/TryfinallyTests.java @@ -0,0 +1,82 @@ +/* +* 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.tryfinally; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class TryfinallyTests extends RuntimeTest { + + private RuntimeTestInfo FINALLY002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.tryfinally.finally002"), + "com.android.jack.tryfinally.finally002.dx.Tests"); + + private RuntimeTestInfo FINALLY003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.tryfinally.finally003"), + "com.android.jack.tryfinally.finally003.dx.Tests"); + + private RuntimeTestInfo FINALLY004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.tryfinally.finally004"), + "com.android.jack.tryfinally.finally004.dx.Tests"); + + private RuntimeTestInfo FINALLYBLOCK = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.tryfinally.finallyblock"), + "com.android.jack.tryfinally.finallyblock.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + TryfinallyTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void finally002() throws Exception { + new RuntimeTestHelper(FINALLY002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void finally003() throws Exception { + new RuntimeTestHelper(FINALLY003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void finally004() throws Exception { + new RuntimeTestHelper(FINALLY004).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void finallyblock() throws Exception { + new RuntimeTestHelper(FINALLYBLOCK).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(FINALLY002); + rtTestInfos.add(FINALLY003); + rtTestInfos.add(FINALLY004); + rtTestInfos.add(FINALLYBLOCK); + } +} diff --git a/jack-tests/tests/com/android/jack/type/TypeTests.java b/jack-tests/tests/com/android/jack/type/TypeTests.java new file mode 100644 index 00000000..f908532e --- /dev/null +++ b/jack-tests/tests/com/android/jack/type/TypeTests.java @@ -0,0 +1,60 @@ +/* +* 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.type; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class TypeTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.type.test001"), + "com.android.jack.type.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.type.test002"), + "com.android.jack.type.test002.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + TypeTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + } +} diff --git a/jack-tests/tests/com/android/jack/unary/UnaryTests.java b/jack-tests/tests/com/android/jack/unary/UnaryTests.java new file mode 100644 index 00000000..2f1485e1 --- /dev/null +++ b/jack-tests/tests/com/android/jack/unary/UnaryTests.java @@ -0,0 +1,82 @@ +/* +* 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.unary; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class UnaryTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.unary.test001"), + "com.android.jack.unary.test001.dx.Tests"); + + private RuntimeTestInfo TEST002 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.unary.test002"), + "com.android.jack.unary.test002.dx.Tests"); + + private RuntimeTestInfo TEST003 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.unary.test003"), + "com.android.jack.unary.test003.dx.Tests"); + + private RuntimeTestInfo TEST004 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.unary.test004"), + "com.android.jack.unary.test004.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + UnaryTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test002() throws Exception { + new RuntimeTestHelper(TEST002).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test003() throws Exception { + new RuntimeTestHelper(TEST003).compileAndRunTest(); + } + + @Test + @Category(RuntimeRegressionTest.class) + public void test004() throws Exception { + new RuntimeTestHelper(TEST004).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + rtTestInfos.add(TEST002); + rtTestInfos.add(TEST003); + rtTestInfos.add(TEST004); + } +} diff --git a/jack-tests/tests/com/android/jack/verify/VerifyTests.java b/jack-tests/tests/com/android/jack/verify/VerifyTests.java new file mode 100644 index 00000000..12c0cfb9 --- /dev/null +++ b/jack-tests/tests/com/android/jack/verify/VerifyTests.java @@ -0,0 +1,49 @@ +/* +* 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.verify; + +import com.android.jack.test.category.RuntimeRegressionTest; +import com.android.jack.test.helper.RuntimeTestHelper; +import com.android.jack.test.runtime.RuntimeTest; +import com.android.jack.test.runtime.RuntimeTestInfo; +import com.android.jack.test.toolchain.AbstractTestTools; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +public class VerifyTests extends RuntimeTest { + + private RuntimeTestInfo TEST001 = new RuntimeTestInfo( + AbstractTestTools.getTestRootDir("com.android.jack.verify.test001"), + "com.android.jack.verify.test001.dx.Tests"); + + @BeforeClass + public static void setUpClass() { + VerifyTests.class.getClassLoader().setDefaultAssertionStatus(true); + } + @Test + @Category(RuntimeRegressionTest.class) + public void test001() throws Exception { + new RuntimeTestHelper(TEST001).compileAndRunTest(); + } + + @Override + protected void fillRtTestInfos() { + rtTestInfos.add(TEST001); + } +} diff --git a/jack-tests/tests/com/android/jack/withphantom/WithPhantomTests.java b/jack-tests/tests/com/android/jack/withphantom/WithPhantomTests.java new file mode 100644 index 00000000..fbf946c2 --- /dev/null +++ b/jack-tests/tests/com/android/jack/withphantom/WithPhantomTests.java @@ -0,0 +1,208 @@ +/* + * 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.withphantom; + +import com.android.jack.ProguardFlags; +import com.android.jack.test.category.KnownBugs; +import com.android.jack.library.FileType; +import com.android.jack.test.toolchain.AbstractTestTools; +import com.android.jack.test.toolchain.JackBasedToolchain; + +import junit.framework.Assert; + +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import java.io.File; +import java.io.FilenameFilter; + +import javax.annotation.Nonnull; + +/** + * Test compilation involving phantoms. + */ +public class WithPhantomTests { + + @Nonnull + private static final String TEST001 = "com.android.jack.withphantom.test001"; + @Nonnull + private static final String TEST001_JACK = TEST001 + ".jack"; + @Nonnull + private static final String TEST002 = "com.android.jack.withphantom.test002"; + @Nonnull + private static final String TEST002_JACK = TEST002 + ".jack"; + + @Nonnull + private static String fixPath(@Nonnull String unixPath) { + return unixPath.replace('/', File.separatorChar); + } + + @Test + public void testPhantomOuter() throws Exception { + File tempJackFolder = AbstractTestTools.createTempDir(); + JackBasedToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + tempJackFolder, + /* zipFiles = */ false, + AbstractTestTools.getTestRootDir(TEST001_JACK)); + + boolean deleted = + new File(tempJackFolder, FileType.JAYCE.getPrefix() + File.separatorChar + + fixPath("com/android/jack/withphantom/test001/jack/A.jayce")).delete(); + Assert.assertTrue(deleted); + + File testFolder = AbstractTestTools.getTestRootDir(TEST001); + + File tempOut1 = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProguardFlags(new ProguardFlags(testFolder, "shrink1.flags")) + .libToLib(tempJackFolder, tempOut1, /* zipFiles = */ false); + + File tempOut2 = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProguardFlags(new ProguardFlags(testFolder, "shrink2.flags")) + .libToLib(tempJackFolder, tempOut2, /* zipFiles = */ false); + + File tempOut3 = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProguardFlags(new ProguardFlags(testFolder, "obf1.flags")) + .libToLib(tempJackFolder, tempOut3, /* zipFiles = */ false); + + File tempOut4 = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProguardFlags(new ProguardFlags(testFolder, "obf2.flags")) + .libToLib(tempJackFolder, tempOut4, /* zipFiles = */ false); + + File tempOut5 = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.libToExe(tempJackFolder, tempOut5, /* zipFile = */ false); + } + + @Test + public void testPhantomInner() throws Exception { + File tempJackFolder = AbstractTestTools.createTempDir(); + JackBasedToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + tempJackFolder, + /* zipFiles = */ false, + AbstractTestTools.getTestRootDir(TEST001_JACK)); + + boolean deleted = + new File(tempJackFolder, fixPath(FileType.JAYCE.getPrefix() + File.separatorChar + + "com/android/jack/withphantom/test001/jack/A$Inner1.jayce")).delete(); + Assert.assertTrue(deleted); + deleted = + new File(tempJackFolder, fixPath(FileType.DEX.getPrefix() + File.separatorChar + + "com/android/jack/withphantom/test001/jack/A$Inner1.dex")).delete(); + Assert.assertTrue(deleted); + + File testFolder = AbstractTestTools.getTestRootDir(TEST001); + + File tempOut1 = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProguardFlags(new ProguardFlags(testFolder, "shrink1.flags")) + .libToLib(tempJackFolder, tempOut1, /* zipFiles = */ false); + + File tempOut2 = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProguardFlags(new ProguardFlags(testFolder, "shrink2.flags")) + .libToLib(tempJackFolder, tempOut2, /* zipFiles = */ false); + + File tempOut3 = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProguardFlags(new ProguardFlags(testFolder, "obf1.flags")) + .libToLib(tempJackFolder, tempOut3, /* zipFiles = */ false); + + File tempOut4 = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProguardFlags(new ProguardFlags(testFolder, "obf2.flags")) + .libToLib(tempJackFolder, tempOut4, /* zipFiles = */ false); + + File tempOutFolder = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.libToExe(tempJackFolder, tempOutFolder, /* zipFile = */ false); + } + + @Category(KnownBugs.class) + @Test + public void testPhantomLocal() throws Exception { + File tempJackFolder = AbstractTestTools.createTempDir(); + JackBasedToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + tempJackFolder, + /* zipFiles = */ false, + AbstractTestTools.getTestRootDir(TEST002_JACK)); + + File[] inners = + new File(tempJackFolder, fixPath(FileType.JAYCE.getPrefix() + File.separatorChar + + "com/android/jack/withphantom/test002/jack/")).listFiles(new FilenameFilter() { + @Override + public boolean accept(File dir, String name) { + return name.startsWith("A$"); + } + }); + for (File file : inners) { + Assert.assertTrue(file.delete()); + } + + File testFolder = AbstractTestTools.getTestRootDir(TEST002); + + File tempOut1 = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.addProguardFlags(new ProguardFlags(testFolder, "obf1.flags")) + .libToLib(tempJackFolder, tempOut1, /* zipFiles = */ false); + + File tempOutFolder = AbstractTestTools.createTempDir(); + toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.libToExe(tempJackFolder, tempOutFolder, /* zipFile = */ false); + } + + @Test + public void testPhantomLocalOuter() throws Exception { + File tempJackFolder = AbstractTestTools.createTempDir(); + JackBasedToolchain toolchain = + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class); + toolchain.srcToLib( + AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), + tempJackFolder, + /* zipFiles = */ false, + AbstractTestTools.getTestRootDir(TEST002_JACK)); + + boolean deleted = + new File(tempJackFolder, fixPath(FileType.JAYCE.getPrefix() + File.separatorChar + + "com/android/jack/withphantom/test002/jack/A.jayce")).delete(); + Assert.assertTrue(deleted); + + File testFolder = AbstractTestTools.getTestRootDir(TEST002); + + File tempOut1 = AbstractTestTools.createTempDir(); + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class) + .addProguardFlags(new ProguardFlags(testFolder, "obf1.flags")) + .libToLib(tempJackFolder, tempOut1, /* zipFiles = */ false); + + File tempOutFolder = AbstractTestTools.createTempDir(); + AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class) + .libToExe(tempJackFolder, tempOutFolder, /* zipFile = */ false); + } + +} |