Java 类com.google.inject.util.Types 实例源码

@Override
public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException
{
    ConfigDescriptor desc = descLookupByAttributeName.get(attribute.getName());
    if (desc == null) {
        log.warn("Attribute Set name={} value={} requested on MXBean {}, but no matching configDescriptor found.",
            attribute.getName(), attribute.getValue(), mbeanName);
        throw new AttributeNotFoundException();
    }

    // get appropriate config value converter and test the conversion for immediate error feedback
    ConfigValueConverter<?> converter = (ConfigValueConverter<?>) this.injectorRef.get().getInstance(Key.get(Types.newParameterizedType(ConfigValueConverter.class, desc.getConfigType())));
    String strValue = attribute.getValue() == null ? null : attribute.getValue().toString();
    try {
        converter.apply(strValue);
    }
    catch (Exception ex) {
        log.warn("Attribute Set name={} value={} requested on MXBean {}, but value failed to convert to type {}",
            attribute.getName(), attribute.getValue(), mbeanName, desc.getConfigType().getTypeName());
        throw new InvalidAttributeValueException("Failed to parse value: " + ex.getMessage());
    }

    // emit event
    this.eventSink.fireEvent(desc.getConfigName(), Optional.ofNullable(strValue));
}

public static <C> PrivateModule module(final PropertyIdentifier propertyIdentifier, final ConfigDescriptor desc)
{
    return new PrivateModule()
    {
        @Override
        protected void configure()
        {
            // Alias the private module scoped bindings for the un-annotated ConstantValuePropertyAccessor and PropertyIdentifier to globally scoped and annotated ones.
            // Intent here is to make the implementation of this nice and guicified but support a number of different instances.
            bind(ConstantValuePropertyAccessor.class).to(Key.get(ConstantValuePropertyAccessor.class, propertyIdentifier));
            bind(PropertyIdentifier.class).to(Key.get(PropertyIdentifier.class, propertyIdentifier));

            TypeLiteral<PropertyAccessor<C>> accessorType = (TypeLiteral<PropertyAccessor<C>>) TypeLiteral.get(Types.newParameterizedType(PropertyAccessor.class, desc.getConfigType()));
            bind(Key.get(accessorType, propertyIdentifier)).to(accessorType).in(Scopes.SINGLETON);
            expose(Key.get(accessorType, propertyIdentifier));
        }
    };
}

private ConfigDescriptor internalBuildDescriptor(Method method, Optional<String> scopeOpt, Optional<String> defaultValue)
{
    String configName = namingStrategy.methodToFlatName(method, scopeOpt);

    DefaultValue dv = method.getAnnotation(DefaultValue.class);
    NoDefaultValue ndv = method.getAnnotation(NoDefaultValue.class);
    Class<?> innerClass = null;
    if (dv != null && dv.innerType() != None.class) {
        innerClass = dv.innerType();
    }
    else if (ndv != null && ndv.innerType() != None.class) {
        innerClass = ndv.innerType();
    }

    // Only using the base return type to determine isObservable. Validation is ensuring the other requirements.
    boolean isObservable = Observable.class.isAssignableFrom(method.getReturnType());

    Type configType = innerClass == null
        ? ensureBoxedType(method.getReturnType())
        : Types.newParameterizedType(ensureBoxedType(method.getReturnType()), innerClass);

    return new ConfigDescriptor(method, configName, configType, isObservable, scopeOpt, defaultValue);
}

public <T> Set<T> resolveSet(Class<T> clazz) {
    Injector injector = getInjector();
    try {
        TypeLiteral<Set<T>> lit = (TypeLiteral<Set<T>>) TypeLiteral.get(Types.setOf(clazz));
        Key<Set<T>> key = Key.get(lit);
        Set<T> bindings = injector.getInstance(key);

        if (bindings != null) {
            return bindings;
        }
    }
    catch (Exception e) {

    }

    return new TreeSet<>();
}

public void testResolve() {
    TypeLiteral<?> typeResolver = TypeLiteral.get(StringIntegerMap.class);
    assertEquals(String.class, typeResolver.resolveType(mapK));

    typeResolver = new TypeLiteral<Map<String, Integer>>() {
    };
    assertEquals(String.class, typeResolver.resolveType(mapK));
    assertEquals(Types.mapOf(String.class, Integer.class),
            typeResolver.getSupertype(Map.class).getType());

    typeResolver = new TypeLiteral<BetterMap<String, Integer>>() {
    };
    assertEquals(String.class, typeResolver.resolveType(mapK));

    typeResolver = new TypeLiteral<BestMap<String, Integer>>() {
    };
    assertEquals(String.class, typeResolver.resolveType(mapK));

    typeResolver = TypeLiteral.get(StringIntegerHashMap.class);
    assertEquals(String.class, typeResolver.resolveType(mapK));
    assertEquals(String.class, typeResolver.resolveType(hashMapK));
    assertEquals(entryStringInteger, typeResolver.resolveType(setEntryKV));
    assertEquals(Object.class,
            typeResolver.getSupertype(Object.class).getType());
}

public void testGenericProviderMethods() {
    Injector injector = Guice
            .createInjector(new ProvideTs<String>("A", "B") {
            }, new ProvideTs<Integer>(1, 2) {
            });

    assertEquals("A", injector
            .getInstance(Key.get(String.class, Names.named("First"))));
    assertEquals("B", injector
            .getInstance(Key.get(String.class, Names.named("Second"))));
    assertEquals(ImmutableSet.of("A", "B"),
            injector.getInstance(Key.get(Types.setOf(String.class))));

    assertEquals(1,
            injector.getInstance(
                    Key.get(Integer.class, Names.named("First")))
            .intValue());
    assertEquals(2,
            injector.getInstance(
                    Key.get(Integer.class, Names.named("Second")))
            .intValue());
    assertEquals(ImmutableSet.of(1, 2),
            injector.getInstance(Key.get(Types.setOf(Integer.class))));
}

public void testWithWildcardType()
        throws NoSuchFieldException, IOException {
    TypeLiteral<?> a = TypeLiteral
            .get(getClass().getField("wildcardExtends").getGenericType());
    TypeLiteral<?> b = TypeLiteral
            .get(Types.listOf(Types.subtypeOf(CharSequence.class)));
    TypeLiteral<?> c = new TypeLiteral<List<? extends CharSequence>>() {
    };
    assertEqualsBothWays(a, b);
    assertEqualsBothWays(b, c);
    assertEquals("java.util.List<? extends java.lang.CharSequence>",
            a.toString());
    assertEquals("java.util.List<? extends java.lang.CharSequence>",
            b.toString());
    assertEquals("java.util.List<? extends java.lang.CharSequence>",
            c.toString());
    assertNotSerializable(a);
    assertNotSerializable(b);
    assertNotSerializable(c);
}

@Test
public void testLoadConfiguration_JsonYaml() {

    BQRuntime runtime = testFactory.app("--config=http://127.0.0.1:12025/test1.json",
            "--config=http://127.0.0.1:12025/test1.yml").createRuntime();

    JsonNodeConfigurationFactoryProvider provider = new JsonNodeConfigurationFactoryProvider(
            runtime.getInstance(ConfigurationSource.class), runtime.getInstance(Environment.class),
            runtime.getInstance(JacksonService.class), runtime.getBootLogger(),
               runtime.getInstance(Key.get((TypeLiteral<Set<OptionMetadata>>) TypeLiteral.get(Types.setOf(OptionMetadata.class)))),
            Collections.emptySet(),
               runtime.getInstance(Cli.class));

    JsonNode config = provider.loadConfiguration(Collections.emptyMap(), Collections.emptyMap());
    assertEquals("{\"x\":1,\"a\":\"b\"}", config.toString());
}

public void addGenericBinding(
        final Type genericClass,
        final Class to,
        final Type... genericClassParams)
{
    if (ObjectUtils.anyNull(genericClass, genericClassParams, to))
        throw new NullPointerException();

    this.bindings.add(new BindingAction()
    {
        @Override
        public void bind(Binder b)
        {
            ParameterizedType pt = Types.newParameterizedType(genericClass, genericClassParams);
            Key k = Key.get(TypeLiteral.get(pt));
            b.bind(k).to(to);
        }
    });
}

public void addGenericBinding(
        final Type genericClass,
        final Object to,
        final Type... genericClassParams)
{
    if (ObjectUtils.anyNull(genericClass, genericClassParams, to))
        throw new NullPointerException();

    this.bindings.add(new BindingAction()
    {
        @Override
        public void bind(Binder b)
        {
            ParameterizedType pt = Types.newParameterizedType(genericClass, genericClassParams);
            Key k = Key.get(TypeLiteral.get(pt));
            b.bind(k).toInstance(to);
        }
    });
}

@Override
public List<Node> marshalParameters(Algorithm alg, Document doc) throws UnsupportedAlgorithmException
{
    AlgorithmParametersMarshaller marshaller;
    try
    {
        ParameterizedType pt = Types.newParameterizedType(AlgorithmParametersMarshaller.class, alg.getClass());
        marshaller = (AlgorithmParametersMarshaller) injector.getInstance(Key.get(TypeLiteral.get(pt)));
    } catch (RuntimeException ex)
    {
        throw new UnsupportedAlgorithmException("AlgorithmParametersMarshaller not available", alg.getUri(), ex);
    }

    List<Node> params = marshaller.marshalParameters(alg, doc);
    if (params != null && params.isEmpty())
    {
        throw new IllegalArgumentException(String.format("Parameter marshaller returned empty parameter list for algorithm %s", alg.getUri()));
    }
    return params;
}

/**
 * Returns an type that's appropriate for use in a key.
 *
 * <p>If the raw type of {@code typeLiteral} is a {@code javax.inject.Provider}, this returns a
 * {@code com.google.inject.Provider} with the same type parameters.
 *
 * <p>If the type is a primitive, the corresponding wrapper type will be returned.
 *
 * @throws ConfigurationException if {@code type} contains a type variable
 */
public static <T> TypeLiteral<T> canonicalizeForKey(TypeLiteral<T> typeLiteral) {
  Type type = typeLiteral.getType();
  if (!isFullySpecified(type)) {
    Errors errors = new Errors().keyNotFullySpecified(typeLiteral);
    throw new ConfigurationException(errors.getMessages());
  }

  if (typeLiteral.getRawType() == javax.inject.Provider.class) {
    ParameterizedType parameterizedType = (ParameterizedType) type;

    // the following casts are generally unsafe, but com.google.inject.Provider extends
    // javax.inject.Provider and is covariant
    @SuppressWarnings("unchecked")
    TypeLiteral<T> guiceProviderType = (TypeLiteral<T>) TypeLiteral.get(
        Types.providerOf(parameterizedType.getActualTypeArguments()[0]));
    return guiceProviderType;
  }

  @SuppressWarnings("unchecked")
  TypeLiteral<T> wrappedPrimitives = (TypeLiteral<T>) PRIMITIVE_TO_WRAPPER.get(typeLiteral);
  return wrappedPrimitives != null
      ? wrappedPrimitives
      : typeLiteral;
}

@Before
@SuppressWarnings("unchecked")
public void setUp() {
    when(providerBuilder.build()).thenReturn(provider);

    dependencies = new AbstractModule() {
        @Override
        protected void configure() {
            bind(
                    (Key<ServiceProviderBuilder<Void>>) Key.get(
                            Types.newParameterizedType(ServiceProviderBuilder.class, Void.class), Curator.class))
                    .toInstance(providerBuilder);

        }
    };

    inj = Guice.createInjector(
            dependencies,
            ServiceProviderModuleBuilder.create(Void.class).discovery(Curator.class)
                    .additionalFilter(instanceFilter1).additionalFilter(instanceFilter2)
                    .providerStrategy(providerStrategy).threadFactory(threadFactory)
                    .downInstancePolicy(downInstancePolicy).annotation(Curator.class).name("test").build());
}

@Override
public boolean execute(String name, Object obj, ConfigurationNode node, Class<?> argType, Injector injector, Method method) throws Exception {
    TypeLiteral<ComponentManager<?>> managerLiteral = (TypeLiteral<ComponentManager<?>>) TypeLiteral.get(Types.newParameterizedType(ComponentManager.class, argType));
    Binding<ComponentManager<?>> managerBinding = injector.getExistingBinding(Key.get(managerLiteral));
    if (managerBinding != null) {
        ComponentManager<?> manager = managerBinding.getProvider().get();
        try {
            method.invoke(obj, manager.create(node));
            return true;
        }
        catch (Exception e) {
            throw new Exception(String.format(
                    "Unable to get component '%s' (%s) for property '%s' must be one of %s",
                    name, argType.getSimpleName(), propertyName, manager.getIds()), e);
        }
    }
    return false;    
}

@Test
public void paramToSet() throws ParseException {
  params(new RouteParamCollector().accept(expr("req -> {",
      "req.param(\"p1\").toSet();",
      "req.param(\"p2\").toSet(String.class);",
      "req.param(\"p3\").toSet(apps.model.Pet.class);",
      "}"), ctx()))
  .next(p -> {
    assertEquals("p1", p.name());
    assertEquals(Types.newParameterizedType(Set.class, String.class), p.type());
    assertEquals(null, p.value());
  })
  .next(p -> {
    assertEquals("p2", p.name());
    assertEquals(Types.newParameterizedType(Set.class, String.class), p.type());
    assertEquals(null, p.value());
  })
  .next(p -> {
    assertEquals("p3", p.name());
    assertEquals(Types.newParameterizedType(Set.class, Pet.class), p.type());
    assertEquals(null, p.value());
  });
}

@SuppressWarnings({"unchecked"})
private Key<P> createKey() {
  TypeLiteral<P> typeLiteral;
  if (interfaceType.getTypeParameters().length == 1) {
    ParameterizedType type = Types.newParameterizedTypeWithOwner(
        interfaceType.getEnclosingClass(), interfaceType, valueType);
    typeLiteral = (TypeLiteral<P>) TypeLiteral.get(type);
  } else {
    typeLiteral = TypeLiteral.get(interfaceType);
  }

  if (annotation != null) {
    return Key.get(typeLiteral, annotation);

  } else if (annotationType != null) {
    return Key.get(typeLiteral, annotationType);

  } else {
    return Key.get(typeLiteral);
  }
}

@Test
public void onListPojoMessage() throws Exception {
  Pojo pojo = new Pojo();
  new MockUnit(WebSocket.class, Injector.class, PojoListSocket.class, Binder.class, Mutant.class)
      .expect(childInjector(PojoListSocket.class))
      .expect(mutant(TypeLiteral.get(Types.listOf(Pojo.class)), ImmutableList.of(pojo)))
      .expect(unit -> {
        PojoListSocket socket = unit.get(PojoListSocket.class);
        socket.onMessage(ImmutableList.of(pojo));
      })
      .run(unit -> {
        new MvcWebSocket(unit.get(WebSocket.class), PojoListSocket.class)
            .onMessage(unit.get(Mutant.class));
      }, unit -> {
        unit.captured(Module.class).iterator().next().configure(unit.get(Binder.class));
      });
}

@SuppressWarnings("rawtypes")
private static List<TypeLiteral> cacheType(final String name, final Object cache,
    final Type superclass) {
  Class[] ctypes;
  if (cache instanceof AsyncLoadingCache) {
    ctypes = new Class[]{AsyncLoadingCache.class };
  } else if (cache instanceof LoadingCache) {
    ctypes = new Class[]{LoadingCache.class, Cache.class };
  } else {
    ctypes = new Class[]{Cache.class };
  }
  List<TypeLiteral> result = new ArrayList<>(ctypes.length);
  for (Class ctype : ctypes) {
    if (name.equals("session")) {
      result.add(TypeLiteral.get(Types.newParameterizedType(ctype, String.class, Session.class)));
    } else {
      result.add(TypeLiteral.get(Types.newParameterizedType(ctype, types(superclass))));
    }
  }
  return result;
}

@Test
public void getInstance_NodeContainerWithAnnotation_PropertyOverrideSetBefore_ReturnsPropertyOverrideNodeContainer() {

    PropertyReader.setProperties(ImmutableMap.of("foo", "foo"));

    Module module = NodeContainerModuleBuilder.create(String.class).annotation(Curator.class)
            .mapper(StringUTF8ByteArrayMapper.class).overrideProperty("foo").path("/dev/test").build();
    injector = Guice.createInjector(Stage.PRODUCTION, new AbstractModule() {
        @Override
        protected void configure() {
            bind(CuratorFramework.class).annotatedWith(Curator.class).toInstance(framework);
        }
    }, module);

    assertTrue(injector.getInstance(Key.get(Types.newParameterizedType(NodeContainer.class, String.class),
            Curator.class)) instanceof PropertyOverrideNodeContainer);
}

@Test
@SuppressWarnings("unchecked")
public void createInjector_ServiceProviderBuilderBound_Succeeds() {

    Guice.createInjector(
            new AbstractModule() {
                @Override
                protected void configure() {
                    bind(
                            (Key<ServiceProviderBuilder<Void>>) Key.get(
                                    Types.newParameterizedType(ServiceProviderBuilder.class, Void.class),
                                    Curator.class)).toInstance(providerBuilder);

                }
            },
            ServiceProviderModuleBuilder.create(Void.class).discovery(Curator.class).annotation(Curator.class)
                    .name("test").build());
}

@Test
public void createInjector_DiscoveryDefinedAndScheduleDefinedSansExecutor_ReturnsNotNull() {

    assertNotNull(Guice.createInjector(
            RegistrationServiceModuleBuilder.create().targetAnnotation(Cultivar.class)
                    .discoveryAnnotation(Cultivar.class).provider(new ServiceInstanceProvider())
                    .updating(10, TimeUnit.SECONDS).build(), new AbstractModule() {
                @Override
                protected void configure() {
                    bind(
                            (Key<ServiceDiscovery<Void>>) Key.get(
                                    Types.newParameterizedType(ServiceDiscovery.class, Void.class),
                                    Cultivar.class)).toInstance(discovery);
                }
            }));
}

public void testResolve() {
  TypeLiteral<?> typeResolver = TypeLiteral.get(StringIntegerMap.class);
  assertEquals(String.class, typeResolver.resolveType(mapK));

  typeResolver = new TypeLiteral<Map<String, Integer>>() {};
  assertEquals(String.class, typeResolver.resolveType(mapK));
  assertEquals(
      Types.mapOf(String.class, Integer.class), typeResolver.getSupertype(Map.class).getType());

  typeResolver = new TypeLiteral<BetterMap<String, Integer>>() {};
  assertEquals(String.class, typeResolver.resolveType(mapK));

  typeResolver = new TypeLiteral<BestMap<String, Integer>>() {};
  assertEquals(String.class, typeResolver.resolveType(mapK));

  typeResolver = TypeLiteral.get(StringIntegerHashMap.class);
  assertEquals(String.class, typeResolver.resolveType(mapK));
  assertEquals(String.class, typeResolver.resolveType(hashMapK));
  assertEquals(entryStringInteger, typeResolver.resolveType(setEntryKV));
  assertEquals(Object.class, typeResolver.getSupertype(Object.class).getType());
}

public void testParentBindingToPrivateLinkedJitBinding() {
  Injector injector = Guice.createInjector(new ManyPrivateModules());
  try {
    injector.getBinding(Key.get(Types.providerOf(List.class)));
    fail();
  } catch (ConfigurationException expected) {
    assertEquals(1, expected.getErrorMessages().size());
    assertContains(
        expected.toString(),
        "Unable to create binding for com.google.inject.Provider<java.util.List>.",
        "It was already configured on one or more child injectors or private modules",
        "bound at " + FailingPrivateModule.class.getName() + ".configure(",
        asModuleChain(ManyPrivateModules.class, FailingPrivateModule.class),
        "bound at " + SecondFailingPrivateModule.class.getName() + ".configure(",
        asModuleChain(ManyPrivateModules.class, SecondFailingPrivateModule.class),
        "If it was in a PrivateModule, did you forget to expose the binding?",
        "while locating com.google.inject.Provider<java.util.List>");
  }
}

public void testParentBindingToPrivateLinkedJitBinding() {
  Injector injector = Guice.createInjector(new ManyPrivateModules());
  try {
    injector.getBinding(Key.get(Types.providerOf(List.class)));
    fail();
  } catch(ConfigurationException expected) {
    assertEquals(1, expected.getErrorMessages().size());
    assertContains(expected.toString(),
        "Unable to create binding for com.google.inject.Provider<java.util.List>.",
        "It was already configured on one or more child injectors or private modules",
        "bound at " + FailingPrivateModule.class.getName() + ".configure(",
        asModuleChain(ManyPrivateModules.class, FailingPrivateModule.class),
        "bound at " + SecondFailingPrivateModule.class.getName() + ".configure(",
        asModuleChain(ManyPrivateModules.class, SecondFailingPrivateModule.class),
        "If it was in a PrivateModule, did you forget to expose the binding?",
        "while locating com.google.inject.Provider<java.util.List>");
  }
}

@Test
public void paramToList() throws ParseException {
  params(new RouteParamCollector().accept(expr("req -> {",
      "req.param(\"p1\").toList();",
      "req.param(\"p2\").toList(Integer.class);",
      "req.param(\"p3\").toList(apps.model.Pet.class);",
      "}"), ctx()))
  .next(p -> {
    assertEquals("p1", p.name());
    assertEquals(Types.newParameterizedType(List.class, String.class), p.type());
    assertEquals(null, p.value());
  })
  .next(p -> {
    assertEquals("p2", p.name());
    assertEquals(Types.newParameterizedType(List.class, Integer.class), p.type());
    assertEquals(null, p.value());
  })
  .next(p -> {
    assertEquals("p3", p.name());
    assertEquals(Types.newParameterizedType(List.class, Pet.class), p.type());
    assertEquals(null, p.value());
  });
}

@Before
@SuppressWarnings("unchecked")
public void setUp() {
    when(providerBuilder.build()).thenReturn(provider);

    dependencies = new AbstractModule() {
        @Override
        protected void configure() {
            bind(
                    (Key<ServiceProviderBuilder<Void>>) Key.get(
                            Types.newParameterizedType(ServiceProviderBuilder.class, Void.class), Curator.class))
                    .toInstance(providerBuilder);

        }
    };

    inj = Guice.createInjector(
            dependencies,
            ServiceProviderModuleBuilder.create(Void.class).discovery(Curator.class)
                    .additionalFilter(instanceFilter1).additionalFilter(instanceFilter2)
                    .providerStrategy(providerStrategy).threadFactory(threadFactory)
                    .downInstancePolicy(downInstancePolicy).annotation(Curator.class).name("test").build());
}

public static Optional<Type> parse(final Node node, final Context ctx, final String text) {
  Matcher matcher = TYPE.matcher(text);
  Type type = null;
  while (matcher.find()) {
    String link = matcher.group(1).trim();
    String stype = link.split("\\s+")[0];
    Optional<Type> resolvedType = ctx.resolveType(node, stype);
    if (resolvedType.isPresent()) {
      Type ittype = resolvedType.get();
      if (type != null) {
        type = Types.newParameterizedType(type, ittype);
      } else {
        type = ittype;
      }
    }
  }
  return Optional.ofNullable(type);
}

@SuppressWarnings("unchecked")
public Module build() {
    checkState(provider != null, "Provider must be provided.");
    checkState(targetAnnotation != null, "Target annotation must be set.");

    return new AbstractModule() {
        @Override
        protected void configure() {
            Key<ServiceProvider<T>> target = (Key<ServiceProvider<T>>) targetAnnotation.generateKey(Types
                    .newParameterizedType(ServiceProvider.class, payloadClass));

            Key<ServiceProviderManager<T>> manager = (Key<ServiceProviderManager<T>>) targetAnnotation
                    .generateKey(Types.newParameterizedType(ServiceProviderManager.class, payloadClass));

            bind(target).toInstance(provider);
            bind(manager).to(
                    (Key<ServiceProviderManager<T>>) Key.get(Types.newParameterizedType(
                            ControllableServiceProviderManager.class, payloadClass))).in(Singleton.class);
        }
    };
}

@Test
public void createInjector_DiscoveryDefinedAndScheduleDefinedWithExecutor_ReturnsNotNull() {

    assertNotNull(Guice.createInjector(
            RegistrationServiceModuleBuilder.create().targetAnnotation(Cultivar.class)
                    .discoveryAnnotation(Cultivar.class).provider(new ServiceInstanceProvider())
                    .updating(10, TimeUnit.SECONDS, new ScheduledThreadPoolExecutor(1)).build(),
            new AbstractModule() {
                @Override
                protected void configure() {
                    bind(
                            (Key<ServiceDiscovery<Void>>) Key.get(
                                    Types.newParameterizedType(ServiceDiscovery.class, Void.class),
                                    Cultivar.class)).toInstance(discovery);
                }
            }));
}

@SuppressWarnings("nls")
@Override
protected void configure()
{
    bindTracker(Types.newParameterizedType(AttachmentResourceExtension.class, IAttachment.class),
        "attachmentResource", "class").orderByParameter("order");
    bindTracker(AttachmentTreeExtension.class, "attachmentTree", "bean");
    bindTracker(ViewableItemResolverExtension.class, "viewableItemResolver", "bean").setIdParam("id");
}

private static void setupBullshit()
{
    Injector injector = Guice.createInjector(new Module()
    {
        @SuppressWarnings({"unchecked", "nls"})
        @Override
        public void configure(Binder arg0)
        {
            arg0.bind(PluginService.class).toInstance(new FakePluginService());
            ParameterizedType type = Types.newParameterizedType(PluginTracker.class, SectionsConverter.class);
            TrackerProvider<SectionsConverter> trackerProvider = new TrackerProvider<SectionsConverter>(
                "", "", "")
            {
                @Override
                public PluginTracker<SectionsConverter> get()
                {
                    return new FakePluginTracker();
                }
            };

            TypeLiteral<PluginTracker<SectionsConverter>> typeLiteral = (TypeLiteral<PluginTracker<SectionsConverter>>) TypeLiteral
                .get(type);
            LinkedBindingBuilder<PluginTracker<SectionsConverter>> bindingBuilder = arg0.bind(typeLiteral);
            bindingBuilder.toProvider(trackerProvider).in(Scopes.SINGLETON);
        }
    });
    injector.getInstance(Conversion.class);
}

protected <T> TrackerProvider<T> bindTracker(java.lang.reflect.Type typeParam, Annotation annotatedWith,
    String extensionPoint, String beanParameter)
{
    ParameterizedType type = Types.newParameterizedType(PluginTracker.class, typeParam);
    TrackerProvider<T> trackerProvider = new TrackerProvider<T>(getPluginId(), extensionPoint, beanParameter);
    @SuppressWarnings("unchecked")
    TypeLiteral<PluginTracker<T>> typeLiteral = (TypeLiteral<PluginTracker<T>>) TypeLiteral.get(type);
    LinkedBindingBuilder<PluginTracker<T>> bindingBuilder = bind(typeLiteral);
    if( annotatedWith != null )
    {
        bindingBuilder = ((AnnotatedBindingBuilder<PluginTracker<T>>) bindingBuilder).annotatedWith(annotatedWith);
    }
    bindingBuilder.toProvider(trackerProvider).in(Scopes.SINGLETON);
    return trackerProvider;
}

public ConfigDynamicMBean(ConfigEventSink<String> eventSink, Injector injector, List<ConfigDescriptor> configDescriptors)
{
    checkNotNull(eventSink);
    checkNotNull(injector);
    checkNotNull(configDescriptors);
    checkArgument(!configDescriptors.isEmpty());

    this.mbeanName = descToBeanName(configDescriptors.get(0));
    this.eventSink = eventSink;
    this.injectorRef = new WeakReference<>(injector);
    this.providerLookupByAttributeName = Maps.newHashMap();
    this.descLookupByAttributeName = Maps.newHashMap();
    for (ConfigDescriptor desc : configDescriptors) {
        String attrName = desc.getMethod().getName();
        log.trace("MBean {} Found Attribute {}", mbeanName, attrName);

        // Add entry to descriptor lookup map
        this.descLookupByAttributeName.put(attrName, desc);

        // Add entry to provider lookup map
        TypeLiteral<PropertyAccessor<?>> accessorKey = (TypeLiteral<PropertyAccessor<?>>) TypeLiteral.get(Types.newParameterizedType(PropertyAccessor.class, desc.getConfigType()));
        this.providerLookupByAttributeName.put(attrName, injectorRef.get().getProvider(Key.get(accessorKey, ConfigSystem.getIdentifier(desc))));
    }

    MBeanAttributeInfo[] attributeInfos = configDescriptors.stream()
        .sorted(comparing(d -> d.getConfigName()))
        .map(ConfigDynamicMBean::descToAttributeInfo)
        .toArray(MBeanAttributeInfo[]::new);

    String className = configDescriptors.get(0).getMethod().getDeclaringClass().getDeclaringClass().getName();
    this.mbeanInfo = new MBeanInfo(className, "", attributeInfos, null, null, null);
}

/**
 * Validates all static configurations (i.e. strings in your @DefaultValue annotations) which are found in the
 * injector in which ConfigSystem was retrieved from.
 * Intended to be used both in unit tests as well as in the initialization logic of your application immediately
 * after the Guice Injector has been created. It is essentially a sanity check of all static configurations.
 *
 * @throws ConfigException if Guice had issues provisioning property accessors
 */
public void validateStaticConfiguration()
{
    int failedConfigCount = 0;

    if (allConfigDescriptors == null) {
        log.warn("No config descriptors found. If you don't have any configurations installed, this warning can be ignored");
        return;
    }

    for (ConfigDescriptor desc : allConfigDescriptors) {
        try {
            log.trace("Checking static config for property {}, with default value of {}",
                desc.getConfigName(), desc.getDefaultValue());
            PropertyIdentifier propertyId = getIdentifier(desc);
            TypeLiteral<PropertyAccessor<?>> accessorKey =
                (TypeLiteral<PropertyAccessor<?>>) TypeLiteral.get(
                    Types.newParameterizedType(PropertyAccessor.class, desc.getConfigType()));
            Provider<PropertyAccessor<?>> propertyAccessor = injector.getProvider(Key.get(accessorKey, propertyId));

            propertyAccessor.get();
        }
        catch (ProvisionException ex) {
            ++failedConfigCount;
            log.warn("Failed static config check for property {}", desc.getConfigName(), ex);
        }
    }

    if (failedConfigCount > 0) {
        throw new ConfigException("{} of {} configuration values failed static config checks",
            failedConfigCount,
            allConfigDescriptors.size());
    }
}

@Test(timeout = 5000)
public void testStringListConverter_viaMap()
{
    ConfigValueConverter<List<String>> listConverter = (ConfigValueConverter<List<String>>) converterMap.get(TypeLiteral.get(Types.newParameterizedType(List.class, String.class)));
    List<String> result = listConverter.apply("abc,def,123");
    assertNotNull(result);
    assertEquals(3, result.size());
    assertEquals("abc", result.get(0));
    assertEquals("def", result.get(1));
    assertEquals("123", result.get(2));
}

@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
                                                        Retrofit retrofit) {
    if (type.toString().equals(Types.newParameterizedType(List.class, BrowseGithubsShowGithubThing.class).toString())) {
        return new BraqueResponseBodyConverter(BrowseGithubsShowGithubThing.class,
                StringProvisioner.pathBrowseGithubs(),
                new BraqueResponseBodyConverter.BraqueProperty[]{
                        new BraqueProperty("id", StringProvisioner.propId()),
                        new BraqueProperty("stargazers_count", StringProvisioner.propStars()),
                        new BraqueProperty("name", StringProvisioner.propName()),
                        new BraqueProperty("forks_count", StringProvisioner.propForks()),
                        new BraqueProperty("watchers_count", StringProvisioner.propWatchers()),
                        new BraqueProperty("description", StringProvisioner.propDescription())

                }, "items");
    } else if (type.toString().equals(Types.newParameterizedType(List.class, BrowseTVMazesShowTVMazeThing.class).toString())) {
        return new BraqueResponseBodyConverter(BrowseTVMazesShowTVMazeThing.class,
                StringProvisioner.pathBrowseTVMazes(),
                new BraqueResponseBodyConverter.BraqueProperty[]{
                        new BraqueProperty("show.id", StringProvisioner.propId()),
                        new BraqueProperty("show.type", StringProvisioner.propShowType()),
                        new BraqueProperty("show.name", StringProvisioner.propName()),
                        new BraqueProperty("show.summary", StringProvisioner.propDescription())
                });
    } else if (type.toString().equals(Types.newParameterizedType(List.class, BrowseOMDBsShowOMDBThing.class).toString())) {
        return new BraqueResponseBodyConverter(BrowseOMDBsShowOMDBThing.class,
                StringProvisioner.pathBrowseOMDBs(),
                new BraqueResponseBodyConverter.BraqueProperty[]{
                        new BraqueProperty("imdbID", StringProvisioner.propId()),
                        new BraqueProperty("Title", StringProvisioner.propName()),
                        new BraqueProperty("Year", StringProvisioner.propYear()),
                }, "Search");
    }
    return null;
}

@Override
public TypeReference<JobStatus<?, ?>> load(final JobType<?, ?> jobType)
        throws Exception {
    return new TypeReference<JobStatus<?, ?>>() {
        private Type _type = Types.newParameterizedType(
                JobStatus.class, jobType.getRequestType(), jobType.getResultType());

        @Override
        public Type getType() {
            return _type;
        }
    };
}

@Test public void testParameterizedTypes() throws Exception {
    ParameterizedTypeModule module = new ParameterizedTypeModule();
    Injector createInjector = Guice.createInjector(module);
    Object bindToType = createInjector.getInstance(Key.get(Types.newParameterizedType(Comparable.class, ParameterizedTypeModule.X.class)));
    assertTrue(bindToType instanceof ParameterizedTypeModule.X);
    Object bindToInstance = createInjector.getInstance(Key.get(Types.newParameterizedType(Iterator.class, ParameterizedTypeModule.X.class)));
    assertSame(module.BIND_X,bindToInstance);
    Object provide = createInjector.getInstance(Key.get(Types.newParameterizedType(Iterable.class, ParameterizedTypeModule.X.class)));
    assertSame(module.PROVIDE_X,provide );
}

/**
 * Gets the type of this type's provider.
 */
@SuppressWarnings("unchecked")
final TypeLiteral<Provider<T>> providerType() {
    // This cast is safe and wouldn't generate a warning if Type had a type
    // parameter.
    return (TypeLiteral<Provider<T>>) get(Types.providerOf(getType()));
}

/**
 * Returns an type that's appropriate for use in a key.
 *
 * <p>
 * If the raw type of {@code typeLiteral} is a {@code javax.inject.Provider}
 * , this returns a {@code com.google.inject.Provider} with the same type
 * parameters.
 *
 * <p>
 * If the type is a primitive, the corresponding wrapper type will be
 * returned.
 *
 * @throws ConfigurationException
 *             if {@code type} contains a type variable
 */
public static <T> TypeLiteral<T> canonicalizeForKey(
        TypeLiteral<T> typeLiteral) {
    Type type = typeLiteral.getType();
    if (!isFullySpecified(type)) {
        Errors errors = new Errors().keyNotFullySpecified(typeLiteral);
        throw new ConfigurationException(errors.getMessages());
    }

    if (typeLiteral.getRawType() == javax.inject.Provider.class) {
        ParameterizedType parameterizedType = (ParameterizedType) type;

        // the following casts are generally unsafe, but
        // com.google.inject.Provider extends
        // javax.inject.Provider and is covariant
        @SuppressWarnings("unchecked")
        TypeLiteral<T> guiceProviderType = (TypeLiteral<T>) TypeLiteral
                .get(Types.providerOf(
                        parameterizedType.getActualTypeArguments()[0]));
        return guiceProviderType;
    }

    @SuppressWarnings("unchecked")
    TypeLiteral<T> wrappedPrimitives = (TypeLiteral<T>) PRIMITIVE_TO_WRAPPER
            .get(typeLiteral);
    return wrappedPrimitives != null ? wrappedPrimitives : typeLiteral;
}