31 import com.google.inject.AbstractModule;

32 import com.google.inject.Guice;

33 import com.google.inject.TypeLiteral;

104

105 public void testPropertyChangesDelimiter() {

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

107

108 @Override

119

120 public void testPropertyChangesPrefix() {

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

122

123 @Override

135

136 public void testCanChangeSuffixSupplier() {

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

138

139 @Override

15 * limitations under the License.

16 */

17 package org.jclouds.googlecomputeengine.compute.functions;

18

19 import static org.easymock.EasyMock.createMock;

30 import org.jclouds.compute.domain.NodeMetadata;

31 import org.jclouds.compute.domain.internal.NodeMetadataImpl;

32 import org.jclouds.googlecomputeengine.compute.predicates.GroupIsEmpty;

33 import org.testng.annotations.Test;

34

39 import com.google.inject.AbstractModule;

40 import com.google.inject.Guice;

41

42 public class OrphanedGroupsFromDeadNodesTest {

164

165 private Predicate<String> allNodesInGroupTerminated(final ComputeService mock) {

166 return Guice.createInjector(new AbstractModule() {

167 @Override protected void configure() {

168 bind(ComputeService.class).toInstance(mock);

17 import org.snowfk.web.db.hibernate.DefaultHibernateModule;

18

19 import com.google.inject.Guice;

20 import com.google.inject.Injector;

21 import com.google.inject.Module;

22 import com.google.inject.util.Modules;

152 rootModules.add(combineAppModule);

153

154 appInjector = Guice.createInjector(rootModules);

155 /*--------- /Load WebApplication ---------*/

156

19 import com.google.inject.AbstractModule;

20 import com.google.inject.Guice;

21 import com.google.inject.Inject;

22 import com.google.inject.Injector;

23 import com.wideplay.warp.persist.PersistenceService;

24 import com.wideplay.warp.persist.Transactional;

54 @BeforeClass

55 public void pre() {

56 injector = Guice.createInjector(PersistenceService.usingJpa()

57 .across(UnitOfWork.TRANSACTION)

58 .addAccessor(JpaTestAccessor.class)

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

31 import com.google.inject.Guice;

32 import com.google.inject.Injector;

54

55 protected Injector injector() {

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

57 }

58

19 import com.google.inject.AbstractModule;

20 import com.google.inject.Guice;

21 import com.google.inject.Inject;

22 import com.google.inject.Injector;

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

47 @BeforeClass

48 public void pre() {

49 injector = Guice.createInjector(PersistenceService.usingJpa()

50 .across(UnitOfWork.REQUEST)

51

11 import org.jmock.Mockery;

12

13 import com.google.inject.Guice;

14 import com.google.inject.Injector;

60 */

61 public void setUp() {

62 _testInjector = Guice.createInjector(new HeavyLeadTestModule());

63

64 _mockery = _testInjector.getInstance(Mockery.class);

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

2

3 import com.google.inject.Guice;

4 import com.google.inject.Injector;

22 @Before

23 public void setup() {

24 final Injector injector = Guice.createInjector(new InstrumentationModule());

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

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

248 "timedAndExceptionExceptions"));

249

250 assertThat("Guice creates a metric",

251 timedMetric,

252 is(notNullValue()));

253

254 assertThat("Guice creates a timer",

255 timedMetric,

256 is(instanceOf(Timer.class)));

15 import org.osgi.framework.BundleContext;

16

17 import com.google.inject.Guice;

18 import com.google.inject.Injector;

19 import com.google.inject.Module;

20

21 public class JnarioActivator extends AbstractUIPlugin {

44 public synchronized Injector getInjector() {

45 if (injector == null) {

46 injector = createInjector();

47 }

48 return injector;

53 Module sharedStateModule = getSharedStateModule();

54 Module jnarioModule = new JnarioUiModule(this);

55 return Guice.createInjector(Modules2.mixin(jnarioModule, sharedStateModule));

56 } catch (Exception e) {

57 logger.error("Failed to create injector for jnario");

16 package com.google.test.metric;

17

18 import com.google.inject.Guice;

19 import com.google.inject.Injector;

80 Injector injector = Guice.createInjector(new ConfigModule(new String[]{

81 "-cp", "not/default/path",

82 "com.google.FirstClass com.google.second.package com.google.third.package"},

83 outStream, errStream));

84 CommandLineConfig commandLineConfig = injector.getInstance(CommandLineConfig.class);

116

117 public void testJarFileNoClasspath() throws Exception {

118 Guice.createInjector(new ConfigModule(new String[] {"junit.runner", "-cp"},

119 outStream, errStream)).getInstance(CommandLineConfig.class);

120 /**

130 String fileUrl = "http://code.google.com/p/testability-explorer/source/browse/trunk/src/{path}";

131 Injector injector = Guice.createInjector(new ConfigModule(new String[]{

132 "-srcFileLineUrl", lineUrl, "-srcFileUrl", fileUrl},

133 outStream, errStream));

22 import static org.easymock.EasyMock.verify;

23

24 import com.google.inject.Guice;

25 import com.google.inject.Injector;

62 public final void testDispatchRequestToManagedPipelineServlets()

63 throws ServletException, IOException {

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

65

66 @Override

102 public final void testVarargsSkipDispatchRequestToManagedPipelineServlets()

103 throws ServletException, IOException {

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

105

106 @Override

142 public final void testDispatchRequestToManagedPipelineWithFilter()

143 throws ServletException, IOException {

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

145

146 @Override

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;

45

46 protected void registerInjectorFor(String language) throws Exception {

47 injectors.put(language, createInjector(

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

49 }

14 * limitations under the License.

15 */

16 package org.directwebremoting.guice;

17

18 import java.util.prefs.Preferences;

19

20 import com.google.inject.Guice;

21 import com.google.inject.Injector;

31 * @author Tim Peierls [tim at peierls dot net]

32 */

33 public abstract class DwrGuiceServletContextListener extends AbstractDwrGuiceServletContextListener

34 {

35 /**

39 protected final Injector createInjector()

40 {

41 return Guice.createInjector(getStage(), new DwrScopeBinder(this));

42 }

43

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

47 import com.google.inject.Guice;

48 import com.google.inject.Key;

99 .password("password").build());

100

101 ExpectedBindings bindings = Guice.createInjector(new BindProviderMetadataContextAndCredentials(md, creds))

102 .getInstance(ExpectedBindings.class);

103 assertEquals(bindings.creds.identity, "user");

111 Supplier<Credentials> creds = Suppliers.<Credentials> ofInstance(LoginCredentials.builder().user("user").build());

112

113 ExpectedBindings bindings = Guice.createInjector(new BindProviderMetadataContextAndCredentials(md, creds))

114 .getInstance(ExpectedBindings.class);

115 assertEquals(bindings.creds.identity, "user");

125 Supplier<Credentials> creds = Suppliers.<Credentials> ofInstance(LoginCredentials.builder().user("user").build());

126

127 ExpectedBindings bindings = Guice.createInjector(new BindProviderMetadataContextAndCredentials(md, creds))

128 .getInstance(ExpectedBindings.class);

129 assertEquals(bindings.buildVersion, null);

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

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

28 import com.google.inject.Guice;

29 import com.google.inject.Injector;

34 @Override

35 protected Injector injector() {

36 return Guice.createInjector(new GsonModule() {

37 @Override

38 protected void configure() {

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

25 * framework should be used for creating specs. To do so, create a custom `SpecCreator` and

26 * annotate your spec with `CreateWith` and pass as a value the type of the custom `SpecCreator`.

27 * Here is an example for a custom `SpecCreator` that uses Google Guice to create the specification:

28 *

29 * <pre class="prettyprint">

30 * package org.jnario.lib;

31 *

32 * import com.google.inject.Guice;

33 * import com.google.inject.util.Modules;

35 * public class GuiceSpecCreator extends AbstractSpecCreator {

36 * public Object create(Class<?> klass) throws Exception {

37 * return Guice.createInjector(Modules.EMPTY_MODULE).getInstance(klass);

38 * }

39 * }

54

55 /**

56 * This example uses the Google Guice to instantiate the specification.

57 * @filter('''|.executesSuccessfully)

58 */

15 */

16

17 package com.mycila.testing.plugin.guice;

18

19 import com.google.inject.*;

20 import com.google.inject.binder.AnnotatedBindingBuilder;

21 import com.google.inject.binder.LinkedBindingBuilder;

22 import com.google.inject.binder.ScopedBindingBuilder;

38

39 public void prepareTestInstance(Context context) {

40 GuiceContext ctx = context.getTest().getTargetClass().getAnnotation(GuiceContext.class);

41 List<Module> modules = new ArrayList<Module>();

42 modules.addAll(contextualModules(ctx));

47 modules.add((Module) context.getTest().getTarget());

48 }

49 Injector injector = Guice.createInjector(findStage(ctx), modules);

50 context.setAttribute("com.google.inject.Injector", injector);

9 import javax.inject.Inject;

10

11 import com.google.inject.Guice;

12 import com.google.inject.Injector;

72 public static void main(String[] args)

73 {

74 Injector injector = Guice.createInjector(new AIMLModule());

75 InteractiveExample example = new InteractiveExample();

76 injector.injectMembers(example);

19 import com.google.inject.AbstractModule;

20 import com.google.inject.Guice;

21 import com.google.inject.Injector;

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

23 import com.wideplay.codemonkey.web.startup.Initializer;

24 import com.wideplay.warp.persist.PersistenceService;

48 @BeforeTest

49 public void pre() {

50 injector = Guice.createInjector(PersistenceService.usingHibernate()

51 .across(UnitOfWork.TRANSACTION)

52 .forAll(Matchers.any())

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;

16 import com.google.common.cache.Cache;

17 import com.google.common.cache.CacheBuilder;

18 import com.google.common.cache.CacheLoader;

19

20 import java.util.concurrent.ExecutionException;

38 import org.restlet.ext.guice.FinderFactory;

39 import org.restlet.ext.guice.RestletGuice;

40 import org.restlet.resource.Get;

41 import org.restlet.resource.ServerResource;

45 import com.google.inject.Injector;

46 import com.google.inject.Module;

47

48 /**

51 * instances obtained from a FinderFactory. A command line argument controls

52 * whether the Injector behind the FinderFactory is created explicitly with

53 * RestletGuice or implicitly from the first use of RestletGuice.Module as a

54 * FinderFactory.

55 */

158 switch (mode) {

159 case EXPLICIT_INJECTOR:

160 Injector injector = RestletGuice.createInjector(bindings);

161 ff = injector.getInstance(FinderFactory.class);

162 break;

23 */

24

25 package org.restlet.test.ext.guice;

26

27 import javax.inject.Inject;

35 import org.restlet.data.MediaType;

36 import org.restlet.data.Protocol;

37 import org.restlet.ext.guice.SelfInjectingServerResource;

38 import org.restlet.ext.guice.SelfInjectingServerResourceModule;

44 import com.google.inject.AbstractModule;

45 import com.google.inject.Guice;

46 import com.google.inject.Provides;

109 super.setUp();

110

111 Guice.createInjector(new TestModule(),

112 new SelfInjectingServerResourceModule());

113

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(

1 /**

2 * Copyright (C) 2008 Google Inc.

3 *

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

18 import com.google.inject.AbstractModule;

19 import com.google.inject.Guice;

20 import com.google.inject.Injector;

35 public final void testExplicitBindingsWorksWithGuiceServlet() {

36 Injector injector = Guice.createInjector(

37 new AbstractModule() {

38 @Override

102

103 //verify that it doesn't blow up!

104 Guice.createInjector(Stage.TOOL, webModule);

105 }

106 }

9 import org.hibernate.SessionFactory;

10 import org.hibernate.criterion.Expression;

11 import com.google.inject.Guice;

12 import com.google.inject.Injector;

13 import com.google.inject.Inject;

14 import com.google.inject.AbstractModule;

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

16 import com.wideplay.codemonkey.web.startup.Initializer;

17 import com.wideplay.warp.persist.*;

34 @BeforeClass

35 public void pre() {

36 injector = Guice.createInjector(PersistenceService.usingHibernate()

37 .across(UnitOfWork.TRANSACTION)

38 .transactedWith(TransactionStrategy.LOCAL)

1 package com.dburger.guice.xamp;

2

3 import com.google.inject.AbstractModule;

4 import com.google.inject.Guice;

5 import com.google.inject.Inject;

6 import com.google.inject.Injector;

7 import com.google.inject.Provider;

8 import com.google.inject.Provides;

9

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

152 System.out.println("hello world, going to inject...");

153 System.out.println("=================================================");

154 Injector injector = Guice.createInjector(new WorldDominationModule());

155 WorldDominator wd = injector.getInstance(WorldDominator.class);

156 wd.dominate();

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

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

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 }

41 package com.sun.jersey.test.functional.guice;

42

43 import com.google.inject.Guice;

44 import com.google.inject.Injector;

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

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

47 import com.sun.jersey.guice.spi.container.servlet.GuiceContainer;

48 import com.sun.jersey.test.functional.guice.resources.PerRequestResource;

52 * @author paulsandoz

53 */

54 public class GuiceServletConfig extends GuiceServletContextListener {

55

56 @Override

16 package org.directwebremoting.guice;

17

18 import static org.directwebremoting.guice.DwrGuiceUtil.INJECTOR;

19

20 import java.util.ArrayList;

28 import org.apache.commons.logging.LogFactory;

29

30 import static org.directwebremoting.guice.util.ContextCloseHandlers.newExceptionLoggingCloseableHandler;

31

32 import com.google.inject.Injector;

47 {

48 final ServletContext servletContext = servletContextEvent.getServletContext();

49 DwrGuiceUtil.withServletContext(servletContext, new Runnable()

50 {

51 public void run()

27 import org.testng.annotations.Test;

28

29 import com.google.common.base.Functions;

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

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

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

34 import com.google.inject.Binder;

35 import com.google.inject.Guice;

36 import com.google.inject.Module;

39 @Test

40 public class AssignCorrectHostnameForBucketTest {

41 static final RegionToEndpointOrProviderIfNull REGION_TO_ENDPOINT = Guice.createInjector(new Module() {

42 @Override public void configure(Binder binder) {

43 binder.bindConstant().annotatedWith(Provider.class).to("s3");

35 import org.testng.annotations.Test;

36

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

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

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

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

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

43 import com.google.inject.Guice;

44

45 @Test(testName = "OrphanedGroupsByRegionIdTest")

53 .<String, Location> of("az-1.region-a.geo-1", region));

54

55 GroupNamingConvention.Factory namingConvention = Guice.createInjector().getInstance(GroupNamingConvention.Factory.class);

56

57 @Test

25 import org.testng.annotations.Test;

26

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

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

29 import com.google.inject.Guice;

30

31 @Test(groups = { "unit" })

32 public class CreateDriveRequestToMapTest {

33

34 private static final CreateDriveRequestToMap BASEDRIVE_TO_MAP = Guice.createInjector().getInstance(

35 CreateDriveRequestToMap.class);

36

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

27 import com.google.inject.Guice;

28 import com.google.inject.Injector;

36 public class CreateSharedIpGroupOptionsTest {

37

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

39

40 @Test

15 import org.jmock.Mockery;

16

17 import com.google.inject.Guice;

18 import com.google.inject.Injector;

64 @Override

65 public void setUp() {

66 _testInjector = Guice.createInjector(new HeavyLeadTestModule());

67 _mockery = _testInjector.getInstance(Mockery.class);

68

36 import org.testng.annotations.Test;

37

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

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

40 import com.google.inject.AbstractModule;

41 import com.google.inject.Guice;

42 import com.google.inject.Injector;

61 sysProperties.setProperty("user.name", "user");

62

63 Injector injector = Guice.createInjector(new ChefParserModule(), new GsonModule(), new OhaiModule() {

64 @Override

65 protected Long millis() {

90 sysProperties.setProperty("user.name", "user");

91

92 Injector injector = Guice.createInjector(new ChefParserModule(), new GsonModule(), new OhaiModule() {

93 @Override

94 protected Long millis() {

17 package org.jclouds.glesys.compute.functions;

18

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

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

36 import org.testng.annotations.Test;

37

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

39 import com.google.gson.Gson;

40 import com.google.inject.Guice;

41 import com.google.inject.TypeLiteral;

65

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

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

68 .getInstance(Json.class)));

69

38 import com.google.inject.ConfigurationException;

39 import com.google.inject.Guice;

40 import com.google.inject.Injector;

41 import com.google.inject.Key;

42 import com.google.inject.util.Types;

50

51 static {

52 injector = Guice.createInjector(new XmlModule());

53 }

54

34 import com.google.inject.AbstractModule;

35 import com.google.inject.Guice;

36 import com.google.inject.Injector;

44 @BeforeTest

45 protected void setUpInjector() throws IOException {

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

47 @Override

48 protected void configure() {

33 import com.google.inject.Binder;

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

36 import com.google.inject.Module;

37 import com.mu.jacob.core.ant.ConfigModule;

38 import com.mu.jacob.core.builder.IBuilder;

48 private ElementModule elementModule = new ElementModule();

49

50 /* Custom module for Guice DI */

51 private Module module = null;

52

79 ConfigModule configModule = new ConfigModule();

80 Module customModule = (module != null)? module : emptyModule;

81 Injector injector = Guice.createInjector(configModule, decoratorModule, elementModule, customModule);

82

83 // Create configuration

15 * limitations under the License.

16 */

17 package org.apache.bval.guice;

18

19 import java.util.Set;

26 import junit.framework.TestCase;

27

28 import com.google.inject.Guice;

29

30 /**

51 @Override

52 protected void setUp() throws Exception {

53 Guice.createInjector(new ValidationModule()).injectMembers(this);

54 }

55

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);

40 import android.view.Window;

41

42 import com.google.inject.Guice;

43 import com.google.inject.Injector;

44 import com.google.inject.Key;

45 import com.google.inject.TypeLiteral;

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

47

48

65 */

66 public SfVsMk2() {

67 injector = Guice.createInjector(

68 new EngineModule(),

69 new AndroidGraphicsModule(this),

79 };

80

81 Injector injector = Guice.createInjector(new InterceptingBindingsBuilder()

82 .intercept(String.class)

83 .install(module)

117 };

118

119 Injector injector = Guice.createInjector(new InterceptingBindingsBuilder()

120 .intercept(Integer.class)

121 .install(module)

223 };

224

225 Injector injector = Guice.createInjector(new InterceptingBindingsBuilder()

226 .intercept(List.class)

227 .intercept(Collection.class)

35 import org.testng.annotations.Test;

36

37 import com.google.inject.Guice;

38

39 /**

64 String content, Class<? extends Exception> expected) {

65

66 VCloudDirectorErrorHandler function = Guice.createInjector().getInstance(VCloudDirectorErrorHandler.class);

67

68 HttpCommand command = createMock(HttpCommand.class);

40 @Test

41 public void factoryCanBeIntantiatedWithArgConstructor() {

42 factory = new GuiceFactory(Guice.createInjector());

43 assertThat(factory, notNullValue());

44 }

46 @Test

47 public void factoryStartFailsIfScenarioScopeIsNotBound() {

48 factory = new GuiceFactory(Guice.createInjector());

49 try {

50 factory.start();

161

162 private Injector injector(Module... module) {

163 return Guice.createInjector(Stage.PRODUCTION, module);

164 }

165

19 import com.google.inject.Binder;

20 import com.google.inject.Guice;

21 import com.google.inject.Key;

22 import com.google.inject.Module;

23 import com.google.inject.TypeLiteral;

24 import com.google.inject.multibindings.MapBinder;

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

26 import com.google.inject.util.Modules;

27 import com.google.inject.util.Types;

217 try

218 {

219 return Guice.createInjector(finalModules).getInstance(clazz);

220 }

221 catch (RuntimeException ex)

17 package org.jclouds.chef.binders;

18

19 import static com.google.common.io.BaseEncoding.base16;

20 import static com.google.common.primitives.Bytes.asList;

32 import org.testng.annotations.Test;

33

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

35 import com.google.inject.AbstractModule;

36 import com.google.inject.Guice;

37 import com.google.inject.Injector;

40 public class BindHexEncodedMD5sToJsonPayloadTest {

41

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

43 @Override

44 protected void configure() {

39 final Listener listener = new Listener();

40

41 final Injector injector = Guice.createInjector(new IdentityModule() {

42 @Override

43 protected void configure() {

96 final Listener listener = new Listener();

97

98 final Injector injector = Guice.createInjector(new IdentityModule() {

99 @Override

100 protected void configure() {

127 final Listener listener = new Listener();

128

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

130 @Override

131 protected void configure() {

3 import com.google.gwt.user.client.rpc.AsyncCallback;

4 import com.google.inject.Guice;

5 import com.google.inject.Injector;

6 import com.google.inject.internal.Preconditions;

7 import com.google.inject.servlet.GuiceFilter;

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

38 @Before

39 public void setUp() throws Exception {

40 injector = Guice.createInjector(new Module());

41

42 }

55 @Override

56 protected Injector getInjector() {

57 return Guice.createInjector(new ServletModule() {

58 @Override

59 protected void configureServlets() {

34 import org.testng.annotations.Test;

35

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

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

38 import com.google.inject.Guice;

39 import com.google.inject.Injector;

91

92 protected Injector injector() {

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

94 }

95 }

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

29 import com.google.inject.Guice;

30 import com.google.inject.Injector;

46 private JpaInitializer jpaInitializer;

47 /**

48 * Guice Injector to get DAOs

49 */

50 private Injector injector;

75 public final void initialize() {

76 NinjaPropertiesImpl ninjaProperties = new NinjaPropertiesImpl(ninjaMode);

77 injector = Guice.createInjector(new JpaModule(ninjaProperties));

78 jpaInitializer = injector.getInstance(JpaInitializer.class);

79 jpaInitializer.start();

20 package scenarios;

21

22 import com.google.inject.Guice;

23 import com.google.inject.Injector;

56

57 static {

58 injector_ = Guice.createInjector(new EntityModule(), new ServiceModule(localIP_, localPort_, Integer.MAX_VALUE));

59 try {

60 localPeerContextInit();

83

84 public void testEverythingInjectorGetInstance() {

85 Guice.createInjector(everythingModule)

86 .getInstance(HasOptionalInjections.class)

87 .assertEverythingInjected();

119

120 public void testEverythingInjectorToInstance() {

121 Guice.createInjector(everythingModule, toInstanceModule)

122 .getInstance(HasOptionalInjections.class)

123 .assertEverythingInjected();

277 */

278 public void testIndirectOptionalInjection() {

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

280 assertNotNull(indirect.hasOptionalInjections);

281 indirect.hasOptionalInjections.assertNothingInjected();

61 @Test

62 void factoryCanBeIntantiatedWithArgConstructor() {

63 factory = new GuiceFactory(Guice.createInjector());

64 assertThat(factory, notNullValue());

65 }

67 @Test

68 void factoryStartFailsIfScenarioScopeIsNotBound() {

69 factory = new GuiceFactory(Guice.createInjector());

70

71 Executable testMethod = () -> factory.start();

85

86 private Injector injector(Module... module) {

87 return Guice.createInjector(Stage.PRODUCTION, module);

88 }

89

29 import org.testng.annotations.Test;

30

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

32 import com.google.inject.AbstractModule;

33 import com.google.inject.Guice;

34 import com.google.inject.Injector;

44 @BeforeTest

45 protected void setUpInjector() throws IOException {

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

47 @Override

48 protected void configure() {

32 import org.gbif.checklistbank.api.service.TypeSpecimenService;

33 import org.gbif.checklistbank.api.service.VernacularNameService;

34 import org.gbif.checklistbank.ws.client.guice.ChecklistBankWsClientModule;

35 import org.gbif.checklistbank.ws.guice.ChecklistBankWsModule;

36

37 import com.google.inject.Guice;

38 import com.google.inject.Injector;

53 public void init() {

54 clientInjector =

55 Guice

56 .createInjector(new UrlBindingModule(this.getBaseURI(), "clb"), new ChecklistBankWsClientModule(false, true));

1 package code.lucamarrocco.scala.eclipse;

2

3 import static com.google.inject.Guice.*;

4 import static org.hamcrest.Matchers.*;

5 import static org.junit.Assert.*;

12 import org.junit.*;

13

14 import com.google.inject.*;

15

16 public class ScalaModuleTest {

38 workspace = mock(IWorkspace.class);

39 module = new ScalaModule(plugin, log, editorRegistry, contentTypeManager, workspace);

40 injector = createInjector(module);

41 }

42

27 import com.google.common.net.HostAndPort;

28 import com.google.inject.Guice;

29 import com.google.inject.Injector;

37 public void testConfigureBindsClient() throws UnknownHostException {

38

39 Injector i = Guice.createInjector(new JschSshClientModule(), new SLF4JLoggingModule());

40 SshClient.Factory factory = i.getInstance(SshClient.Factory.class);

41 SshClient connection = factory.create(HostAndPort.fromParts("localhost", 22), LoginCredentials.builder().user("username")

15 package com.kiahu.sample.server.guice;

16

17 import com.google.inject.Guice;

18 import com.google.inject.Injector;

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

20

21 public class BasicProjectGuiceServletContextListener extends GuiceServletContextListener {

23 @Override

24 protected Injector getInjector() {

25 return Guice.createInjector(new BasicProjectServerModule(), new BasicProjectServletModule());

26 }

27 }

36 import org.junit.Test;

37

38 import com.google.inject.Guice;

39 import com.google.inject.Injector;

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

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

42 import com.sun.jersey.api.client.ClientResponse;

43 import com.sun.jersey.api.client.WebResource;

44 import com.sun.jersey.guice.spi.container.servlet.GuiceContainer;

45 import com.sun.jersey.test.framework.JerseyTest;

46 import com.sun.jersey.test.framework.WebAppDescriptor;

50 private YarnConfiguration conf;

51

52 private Injector injector = Guice.createInjector(new ServletModule() {

53 @Override

54 protected void configureServlets() {

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

22 import com.google.inject.Guice;

23 import com.google.inject.Injector;

33 @Override

34 protected Injector injector() {

35 return Guice.createInjector(new GsonModule() {

36

37 @Override

25 import org.testng.annotations.Test;

26

27 import com.google.inject.Guice;

28 import com.google.inject.Injector;

33 @Test(groups = "unit")

34 public class BindUserMetadataToHeadersTest {

35 Injector injector = Guice.createInjector();

36 BindUserMetadataToHeaders binder = injector.getInstance(BindUserMetadataToHeaders.class);

37

34 import com.google.inject.ConfigurationException;

35 import com.google.inject.Guice;

36 import com.google.inject.Injector;

39 import com.google.inject.Stage;

40 import com.google.inject.TypeLiteral;

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

44 /**

45 *

46 * A Container Provider that uses Google Guice as DI container.

47 *

48 * @author Lucas Cavalcanti

96 container = new GuiceContainer();

97 injector = Guice.createInjector(Stage.PRODUCTION, Modules.override(new VRaptorAbstractModule(context, container)).with(customModule()));

98 executeStereotypeHandlers();

99 injector.injectMembers(REQUEST);

19 import com.google.inject.AbstractModule;

20 import com.google.inject.Guice;

21 import com.google.inject.Inject;

22 import com.google.inject.Injector;

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

55 @BeforeClass

56 public void pre() {

57 injector = Guice.createInjector(PersistenceService.usingHibernate()

58 .across(UnitOfWork.REQUEST)

59 .forAll(Matchers.subclassesOf(TransactionalObject.class), Matchers.any())

32

33 public void testProviderInjection() throws CreationException {

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

35 @Override

36 protected void configure() {

69

70 try {

71 Guice.createInjector(m);

72 fail("Should have thrown a CreationException");

73 }

82 */

83 public void testProvidersAreInjectedBeforeTheyAreUsed() {

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

85 @Override

86 public void configure() {

35 import org.testng.annotations.Test;

36

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

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

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

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

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

43 import com.google.inject.Guice;

44

45 /**

58 .<String, Location> of("az-1.region-a.geo-1", zone));

59

60 GroupNamingConvention.Factory namingConvention = Guice.createInjector().getInstance(GroupNamingConvention.Factory.class);

61

62 @Test

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

35 import com.google.inject.Guice;

36 import com.google.inject.Injector;

71

72 protected Injector injector() {

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

74 }

75

10 * You may elect to redistribute this code under either of these licenses.

11 *******************************************************************************/

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

13

14 import java.io.File;

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

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

27 import org.sonatype.guice.bean.locators.MutableBeanLocator;

35 import com.google.inject.Binder;

36 import com.google.inject.Guice;

37 import com.google.inject.Key;

62 public void setUp()

63 {

64 Guice.createInjector( new WireModule( new SetUpModule(), new SpaceModule( space(), scanning() ) ) );

65 }

66

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

32 import com.google.inject.Guice;

33 import com.google.inject.Injector;

64

65 protected Injector injector() {

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

67 }

68

24 import com.google.inject.Binder;

25 import com.google.inject.Guice;

26 import com.google.inject.ImplementedBy;

365 } ), 3 );

366

367 locator.add( Guice.createInjector( new Module()

368 {

369 public void configure( final Binder binder )

425 } ), 7 );

426

427 locator.add( Guice.createInjector( new Module()

428 {

429 public void configure( final Binder binder )

446 world.getRealm( "B2" ).importFrom( "B3", "B3" );

447

448 locator.add( Guice.createInjector( new AbstractModule()

449 {

450 @Override

23 */

24

25 package org.restlet.test.ext.guice;

26

27 import javax.inject.Inject;

33 import org.restlet.data.MediaType;

34 import org.restlet.data.Protocol;

35 import org.restlet.ext.guice.ResourceInjectingApplication;

36 import org.restlet.ext.guice.SelfInjectingServerResource;

44 import com.google.inject.AbstractModule;

45 import com.google.inject.Guice;

46 import com.google.inject.Injector;

144 protected void setUp() throws Exception {

145 super.setUp();

146 Injector injector = Guice.createInjector(new TestModule(),

147 new SelfInjectingServerResourceModule());

148

124

125 public void testNoAnnotationNoScope() throws BindException, RemoteException {

126 Injector injector = Guice.createInjector(new TestModule());

127 RpcProvider<String> provider = injector

128 .getInstance(Key.get(rpcProviderOfString));

162 public void testWithThrownException() {

163 TestModule testModule = new TestModule();

164 Injector injector = Guice.createInjector(testModule);

165 RpcProvider<Float> provider = injector

166 .getInstance(Key.get(rpcProviderOfFloat));

177 public void testExposedMethod() throws BindException, RemoteException {

178 TestModule testModule = new TestModule();

179 Injector injector = Guice.createInjector(testModule);

180 RpcProvider<String> provider = injector

181 .getInstance(Key.get(rpcProviderOfString, Names.named("fruit")));

37 final List<String> names = Arrays.asList("foo", "bar", "bob");

38

39 Injector injector = Guice.createInjector((Module) new AbstractModule() {

40 protected void configure() {

41 bind(new TypeLiteral<List<String>>() {}).toInstance(names);

58 public void testImplicitBindingOfGenericType() {

59 Parameterized<String> parameterized

60 = Guice.createInjector().getInstance(Key.get(new TypeLiteral<Parameterized<String>>() {}));

61 assertNotNull(parameterized);

62 }

63

64 public void testExplicitBindingOfGenericType() {

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

66 protected void configure() {

67 bind(Key.get(new TypeLiteral<Parameterized<String>>() {}))

38 package org.jooq.example.guice.test;

39

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

41 import static org.junit.Assert.assertEquals;

42 import static org.junit.Assert.fail;

43

44 import org.jooq.example.db.h2.tables.pojos.Author;

45 import org.jooq.example.guice.Module;

46 import org.jooq.example.guice.Service;

54 public class Tests {

55

56 Service service = createInjector(new Module()).getInstance(Service.class);

57

58 @Test

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

20 import com.google.inject.Guice;

21 import com.google.inject.Injector;

47

48 protected Injector injector() {

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

50 }

51 }

29 import org.testng.annotations.Test;

30

31 import com.google.inject.Guice;

32

33 /**

37 public class VirtualGuestToImageTest {

38

39 OperatingSystemToImage operatingSystemToImage = Guice.createInjector().getInstance(OperatingSystemToImage.class);

40

41 @Test

3 import com.google.inject.Injector;

4 import com.google.inject.Guice;

5 import com.google.inject.AbstractModule;

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

7 import com.wideplay.codemonkey.web.startup.Initializer;

8 import com.wideplay.warp.hibernate.HibernatePersistenceService;

32 @BeforeClass

33 public void pre() {

34 injector = Guice.createInjector(PersistenceService.usingHibernate()

35 .across(UnitOfWork.TRANSACTION)

36 .transactedWith(TransactionStrategy.LOCAL)

34 import com.google.inject.AbstractModule;

35 import com.google.inject.Guice;

36 import com.google.inject.Injector;

37 import com.google.inject.Key;

38 import com.google.inject.TypeLiteral;

49 @BeforeTest

50 protected void setUpInjector() throws IOException {

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

52 @Override

53 protected void configure() {

17 package org.jclouds.openstack.nova.v2_0.config;

18

19 import static com.google.common.collect.Iterables.getOnlyElement;

20 import static org.testng.Assert.assertEquals;

21 import static org.testng.Assert.assertNotNull;

28 import org.testng.annotations.Test;

29

30 import com.google.common.base.Charsets;

31 import com.google.common.io.Resources;

32 import com.google.gson.Gson;

33 import com.google.inject.Guice;

34 import com.google.inject.Injector;

41 @BeforeTest

42 public void setup() {

43 Injector injector = Guice.createInjector(new GsonModule(), new NovaParserModule());

44 gson = injector.getInstance(Gson.class);

45 }

47

48 public void testDifferentOrderParameters() {

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

50 @Override

51 protected void configure() {

95 assertEquals(null, 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() {

3 import com.google.inject.Binding;

4 import com.google.inject.Guice;

5 import com.google.inject.Injector;

30 public void process(final Module... modules)

31 {

32 final Injector injector = Guice.createInjector(modules);

33 processInjector(injector);

34 }

36 public void process(final Stage stage, final Module... modules)

37 {

38 final Injector injector = Guice.createInjector(stage, modules);

39 processInjector(injector);

40 }

42 public void process(final Iterable<Module> modules)

43 {

44 final Injector injector = Guice.createInjector(modules);

45 processInjector(injector);

46 }

25 import rabbit.data.internal.xml.schema.events.TaskFileEventType;

26

27 import com.google.inject.Guice;

28 import com.google.inject.Injector;

29 import com.google.inject.Key;

30 import com.google.inject.TypeLiteral;

70 this.mergerInterface = mergerInterface;

71 this.mergerImpl = mergerImpl;

72 this.injector = Guice.createInjector(new MergerModule());

73 }

74

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() {

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

42 import com.google.inject.Guice;

43 import com.google.inject.Injector;

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

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

53 * @author Adrian Cole

54 */

55 public class GuiceServletConfig extends GuiceServletContextListener {

56

57 private Logger logger = new JDKLogger.JDKLoggerFactory().getLogger(GuiceServletConfig.class.getName());

78 @Override

79 protected Injector getInjector() {

80 return Guice.createInjector(concat(modulesForProviderInProperties("chef", properties), ImmutableSet.of(

81 new GsonModule(), new ServletModule() {

82 @Override

26 import com.google.inject.AbstractModule;

27 import com.google.inject.Guice;

28 import com.google.inject.Inject;

39 public static ProxyPool newInstance()

40 {

41 return Guice.createInjector(new AbstractModule() {

42 @Override protected void configure() {

43

54 proxyPool.submitAndWait(Arrays.<Worker>asList(new Worker() {

55 public void work(Session with) throws Throwable {

56 with.load(new URL("http://www.google.com/"));

57 System.out.println("DONE google!!!");

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

31 import com.google.inject.Guice;

32 import com.google.inject.Injector;

40 public class InstantiateVAppTemplateOptionsTest {

41

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

43

44 @Test

17 package org.jclouds.cloudsigma.functions;

18

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

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

37 import org.testng.annotations.Test;

38

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

40 import com.google.gson.Gson;

41 import com.google.inject.Guice;

42 import com.google.inject.TypeLiteral;

69

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

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

72 .getInstance(Json.class)));

73

35 import org.testng.annotations.Test;

36

37 import com.google.inject.Guice;

38 import com.google.inject.Injector;

45 @BeforeClass

46 public void setup() {

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

48 json = injector.getInstance(Json.class);

49 }

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

33 import com.google.inject.Guice;

34 import com.google.inject.Injector;

49 public void test() {

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

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

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

53 FirewallService result = factory.create(injector.getInstance(FirewallServiceHandler.class)).parse(is);

17

18 import atunit.core.Container;

19 import atunit.lib.com.google.common.collect.Iterables;

20 import atunit.lib.com.google.common.collect.Multimap;

21 import atunit.lib.com.google.common.collect.Multimaps;

22 import com.google.inject.*;

28 import java.util.Map;

29

30 public class GuiceContainer implements Container {

31

32 public Object createTest(Class<?> testClass, Map<Field, Object> fieldValues) throws Exception {

34 Injector injector;

35 if (Module.class.isAssignableFrom(testClass)) {

36 injector = Guice.createInjector(fields, (Module) testClass.newInstance());

37 } else {

38 injector = Guice.createInjector(fields);

15 * limitations under the License.

16 */

17 package salve.depend.guice;

18

19 import junit.framework.Assert;

28 import salve.depend.guice.model.Injected;

29 import salve.depend.guice.model.MockService;

30

31 import com.google.inject.AbstractModule;

32 import com.google.inject.Guice;

33 import com.google.inject.Injector;

58 };

59

60 Injector injector = Guice.createInjector(module);

61 locator = new GuiceBeanLocator(injector);

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

31 import com.google.inject.Guice;

32 import com.google.inject.Injector;

56

57 protected Injector injector() {

58 return Guice.createInjector(new GleSYSParserModule(), new GsonModule());

59 }

60 }

35 import org.testng.annotations.Test;

36

37 import com.google.inject.Guice;

38 import com.google.inject.Injector;

62 replay(converter);

63

64 Injector injector = Guice.createInjector(new GsonModule(), new ServletOhaiModule() {

65 @SuppressWarnings("unused")

66 @Provides

98 replay(converter);

99

100 Injector injector = Guice.createInjector(new GsonModule(), new ServletOhaiModule() {

101 @SuppressWarnings("unused")

102 @Provides

134 replay(converter);

135

136 Injector injector = Guice.createInjector(new GsonModule(), new ServletOhaiModule() {

137 @SuppressWarnings("unused")

138 @Provides

17

18 import atunit.core.Container;

19 import atunit.lib.com.google.common.collect.Iterables;

20 import atunit.lib.com.google.common.collect.Multimap;

21 import atunit.lib.com.google.common.collect.Multimaps;

22 import com.google.inject.AbstractModule;

23 import com.google.inject.Guice;

24 import com.google.inject.Injector;

38 Injector injector;

39 if (Module.class.isAssignableFrom(testClass)) {

40 injector = Guice.createInjector(fields, (Module) testClass.newInstance());

41 } else {

42 injector = Guice.createInjector(fields);

1 package bbejeck.nio.channels.guice;

2

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

4 import com.google.inject.Guice;

5 import com.google.inject.Injector;

11 * Time: 10:01 PM

12 */

13 public class GuiceAsyncDriver {

14

15 public static void main(String[] args) throws Exception {

16 Injector injector = Guice.createInjector(new AsynchronousServerModule());

17 AsyncSocketServerGuiceExample socketServer = injector.getInstance(AsyncSocketServerGuiceExample.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 BindDriveToPlainTextStringTest {

48

49 private static final BindDriveToPlainTextString FN = Guice.createInjector(new AbstractModule() {

50

51 @Override

19 package org.apache.roller.weblogger.business;

20

21 import com.google.inject.Guice;

22 import com.google.inject.Injector;

40

41 /**

42 * Instantiate a new GuiceWebloggerProvider using default guice module

43 * configured in WebloggerConfig via 'guice.backend.module' property.

51

52 /**

53 * Instantiate a new GuiceWebloggerProvider using the given Guice module.

54 *

55 * @param moduleClassname The full classname of the Guice module to use.

61 try {

62 Module module = (Module) Reflection.newInstance(moduleClassname);

63 injector = Guice.createInjector(module);

64 } catch (ThreadDeath t) {

65 throw t;

39 import org.testng.annotations.Test;

40

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

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

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

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

46 import com.google.common.io.Resources;

47 import com.google.inject.Guice;

48 import com.google.inject.Injector;

54 public class TagToBootScriptTest {

55

56 Injector injector = Guice.createInjector(new ChefParserModule(), new GsonModule());

57 Json json = injector.getInstance(Json.class);

58 Statement installChefGems = new InstallChefGems();

15 */

16

17 import com.google.inject.AbstractModule;

18 import com.google.inject.Provider;

63 @Test

64 public void testUntargettedBinding() {

65 Jsr250Injector injector = Jsr250.createInjector(new AbstractModule() {

66 @Override

67 protected void configure() {

81 @Test

82 public void testLinkedBinding() {

83 Jsr250Injector injector = Jsr250.createInjector(new AbstractModule() {

84 @Override

85 protected void configure() {

96 assertEquals(1, component.destroyed);

97

98 // Guice creates an internal jit ConstructorBinding therefor this fails as Mycila destroys on both bindings

99 }

100

3 import com.google.inject.Injector;

4 import com.google.inject.Guice;

5 import com.google.inject.Inject;

6 import com.google.inject.AbstractModule;

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

34 @BeforeClass

35 public void pre() {

36 injector = Guice.createInjector(PersistenceService.usingHibernate()

37 .across(UnitOfWork.REQUEST)

38 .transactedWith(TransactionStrategy.LOCAL)

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

26 import com.google.inject.Guice;

27

28 /**

33 public class ListOfKeyValuesDelimitedByBlankLinesToVLANInfoSetTest {

34

35 private static final ListOfKeyValuesDelimitedByBlankLinesToVLANInfoSet FN = Guice.createInjector().getInstance(

36 ListOfKeyValuesDelimitedByBlankLinesToVLANInfoSet.class);

37

32 import com.google.inject.AbstractModule;

33 import com.google.inject.Guice;

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

44 @Test(groups = "unit", testName = "OnlyReferenceTypeFirstWithNameMatchingConfigurationKeyOrDefaultTest")

45 public class OnlyReferenceTypeFirstWithNameMatchingConfigurationKeyOrDefaultTest {

46 ValueOfConfigurationKeyOrNull valueOfConfigurationKeyOrNull = Guice.createInjector().getInstance(

47 ValueOfConfigurationKeyOrNull.class);

48

91

92 assertEquals(

93 new OnlyReferenceTypeFirstWithNameMatchingConfigurationKeyOrDefault(Guice.createInjector(

94 new AbstractModule() {

95 protected void configure() {

106 ReferenceType reference2 = new ReferenceTypeImpl("hail mary", null, null);

107

108 new OnlyReferenceTypeFirstWithNameMatchingConfigurationKeyOrDefault(Guice.createInjector(new AbstractModule() {

109 protected void configure() {

110 bindConstant().annotatedWith(Names.named("foo")).to(".*happy.*");

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() {

40 package com.sun.jersey.samples.guice;

41

42 import com.google.inject.Guice;

43 import com.google.inject.Injector;

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

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

46 import com.sun.jersey.guice.spi.container.servlet.GuiceContainer;

47 import com.sun.jersey.samples.guice.resources.PerRequestResource;

54 * @author Marek Potociar (marek.potociar at oracle.com)

55 */

56 public class GuiceServletConfig extends GuiceServletContextListener {

57

58 @Override

34 import com.google.inject.AbstractModule;

35 import com.google.inject.Guice;

36 import com.google.inject.Injector;

37 import com.google.inject.Key;

38 import com.google.inject.TypeLiteral;

45 @Test(groups = "unit")

46 public class ParseImageFromJsonResponseTest {

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

48

49 @Override

70

71 public static Image parseImage() {

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

73

74 @Override

16 package com.wideplay.warp.persist;

17

18 import com.google.inject.*;

19 import com.wideplay.codemonkey.web.startup.Initializer;

20 import com.wideplay.warp.persist.dao.Finder;

59 .buildModule();

60

61 injector = Guice.createInjector(hibernateModule, hibernateModule2,

62 new PersistenceServiceExtrasModule());

63

24 import com.google.inject.Injector;

25 import com.google.inject.Guice;

26 import com.google.inject.AbstractModule;

50 @BeforeMethod

51 public void pre() {

52 injector = Guice.createInjector(PersistenceService.usingHibernate()

53 .across(UnitOfWork.TRANSACTION)

54 .addAccessor(HibernateTestAccessorForDFs.class)

15 * limitations under the License.

16 */

17 package org.jclouds.googlecomputeengine.internal;

18

19 import java.util.Date;

20

21 import org.jclouds.date.internal.SimpleDateFormatDateService;

22 import org.jclouds.googlecomputeengine.config.GoogleComputeEngineParserModule;

23 import org.jclouds.json.BaseItemParserTest;

24 import org.jclouds.json.config.GsonModule;

25

26 import com.google.inject.Guice;

27 import com.google.inject.Injector;

33 @Override

34 protected Injector injector() {

35 return Guice.createInjector(new GsonModule(), new GoogleComputeEngineParserModule());

36 }

37

23 import static org.easymock.EasyMock.verify;

24

25 import com.google.inject.Guice;

26 import com.google.inject.Injector;

64 public final void testDispatchRequestToManagedPipelineServlets()

65 throws ServletException, IOException {

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

67

68 @Override

108 public final void testDispatchRequestToManagedPipelineWithFilter()

109 throws ServletException, IOException {

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

111

112 @Override

233

234 public void testForwardUsingRequestDispatcher() throws IOException, ServletException {

235 Guice.createInjector(new ServletModule() {

236 @Override

237 protected void configureServlets() {

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

35 import com.google.inject.Guice;

36 import com.google.inject.Injector;

37 import com.google.inject.Key;

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

43 @Test

44 public void testLinkedViewBindsViewAndContextSuppliers() {

45 Injector injector = Guice.createInjector(linkView(new DummyView(contextFor(IntegrationTestClient.class))));

46

47 assertNotNull(injector.getExistingBinding(Key.get(CONTEXT_SUPPLIER, Names.named("IntegrationTestClient"))));

51 @Test

52 public void testLinkedContextBindsContextSupplier() {

53 Injector injector = Guice.createInjector(linkContext(contextFor(IntegrationTestClient.class)));

54

55 assertNotNull(injector.getExistingBinding(Key.get(CONTEXT_SUPPLIER, Names.named("IntegrationTestClient"))));

18 import com.google.inject.AbstractModule;

19 import com.google.inject.Guice;

20 import com.google.inject.Inject;

21 import com.google.inject.Injector;

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

43 @BeforeClass

44 public void pre() {

45 injector = Guice.createInjector(PersistenceService.usingHibernate()

46 .across(UnitOfWork.TRANSACTION)

47 .forAll(Matchers.any())

30 import org.testng.annotations.Test;

31

32 import com.google.inject.Guice;

33 import com.google.inject.Injector;

43 public void test() {

44 InputStream is = getClass().getResourceAsStream("/network.xml");

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

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

47 Network result = factory.create(injector.getInstance(NetworkHandler.class)).parse(is);

54 public void testNat() {

55 InputStream is = getClass().getResourceAsStream("/network-nat.xml");

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

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

58 Network result = factory.create(injector.getInstance(NetworkHandler.class)).parse(is);

65 public void tesWhenNoVAppsInNetworkSetsAllZerosToGatewayAndNetmask() {

66 InputStream is = getClass().getResourceAsStream("/network-unused.xml");

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

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

69 Network result = factory.create(injector.getInstance(NetworkHandler.class)).parse(is);

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

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

64 @Override

65 protected Injector injector() {

66 return Guice.createInjector(new GsonModule(), new KeystoneParserModule());

67 }

68 }

39 import org.junit.runner.RunWith;

40

41 import com.google.inject.Guice;

42 import com.google.inject.Inject;

43 import com.google.inject.Injector;

44 import com.google.inject.Provider;

70 public Injector createInjector()

71 {

72 return Guice.createInjector(new org.eclipse.emf.ecore.xcore.XcoreRuntimeModule()

73 {

74 @Override

79 });

80 }

81 }.createInjectorAndDoEMFRegistration();

82 stateAfterInjectorCreation = GlobalRegistries.makeCopyOfGlobalState();

83 }

20 import org.gbif.checklistbank.search.model.NameUsageSolrSearchResult;

21

22 import com.google.inject.Guice;

23 import com.google.inject.Injector;

24 import com.google.inject.Key;

25 import com.google.inject.TypeLiteral;

40 @BeforeClass

41 public static void init() {

42 injector = Guice.createInjector(new SearchModule());

43 searchService = injector.getInstance(Key.get(new TypeLiteral<NameUsageSearchService<NameUsageSolrSearchResult>>() {

44 }));

17 package nodus.inject;

18

19 import com.google.inject.Guice;

20

21 /**

23 */

24 public class Injector {

25 private static com.google.inject.Injector injector;

26

27 static {

28 injector = Guice.createInjector(new HttpModule());

29 }

30

23 import com.google.inject.AbstractModule;

24 import com.google.inject.Guice;

25 import com.google.inject.Inject;

26 import com.google.inject.Injector;

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

43 @BeforeClass

44 public void preClass() {

45 injector = Guice.createInjector(PersistenceService.usingDb4o()

46 .across(UnitOfWork.TRANSACTION)

47 .buildModule(),

31 import org.testng.annotations.Test;

32

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

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

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

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

38 import com.google.inject.AbstractModule;

39 import com.google.inject.Guice;

40 import com.google.inject.Provides;

47 @Override

48 protected void setUpInjector() {

49 injector = Guice.createInjector(new SaxParserModule(), new AbstractModule() {

50

51 @Override

9 import com.google.inject.AbstractModule;

10 import com.google.inject.Guice;

11 import com.google.inject.Injector;

12 import com.google.inject.Module;

13 import com.google.inject.Provider;

14 import com.google.inject.Provides;

15 import com.google.inject.Singleton;

125

126

127 return Guice.createInjector(modules);

128 }

129

171 public void testCannotBindMembersInjector() {

172 try {

173 Guice.createInjector(new AbstractModule() {

174 protected void configure() {

175 bind(MembersInjector.class).toProvider(Providers.<MembersInjector>of(null));

230

231 public void testGettingRawMembersInjector() {

232 Injector injector = Guice.createInjector();

233 try {

234 injector.getInstance(MembersInjector.class);

241

242 public void testGettingAnnotatedMembersInjector() {

243 Injector injector = Guice.createInjector();

244 try {

245 injector.getInstance(new Key<MembersInjector<String>>(Names.named("foo")) {});

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

35 import com.google.inject.Guice;

36 import com.google.inject.Injector;

46 public void testSavvis() {

47 InputStream is = getClass().getResourceAsStream("/orglist.xml");

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

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

50 Set<Resource> result = factory.create(injector.getInstance(OrgListHandler.class)).parse(is);

29 import org.testng.annotations.Test;

30

31 import com.google.inject.Guice;

32 import com.google.inject.Injector;

59

60 protected Injector injector() {

61 return Guice.createInjector(new GsonModule() {

62

63 @Override

1 package com.google.maven;

2

3 import com.google.classpath.ClassPath;

4 import com.google.classpath.ClassPathFactory;

5 import com.google.inject.Guice;

6 import com.google.test.metric.JavaTestabilityRunner;

175 return;

176 }

177 Guice.createInjector(new MavenConfigModule(this)).

178 getInstance(JavaTestabilityRunner.class).

179 run();

34

35 public void testConstructorRuntimeException() {

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

37 @Override

38 protected void configure() {

56

57 public void testConstructorCheckedException() {

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

59 @Override

60 protected void configure() {

78

79 public void testCustomProvidersRuntimeException() {

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

81 @Override

82 protected void configure() {

33 import com.google.inject.AbstractModule;

34 import com.google.inject.Guice;

35 import com.google.inject.Injector;

41 public class BindGroupToUpdateRequestJsonPayloadTest {

42

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

44 @Override

45 protected void configure() {

31 import org.testng.annotations.Test;

32

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

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

35 import com.google.inject.AbstractModule;

36 import com.google.inject.Guice;

37 import com.google.inject.TypeLiteral;

44 public class ListOfKeyValuesDelimitedByBlankLinesToServerInfoSetTest {

45

46 private static final ListOfKeyValuesDelimitedByBlankLinesToServerInfoSet FN = Guice.createInjector(

47 new AbstractModule() {

48

7 import org.eclipse.xtext.xbase.annotations.XbaseWithAnnotationsStandaloneSetup;

8

9 import com.google.inject.Guice;

10 import com.google.inject.Injector;

14 private static Injector injector = null;

15

16 public Injector createInjectorAndDoEMFRegistration() {

17 if (injector != null)

18 return injector;

19 XbaseWithAnnotationsStandaloneSetup.doSetup();

20 EPackage.Registry.INSTANCE.put(XtendPackage.eINSTANCE.getNsURI(), XtendPackage.eINSTANCE);

21 injector = Guice.createInjector(new XtendMavenModule());

22 new XtendStandaloneSetupGenerated().register(injector);

23 return injector;

30 import org.testng.annotations.Test;

31

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

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

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

35 import com.google.inject.AbstractModule;

36 import com.google.inject.Guice;

37 import com.google.inject.Injector;

48 @BeforeTest

49 protected void setUpInjector() throws IOException {

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

51 @Override

52 protected void configure() {

31 import org.testng.annotations.Test;

32

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

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

36 import com.google.inject.AbstractModule;

37 import com.google.inject.Guice;

38 import com.google.inject.TypeLiteral;

56 replay(api, keyApi);

57

58 CreateUniqueKeyPair parser = Guice.createInjector(new AbstractModule() {

59

60 @Override

90 replay(api, keyApi, uniqueIdSupplier);

91

92 CreateUniqueKeyPair parser = Guice.createInjector(new AbstractModule() {

93

94 @Override

20 import java.util.Map;

21

22 import com.google.inject.Guice;

23 import com.google.inject.Injector;

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

25 import com.sun.jersey.api.core.PackagesResourceConfig;

26 import com.sun.jersey.api.json.JSONConfiguration;

27 import com.sun.jersey.guice.JerseyServletModule;

28 import com.sun.jersey.guice.spi.container.servlet.GuiceContainer;

29 import org.slf4j.Logger;

30 import org.slf4j.LoggerFactory;

59 protected Injector getInjector() {

60 try {

61 return Guice.createInjector(new SearchModule(), new ChecklistBankSearchWsJerseyModule());

62 } catch (Exception e) {

63 LOG.error("Startup of checklistbank-search-ws failed", e);

37 import com.google.inject.AbstractModule;

38 import com.google.inject.Guice;

39 import com.google.inject.Injector;

57 checkConsistent(map, getStore(createInjectorWithProvidedMap(map)), "test", "instance1", "instancename");

58 checkConsistent(map, getStore(createInjectorWithProvidedMap(map)), "test", "instance1", "instancename");

59 remove(map, getStore(createInjectorWithProvidedMap(map)), "test");

64 Map<String, Node> map = Maps.newConcurrentMap();

65

66 Injector injector = createInjectorWithProvidedMap(map);

67 assertEquals(injector.getInstance(Key.get(new TypeLiteral<LoadingCache<String, Node>>() {

68 })).asMap(), map);

103 private Injector createInjectorWithProvidedMap(Map<String, Node> map) {

104 return Guice.createInjector(new CacheNodeStoreModule(map), new AbstractModule() {

105

106 @Override

114 private Injector createInjectorWithProvidedCache(LoadingCache<String, Node> cache) {

115 return Guice.createInjector(new CacheNodeStoreModule(cache), new AbstractModule() {

116

117 @Override

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

16 import com.google.inject.Guice;

17 import com.google.inject.Injector;

18 import com.google.inject.Module;

19

20 /**

53 Injector injector = injectors.get(language);

54 if (injector == null) {

55 injectors.put(language, injector = createInjector(language));

56 }

57 return injector;

65 Module uiModule = getUiModule(language);

66 Module mergedModule = Modules2.mixin(runtimeModule, sharedStateModule, uiModule);

67 return Guice.createInjector(mergedModule);

68 } catch (Exception e) {

69 logger.error("Failed to create injector for " + language);

5 package net.orfjackal.dimdwarf.entities;

6

7 import com.google.inject.*;

8 import jdave.*;

9 import jdave.junit4.JDaveRunner;

28

29 public void create() throws Exception {

30 injector = Guice.createInjector(

31 new CommonModules()

32 );

13 */

14

15 package com.google.inject.persist.jpa;

16

17 import com.google.inject.AbstractModule;

18 import com.google.inject.Guice;

19 import com.google.inject.Injector;

20 import com.google.inject.persist.PersistService;

21 import com.google.inject.persist.UnitOfWork;

89 final DataSource dataSource = getDataSource();

90

91 injector = Guice.createInjector(new DBModule(dataSource, passDataSource));

92

93 //startup persistence

9 import org.osgi.framework.BundleContext;

10

11 import com.google.inject.Guice;

12 import com.google.inject.Inject;

13 import com.google.inject.Injector;

14 import com.google.inject.Module;

49 {

50 BundleContext bundleContext = getBundle().getBundleContext();

51 Guice.createInjector(osgiModule(bundleContext, eclipseRegistry()), module).injectMembers(this);

52

53 templateLoader.loadTemplates();

35 import org.testng.annotations.Test;

36

37 import com.google.inject.Guice;

38

39 /**

64 String content, Class<? extends Exception> expected) {

65

66 OpSourceServersErrorHandler function = Guice.createInjector().getInstance(OpSourceServersErrorHandler.class);

67

68 HttpCommand command = createMock(HttpCommand.class);

14 import com.atlassian.webdriver.refapp.RefappTestedProduct;

15

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

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

18 import com.google.inject.AbstractModule;

19 import com.google.inject.ConfigurationException;

20 import com.google.inject.Guice;

21 import com.google.inject.Injector;

37 public static Composer compose()

38 {

39 Injector injector = Guice.createInjector(new UpmUiModule());

40 return CompositeTestRunner.compose().

41 from(TestGroupRunner.compose()).

31 import com.google.inject.AbstractModule;

32 import com.google.inject.Guice;

33 import com.google.inject.Injector;

52 @Test

53 public void testNewInstance() {

54 assertNotNull("new MonitoringGuiceInterceptor", new MonitoringGuiceInterceptor());

55 }

56

65 public void testGuiceAOP() {

66 final Counter guiceCounter = MonitoringProxy.getGuiceCounter();

67 guiceCounter.clear();

84 }

85 };

86 final Injector injector = Guice.createInjector(testModule);

87 final SpringTestFacade springTestFacade = injector.getInstance(SpringTestFacade.class);

88

1 /* Copyright 2008 Google Inc.

2 *

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

17 package com.google.dataconnector.util;

18

19 import com.google.dataconnector.protocol.ProtocolGuiceModule;

20 import com.google.inject.AbstractModule;

21 import com.google.inject.Guice;

22 import com.google.inject.Injector;

54 public static Injector getInjector() {

55 if (injector == null) {

56 injector = Guice.createInjector(new ClientGuiceModule(), new ProtocolGuiceModule());

57 }

58 return injector;

23 import com.google.inject.AbstractModule;

24 import com.google.inject.Guice;

25 import com.google.inject.Inject;

26 import com.google.inject.Injector;

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

41 @BeforeClass

42 public void preClass() {

43 injector = Guice.createInjector(PersistenceService.usingDb4o()

44 .across(UnitOfWork.REQUEST)

45

1 package cucumber.runtime.java.guice.impl;

2

3 import com.google.inject.Injector;

4 import cucumber.runtime.Env;

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

6 import org.junit.Test;

7

15 public class InjectorSourceFactoryTest {

16

17 private InjectorSourceFactory createInjectorSourceFactory(Properties properties) {

18 return new InjectorSourceFactory(new Env(properties));

19 }

20

21 @Test

22 public void createsDefaultInjectorSourceWhenGuiceModulePropertyIsNotSet() throws Exception {

23 InjectorSourceFactory injectorSourceFactory = createInjectorSourceFactory(new Properties());

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

33 import com.google.inject.Guice;

34 import com.google.inject.Injector;

58

59 protected Injector injector() {

60 return Guice.createInjector(new GsonModule() {

61

62 @Override