@SuppressWarnings("deprecation")
  @Before
  public void setupDependencies() throws Exception {
    if (null != _service_context) {
      return;
    }

    final String temp_dir = System.getProperty("java.io.tmpdir") + File.separator;

    // OK we're going to use guice, it was too painful doing this by hand...
    Config config =
        ConfigFactory.parseReader(
                new InputStreamReader(
                    this.getClass().getResourceAsStream("test_data_bucket_change.properties")))
            .withValue("globals.local_root_dir", ConfigValueFactory.fromAnyRef(temp_dir))
            .withValue("globals.local_cached_jar_dir", ConfigValueFactory.fromAnyRef(temp_dir))
            .withValue("globals.distributed_root_dir", ConfigValueFactory.fromAnyRef(temp_dir))
            .withValue("globals.local_yarn_config_dir", ConfigValueFactory.fromAnyRef(temp_dir));

    Injector app_injector = ModuleUtils.createTestInjector(Arrays.asList(), Optional.of(config));
    app_injector.injectMembers(this);

    _db_actor_context = new ManagementDbActorContext(_service_context, true);

    _actor_context =
        new DataImportActorContext(_service_context, new GeneralInformationService(), null); // TODO
    app_injector.injectMembers(_actor_context);

    // Have to do this in order for the underlying management db to live...
    _service_context.getCoreManagementDbService();
  }
  @Before
  public void setUp() throws Exception {
    Injector injector = Guice.createInjector(getModule());
    injector.injectMembers(this);
    typeProviderFactory.findOrCreateTypeProvider(resourceSet);
    syntheticResource = new XMLResourceImpl(URI.createURI("http://synthetic.resource"));
    resourceSet.getResources().add(syntheticResource);
    final TypeConformanceComputer delegate = computer;
    computer =
        new TypeConformanceComputer() {
          @Override
          public boolean isConformant(
              JvmTypeReference left, JvmTypeReference right, boolean ignoreGenerics) {
            assertTrue(delegate.isConformant(left, left, true));
            assertTrue(delegate.isConformant(left, left, false));
            assertTrue(delegate.isConformant(right, right, true));
            assertTrue(delegate.isConformant(right, right, false));
            assertTrue(delegate.isConformant(left, EcoreUtil2.clone(left), true));
            assertTrue(delegate.isConformant(left, EcoreUtil2.clone(left), false));
            assertTrue(delegate.isConformant(right, EcoreUtil2.clone(right), true));
            assertTrue(delegate.isConformant(right, EcoreUtil2.clone(right), false));
            return delegate.isConformant(left, right, ignoreGenerics);
          }

          @Override
          public JvmTypeReference getCommonSuperType(List<JvmTypeReference> types) {
            return delegate.getCommonSuperType(types);
          }
        };
  }
 @Override
 protected void createDefaultEditPolicies() {
   super.createDefaultEditPolicies();
   ExpressionDirectEditPolicy expressionDirectEditPolicy = new ExpressionDirectEditPolicy();
   injector.injectMembers(expressionDirectEditPolicy);
   installEditPolicy(EditPolicy.DIRECT_EDIT_ROLE, expressionDirectEditPolicy);
 }
Esempio n. 4
0
 @Override
 public SshClient create(IPSocket socket, LoginCredentials credentials) {
   SshClient client =
       new SshjSshClient(backoffLimitedRetryHandler, socket, credentials, timeout);
   injector.injectMembers(client); // add logger
   return client;
 }
 @BeforeClass(groups = "slow")
 protected void beforeClass() throws Exception {
   final Injector injector =
       Guice.createInjector(
           Stage.PRODUCTION, new TestEntitlementModuleWithEmbeddedDB(configSource));
   injector.injectMembers(this);
 }
Esempio n. 6
0
 @Before
 public void setUp() {
   XtendActivator _instance = XtendActivator.getInstance();
   final Injector injector = _instance.getInjector("org.eclipse.xtend.core.Xtend");
   injector.injectMembers(this);
   this.queuedBuildData.reset();
 }
  private void initialize(Context context) {
    Context applicationContext = context.getApplicationContext();
    Injector injector = AirCastingApplication.class.cast(applicationContext).getInjector();
    injector.injectMembers(this);

    gestureDetector.setOnDoubleTapListener(this);
  }
  /**
   * Initializes the application; in particular, bootstrapping the Isis backend, and initializing
   * the {@link ComponentFactoryRegistry} to be used for rendering.
   */
  @Override
  protected void init() {
    super.init();

    // 6.0.0 rather than overriding getRequestCycleSettings
    // TODO: reinstate REDIRECT_TO_RENDER once WICKET-4773 implemented (Wicket 6.1.0)
    getRequestCycleSettings().setRenderStrategy(RenderStrategy.REDIRECT_TO_BUFFER);
    // 6.0.0 instead of subclassing newRequestCycle
    getRequestCycleListeners().add(new WebRequestCycleForIsis());

    getResourceSettings().setParentFolderPlaceholder("$up$");
    final DeploymentType deploymentType = determineDeploymentType();

    final IsisConfigurationBuilder isisConfigurationBuilder =
        createConfigBuilder(getServletContext());

    final IsisInjectModule isisModule =
        new IsisInjectModule(deploymentType, isisConfigurationBuilder);
    final Injector injector = Guice.createInjector(isisModule, newIsisWicketModule());
    injector.injectMembers(this);

    this.bookmarkedPagesModel = new BookmarkedPagesModel();

    initWicketComponentInjection(injector);
  }
  @BeforeClass(groups = "slow")
  protected void beforeClass() throws Exception {
    loadSystemPropertiesFromClasspath("/resource.properties");

    final Injector injector =
        Guice.createInjector(new TestPaymentModuleWithEmbeddedDB(configSource, getClock()));
    injector.injectMembers(this);
  }
Esempio n. 10
0
 public List<AdminCommand> listCommands() {
   final ServiceLoader<AdminCommand> loader = ServiceLoader.load(AdminCommand.class);
   final List<AdminCommand> list = new ArrayList<>();
   for (final AdminCommand command : loader) {
     injector.injectMembers(command);
     list.add(command);
   }
   return list;
 }
 @Before
 public void setUp() throws Exception {
   ResourceSet resourceSet = new ResourceSetImpl();
   Injector injector = Guice.createInjector(getModule());
   injector.injectMembers(this);
   typeProvider =
       injector.getInstance(IJvmTypeProvider.Factory.class).findOrCreateTypeProvider(resourceSet);
   typeRefs = new JvmTypeReferences(injector.getInstance(TypesFactory.class), typeProvider);
 }
Esempio n. 12
0
  /**
   * Implementation does injection of actor handler from class.
   *
   * <p>{@inheritDoc}
   */
  @Override
  public void onInit(SparrowEngine engine) {
    if (actorHandler == null) {
      actorHandler = injector.getInstance(actorHandlerClass);
    } else {
      injector.injectMembers(actorHandler);
    }

    super.onInit(engine);
  }
 private void initValidationJob() {
   final IFile file = ((IFileEditorInput) getEditorInput()).getFile();
   validationJob = new SCTValidationJob(getDiagram());
   IExpressionLanguageProvider registeredProvider =
       ExpressionLanguageProviderExtensions.getRegisteredProvider(
           SemanticTarget.StatechartSpecification, file.getFileExtension());
   Injector injector = registeredProvider.getInjector();
   injector.injectMembers(validationJob);
   validationJob.setRule(file);
 }
 /* (non-Javadoc)
  * @see org.eclipse.riena.navigation.ui.swt.views.SubModuleView#createController(org.eclipse.riena.navigation.ISubModuleNode)
  */
 @Override
 protected SubModuleController createController(ISubModuleNode node) {
   SubModuleController controller = super.createController(node);
   if (controller != null) {
     BundleContext context = Platform.getBundle("com.agritrace.edairy.desktop").getBundleContext();
     ServiceReference service = context.getServiceReference(Injector.class.getName());
     Injector injector = (Injector) context.getService(service);
     injector.injectMembers(controller);
   }
   return controller;
 }
Esempio n. 15
0
 @Before
 public void initialize() {
   Config conf = MidoTestConfigurator.forAgents(fillConfig());
   injector =
       Guice.createInjector(
           new SerializationModule(),
           new MidolmanConfigModule(conf),
           new MockZookeeperConnectionModule(),
           new MidonetBackendTestModule(conf),
           new LegacyClusterModule());
   injector.injectMembers(this);
 }
Esempio n. 16
0
 /**
  * Creates an {@link IHandlePart} for the specified vertex of the {@link IGeometry} provided by
  * the given <i>handleGeometryProvider</i>.
  *
  * @param target {@link IVisualPart} for which a selection handle is created.
  * @param segmentsProvider Provides the {@link BezierCurve}s from which the handle can retrieve
  *     its location.
  * @param segmentCount Number of segments.
  * @param segmentIndex Index of the segment where the handle is located.
  * @param contextMap Stores context information as an {@link IBehavior} is stateless.
  * @return {@link IHandlePart} for the specified vertex of the {@link IGeometry} provided by the
  *     <i>handleGeometryProvider</i>
  */
 protected IHandlePart<Node, ? extends Node> createSelectionSegmentHandlePart(
     final IVisualPart<Node, ? extends Node> target,
     Provider<BezierCurve[]> segmentsProvider,
     int segmentCount,
     int segmentIndex,
     Map<Object, Object> contextMap) {
   FXCircleSegmentHandlePart part = injector.getInstance(FXCircleSegmentHandlePart.class);
   part.setSegmentsProvider(segmentsProvider);
   part.setSegmentIndex(segmentIndex);
   part.setSegmentParameter(0);
   injector.injectMembers(part);
   return part;
 }
Esempio n. 17
0
  private Object createTest(Class<?> testClass, Map<Field, Binding> fieldValues) throws Exception {
    FieldModule fields = new FieldModule(fieldValues);

    Injector injector;
    Object test = super.createTest();
    if (Module.class.isAssignableFrom(testClass)) {
      injector = Guice.createInjector(fields, (Module) testClass.newInstance());
    } else {
      injector = Guice.createInjector(fields);
    }
    injector.injectMembers(test);
    return test;
  }
  @BeforeGroups(groups = {"integration", "live"})
  public void setupClient()
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    if (tag == null) tag = checkNotNull(service, "service");
    setupCredentials();
    setupKeyPair();
    initializeContextAndClient();

    Injector injector = createSshClientInjector();
    sshFactory = injector.getInstance(SshClient.Factory.class);
    SocketOpen socketOpen = injector.getInstance(SocketOpen.class);
    socketTester = new RetryablePredicate<IPSocket>(socketOpen, 60, 1, TimeUnit.SECONDS);
    injector.injectMembers(socketOpen); // add logger
  }
Esempio n. 19
0
  @Override
  public void injectMembers(@Nonnull Object instance) throws MembersInjectionException {
    requireNonNull(instance, ERROR_INSTANCE_NULL);

    if (isClosed()) {
      throw new MembersInjectionException(instance, new ClosedInjectorException(this));
    }

    try {
      delegate.injectMembers(instance);
    } catch (RuntimeException e) {
      throw new MembersInjectionException(instance, e);
    }
  }
 @Override
 public Object execute(ExecutionEvent event) throws ExecutionException {
   try {
     IFile file = (IFile) HandlerUtil.getActiveEditorInput(event).getAdapter(IFile.class);
     if (file != null) {
       RuntimeMatcherRegistrator registrator = new RuntimeMatcherRegistrator(file, null);
       injector.injectMembers(registrator);
       Display.getDefault().asyncExec(registrator);
     }
   } catch (Exception e) {
     throw new ExecutionException("Cannot load pattern file", e);
   }
   return null;
 }
Esempio n. 21
0
  public boolean visit(IResourceDelta delta) {
    IResource res = delta.getResource();

    if (res != null && res instanceof IFile && delta.getKind() == IResourceDelta.CHANGED) {

      IFile file = (IFile) res;
      if (PatternRegistry.getInstance().getFiles().contains(file)) {
        RuntimeMatcherRegistrator registrator = new RuntimeMatcherRegistrator((IFile) file);
        injector.injectMembers(registrator);
        Display.getDefault().syncExec(registrator);
      }
      return false;
    }
    return true;
  }
Esempio n. 22
0
 @Override
 public void setUp() throws Exception {
   super.setUp();
   IJavaProject project = JavaProjectSetupUtil.createJavaProject(TEST_PROJECT);
   addNature(project.getProject(), XtextProjectHelper.NATURE_ID);
   Injector injector = Activator.getInstance().getInjector(getEditorId());
   injector.injectMembers(this);
   IFile fooFile =
       IResourcesSetupUtil.createFile(TEST_PROJECT + "/foo.refactoringtestlanguage", "foo");
   IFile barFile =
       IResourcesSetupUtil.createFile(
           TEST_PROJECT + "/bar.refactoringtestlanguage", "bar { ref foo }");
   waitForAutoBuild();
   fooEditor = openEditor(fooFile);
   barEditor = openEditor(barFile);
   assertTrue(refactoringPreferences.useInlineRefactoring());
 }
  @Override
  @Before
  public void setUp() {
    Injector injector =
        Guice.createInjector(
            // configure the provider to return always the same in memory implementation of the
            // strategy catalog
            new SearchApiCuseBindingModule(InMemoryRepository.class) {

              @Override
              EntityLoader getEntityLoader(Injector injector) {
                return inMemoryRepository;
              }
            });
    injector.injectMembers(this);
    super.setUp();
  }
Esempio n. 24
0
  @Before
  public void setUpInjector() throws Exception {
    lifecycle = new LifecycleManager();
    Injector injector = createInjector();
    lifecycle.add(injector);
    injector.injectMembers(this);
    lifecycle.start();

    db = schemaFactory.open();
    schemaCreator.create(db);
    userId = accountManager.authenticate(AuthRequest.forUser("user")).getAccountId();
    Account userAccount = db.accounts().get(userId);
    userAccount.setPreferredEmail("*****@*****.**");
    db.accounts().update(ImmutableList.of(userAccount));
    user = userFactory.create(Providers.of(db), userId);
    requestContext.setContext(newRequestContext(userAccount.getId()));
  }
  /** Guice test initialization method. */
  @Before
  public void beforeGwtGuiceTest() {

    final Injector injector = getInjector();
    // add a new RemoteServiceHandler which will call Guice Injector
    addGwtCreateHandler(
        new RemoteServiceCreateHandler() {

          @Override
          protected Object findService(
              Class<?> remoteServiceClass, String remoteServiceRelativePath) {
            return getRpcServiceFromInjector(
                injector, remoteServiceClass, remoteServiceRelativePath);
          }
        });

    injector.injectMembers(this);
  }
  public NewMechanoidOpsFileWizard() {

    Injector injector =
        OpServiceModelActivator.getInstance()
            .getInjector(OpServiceModelActivator.COM_ROBOTOWORKS_MECHANOID_OPS_OPSERVICEMODEL);

    injector.injectMembers(this);

    mNewFilePage =
        new NewMechanoidElementPage("new_file_page") { // $NON-NLS-1$
          @Override
          protected String getNameFieldInfoMessage() {
            return Messages.NewMechanoidOpsFileWizard_Widget_Label_Message_Name;
          }
        };
    mNewFilePage.setTitle(Messages.NewMechanoidOpsFileWizard_Title);
    mNewFilePage.setDescription(Messages.NewMechanoidOpsFileWizard_Message);
  }
Esempio n. 27
0
  @BeforeGroups(groups = {"live"})
  public void setupClient() {
    String identity =
        checkNotNull(System.getProperty("jclouds.test.identity"), "jclouds.test.identity");

    Injector injector =
        new RestContextFactory()
            .createContextBuilder(
                "slicehost",
                identity,
                null,
                ImmutableSet.<Module>of(new Log4JLoggingModule(), new JschSshClientModule()),
                new Properties())
            .buildInjector();

    client = injector.getInstance(SlicehostClient.class);
    sshFactory = injector.getInstance(SshClient.Factory.class);
    SocketOpen socketOpen = injector.getInstance(SocketOpen.class);
    socketTester = new RetryablePredicate<IPSocket>(socketOpen, 120, 1, TimeUnit.SECONDS);
    injector.injectMembers(socketOpen); // add logger
  }
Esempio n. 28
0
 @Test
 public void testDecodeURI() {
   try {
     StringConcatenation _builder = new StringConcatenation();
     _builder.append("package mypack");
     _builder.newLine();
     _builder.newLine();
     _builder.append("class Foo {");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("public def void foo() {");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("}");
     _builder.newLine();
     _builder.append("}");
     _builder.newLine();
     final IFile file = this.helper.createFile("mypack/MyClass Foo.xtend", _builder.toString());
     IResourcesSetupUtil.waitForAutoBuild();
     final ResourceStorageTest.TestableStorageAwareTrace storageAwareTrace =
         new ResourceStorageTest.TestableStorageAwareTrace();
     Injector _injector = this.getInjector();
     _injector.injectMembers(storageAwareTrace);
     storageAwareTrace.setLocalStorage(file);
     URI _createURI = URI.createURI("mypack/MyClass%20Foo.xtend");
     URI result = storageAwareTrace.resolvePath(_createURI);
     String _string = result.toString();
     Assert.assertEquals(
         "platform:/resource/test.project/src/mypack/MyClass%20Foo.xtend", _string);
     IProject _project = this.helper.getProject();
     URI _createURI_1 = URI.createURI("src/mypack/MyClass%20Foo.xtend");
     URI _resolvePath = storageAwareTrace.resolvePath(_project, _createURI_1);
     result = _resolvePath;
     String _string_1 = result.toString();
     Assert.assertEquals(
         "platform:/resource/test.project/src/mypack/MyClass%20Foo.xtend", _string_1);
   } catch (Throwable _e) {
     throw Exceptions.sneakyThrow(_e);
   }
 }
  @BeforeGroups(groups = {"live"})
  public void setupClient() {
    setupCredentials();
    Properties overrides = setupProperties();
    Injector injector =
        new RestContextFactory()
            .createContextBuilder(
                provider, ImmutableSet.<Module>of(new Log4JLoggingModule()), overrides)
            .buildInjector();
    client = injector.getInstance(EC2Client.class);
    sshFactory = injector.getInstance(SshClient.Factory.class);
    SocketOpen socketOpen = injector.getInstance(SocketOpen.class);
    socketTester = new RetryablePredicate<IPSocket>(socketOpen, 120, 1, TimeUnit.SECONDS);

    VolumeAvailable volumeAvailable = injector.getInstance(VolumeAvailable.class);
    volumeTester = new RetryablePredicate<Volume>(volumeAvailable, 60, 1, TimeUnit.SECONDS);

    SnapshotCompleted snapshotCompleted = injector.getInstance(SnapshotCompleted.class);
    snapshotTester = new RetryablePredicate<Snapshot>(snapshotCompleted, 120, 3, TimeUnit.SECONDS);

    VolumeAttached volumeAttached = injector.getInstance(VolumeAttached.class);
    attachTester = new RetryablePredicate<Attachment>(volumeAttached, 60, 1, TimeUnit.SECONDS);

    runningTester =
        new RetryablePredicate<RunningInstance>(
            new InstanceStateRunning(client), 180, 5, TimeUnit.SECONDS);

    InstanceStateStopped instanceStateStopped = injector.getInstance(InstanceStateStopped.class);
    stoppedTester =
        new RetryablePredicate<RunningInstance>(instanceStateStopped, 60, 1, TimeUnit.SECONDS);

    InstanceStateTerminated instanceStateTerminated =
        injector.getInstance(InstanceStateTerminated.class);
    terminatedTester =
        new RetryablePredicate<RunningInstance>(instanceStateTerminated, 60, 1, TimeUnit.SECONDS);

    injector.injectMembers(socketOpen); // add logger
  }
Esempio n. 30
0
  @Override
  public void start(BundleContext context) throws Exception {
    injector =
        GuiceContext.createChildInjector(
            Peaberry.osgiModule(context),
            new AbstractMyBatisExportModule() {
              @Override
              protected void initialize() {
                this.addSimpleAlias(AsCompoModel.class);
                this.addSimpleAlias(BusinessType.class);
                this.addSimpleAlias(Company.class);
                this.addSimpleAlias(Org.class);
                this.addSimpleAlias(Point.class);
                this.addSimpleAlias(Position.class);
                this.addSimpleAlias(Staff.class);

                this.addMapperClass(BusinessMapper.class);

                this.exportService(BusinessService.class, BusinessServiceImpl.class);
              }
            });
    injector.injectMembers(this);
  }