164 lines
5.8 KiB
Java
164 lines
5.8 KiB
Java
/*
|
|
* Copyright (C) 2020 The Dagger Authors.
|
|
*
|
|
* 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 dagger.hilt.android;
|
|
|
|
import static com.google.common.truth.Truth.assertThat;
|
|
|
|
import android.os.Build;
|
|
import androidx.activity.ComponentActivity;
|
|
import androidx.test.ext.junit.runners.AndroidJUnit4;
|
|
import dagger.hilt.android.other.pkg.AndroidEntryPointBaseClassOtherPkg;
|
|
import org.junit.Test;
|
|
import org.junit.runner.RunWith;
|
|
import org.robolectric.annotation.Config;
|
|
|
|
/**
|
|
* Regression test for https://github.com/google/dagger/issues/1910
|
|
*
|
|
* <p>There are 8 different tests to cover 3 levels of inheritance where each level uses either the
|
|
* long-form (L) or short-form (S) of @AndroidEntryPoint:
|
|
*
|
|
* <ol>
|
|
* <li> L -> L -> L
|
|
* <li> L -> L -> S
|
|
* <li> L -> S -> L
|
|
* <li> L -> S -> S
|
|
* <li> S -> L -> L
|
|
* <li> S -> L -> S
|
|
* <li> S -> S -> L
|
|
* <li> S -> S -> S
|
|
* </ol>
|
|
*
|
|
* Note: We don't actually test injection in this class because Bazel doesn't do bytecode injection.
|
|
* We're only testing that the classes build, and verifying their inheritance matches what we
|
|
* expect.
|
|
*/
|
|
@RunWith(AndroidJUnit4.class)
|
|
// Robolectric requires Java9 to run API 29 and above, so use API 28 instead
|
|
@Config(sdk = Build.VERSION_CODES.P)
|
|
public final class AndroidEntryPointBaseClassTest {
|
|
|
|
@AndroidEntryPoint
|
|
public static final class SSActivity extends AndroidEntryPointBaseClassOtherPkg.SBaseActivity {}
|
|
|
|
@AndroidEntryPoint
|
|
public static final class SLActivity extends AndroidEntryPointBaseClassOtherPkg.LBaseActivity {}
|
|
|
|
@AndroidEntryPoint(AndroidEntryPointBaseClassOtherPkg.SBaseActivity.class)
|
|
public static final class LSActivity extends Hilt_AndroidEntryPointBaseClassTest_LSActivity {}
|
|
|
|
@AndroidEntryPoint(AndroidEntryPointBaseClassOtherPkg.LBaseActivity.class)
|
|
public static final class LLActivity extends Hilt_AndroidEntryPointBaseClassTest_LLActivity {}
|
|
|
|
@AndroidEntryPoint(LL.class)
|
|
public static final class LLL extends Hilt_AndroidEntryPointBaseClassTest_LLL {}
|
|
|
|
@AndroidEntryPoint(LS.class)
|
|
public static final class LLS extends Hilt_AndroidEntryPointBaseClassTest_LLS {}
|
|
|
|
@AndroidEntryPoint(SL.class)
|
|
public static final class LSL extends Hilt_AndroidEntryPointBaseClassTest_LSL {}
|
|
|
|
@AndroidEntryPoint(SS.class)
|
|
public static final class LSS extends Hilt_AndroidEntryPointBaseClassTest_LSS {}
|
|
|
|
@AndroidEntryPoint
|
|
public static final class SLL extends LL {}
|
|
|
|
@AndroidEntryPoint
|
|
public static final class SLS extends LS {}
|
|
|
|
@AndroidEntryPoint
|
|
public static final class SSL extends SL {}
|
|
|
|
@AndroidEntryPoint
|
|
public static final class SSS extends SS {}
|
|
|
|
@AndroidEntryPoint(L.class)
|
|
public static class LL extends Hilt_AndroidEntryPointBaseClassTest_LL {}
|
|
|
|
@AndroidEntryPoint(S.class)
|
|
public static class LS extends Hilt_AndroidEntryPointBaseClassTest_LS {}
|
|
|
|
@AndroidEntryPoint
|
|
public static class SL extends L {}
|
|
|
|
@AndroidEntryPoint
|
|
public static class SS extends S {}
|
|
|
|
@AndroidEntryPoint(ComponentActivity.class)
|
|
public static class L extends Hilt_AndroidEntryPointBaseClassTest_L {}
|
|
|
|
@AndroidEntryPoint
|
|
public static class S extends ComponentActivity {}
|
|
|
|
@Test
|
|
public void checkGeneratedClassHierarchy_shortForm() throws Exception {
|
|
// When using the short form notation, the generated top level class is not actually assignable
|
|
// to the generated base classes at compile time
|
|
assertIsNotAssignableTo(
|
|
Hilt_AndroidEntryPointBaseClassTest_SSS.class,
|
|
Hilt_AndroidEntryPointBaseClassTest_S.class);
|
|
assertIsNotAssignableTo(
|
|
Hilt_AndroidEntryPointBaseClassTest_SS.class,
|
|
Hilt_AndroidEntryPointBaseClassTest_S.class);
|
|
}
|
|
|
|
@Test
|
|
public void checkGeneratedClassHierarchy_longForm() throws Exception {
|
|
// When using the long form notation, they are assignable at compile time
|
|
assertIsAssignableTo(
|
|
Hilt_AndroidEntryPointBaseClassTest_LLL.class,
|
|
Hilt_AndroidEntryPointBaseClassTest_LL.class);
|
|
assertIsAssignableTo(
|
|
Hilt_AndroidEntryPointBaseClassTest_LL.class,
|
|
Hilt_AndroidEntryPointBaseClassTest_L.class);
|
|
}
|
|
|
|
@Test
|
|
public void checkGeneratedClassHierarchy_shortFormRoot() throws Exception {
|
|
// If the root is short-form, then the child class cannot be assigned to it.
|
|
assertIsNotAssignableTo(
|
|
Hilt_AndroidEntryPointBaseClassTest_LLS.class,
|
|
Hilt_AndroidEntryPointBaseClassTest_S.class);
|
|
assertIsNotAssignableTo(
|
|
Hilt_AndroidEntryPointBaseClassTest_LS.class,
|
|
Hilt_AndroidEntryPointBaseClassTest_S.class);
|
|
}
|
|
|
|
@Test
|
|
public void checkGeneratedClassHierarchy_longFormRoot() throws Exception {
|
|
// If the root is long-form, then the child class can be assigned to it.
|
|
assertIsAssignableTo(
|
|
Hilt_AndroidEntryPointBaseClassTest_SSL.class,
|
|
Hilt_AndroidEntryPointBaseClassTest_L.class);
|
|
assertIsAssignableTo(
|
|
Hilt_AndroidEntryPointBaseClassTest_SL.class,
|
|
Hilt_AndroidEntryPointBaseClassTest_L.class);
|
|
}
|
|
|
|
/** Asserts that the {@code class1} is not assignable to the {@code class2}. */
|
|
private static void assertIsNotAssignableTo(Class<?> class1, Class<?> class2) {
|
|
assertThat(class2.isAssignableFrom(class1)).isFalse();
|
|
}
|
|
|
|
/** Asserts that the {@code class1} is assignable to the {@code class2}. */
|
|
private static void assertIsAssignableTo(Class<?> class1, Class<?> class2) {
|
|
assertThat(class1).isAssignableTo(class2);
|
|
}
|
|
}
|