import javax.enterprise.inject.Instance; //导入依赖的package包/类
@Uri("")
@Produces
@Typed(MockEndpoint.class)
// Qualifiers are dynamically added in CdiCamelExtension
private static MockEndpoint mockEndpointFromUri(InjectionPoint ip, @Any Instance<CamelContext> instance, CdiCamelExtension extension) {
    Uri uri = getQualifierByType(ip, Uri.class).get();
    try {
        CamelContext context = uri.context().isEmpty()
            ? selectContext(ip, instance, extension)
            : selectContext(uri.context(), instance);
        return context.getEndpoint(uri.value(), MockEndpoint.class);
    } catch (Exception cause) {
        throw new InjectionException("Error injecting mock endpoint annotated with " + uri
            + " into " + ip, cause);
    }
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@Override
public void filter(ContainerRequestContext requestContext) throws IOException {
    Instance<Object> instance = CDI.current();
    User user = instance.select(User.class).get();

    List<AccountRole> roles = user.getAccountRoles();
    if (Arrays.stream(permissions.roles()).anyMatch(roles::contains)) {
        return;
    }

    Permission permission = instance.select(permissions.value()).get();
    if (permission.test(requestContext)) {
        return;
    }

    throw new ForbiddenException();
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@Before
public void prepare() {
    ZonedDateTimeAdapter adapter = new ZonedDateTimeAdapter();

    Instance<BoundStatement> getByIdStatement = mock(Instance.class);
    when(getByIdStatement.get())
            .thenReturn(new BoundStatement(session.prepare(BoundStatements.GET_BY_ID.getValue())));

    Instance<BoundStatement> createStatement = mock(Instance.class);
    when(createStatement.get())
            .thenReturn(new BoundStatement(session.prepare(BoundStatements.CREATE.getValue())));

    tokenService = new TokenService();
    tokenService.session = session;
    tokenService.zonedDateTimeAdapter = adapter;
    tokenService.stmtGetById = getByIdStatement;
    tokenService.stmtCreate = createStatement;
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@Inject
public PreferenceStoreImpl(final PreferenceStorage storage,
                           final PreferenceScopeFactory scopeFactory,
                           @Customizable final PreferenceScopeResolutionStrategy defaultScopeResolutionStrategy,
                           final Instance<PreferenceScopeResolutionStrategy> preferenceScopeResolutionStrategy,
                           final InjectionPoint ip) {
    this.storage = storage;
    this.scopeFactory = scopeFactory;

    if (preferenceScopeResolutionStrategy.isUnsatisfied()) {
        if (ip != null) {
            String componentKey = null;
            Annotation annotation = ip.getAnnotated().getAnnotation(ComponentKey.class);
            if (annotation != null) {
                componentKey = ((ComponentKey) annotation).value();
            }

            this.defaultScopeResolutionStrategy = new DefaultPreferenceScopeResolutionStrategy(scopeFactory,
                                                                                               componentKey);
        } else {
            this.defaultScopeResolutionStrategy = defaultScopeResolutionStrategy;
        }
    } else {
        this.defaultScopeResolutionStrategy = preferenceScopeResolutionStrategy.get();
    }
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@Inject
public Row(View view,
           Instance<ComponentColumn> columnInstance,
           Instance<ColumnWithComponents> columnWithComponentsInstance,
           DnDManager dndManager,
           LayoutDragComponentHelper layoutDragComponentHelper,
           Event<ComponentDropEvent> componentDropEvent,
           Event<ComponentRemovedEvent> componentRemovedEvent,
           Event<RowResizeEvent> rowResizeEvent) {

    this.view = view;
    this.columnInstance = columnInstance;
    this.columnWithComponentsInstance = columnWithComponentsInstance;
    this.dndManager = dndManager;
    this.layoutDragComponentHelper = layoutDragComponentHelper;
    this.componentDropEvent = componentDropEvent;
    this.componentRemovedEvent = componentRemovedEvent;
    this.rowResizeEvent = rowResizeEvent;
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@Inject
public CopyServiceImpl(@Named("ioStrategy") IOService ioService,
                       User identity,
                       SessionInfo sessionInfo,
                       Instance<CopyHelper> helpers,
                       Event<ResourceCopiedEvent> resourceCopiedEvent,
                       Instance<CopyRestrictor> copyRestrictorBeans,
                       PathNamingService pathNamingService) {
    this.ioService = ioService;
    this.identity = identity;
    this.sessionInfo = sessionInfo;
    this.helpers = helpers;
    this.resourceCopiedEvent = resourceCopiedEvent;
    this.copyRestrictorBeans = copyRestrictorBeans;
    this.pathNamingService = pathNamingService;
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@Before
public void setup() {
    securityConstraints = mock(Instance.class);
    event1 = generateEvent(new SocialUser("admin"));
    event2 = generateEvent(new SocialUser("dora"));
    events = new ArrayList<>();
    events.add(event1);
    events.add(event2);
    constraint1 = mock(SocialSecurityConstraint.class);
    constraint2 = mock(SocialSecurityConstraint.class);
    when(securityConstraints.iterator()).thenReturn(createSecurityConstraintsIterator());
    socialSecurityConstraintsManager = new SocialSecurityConstraintsManager() {
        @Override
        Instance<SocialSecurityConstraint> getSocialSecurityConstraints() {
            Instance<SocialSecurityConstraint> mock = mock(Instance.class);
            when(mock.iterator()).thenReturn(createSecurityConstraintsIterator());
            return mock;
        }
    };
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@Inject
public PanelManagerImpl(
        Event<PlaceGainFocusEvent> placeGainFocusEvent,
        Event<PlaceLostFocusEvent> placeLostFocusEvent,
        Event<PanelFocusEvent> panelFocusEvent,
        Event<SelectPlaceEvent> selectPlaceEvent,
        Event<PlaceMaximizedEvent> placeMaximizedEvent,
        Event<PlaceMinimizedEvent> placeMinimizedEventEvent,
        Event<PlaceHiddenEvent> placeHiddenEvent,
        SyncBeanManager iocManager,
        Instance<PlaceManager> placeManager,
        LayoutSelection layoutSelection,
        BeanFactory beanFactory) {
    this.placeGainFocusEvent = placeGainFocusEvent;
    this.placeLostFocusEvent = placeLostFocusEvent;
    this.panelFocusEvent = panelFocusEvent;
    this.selectPlaceEvent = selectPlaceEvent;
    this.placeMaximizedEvent = placeMaximizedEvent;
    this.placeMinimizedEvent = placeMinimizedEventEvent;
    this.placeHiddenEvent = placeHiddenEvent;
    this.iocManager = iocManager;
    this.placeManager = placeManager;
    this.layoutSelection = layoutSelection;
    this.beanFactory = beanFactory;
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@Before
public void setupGuvnorM2Repository() {
    ArtifactRepositoryPreference pref = mock(ArtifactRepositoryPreference.class);
    when(pref.getGlobalM2RepoDir()).thenReturn("repositories/kie");
    when(pref.isGlobalM2RepoDirEnabled()).thenReturn(true);
    when(pref.isDistributionManagementM2RepoDirEnabled()).thenReturn(true);
    when(pref.isWorkspaceM2RepoDirEnabled()).thenReturn(false);
    WorkspaceNameResolver resolver = mock(WorkspaceNameResolver.class);
    when(resolver.getWorkspaceName()).thenReturn("global");
    ArtifactRepositoryProducer producer = new ArtifactRepositoryProducer(pref,
                                                                         resolver);
    producer.initialize();
    Instance<ArtifactRepository> repositories = new MockInstanceImpl<>(producer.produceLocalRepository(),
                                                                       producer.produceGlobalRepository(),
                                                                       producer.produceDistributionManagementRepository());
    ArtifactRepositoryService factory = new ArtifactRepositoryService(repositories);
    repository = new GuvnorM2Repository(factory);
    repository.init();
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
/**
 * Test of getJsTopicMessageControllerFromJsTopicControls method, of class.
 */
@Test
public void getJsTopicMessageControllerFromJsTopicControlsTest() {
	System.out.println("getJsTopicMessageControllerFromJsTopicControls");
	JsTopicMessageController jtmc = mock(JsTopicMessageController.class);
	Instance select = mock(Instance.class);

	when(topicMessageController.select(any(JsTopicCtrlsAnnotationLiteral.class))).thenReturn(select);
	when(select.isUnsatisfied()).thenReturn(Boolean.TRUE).thenReturn(Boolean.FALSE);
	doReturn(jtmc).when(instance).getJsTopicMessageControllerFromIterable(eq(TOPIC), any(Instance.class));

	JsTopicMessageController result = instance.getJsTopicMessageControllerFromJsTopicControls(TOPIC);
	assertThat(result).isNull();

	result = instance.getJsTopicMessageControllerFromJsTopicControls(TOPIC);
	assertThat(result).isEqualTo(jtmc);
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
/**
 * Test of checkAccessTopicFromJsTopicAccessControllers method, of class.
 * @throws java.lang.IllegalAccessException
 */
@Test(expected = IllegalAccessException.class)
public void checkAccessTopicFromJsTopicControlsTest() throws IllegalAccessException {
	System.out.println("checkAccessTopicFromJsTopicControls");
	UserContext userContext = mock(UserContext.class);
	Instance instances = mock(Instance.class);
	when(topicAccessController.select(eq(new JsTopicCtrlsAnnotationLiteral()))).thenReturn(instances);
	when(instances.isUnsatisfied()).thenReturn(Boolean.TRUE).thenReturn(Boolean.FALSE);
	doReturn(Boolean.TRUE).doReturn(Boolean.FALSE).doThrow(IllegalAccessException.class).when(instance).checkAccessTopicFromJsTopicAccessControllers(eq(userContext), eq(TOPIC1), eq(instances));
	boolean result = instance.checkAccessTopicFromJsTopicControls(userContext, TOPIC1);
	assertThat(result).isFalse();
	result = instance.checkAccessTopicFromJsTopicControls(userContext, TOPIC1);
	assertThat(result).isTrue();
	result = instance.checkAccessTopicFromJsTopicControls(userContext, TOPIC1);
	assertThat(result).isFalse();
	instance.checkAccessTopicFromJsTopicControls(userContext, TOPIC1);
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
protected AbstractLightblueProxyServlet getTestServlet(CloseableHttpClient httpClient,
                                                       LightblueClientConfiguration clientConfig, final String serviceUri,
                                                       ServletConfig servletConfig) throws ServletException {
    Instance<LightblueClientConfiguration> instance = new StubInstance<>(clientConfig);

    AbstractLightblueProxyServlet servlet;
    servlet = new AbstractLightblueProxyServlet(httpClient, instance) {
        @Override
        protected String serviceUriForRequest(HttpServletRequest request) throws ServletException {
            return serviceUri + servicePathForRequest(request);
        }
    ;
    };

    if (servletConfig == null) {
        servlet.init();
    } else {
        servlet.init(servletConfig);
    }

    return servlet;
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
public AuthorizationCodeGrant asCodeGrant(Instance<AbstractAuthorizationGrant> grantInstance) {
    AuthorizationCodeGrant grant = grantInstance.select(AuthorizationCodeGrant.class).get();
    grant.init(user, client, authenticationTime);

    grant.setAuthorizationCode(new AuthorizationCode(authorizationCodeString, authorizationCodeCreationDate, authorizationCodeExpirationDate));
    grant.setScopes(scopes);
    grant.setGrantId(grantId);
    grant.setSessionDn(sessionDn);
    grant.setCodeChallenge(codeChallenge);
    grant.setCodeChallengeMethod(codeChallengeMethod);
    grant.setAcrValues(acrValues);
    grant.setNonce(nonce);
    grant.setClaims(claims);

    return grant;
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@SuppressWarnings({ "unchecked" })
@Test
public void testByDir() throws TemplateProcessorException {
	Instance<ProxiedParam<String>> templateDirectory = Mockito.mock(Instance.class);
	ProxiedParam<String> pp = new ProxiedParam<>();
	
	pp.setParam(Paths.get("src/test/resources/templates/").toAbsolutePath().toString());
	
	Mockito.when(templateDirectory.isUnsatisfied()).thenReturn(Boolean.FALSE);
	Mockito.when(templateDirectory.get()).thenReturn(pp);

	TemplateConfigProducer producer = new TemplateConfigProducer(templateDirectory);

	TemplateProcessor p = new TemplateProcessor(producer.produceConfiguration());
	Assert.assertEquals("template val.", p.processTemplate("test2.ftl", null));

}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
/**
 * Initialise all statistics modules that are found in the system
 * @param modules
 */
@Inject
protected void initModules(@Any Instance<StatisticsModule> modules) {
    log.info("Apache Marmotta StatisticsService starting up ...");

    this.modules = new LinkedHashMap<String,StatisticsModule>();

    for(StatisticsModule module : modules) {
        registerModule(module.getName(),module);
    }

    if(configurationService.getBooleanConfiguration("statistics.enabled",false)) {
        enableAll();
    } else {
        disableAll();
    }
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@PostConstruct
protected void initialize() {
    log.debug("initializing AuthenticationService");

    final String prov = configurationService.getStringConfiguration("user.auth.provider", DEFAULT_AUTH_PROVIDER_NAMED);

    Instance<AuthenticationProvider> selected = CDIUtils.selectNamed(providers, prov);
    if (selected.isAmbiguous()) {
        authenticationProvider = selected.iterator().next();
        log.error("multiple candidates for AuthenticationProvider '{}' found. Chose randomly!", prov);
    } else if (selected.isUnsatisfied()) {
        log.error("no candidate for AuthenticationProvider '{}' found, falling back to default", prov);
        authenticationProvider = CDIUtils.selectNamed(providers, DEFAULT_AUTH_PROVIDER_NAMED).iterator().next();
    } else {
        authenticationProvider = selected.get();
    }
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
public HealthCheckModel performHealthChecks() {
    Instance<HealthCheck> healthChecks = this.healthChecks;
    if (requireAnnotation) {
        healthChecks = this.healthChecks.select(HealthLiteral.INSTANCE);
    }
    List<HealthCheck> healthCheckBeans = healthChecks.stream()
            .collect(toList());

    List<HealthResultModel> results = healthCheckBeans.stream()
            .map(HealthCheck::call)
            .map(r -> new HealthResultModel(r.getName(), r.getState().name(), r.getData().orElse(emptyMap())))
            .collect(toList());
    boolean anyDown = results.stream().anyMatch(r -> r.getState().equalsIgnoreCase(HealthCheckResponse.State.DOWN.name()));
    try {
        if (anyDown) {
            return toModel(HealthCheckResponse.State.DOWN, results);
        } else {
            return toModel(HealthCheckResponse.State.UP, results);
        }
    }
    finally {
        healthCheckBeans.forEach(healthChecks::destroy);
    }
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@Inject
public GuidedRuleEditorCopyHelper(final @Named("ioStrategy") IOService ioService,
                                  final GuidedRuleDRLResourceTypeDefinition drlResourceType,
                                  final GuidedRuleDSLRResourceTypeDefinition dslrResourceType,
                                  final GuidedRuleEditorServiceUtilities utilities,
                                  final CommentedOptionFactory commentedOptionFactory,
                                  final DataModelService dataModelService,
                                  final Instance<RuleModelIActionPersistenceExtension> persistenceExtensionInstance) {
    this.ioService = ioService;
    this.drlResourceType = drlResourceType;
    this.dslrResourceType = dslrResourceType;
    this.utilities = utilities;
    this.commentedOptionFactory = commentedOptionFactory;
    this.dataModelService = dataModelService;

    persistenceExtensionInstance.forEach(persistenceExtensions::add);
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@Inject
public GuidedRuleEditorRenameHelper(final @Named("ioStrategy") IOService ioService,
                                    final GuidedRuleDRLResourceTypeDefinition drlResourceType,
                                    final GuidedRuleDSLRResourceTypeDefinition dslrResourceType,
                                    final GuidedRuleEditorServiceUtilities utilities,
                                    final CommentedOptionFactory commentedOptionFactory,
                                    final DataModelService dataModelService,
                                    final Instance<RuleModelIActionPersistenceExtension> persistenceExtensionInstance) {
    this.ioService = ioService;
    this.drlResourceType = drlResourceType;
    this.dslrResourceType = dslrResourceType;
    this.utilities = utilities;
    this.commentedOptionFactory = commentedOptionFactory;
    this.dataModelService = dataModelService;

    persistenceExtensionInstance.forEach(persistenceExtensions::add);
}
 

import javax.enterprise.inject.Instance; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void createFixture(Instance<Properties> joynrProperties, Instance<String> joynrLocalDomain) throws Exception {
    Instance<RawMessagingPreprocessor> rawMessageProcessor = mock(Instance.class);
    when(rawMessageProcessor.get()).thenReturn(new NoOpRawMessagingPreprocessor());
    BeanManager beanManager = mock(BeanManager.class);
    Bean<JoynrMessageProcessor> bean = mock(Bean.class);
    when(bean.create(Mockito.any())).thenReturn(new JoynrMessageProcessorTest());
    when(beanManager.getBeans(Mockito.<Type> eq(JoynrMessageProcessor.class), Mockito.<Annotation> any())).thenReturn(Sets.newHashSet(bean));

    final String mqttClientId = "someTestMqttClientId";
    MqttClientIdProvider mqttClientIdProvider = mock(MqttClientIdProvider.class);
    when(mqttClientIdProvider.getClientId()).thenReturn(mqttClientId);
    Instance<MqttClientIdProvider> mqttClientIdProviderInstance = mock(Instance.class);
    when(mqttClientIdProviderInstance.get()).thenReturn(mqttClientIdProvider);

    fixture = new DefaultJoynrRuntimeFactory(joynrProperties, joynrLocalDomain,
                                             rawMessageProcessor, mqttClientIdProviderInstance,
                                             beanManager);
    scheduledExecutorService = mock(ScheduledExecutorService.class);
    Field executorField = DefaultJoynrRuntimeFactory.class.getDeclaredField("scheduledExecutorService");
    executorField.setAccessible(true);
    executorField.set(fixture, scheduledExecutorService);
}