You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
266 lines
10 KiB
266 lines
10 KiB
/*
|
|
* 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.functional.assisted;
|
|
|
|
import static com.google.common.truth.Truth.assertThat;
|
|
|
|
import dagger.Component;
|
|
import dagger.assisted.Assisted;
|
|
import dagger.assisted.AssistedFactory;
|
|
import dagger.assisted.AssistedInject;
|
|
import javax.inject.Inject;
|
|
import javax.inject.Provider;
|
|
import javax.inject.Singleton;
|
|
import org.junit.Test;
|
|
import org.junit.runner.RunWith;
|
|
import org.junit.runners.JUnit4;
|
|
|
|
@RunWith(JUnit4.class)
|
|
public final class AssistedFactoryParameterizedTest {
|
|
@Singleton
|
|
@Component
|
|
interface ParentComponent {
|
|
// Tests a parameterized Factory with unique @Assisted types
|
|
ParameterizedFooFactory<Dep2, AssistedDep2> uniqueParameterizedFooFactory();
|
|
|
|
// Tests a parameterized Factory with duplicate @Assisted types in its resolved request type.
|
|
// Note: this is fine since the @Assisted types are still unique on the @AssistedInject and
|
|
// @AssistedFactory types, so that the generated code can correctly matches types.
|
|
ParameterizedFooFactory<Dep1, AssistedDep1> dupeParameterizedFooFactory();
|
|
|
|
// Tests a parameterized Factory with same type as binding
|
|
ParameterizedFooFactory<Dep1, Dep1> bindingParameterizedFooFactory();
|
|
|
|
// Tests a parameterized Factory with fixed type parameters
|
|
FixedParameterizedFooFactory fixedParameterizedFooFactory();
|
|
|
|
// Tests a parameterized Factory that extends an interface with a parameterized return type
|
|
ExtendedFooFactory<Dep2, AssistedDep2> extendedParameterizedFooFactory();
|
|
|
|
// Tests a request of factories from another binding.
|
|
SomeEntryPoint someEntryPoint();
|
|
}
|
|
|
|
static final class Dep1 {
|
|
@Inject
|
|
Dep1(Dep2 dep2, Dep3 dep3) {}
|
|
}
|
|
|
|
static final class Dep2 {
|
|
@Inject
|
|
Dep2(Dep3 dep3) {}
|
|
}
|
|
|
|
static final class Dep3 {
|
|
@Inject
|
|
Dep3(Dep4 dep4) {}
|
|
}
|
|
|
|
static final class Dep4 {
|
|
@Inject
|
|
Dep4() {}
|
|
}
|
|
|
|
// A base interface to test that factories can reference subclasses of the assisted parameter.
|
|
interface AssistedDep {}
|
|
|
|
static final class AssistedDep1 implements AssistedDep {}
|
|
|
|
static final class AssistedDep2 implements AssistedDep {}
|
|
|
|
abstract static class BaseFoo {
|
|
@Inject Dep4 dep4;
|
|
}
|
|
|
|
static final class ParameterizedFoo<DepT, AssistedDepT> extends BaseFoo {
|
|
private final Dep1 dep1;
|
|
private final Provider<DepT> depTProvider;
|
|
private final AssistedDep1 assistedDep1;
|
|
private final AssistedDepT assistedDepT;
|
|
private final int assistedInt;
|
|
private final ParameterizedFooFactory<DepT, AssistedDepT> factory;
|
|
|
|
@Inject Dep3 dep3;
|
|
|
|
@AssistedInject
|
|
ParameterizedFoo(
|
|
Dep1 dep1,
|
|
@Assisted AssistedDep1 assistedDep1,
|
|
Provider<DepT> depTProvider,
|
|
@Assisted AssistedDepT assistedDepT,
|
|
@Assisted int assistedInt,
|
|
ParameterizedFooFactory<DepT, AssistedDepT> factory) {
|
|
this.dep1 = dep1;
|
|
this.depTProvider = depTProvider;
|
|
this.assistedDep1 = assistedDep1;
|
|
this.assistedDepT = assistedDepT;
|
|
this.assistedInt = assistedInt;
|
|
this.factory = factory;
|
|
}
|
|
}
|
|
|
|
@AssistedFactory
|
|
interface ParameterizedFooFactory<DepT, AssistedDepT> {
|
|
ParameterizedFoo<DepT, AssistedDepT> create(
|
|
AssistedDep1 assistedDep1, AssistedDepT assistedDepT, int assistedInt);
|
|
}
|
|
|
|
@Test
|
|
public void testUniqueParameterizedFooFactory() {
|
|
AssistedDep1 assistedDep1 = new AssistedDep1();
|
|
AssistedDep2 assistedDep2 = new AssistedDep2();
|
|
int assistedInt = 7;
|
|
ParameterizedFoo<Dep2, AssistedDep2> parameterizedFoo =
|
|
DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
|
|
.uniqueParameterizedFooFactory()
|
|
.create(assistedDep1, assistedDep2, assistedInt);
|
|
assertThat(parameterizedFoo.dep1).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
|
|
assertThat(parameterizedFoo.dep3).isNotNull();
|
|
assertThat(parameterizedFoo.dep4).isNotNull();
|
|
assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
|
|
assertThat(parameterizedFoo.assistedDepT).isEqualTo(assistedDep2);
|
|
assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
|
|
assertThat(parameterizedFoo.factory).isNotNull();
|
|
}
|
|
|
|
@Test
|
|
public void testDupeParameterizedFooFactory() {
|
|
AssistedDep1 assistedDep1 = new AssistedDep1();
|
|
int assistedInt = 7;
|
|
ParameterizedFoo<Dep1, AssistedDep1> parameterizedFoo =
|
|
DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
|
|
.dupeParameterizedFooFactory()
|
|
.create(assistedDep1, assistedDep1, assistedInt);
|
|
assertThat(parameterizedFoo.dep1).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
|
|
assertThat(parameterizedFoo.dep3).isNotNull();
|
|
assertThat(parameterizedFoo.dep4).isNotNull();
|
|
assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
|
|
assertThat(parameterizedFoo.assistedDepT).isEqualTo(assistedDep1);
|
|
assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
|
|
assertThat(parameterizedFoo.factory).isNotNull();
|
|
}
|
|
|
|
@Test
|
|
public void testBindingParameterizedFooFactory() {
|
|
AssistedDep1 assistedDep1 = new AssistedDep1();
|
|
Dep1 dep1 = new Dep1(new Dep2(new Dep3(new Dep4())), new Dep3(new Dep4()));
|
|
int assistedInt = 7;
|
|
ParameterizedFoo<Dep1, Dep1> parameterizedFoo =
|
|
DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
|
|
.bindingParameterizedFooFactory()
|
|
.create(assistedDep1, dep1, assistedInt);
|
|
assertThat(parameterizedFoo.dep1).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
|
|
assertThat(parameterizedFoo.dep3).isNotNull();
|
|
assertThat(parameterizedFoo.dep4).isNotNull();
|
|
assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
|
|
assertThat(parameterizedFoo.assistedDepT).isEqualTo(dep1);
|
|
assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
|
|
assertThat(parameterizedFoo.factory).isNotNull();
|
|
}
|
|
|
|
@AssistedFactory
|
|
interface FixedParameterizedFooFactory {
|
|
ParameterizedFoo<Dep2, AssistedDep2> create(
|
|
AssistedDep1 assistedDep1, AssistedDep2 assistedDep2, int assistedInt);
|
|
}
|
|
|
|
@Test
|
|
public void testFixedParameterizedFooFactory() {
|
|
AssistedDep1 assistedDep1 = new AssistedDep1();
|
|
AssistedDep2 assistedDep2 = new AssistedDep2();
|
|
int assistedInt = 7;
|
|
ParameterizedFoo<Dep2, AssistedDep2> parameterizedFoo =
|
|
DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
|
|
.fixedParameterizedFooFactory()
|
|
.create(assistedDep1, assistedDep2, assistedInt);
|
|
assertThat(parameterizedFoo.dep1).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
|
|
assertThat(parameterizedFoo.dep3).isNotNull();
|
|
assertThat(parameterizedFoo.dep4).isNotNull();
|
|
assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
|
|
assertThat(parameterizedFoo.assistedDepT).isEqualTo(assistedDep2);
|
|
assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
|
|
assertThat(parameterizedFoo.factory).isNotNull();
|
|
}
|
|
|
|
interface ParameterizedFactory<ReturnT, DepT, AssistedDepT> {
|
|
// Use different parameter names than Foo to make sure we're not assuming they're the same.
|
|
ReturnT create(
|
|
AssistedDep1 factoryAssistedDep1, AssistedDepT factoryAssistedDepT, int factoryAssistedInt);
|
|
}
|
|
|
|
@AssistedFactory
|
|
interface ExtendedFooFactory<DepT, AssistedDepT>
|
|
extends ParameterizedFactory<ParameterizedFoo<DepT, AssistedDepT>, DepT, AssistedDepT> {}
|
|
|
|
@Test
|
|
public void testExtendedFooFactory() {
|
|
AssistedDep1 assistedDep1 = new AssistedDep1();
|
|
AssistedDep2 assistedDep2 = new AssistedDep2();
|
|
int assistedInt = 7;
|
|
ParameterizedFoo<Dep2, AssistedDep2> parameterizedFoo =
|
|
DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
|
|
.extendedParameterizedFooFactory()
|
|
.create(assistedDep1, assistedDep2, assistedInt);
|
|
assertThat(parameterizedFoo.dep1).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
|
|
assertThat(parameterizedFoo.dep3).isNotNull();
|
|
assertThat(parameterizedFoo.dep4).isNotNull();
|
|
assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
|
|
assertThat(parameterizedFoo.assistedDepT).isEqualTo(assistedDep2);
|
|
assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
|
|
assertThat(parameterizedFoo.factory).isNotNull();
|
|
}
|
|
|
|
static class SomeEntryPoint {
|
|
private final ParameterizedFooFactory<Dep1, AssistedDep1> dupeParameterizedFooFactory;
|
|
|
|
@Inject
|
|
SomeEntryPoint(ParameterizedFooFactory<Dep1, AssistedDep1> dupeParameterizedFooFactory) {
|
|
this.dupeParameterizedFooFactory = dupeParameterizedFooFactory;
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testParameterizedFooFactoryFromSomeEntryPoint() {
|
|
AssistedDep1 assistedDep1 = new AssistedDep1();
|
|
int assistedInt = 7;
|
|
ParameterizedFoo<Dep1, AssistedDep1> parameterizedFoo =
|
|
DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
|
|
.someEntryPoint()
|
|
.dupeParameterizedFooFactory
|
|
.create(assistedDep1, assistedDep1, assistedInt);
|
|
assertThat(parameterizedFoo.dep1).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider).isNotNull();
|
|
assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
|
|
assertThat(parameterizedFoo.dep3).isNotNull();
|
|
assertThat(parameterizedFoo.dep4).isNotNull();
|
|
assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
|
|
assertThat(parameterizedFoo.assistedDepT).isEqualTo(assistedDep1);
|
|
assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
|
|
assertThat(parameterizedFoo.factory).isNotNull();
|
|
}
|
|
}
|