1 /* 2 * Copyright (C) 2020 The Dagger Authors. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package dagger.internal.codegen; 18 19 import static com.google.testing.compile.CompilationSubject.assertThat; 20 import static dagger.internal.codegen.Compilers.compilerWithOptions; 21 22 import com.google.common.collect.ImmutableCollection; 23 import com.google.testing.compile.Compilation; 24 import com.google.testing.compile.JavaFileObjects; 25 import javax.tools.JavaFileObject; 26 import org.junit.Test; 27 import org.junit.runner.RunWith; 28 import org.junit.runners.Parameterized; 29 import org.junit.runners.Parameterized.Parameters; 30 31 @RunWith(Parameterized.class) 32 public class AssistedInjectErrorsTest { 33 @Parameters(name = "{0}") parameters()34 public static ImmutableCollection<Object[]> parameters() { 35 return CompilerMode.TEST_PARAMETERS; 36 } 37 38 private final CompilerMode compilerMode; 39 AssistedInjectErrorsTest(CompilerMode compilerMode)40 public AssistedInjectErrorsTest(CompilerMode compilerMode) { 41 this.compilerMode = compilerMode; 42 } 43 44 @Test testAssistedInjectWithDuplicateTypesFails()45 public void testAssistedInjectWithDuplicateTypesFails() { 46 JavaFileObject foo = 47 JavaFileObjects.forSourceLines( 48 "test.Foo", 49 "package test;", 50 "", 51 "import dagger.assisted.Assisted;", 52 "import dagger.assisted.AssistedInject;", 53 "", 54 "class Foo {", 55 " @AssistedInject", 56 " Foo(@Assisted String str1, @Assisted String str2) {}", 57 "}"); 58 59 Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo); 60 assertThat(compilation).failed(); 61 assertThat(compilation).hadErrorCount(1); 62 assertThat(compilation) 63 .hadErrorContaining( 64 "@AssistedInject constructor has duplicate @Assisted type: @Assisted java.lang.String") 65 .inFile(foo) 66 .onLine(8); 67 } 68 69 @Test testAssistedInjectWithDuplicateTypesEmptyQualifierFails()70 public void testAssistedInjectWithDuplicateTypesEmptyQualifierFails() { 71 JavaFileObject foo = 72 JavaFileObjects.forSourceLines( 73 "test.Foo", 74 "package test;", 75 "", 76 "import dagger.assisted.Assisted;", 77 "import dagger.assisted.AssistedInject;", 78 "", 79 "class Foo {", 80 " @AssistedInject", 81 " Foo(@Assisted(\"\") String str1, @Assisted String str2) {}", 82 "}"); 83 84 Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo); 85 assertThat(compilation).failed(); 86 assertThat(compilation).hadErrorCount(1); 87 assertThat(compilation) 88 .hadErrorContaining( 89 "@AssistedInject constructor has duplicate @Assisted type: @Assisted java.lang.String") 90 .inFile(foo) 91 .onLine(8); 92 } 93 94 @Test testAssistedInjectWithDuplicateQualifiedTypesFails()95 public void testAssistedInjectWithDuplicateQualifiedTypesFails() { 96 JavaFileObject foo = 97 JavaFileObjects.forSourceLines( 98 "test.Foo", 99 "package test;", 100 "", 101 "import dagger.assisted.Assisted;", 102 "import dagger.assisted.AssistedInject;", 103 "", 104 "class Foo<T> {", 105 " @AssistedInject", 106 " Foo(@Assisted(\"MyQualfier\") String s1, @Assisted(\"MyQualfier\") String s2) {}", 107 "}"); 108 109 Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo); 110 assertThat(compilation).failed(); 111 assertThat(compilation).hadErrorCount(1); 112 assertThat(compilation) 113 .hadErrorContaining( 114 "@AssistedInject constructor has duplicate @Assisted type: " 115 + "@Assisted(\"MyQualfier\") java.lang.String") 116 .inFile(foo) 117 .onLine(8); 118 } 119 120 @Test testAssistedInjectWithDuplicateGenericTypesFails()121 public void testAssistedInjectWithDuplicateGenericTypesFails() { 122 JavaFileObject foo = 123 JavaFileObjects.forSourceLines( 124 "test.Foo", 125 "package test;", 126 "", 127 "import dagger.assisted.Assisted;", 128 "import dagger.assisted.AssistedInject;", 129 "import java.util.List;", 130 "", 131 "class Foo {", 132 " @AssistedInject", 133 " Foo(@Assisted List<String> list1, @Assisted List<String> list2) {}", 134 "}"); 135 136 Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo); 137 assertThat(compilation).failed(); 138 assertThat(compilation).hadErrorCount(1); 139 assertThat(compilation) 140 .hadErrorContaining( 141 "@AssistedInject constructor has duplicate @Assisted type: " 142 + "@Assisted java.util.List<java.lang.String>") 143 .inFile(foo) 144 .onLine(9); 145 } 146 147 @Test testAssistedInjectWithDuplicateParameterizedTypesFails()148 public void testAssistedInjectWithDuplicateParameterizedTypesFails() { 149 JavaFileObject foo = 150 JavaFileObjects.forSourceLines( 151 "test.Foo", 152 "package test;", 153 "", 154 "import dagger.assisted.Assisted;", 155 "import dagger.assisted.AssistedInject;", 156 "", 157 "class Foo<T> {", 158 " @AssistedInject", 159 " Foo(@Assisted T t1, @Assisted T t2) {}", 160 "}"); 161 162 Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo); 163 assertThat(compilation).failed(); 164 assertThat(compilation).hadErrorCount(1); 165 assertThat(compilation) 166 .hadErrorContaining("@AssistedInject constructor has duplicate @Assisted type: @Assisted T") 167 .inFile(foo) 168 .onLine(8); 169 } 170 171 @Test testAssistedInjectWithUniqueParameterizedTypesPasses()172 public void testAssistedInjectWithUniqueParameterizedTypesPasses() { 173 JavaFileObject foo = 174 JavaFileObjects.forSourceLines( 175 "test.Foo", 176 "package test;", 177 "", 178 "import dagger.assisted.Assisted;", 179 "import dagger.assisted.AssistedInject;", 180 "import java.util.List;", 181 "", 182 "class Foo<T1, T2> {", 183 " @AssistedInject", 184 " Foo(@Assisted T1 t1, @Assisted T2 t2) {}", 185 "}"); 186 187 Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo); 188 assertThat(compilation).succeeded(); 189 } 190 191 @Test testAssistedInjectWithUniqueGenericTypesPasses()192 public void testAssistedInjectWithUniqueGenericTypesPasses() { 193 JavaFileObject foo = 194 JavaFileObjects.forSourceLines( 195 "test.Foo", 196 "package test;", 197 "", 198 "import dagger.assisted.Assisted;", 199 "import dagger.assisted.AssistedInject;", 200 "import java.util.List;", 201 "", 202 "class Foo {", 203 " @AssistedInject", 204 " Foo(@Assisted List<String> list1, @Assisted List<Integer> list2) {}", 205 "}"); 206 207 Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo); 208 assertThat(compilation).succeeded(); 209 } 210 211 @Test testAssistedInjectWithUniqueQualifiedTypesPasses()212 public void testAssistedInjectWithUniqueQualifiedTypesPasses() { 213 JavaFileObject foo = 214 JavaFileObjects.forSourceLines( 215 "test.Foo", 216 "package test;", 217 "", 218 "import dagger.assisted.Assisted;", 219 "import dagger.assisted.AssistedInject;", 220 "import java.util.List;", 221 "", 222 "class Foo {", 223 " @AssistedInject", 224 " Foo(", 225 " @Assisted(\"1\") Integer i1,", 226 " @Assisted(\"1\") String s1,", 227 " @Assisted(\"2\") String s2,", 228 " @Assisted String s3) {}", 229 "}"); 230 231 Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo); 232 assertThat(compilation).succeeded(); 233 } 234 } 235