com.google.inject.Guice Java Examples

@Test
public void update() {
	Injector injector = Guice.createInjector(new MockProblemModule());
	IndividualFactory factory = injector.getInstance(IndividualFactory.class);

	Objective o0 = new Objective("o0");
	Objective o1 = new Objective("o1");

	TestArchive archive = new TestArchive();

	Individual i0 = factory.create();
	Objectives objectives0 = new Objectives();
	objectives0.add(o0, 1);
	objectives0.add(o1, 0);
	i0.setObjectives(objectives0);

	Assert.assertTrue(archive.update(i0));
	Assert.assertTrue(archive.contains(i0));
}
 

@Override
public PluginContainer createPlugin(PluginDescription description) throws Exception {
  if (!(description instanceof JavaVelocityPluginDescription)) {
    throw new IllegalArgumentException("Description provided isn't of the Java plugin loader");
  }

  JavaVelocityPluginDescription javaDescription = (JavaVelocityPluginDescription) description;
  Optional<Path> source = javaDescription.getSource();

  if (!source.isPresent()) {
    throw new IllegalArgumentException("No path in plugin description");
  }

  Injector injector = Guice
      .createInjector(new VelocityPluginModule(server, javaDescription, baseDirectory));
  Object instance = injector.getInstance(javaDescription.getMainClass());

  if (instance == null) {
    throw new IllegalStateException(
        "Got nothing from injector for plugin " + javaDescription.getId());
  }

  return new VelocityPluginContainer(description, instance);
}
 

/**
 * Initialize and start the PubsubEmulatorServer.
 *
 * <p>To set an external configuration file must be considered argument
 * `configuration.location=/to/path/application.yaml` the properties will be merged.
 */
public static void main(String[] args) {
  Args argObject = new Args();
  JCommander jCommander = JCommander.newBuilder().addObject(argObject).build();
  jCommander.parse(args);
  if (argObject.help) {
    jCommander.usage();
    return;
  }
  Injector injector =
      Guice.createInjector(new DefaultModule(argObject.configurationFile, argObject.pubSubFile));
  PubsubEmulatorServer pubsubEmulatorServer = injector.getInstance(PubsubEmulatorServer.class);
  try {
    pubsubEmulatorServer.start();
    pubsubEmulatorServer.blockUntilShutdown();
  } catch (IOException | InterruptedException e) {
    logger.atSevere().withCause(e).log("Unexpected server failure");
  }
}
 

private static Injector getInjector() throws IOException {
  File serverConfig = TEMPORARY_FOLDER.newFile();
  File pubSubRepository = TEMPORARY_FOLDER.newFile();
  Files.write(pubSubRepository.toPath(), Configurations.PUBSUB_CONFIG_JSON.getBytes(UTF_8));

  if (!USE_SSL) {
    Files.write(serverConfig.toPath(), Configurations.SERVER_CONFIG_JSON.getBytes(UTF_8));
  } else {
    // Update certificate paths
    String updated =
        Configurations.SSL_SERVER_CONFIG_JSON
            .replace("/path/to/server.crt", ClassLoader.getSystemResource("server.crt").getPath())
            .replace(
                "/path/to/server.key", ClassLoader.getSystemResource("server.key").getPath());
    Files.write(serverConfig.toPath(), updated.getBytes(UTF_8));
  }
  return Guice.createInjector(
      new DefaultModule(serverConfig.getPath(), pubSubRepository.getPath()));
}
 

private Injector createInjector()
{
    try
    {
        return Guice.createInjector(new ExternalDependenciesModule(this));

    }
    catch (Exception e)
    {
        String msg = MessageFormat.format(Messages.BslValidator_Failed_to_create_injector_for_0,
            getBundle().getSymbolicName());
        log(createErrorStatus(msg, e));
        return null;

    }
}
 

protected Injector getInjector() {
    boolean success = false;

    final StringWriter errorOut = new StringWriter();
    PrintWriter errorWriter = new PrintWriter(errorOut);
    try {
        this.injector = Guice.createInjector(Stage.PRODUCTION, this.getModules());
        success = true;
    } catch (Exception e){
        System.err.println("[HMDM-INITIALIZER]: Unexpected error during injector initialization: " + e);
        e.printStackTrace();
        e.printStackTrace(errorWriter);
    }
    if (success) {
        System.out.println("[HMDM-INITIALIZER]: Application initialization was successful");
        onInitializationCompletion(null);
    } else {
        System.out.println("[HMDM-INITIALIZER]: Application initialization has failed");
        onInitializationCompletion(errorOut);
    }
    return injector;
}
 

@Test
public void test_memory_persistence() {
    when(persistenceConfigurationService.getMode()).thenReturn(PersistenceConfigurationService.PersistenceMode.IN_MEMORY);

    final Injector injector = Guice.createInjector(
            new PersistenceMigrationModule(new MetricRegistry(), persistenceConfigurationService),
            new AbstractModule() {
                @Override
                protected void configure() {
                    bind(SystemInformation.class).toInstance(systemInformation);
                    bindScope(LazySingleton.class, LazySingletonScope.get());
                    bind(MqttConfigurationService.class).toInstance(mqttConfigurationService);
                }
            });

    assertTrue(injector.getInstance(RetainedMessageLocalPersistence.class) instanceof RetainedMessageMemoryLocalPersistence);
    assertTrue(injector.getInstance(PublishPayloadLocalPersistence.class) instanceof PublishPayloadMemoryLocalPersistence);
}
 

@Before
public void setUp() throws Exception {

    MockitoAnnotations.initMocks(this);

    testConfigurationBootstrap = new TestConfigurationBootstrap();
    final FullConfigurationService fullConfigurationService = testConfigurationBootstrap.getFullConfigurationService();

    injector = Guice.createInjector(new SystemInformationModule(new SystemInformationImpl()), new ConfigurationModule(fullConfigurationService, new HivemqId()),
            new AbstractModule() {
                @Override
                protected void configure() {
                    bind(SharedSubscriptionService.class).toInstance(sharedSubscriptionService);
                }
            });
}
 

@Test
public void test_topic_matcher_not_same() {

    final Injector injector = Guice.createInjector(Stage.PRODUCTION,
            new HiveMQMainModule(),
            new AbstractModule() {
                @Override
                protected void configure() {
                    bind(EventExecutorGroup.class).toInstance(Mockito.mock(EventExecutorGroup.class));
                }
            });

    final TopicMatcher instance1 = injector.getInstance(TopicMatcher.class);
    final TopicMatcher instance2 = injector.getInstance(TopicMatcher.class);

    assertNotSame(instance1, instance2);

}
 

@BeforeEach
void setUp() throws InterruptedException
{
    Injector injector = Guice.createInjector(Modules.override(new MainModule()).with(getTestModule()));
    server = injector.getInstance(HttpServer.class);

    check = injector.getInstance(MockHealthCheck.class);
    service = injector.getInstance(HealthService.class);
    vertx = injector.getInstance(Vertx.class);
    config = injector.getInstance(Configuration.class);

    VertxTestContext context = new VertxTestContext();
    server.listen(config.getPort(), context.completing());

    context.awaitCompletion(5, TimeUnit.SECONDS);
}
 

@Before
public void setUp() throws Exception {

	Objective o0 = new Objective("o0");
	Objective o1 = new Objective("o1");

	Injector injector = Guice.createInjector(new MockProblemModule());
	IndividualFactory factory = injector.getInstance(IndividualFactory.class);

	for (int i = 0; i < SIZE; i++) {
		Individual individual = factory.create();
		Objectives objectives = new Objectives();
		objectives.add(o0, i);
		objectives.add(o1, SIZE - i);
		individual.setObjectives(objectives);
		set.add(individual);
	}
}
 

private void createClientConnection(AsynchronousSocketChannel socketChannel) {
	Injector injector = Guice.createInjector(getGLSPModule());
	GsonConfigurator gsonConf = injector.getInstance(GsonConfigurator.class);

	InputStream in = Channels.newInputStream(socketChannel);
	OutputStream out = Channels.newOutputStream(socketChannel);

	Consumer<GsonBuilder> configureGson = (GsonBuilder builder) -> gsonConf.configureGsonBuilder(builder);
	Function<MessageConsumer, MessageConsumer> wrapper = Function.identity();
	GLSPServer languageServer = injector.getInstance(GLSPServer.class);

	Launcher<GLSPClient> launcher = Launcher.createIoLauncher(languageServer, GLSPClient.class, in, out, threadPool,
			wrapper, configureGson);
	languageServer.connect(launcher.getRemoteProxy());
	launcher.startListening();

	try {
		SocketAddress remoteAddress = socketChannel.getRemoteAddress();
		log.info("Started language server for client " + remoteAddress);
	} catch (IOException ex) {
		log.error("Failed to get the remoteAddress for the new client connection: " + ex.getMessage(), ex);
	}
}
 

@Before
public void before()
{
	Guice.createInjector(BoundFieldModule.of(this)).injectMembers(this);

	// Set up spec weapon
	ItemContainer equipment = mock(ItemContainer.class);
	when(equipment.getItem(EquipmentInventorySlot.WEAPON.getSlotIdx())).thenReturn(new Item(ItemID.BANDOS_GODSWORD, 1));
	when(client.getItemContainer(InventoryID.EQUIPMENT)).thenReturn(equipment);

	// Set up special attack energy
	when(client.getVar(VarPlayer.SPECIAL_ATTACK_PERCENT)).thenReturn(100);
	specialCounterPlugin.onVarbitChanged(new VarbitChanged());

}
 

/**
 * Start Ark Service Container
 * @throws ArkRuntimeException
 * @since 0.1.0
 */
public void start() throws ArkRuntimeException {
    if (started.compareAndSet(false, true)) {
        ClassLoader oldClassLoader = ClassLoaderUtils.pushContextClassLoader(getClass()
            .getClassLoader());
        try {
            LOGGER.info("Begin to start ArkServiceContainer");

            injector = Guice.createInjector(findServiceModules());
            for (Binding<ArkService> binding : injector
                .findBindingsByType(new TypeLiteral<ArkService>() {
                })) {
                arkServiceList.add(binding.getProvider().get());
            }
            Collections.sort(arkServiceList, new OrderComparator());

            for (ArkService arkService : arkServiceList) {
                LOGGER.info(String.format("Init Service: %s", arkService.getClass().getName()));
                arkService.init();
            }

            ArkServiceContainerHolder.setContainer(this);
            ArkClient.setBizFactoryService(getService(BizFactoryService.class));
            ArkClient.setBizManagerService(getService(BizManagerService.class));
            ArkClient.setInjectionService(getService(InjectionService.class));
            ArkClient.setEventAdminService(getService(EventAdminService.class));
            ArkClient.setArguments(arguments);
            LOGGER.info("Finish to start ArkServiceContainer");
        } finally {
            ClassLoaderUtils.popContextClassLoader(oldClassLoader);
        }

    }

}
 

/**
 * Tests {@link AbstractArchive#removeArchiveDominated(List)} with a
 * dominated individual.
 */
@Test
public void removeArchiveDominatedTest2() {
	Injector injector = Guice.createInjector(new MockProblemModule());
	IndividualFactory factory = injector.getInstance(IndividualFactory.class);

	Objective o0 = new Objective("o0");
	Objective o1 = new Objective("o1");

	Individual iArchived0 = factory.create();
	Objectives objectivesA0 = new Objectives();
	objectivesA0.add(o0, 2);
	objectivesA0.add(o1, 3);
	iArchived0.setObjectives(objectivesA0);

	Individual iArchived1 = factory.create();
	Objectives objectivesA1 = new Objectives();
	objectivesA1.add(o0, 3);
	objectivesA1.add(o1, 2);
	iArchived1.setObjectives(objectivesA1);

	TestArchive archive = new TestArchive();
	archive.addAll(iArchived0, iArchived1);

	Individual i0 = factory.create();
	Objectives objectives0 = new Objectives();
	objectives0.add(o0, 4);
	objectives0.add(o1, 4);
	i0.setObjectives(objectives0);

	List<Individual> list = new ArrayList<>();
	list.add(i0);
	archive.removeArchiveDominated(list);

	Assert.assertTrue(list.isEmpty());
	Assert.assertEquals(2, archive.size());
}
 

public Injector createInjector() {
	return Guice.createInjector(new RDRuntimeModule() {
		@Override
		public Class<? extends IGenerator2> bindIGenerator2() {
			return RDOutput.class;
		}
	});
}
 

/**
 * Test a given {@link Opt4JModule}.
 * 
 * @param archiveModule
 *            the archive module under test
 */
protected void archiveOptimalityTest(Opt4JModule archiveModule) {
	Injector injector = Guice.createInjector(archiveModule);
	Archive archive = injector.getInstance(Archive.class);

	fillArchive(injector, archive);

	Assert.assertTrue(archive.contains(first));
	Assert.assertTrue(archive.contains(last));
	Assert.assertTrue(archive.contains(randMin));

	testOptimalityOfAllIndividuals(archive);
}
 

@Before
public void before()
{
	Guice.createInjector(BoundFieldModule.of(this)).injectMembers(this);
	when(screenshotConfig.screenshotLevels()).thenReturn(true);
	when(screenshotConfig.screenshotValuableDrop()).thenReturn(true);
	when(screenshotConfig.screenshotUntradeableDrop()).thenReturn(true);
}
 

private void initializeSystemUnderTest() {
  underTest = Guice.createInjector(new TransactionModule(), new AbstractModule() {
    @Override
    protected void configure() {
      bind(IndexYamlBuilder.class).toInstance(indexYamlBuilder);
    }
  }).getInstance(CreateIndexServiceImpl.class);
}
 

@Test
public void evaluate() throws TerminationException {
	Injector injector = Guice.createInjector(new MockProblemModule());
	IndividualFactory factory = injector.getInstance(IndividualFactory.class);
	Individual i1 = factory.create();

	SequentialIndividualCompleter completer = injector.getInstance(SequentialIndividualCompleter.class);

	i1.setPhenotype("my phenotype");
	Assert.assertTrue(i1.getState().equals(State.PHENOTYPED));
	completer.evaluate(i1);
	Assert.assertTrue(i1.getState().equals(State.EVALUATED));
	// Assert.assertTrue(i1.getObjectives() == objectives);
}
 

@Before
public void before()
{
	Guice.createInjector(BoundFieldModule.of(this)).injectMembers(this);

	when(client.getLocalPlayer()).thenReturn(mock(Player.class));

	xpTrackerPlugin.setXpPanel(mock(XpPanel.class));
}
 

/**
 * Tests {@link AbstractArchive#removeDominatedCandidates(List)} with two
 * nondominated individuals.
 */
@Test
public void removeDominatedCandidatesTest() {
	Injector injector = Guice.createInjector(new MockProblemModule());
	IndividualFactory factory = injector.getInstance(IndividualFactory.class);

	Objective o0 = new Objective("o0");
	Objective o1 = new Objective("o1");

	TestArchive archive = new TestArchive();

	Individual i0 = factory.create();
	Objectives objectives0 = new Objectives();
	objectives0.add(o0, 1);
	objectives0.add(o1, 0);
	i0.setObjectives(objectives0);

	Individual i1 = factory.create();
	Objectives objectives1 = new Objectives();
	objectives1.add(o0, 0);
	objectives1.add(o1, 1);
	i1.setObjectives(objectives1);

	List<Individual> list = new ArrayList<>();
	list.add(i0);
	list.add(i1);
	archive.removeDominatedCandidates(list);

	Assert.assertEquals(2, list.size());
	Assert.assertTrue(list.contains(i0));
	Assert.assertTrue(list.contains(i1));
}
 

/**
 * Tests {@link AbstractArchive#removeDominatedCandidates(List)} with two
 * individuals which dominate themselves.
 */
@Test
public void removeDominatedCandidatesTest2() {
	Injector injector = Guice.createInjector(new MockProblemModule());
	IndividualFactory factory = injector.getInstance(IndividualFactory.class);

	Objective o0 = new Objective("o0");
	Objective o1 = new Objective("o1");

	TestArchive archive = new TestArchive();

	Individual i0 = factory.create();
	Objectives objectives0 = new Objectives();
	objectives0.add(o0, 0);
	objectives0.add(o1, 0);
	i0.setObjectives(objectives0);

	Individual i1 = factory.create();
	Objectives objectives1 = new Objectives();
	objectives1.add(o0, 1);
	objectives1.add(o1, 1);
	i1.setObjectives(objectives1);

	List<Individual> list = new ArrayList<>();
	list.add(i0);
	list.add(i1);
	archive.removeDominatedCandidates(list);

	Assert.assertEquals(1, list.size());
	Assert.assertTrue(list.contains(i0));

	list.clear();
	list.add(i1);
	list.add(i0);
	archive.removeDominatedCandidates(list);

	Assert.assertEquals(1, list.size());
	Assert.assertTrue(list.contains(i0));
}
 

/**
 * Initialize a task manually before executing it. This enables to get
 * instances of classes before the optimization starts.
 */
public synchronized void open() {
	if (injector == null && !isClosed) {
		if (!isInit) {
			throw new IllegalStateException("Task is not initialized. Call method init(modules) first.");
		}
		if (parentInjector == null) {
			injector = Guice.createInjector(modules);
		} else {
			injector = parentInjector.createChildInjector(modules);
		}
	}
}
 

@Before
public void createReconSchemaForTest() throws IOException {
  injector = Guice.createInjector(getReconSqlDBModules());
  dslContext = DSL.using(new DefaultConfiguration().set(
      injector.getInstance(DataSource.class)));
  createSchema(injector);
}
 

@Test(expected = AssertionError.class)
public void evaluateDifferentObjectivesSize() throws TerminationException {
	Injector injector = Guice.createInjector(new MockProblemModule());
	IndividualFactory factory = injector.getInstance(IndividualFactory.class);
	Individual i1 = factory.create();
	Individual i2 = factory.create();

	SequentialIndividualCompleter completer = injector.getInstance(SequentialIndividualCompleter.class);

	i1.setPhenotype("my phenotype");
	i2.setPhenotype("my other phenotype");
	completer.evaluate(i1);
	objectives.add(new Objective("y"), 4);
	completer.evaluate(i2);
}
 

@Before
public void setUp() throws IOException {
  tempFolder.create();
  injector = Guice.createInjector(new AbstractModule() {
    @Override
    protected void configure() {
      File dbDir = tempFolder.getRoot();
      OzoneConfiguration configuration = new OzoneConfiguration();
      configuration.set(OZONE_RECON_DB_DIR, dbDir.getAbsolutePath());
      bind(OzoneConfiguration.class).toInstance(configuration);
      bind(DBStore.class).toProvider(ReconContainerDBProvider.class).in(
          Singleton.class);
    }
  });
}
 

@Override
public DataSourceReader createReader(StructType schema, DataSourceOptions options) {
    SparkSession spark = getDefaultSparkSessionOrCreate();

    Injector injector = Guice.createInjector(
            new BigQueryClientModule(),
            new SparkBigQueryConnectorModule(spark, options, Optional.ofNullable(schema)));

    BigQueryDataSourceReader reader = injector.getInstance(BigQueryDataSourceReader.class);
    return reader;
}
 

public static void main(String[] args) {
    ExecutorService executor = Executors.newSingleThreadExecutor();

    ExampleModule exampleModule = new ExampleModule(executor);
    Injector injector = Guice.createInjector(exampleModule, new AppModule());

    messageClientService = injector.getInstance(MessageClientServiceImpl.class);
}
 

/**
 * The plant overview client's main entry point.
 *
 * @param args the command line arguments
 */
@SuppressWarnings("deprecation")
public static void main(final String[] args) {
  System.setSecurityManager(new SecurityManager());
  Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionLogger(false));
  System.setProperty(org.opentcs.util.configuration.Configuration.PROPKEY_IMPL_CLASS,
                     org.opentcs.util.configuration.XMLConfiguration.class.getName());

  Environment.logSystemInfo();

  Injector injector = Guice.createInjector(customConfigurationModule());
  injector.getInstance(PlantOverviewStarter.class).startPlantOverview();
}