27 import java.util.Map;

28

29 import com.google.inject.Module;

30 import com.google.inject.Scopes;

31 import com.google.inject.servlet.RequestScoped;

32 import com.google.inject.AbstractModule;

33 import com.google.inject.Guice;

34 import com.google.inject.Injector;

55 final T impl,

56 final Module... modules) {

57 return Guice.createInjector(new AbstractModule() {

58 final PrintWriter writer = spy(new PrintWriter(System.out));

59 final HttpServletRequest request = createRequest();

4 import com.google.inject.AbstractModule;

5 import com.google.inject.Guice;

6 import com.google.inject.Injector;

7 import com.google.sitebricks.acceptance.util.AcceptanceTest;

8 import com.google.sitebricks.client.Web;

24

25 public void shouldServiceTopLevelDynamicPath() {

26 WebResponse response = createInjector()

27 .getInstance(Web.class)

28 .clientOf(AcceptanceTest.baseUrl() + "/superpath2/" + TOPLEVEL)

137 private Injector createInjector() {

138 return Guice.createInjector(new AbstractModule() {

139 protected void configure() {

140 bind(ConverterRegistry.class).toInstance(new StandardTypeConverter(

123 }

124 };

125 Injector injector = Guice.createInjector(

126 Stage.PRODUCTION,

127 new LifeCycleModule(),

274 throws Exception

275 {

276 Injector injector = Guice.createInjector(

277 Stage.PRODUCTION,

278 new LifeCycleModule(),

313 }

314 };

315 Injector injector = Guice.createInjector(

316 Stage.PRODUCTION,

317 new LifeCycleModule(),

37 import org.testng.annotations.Test;

38

39 import com.google.common.collect.ImmutableMultimap;

40 import com.google.common.collect.LinkedHashMultimap;

41 import com.google.common.collect.Multimap;

42 import com.google.inject.AbstractModule;

43 import com.google.inject.Guice;

44 import com.google.inject.Injector;

52 @Test(groups = "unit")

53 public class RedirectionRetryHandlerTest {

54 Injector injector = Guice.createInjector(new MockModule(), new RestModule(), new AbstractModule() {

55 @SuppressWarnings("unused")

56 @Provides

47 resourceBundle.put(HELLO, "hello there!");

48

49 String msg = Guice.createInjector(new AbstractModule() {

50 @Override

51 protected void configure() {

197 = new AtomicReference<HttpServletRequest>(japaneseRequest);

198

199 Injector injector = Guice.createInjector(new AbstractModule() {

200 @Override

201 protected void configure() {

242 @Test

243 public final void parameterizedWithNoExternalBundle() {

244 String msg = Guice.createInjector(new AbstractModule() {

245 @Override

246 protected void configure() {

36 import org.testng.annotations.Test;

37

38 import com.google.common.reflect.TypeToken;

39 import com.google.inject.AbstractModule;

40 import com.google.inject.Guice;

41 import com.google.inject.Injector;

73

74 private Injector injectorFor(ProviderMetadata md) {

75 return Guice.createInjector(

76 new BindNameToContext("test"),

77 new BindProviderMetadataContextAndCredentials(md, new Credentials("user", "pass")),

11 * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.

12 */

13 package org.sonatype.guice.bean.containers;

14

15 import java.util.Dictionary;

31 import org.sonatype.guice.bean.binders.SpaceModule;

32 import org.sonatype.guice.bean.binders.WireModule;

33 import org.sonatype.guice.bean.locators.DefaultBeanLocator;

38 import com.google.inject.Binder;

39 import com.google.inject.Guice;

40 import com.google.inject.Injector;

184

185 final ClassSpace space = new BundleClassSpace( bundle );

186 injector = Guice.createInjector( new WireModule( this, new SpaceModule( space ) ) );

187 final Dictionary<Object, Object> metadata = new Hashtable<Object, Object>();

188 metadata.put( Constants.SERVICE_PID, "org.sonatype.inject" );

1 /**

2 * Copyright (C) 2012 Google Inc.

3 *

4 * Licensed under the Apache License, Version 2.0 (the "License");

20 import com.google.inject.AbstractModule;

21 import com.google.inject.Guice;

22 import com.google.inject.Injector;

68

69 public void testTransferNonHttpRequest() throws Exception {

70 final Injector injector = Guice.createInjector(new AbstractModule() {

71 @Override protected void configure() {

72 bindScope(RequestScoped.class, ServletScopes.REQUEST);

98

99 public void testTransferNonHttpRequest_closeable() throws Exception {

100 final Injector injector = Guice.createInjector(new AbstractModule() {

101 @Override protected void configure() {

102 bindScope(RequestScoped.class, ServletScopes.REQUEST);

37 import com.google.inject.AbstractModule;

38 import com.google.inject.Guice;

39 import com.google.inject.Injector;

40 import com.google.inject.Key;

41 import com.google.inject.TypeLiteral;

48 @Test(groups = "unit")

49 public class ParseImageFromJsonResponseTest {

50 Injector i = Guice.createInjector(new AbstractModule() {

51

52 @Override

73

74 public static Image parseImage() {

75 Injector i = Guice.createInjector(new AbstractModule() {

76

77 @Override

39 @Test

40 public void createDynamicModule() {

41 Injector injector = Guice.createInjector(new TestStartupModule(SonatypeScanner.class,

42 PackageFilter.create(PackageFilterTests.class)));

43 assertNotNull(injector);

75 @Test

76 public void createSecondTestInterface() {

77 Injector injector = Guice.createInjector(new TestStartupModule(SonatypeScanner.class,

78 PackageFilter.create(PackageFilterTests.class)));

79 assertNotNull(injector);

88 @Test

89 public void createAllInterfaces() {

90 Injector injector = Guice.createInjector(new TestStartupModule(SonatypeScanner.class,

91 PackageFilter.create(PackageFilterTests.class)));

92 assertNotNull(injector);

39 @Test

40 public void createDynamicModule() {

41 Injector injector = Guice.createInjector(new TestStartupModule(SonatypeScanner.class,

42 PackageFilter.create(AutobindTests.class, false)));

43 assertNotNull(injector);

75 @Test

76 public void createSecondTestInterface() {

77 Injector injector = Guice.createInjector(new TestStartupModule(SonatypeScanner.class,

78 PackageFilter.create(AutobindTests.class, false)));

79 assertNotNull(injector);

88 @Test

89 public void createAllInterfaces() {

90 Injector injector = Guice.createInjector(new TestStartupModule(SonatypeScanner.class,

91 PackageFilter.create(AutobindTests.class, false)));

92 assertNotNull(injector);

15 * limitations under the License.

16 */

17 package org.apache.camel.guice;

18

19 import java.util.List;

31 import org.apache.camel.RoutesBuilder;

32 import org.apache.camel.TypeConverter;

33 import org.apache.camel.guice.impl.GuiceInjector;

34 import org.apache.camel.guice.inject.Injectors;

47 * <p/>

48 * It is recommended you use this implementation with the

49 * <a href="http://code.google.com/p/guiceyfruit/wiki/GuiceyJndi">Guicey JNDI Provider</a>

50 *

51 * @version

55

56 @Inject

57 public GuiceCamelContext(com.google.inject.Injector injector) {

58 this.injector = injector;

59 }

6 import static org.easymock.EasyMock.verify;

7

8 import com.google.inject.Guice;

9 import com.google.inject.Injector;

46

47 public final void testDispatchRequestToManagedPipeline() throws ServletException, IOException {

48 final Injector injector = Guice.createInjector(new ServletModule() {

49

50 @Override

86

87 public final void testDispatchThatNoFiltersFire() throws ServletException, IOException {

88 final Injector injector = Guice.createInjector(new ServletModule() {

89

90 @Override

127 IOException {

128

129 final Injector injector = Guice.createInjector(new ServletModule() {

130

131 @Override

1 package com.yammer.metrics.guice.tests;

2

3 import com.google.inject.Guice;

4 import com.google.inject.Injector;

25 @Before

26 public void setup() {

27 Injector injector = Guice.createInjector(new InstrumentationModule());

28 instance = injector.getInstance(InstrumentedWithExceptionMetered.class);

29 registry = injector.getInstance(MetricsRegistry.class);

234 is("poops"));

235

236 assertThat("Guice creates a meter with the given rate unit",

237 ((MeterMetric) metric).rateUnit(),

238 is(TimeUnit.MINUTES));

259 is(instanceOf(TimerMetric.class)));

260

261 assertThat("Guice creates a metric",

262 errorMetric,

263 is(notNullValue()));

35 import com.google.common.collect.ImmutableSortedSet;

36 import com.google.inject.Guice;

37 import com.google.inject.Injector;

38 import com.google.inject.Key;

39 import com.google.inject.TypeLiteral;

46 @Test(groups = "unit")

47 public class ParseContainerCDNMetadataListFromJsonResponseTest {

48 Injector i = Guice.createInjector(new GsonModule());

49

50 @Test

10 import com.google.common.collect.ImmutableMap;

11 import com.google.inject.Guice;

12 import com.google.inject.Injector;

20 import play.inject.guice.GuiceApplicationBuilder;

21 import play.inject.guice.GuiceApplicationLoader;

22

23 import static org.hamcrest.CoreMatchers.*;

65 "db.other.driver", "org.h2.Driver",

66 "db.other.url", "jdbc:h2:mem:other");

67 Injector injector = createInjector(config);

68 assertThat(

69 injector.getInstance(NamedOtherComponent.class).db.getUrl(), equalTo("jdbc:h2:mem:other"));

107 new GuiceApplicationLoader().builder(new Context(Environment.simple(), config));

108 return Guice.createInjector(builder.applicationModule());

109 }

110

28 import xivo.restapi.model.User;

29

30 import com.google.inject.Guice;

31 import com.google.inject.Inject;

32 import com.google.inject.Injector;

33

34 public abstract class AbstractLdapSynchronizer {

59 }

60 AbstractLDAPModule module = getModuleInstance(moduleClass, parsing);

61 Injector injector = Guice.createInjector(module);

62 AbstractLdapSynchronizer synchronizer = injector.getInstance(AbstractLdapSynchronizer.class);

63 synchronizer.setUp();

34 import com.google.common.collect.ImmutableSet;

35 import com.google.inject.Guice;

36 import com.google.inject.Injector;

45 @Override

46 protected Injector injector() {

47 return Guice.createInjector(new CloudStackParserModule(), new GsonModule() {

48

49 @Override

31 import com.google.common.collect.ImmutableSet;

32 import com.google.inject.Guice;

33 import com.google.inject.Injector;

41

42 protected Injector injector() {

43 return Guice.createInjector(new GsonModule(), new IBMSmartCloudParserModule());

44 }

45

35 import com.google.common.collect.Maps;

36 import com.google.inject.Guice;

37 import com.google.inject.Injector;

44 @Test(groups = "unit")

45 public class BindBlockDeviceMappingToIndexedFormParamsTest {

46 Injector injector = Guice.createInjector();

47 BindBlockDeviceMappingToIndexedFormParams binder = injector

48 .getInstance(BindBlockDeviceMappingToIndexedFormParams.class);

36 import com.google.common.collect.ImmutableMap;

37 import com.google.inject.Guice;

38 import com.google.inject.Injector;

48 public void testApplyInputStream() {

49 InputStream is = getClass().getResourceAsStream("/vdc.xml");

50 Injector injector = Guice.createInjector(new SaxParserModule());

51 Factory factory = injector.getInstance(ParseSax.Factory.class);

52

15 import com.google.inject.AbstractModule;

16 import com.google.inject.Guice;

17 import com.google.inject.Injector;

18 import com.google.inject.Provider;

19 import com.google.inject.matcher.Matchers;

122

123 private TestClass createTestClass(final Provider<TransactionManager> provider) {

124 Injector injector = Guice.createInjector(new AbstractModule() {

125

126 @Override

1 package com.google.sitebricks.stat;

2

3 import com.google.common.collect.ImmutableMap;

4 import com.google.inject.AbstractModule;

5 import com.google.inject.Guice;

6 import com.google.inject.Injector;

7 import com.google.sitebricks.stat.testservices.ChildDummyService;

8 import com.google.sitebricks.stat.testservices.DummyService;

9 import com.google.sitebricks.stat.testservices.StatExposerTestingService;

10 import com.google.sitebricks.stat.testservices.StaticDummyService;

26 @BeforeMethod

27 public final void before() {

28 injector = Guice.createInjector(new AbstractModule() {

29 @Override

30 protected void configure() {

46 import org.testng.annotations.Test;

47

48 import com.google.common.collect.ImmutableMap;

49 import com.google.inject.AbstractModule;

50 import com.google.inject.Guice;

51

52 /**

83 replay(crypto, rsaKeyPairGenerator, secureRandom);

84

85 RsaSshKeyPairGenerator supplier = Guice.createInjector(new AbstractModule(){

86 protected void configure() {

87 bind(Crypto.class).toInstance(crypto);

25 import java.util.Properties;

26

27 import com.google.inject.Guice;

28 import com.google.inject.Injector;

31 import com.netflix.config.DynamicPropertyFactory;

32 import com.netflix.config.DynamicStringProperty;

33 import com.netflix.governator.guice.LifecycleInjector;

34 import com.netflix.governator.lifecycle.LifecycleManager;

35

63 try

64 {

65 // Injector injector = Guice.createInjector(new Amd64MinimalBootstrapModule());

66

67 // Injector injector = LifecycleInjector.builder().withBootstrapModule(new GentooBootstrapModule()).createInjector();

70 if ("hvm".equals(virtualizationType.get()))

71 {

72 injector = LifecycleInjector.builder().withBootstrapModule(new HvmBootstrapModule()).createInjector();

73 }

74 else if ("hvm1".equals(virtualizationType.get()))

41 import org.virtualbox_4_1.VirtualBoxManager;

42

43 import com.google.inject.Guice;

44

45 @Test(groups = "unit")

47

48 Map<OsFamily, Map<String, String>> map = new BaseComputeServiceContextModule() {

49 }.provideOsVersionMap(new ComputeServiceConstants.ReferenceData(), Guice.createInjector(new GsonModule())

50 .getInstance(Json.class));

51

38 import org.testng.annotations.Test;

39

40 import com.google.common.base.Function;

41 import com.google.common.base.Throwables;

42 import com.google.common.collect.ImmutableList;

43 import com.google.inject.Guice;

44 import com.google.inject.Injector;

86

87 protected Injector injector() {

88 return Guice.createInjector(new GsonModule() {

89 protected void configure() {

90 bind(DateAdapter.class).to(Iso8601DateAdapter.class);

1 /**

2 * Copyright (C) 2009 Google Inc.

3 *

4 * Licensed under the Apache License, Version 2.0 (the "License");

15 */

16

17 package com.googlecode.guice.bundle;

18

19 import static com.google.inject.name.Names.named;

21 import com.google.inject.AbstractModule;

22 import com.google.inject.Guice;

23 import com.google.inject.Inject;

485 final Bundle bundle = context.getBundle();

486

487 Injector injector = Guice.createInjector(new TestModule(bundle));

488 /*if[AOP]*/

489 Injector aopInjector = Guice.createInjector(new TestModule(bundle), new InterceptorModule());

24 import org.apache.s4.core.Stream;

25

26 import com.google.inject.Guice;

27 import com.google.inject.Injector;

133 public static void main(String[] args) {

134

135 Injector injector = Guice.createInjector(new Module());

136 MyApp myApp = injector.getInstance(MyApp.class);

137 Sender sender = injector.getInstance(Sender.class);

34 import org.testng.annotations.Test;

35

36 import com.google.common.base.Function;

37 import com.google.common.collect.ImmutableSet;

38 import com.google.inject.AbstractModule;

39 import com.google.inject.Guice;

40 import com.google.inject.TypeLiteral;

47 public class ListOfKeyValuesDelimitedByBlankLinesToServerInfoSetTest {

48

49 private static final ListOfKeyValuesDelimitedByBlankLinesToServerInfoSet FN = Guice.createInjector(

50 new AbstractModule() {

51

36 import com.google.common.collect.ImmutableSet;

37 import com.google.inject.Guice;

38 import com.google.inject.Injector;

82

83 protected Injector injector() {

84 return Guice.createInjector(new NovaParserModule(), new GsonModule());

85 }

86

27 import com.google.common.collect.ImmutableMap;

28 import com.google.inject.Guice;

29 import com.google.inject.Injector;

30 import com.google.inject.assistedinject.FactoryModuleBuilder;

31

32 /**

38 public class BindToJsonPayloadWrappedWithTest {

39

40 Injector injector = Guice.createInjector(new GsonModule(), new FactoryModuleBuilder()

41 .build(BindToJsonPayloadWrappedWith.Factory.class));

42

40 import com.google.common.io.Closeables;

41 import com.google.inject.Guice;

42 import com.google.inject.Injector;

44 import com.google.inject.TypeLiteral;

45 import com.google.inject.servlet.GuiceServletContextListener;

46 import com.google.inject.servlet.ServletModule;

51 * @author Adrian Cole

52 */

53 public class GuiceServletConfig extends GuiceServletContextListener {

54

55 private Iterable<BlobStoreContext> blobsStoreContexts;

90 @Override

91 protected Injector getInjector() {

92 return Guice.createInjector(new ServletModule() {

93 @Override

94 protected void configureServlets() {

33 import com.google.inject.AbstractModule;

34 import com.google.inject.Guice;

35 import com.google.inject.TypeLiteral;

110

111 public void testPropertyChangesDelimiter() {

112 GroupNamingConvention fn = Guice.createInjector(new AbstractModule() {

113

114 @Override

125

126 public void testPropertyChangesPrefix() {

127 GroupNamingConvention fn = Guice.createInjector(new AbstractModule() {

128

129 @Override

141

142 public void testCanChangeSuffixSupplier() {

143 GroupNamingConvention fn = Guice.createInjector(new AbstractModule() {

144

145 @Override

32 import org.testng.annotations.Test;

33

34 import com.google.common.collect.ImmutableMap;

35 import com.google.common.collect.ImmutableSet;

36 import com.google.inject.Guice;

37 import com.google.inject.Injector;

44 @Test(groups = "unit")

45 public class BindTagFiltersToIndexedFormParamsTest {

46 Injector injector = Guice.createInjector();

47 BindTagFiltersToIndexedFormParams binder = injector.getInstance(BindTagFiltersToIndexedFormParams.class);

48

29 import org.testng.annotations.Test;

30

31 import com.google.common.collect.ImmutableMap;

32 import com.google.inject.AbstractModule;

33 import com.google.inject.Guice;

34 import com.google.inject.Injector;

35 import com.google.inject.name.Names;

36

37 /**

43 public class ParseAuthenticationResponseFromHeadersTest {

44

45 Injector i = Guice.createInjector(new AbstractModule() {

46

47 @Override

28 import com.google.common.collect.ImmutableMap;

29 import com.google.inject.Guice;

30 import com.google.inject.Injector;

38 public class CreateSharedIpGroupOptionsTest {

39

40 Injector injector = Guice.createInjector(new GsonModule());

41

42 @Test

33 import com.google.common.collect.ImmutableSet;

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

69 @Override

70 protected Injector injector() {

71 return Guice.createInjector(new GsonModule(), new CloudStackParserModule());

72 }

73 }

13 import com.google.inject.AbstractModule;

14 import com.google.inject.Guice;

15 import com.google.inject.Injector;

16 import com.google.inject.multibindings.Multibinder;

17 import org.eclipse.che.api.core.NotFoundException;

18 import org.eclipse.che.api.project.server.*;

41 public void setUp() throws Exception {

42 // Bind components

43 injector = Guice.createInjector(new AbstractModule() {

44 @Override

45 protected void configure() {

55 @Test

56 public void textReply() throws IOException {

57 Injector injector = Guice.createInjector();

58 HeadlessRenderer renderer = injector.getInstance(HeadlessRenderer.class);

59 HttpServletResponse response = createNiceMock(HttpServletResponse.class);

79 @Test

80 public void jsonReply() throws IOException {

81 Injector injector = Guice.createInjector(new AbstractModule() {

82 @SuppressWarnings("rawtypes")

83 @Override

120 @Test

121 public void xmlReplyWithHeaders() throws IOException {

122 Injector injector = Guice.createInjector();

123 HeadlessRenderer renderer = injector.getInstance(HeadlessRenderer.class);

124 HttpServletResponse response = createNiceMock(HttpServletResponse.class);

29 import org.testng.annotations.Test;

30

31 import com.google.inject.Guice;

32 import com.google.inject.Injector;

39 @Test(groups = "unit")

40 public class BindInstanceIdsToIndexedFormParamsTest {

41 Injector injector = Guice.createInjector();

42 BindInstanceIdsToIndexedFormParams binder = injector.getInstance(BindInstanceIdsToIndexedFormParams.class);

43

25 import com.google.inject.AbstractModule;

26 import com.google.inject.Guice;

27 import com.google.inject.name.Names;

37 @Test

38 public void testNotThere() {

39 assertEquals(Guice.createInjector().getInstance(ValueOfConfigurationKeyOrNull.class).apply("foo"), null);

40 }

41

42 @Test

43 public void testThere() {

44 assertEquals(Guice.createInjector(new AbstractModule() {

45

46 @Override

54 @Test

55 public void testEmptyIsThere() {

56 assertEquals(Guice.createInjector(new AbstractModule() {

57

58 @Override

29 import com.google.inject.AbstractModule;

30 import com.google.inject.Guice;

31 import com.google.inject.Provides;

40

41 public void testEmptyWhenNoStringsBound() {

42 FilterStringsBoundToInjectorByName fn = Guice.createInjector().getInstance(FilterStringsBoundToInjectorByName.class);

43 assertEquals(fn.apply(Predicates.<String> alwaysTrue()), ImmutableMap.<String, String> of());

44 }

45

46 public void testEmptyWhenNotStringsBound() {

47 FilterStringsBoundToInjectorByName fn = Guice.createInjector(new AbstractModule() {

48

49 @Override

59 public void testReturnsGuiceNamedString() {

60 FilterStringsBoundToInjectorByName fn = Guice.createInjector(new AbstractModule() {

61

62 @Override

1 package com.proofpoint.configuration;

2

3 import com.google.common.collect.ImmutableList;

4 import com.google.common.collect.ImmutableMap;

5 import com.google.common.collect.Iterators;

6 import com.google.inject.Binder;

7 import com.google.inject.Guice;

8 import com.google.inject.Module;

69 List<Message> messages = new ConfigurationValidator(configurationFactory).validate(module);

70 InspectionVerifier verifier = new InspectionVerifier(new ConfigurationInspector().inspect(configurationFactory));

71 Guice.createInjector(new ConfigurationModule(configurationFactory), module, new ValidationErrorModule(messages));

72 return verifier;

73 }

16 package com.proofpoint.configuration;

17

18 import com.google.common.collect.ImmutableList;

19 import com.google.common.collect.ImmutableMap;

20 import com.google.inject.Binder;

21 import com.google.inject.CreationException;

22 import com.google.inject.Guice;

23 import com.google.inject.Injector;

24 import com.google.inject.Module;

25 import com.google.inject.spi.Message;

35 import java.util.TreeMap;

36

37 import static com.google.common.base.MoreObjects.firstNonNull;

38 import static com.proofpoint.configuration.ConfigBinder.bindConfig;

39 import static com.proofpoint.testing.Assertions.assertContainsAllOf;

31 import com.google.common.collect.ImmutableMap;

32 import com.google.inject.Guice;

33 import com.google.inject.Injector;

40 @Test(groups = "unit")

41 public class BindTagsToIndexedFormParamsTest {

42 Injector injector = Guice.createInjector();

43 BindTagsToIndexedFormParams binder = injector.getInstance(BindTagsToIndexedFormParams.class);

44

25 import org.testng.annotations.Test;

26

27 import com.google.inject.Guice;

28 import com.google.inject.Injector;

29 import com.google.inject.Stage;

30 import com.ning.billing.catalog.api.BillingPeriod;

31 import com.ning.billing.catalog.api.IDuration;

40 @Override

41 protected Injector getInjector() {

42 return Guice.createInjector(Stage.DEVELOPMENT, new EngineModuleSqlMock());

43 }

44

45

46 import com.beust.jcommander.internal.Lists;

47 import com.google.common.base.Function;

48 import com.google.common.base.Suppliers;

49 import com.google.inject.Guice;

50

51 @Test(groups = "unit")

53

54 Map<OsFamily, Map<String, String>> osMap = new BaseComputeServiceContextModule() {

55 }.provideOsVersionMap(new ComputeServiceConstants.ReferenceData(), Guice.createInjector(new GsonModule())

56 .getInstance(Json.class));

57

17

18 import com.fasterxml.jackson.annotation.JsonProperty;

19 import com.google.auto.value.AutoValue;

20 import com.google.common.collect.ImmutableList;

21 import com.google.common.collect.ImmutableMap;

22 import com.google.inject.Guice;

23 import com.google.inject.Injector;

24 import com.google.inject.Key;

25 import com.google.inject.TypeLiteral;

45 {

46 TraceTokenManager.clearRequestToken();

47 Injector injector = Guice.createInjector(

48 new TestingAuditLogModule(),

49 new JsonModule(),

29 import org.testng.annotations.Test;

30

31 import com.google.inject.Guice;

32 import com.google.inject.Injector;

39 @Test(groups = "unit")

40 public class BindGroupNamesToIndexedFormParamsTest {

41 Injector injector = Guice.createInjector();

42 BindGroupNamesToIndexedFormParams binder = injector.getInstance(BindGroupNamesToIndexedFormParams.class);

43

37 import org.testng.annotations.Test;

38

39 import com.google.common.collect.ImmutableMap;

40 import com.google.inject.AbstractModule;

41 import com.google.inject.Guice;

42 import com.google.inject.TypeLiteral;

50

51 public void testReturnsCorrectFunction() {

52 PersistNodeCredentials persistNodeCredentials = Guice.createInjector(new PersistNodeCredentialsModule(),

53 new AbstractModule() {

54

4 import com.google.common.collect.ImmutableList;

5 import com.google.inject.Guice;

6 import com.google.inject.Injector;

7 import com.google.inject.Module;

8 import org.embulk.config.ConfigSource;

9 import org.embulk.exec.SystemConfigModule;

13 import org.embulk.plugin.BuiltinPluginSourceModule;

14 import org.embulk.jruby.JRubyScriptingModule;

15 import static com.google.common.base.Preconditions.checkState;

16

17 @Deprecated

60 modules = overrideModules(modules, systemConfig);

61

62 injector = Guice.createInjector(modules);

63 initialized = true;

64

4 import com.google.inject.AbstractModule;

5 import com.google.inject.Guice;

6 import com.google.inject.Injector;

7 import com.google.sitebricks.acceptance.util.AcceptanceTest;

8 import com.google.sitebricks.client.Web;

9 import com.google.sitebricks.client.WebResponse;

10 import com.google.sitebricks.client.transport.Json;

11 import com.google.sitebricks.conversion.Converter;

12 import com.google.sitebricks.conversion.ConverterRegistry;

13 import com.google.sitebricks.conversion.StandardTypeConverter;

104 private Injector createInjector() {

105 return Guice.createInjector(new AbstractModule() {

106 protected void configure() {

107 bind(ConverterRegistry.class).toInstance(new StandardTypeConverter(

24 import org.junit.Test;

25

26 import com.google.common.collect.Iterables;

27 import com.google.inject.Binder;

28 import com.google.inject.Guice;

29 import com.google.inject.Inject;

30 import com.google.inject.Injector;

31

32 public class Bug250313Test extends AbstractXtextTests {

45 public Injector createInjector() {

46 return Guice.createInjector(new MyBug250313RuntimeModule(Bug250313Test.this));

47 }

48 });

14 import com.google.inject.multibindings.Multibinder;

15 import com.google.template.soy.SoyFileSet;

16 import com.google.template.soy.SoyModule;

17 import com.google.template.soy.jssrc.SoyJsSrcOptions;

18 import com.google.template.soy.shared.restricted.SoyFunction;

19 import com.google.template.soy.xliffmsgplugin.XliffMsgPluginModule;

20

21 import org.dom4j.Element;

66 guiceModules.add(new OurFunctionsModule());

67

68 final Injector injector = Guice.createInjector(guiceModules);

69

70 SoyFileSet.Builder sfsBuilder = injector.getInstance(SoyFileSet.Builder.class);

33 import com.google.common.collect.Iterables;

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

43 public class InstantiateVAppTemplateOptionsTest {

44

45 Injector injector = Guice.createInjector(new SaxParserModule());

46

47 @Test

35 import org.testng.annotations.Test;

36

37 import com.google.inject.Guice;

38

39 /**

59

60 CloudServersImageToImage parser = new CloudServersImageToImage(new CloudServersImageToOperatingSystem(new BaseComputeServiceContextModule() {

61 }.provideOsVersionMap(new ComputeServiceConstants.ReferenceData(), Guice.createInjector(new GsonModule())

62 .getInstance(Json.class))));

63

37 import org.testng.annotations.Test;

38

39 import com.google.common.base.Function;

40 import com.google.common.collect.ImmutableSet;

41 import com.google.inject.AbstractModule;

42 import com.google.inject.Guice;

43 import com.google.inject.TypeLiteral;

50 public class BindDriveDataToPlainTextStringTest {

51

52 private static final BindDriveDataToPlainTextString FN = Guice.createInjector(new AbstractModule() {

53

54 @Override

34 import com.google.common.collect.Iterables;

35 import com.google.inject.Guice;

36 import com.google.inject.Injector;

45 public void testVCloud1_0() {

46 InputStream is = getClass().getResourceAsStream("/networkconnectionsection.xml");

47 Injector injector = Guice.createInjector(new SaxParserModule());

48 Factory factory = injector.getInstance(ParseSax.Factory.class);

49 NetworkConnectionSection result = factory.create(injector.getInstance(NetworkConnectionSectionHandler.class))

41 import org.testng.annotations.Test;

42

43 import com.google.common.base.Supplier;

44 import com.google.common.base.Suppliers;

45 import com.google.common.collect.ImmutableMap;

46 import com.google.inject.AbstractModule;

47 import com.google.inject.Guice;

48 import com.google.inject.TypeLiteral;

60 @BeforeClass

61 public void setup() throws InvalidKeySpecException, NoSuchAlgorithmException, IOException {

62 namingConvention = Guice.createInjector(new AbstractModule() {

63

64 @Override

39 */

40

41 import com.google.inject.Guice;

42 import com.google.inject.Injector;

64 @BeforeClass

65 public static void init() {

66 injector = Guice.createInjector(new TestModule());

67 }

68

3 import com.google.gson.Gson;

4 import com.google.inject.Guice;

5 import com.google.inject.Inject;

6 import com.google.inject.Injector;

7 import nu.marginalia.process.log.WorkLog;

8 import plan.CrawlPlanLoader;

33 var plan = new CrawlPlanLoader().load(Path.of(args[0]));

34

35 Injector injector = Guice.createInjector(

36 new ConverterModule(plan)

37 );

81

82 public void testEverythingInjectorGetInstance() {

83 Guice.createInjector(everythingModule)

84 .getInstance(HasOptionalInjections.class)

85 .assertEverythingInjected();

117

118 public void testEverythingInjectorToInstance() {

119 Guice.createInjector(everythingModule, toInstanceModule)

120 .getInstance(HasOptionalInjections.class)

121 .assertEverythingInjected();

275 */

276 public void testIndirectOptionalInjection() {

277 Indirect indirect = Guice.createInjector().getInstance(Indirect.class);

278 assertNotNull(indirect.hasOptionalInjections);

279 indirect.hasOptionalInjections.assertNothingInjected();

3 import com.google.inject.AbstractModule;

4 import com.google.inject.Guice;

5 import com.google.inject.Injector;

58 // dormMetadata.setAuthor("greg");

59 DormResource expectedResource = new DefaultDormResource("zenika_test", "jar", testJarRepo);

60 Injector injector = Guice.createInjector(new AbstractModule() {

61 @Override

62 protected void configure() {

18 import com.google.inject.AbstractModule;

19 import com.google.inject.Guice;

20 import com.google.inject.Injector;

21 import com.google.inject.Provides;

22 import com.google.inject.Stage;

59 variables.set(SHELL_GROUP_PATH, ".:/");

60

61 Injector injector = Guice.createInjector(Stage.DEVELOPMENT, new AbstractModule() {

62 @Override

63 protected void configure() {

18 import com.google.inject.Binder;

19 import com.google.inject.Guice;

20 import com.google.inject.Module;

274 private static TestingHttpServer createServer(final TestResource resource)

275 {

276 return Guice.createInjector(

277 new TestingNodeModule(),

278 new JaxrsModule(true),

34 import com.google.inject.AbstractModule;

35 import com.google.inject.Guice;

36 import com.google.inject.name.Names;

47 public class OnlyReferenceTypeFirstWithNameMatchingConfigurationKeyOrDefaultTest {

48 ValueOfConfigurationKeyOrNull valueOfConfigurationKeyOrNull = new ValueOfConfigurationKeyOrNull(

49 Guice.createInjector());

50

51 @Test(expectedExceptions = IllegalArgumentException.class)

93

94 assertEquals(new OnlyReferenceTypeFirstWithNameMatchingConfigurationKeyOrDefault(

95 new ValueOfConfigurationKeyOrNull(Guice.createInjector(new AbstractModule() {

96

97 @Override

111

112 new OnlyReferenceTypeFirstWithNameMatchingConfigurationKeyOrDefault(new ValueOfConfigurationKeyOrNull(

113 Guice.createInjector(new AbstractModule() {

114

115 @Override

37 import org.testng.annotations.Test;

38

39 import com.google.inject.Guice;

40

41 /**

85 SlicehostImageToImage parser = new SlicehostImageToImage(new SlicehostImageToOperatingSystem(

86 new BaseComputeServiceContextModule() {

87 }.provideOsVersionMap(new ComputeServiceConstants.ReferenceData(), Guice.createInjector(new GsonModule())

88 .getInstance(Json.class))));

89

1 package servlet;

2

3 import com.google.inject.Guice;

4 import com.google.inject.Injector;

5 import entity.TodoEntity;

6 import guice.GuiceModule;

7 import java.io.IOException;

8 import java.io.PrintWriter;

23 throws ServletException, IOException {

24

25 Injector injector = Guice.createInjector(new GuiceModule());

26 TodoService todoService = injector.getInstance(TodoService.class);

27

29 import org.testng.annotations.Test;

30

31 import com.google.inject.Guice;

32 import com.google.inject.Injector;

40

41 protected Injector injector() {

42 return Guice.createInjector(new GsonModule(), new IBMSmartCloudParserModule());

43 }

44

29 import com.google.inject.Binding;

30 import com.google.inject.Guice;

31 import com.google.inject.Injector;

32 import com.google.inject.Key;

33 import com.google.inject.Module;

34 import com.google.inject.Scope;

35 import com.google.inject.Scopes;

36 import com.google.inject.Singleton;

37 import com.google.inject.spi.BindingScopingVisitor;

38

39 /**

158 private void createInjector() {

159 injector =

160 Guice.createInjector(Peaberry.osgiModule(bundle.getBundleContext()), Reflection

161 .create(moduleClass));

162 }

30 import org.testng.annotations.Test;

31

32 import com.google.inject.Guice;

33 import com.google.inject.Injector;

69

70 protected Injector injector() {

71 return Guice.createInjector(new SmartOSParserModule(), new GsonModule());

72 }

73 }

13 import org.apache.commons.io.FileUtils;

14

15 import com.google.inject.Guice;

16 import com.google.inject.Injector;

21 import com.saltaku.data.area.relationfinder.RelationFinderException;

22 import com.saltaku.data.area.writer.io.DataStoreProvider;

23 import com.saltaku.data.server.guice.DefaultModule;

24 import com.saltaku.geo.GeoException;

25 import com.saltaku.geo.GeoProcessor;

57 public InsertSampleData()

58 {

59 injector = Guice.createInjector(new DefaultModule(new Properties()) );

60 gp=injector.getInstance(GeoProcessor.class);

61 db=injector.getInstance(DBStore.class);

30 import org.testng.annotations.Test;

31

32 import com.google.common.collect.ImmutableMap;

33 import com.google.common.collect.ImmutableSet;

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

67

68 protected Injector injector() {

69 return Guice.createInjector(new GsonModule() {

70

71 @Override

40 @Test

41 public void createDynamicModule() {

42 Injector injector = Guice.createInjector(StartupModule.create(ReflectionsScanner.class,

43 PackageFilter.create(MultibindTests.class)));

44 assertNotNull(injector);

47 @Test

48 public void testWithWrongPackage1() {

49 Injector injector = Guice.createInjector(StartupModule.create(ReflectionsScanner.class,

50 PackageFilter.create("java.util.concurrent")));

51 assertNotNull(injector);

109 @Test

110 public void createAllInterfaces() {

111 Injector injector = Guice.createInjector(StartupModule.create(ReflectionsScanner.class,

112 PackageFilter.create(MultibindTests.class)));

113 assertNotNull(injector);

17 import com.google.inject.AbstractModule;

18 import com.google.inject.Guice;

19 import com.google.inject.Injector;

20 import com.google.inject.Stage;

21

22 import cucumber.api.guice.CucumberModules;

23 import cucumber.runtime.java.guice.InjectorSource;

24

25 import com.amazonaws.AmazonWebServiceClient;

36 @Override

37 public Injector getInjector() {

38 return Guice.createInjector(Stage.PRODUCTION, CucumberModules.SCENARIO,

39 new AWSMarketplaceCommerceAnalyticsModule());

40 }

10 import org.opengis.referencing.operation.TransformException;

11

12 import com.google.inject.Guice;

13 import com.google.inject.Injector;

25 public static void main( String[] args ) throws ImportException, MalformedURLException

26 {

27 Injector injector = Guice.createInjector(new AreaModule());

28

29 /*

33 import org.testng.annotations.Test;

34

35 import com.google.inject.Guice;

36

37 /**

48 InputStream is = getClass().getResourceAsStream("/test_error_handler.json");

49

50 GoGridErrorHandler handler = Guice.createInjector(new GsonModule()).getInstance(GoGridErrorHandler.class);

51

52 HttpCommand command = createHttpCommand();

29 import org.apache.myfaces.config.element.ManagedBean;

30

31 import com.google.inject.Injector;

32

33 /**

36 * </p>

37 *

38 * &ltapplication> &ltel-resolver>org.apache.myfaces.el.unified.resolver.GuiceResolver&lt/el-resolver> &lt/application>

39 *

40 * <p>

42 * </p>

43 *

44 * &ltlistener> <listener-class>com.your_company.GuiceServletContextListener&lt/listener-class> &lt/listener>

45 *

46 * <p>

51 *

52 * public void contextInitialized(ServletContextEvent event) { ServletContext ctx = event.getServletContext(); //when on

53 * Java6, use ServiceLoader.load(com.google.inject.Module.class); Injector injector = Guice.createInjector(new

54 * YourModule()); ctx.setAttribute(GuiceResolver.KEY, injector); }

21 import com.google.inject.AbstractModule;

22 import com.google.inject.Guice;

23 import com.google.inject.Injector;

57 @Before

58 public void setup() {

59 injector = Guice.createInjector(new EventPublicationListenerModule());

60 }

61

35 import org.testng.annotations.Test;

36

37 import com.google.common.base.Function;

38 import com.google.common.base.Throwables;

39 import com.google.inject.Guice;

40 import com.google.inject.Injector;

80

81 protected Injector injector() {

82 return Guice.createInjector(new GsonModule() {

83

84 @Override

32 import org.testng.annotations.Test;

33

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

49 public void testTerremark() {

50 InputStream is = getClass().getResourceAsStream("/catalog.xml");

51 injector = Guice.createInjector(new SaxParserModule());

52 factory = injector.getInstance(ParseSax.Factory.class);

53 Catalog result = (Catalog) factory.create(injector.getInstance(CatalogHandler.class)).parse(is);

44 public void testHttpSelectorString()

45 {

46 Injector injector = Guice.createInjector(

47 new ConfigurationModule(new ConfigurationFactory(ImmutableMap.<String, String>of())),

48 new TestingNodeModule(),

146 public void testNoHttpServices()

147 {

148 Injector injector = Guice.createInjector(

149 new ConfigurationModule(new ConfigurationFactory(ImmutableMap.<String, String>of())),

150 new TestingNodeModule(),

171 public void testInvalidUris()

172 {

173 Injector injector = Guice.createInjector(

174 new ConfigurationModule(new ConfigurationFactory(ImmutableMap.<String, String>of())),

175 new TestingNodeModule(),

21 import com.google.common.collect.ImmutableList;

22 import com.google.inject.Guice;

23 import com.google.inject.Injector;

24 import com.google.inject.Key;

25 import com.google.inject.TypeLiteral;

45 public class ParseInetAddressListFromJsonResponseTest {

46

47 Injector i = Guice.createInjector(new GsonModule());

48

49 @Test

33 import com.google.inject.AbstractModule;

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

36 import com.google.inject.Key;

37 import com.google.inject.Provides;

46 @Test

47 void testBindsExecutor() {

48 Injector i = createInjector();

49 assert i.getInstance(Key.get(ExecutorService.class, Names

50 .named(Constants.PROPERTY_USER_THREADS))) != null;

55 private Injector createInjector() {

56 Injector i = Guice.createInjector(new LifeCycleModule() {

57 @SuppressWarnings("unused")

58 @Provides

6 import static com.google.inject.util.Modules.override;

7 import static com.google.inject.Guice.createInjector;

8

9 import org.apache.log4j.Logger;

12 import org.osgi.framework.BundleContext;

13

14 import com.google.inject.Injector;

15 import com.google.inject.Module;

78

79 protected void registerInjectorFor(String language) throws Exception {

80 injectors.put(language, createInjector(

81 override(override(getRuntimeModule(language)).with(getSharedStateModule())).with(getUiModule(language))));

82 }

10 import com.google.inject.AbstractModule;

11 import com.google.inject.Guice;

12 import com.google.inject.Inject;

13 import com.google.inject.Injector;

14 import com.google.inject.name.Named;

56

57 /* After some indirection we get the injector. */

58 injector = Guice.createInjector(module);

59

60 fwkLauncher.launch();

33 import com.google.common.collect.ImmutableSet;

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

43

44 protected Injector injector() {

45 return Guice.createInjector(new GsonModule(), new IBMSmartCloudParserModule());

46 }

47

19 package org.jclouds.cloudsigma.functions;

20

21 import static com.google.common.collect.Iterables.transform;

22 import static com.google.common.collect.Lists.newArrayList;

39 import org.testng.annotations.Test;

40

41 import com.google.common.base.Function;

42 import com.google.gson.Gson;

43 import com.google.inject.Guice;

44 import com.google.inject.TypeLiteral;

71

72 ParseOsFamilyVersion64BitFromImageName parser = new ParseOsFamilyVersion64BitFromImageName(new BaseComputeServiceContextModule() {

73 }.provideOsVersionMap(new ComputeServiceConstants.ReferenceData(), Guice.createInjector(new GsonModule())

74 .getInstance(Json.class)));

75

30 import org.testng.annotations.Test;

31

32 import com.google.common.util.concurrent.ExecutionList;

33 import com.google.inject.AbstractModule;

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

36 import com.google.inject.Key;

37 import com.google.inject.Provides;

38 import com.google.inject.name.Names;

39

40 /**

56 private Injector createInjector() {

57 Injector i = Guice.createInjector(new LifeCycleModule() {

58 @SuppressWarnings("unused")

59 @Provides

1 package org.openlogics.aop.jdbc;

2

3 import com.google.common.base.Strings;

4 import com.google.inject.AbstractModule;

5 import com.google.inject.Guice;

6 import com.google.inject.Inject;

7 import com.google.inject.Injector;

8 import com.google.inject.matcher.Matchers;

39 public void setup() {

40

41 Injector injector = Guice.createInjector(new AbstractModule() {

42 @Override

43 protected void configure() {

33 import com.google.common.collect.ImmutableSet;

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

73 @Override

74 protected Injector injector() {

75 return Guice.createInjector(new GsonModule(), new CloudStackParserModule());

76 }

77

1 package com.yammer.metrics.guice.tests;

2

3 import com.google.inject.Guice;

4 import com.google.inject.Injector;

25 @Before

26 public void setup() {

27 Injector injector = Guice.createInjector(new InstrumentationModule());

28 instance = injector.getInstance(InstrumentedWithExceptionMetered.class);

29 registry = injector.getInstance(MetricsRegistry.class);

224 is("poops"));

225

226 assertThat("Guice creates a meter with the given rate unit",

227 ((MeterMetric) metric).rateUnit(),

228 is(TimeUnit.MINUTES));

247 is(instanceOf(TimerMetric.class)));

248

249 assertThat("Guice creates a metric",

250 errorMetric,

251 is(notNullValue()));

30 import org.testng.annotations.Test;

31

32 import com.google.common.collect.ImmutableMap;

33 import com.google.common.collect.ImmutableSet;

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

68

69 protected Injector injector() {

70 return Guice.createInjector(new GsonModule() {

71

72 @Override

1 package io.digdag.core.workflow;

2

3 import com.google.common.base.Optional;

4 import com.google.common.collect.ImmutableMap;

5 import com.google.inject.Guice;

6 import com.google.inject.Injector;

43 public static <T extends OperatorFactory> T newOperatorFactory(Class<T> factoryClass)

44 {

45 Injector initInjector = Guice.createInjector((Module) (binder) -> {

46 binder.bind(CommandExecutor.class).to(MockCommandExecutor.class).in(Scopes.SINGLETON);

47 binder.bind(CommandLogger.class).to(TaskContextCommandLogger.class).in(Scopes.SINGLETON);

53 });

54

55 Injector injector = Guice.createInjector(

56 (Module) initInjector.getInstance(OperatorRegistry.DynamicOperatorPluginInjectionModule.class),

57 (Module) (binder) -> binder.bind(factoryClass)

19 package org.jclouds.demo.paas.config;

20

21 import static com.google.common.base.Preconditions.checkNotNull;

22 import static java.lang.String.format;

23 import static java.util.concurrent.TimeUnit.SECONDS;

33 import org.jclouds.http.config.JavaUrlHttpCommandExecutorServiceModule;

34

35 import com.google.common.collect.ImmutableMap;

36 import com.google.common.collect.ImmutableMap.Builder;

37 import com.google.inject.Guice;

38

39 /**

60 protected static HttpCommandExecutorService createHttpClient(

61 final ServletContext context) {

62 return Guice.createInjector(new ExecutorServiceModule(),

63 new JavaUrlHttpCommandExecutorServiceModule(),

64 new HttpClientModule(context))

34 import org.jclouds.http.config.JavaUrlHttpCommandExecutorServiceModule;

35

36 import com.google.common.collect.ImmutableMap;

37 import com.google.common.collect.ImmutableMap.Builder;

38 import com.google.inject.Guice;

39

40 /**

58 protected static HttpCommandExecutorService createHttpClient(

59 final ServletContext context) {

60 return Guice.createInjector(new ExecutorServiceModule(),

61 new JavaUrlHttpCommandExecutorServiceModule(),

62 new HttpClientModule(context))

10 package org.mule.config.dsl;

11

12 import com.google.inject.Guice;

13 import com.google.inject.Injector;

59

60 final DefaultCatalogImpl myCatalog = new DefaultCatalogImpl();

61 final List<com.google.inject.Module> guiceModules = new ArrayList<com.google.inject.Module>();

62

63 for (final Module module : modules) {

65 if (module instanceof com.google.inject.Module) {

66 guiceModules.add((com.google.inject.Module) module);

67 }

68 }

71 if (guiceModules.size() > 0) {

72 final Injector injector = Guice.createInjector(guiceModules);

73 muleContextBuilder = new MuleContextBuilder(myCatalog, injector);

74 } else {

10 import org.osgi.framework.BundleContext;

11

12 import com.google.inject.Guice;

13 import com.google.inject.Injector;

14 import com.google.inject.Module;

15

16 /**

49 protected void initializeInjector() {

50 Module module = Modules3.mixin(new SprayRuntimeModule(), new GraphitiRuntimeModule(), new GraphitiGeneratorModule(), new GraphitiGeneratorUIModule(this), new SharedStateModule()/* , new SprayUiModule(this) */);

51 injector = Guice.createInjector(module);

52 injector.injectMembers(this);

53 }

20 import static com.google.inject.servlet.UriPatternType.SERVLET;

21

22 import com.google.common.collect.ImmutableList;

23 import com.google.common.collect.ImmutableMap;

24 import com.google.inject.Binding;

25 import com.google.inject.Guice;

26 import com.google.inject.Injector;

27 import com.google.inject.Key;

28 import com.google.inject.name.Names;

65 ServletSpiVisitor visitor = new ServletSpiVisitor(true);

66 int count = 0;

67 Injector injector = Guice.createInjector(new Module());

68 for (Binding binding : injector.getBindings().values()) {

69 assertEquals(count++, binding.acceptTargetVisitor(visitor));

36 import com.google.common.collect.ImmutableSortedMap;

37 import com.google.inject.Guice;

38 import com.google.inject.name.Names;

50 @BeforeTest

51 protected void setUpInjector() {

52 injector = Guice.createInjector(new SaxParserModule() {

53 @Override

54 public void configure() {

27 import com.google.inject.AbstractModule;

28 import com.google.inject.Guice;

29 import com.google.inject.name.Names;

39 @Test

40 public void testNotThere() throws InterruptedException, ExecutionException {

41 assertEquals(new ValueOfConfigurationKeyOrNull(Guice.createInjector()).apply("foo"), null);

42 }

43

44 @Test

45 public void testThere() throws InterruptedException, ExecutionException {

46 assertEquals(new ValueOfConfigurationKeyOrNull(Guice.createInjector(new AbstractModule() {

47

48 @Override

32 import org.testng.annotations.Test;

33

34 import com.google.common.collect.ImmutableList;

35 import com.google.common.collect.ImmutableMap;

36 import com.google.common.collect.ImmutableSet;

37 import com.google.inject.Guice;

38 import com.google.inject.TypeLiteral;

45 public class ParseFirstJsonValueNamedTest {

46

47 GsonWrapper json = Guice.createInjector(new GsonModule()).getInstance(GsonWrapper.class);

48

49 static class Event {

33 import org.testng.annotations.Test;

34

35 import com.google.common.collect.ImmutableSet;

36 import com.google.inject.AbstractModule;

37 import com.google.inject.Guice;

38 import com.google.inject.Injector;

46 public class BindGroupToUpdateRequestJsonPayloadTest {

47

48 private Injector injector = Guice.createInjector(new AbstractModule() {

49 @Override

50 protected void configure() {

36 import org.testng.annotations.Test;

37

38 import com.google.common.collect.LinkedHashMultimap;

39 import com.google.common.collect.Multimap;

40 import com.google.inject.AbstractModule;

41 import com.google.inject.Guice;

42 import com.google.inject.Injector;

43 import com.google.inject.Provides;

44

45 /**

50 @Test(groups = "unit")

51 public class DeltacloudRedirectionRetryHandlerTest {

52 Injector injector = Guice.createInjector(new MockModule(), new RestModule(), new AbstractModule() {

53 @SuppressWarnings("unused")

54 @Provides

8

9 import play.Play;

10 import play.modules.guice.GuiceSupport;

11 import security.Secure;

12

13 import com.google.inject.AbstractModule;

14 import com.google.inject.Guice;

15 import com.google.inject.Injector;

16 import com.google.inject.Module;

17 import com.google.inject.Stage;

28 @Override

29 protected Injector configure() {

30 injector = Guice.createInjector(stage, modulesToLoad());

31 return injector;

32 }

31 import org.testng.annotations.Test;

32

33 import com.google.inject.Guice;

34 import com.google.inject.Injector;

42 public class RebuildServerOptionsTest {

43

44 Injector injector = Guice.createInjector(new GsonModule());

45

46 @Test

33 import com.google.common.collect.ImmutableList;

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

36 import com.google.inject.Key;

37 import com.google.inject.TypeLiteral;

45 public class ParseInetAddressListFromJsonResponseTest {

46

47 Injector i = Guice.createInjector(new GsonModule());

48

49 public void testPublic() throws UnknownHostException {

16 package io.airlift.configuration;

17

18 import com.google.common.collect.ImmutableMap;

19 import com.google.common.collect.ImmutableMap.Builder;

20 import com.google.inject.Binder;

21 import com.google.inject.CreationException;

22 import com.google.inject.Guice;

23 import com.google.inject.Injector;

24 import com.google.inject.Module;

25 import com.google.inject.spi.Message;

91 ConfigurationFactory configurationFactory = new ConfigurationFactory(properties);

92 List<Message> messages = new ConfigurationValidator(configurationFactory, null).validate(module);

93 return Guice.createInjector(new ConfigurationModule(configurationFactory), module, new ValidationErrorModule(messages));

94 }

95

19 package org.jclouds.ultradns.ws.handlers;

20

21 import static com.google.common.base.Throwables.propagate;

22 import static org.jclouds.rest.internal.BaseRestApiExpectTest.payloadFromStringWithContentType;

23 import static org.jclouds.util.Strings2.toStringAndClose;

35 import org.testng.annotations.Test;

36

37 import com.google.inject.Guice;

38

39 /**

43 @Test(groups = "unit" )

44 public class UltraDNSWSErrorHandlerTest {

45 UltraDNSWSErrorHandler function = Guice.createInjector(new SaxParserModule()).getInstance(

46 UltraDNSWSErrorHandler.class);

47

47

48 public void testDifferentOrderParameters() {

49 Injector injector = Guice.createInjector(new AbstractModule() {

50 @Override

51 protected void configure() {

95 assertNull(noIndex.index);

96

97 injector = Guice.createInjector(new AbstractModule() {

98 @Override

99 protected void configure() {

228

229 public void testDependenciesAndOtherAnnotations() {

230 Injector injector = Guice.createInjector(new AbstractModule() {

231 @Override

232 protected void configure() {

24 import com.google.inject.AbstractModule;

25 import com.google.inject.Guice;

26 import com.google.inject.Injector;

61 teams.setProperty("Edmonton", "Oilers");

62

63 Injector injector = Guice.createInjector(new AbstractModule() {

64 protected void configure() {

65 Names.bindProperties(binder(), teams);

75 "SanJose", "Sharks", "Edmonton", "Oilers");

76

77 Injector injector = Guice.createInjector(new AbstractModule() {

78 protected void configure() {

79 Names.bindProperties(binder(), properties);

94 teams.setProperty("Edmonton", "Oilers");

95

96 Injector injector = Guice.createInjector(new AbstractModule() {

97 protected void configure() {

98 Names.bindProperties(binder(), teams);

31 import org.testng.annotations.Test;

32

33 import com.google.inject.Guice;

34

35 /**

40 @Test(groups = "unit", testName = "pcs2.BindFileInfoToXmlPayloadTest")

41 public class BindFileInfoToXmlPayloadTest {

42 PCSFile.Factory factory = Guice.createInjector(new PCSObjectModule()).getInstance(PCSFile.Factory.class);

43

44 public void test() {

31 import org.testng.annotations.Test;

32

33 import com.google.common.collect.ImmutableMap;

34 import com.google.common.collect.ImmutableMultimap;

35 import com.google.inject.AbstractModule;

36 import com.google.inject.Guice;

37 import com.google.inject.Injector;

38 import com.google.inject.name.Names;

39 import com.sun.jersey.api.uri.UriBuilderImpl;

40

47 public class ParseAuthenticationResponseFromHeadersTest {

48

49 Injector i = Guice.createInjector(new AbstractModule() {

50

51 @Override

36 import com.google.common.collect.ImmutableSet;

37 import com.google.inject.Guice;

38 import com.google.inject.Injector;

67

68 protected Injector injector() {

69 return Guice.createInjector(new NovaParserModule(), new GsonModule());

70 }

71 }

19 package org.jclouds.trmk.vcloud_0_8.xml;

20

21 import static com.google.common.base.Preconditions.checkNotNull;

22 import static org.testng.Assert.assertEquals;

23

39 import com.google.common.collect.ImmutableSortedMap;

40 import com.google.inject.Guice;

41 import com.google.inject.name.Names;

53 @BeforeTest

54 protected void setUpInjector() {

55 injector = Guice.createInjector(new SaxParserModule() {

56 @Override

57 public void configure() {

22 import org.limewire.rudp.RUDPUtils;

23

24 import com.google.inject.AbstractModule;

25 import com.google.inject.Inject;

26 import com.google.inject.Injector;

27 import com.google.inject.Singleton;

39 protected void setUp() throws Exception {

40 super.setUp();

41 injector = LimeTestUtils.createInjectorAndStart(new AbstractModule() {

42 @Override

43 protected void configure() {

74 private Injector createInjector() {

75 return Guice.createInjector(

76 new AbstractModule() {

77 protected void configure() {

104

105 public void testBindNullToProvider() {

106 Injector injector = Guice.createInjector(new AbstractModule() {

107 protected void configure() {

108 bind(Foo.class).toProvider(new Provider<Foo>() {

124

125 public void testBindScopedNull() {

126 Injector injector = Guice.createInjector(new AbstractModule() {

127 protected void configure() {

128 bind(Foo.class).toProvider(new Provider<Foo>() {

144

145 public void testBindNullAsEagerSingleton() {

146 Injector injector = Guice.createInjector(new AbstractModule() {

147 protected void configure() {

148 bind(Foo.class).toProvider(new Provider<Foo>() {

29 import com.google.common.collect.ImmutableSet;

30 import com.google.inject.Guice;

31 import com.google.inject.Injector;

40 @Override

41 protected Injector injector() {

42 return Guice.createInjector(new GsonModule() {

43

44 @Override

17 package org.ops4j.peaberry.osgi;

18

19 import static com.google.inject.name.Names.named;

20 import static java.lang.Math.max;

21 import static org.ops4j.peaberry.Peaberry.CACHE_GENERATIONS_HINT;

35 import com.google.inject.AbstractModule;

36 import com.google.inject.Guice;

37 import com.google.inject.Inject;

38 import com.google.inject.Injector;

39 import com.google.inject.Key;

113

114 public void start(final BundleContext context) {

115 final Injector injector = Guice.createInjector(osgiModule(context), new AbstractModule() {

116 @Override

117 protected void configure() {