Java 类com.google.inject.multibindings.OptionalBinder 实例源码

public void testTypeNotBoundByDefault() {
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder.newOptionalBinder(binder(), String.class);
          requireBinding(new Key<Optional<String>>() {}); // the above specifies this.
          requireBinding(String.class); // but it doesn't specify this.
          binder().requireExplicitBindings(); // need to do this, otherwise String will JIT

          if (HAS_JAVA_OPTIONAL) {
            requireBinding(Key.get(javaOptionalOfString));
          }
        }
      };

  try {
    Guice.createInjector(module);
    fail();
  } catch (CreationException ce) {
    assertContains(
        ce.getMessage(),
        "1) Explicit bindings are required and java.lang.String is not explicitly bound.");
    assertEquals(1, ce.getErrorMessages().size());
  }
}

public void testDifferentBindingsFail_defaults() {
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder.newOptionalBinder(binder(), String.class).setDefault().toInstance("a");
          OptionalBinder.newOptionalBinder(binder(), String.class).setDefault().toInstance("b");
        }
      };
  try {
    Guice.createInjector(module);
    fail();
  } catch (CreationException ce) {
    assertEquals(ce.getMessage(), 1, ce.getErrorMessages().size());
    assertContains(
        ce.getMessage(),
        "1) A binding to java.lang.String annotated with @"
            + RealOptionalBinder.Default.class.getName()
            + " was already configured at "
            + module.getClass().getName()
            + ".configure(",
        "at " + module.getClass().getName() + ".configure(");
  }
}

public void testDifferentBindingsFail_actual() {
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder.newOptionalBinder(binder(), String.class).setBinding().toInstance("a");
          OptionalBinder.newOptionalBinder(binder(), String.class).setBinding().toInstance("b");
        }
      };
  try {
    Guice.createInjector(module);
    fail();
  } catch (CreationException ce) {
    assertEquals(ce.getMessage(), 1, ce.getErrorMessages().size());
    assertContains(
        ce.getMessage(),
        "1) A binding to java.lang.String annotated with @"
            + RealOptionalBinder.Actual.class.getName()
            + " was already configured at "
            + module.getClass().getName()
            + ".configure(",
        "at " + module.getClass().getName() + ".configure(");
  }
}

public void testMultipleDifferentOptionals() {
  final Key<String> bKey = Key.get(String.class, named("b"));
  final Key<String> cKey = Key.get(String.class, named("c"));
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder.newOptionalBinder(binder(), String.class).setDefault().toInstance("a");
          OptionalBinder.newOptionalBinder(binder(), Integer.class).setDefault().toInstance(1);

          OptionalBinder.newOptionalBinder(binder(), bKey).setDefault().toInstance("b");
          OptionalBinder.newOptionalBinder(binder(), cKey).setDefault().toInstance("c");
        }
      };
  Injector injector = Guice.createInjector(module);
  assertEquals("a", injector.getInstance(String.class));
  assertEquals(1, injector.getInstance(Integer.class).intValue());
  assertEquals("b", injector.getInstance(bKey));
  assertEquals("c", injector.getInstance(cKey));

  assertOptionalVisitor(stringKey, setOf(module), VisitType.BOTH, 3, instance("a"), null, null);
  assertOptionalVisitor(intKey, setOf(module), VisitType.BOTH, 3, instance(1), null, null);
  assertOptionalVisitor(bKey, setOf(module), VisitType.BOTH, 3, instance("b"), null, null);
  assertOptionalVisitor(cKey, setOf(module), VisitType.BOTH, 3, instance("c"), null, null);
}

public void testSourceLinesInException() {
  try {
    Guice.createInjector(
        new AbstractModule() {
          @Override
          protected void configure() {
            OptionalBinder.newOptionalBinder(binder(), Integer.class).setDefault();
          }
        });
    fail();
  } catch (CreationException expected) {
    assertContains(
        expected.getMessage(),
        "No implementation for java.lang.Integer",
        "at " + getClass().getName());
  }
}

public void testDependencies_both() {
  Injector injector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              OptionalBinder<String> optionalbinder =
                  OptionalBinder.newOptionalBinder(binder(), String.class);
              optionalbinder.setDefault().toInstance("A");
              optionalbinder.setBinding().to(Key.get(String.class, Names.named("b")));
              bindConstant().annotatedWith(Names.named("b")).to("B");
            }
          });

  Binding<String> binding = injector.getBinding(Key.get(String.class));
  HasDependencies withDependencies = (HasDependencies) binding;
  Set<String> elements = Sets.newHashSet();
  elements.addAll(recurseForDependencies(injector, withDependencies));
  assertEquals(ImmutableSet.of("B"), elements);
}

public void testDependencies_actual() {
  Injector injector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              OptionalBinder<String> optionalbinder =
                  OptionalBinder.newOptionalBinder(binder(), String.class);
              optionalbinder.setBinding().to(Key.get(String.class, Names.named("b")));
              bindConstant().annotatedWith(Names.named("b")).to("B");
            }
          });

  Binding<String> binding = injector.getBinding(Key.get(String.class));
  HasDependencies withDependencies = (HasDependencies) binding;
  Set<String> elements = Sets.newHashSet();
  elements.addAll(recurseForDependencies(injector, withDependencies));
  assertEquals(ImmutableSet.of("B"), elements);
}

public void testDependencies_default() {
  Injector injector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              OptionalBinder<String> optionalbinder =
                  OptionalBinder.newOptionalBinder(binder(), String.class);
              optionalbinder.setDefault().toInstance("A");
            }
          });

  Binding<String> binding = injector.getBinding(Key.get(String.class));
  HasDependencies withDependencies = (HasDependencies) binding;
  Set<String> elements = Sets.newHashSet();
  elements.addAll(recurseForDependencies(injector, withDependencies));
  assertEquals(ImmutableSet.of("A"), elements);
}

/** Doubly-installed modules should not conflict, even when one is overridden. */
public void testModuleOverrideRepeatedInstalls_toInstance() {
  Module m =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder<String> b = OptionalBinder.newOptionalBinder(binder(), String.class);
          b.setDefault().toInstance("A");
          b.setBinding().toInstance("B");
        }
      };

  assertEquals("B", Guice.createInjector(m, m).getInstance(Key.get(String.class)));

  Injector injector = Guice.createInjector(m, Modules.override(m).with(m));
  assertEquals("B", injector.getInstance(Key.get(String.class)));

  assertOptionalVisitor(
      stringKey,
      setOf(m, Modules.override(m).with(m)),
      VisitType.BOTH,
      0,
      instance("A"),
      instance("B"),
      null);
}

public void testModuleOverrideRepeatedInstalls_toProviderKey() {
  Module m =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder<String> b = OptionalBinder.newOptionalBinder(binder(), String.class);
          b.setDefault().toProvider(Key.get(AStringProvider.class));
          b.setBinding().toProvider(Key.get(BStringProvider.class));
        }
      };

  assertEquals("B", Guice.createInjector(m, m).getInstance(Key.get(String.class)));

  Injector injector = Guice.createInjector(m, Modules.override(m).with(m));
  assertEquals("B", injector.getInstance(Key.get(String.class)));

  assertOptionalVisitor(
      stringKey,
      setOf(m, Modules.override(m).with(m)),
      VisitType.BOTH,
      0,
      providerKey(Key.get(AStringProvider.class)),
      providerKey(Key.get(BStringProvider.class)),
      null);
}

/**
 * Unscoped bindings should not conflict, whether they were bound with no explicit scope, or
 * explicitly bound in {@link Scopes#NO_SCOPE}.
 */
public void testDuplicateUnscopedBindings() {
  Module m =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder<Integer> b = OptionalBinder.newOptionalBinder(binder(), Integer.class);
          b.setDefault().to(Key.get(Integer.class, named("foo")));
          b.setDefault().to(Key.get(Integer.class, named("foo"))).in(Scopes.NO_SCOPE);
          b.setBinding().to(Key.get(Integer.class, named("foo")));
          b.setBinding().to(Key.get(Integer.class, named("foo"))).in(Scopes.NO_SCOPE);
        }

        @Provides
        @Named("foo")
        int provideInt() {
          return 5;
        }
      };
  assertEquals(5, Guice.createInjector(m).getInstance(Integer.class).intValue());
}

/** Ensure bindings do not rehash their keys once returned from {@link Elements#getElements}. */
public void testBindingKeysFixedOnReturnFromGetElements() {
  final List<String> list = Lists.newArrayList();
  Module m =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder<List<String>> b =
              OptionalBinder.newOptionalBinder(binder(), listOfStrings);
          b.setDefault().toInstance(list);
          list.add("A");
          list.add("B");
        }
      };

  InstanceBinding<?> binding =
      Iterables.getOnlyElement(Iterables.filter(Elements.getElements(m), InstanceBinding.class));
  Key<?> keyBefore = binding.getKey();
  assertEquals(listOfStrings, keyBefore.getTypeLiteral());

  list.add("C");
  Key<?> keyAfter = binding.getKey();
  assertSame(keyBefore, keyAfter);
}

public void testSetAndMapValueAreDistinct() {
  Injector injector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              Multibinder.newSetBinder(binder(), String.class).addBinding().toInstance("A");

              MapBinder.newMapBinder(binder(), String.class, String.class)
                  .addBinding("B")
                  .toInstance("b");

              OptionalBinder.newOptionalBinder(binder(), String.class)
                  .setDefault()
                  .toInstance("C");
              OptionalBinder.newOptionalBinder(binder(), String.class)
                  .setBinding()
                  .toInstance("D");
            }
          });

  assertEquals(ImmutableSet.of("A"), injector.getInstance(Key.get(setOfString)));
  assertEquals(ImmutableMap.of("B", "b"), injector.getInstance(Key.get(mapOfStringString)));
  assertEquals(Optional.of("D"), injector.getInstance(Key.get(optionalOfString)));
}

/**
 * Tests for a regression where dependency objects were not updated properly and OptionalBinder
 * was rejecting nulls from its dependencies.
 */
public void testBindNullAndLinkFromOptionalBinder() {
  Injector injector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              bind(Foo.class).toProvider(Providers.<Foo>of(null));
              OptionalBinder.newOptionalBinder(binder(), Foo.class);
            }

            @Provides
            @Named("throughProvidesMethod")
            Foo provideFoo(Optional<Foo> foo) {
              return foo.orNull();
            }
          });
  assertNull(injector.getInstance(Key.get(Foo.class, Names.named("throughProvidesMethod"))));
}

@Override
protected void configure() {
  OptionalBinder
      .newOptionalBinder(
          binder(),
          Key.get(String.class, CorrelationIdClientHeader.class))
      .setDefault().toInstance(CorrelationIdContext.DEFAULT_HEADER_NAME);

  OptionalBinder
      .newOptionalBinder(
          binder(),
          Key.get(BeadledomClientConfiguration.class, clientBindingAnnotation));

  install(new BeadledomClientPrivateModule(clientBindingAnnotation));
}

@Override
protected void configure() {
    bindAndExpose(TournamentStore.class);

    bindModel(team.Team.class, team.Partial.class);

    bindModel(Tournament.class, model -> {
        model.bindStore().to(TournamentStore.class);
        model.queryService().setBinding().to(TournamentService.class);
    });

    OptionalBinder.newOptionalBinder(publicBinder(), TournamentService.class)
                  .setDefault().to(NullTournamentService.class);
}

private ModelBinder(ProtectedBinder protectedBinder, TypeLiteral<M> M, TypeLiteral<P> P) {
    this.binder = Binders.wrap(protectedBinder.publicBinder());
    this.M = M;
    this.P = P;

    this.metas = Multibinder.newSetBinder(binder, ModelMeta.class);
    this.serviceBinder = OptionalBinder.newOptionalBinder(binder, ModelService(M, P));
    this.queryServiceBinder = OptionalBinder.newOptionalBinder(binder, QueryService(M));
    this.updateServiceBinder = OptionalBinder.newOptionalBinder(binder, UpdateService(P));
    this.storeBinder = OptionalBinder.newOptionalBinder(binder, ModelStore(M));

    binder.install(new OneTime());
    binder.install(new PerModel());
}

@Override
protected void configure() {
    bindModel(Session.class, SessionDoc.Partial.class, model -> {
        model.bindService().to(SessionService.class);
    });

    OptionalBinder.newOptionalBinder(publicBinder(), SessionService.class);
}

@Override
protected void configure() {
    bindModel(User.class, UserDoc.Partial.class, model -> {
        model.bindService().to(UserService.class);
    });

    OptionalBinder.newOptionalBinder(publicBinder(), UserService.class);
}

@Override
protected void configure() {
    bindModel(EngagementDoc.class);

    OptionalBinder.newOptionalBinder(publicBinder(), EngagementService.class)
                  .setDefault().to(LocalEngagementService.class);
}

@Override
protected void configure() {
    bindModel(Whisper.class, WhisperDoc.Partial.class, model -> {
        model.bindService().to(WhisperService.class);
    });

    OptionalBinder.newOptionalBinder(publicBinder(), WhisperService.class)
                  .setDefault().to(NullWhisperService.class);

}

@Override
protected void configure() {
    bindAndExpose(ServerStore.class);

    bindModel(Server.class, ServerDoc.Partial.class, model -> {
        model.bindStore().to(ServerStore.class);
        model.bindService().to(ServerService.class);
    });

    OptionalBinder.newOptionalBinder(publicBinder(), ServerService.class);
}

@Override
protected void configure() {
    bindModel(MapDoc.class, model -> {
        model.bindService().to(MapService.class);
    });

    OptionalBinder.newOptionalBinder(publicBinder(), MapService.class);
}

@Override
protected void configure() {
    install(new Resilience4jModule());

    bind(SqsManager.class).asEagerSingleton();
    bind(ConsumerManager.class).asEagerSingleton();

    OptionalBinder.newOptionalBinder(binder(), AmazonSQSProvider.class)
        .setDefault().to(DefaultAmazonSQSProvider.class);
}

@Override
protected void configure() {
    OptionalBinder.newOptionalBinder(binder(), AmazonSNSProvider.class)
        .setDefault()
        .to(DefaultAmazonSNSProvider.class);

    OptionalBinder.newOptionalBinder(binder(), SnsService.class)
        .setDefault()
        .to(DefaultSnsService.class);
}

@Override
protected void configure() {
  // This installs all the core plugins and the apicallscope dependencies.
  install(new SharedModule());
  OptionalBinder.newOptionalBinder(
      binder(), new Key<ImmutableSet<String>>(Deltemplates.class) {});
}

public void testOptionalIsAbsentByDefault() throws Exception {
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder.newOptionalBinder(binder(), String.class);
        }
      };

  Injector injector = Guice.createInjector(module);
  Optional<String> optional = injector.getInstance(Key.get(optionalOfString));
  assertFalse(optional.isPresent());

  Optional<Provider<String>> optionalP = injector.getInstance(Key.get(optionalOfProviderString));
  assertFalse(optionalP.isPresent());

  Optional<javax.inject.Provider<String>> optionalJxP =
      injector.getInstance(Key.get(optionalOfJavaxProviderString));
  assertFalse(optionalJxP.isPresent());

  assertOptionalVisitor(stringKey, setOf(module), VisitType.BOTH, 0, null, null, null);

  if (HAS_JAVA_OPTIONAL) {
    optional = toOptional(injector.getInstance(Key.get(javaOptionalOfString)));
    assertFalse(optional.isPresent());

    optionalP = toOptional(injector.getInstance(Key.get(javaOptionalOfProviderString)));
    assertFalse(optionalP.isPresent());

    optionalJxP = toOptional(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
    assertFalse(optionalJxP.isPresent());
  }
}

public void testSetDefault() throws Exception {
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder.newOptionalBinder(binder(), String.class).setDefault().toInstance("a");
        }
      };
  Injector injector = Guice.createInjector(module);
  assertEquals("a", injector.getInstance(String.class));

  Optional<String> optional = injector.getInstance(Key.get(optionalOfString));
  assertTrue(optional.isPresent());
  assertEquals("a", optional.get());

  Optional<Provider<String>> optionalP = injector.getInstance(Key.get(optionalOfProviderString));
  assertTrue(optionalP.isPresent());
  assertEquals("a", optionalP.get().get());

  Optional<javax.inject.Provider<String>> optionalJxP =
      injector.getInstance(Key.get(optionalOfJavaxProviderString));
  assertTrue(optionalJxP.isPresent());
  assertEquals("a", optionalJxP.get().get());

  assertOptionalVisitor(stringKey, setOf(module), VisitType.BOTH, 0, instance("a"), null, null);

  if (HAS_JAVA_OPTIONAL) {
    optional = toOptional(injector.getInstance(Key.get(javaOptionalOfString)));
    assertTrue(optional.isPresent());
    assertEquals("a", optional.get());

    optionalP = toOptional(injector.getInstance(Key.get(javaOptionalOfProviderString)));
    assertTrue(optionalP.isPresent());
    assertEquals("a", optionalP.get().get());

    optionalJxP = toOptional(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
    assertTrue(optionalJxP.isPresent());
    assertEquals("a", optionalJxP.get().get());
  }
}

public void testSetBinding() throws Exception {
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder.newOptionalBinder(binder(), String.class).setBinding().toInstance("a");
        }
      };
  Injector injector = Guice.createInjector(module);
  assertEquals("a", injector.getInstance(String.class));

  Optional<String> optional = injector.getInstance(Key.get(optionalOfString));
  assertTrue(optional.isPresent());
  assertEquals("a", optional.get());

  Optional<Provider<String>> optionalP = injector.getInstance(Key.get(optionalOfProviderString));
  assertTrue(optionalP.isPresent());
  assertEquals("a", optionalP.get().get());

  Optional<javax.inject.Provider<String>> optionalJxP =
      injector.getInstance(Key.get(optionalOfJavaxProviderString));
  assertTrue(optionalJxP.isPresent());
  assertEquals("a", optionalJxP.get().get());

  assertOptionalVisitor(stringKey, setOf(module), VisitType.BOTH, 0, null, instance("a"), null);

  if (HAS_JAVA_OPTIONAL) {
    optional = toOptional(injector.getInstance(Key.get(javaOptionalOfString)));
    assertTrue(optional.isPresent());
    assertEquals("a", optional.get());

    optionalP = toOptional(injector.getInstance(Key.get(javaOptionalOfProviderString)));
    assertTrue(optionalP.isPresent());
    assertEquals("a", optionalP.get().get());

    optionalJxP = toOptional(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
    assertTrue(optionalJxP.isPresent());
    assertEquals("a", optionalJxP.get().get());
  }
}

public void testDifferentBindingsFail_both() {
  Module module =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder.newOptionalBinder(binder(), String.class).setDefault().toInstance("a");
          OptionalBinder.newOptionalBinder(binder(), String.class).setDefault().toInstance("b");
          OptionalBinder.newOptionalBinder(binder(), String.class).setBinding().toInstance("b");
          OptionalBinder.newOptionalBinder(binder(), String.class).setBinding().toInstance("c");
        }
      };
  try {
    Guice.createInjector(module);
    fail();
  } catch (CreationException ce) {
    assertEquals(ce.getMessage(), 2, ce.getErrorMessages().size());
    assertContains(
        ce.getMessage(),
        "1) A binding to java.lang.String annotated with @"
            + RealOptionalBinder.Default.class.getName()
            + " was already configured at "
            + module.getClass().getName()
            + ".configure(",
        "at " + module.getClass().getName() + ".configure(",
        "2) A binding to java.lang.String annotated with @"
            + RealOptionalBinder.Actual.class.getName()
            + " was already configured at "
            + module.getClass().getName()
            + ".configure(",
        "at " + module.getClass().getName() + ".configure(");
  }
}

public void testModuleOverrideRepeatedInstalls_toKey() {
  final Key<String> aKey = Key.get(String.class, Names.named("A_string"));
  final Key<String> bKey = Key.get(String.class, Names.named("B_string"));
  Module m =
      new AbstractModule() {
        @Override
        protected void configure() {
          bind(aKey).toInstance("A");
          bind(bKey).toInstance("B");

          OptionalBinder<String> b = OptionalBinder.newOptionalBinder(binder(), String.class);
          b.setDefault().to(aKey);
          b.setBinding().to(bKey);
        }
      };

  assertEquals("B", Guice.createInjector(m, m).getInstance(Key.get(String.class)));

  Injector injector = Guice.createInjector(m, Modules.override(m).with(m));
  assertEquals("B", injector.getInstance(Key.get(String.class)));

  assertOptionalVisitor(
      stringKey,
      setOf(m, Modules.override(m).with(m)),
      VisitType.BOTH,
      0,
      linked(aKey),
      linked(bKey),
      null);
}

public void testModuleOverrideRepeatedInstalls_toProviderInstance() {
  // Providers#of() does not redefine equals/hashCode, so use the same one both times.
  final Provider<String> aProvider = Providers.of("A");
  final Provider<String> bProvider = Providers.of("B");
  Module m =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder<String> b = OptionalBinder.newOptionalBinder(binder(), String.class);
          b.setDefault().toProvider(aProvider);
          b.setBinding().toProvider(bProvider);
        }
      };

  assertEquals("B", Guice.createInjector(m, m).getInstance(Key.get(String.class)));

  Injector injector = Guice.createInjector(m, Modules.override(m).with(m));
  assertEquals("B", injector.getInstance(Key.get(String.class)));

  assertOptionalVisitor(
      stringKey,
      setOf(m, Modules.override(m).with(m)),
      VisitType.BOTH,
      0,
      providerInstance("A"),
      providerInstance("B"),
      null);
}

public void testModuleOverrideRepeatedInstalls_toConstructor() {
  Module m =
      new AbstractModule() {
        @Override
        protected void configure() {
          Key<String> aKey = Key.get(String.class, Names.named("A_string"));
          Key<String> bKey = Key.get(String.class, Names.named("B_string"));
          bind(aKey).toInstance("A");
          bind(bKey).toInstance("B");
          bind(Integer.class).toInstance(0); // used to disambiguate constructors

          OptionalBinder<StringGrabber> b =
              OptionalBinder.newOptionalBinder(binder(), StringGrabber.class);
          try {
            b.setDefault().toConstructor(StringGrabber.class.getConstructor(String.class));
            b.setBinding()
                .toConstructor(StringGrabber.class.getConstructor(String.class, int.class));
          } catch (NoSuchMethodException e) {
            fail("No such method: " + e.getMessage());
          }
        }
      };

  assertEquals("B", Guice.createInjector(m, m).getInstance(Key.get(StringGrabber.class)).string);

  Injector injector = Guice.createInjector(m, Modules.override(m).with(m));
  assertEquals("B", injector.getInstance(Key.get(StringGrabber.class)).string);
}

/** Ensure key hash codes are fixed at injection time, not binding time. */
public void testKeyHashCodesFixedAtInjectionTime() {
  Module m =
      new AbstractModule() {
        @Override
        protected void configure() {
          OptionalBinder<List<String>> b =
              OptionalBinder.newOptionalBinder(binder(), listOfStrings);
          List<String> list = Lists.newArrayList();
          b.setDefault().toInstance(list);
          b.setBinding().toInstance(list);
          list.add("A");
          list.add("B");
        }
      };

  Injector injector = Guice.createInjector(m);
  for (Entry<Key<?>, Binding<?>> entry : injector.getAllBindings().entrySet()) {
    Key<?> bindingKey = entry.getKey();
    Key<?> clonedKey;
    if (bindingKey.getAnnotation() != null) {
      clonedKey = Key.get(bindingKey.getTypeLiteral(), bindingKey.getAnnotation());
    } else if (bindingKey.getAnnotationType() != null) {
      clonedKey = Key.get(bindingKey.getTypeLiteral(), bindingKey.getAnnotationType());
    } else {
      clonedKey = Key.get(bindingKey.getTypeLiteral());
    }
    assertEquals(bindingKey, clonedKey);
    assertEquals(
        "Incorrect hashcode for " + bindingKey + " -> " + entry.getValue(),
        bindingKey.hashCode(),
        clonedKey.hashCode());
  }
}

@Marker
public void testMatchingMarkerAnnotations() throws Exception {
  Method m = OptionalBinderTest.class.getDeclaredMethod("testMatchingMarkerAnnotations");
  assertNotNull(m);
  final Annotation marker = m.getAnnotation(Marker.class);
  Injector injector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            public void configure() {
              OptionalBinder<Integer> mb1 =
                  OptionalBinder.newOptionalBinder(
                      binder(), Key.get(Integer.class, Marker.class));
              OptionalBinder<Integer> mb2 =
                  OptionalBinder.newOptionalBinder(binder(), Key.get(Integer.class, marker));
              mb1.setDefault().toInstance(1);
              mb2.setBinding().toInstance(2);

              // This assures us that the two binders are equivalent, so we expect the instance added to
              // each to have been added to one set.
              assertEquals(mb1, mb2);
            }
          });
  Integer i1 = injector.getInstance(Key.get(Integer.class, Marker.class));
  Integer i2 = injector.getInstance(Key.get(Integer.class, marker));

  // These must be identical, because the marker annotations collapsed to the same thing.
  assertSame(i1, i2);
  assertEquals(2, i2.intValue());
}

public void testWeakKeySet_integration() {
  Injector parentInjector =
      Guice.createInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              bind(String.class).toInstance("hi");
            }
          });
  WeakKeySetUtils.assertNotBlacklisted(parentInjector, Key.get(Integer.class));

  Injector childInjector =
      parentInjector.createChildInjector(
          new AbstractModule() {
            @Override
            protected void configure() {
              OptionalBinder.newOptionalBinder(binder(), Integer.class)
                  .setDefault()
                  .toInstance(4);
            }
          });
  WeakReference<Injector> weakRef = new WeakReference<>(childInjector);
  WeakKeySetUtils.assertBlacklisted(parentInjector, Key.get(Integer.class));

  // Clear the ref, GC, and ensure that we are no longer blacklisting.
  childInjector = null;

  Asserts.awaitClear(weakRef);
  WeakKeySetUtils.assertNotBlacklisted(parentInjector, Key.get(Integer.class));
}

@Override
protected void setup(Binder binder) {
    CustomDataSourceConfig config = buildConfigObject(CustomDataSourceConfig.class);
    OptionalBinder.newOptionalBinder(binder, CustomDataSourceService.class);

    if (config.getEnabled()) {
        Multibinder<HttpService> httpServiceMultibinder = Multibinder.newSetBinder(binder, HttpService.class);
        httpServiceMultibinder.addBinding().to(CustomDataSourceHttpService.class).in(Scopes.SINGLETON);
        binder.bind(CustomDataSourceService.class);
    }
}

@Override
protected void setup(Binder binder) {
    OptionalBinder.newOptionalBinder(binder, AuthService.class).setBinding().to(SamlAuthService.class);
    configBinder(binder).bindConfig(SamlConfig.class);

    Multibinder<HttpService> httpServices = Multibinder.newSetBinder(binder, HttpService.class);
    httpServices.addBinding().to(SamlHttpService.class);
}

@Override
protected void setup(Binder binder) {
    OptionalBinder.newOptionalBinder(binder, CustomPageDatabase.class);
    OptionalBinder.newOptionalBinder(binder, CustomReportMetadata.class);
    OptionalBinder.newOptionalBinder(binder, ReportMetadata.class);
    OptionalBinder.newOptionalBinder(binder, DashboardService.class);

    if (!"true".equals(getConfig("ui.enable"))) {
        Multibinder.newSetBinder(binder, HttpService.class).addBinding()
                .to(RootAPIInformationService.class).in(Scopes.SINGLETON);
    }
}

@Override
protected void configure() {
  // Required to build BeadledomClientBuilder
  OptionalBinder
      .newOptionalBinder(
          binder(),
          Key.get(BeadledomClientBuilderFactory.class, getBindingAnnotation()))
      .setDefault().toInstance(new ResteasyClientBuilderFactory());


  bindDynamicProvider(BeadledomClientBuilderFactory.class);

  // Required to build BeadledomClientBuilder
  BeadledomClientBuilderProvider beadledomClientBuilderProvider =
      new BeadledomClientBuilderProvider(getBindingAnnotation());

  bind(BeadledomClientBuilder.class).annotatedWith(getBindingAnnotation())
      .toProvider(beadledomClientBuilderProvider)
      .asEagerSingleton();

  bindDynamicProvider(BeadledomClientBuilder.class);

  // Required to build BeadledomClientConfiguration
  TypeLiteral<Optional<BeadledomClientConfiguration>> clientConfigOptTypeLiteral =
      new TypeLiteral<Optional<BeadledomClientConfiguration>>() {
      };

  bindDynamicProvider(clientConfigOptTypeLiteral);

  //Required to build BeadledomClient
  BeadledomClientProvider beadledomClientProvider =
      new BeadledomClientProvider(getBindingAnnotation());

  bind(BeadledomClient.class).annotatedWith(getBindingAnnotation())
      .toProvider(beadledomClientProvider)
      .asEagerSingleton();

  bindDynamicProvider(BeadledomClient.class);

  // Lifecycle hook
  BeadledomClientLifecycleHookProvider provider =
      new BeadledomClientLifecycleHookProvider(getBindingAnnotation());

  bind(BeadledomClientLifecycleHook.class).annotatedWith(getBindingAnnotation())
      .toProvider(provider).asEagerSingleton();

  expose(BeadledomClientBuilder.class).annotatedWith(getBindingAnnotation());
  expose(BeadledomClient.class).annotatedWith(getBindingAnnotation());
  expose(BeadledomClientLifecycleHook.class).annotatedWith(getBindingAnnotation());
}