Home | History | Annotate | Download | only in test
      1 /*
      2  * Copyright (C) 2015 Google, Inc.
      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 package test;
     17 
     18 import dagger.Lazy;
     19 import dagger.MembersInjector;
     20 import javax.inject.Inject;
     21 import javax.inject.Provider;
     22 
     23 @SuppressWarnings("unused")
     24 final class InjectedThing {
     25   @Inject byte primitiveByte;
     26   @Inject char primitiveChar;
     27   @Inject short primitiveShort;
     28   @Inject int primitiveInt;
     29   @Inject long primitiveLong;
     30   @Inject boolean primitiveBoolean;
     31   @Inject float primitiveFloat;
     32   @Inject double primitiveDouble;
     33 
     34   @Inject Provider<Byte> byteProvider;
     35   @Inject Provider<Character> charProvider;
     36   @Inject Provider<Short> shortProvider;
     37   @Inject Provider<Integer> intProvider;
     38   @Inject Provider<Long> longProvider;
     39   @Inject Provider<Boolean> booleanProvider;
     40   @Inject Provider<Float> floatProvider;
     41   @Inject Provider<Double> doubleProvider;
     42 
     43   @Inject Lazy<Byte> lazyByte;
     44   @Inject Lazy<Character> lazyChar;
     45   @Inject Lazy<Short> lazyShort;
     46   @Inject Lazy<Integer> lazyInt;
     47   @Inject Lazy<Long> lazyLong;
     48   @Inject Lazy<Boolean> lazyBoolean;
     49   @Inject Lazy<Float> lazyFloat;
     50   @Inject Lazy<Double> lazyDouble;
     51 
     52   @Inject Byte boxedBype;
     53   @Inject Character boxedChar;
     54   @Inject Short boxedShort;
     55   @Inject Integer boxedInt;
     56   @Inject Long boxedLong;
     57   @Inject Boolean boxedBoolean;
     58   @Inject Float boxedFloat;
     59   @Inject Double boxedDouble;
     60 
     61   @Inject byte[] byteArray;
     62   @Inject char[] charArray;
     63   @Inject short[] shortArray;
     64   @Inject int[] intArray;
     65   @Inject long[] longArray;
     66   @Inject boolean[] booleanArray;
     67   @Inject float[] floatArray;
     68   @Inject double[] doubleArray;
     69 
     70   @Inject Provider<byte[]> byteArrayProvider;
     71   @Inject Provider<char[]> charArrayProvider;
     72   @Inject Provider<short[]> shortArrayProvider;
     73   @Inject Provider<int[]> intArrayProvider;
     74   @Inject Provider<long[]> longArrayProvider;
     75   @Inject Provider<boolean[]> booleanArrayProvider;
     76   @Inject Provider<float[]> floatArrayProvider;
     77   @Inject Provider<double[]> doubleArrayProvider;
     78 
     79   @Inject Lazy<byte[]> lazyByteArray;
     80   @Inject Lazy<char[]> lazyCharArray;
     81   @Inject Lazy<short[]> lazyShortArray;
     82   @Inject Lazy<int[]> lazyIntArray;
     83   @Inject Lazy<long[]> lazyLongArray;
     84   @Inject Lazy<boolean[]> lazyBooleanArray;
     85   @Inject Lazy<float[]> lazy;
     86   @Inject Lazy<double[]> lazyDoubleArray;
     87 
     88   @Inject Thing thing;
     89   @Inject Provider<Thing> thingProvider;
     90   @Inject Lazy<Thing> lazyThing;
     91   @Inject MembersInjector<Thing> thingMembersInjector;
     92 
     93   @Inject InjectedThing(
     94       byte primitiveByte,
     95       char primitiveChar,
     96       short primitiveShort,
     97       int primitiveInt,
     98       long primitiveLong,
     99       boolean primitiveBoolean,
    100       float primitiveFloat,
    101       double primitiveDouble,
    102 
    103       Provider<Byte> byteProvider,
    104       Provider<Character> charProvider,
    105       Provider<Short> shortProvider,
    106       Provider<Integer> intProvider,
    107       Provider<Long> longProvider,
    108       Provider<Boolean> booleanProvider,
    109       Provider<Float> floatProvider,
    110       Provider<Double> doubleProvider,
    111 
    112       Lazy<Byte> lazyByte,
    113       Lazy<Character> lazyChar,
    114       Lazy<Short> lazyShort,
    115       Lazy<Integer> lazyInt,
    116       Lazy<Long> lazyLong,
    117       Lazy<Boolean> lazyBoolean,
    118       Lazy<Float> lazyFloat,
    119       Lazy<Double> lazyDouble,
    120 
    121       Byte boxedBype,
    122       Character boxedChar,
    123       Short boxedShort,
    124       Integer boxedInt,
    125       Long boxedLong,
    126       Boolean boxedBoolean,
    127       Float boxedFloat,
    128       Double boxedDouble,
    129 
    130       byte[] byteArray,
    131       char[] charArray,
    132       short[] shortArray,
    133       int[] intArray,
    134       long[] longArray,
    135       boolean[] booleanArray,
    136       float[] floatArray,
    137       double[] doubleArray,
    138 
    139       Provider<byte[]> byteArrayProvider,
    140       Provider<char[]> charArrayProvider,
    141       Provider<short[]> shortArrayProvider,
    142       Provider<int[]> intArrayProvider,
    143       Provider<long[]> longArrayProvider,
    144       Provider<boolean[]> booleanArrayProvider,
    145       Provider<float[]> floatArrayProvider,
    146       Provider<double[]> doubleArrayProvider,
    147 
    148       Lazy<byte[]> lazyByteArray,
    149       Lazy<char[]> lazyCharArray,
    150       Lazy<short[]> lazyShortArray,
    151       Lazy<int[]> lazyIntArray,
    152       Lazy<long[]> lazyLongArray,
    153       Lazy<boolean[]> lazyBooleanArray,
    154       Lazy<float[]> lazy,
    155       Lazy<double[]> lazyDoubleArray,
    156 
    157       Thing thing,
    158       Provider<Thing> thingProvider,
    159       Lazy<Thing> lazyThing,
    160       MembersInjector<Thing> thingMembersInjector) {}
    161 
    162   @Inject void primitiveByte(byte primitiveByte) {}
    163   @Inject void primitiveChar(char primitiveChar) {}
    164   @Inject void primitiveShort(short primitiveShort) {}
    165   @Inject void primitiveInt(int primitiveInt) {}
    166   @Inject void primitiveLong(long primitiveLong) {}
    167   @Inject void primitiveBoolean(boolean primitiveBoolean) {}
    168   @Inject void primitiveFloat(float primitiveFloat) {}
    169   @Inject void primitiveDouble(double primitiveDouble) {}
    170 
    171   @Inject void byteProvider(Provider<Byte> byteProvider) {}
    172   @Inject void charProvider(Provider<Character> charProvider) {}
    173   @Inject void shortProvider(Provider<Short> shortProvider) {}
    174   @Inject void intProvider(Provider<Integer> intProvider) {}
    175   @Inject void longProvider(Provider<Long> longProvider) {}
    176   @Inject void booleanProvider(Provider<Boolean> booleanProvider) {}
    177   @Inject void floatProvider(Provider<Float> floatProvider) {}
    178   @Inject void doubleProvider(Provider<Double> doubleProvider) {}
    179 
    180   @Inject void lazyByte(Lazy<Byte> lazyByte) {}
    181   @Inject void lazyChar(Lazy<Character> lazyChar) {}
    182   @Inject void lazyShort(Lazy<Short> lazyShort) {}
    183   @Inject void lazyInt(Lazy<Integer> lazyInt) {}
    184   @Inject void lazyLong(Lazy<Long> lazyLong) {}
    185   @Inject void lazyBoolean(Lazy<Boolean> lazyBoolean) {}
    186   @Inject void lazyFloat(Lazy<Float> lazyFloat) {}
    187   @Inject void lazyDouble(Lazy<Double> lazyDouble) {}
    188 
    189   @Inject void boxedBype(Byte boxedBype) {}
    190   @Inject void boxedChar(Character boxedChar) {}
    191   @Inject void boxedShort(Short boxedShort) {}
    192   @Inject void boxedInt(Integer boxedInt) {}
    193   @Inject void boxedLong(Long boxedLong) {}
    194   @Inject void boxedBoolean(Boolean boxedBoolean) {}
    195   @Inject void boxedFloat(Float boxedFloat) {}
    196   @Inject void boxedDouble(Double boxedDouble) {}
    197 
    198   @Inject void byteArray(byte[] byteArray) {}
    199   @Inject void charArray(char[] charArray) {}
    200   @Inject void shortArray(short[] shortArray) {}
    201   @Inject void intArray(int[] intArray) {}
    202   @Inject void longArray(long[] longArray) {}
    203   @Inject void booleanArray(boolean[] booleanArray) {}
    204   @Inject void floatArray(float[] floatArray) {}
    205   @Inject void doubleArray(double[] doubleArray) {}
    206 
    207   @Inject void byteArrayProvider(Provider<byte[]> byteArrayProvider) {}
    208   @Inject void charArrayProvider(Provider<char[]> charArrayProvider) {}
    209   @Inject void shortArrayProvider(Provider<short[]> shortArrayProvider) {}
    210   @Inject void intArrayProvider(Provider<int[]> intArrayProvider) {}
    211   @Inject void longArrayProvider(Provider<long[]> longArrayProvider) {}
    212   @Inject void booleanArrayProvider(Provider<boolean[]> booleanArrayProvider) {}
    213   @Inject void floatArrayProvider(Provider<float[]> floatArrayProvider) {}
    214   @Inject void doubleArrayProvider(Provider<double[]> doubleArrayProvider) {}
    215 
    216   @Inject void lazyByteArray(Lazy<byte[]> lazyByteArray) {}
    217   @Inject void lazyCharArray(Lazy<char[]> lazyCharArray) {}
    218   @Inject void lazyShortArray(Lazy<short[]> lazyShortArray) {}
    219   @Inject void lazyIntArray(Lazy<int[]> lazyIntArray) {}
    220   @Inject void lazyLongArray(Lazy<long[]> lazyLongArray) {}
    221   @Inject void lazyBooleanArray(Lazy<boolean[]> lazyBooleanArray) {}
    222   @Inject void lazy(Lazy<float[]> lazy) {}
    223   @Inject void lazyDoubleArray(Lazy<double[]> lazyDoubleArray) {}
    224 
    225   @Inject void thing(Thing thing) {}
    226   @Inject void thingProvider(Provider<Thing> thingProvider) {}
    227   @Inject void lazyThing(Lazy<Thing> lazyThing) {}
    228   @Inject void thingMembersInjector(MembersInjector<Thing> thingMembersInjector) {}
    229 }
    230