Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { ConfigurableApplicationContext registerAnnotatedClasses(ConfigurableApplicationContext applicationContext, Class<?>[] annotatedClasses) { return applicationContext instanceof AnnotationConfigApplicationContext && !ObjectUtils.isEmpty(annotatedClasses) ? doRegister(applicationContext, annotatedClasses) : applicationContext; } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }### Answer: @Test public void registerAnnotatedClasses() { AnnotationConfigApplicationContext mockApplicationContext = mock(AnnotationConfigApplicationContext.class,"MockApplicationContext"); Class<?>[] annotatedClasses = { TestAppConfigOne.class, TestAppConfigTwo.class }; SpringContextBootstrappingInitializer initializer = spy(new SpringContextBootstrappingInitializer()); doReturn(mockApplicationContext) .when(initializer).doRegister(any(ConfigurableApplicationContext.class), any(Class[].class)); assertThat(initializer.registerAnnotatedClasses(mockApplicationContext, annotatedClasses), is(sameInstance(mockApplicationContext))); verify(initializer, times(1)) .doRegister(eq(mockApplicationContext), eq(annotatedClasses)); }
### Question: SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { ConfigurableApplicationContext scanBasePackages(ConfigurableApplicationContext applicationContext, String[] basePackages) { return applicationContext instanceof AnnotationConfigApplicationContext && !ObjectUtils.isEmpty(basePackages) ? doScan(applicationContext, basePackages) : applicationContext; } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }### Answer: @Test public void scanBasePackages() { AnnotationConfigApplicationContext mockApplicationContext = mock(AnnotationConfigApplicationContext.class, "MockApplicationContext"); SpringContextBootstrappingInitializer initializer = spy(new SpringContextBootstrappingInitializer()); doReturn(mockApplicationContext) .when(initializer).doScan(any(ConfigurableApplicationContext.class), any(String[].class)); String[] basePackages = { "org.example.app", "org.example.plugins" }; assertThat(initializer.scanBasePackages(mockApplicationContext, basePackages), is(sameInstance(mockApplicationContext))); verify(initializer, times(1)).doScan(eq(mockApplicationContext), eq(basePackages)); }
### Question: SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { ConfigurableApplicationContext setClassLoader(ConfigurableApplicationContext applicationContext) { ClassLoader beanClassLoader = beanClassLoaderReference.get(); if (applicationContext instanceof DefaultResourceLoader && beanClassLoader != null) { ((DefaultResourceLoader) applicationContext).setClassLoader(beanClassLoader); } return applicationContext; } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }### Answer: @Test public void setClassLoader() { AbstractApplicationContext mockApplicationContext = mock(AbstractApplicationContext.class, "MockApplicationContext"); SpringContextBootstrappingInitializer.setBeanClassLoader(Thread.currentThread().getContextClassLoader()); assertThat(new SpringContextBootstrappingInitializer().setClassLoader(mockApplicationContext), is(sameInstance(mockApplicationContext))); verify(mockApplicationContext, times(1)) .setClassLoader(eq(Thread.currentThread().getContextClassLoader())); }
### Question: SpringContextBootstrappingInitializer implements Declarable, ApplicationListener<ApplicationContextEvent> { String nullSafeGetApplicationContextId(ApplicationContext applicationContext) { return applicationContext != null ? applicationContext.getId() : null; } static synchronized ConfigurableApplicationContext getApplicationContext(); static void setBeanClassLoader(ClassLoader beanClassLoader); static T register(T listener); static boolean register(Class<?> annotatedClass); static T unregister(T listener); static boolean unregister(Class<?> annotatedClass); @Override @SuppressWarnings("deprecation") void init(Properties parameters); void init(Cache cache, Properties parameters); @Override void onApplicationEvent(ApplicationContextEvent event); static final String BASE_PACKAGES_PARAMETER; static final String CONTEXT_CONFIG_LOCATIONS_PARAMETER; }### Answer: @Test public void nullSafeGetApplicationContextIdWithNullReference() { assertThat(new SpringContextBootstrappingInitializer().nullSafeGetApplicationContextId(null), is(nullValue())); } @Test public void nullSafeGetApplicationContextIdWithNonNullReference() { ApplicationContext mockApplicationContext = mock(ApplicationContext.class, "MockApplicationContext"); when(mockApplicationContext.getId()).thenReturn("123"); assertThat(new SpringContextBootstrappingInitializer().nullSafeGetApplicationContextId(mockApplicationContext), is(equalTo("123"))); }
### Question: IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { @Override public void afterPropertiesSet() throws Exception { this.indexName = resolveIndexName(); applyIndexConfigurers(this.indexName); this.cache = resolveCache(); this.queryService = resolveQueryService(); assertIndexDefinitionConfiguration(); this.index = createIndex(this.queryService, this.indexName); registerAlias(getBeanName(), this.indexName); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }### Answer: @Test(expected = IllegalArgumentException.class) public void afterPropertiesSetWithNoIndexName() throws Exception { try { newIndexFactoryBean().afterPropertiesSet(); } catch (IllegalArgumentException expected) { assertThat(expected).hasMessage("Index name is required"); assertThat(expected).hasNoCause(); throw expected; } }
### Question: AnnotationBasedExpiration implements BeanFactoryAware, CustomExpiry<K, V> { protected BeanFactory getBeanFactory() { BeanFactory localBeanFactory = BEAN_FACTORY_REFERENCE.get(); Assert.state(localBeanFactory != null, "beanFactory was not properly initialized"); return localBeanFactory; } AnnotationBasedExpiration(); AnnotationBasedExpiration(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forIdleTimeout(); static AnnotationBasedExpiration<K, V> forIdleTimeout(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forTimeToLive(); static AnnotationBasedExpiration<K, V> forTimeToLive(ExpirationAttributes defaultExpirationAttributes); @Override void setBeanFactory(BeanFactory beanFactory); void setDefaultExpirationAttributes(ExpirationAttributes defaultExpirationAttributes); @Override ExpirationAttributes getExpiry(Region.Entry<K, V> entry); @Override void close(); }### Answer: @Test(expected = IllegalStateException.class) public void getUninitializedBeanFactory() { new AnnotationBasedExpiration<Object, Object>().getBeanFactory(); }
### Question: IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { RegionService resolveCache() { RegionService resolvedCache = this.cache != null ? this.cache : GemfireUtils.resolveGemFireCache(); return Optional.ofNullable(resolvedCache) .orElseThrow(() -> newIllegalStateException("Cache is required")); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }### Answer: @Test public void resolveCacheFromCacheProperty() { assertThat(newIndexFactoryBean().resolveCache()).isSameAs(mockCache); }
### Question: IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { QueryService doLookupQueryService() { Supplier<QueryService> queryServiceSupplier = () -> this.cache instanceof ClientCache ? ((ClientCache) this.cache).getLocalQueryService() : this.cache.getQueryService(); return Optional.ofNullable(this.queryService) .orElseGet(queryServiceSupplier); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }### Answer: @Test public void doLookupQueryService() { QueryService mockQueryServiceOne = mockQueryService("testDoLookupQueryService.MockQueryService.One"); IndexFactoryBean indexFactoryBean = newIndexFactoryBean(); indexFactoryBean.setQueryService(mockQueryServiceOne); assertThat(indexFactoryBean.doLookupQueryService()).isSameAs(mockQueryServiceOne); verify(mockCache, never()).getQueryService(); }
### Question: IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { QueryService resolveQueryService() { QueryService resolvedQueryService = this.queryService != null ? this.queryService : lookupQueryService(); return Optional.ofNullable(resolvedQueryService) .orElseThrow(() -> newIllegalStateException("QueryService is required to create an Index")); } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }### Answer: @Test public void resolveQueryServiceReturnsIndexFactoryBeanConfiguredQueryService() { assertThat(newIndexFactoryBean().resolveQueryService()).isSameAs(mockQueryService); }
### Question: IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { Index createFunctionalIndex(QueryService queryService, String indexName, String expression, String from, String imports) throws Exception { boolean hasImports = StringUtils.hasText(imports); if (isDefine()) { if (hasImports) { queryService.defineIndex(indexName, expression, from , imports); } else { queryService.defineIndex(indexName, expression, from); } return new IndexWrapper(queryService, indexName); } else { if (hasImports) { return queryService.createIndex(indexName, expression, from, imports); } else { return queryService.createIndex(indexName, expression, from); } } } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }### Answer: @Test public void createFunctionalIndex() throws Exception { Index mockIndex = mockIndex("testCreateFunctionalIndex.MockIndex"); when(mockQueryService.createIndex(eq("FunctionalIndex"), eq("purchaseDate"), eq("/Orders"))) .thenReturn(mockIndex); Index actualIndex = indexFactoryBean.createFunctionalIndex(mockQueryService, "FunctionalIndex", "purchaseDate", "/Orders", null); assertThat(actualIndex).isSameAs(mockIndex); verify(mockQueryService, times(1)) .createIndex(eq("FunctionalIndex"), eq("purchaseDate"), eq("/Orders")); verify(mockQueryService, never()).defineIndex(anyString(), anyString(), anyString()); }
### Question: AnnotationBasedExpiration implements BeanFactoryAware, CustomExpiry<K, V> { @Override public ExpirationAttributes getExpiry(Region.Entry<K, V> entry) { return newExpirationAttributes(getExpirationMetaData(entry)); } AnnotationBasedExpiration(); AnnotationBasedExpiration(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forIdleTimeout(); static AnnotationBasedExpiration<K, V> forIdleTimeout(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forTimeToLive(); static AnnotationBasedExpiration<K, V> forTimeToLive(ExpirationAttributes defaultExpirationAttributes); @Override void setBeanFactory(BeanFactory beanFactory); void setDefaultExpirationAttributes(ExpirationAttributes defaultExpirationAttributes); @Override ExpirationAttributes getExpiry(Region.Entry<K, V> entry); @Override void close(); }### Answer: @Test public void getExpiryCallsGetExpirationMetaDataOnRegionEntryFollowedByNewExpirationAttributes() { final ExpirationAttributes expectedExpirationAttributes = new ExpirationAttributes(60, ExpirationAction.LOCAL_DESTROY); final Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); AnnotationBasedExpiration expiration = new AnnotationBasedExpiration() { @Override protected ExpirationMetaData getExpirationMetaData(Region.Entry entry) { assertThat(entry, is(sameInstance(mockRegionEntry))); return ExpirationMetaData.from(expectedExpirationAttributes); } @Override protected ExpirationAttributes newExpirationAttributes(ExpirationMetaData expirationMetaData) { assertThat(expirationMetaData.timeout(), is(equalTo(expectedExpirationAttributes.getTimeout()))); assertThat(expirationMetaData.expirationAction(), is(equalTo(expectedExpirationAttributes.getAction()))); return expectedExpirationAttributes; } }; assertThat(expiration.getExpiry(mockRegionEntry), is(equalTo(expectedExpirationAttributes))); }
### Question: IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { Index createKeyIndex(QueryService queryService, String indexName, String expression, String from) throws Exception { if (isDefine()) { queryService.defineKeyIndex(indexName, expression, from); return new IndexWrapper(queryService, indexName); } else { return queryService.createKeyIndex(indexName, expression, from); } } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }### Answer: @Test public void createKeyIndex() throws Exception { Index mockIndex = mockIndex("testCreateKeyIndex.MockKeyIndex"); when(mockQueryService.createKeyIndex(eq("KeyIndex"), eq("id"), eq("/Example"))) .thenReturn(mockIndex); Index actualIndex = indexFactoryBean.createKeyIndex(mockQueryService, "KeyIndex", "id", "/Example"); assertThat(actualIndex).isSameAs(mockIndex); verify(mockQueryService, times(1)) .createKeyIndex(eq("KeyIndex"), eq("id"), eq("/Example")); verify(mockQueryService, never()).defineKeyIndex(anyString(), anyString(), anyString()); }
### Question: AnnotationBasedExpiration implements BeanFactoryAware, CustomExpiry<K, V> { protected boolean isExpirationConfigured(Region.Entry<K, V> entry) { return entry != null && isExpirationConfigured(entry.getValue()); } AnnotationBasedExpiration(); AnnotationBasedExpiration(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forIdleTimeout(); static AnnotationBasedExpiration<K, V> forIdleTimeout(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forTimeToLive(); static AnnotationBasedExpiration<K, V> forTimeToLive(ExpirationAttributes defaultExpirationAttributes); @Override void setBeanFactory(BeanFactory beanFactory); void setDefaultExpirationAttributes(ExpirationAttributes defaultExpirationAttributes); @Override ExpirationAttributes getExpiry(Region.Entry<K, V> entry); @Override void close(); }### Answer: @Test public void isExpirationConfiguredWithGenericExpirationBasedRegionEntry() { Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithGenericExpiration()); assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(true)); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration()); assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(true)); verify(mockRegionEntry, times(2)).getValue(); } @Test public void isExpirationConfiguredWithNoGenericExpirationRegionEntry() { Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutExpiration()); assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(false)); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration()); assertThat(noDefaultExpiration.isExpirationConfigured(mockRegionEntry), is(false)); verify(mockRegionEntry, times(2)).getValue(); }
### Question: IndexFactoryBean extends AbstractFactoryBeanSupport<Index> implements InitializingBean { @Override public Class<?> getObjectType() { Index index = getIndex(); return index != null ? index.getClass() : Index.class; } @Override void afterPropertiesSet(); Index getIndex(); @Override Index getObject(); @Override Class<?> getObjectType(); void setCache(RegionService cache); void setName(String name); void setQueryService(QueryService service); void setDefine(boolean define); void setExpression(String expression); void setFrom(String from); void setImports(String imports); void setIgnoreIfExists(boolean ignore); boolean isIgnoreIfExists(); @SuppressWarnings("unused") void setIndexConfigurers(IndexConfigurer... indexConfigurers); void setIndexConfigurers(List<IndexConfigurer> indexConfigurers); void setOverride(boolean override); boolean isOverride(); void setType(String type); void setType(IndexType type); static final String BASIC_INDEX_DEFINITION; static final String DETAILED_INDEX_DEFINITION; }### Answer: @Test public void getObjectTypeReturnsIndexClassType() { assertThat(newIndexFactoryBean().getObjectType()).isEqualTo(Index.class); }
### Question: SubscriptionAttributesFactoryBean implements FactoryBean<SubscriptionAttributes>, InitializingBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override SubscriptionAttributes getObject(); @Override Class<?> getObjectType(); @Override boolean isSingleton(); void setInterestPolicy(InterestPolicy interestPolicy); InterestPolicy getInterestPolicy(); }### Answer: @Test public void testIsSingleton() { assertTrue(new SubscriptionAttributesFactoryBean().isSingleton()); }
### Question: EvictionAttributesFactoryBean implements FactoryBean<EvictionAttributes>, InitializingBean { public boolean isSingleton() { return true; } void afterPropertiesSet(); EvictionAttributes getObject(); Class<?> getObjectType(); boolean isSingleton(); void setAction(final EvictionAction action); EvictionAction getAction(); void setObjectSizer(final ObjectSizer objectSizer); ObjectSizer getObjectSizer(); void setThreshold(final Integer threshold); Integer getThreshold(); void setType(final EvictionPolicyType type); EvictionPolicyType getType(); }### Answer: @Test public void testIsSingleton() { assertTrue(new EvictionAttributesFactoryBean().isSingleton()); }
### Question: LookupRegionFactoryBean extends ResolvableRegionFactoryBean<K, V> { @Override public final boolean isLookupEnabled() { return true; } @Override void afterPropertiesSet(); @Override final boolean isLookupEnabled(); void setAsyncEventQueues(AsyncEventQueue[] asyncEventQueues); void setAsyncEventQueueIds(String[] asyncEventQueueIds); void setCacheListeners(CacheListener<K, V>[] cacheListeners); void setCacheLoader(CacheLoader<K, V> cacheLoader); void setCacheWriter(CacheWriter<K, V> cacheWriter); void setCloningEnabled(Boolean cloningEnabled); void setCustomEntryIdleTimeout(CustomExpiry<K, V> customEntryIdleTimeout); void setCustomEntryTimeToLive(CustomExpiry<K, V> customEntryTimeToLive); void setEntryIdleTimeout(ExpirationAttributes entryIdleTimeout); void setEntryTimeToLive(ExpirationAttributes entryTimeToLive); void setEvictionMaximum(final Integer evictionMaximum); void setGatewaySenders(GatewaySender[] gatewaySenders); void setGatewaySenderIds(String[] gatewaySenderIds); void setRegionIdleTimeout(ExpirationAttributes regionIdleTimeout); void setRegionTimeToLive(ExpirationAttributes regionTimeToLive); void setStatisticsEnabled(Boolean enableStatistics); }### Answer: @Test public void testIsLookupEnabledAlways() { LookupRegionFactoryBean factoryBean = new LookupRegionFactoryBean(); assertTrue(factoryBean.isLookupEnabled()); factoryBean.setLookupEnabled(false); assertTrue(factoryBean.isLookupEnabled()); }
### Question: WiringInstantiator extends Instantiator implements BeanFactoryAware, InitializingBean, DisposableBean { @Override public DataSerializable newInstance() { DataSerializable instance = createInstance(); configurer.configureBean(instance); return instance; } WiringInstantiator(Instantiator instantiator); WiringInstantiator(Class<? extends DataSerializable> c, int classId); void afterPropertiesSet(); void destroy(); void setBeanFactory(BeanFactory beanFactory); @Override DataSerializable newInstance(); void setConfigurer(BeanConfigurerSupport configurer); void setAutoRegister(boolean autoRegister); void setDistribute(boolean distribute); }### Answer: @Test public void testAutowiredBean() { Object instance = instantiator.newInstance(); assertNotNull(instance); assertTrue(instance instanceof AnnotatedBean); AnnotatedBean bean = (AnnotatedBean) instance; assertNotNull(bean.point); assertNotNull(bean.shape); assertSame(bean.point, applicationContext.getBean("point")); assertSame(bean.shape, applicationContext.getBean("area")); }
### Question: GemfireRepositoryConfigurationExtension extends RepositoryConfigurationExtensionSupport { @Override protected Collection<Class<? extends Annotation>> getIdentifyingAnnotations() { return Region.REGION_ANNOTATION_TYPES; } @Override String getRepositoryFactoryBeanClassName(); @Override void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource source); @Override void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfigurationSource configurationSource); @Override void postProcess(BeanDefinitionBuilder builder, XmlRepositoryConfigurationSource configurationSource); @Override void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configurationSource); }### Answer: @Test public void identifyingAnnotationsIncludesRegionAnnotation() { Collection<Class<? extends Annotation>> identifyingAnnotations = repositoryConfigurationExtension.getIdentifyingAnnotations(); assertThat(identifyingAnnotations, is(notNullValue(Collection.class))); assertThat(identifyingAnnotations.contains(Region.class), is(true)); }
### Question: GemfireRepositoryConfigurationExtension extends RepositoryConfigurationExtensionSupport { @Override protected Collection<Class<?>> getIdentifyingTypes() { return Collections.singleton(GemfireRepository.class); } @Override String getRepositoryFactoryBeanClassName(); @Override void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource source); @Override void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfigurationSource configurationSource); @Override void postProcess(BeanDefinitionBuilder builder, XmlRepositoryConfigurationSource configurationSource); @Override void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configurationSource); }### Answer: @Test public void identifyingTypesContainsGemfireRepositoryAnnotation() { Collection<Class<?>> identifyingTypes = repositoryConfigurationExtension.getIdentifyingTypes(); assertThat(identifyingTypes, is(notNullValue(Collection.class))); assertThat(identifyingTypes.contains(GemfireRepository.class), is(true)); }
### Question: AnnotationBasedExpiration implements BeanFactoryAware, CustomExpiry<K, V> { protected boolean isIdleTimeoutConfigured(Region.Entry<K, V> entry) { return entry != null && isIdleTimeoutConfigured(entry.getValue()); } AnnotationBasedExpiration(); AnnotationBasedExpiration(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forIdleTimeout(); static AnnotationBasedExpiration<K, V> forIdleTimeout(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forTimeToLive(); static AnnotationBasedExpiration<K, V> forTimeToLive(ExpirationAttributes defaultExpirationAttributes); @Override void setBeanFactory(BeanFactory beanFactory); void setDefaultExpirationAttributes(ExpirationAttributes defaultExpirationAttributes); @Override ExpirationAttributes getExpiry(Region.Entry<K, V> entry); @Override void close(); }### Answer: @Test public void isIdleTimeoutConfiguredWithIdleTimeoutExpirationBasedRegionEntry() { Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithIdleTimeoutExpiration()); assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(true)); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration()); assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(true)); verify(mockRegionEntry, times(2)).getValue(); } @Test public void isIdleTimeoutConfiguredWithNoIdleTimeoutExpirationRegionEntry() { Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveGenericExpiration()); assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(false)); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithNoExpiration()); assertThat(noDefaultExpiration.isIdleTimeoutConfigured(mockRegionEntry), is(false)); verify(mockRegionEntry, times(2)).getValue(); }
### Question: GemfireRepositoryConfigurationExtension extends RepositoryConfigurationExtensionSupport { @Override protected String getModulePrefix() { return GEMFIRE_MODULE_PREFIX; } @Override String getRepositoryFactoryBeanClassName(); @Override void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource source); @Override void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfigurationSource configurationSource); @Override void postProcess(BeanDefinitionBuilder builder, XmlRepositoryConfigurationSource configurationSource); @Override void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configurationSource); }### Answer: @Test public void modulePrefixIsGemFire() { assertThat(repositoryConfigurationExtension.getModulePrefix(), is(equalTo("gemfire"))); }
### Question: GemfireRepositoryConfigurationExtension extends RepositoryConfigurationExtensionSupport { @Override public String getRepositoryFactoryBeanClassName() { return GemfireRepositoryFactoryBean.class.getName(); } @Override String getRepositoryFactoryBeanClassName(); @Override void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource source); @Override void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfigurationSource configurationSource); @Override void postProcess(BeanDefinitionBuilder builder, XmlRepositoryConfigurationSource configurationSource); @Override void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configurationSource); }### Answer: @Test public void repositoryFactoryClassNameIsGemfireRepositoryFactoryBean() { assertThat(repositoryConfigurationExtension.getRepositoryFactoryBeanClassName(), is(equalTo(GemfireRepositoryFactoryBean.class.getName()))); }
### Question: GemfireRepositoryBean extends CdiRepositoryBean<T> { @SuppressWarnings("unchecked") protected <S> S getDependencyInstance(Bean<S> bean, Type type) { return (S) beanManager.getReference(bean, type, beanManager.createCreationalContext(bean)); } @SuppressWarnings("unchecked") GemfireRepositoryBean(BeanManager beanManager, Class<T> repositoryType, Set<Annotation> qualifiers, CustomRepositoryImplementationDetector detector, Bean<GemfireMappingContext> gemfireMappingContextBean, Set<Bean<Region>> regionBeans); }### Answer: @Test public void getDependencyInstanceGetsReference() { Bean<Region> mockRegionBean = mock(Bean.class); CreationalContext<Region> mockCreationalContext = mock(CreationalContext.class); Region mockRegion = mock(Region.class); when(mockBeanManager.createCreationalContext(eq(mockRegionBean))).thenReturn(mockCreationalContext); when(mockBeanManager.getReference(eq(mockRegionBean), eq(Region.class), eq(mockCreationalContext))) .thenReturn(mockRegion); GemfireRepositoryBean<PersonRepository> repositoryBean = new GemfireRepositoryBean<>(this.mockBeanManager, PersonRepository.class, Collections.emptySet(), newCustomRepositoryImplementationDetector(), null, null); assertThat(repositoryBean.getDependencyInstance(mockRegionBean, Region.class), is(equalTo(mockRegion))); verify(mockBeanManager, times(1)).createCreationalContext(eq(mockRegionBean)); verify(mockBeanManager, times(1)) .getReference(eq(mockRegionBean), eq(Region.class), eq(mockCreationalContext)); }
### Question: GemfireRepositoryExtension extends CdiRepositoryExtensionSupport { void afterBeanDiscovery(@Observes AfterBeanDiscovery afterBeanDiscovery, BeanManager beanManager) { for (Map.Entry<Class<?>, Set<Annotation>> entry : getRepositoryTypes()) { Class<?> repositoryType = entry.getKey(); Set<Annotation> qualifiers = entry.getValue(); CdiRepositoryBean<?> repositoryBean = createRepositoryBean(beanManager, repositoryType, qualifiers); logger.info("Registering bean for '{}' with qualifiers {}.", repositoryType.getName(), qualifiers); registerBean(repositoryBean); afterBeanDiscovery.addBean(repositoryBean); } } GemfireRepositoryExtension(); }### Answer: @Test public void afterBeanDiscoveryRegistersRepositoryBean() { AfterBeanDiscovery mockAfterBeanDiscovery = mock(AfterBeanDiscovery.class); final Set<Annotation> expectedQualifiers = asSet(mockAnnotation(SpringDataRepo.class), mockAnnotation(GemfireRepo.class)); doAnswer(new Answer<Void>() { public Void answer(final InvocationOnMock invocation) throws Throwable { GemfireRepositoryBean<?> repositoryBean = invocation.getArgument(0); assertThat(repositoryBean, is(notNullValue())); assertThat((Class<TestRepository>) repositoryBean.getBeanClass(), is(equalTo(TestRepository.class))); assertThat(repositoryBean.getQualifiers(), is(equalTo(expectedQualifiers))); return null; } }).when(mockAfterBeanDiscovery).addBean(isA(GemfireRepositoryBean.class)); GemfireRepositoryExtension repositoryExtension = new GemfireRepositoryExtension() { @Override protected Iterable<Map.Entry<Class<?>, Set<Annotation>>> getRepositoryTypes() { return Collections.<Class<?>, Set<Annotation>>singletonMap(TestRepository.class, expectedQualifiers).entrySet(); } }; repositoryExtension.afterBeanDiscovery(mockAfterBeanDiscovery, mock(BeanManager.class)); verify(mockAfterBeanDiscovery, times(1)).addBean(isA(GemfireRepositoryBean.class)); }
### Question: GemfireRepositoryFactoryBean extends RepositoryFactoryBeanSupport<T, S, ID> implements ApplicationContextAware { @Override public void afterPropertiesSet() { configureRegions(); resolveGemfireMappingContext(); super.afterPropertiesSet(); } GemfireRepositoryFactoryBean(Class<? extends T> repositoryInterface); @Override void setApplicationContext(@Nullable ApplicationContext applicationContext); void setCache(@Nullable GemFireCache cache); @Autowired(required = false) void setGemfireMappingContext(@Nullable MappingContext<? extends GemfirePersistentEntity<?>, GemfirePersistentProperty> mappingContext); @Override void afterPropertiesSet(); }### Answer: @Test public void rejectsMappingContextNotSet() { exception.expect(IllegalStateException.class); exception.expectMessage("GemfireMappingContext"); repositoryFactoryBean.afterPropertiesSet(); }
### Question: AnnotationBasedExpiration implements BeanFactoryAware, CustomExpiry<K, V> { protected boolean isTimeToLiveConfigured(Region.Entry<K, V> entry) { return entry != null && isTimeToLiveConfigured(entry.getValue()); } AnnotationBasedExpiration(); AnnotationBasedExpiration(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forIdleTimeout(); static AnnotationBasedExpiration<K, V> forIdleTimeout(ExpirationAttributes defaultExpirationAttributes); static AnnotationBasedExpiration<K, V> forTimeToLive(); static AnnotationBasedExpiration<K, V> forTimeToLive(ExpirationAttributes defaultExpirationAttributes); @Override void setBeanFactory(BeanFactory beanFactory); void setDefaultExpirationAttributes(ExpirationAttributes defaultExpirationAttributes); @Override ExpirationAttributes getExpiry(Region.Entry<K, V> entry); @Override void close(); }### Answer: @Test public void isTimeToLiveConfiguredWithTimeToLiveExpirationBasedRegionEntry() { Region.Entry mockRegionEntry = mock(Region.Entry.class, "MockRegionEntry"); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveExpiration()); assertThat(noDefaultExpiration.isTimeToLiveConfigured(mockRegionEntry), is(true)); when(mockRegionEntry.getValue()).thenReturn(new RegionEntryValueWithTimeToLiveIdleTimeoutGenericExpiration()); assertThat(noDefaultExpiration.isTimeToLiveConfigured(mockRegionEntry), is(true)); verify(mockRegionEntry, times(2)).getValue(); }
### Question: NoopSpanNameProvider implements MongoSpanNameProvider { @Override public String generateName(CommandStartedEvent event) { return event != null && event.getCommandName() != null ? event.getCommandName() : NO_OPERATION; } @Override String generateName(CommandStartedEvent event); }### Answer: @Test public void testOperationNameExists() { assertEquals("insert", provider.generateName(TEST_EVENT)); } @Test public void testNullOperationName() { assertEquals("unknown", provider.generateName(null)); }
### Question: OperationCollectionSpanNameProvider extends NoopSpanNameProvider { @Override public String generateName(CommandStartedEvent event) { if (event == null \|\| event.getCommand() == null) { return NO_OPERATION; } final BsonDocument cmd = event.getCommand(); BsonValue firstKey = cmd.get(cmd.getFirstKey()); if (firstKey.isString()) { String collectionName = firstKey.asString().getValue(); return super.generateName(event) + " " + collectionName; } else { return super.generateName(event); } } @Override String generateName(CommandStartedEvent event); }### Answer: @Test public void testOperationNameExists() { assertEquals("insert collection-name", provider.generateName(INSERT_TEST_EVENT)); } @Test public void testNullOperationName() { assertEquals("unknown", provider.generateName(null)); } @Test public void testOperationNameNotString() { assertEquals("buildInfo", provider.generateName(BUILD_INFO_TEST_EVENT)); }
### Question: PrefixSpanNameProvider implements MongoSpanNameProvider { @Override public String generateName(CommandStartedEvent event) { final String operationName = event != null && event.getCommandName() != null ? event.getCommandName() : NO_OPERATION; return ((prefix == null) ? "" : prefix) + operationName; } PrefixSpanNameProvider(String prefix); @Override String generateName(CommandStartedEvent event); }### Answer: @Test public void testOperationNameExists() { assertEquals("mongo.insert", provider.generateName(TEST_EVENT)); } @Test public void testNullOperationName() { assertEquals("mongo.unknown", provider.generateName(null)); } @Test public void testNullPrefixName() { assertEquals("insert", new PrefixSpanNameProvider(null).generateName(TEST_EVENT)); }
### Question: AnnotationScanner { public static String getName(AccessibleObject member) { if (member instanceof Field) { return ((Field)member).getName(); } else if (member instanceof Method) { Method method = (Method)member; String name = method.getName(); if (!name.startsWith("set")) { return null; } return lowerCamelCase(name.substring(3)); } throw new IllegalArgumentException(); } List<AccessibleObject> getJpaAnnotatedMembers(Class<?> c, Class<? extends Annotation> annotation); static String getName(AccessibleObject member); static Class<?> getType(AccessibleObject member); }### Answer: @Test public void getNameTest() throws NoSuchMethodException, SecurityException, NoSuchFieldException { Assert.assertEquals("em", AnnotationScanner.getName(setEmMethod)); Assert.assertEquals("em", AnnotationScanner.getName(emField)); Assert.assertEquals("emf", AnnotationScanner.getName(setEmfMethod)); Assert.assertEquals("emf", AnnotationScanner.getName(emfField)); }
### Question: AnnotationScanner { public static Class<?> getType(AccessibleObject member) { if (member instanceof Field) { return ((Field)member).getType(); } else if (member instanceof Method) { return ((Method)member).getParameterTypes()[0]; } throw new IllegalArgumentException(); } List<AccessibleObject> getJpaAnnotatedMembers(Class<?> c, Class<? extends Annotation> annotation); static String getName(AccessibleObject member); static Class<?> getType(AccessibleObject member); }### Answer: @Test public void getTypeTest() { Assert.assertEquals(EntityManager.class, AnnotationScanner.getType(setEmMethod)); Assert.assertEquals(EntityManager.class, AnnotationScanner.getType(emField)); Assert.assertEquals(EntityManagerFactory.class, AnnotationScanner.getType(setEmfMethod)); Assert.assertEquals(EntityManagerFactory.class, AnnotationScanner.getType(emfField)); }
### Question: AnnotationScanner { public List<AccessibleObject> getJpaAnnotatedMembers(Class<?> c, Class<? extends Annotation> annotation) { final List<AccessibleObject> jpaAnnotated = new ArrayList<AccessibleObject>(); for (Class<?> cl = c; cl != Object.class && cl != null; cl = cl.getSuperclass()) { parseClass(annotation, jpaAnnotated, cl); } return jpaAnnotated; } List<AccessibleObject> getJpaAnnotatedMembers(Class<?> c, Class<? extends Annotation> annotation); static String getName(AccessibleObject member); static Class<?> getType(AccessibleObject member); }### Answer: @Test public void getFactoryTest() { AnnotationScanner scanner = new AnnotationScanner(); List<AccessibleObject> members = scanner.getJpaAnnotatedMembers(TestInterface.class, PersistenceUnit.class); Assert.assertEquals(0, members.size()); }
### Question: EMFTracker extends ServiceTracker { public static EntityManager createProxy(final EmSupplier emSupplier) { ClassLoader loader = EntityManager.class.getClassLoader(); Class<?>[] ifAr = { EntityManager.class }; return (EntityManager)Proxy.newProxyInstance(loader, ifAr, new EmProxy(emSupplier)); } @SuppressWarnings("unchecked") EMFTracker(BundleContext context, Coordinator coordinator); @SuppressWarnings("unchecked") @Override Object addingService(ServiceReference reference); @Override void removedService(ServiceReference reference, Object trackedO); static EntityManager createProxy(final EmSupplier emSupplier); }### Answer: @Test(expected=PersistenceException.class) public void testOriginalExceptionThrown() { EmSupplier emSupplier = mock(EmSupplier.class); EntityManager em = mock(EntityManager.class); when(emSupplier.get()).thenReturn(em); doThrow(new PersistenceException("Message")).when(em).flush(); EntityManager emProxy = EMFTracker.createProxy(emSupplier); emProxy.flush(); }
### Question: DataSourceTracker extends ServiceTracker<DataSource, DataSource> { static Filter createFilter(BundleContext context, String dsName, String puName) { if (dsName == null) { throw new IllegalArgumentException("No DataSource supplied in persistence.xml"); } String subFilter = getSubFilter(dsName); String filter = String.format("(&(objectClass=%s)%s)", DataSource.class.getName(), subFilter); LOGGER.info("Tracking DataSource for punit " + puName + " with filter " + filter); try { return context.createFilter(filter); } catch (InvalidSyntaxException e) { throw new IllegalArgumentException(e); } } DataSourceTracker(BundleContext context, AriesEntityManagerFactoryBuilder builder, String dsName); @Override DataSource addingService(ServiceReference<DataSource> reference); @Override void removedService(ServiceReference<DataSource> reference, DataSource ds); }### Answer: @Test public void testCreateFilterFull() throws InvalidSyntaxException { BundleContext context = mock(BundleContext.class); DataSourceTracker.createFilter(context, "osgi:service/javax.sql.DataSource/(osgi.jndi.service.name=tasklist)", "test"); verify(context, atLeastOnce()).createFilter(Mockito.eq("(&(objectClass=javax.sql.DataSource)(osgi.jndi.service.name=tasklist))")); } @Test public void testCreateFilterSimple() throws InvalidSyntaxException { BundleContext context = mock(BundleContext.class); DataSourceTracker.createFilter(context, "tasklist", "test"); verify(context, atLeastOnce()).createFilter(Mockito.eq("(&(objectClass=javax.sql.DataSource)(osgi.jndi.service.name=tasklist))")); }
### Question: ManagedEMF implements ManagedService { @Override public void updated(Dictionary<String, ?> properties) throws ConfigurationException { if(properties == null) { if(configured.getAndSet(false)) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("The configuration has been deleted for persistence unit {}. Destroying the EMF", pUnitName); } builder.closeEMF(); } else { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Ignoring the unset configuration for persistence unit {}", pUnitName); } return; } } Map<String, Object> overrides = (properties != null) ? asMap(properties) : null; LOGGER.info("Configuration received for persistence unit {}", pUnitName); if (LOGGER.isDebugEnabled()) { LOGGER.debug("Using properties override {}", overrides); } builder.createEntityManagerFactory(overrides); configured.set(true); } ManagedEMF(AriesEntityManagerFactoryBuilder builder, String name); @Override void updated(Dictionary<String, ?> properties); }### Answer: @Test public void testEmfWithoutProps() throws InvalidSyntaxException, ConfigurationException { ManagedEMF emf = new ManagedEMF(builder, "test"); emf.updated(null); Mockito.verifyZeroInteractions(builder); Hashtable<String, Object> props = new Hashtable<String, Object>(); emf.updated(props); verify(builder).createEntityManagerFactory(props); emf.updated(null); verify(builder).closeEMF(); } @Test public void testEmfWithProps() throws InvalidSyntaxException, ConfigurationException { ManagedEMF emf = new ManagedEMF(builder, "test"); Dictionary<String, Object> props = new Hashtable<String, Object>(); props.put("hibernate.hbm2ddl.auto", "create-drop"); emf.updated(props); verify(builder).createEntityManagerFactory(Collections.<String, Object>singletonMap( "hibernate.hbm2ddl.auto", "create-drop")); }
### Question: DisposableCompletableObserver implements CompletableObserver, Disposable { @Override public final boolean isDisposed() { return s.get() == DisposableHelper.DISPOSED; } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }### Answer: @Test public void normal() { TestCompletable tc = new TestCompletable(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertEquals(0, tc.complete); assertTrue(tc.errors.isEmpty()); Completable.complete().subscribe(tc); assertFalse(tc.isDisposed()); assertEquals(1, tc.start); assertEquals(1, tc.complete); assertTrue(tc.errors.isEmpty()); }
### Question: DisposableCompletableObserver implements CompletableObserver, Disposable { @Override public final void dispose() { DisposableHelper.dispose(s); } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }### Answer: @Test public void dispose() { TestCompletable tc = new TestCompletable(); tc.dispose(); assertTrue(tc.isDisposed()); Disposable d = Disposables.empty(); tc.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, tc.start); }
### Question: Scheduler { @NonNull public Disposable scheduleDirect(@NonNull Runnable run) { return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS); } static long clockDriftTolerance(); @NonNull abstract Worker createWorker(); long now(@NonNull TimeUnit unit); void start(); void shutdown(); @NonNull Disposable scheduleDirect(@NonNull Runnable run); @NonNull Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit); @NonNull Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit); static final Disposable REJECTED; }### Answer: @Test public void customScheduleDirectDisposed() { CustomScheduler scheduler = new CustomScheduler(); Disposable d = scheduler.scheduleDirect(Functions.EMPTY_RUNNABLE, 1, TimeUnit.MINUTES); assertFalse(d.isDisposed()); d.dispose(); assertTrue(d.isDisposed()); } @Test public void scheduleDirect() { final int[] count = { 0 }; TestScheduler scheduler = new TestScheduler(); scheduler.scheduleDirect(new Runnable() { @Override public void run() { count[0]++; } }, 100, TimeUnit.MILLISECONDS); assertEquals(0, count[0]); scheduler.advanceTimeBy(200, TimeUnit.MILLISECONDS); assertEquals(1, count[0]); } @Test public void scheduleDirectThrows() throws Exception { List<Throwable> list = TestCommonHelper.trackPluginErrors(); try { Schedulers.io().scheduleDirect(new Runnable() { @Override public void run() { throw new TestException(); } }); Thread.sleep(250); assertEquals(1, list.size()); TestCommonHelper.assertUndeliverable(list, 0, TestException.class, null); } finally { RxJavaCommonPlugins.reset(); } }
### Question: SerializedObserver implements Observer<T>, Disposable { @Override public void dispose() { s.dispose(); } SerializedObserver(@NonNull Observer<? super T> actual); SerializedObserver(@NonNull Observer<? super T> actual, boolean delayError); @Override void onSubscribe(@NonNull Disposable s); @Override void dispose(); @Override boolean isDisposed(); @Override void onNext(@NonNull T t); @Override void onError(@NonNull Throwable t); @Override void onComplete(); }### Answer: @Test public void dispose() { TestObserver<Integer> ts = new TestObserver<Integer>(); SerializedObserver<Integer> so = new SerializedObserver<Integer>(ts); Disposable d = Disposables.empty(); so.onSubscribe(d); assertFalse(so.isDisposed()); ts.cancel(); assertTrue(so.isDisposed()); assertTrue(d.isDisposed()); }
### Question: ResourceSingleObserver implements SingleObserver<T>, Disposable { public final void add(@NonNull Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test(expected = NullPointerException.class) public void nullResource() { TestResourceSingleObserver<Integer> rso = new TestResourceSingleObserver<Integer>(); rso.add(null); }
### Question: ResourceSingleObserver implements SingleObserver<T>, Disposable { @Override public final boolean isDisposed() { return DisposableHelper.isDisposed(s.get()); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test public void normal() { TestResourceSingleObserver<Integer> rso = new TestResourceSingleObserver<Integer>(); assertFalse(rso.isDisposed()); assertEquals(0, rso.start); assertNull(rso.value); assertTrue(rso.errors.isEmpty()); Single.just(1).subscribe(rso); assertTrue(rso.isDisposed()); assertEquals(1, rso.start); assertEquals(Integer.valueOf(1), rso.value); assertTrue(rso.errors.isEmpty()); } @Test public void error() { TestResourceSingleObserver<Integer> rso = new TestResourceSingleObserver<Integer>(); assertFalse(rso.isDisposed()); assertEquals(0, rso.start); assertNull(rso.value); assertTrue(rso.errors.isEmpty()); final RuntimeException error = new RuntimeException("error"); Single.<Integer>error(error).subscribe(rso); assertTrue(rso.isDisposed()); assertEquals(1, rso.start); assertNull(rso.value); assertEquals(1, rso.errors.size()); assertTrue(rso.errors.contains(error)); }
### Question: ResourceSingleObserver implements SingleObserver<T>, Disposable { @Override public final void dispose() { if (DisposableHelper.dispose(s)) { resources.dispose(); } } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test public void dispose() { TestResourceSingleObserver<Integer> rso = new TestResourceSingleObserver<Integer>(); rso.dispose(); Disposable d = Disposables.empty(); rso.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, rso.start); }
### Question: ResourceMaybeObserver implements MaybeObserver<T>, Disposable { public final void add(@NonNull Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test(expected = NullPointerException.class) public void nullResource() { TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<Integer>(); rmo.add(null); }
### Question: ResourceMaybeObserver implements MaybeObserver<T>, Disposable { @Override public final boolean isDisposed() { return DisposableHelper.isDisposed(s.get()); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test public void normal() { TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<Integer>(); assertFalse(rmo.isDisposed()); assertEquals(0, rmo.start); assertNull(rmo.value); assertTrue(rmo.errors.isEmpty()); Maybe.just(1).subscribe(rmo); assertTrue(rmo.isDisposed()); assertEquals(1, rmo.start); assertEquals(Integer.valueOf(1), rmo.value); assertEquals(0, rmo.complete); assertTrue(rmo.errors.isEmpty()); } @Test public void empty() { TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<Integer>(); assertFalse(rmo.isDisposed()); assertEquals(0, rmo.start); assertNull(rmo.value); assertTrue(rmo.errors.isEmpty()); Maybe.<Integer>empty().subscribe(rmo); assertTrue(rmo.isDisposed()); assertEquals(1, rmo.start); assertNull(rmo.value); assertEquals(1, rmo.complete); assertTrue(rmo.errors.isEmpty()); } @Test public void error() { TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<Integer>(); assertFalse(rmo.isDisposed()); assertEquals(0, rmo.start); assertNull(rmo.value); assertTrue(rmo.errors.isEmpty()); final RuntimeException error = new RuntimeException("error"); Maybe.<Integer>error(error).subscribe(rmo); assertTrue(rmo.isDisposed()); assertEquals(1, rmo.start); assertNull(rmo.value); assertEquals(0, rmo.complete); assertEquals(1, rmo.errors.size()); assertTrue(rmo.errors.contains(error)); }
### Question: Exceptions { public static void throwIfFatal(@NonNull Throwable t) { if (t instanceof VirtualMachineError) { throw (VirtualMachineError) t; } else if (t instanceof ThreadDeath) { throw (ThreadDeath) t; } else if (t instanceof LinkageError) { throw (LinkageError) t; } } private Exceptions(); @NonNull static RuntimeException propagate(@NonNull Throwable t); static void throwIfFatal(@NonNull Throwable t); }### Answer: @Test public void manualThrowIfFatal() { try { Exceptions.throwIfFatal(new ThreadDeath()); fail("Didn't throw fatal exception"); } catch (ThreadDeath ex) { } try { Exceptions.throwIfFatal(new LinkageError()); fail("Didn't throw fatal error"); } catch (LinkageError ex) { } try { ExceptionHelper.wrapOrThrow(new LinkageError()); fail("Didn't propagate Error"); } catch (LinkageError ex) { } }
### Question: ResourceMaybeObserver implements MaybeObserver<T>, Disposable { @Override public final void dispose() { if (DisposableHelper.dispose(s)) { resources.dispose(); } } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test public void dispose() { TestResourceMaybeObserver<Integer> rmo = new TestResourceMaybeObserver<Integer>(); rmo.dispose(); Disposable d = Disposables.empty(); rmo.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, rmo.start); }
### Question: DisposableObserver implements Observer<T>, Disposable { @Override public final boolean isDisposed() { return s.get() == DisposableHelper.DISPOSED; } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }### Answer: @Test public void normal() { TestDisposableObserver<Integer> tc = new TestDisposableObserver<Integer>(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertTrue(tc.values.isEmpty()); assertTrue(tc.errors.isEmpty()); Observable.just(1).subscribe(tc); assertFalse(tc.isDisposed()); assertEquals(1, tc.start); assertEquals(1, tc.values.get(0).intValue()); assertTrue(tc.errors.isEmpty()); }
### Question: DisposableObserver implements Observer<T>, Disposable { @Override public final void dispose() { DisposableHelper.dispose(s); } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }### Answer: @Test public void dispose() { TestDisposableObserver<Integer> tc = new TestDisposableObserver<Integer>(); assertFalse(tc.isDisposed()); tc.dispose(); assertTrue(tc.isDisposed()); Disposable d = Disposables.empty(); tc.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, tc.start); }
### Question: ResourceCompletableObserver implements CompletableObserver, Disposable { public final void add(@NonNull Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test(expected = NullPointerException.class) public void nullResource() { TestResourceCompletableObserver rco = new TestResourceCompletableObserver(); rco.add(null); }
### Question: ResourceCompletableObserver implements CompletableObserver, Disposable { @Override public final boolean isDisposed() { return DisposableHelper.isDisposed(s.get()); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test public void normal() { TestResourceCompletableObserver rco = new TestResourceCompletableObserver(); assertFalse(rco.isDisposed()); assertEquals(0, rco.start); assertTrue(rco.errors.isEmpty()); Completable.complete().subscribe(rco); assertTrue(rco.isDisposed()); assertEquals(1, rco.start); assertEquals(1, rco.complete); assertTrue(rco.errors.isEmpty()); } @Test public void error() { TestResourceCompletableObserver rco = new TestResourceCompletableObserver(); assertFalse(rco.isDisposed()); assertEquals(0, rco.start); assertTrue(rco.errors.isEmpty()); final RuntimeException error = new RuntimeException("error"); Completable.error(error).subscribe(rco); assertTrue(rco.isDisposed()); assertEquals(1, rco.start); assertEquals(0, rco.complete); assertEquals(1, rco.errors.size()); assertTrue(rco.errors.contains(error)); }
### Question: ResourceCompletableObserver implements CompletableObserver, Disposable { @Override public final void dispose() { if (DisposableHelper.dispose(s)) { resources.dispose(); } } final void add(@NonNull Disposable resource); @Override final void onSubscribe(@NonNull Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test public void dispose() { TestResourceCompletableObserver rco = new TestResourceCompletableObserver(); rco.dispose(); Disposable d = Disposables.empty(); rco.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, rco.start); }
### Question: ResourceObserver implements Observer<T>, Disposable { public final void add(@NonNull Disposable resource) { ObjectHelper.requireNonNull(resource, "resource is null"); resources.add(resource); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test(expected = NullPointerException.class) public void nullResource() { TestResourceObserver<Integer> ro = new TestResourceObserver<Integer>(); ro.add(null); }
### Question: ResourceObserver implements Observer<T>, Disposable { @Override public final boolean isDisposed() { return DisposableHelper.isDisposed(s.get()); } final void add(@NonNull Disposable resource); @Override final void onSubscribe(Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test public void normal() { TestResourceObserver<Integer> tc = new TestResourceObserver<Integer>(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertTrue(tc.values.isEmpty()); assertTrue(tc.errors.isEmpty()); Observable.just(1).subscribe(tc); assertTrue(tc.isDisposed()); assertEquals(1, tc.start); assertEquals(1, tc.values.get(0).intValue()); assertTrue(tc.errors.isEmpty()); } @Test public void error() { TestResourceObserver<Integer> tc = new TestResourceObserver<Integer>(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertTrue(tc.values.isEmpty()); assertTrue(tc.errors.isEmpty()); final RuntimeException error = new RuntimeException("error"); Observable.<Integer>error(error).subscribe(tc); assertTrue(tc.isDisposed()); assertEquals(1, tc.start); assertTrue(tc.values.isEmpty()); assertEquals(1, tc.errors.size()); assertTrue(tc.errors.contains(error)); }
### Question: Exceptions { @NonNull public static RuntimeException propagate(@NonNull Throwable t) { throw ExceptionHelper.wrapOrThrow(t); } private Exceptions(); @NonNull static RuntimeException propagate(@NonNull Throwable t); static void throwIfFatal(@NonNull Throwable t); }### Answer: @Test public void manualPropagate() { try { Exceptions.propagate(new InternalError()); fail("Didn't throw exception"); } catch (InternalError ex) { } try { throw Exceptions.propagate(new IllegalArgumentException()); } catch (IllegalArgumentException ex) { } try { throw ExceptionHelper.wrapOrThrow(new IOException()); } catch (RuntimeException ex) { if (!(ex.getCause() instanceof IOException)) { fail(ex.toString() + ": should have thrown RuntimeException(IOException)"); } } }
### Question: ResourceObserver implements Observer<T>, Disposable { @Override public final void dispose() { if (DisposableHelper.dispose(s)) { resources.dispose(); } } final void add(@NonNull Disposable resource); @Override final void onSubscribe(Disposable s); @Override final void dispose(); @Override final boolean isDisposed(); }### Answer: @Test public void dispose() { TestResourceObserver<Integer> tc = new TestResourceObserver<Integer>(); tc.dispose(); Disposable d = Disposables.empty(); tc.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, tc.start); }
### Question: SafeObserver implements Observer<T>, Disposable { @Override public void dispose() { s.dispose(); } SafeObserver(@NonNull Observer<? super T> actual); @Override void onSubscribe(@NonNull Disposable s); @Override void dispose(); @Override boolean isDisposed(); @Override void onNext(@NonNull T t); @Override void onError(@NonNull Throwable t); @Override void onComplete(); }### Answer: @Test public void dispose() { TestObserver<Integer> ts = new TestObserver<Integer>(); SafeObserver<Integer> so = new SafeObserver<Integer>(ts); Disposable d = Disposables.empty(); so.onSubscribe(d); ts.dispose(); assertTrue(d.isDisposed()); assertTrue(so.isDisposed()); }
### Question: CompositeException extends RuntimeException { @Override @NonNull public String getMessage() { return message; } CompositeException(@NonNull Throwable... exceptions); CompositeException(@NonNull Iterable<? extends Throwable> errors); @NonNull List<Throwable> getExceptions(); @Override @NonNull String getMessage(); @Override @NonNull synchronized Throwable getCause(); @Override void printStackTrace(); @Override void printStackTrace(PrintStream s); @Override void printStackTrace(PrintWriter s); int size(); }### Answer: @Test public void testEmptyErrors() { try { new CompositeException(); fail("CompositeException should fail if errors is empty"); } catch (IllegalArgumentException e) { assertEquals("errors is empty", e.getMessage()); } try { new CompositeException(new ArrayList<Throwable>()); fail("CompositeException should fail if errors is empty"); } catch (IllegalArgumentException e) { assertEquals("errors is empty", e.getMessage()); } } @Test public void messageCollection() { CompositeException compositeException = new CompositeException(ex1, ex3); assertEquals("2 exceptions occurred. ", compositeException.getMessage()); } @Test public void messageVarargs() { CompositeException compositeException = new CompositeException(ex1, ex2, ex3); assertEquals("3 exceptions occurred. ", compositeException.getMessage()); }
### Question: DisposableSingleObserver implements SingleObserver<T>, Disposable { @Override public final boolean isDisposed() { return s.get() == DisposableHelper.DISPOSED; } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }### Answer: @Test public void normal() { TestSingle<Integer> tc = new TestSingle<Integer>(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertTrue(tc.values.isEmpty()); assertTrue(tc.errors.isEmpty()); Single.just(1).subscribe(tc); assertFalse(tc.isDisposed()); assertEquals(1, tc.start); assertEquals(1, tc.values.get(0).intValue()); assertTrue(tc.errors.isEmpty()); }
### Question: DisposableSingleObserver implements SingleObserver<T>, Disposable { @Override public final void dispose() { DisposableHelper.dispose(s); } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }### Answer: @Test public void dispose() { TestSingle<Integer> tc = new TestSingle<Integer>(); tc.dispose(); assertTrue(tc.isDisposed()); Disposable d = Disposables.empty(); tc.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, tc.start); }
### Question: DisposableMaybeObserver implements MaybeObserver<T>, Disposable { @Override public final boolean isDisposed() { return s.get() == DisposableHelper.DISPOSED; } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }### Answer: @Test public void normal() { TestMaybe<Integer> tc = new TestMaybe<Integer>(); assertFalse(tc.isDisposed()); assertEquals(0, tc.start); assertTrue(tc.values.isEmpty()); assertTrue(tc.errors.isEmpty()); assertEquals(0, tc.complete); Maybe.just(1).subscribe(tc); assertFalse(tc.isDisposed()); assertEquals(1, tc.start); assertEquals(1, tc.values.get(0).intValue()); assertTrue(tc.errors.isEmpty()); assertEquals(0, tc.complete); }
### Question: DisposableMaybeObserver implements MaybeObserver<T>, Disposable { @Override public final void dispose() { DisposableHelper.dispose(s); } @Override final void onSubscribe(@NonNull Disposable s); @Override final boolean isDisposed(); @Override final void dispose(); }### Answer: @Test public void dispose() { TestMaybe<Integer> tc = new TestMaybe<Integer>(); tc.dispose(); assertTrue(tc.isDisposed()); Disposable d = Disposables.empty(); tc.onSubscribe(d); assertTrue(d.isDisposed()); assertEquals(0, tc.start); }
### Question: CompositeException extends RuntimeException { @NonNull public List<Throwable> getExceptions() { return exceptions; } CompositeException(@NonNull Throwable... exceptions); CompositeException(@NonNull Iterable<? extends Throwable> errors); @NonNull List<Throwable> getExceptions(); @Override @NonNull String getMessage(); @Override @NonNull synchronized Throwable getCause(); @Override void printStackTrace(); @Override void printStackTrace(PrintStream s); @Override void printStackTrace(PrintWriter s); int size(); }### Answer: @Test public void constructorWithNull() { assertTrue(new CompositeException((Throwable[])null).getExceptions().get(0) instanceof NullPointerException); assertTrue(new CompositeException((Iterable<Throwable>)null).getExceptions().get(0) instanceof NullPointerException); assertTrue(new CompositeException(null, new TestException()).getExceptions().get(0) instanceof NullPointerException); }
### Question: CompositeException extends RuntimeException { @Override public void printStackTrace() { printStackTrace(System.err); } CompositeException(@NonNull Throwable... exceptions); CompositeException(@NonNull Iterable<? extends Throwable> errors); @NonNull List<Throwable> getExceptions(); @Override @NonNull String getMessage(); @Override @NonNull synchronized Throwable getCause(); @Override void printStackTrace(); @Override void printStackTrace(PrintStream s); @Override void printStackTrace(PrintWriter s); int size(); }### Answer: @Test public void printStackTrace() { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); new CompositeException(new TestException()).printStackTrace(pw); assertTrue(sw.toString().contains("TestException")); }
### Question: BehaviorSubject extends Subject<T> { @Override public void onSubscribe(Disposable s) { if (terminalEvent.get() != null) { s.dispose(); } } @SuppressWarnings("unchecked") BehaviorSubject(); BehaviorSubject(T defaultValue); @CheckReturnValue static BehaviorSubject<T> create(); @CheckReturnValue static BehaviorSubject<T> createDefault(T defaultValue); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasObservers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); @SuppressWarnings("unchecked") T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void onSubscribe() { BehaviorSubject<Object> p = BehaviorSubject.create(); Disposable bs = Disposables.empty(); p.onSubscribe(bs); assertFalse(bs.isDisposed()); p.onComplete(); bs = Disposables.empty(); p.onSubscribe(bs); assertTrue(bs.isDisposed()); }
### Question: BehaviorSubject extends Subject<T> { @CheckReturnValue public static <T> BehaviorSubject<T> create() { return new BehaviorSubject<T>(); } @SuppressWarnings("unchecked") BehaviorSubject(); BehaviorSubject(T defaultValue); @CheckReturnValue static BehaviorSubject<T> create(); @CheckReturnValue static BehaviorSubject<T> createDefault(T defaultValue); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasObservers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); @SuppressWarnings("unchecked") T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void addRemoveRace() { for (int i = 0; i < 500; i++) { final BehaviorSubject<Object> p = BehaviorSubject.create(); final TestObserver<Object> ts = p.test(); Runnable r1 = new Runnable() { @Override public void run() { p.test(); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); } } @Test public void innerDisposed() { BehaviorSubject.create() .subscribe(new Observer<Object>() { @Override public void onSubscribe(Disposable d) { assertFalse(d.isDisposed()); d.dispose(); assertTrue(d.isDisposed()); } @Override public void onNext(Object value) { } @Override public void onError(Throwable e) { } @Override public void onComplete() { } }); }
### Question: AsyncSubject extends Subject<T> { @CheckReturnValue public static <T> AsyncSubject<T> create() { return new AsyncSubject<T>(); } @SuppressWarnings("unchecked") AsyncSubject(); @CheckReturnValue static AsyncSubject<T> create(); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @SuppressWarnings("unchecked") @Override void onError(Throwable t); @SuppressWarnings("unchecked") @Override void onComplete(); @Override boolean hasObservers(); @Override boolean hasThrowable(); @Override boolean hasComplete(); @Override Throwable getThrowable(); boolean hasValue(); T getValue(); Object[] getValues(); T[] getValues(T[] array); }### Answer: @Test public void cancelRace() { AsyncSubject<Object> p = AsyncSubject.create(); for (int i = 0; i < 500; i++) { final TestObserver<Object> ts1 = p.test(); final TestObserver<Object> ts2 = p.test(); Runnable r1 = new Runnable() { @Override public void run() { ts1.cancel(); } }; Runnable r2 = new Runnable() { @Override public void run() { ts2.cancel(); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); } }
### Question: CompletableSubject extends Completable implements CompletableObserver { @CheckReturnValue public static CompletableSubject create() { return new CompletableSubject(); } CompletableSubject(); @CheckReturnValue static CompletableSubject create(); @Override void onSubscribe(Disposable d); @Override void onError(Throwable e); @Override void onComplete(); Throwable getThrowable(); boolean hasThrowable(); boolean hasComplete(); boolean hasObservers(); }### Answer: @Test public void cancelOnArrival() { CompletableSubject.create() .test(true) .assertEmpty(); } @Test public void cancelOnArrival2() { CompletableSubject cs = CompletableSubject.create(); cs.test(); cs .test(true) .assertEmpty(); } @Test public void dispose() { TestHelper.checkDisposed(CompletableSubject.create()); } @Test public void disposeTwice() { CompletableSubject.create() .subscribe(new CompletableObserver() { @Override public void onSubscribe(Disposable d) { assertFalse(d.isDisposed()); d.dispose(); d.dispose(); assertTrue(d.isDisposed()); } @Override public void onError(Throwable e) { } @Override public void onComplete() { } }); } @Test public void addRemoveRace() { for (int i = 0; i < 500; i++) { final CompletableSubject cs = CompletableSubject.create(); final TestObserver<Void> to = cs.test(); Runnable r1 = new Runnable() { @Override public void run() { cs.test(); } }; Runnable r2 = new Runnable() { @Override public void run() { to.cancel(); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); } }
### Question: SingleSubject extends Single<T> implements SingleObserver<T> { @CheckReturnValue @NonNull public static <T> SingleSubject<T> create() { return new SingleSubject<T>(); } @SuppressWarnings("unchecked") SingleSubject(); @CheckReturnValue @NonNull static SingleSubject<T> create(); @Override void onSubscribe(@NonNull Disposable d); @SuppressWarnings("unchecked") @Override void onSuccess(@NonNull T value); @SuppressWarnings("unchecked") @Override void onError(@NonNull Throwable e); @Nullable T getValue(); boolean hasValue(); @Nullable Throwable getThrowable(); boolean hasThrowable(); boolean hasObservers(); }### Answer: @Test public void cancelOnArrival() { SingleSubject.create() .test(true) .assertEmpty(); } @Test public void cancelOnArrival2() { SingleSubject<Integer> ss = SingleSubject.create(); ss.test(); ss .test(true) .assertEmpty(); } @Test public void dispose() { TestHelper.checkDisposed(SingleSubject.create()); } @Test public void disposeTwice() { SingleSubject.create() .subscribe(new SingleObserver<Object>() { @Override public void onSubscribe(Disposable d) { assertFalse(d.isDisposed()); d.dispose(); d.dispose(); assertTrue(d.isDisposed()); } @Override public void onSuccess(Object value) { } @Override public void onError(Throwable e) { } }); } @Test public void addRemoveRace() { for (int i = 0; i < 500; i++) { final SingleSubject<Integer> ss = SingleSubject.create(); final TestObserver<Integer> to = ss.test(); Runnable r1 = new Runnable() { @Override public void run() { ss.test(); } }; Runnable r2 = new Runnable() { @Override public void run() { to.cancel(); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); } }
### Question: ReplaySubject extends Subject<T> { public Object[] getValues() { @SuppressWarnings("unchecked") T[] a = (T[])EMPTY_ARRAY; T[] b = getValues(a); if (b == EMPTY_ARRAY) { return new Object[0]; } return b; } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckReturnValue static ReplaySubject<T> create(int capacityHint); @CheckReturnValue static ReplaySubject<T> createWithSize(int maxSize); @CheckReturnValue static ReplaySubject<T> createWithTime(long maxAge, TimeUnit unit, Scheduler scheduler); @CheckReturnValue static ReplaySubject<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasObservers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void testGetValues() { ReplaySubject<Object> rs = ReplaySubject.create(); Object[] expected = new Object[10]; for (int i = 0; i < expected.length; i++) { expected[i] = i; rs.onNext(i); assertArrayEquals(Arrays.copyOf(expected, i + 1), rs.getValues()); } rs.onComplete(); assertArrayEquals(expected, rs.getValues()); }
### Question: ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> createWithSize(int maxSize) { return new ReplaySubject<T>(new SizeBoundReplayBuffer<T>(maxSize)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckReturnValue static ReplaySubject<T> create(int capacityHint); @CheckReturnValue static ReplaySubject<T> createWithSize(int maxSize); @CheckReturnValue static ReplaySubject<T> createWithTime(long maxAge, TimeUnit unit, Scheduler scheduler); @CheckReturnValue static ReplaySubject<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasObservers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void createWithSizeInvalidCapacity() { try { ReplaySubject.createWithSize(-99); fail("Didn't throw IllegalArgumentException"); } catch (IllegalArgumentException ex) { assertEquals("maxSize > 0 required but it was -99", ex.getMessage()); } }
### Question: ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize) { return new ReplaySubject<T>(new SizeAndTimeBoundReplayBuffer<T>(maxSize, maxAge, unit, scheduler)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckReturnValue static ReplaySubject<T> create(int capacityHint); @CheckReturnValue static ReplaySubject<T> createWithSize(int maxSize); @CheckReturnValue static ReplaySubject<T> createWithTime(long maxAge, TimeUnit unit, Scheduler scheduler); @CheckReturnValue static ReplaySubject<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasObservers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void createWithTimeAndSizeInvalidCapacity() { try { ReplaySubject.createWithTimeAndSize(1, TimeUnit.DAYS, Schedulers.computation(), -99); fail("Didn't throw IllegalArgumentException"); } catch (IllegalArgumentException ex) { assertEquals("maxSize > 0 required but it was -99", ex.getMessage()); } }
### Question: ReplaySubject extends Subject<T> { @Override public boolean hasObservers() { return observers.get().length != 0; } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckReturnValue static ReplaySubject<T> create(int capacityHint); @CheckReturnValue static ReplaySubject<T> createWithSize(int maxSize); @CheckReturnValue static ReplaySubject<T> createWithTime(long maxAge, TimeUnit unit, Scheduler scheduler); @CheckReturnValue static ReplaySubject<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasObservers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void hasObservers() { ReplaySubject<Integer> rp = ReplaySubject.create(); assertFalse(rp.hasObservers()); TestObserver<Integer> ts = rp.test(); assertTrue(rp.hasObservers()); ts.cancel(); assertFalse(rp.hasObservers()); }
### Question: ReplaySubject extends Subject<T> { @CheckReturnValue public static <T> ReplaySubject<T> create() { return new ReplaySubject<T>(new UnboundedReplayBuffer<T>(16)); } @SuppressWarnings("unchecked") ReplaySubject(ReplayBuffer<T> buffer); @CheckReturnValue static ReplaySubject<T> create(); @CheckReturnValue static ReplaySubject<T> create(int capacityHint); @CheckReturnValue static ReplaySubject<T> createWithSize(int maxSize); @CheckReturnValue static ReplaySubject<T> createWithTime(long maxAge, TimeUnit unit, Scheduler scheduler); @CheckReturnValue static ReplaySubject<T> createWithTimeAndSize(long maxAge, TimeUnit unit, Scheduler scheduler, int maxSize); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override boolean hasObservers(); @Override Throwable getThrowable(); T getValue(); Object[] getValues(); T[] getValues(T[] array); @Override boolean hasComplete(); @Override boolean hasThrowable(); boolean hasValue(); }### Answer: @Test public void subscribeCancelRace() { for (int i = 0; i < 500; i++) { final TestObserver<Integer> ts = new TestObserver<Integer>(); final ReplaySubject<Integer> rp = ReplaySubject.create(); Runnable r1 = new Runnable() { @Override public void run() { rp.subscribe(ts); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); } } @Test public void subscribeRace() { for (int i = 0; i < 500; i++) { final ReplaySubject<Integer> rp = ReplaySubject.create(); Runnable r1 = new Runnable() { @Override public void run() { rp.test(); } }; TestCommonHelper.race(r1, r1, Schedulers.single()); } }
### Question: PublishSubject extends Subject<T> { @CheckReturnValue public static <T> PublishSubject<T> create() { return new PublishSubject<T>(); } @SuppressWarnings("unchecked") PublishSubject(); @CheckReturnValue static PublishSubject<T> create(); @Override void subscribeActual(Observer<? super T> t); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @SuppressWarnings("unchecked") @Override void onError(Throwable t); @SuppressWarnings("unchecked") @Override void onComplete(); @Override boolean hasObservers(); @Override Throwable getThrowable(); @Override boolean hasThrowable(); @Override boolean hasComplete(); }### Answer: @Test public void addRemoveRance() throws Exception { for (int i = 0; i < 100; i++) { final PublishSubject<Integer> pp = PublishSubject.create(); final TestObserver<Integer> ts = pp.test(); Runnable r1 = new Runnable() { @Override public void run() { pp.subscribe(); } }; Runnable r2 = new Runnable() { @Override public void run() { ts.cancel(); } }; TestCommonHelper.race(r1, r2, Schedulers.io()); } }
### Question: MaybeSubject extends Maybe<T> implements MaybeObserver<T> { @CheckReturnValue public static <T> MaybeSubject<T> create() { return new MaybeSubject<T>(); } @SuppressWarnings("unchecked") MaybeSubject(); @CheckReturnValue static MaybeSubject<T> create(); @Override void onSubscribe(Disposable d); @SuppressWarnings("unchecked") @Override void onSuccess(T value); @SuppressWarnings("unchecked") @Override void onError(Throwable e); @SuppressWarnings("unchecked") @Override void onComplete(); T getValue(); boolean hasValue(); Throwable getThrowable(); boolean hasThrowable(); boolean hasComplete(); boolean hasObservers(); }### Answer: @Test public void cancelOnArrival() { MaybeSubject.create() .test(true) .assertEmpty(); } @Test public void cancelOnArrival2() { MaybeSubject<Integer> ms = MaybeSubject.create(); ms.test(); ms .test(true) .assertEmpty(); } @Test public void dispose() { TestHelper.checkDisposed(MaybeSubject.create()); } @Test public void disposeTwice() { MaybeSubject.create() .subscribe(new MaybeObserver<Object>() { @Override public void onSubscribe(Disposable d) { assertFalse(d.isDisposed()); d.dispose(); d.dispose(); assertTrue(d.isDisposed()); } @Override public void onSuccess(Object value) { } @Override public void onError(Throwable e) { } @Override public void onComplete() { } }); } @Test public void addRemoveRace() { for (int i = 0; i < 500; i++) { final MaybeSubject<Integer> ms = MaybeSubject.create(); final TestObserver<Integer> to = ms.test(); Runnable r1 = new Runnable() { @Override public void run() { ms.test(); } }; Runnable r2 = new Runnable() { @Override public void run() { to.cancel(); } }; TestCommonHelper.race(r1, r2, Schedulers.single()); } }
### Question: Timed { @Override public int hashCode() { int h = value != null ? value.hashCode() : 0; h = h * 31 + (int)((time >>> 31) ^ time); h = h * 31 + unit.hashCode(); return h; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); @NonNull T value(); @NonNull TimeUnit unit(); long time(); long time(@NonNull TimeUnit unit); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void hashCodeOf() { Timed<Integer> t1 = new Timed<Integer>(1, 5, TimeUnit.SECONDS); assertEquals(TimeUnit.SECONDS.hashCode() + 31 * (5 + 31 * 1), t1.hashCode()); Timed<Integer> t2 = new Timed<Integer>(null, 5, TimeUnit.SECONDS); assertEquals(TimeUnit.SECONDS.hashCode() + 31 * (5 + 31 * 0), t2.hashCode()); }
### Question: Timed { @Override public boolean equals(Object other) { if (other instanceof Timed) { Timed<?> o = (Timed<?>) other; return ObjectHelper.equals(value, o.value) && time == o.time && ObjectHelper.equals(unit, o.unit); } return false; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); @NonNull T value(); @NonNull TimeUnit unit(); long time(); long time(@NonNull TimeUnit unit); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void equalsWith() { Timed<Integer> t1 = new Timed<Integer>(1, 5, TimeUnit.SECONDS); Timed<Integer> t2 = new Timed<Integer>(1, 5, TimeUnit.SECONDS); Timed<Integer> t3 = new Timed<Integer>(2, 5, TimeUnit.SECONDS); Timed<Integer> t4 = new Timed<Integer>(1, 4, TimeUnit.SECONDS); Timed<Integer> t5 = new Timed<Integer>(1, 5, TimeUnit.MINUTES); assertEquals(t1, t1); assertEquals(t1, t2); assertNotEquals(t1, t3); assertNotEquals(t1, t4); assertNotEquals(t2, t3); assertNotEquals(t2, t4); assertNotEquals(t2, t5); assertNotEquals(t3, t1); assertNotEquals(t3, t2); assertNotEquals(t3, t4); assertNotEquals(t3, t5); assertNotEquals(t4, t1); assertNotEquals(t4, t2); assertNotEquals(t4, t3); assertNotEquals(t4, t5); assertNotEquals(t5, t1); assertNotEquals(t5, t2); assertNotEquals(t5, t3); assertNotEquals(t5, t4); assertNotEquals(new Object(), t1); assertFalse(t1.equals(new Object())); }
### Question: Timed { @Override public String toString() { return "Timed[time=" + time + ", unit=" + unit + ", value=" + value + "]"; } Timed(@NonNull T value, long time, @NonNull TimeUnit unit); @NonNull T value(); @NonNull TimeUnit unit(); long time(); long time(@NonNull TimeUnit unit); @Override boolean equals(Object other); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void toStringOf() { Timed<Integer> t1 = new Timed<Integer>(1, 5, TimeUnit.SECONDS); assertEquals("Timed[time=5, unit=SECONDS, value=1]", t1.toString()); }
### Question: CompositeDisposable implements Disposable, DisposableContainer { public void clear() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } set = resources; resources = null; } dispose(set); } CompositeDisposable(); CompositeDisposable(@NonNull Disposable... resources); CompositeDisposable(@NonNull Iterable<? extends Disposable> resources); @Override void dispose(); @Override boolean isDisposed(); @Override boolean add(@NonNull Disposable d); boolean addAll(@NonNull Disposable... ds); @Override boolean remove(@NonNull Disposable d); @Override boolean delete(@NonNull Disposable d); void clear(); int size(); }### Answer: @Test public void testClear() { Disposable s1 = Disposables.empty(); Disposable s2 = Disposables.empty(); CompositeDisposable s = new CompositeDisposable(); s.add(s1); s.add(s2); assertFalse(s1.isDisposed()); assertFalse(s2.isDisposed()); s.clear(); assertTrue(s1.isDisposed()); assertTrue(s2.isDisposed()); assertFalse(s.isDisposed()); Disposable s3 = Disposables.empty(); s.add(s3); s.dispose(); assertTrue(s3.isDisposed()); assertTrue(s.isDisposed()); }
### Question: CompositeDisposable implements Disposable, DisposableContainer { @Override public boolean add(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "d is null"); if (!disposed) { synchronized (this) { if (!disposed) { OpenHashSet<Disposable> set = resources; if (set == null) { set = new OpenHashSet<Disposable>(); resources = set; } set.add(d); return true; } } } d.dispose(); return false; } CompositeDisposable(); CompositeDisposable(@NonNull Disposable... resources); CompositeDisposable(@NonNull Iterable<? extends Disposable> resources); @Override void dispose(); @Override boolean isDisposed(); @Override boolean add(@NonNull Disposable d); boolean addAll(@NonNull Disposable... ds); @Override boolean remove(@NonNull Disposable d); @Override boolean delete(@NonNull Disposable d); void clear(); int size(); }### Answer: @Test(expected = NullPointerException.class) public void testAddingNullDisposableIllegal() { CompositeDisposable csub = new CompositeDisposable(); csub.add(null); } @Test public void addRace() { for (int i = 0; i < 500; i++) { final CompositeDisposable cd = new CompositeDisposable(); Runnable run = new Runnable() { @Override public void run() { cd.add(Disposables.empty()); } }; TestCommonHelper.race(run, run, Schedulers.io()); } }
### Question: FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public boolean cancel(boolean mayInterruptIfRunning) { for (;;) { Disposable a = s.get(); if (a == this \|\| a == DisposableHelper.DISPOSED) { return false; } if (s.compareAndSet(a, DisposableHelper.DISPOSED)) { if (a != null) { a.dispose(); } countDown(); return true; } } } FutureObserver(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long timeout, TimeUnit unit); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void cancel() throws Exception { assertFalse(fo.isDone()); assertFalse(fo.isCancelled()); fo.cancel(false); assertTrue(fo.isDone()); assertTrue(fo.isCancelled()); try { fo.get(); fail("Should have thrown"); } catch (CancellationException ex) { } try { fo.get(1, TimeUnit.MILLISECONDS); fail("Should have thrown"); } catch (CancellationException ex) { } } @Test public void cancelRace() { for (int i = 0; i < 500; i++) { final FutureObserver<Integer> fo = new FutureObserver<Integer>(); Runnable r = new Runnable() { @Override public void run() { fo.cancel(false); } }; TestCommonHelper.race(r, r, Schedulers.single()); } }
### Question: FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onError(Throwable t) { if (error == null) { error = t; for (;;) { Disposable a = s.get(); if (a == this \|\| a == DisposableHelper.DISPOSED) { RxJavaCommonPlugins.onError(t); return; } if (s.compareAndSet(a, this)) { countDown(); return; } } } else { RxJavaCommonPlugins.onError(t); } } FutureObserver(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long timeout, TimeUnit unit); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void onError() throws Exception { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { fo.onError(new TestException("One")); fo.onError(new TestException("Two")); try { fo.get(5, TimeUnit.MILLISECONDS); } catch (ExecutionException ex) { assertTrue(ex.toString(), ex.getCause() instanceof TestException); assertEquals("One", ex.getCause().getMessage()); } TestCommonHelper.assertUndeliverable(errors, 0, TestException.class, "Two"); } finally { RxJavaCommonPlugins.reset(); } }
### Question: FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onNext(T t) { if (value != null) { s.get().dispose(); onError(new IndexOutOfBoundsException("More than one element received")); return; } value = t; } FutureObserver(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long timeout, TimeUnit unit); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void onNext() throws Exception { fo.onNext(1); fo.onComplete(); assertEquals(1, fo.get(5, TimeUnit.MILLISECONDS).intValue()); }
### Question: FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public void onSubscribe(Disposable s) { DisposableHelper.setOnce(this.s, s); } FutureObserver(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long timeout, TimeUnit unit); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void onSubscribe() throws Exception { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { Disposable s = Disposables.empty(); fo.onSubscribe(s); Disposable s2 = Disposables.empty(); fo.onSubscribe(s2); assertFalse(s.isDisposed()); assertTrue(s2.isDisposed()); TestCommonHelper.assertError(errors, 0, IllegalStateException.class, "Disposable already set!"); } finally { RxJavaCommonPlugins.reset(); } }
### Question: FutureObserver extends CountDownLatch implements Observer<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = error; if (ex != null) { throw new ExecutionException(ex); } return value; } FutureObserver(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long timeout, TimeUnit unit); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test(expected = InterruptedException.class) public void getInterrupted() throws Exception { Thread.currentThread().interrupt(); fo.get(); }
### Question: FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public T get() throws InterruptedException, ExecutionException { if (getCount() != 0) { BlockingHelper.verifyNonBlocking(); await(); } if (isCancelled()) { throw new CancellationException(); } Throwable ex = error; if (ex != null) { throw new ExecutionException(ex); } return value; } FutureSingleObserver(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long timeout, TimeUnit unit); @Override void onSubscribe(Disposable s); @Override void onSuccess(T t); @Override void onError(Throwable t); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void timeout() throws Exception { Future<?> f = Single.never().toFuture(); try { f.get(100, TimeUnit.MILLISECONDS); fail("Should have thrown"); } catch (TimeoutException ex) { } } @Test public void errorGetWithTimeout() throws Exception { Future<?> f = Single.error(new TestException()).toFuture(); try { f.get(5, TimeUnit.SECONDS); fail("Should have thrown"); } catch (ExecutionException ex) { assertTrue(ex.toString(), ex.getCause() instanceof TestException); } } @Test public void normalGetWitHTimeout() throws Exception { Future<Integer> f = Single.just(1).toFuture(); assertEquals(1, f.get(5, TimeUnit.SECONDS).intValue()); } @Test public void getAwait() throws Exception { Future<Integer> f = Single.just(1).delay(100, TimeUnit.MILLISECONDS).toFuture(); assertEquals(1, f.get(5, TimeUnit.SECONDS).intValue()); }
### Question: FutureSingleObserver extends CountDownLatch implements SingleObserver<T>, Future<T>, Disposable { @Override public void dispose() { } FutureSingleObserver(); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long timeout, TimeUnit unit); @Override void onSubscribe(Disposable s); @Override void onSuccess(T t); @Override void onError(Throwable t); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void dispose() { Future<Integer> f = Single.just(1).toFuture(); ((Disposable)f).dispose(); assertTrue(((Disposable)f).isDisposed()); }
### Question: BasicFuseableObserver implements Observer<T>, QueueDisposable<R> { @Override public final boolean offer(R e) { throw new UnsupportedOperationException("Should not be called!"); } BasicFuseableObserver(Observer<? super R> actual); @SuppressWarnings("unchecked") @Override final void onSubscribe(Disposable s); @Override void onError(Throwable t); @Override void onComplete(); @Override void dispose(); @Override boolean isDisposed(); @Override boolean isEmpty(); @Override void clear(); @Override final boolean offer(R e); @Override final boolean offer(R v1, R v2); }### Answer: @Test(expected = UnsupportedOperationException.class) public void offer() { TestObserver<Integer> to = new TestObserver<Integer>(); BasicFuseableObserver<Integer, Integer> o = new BasicFuseableObserver<Integer, Integer>(to) { @Nullable @Override public Integer poll() throws Exception { return null; } @Override public int requestFusion(int mode) { return 0; } @Override public void onNext(Integer value) { } @Override protected boolean beforeDownstream() { return false; } }; o.onSubscribe(Disposables.disposed()); to.assertNotSubscribed(); o.offer(1); } @Test(expected = UnsupportedOperationException.class) public void offer2() { BasicFuseableObserver<Integer, Integer> o = new BasicFuseableObserver<Integer, Integer>(new TestObserver<Integer>()) { @Nullable @Override public Integer poll() throws Exception { return null; } @Override public int requestFusion(int mode) { return 0; } @Override public void onNext(Integer value) { } }; o.offer(1, 2); }
### Question: DeferredScalarObserver extends DeferredScalarDisposable<R> implements Observer<T> { @Override public void onSubscribe(Disposable s) { if (DisposableHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); } } DeferredScalarObserver(Observer<? super R> actual); @Override void onSubscribe(Disposable s); @Override void onError(Throwable t); @Override void onComplete(); @Override void dispose(); }### Answer: @Test public void normal() { TestObserver<Integer> to = new TestObserver<Integer>(); TakeFirst source = new TakeFirst(to); source.onSubscribe(Disposables.empty()); Disposable d = Disposables.empty(); source.onSubscribe(d); assertTrue(d.isDisposed()); source.onNext(1); to.assertResult(1); }
### Question: CompositeDisposable implements Disposable, DisposableContainer { @Override public boolean delete(@NonNull Disposable d) { ObjectHelper.requireNonNull(d, "Disposable item is null"); if (disposed) { return false; } synchronized (this) { if (disposed) { return false; } OpenHashSet<Disposable> set = resources; if (set == null \|\| !set.remove(d)) { return false; } } return true; } CompositeDisposable(); CompositeDisposable(@NonNull Disposable... resources); CompositeDisposable(@NonNull Iterable<? extends Disposable> resources); @Override void dispose(); @Override boolean isDisposed(); @Override boolean add(@NonNull Disposable d); boolean addAll(@NonNull Disposable... ds); @Override boolean remove(@NonNull Disposable d); @Override boolean delete(@NonNull Disposable d); void clear(); int size(); }### Answer: @Test public void delete() { CompositeDisposable cd = new CompositeDisposable(); Disposable d1 = Disposables.empty(); assertFalse(cd.delete(d1)); Disposable d2 = Disposables.empty(); cd.add(d2); assertFalse(cd.delete(d1)); cd.dispose(); assertFalse(cd.delete(d1)); }
### Question: DeferredScalarObserver extends DeferredScalarDisposable<R> implements Observer<T> { @Override public void dispose() { super.dispose(); s.dispose(); } DeferredScalarObserver(Observer<? super R> actual); @Override void onSubscribe(Disposable s); @Override void onError(Throwable t); @Override void onComplete(); @Override void dispose(); }### Answer: @Test public void dispose() { TestObserver<Integer> to = new TestObserver<Integer>(); TakeFirst source = new TakeFirst(to); Disposable d = Disposables.empty(); source.onSubscribe(d); assertFalse(d.isDisposed()); to.cancel(); assertTrue(d.isDisposed()); assertTrue(source.isDisposed()); }
### Question: BasicQueueDisposable implements QueueDisposable<T> { @Override public final boolean offer(T e) { throw new UnsupportedOperationException("Should not be called"); } @Override final boolean offer(T e); @Override final boolean offer(T v1, T v2); }### Answer: @Test(expected = UnsupportedOperationException.class) public void offer() { q.offer(1); } @Test(expected = UnsupportedOperationException.class) public void offer2() { q.offer(1, 2); }
### Question: LambdaObserver extends AtomicReference<Disposable> implements Observer<T>, Disposable { @Override public void onNext(T t) { if (!isDisposed()) { try { onNext.accept(t); } catch (Throwable e) { Exceptions.throwIfFatal(e); get().dispose(); onError(e); } } } LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe); @Override void onSubscribe(Disposable s); @Override void onNext(T t); @Override void onError(Throwable t); @Override void onComplete(); @Override void dispose(); @Override boolean isDisposed(); }### Answer: @Test public void onNextThrowsCancelsUpstream() { PublishSubject<Integer> ps = PublishSubject.create(); final List<Throwable> errors = new ArrayList<Throwable>(); ps.subscribe(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { throw new TestException(); } }, new Consumer<Throwable>() { @Override public void accept(Throwable e) throws Exception { errors.add(e); } }); assertTrue("No observers?!", ps.hasObservers()); assertTrue("Has errors already?!", errors.isEmpty()); ps.onNext(1); assertFalse("Has observers?!", ps.hasObservers()); assertFalse("No errors?!", errors.isEmpty()); assertTrue(errors.toString(), errors.get(0) instanceof TestException); }
### Question: CompositeDisposable implements Disposable, DisposableContainer { @Override public void dispose() { if (disposed) { return; } OpenHashSet<Disposable> set; synchronized (this) { if (disposed) { return; } disposed = true; set = resources; resources = null; } dispose(set); } CompositeDisposable(); CompositeDisposable(@NonNull Disposable... resources); CompositeDisposable(@NonNull Iterable<? extends Disposable> resources); @Override void dispose(); @Override boolean isDisposed(); @Override boolean add(@NonNull Disposable d); boolean addAll(@NonNull Disposable... ds); @Override boolean remove(@NonNull Disposable d); @Override boolean delete(@NonNull Disposable d); void clear(); int size(); }### Answer: @Test public void disposeRace() { for (int i = 0; i < 500; i++) { final CompositeDisposable cd = new CompositeDisposable(); Runnable run = new Runnable() { @Override public void run() { cd.dispose(); } }; TestCommonHelper.race(run, run, Schedulers.io()); } }
### Question: ObservableRefCount extends AbstractObservableWithUpstream<T, T> { private Consumer<Disposable> onSubscribe(final Observer<? super T> observer, final AtomicBoolean writeLocked) { return new DisposeConsumer(observer, writeLocked); } ObservableRefCount(ConnectableObservable<T> source); @Override void subscribeActual(final Observer<? super T> subscriber); }### Answer: @Test public void onlyFirstShouldSubscribeAndLastUnsubscribe() { final AtomicInteger subscriptionCount = new AtomicInteger(); final AtomicInteger unsubscriptionCount = new AtomicInteger(); Observable<Integer> o = Observable.unsafeCreate(new ObservableSource<Integer>() { @Override public void subscribe(Observer<? super Integer> observer) { subscriptionCount.incrementAndGet(); observer.onSubscribe(Disposables.fromRunnable(new Runnable() { @Override public void run() { unsubscriptionCount.incrementAndGet(); } })); } }); Observable<Integer> refCounted = o.publish().refCount(); Disposable first = refCounted.subscribe(); assertEquals(1, subscriptionCount.get()); Disposable second = refCounted.subscribe(); assertEquals(1, subscriptionCount.get()); first.dispose(); assertEquals(0, unsubscriptionCount.get()); second.dispose(); assertEquals(1, unsubscriptionCount.get()); } @Test public void noOpConnect() { final int[] calls = { 0 }; Observable<Integer> o = new ConnectableObservable<Integer>() { @Override public void connect(Consumer<? super Disposable> connection) { calls[0]++; } @Override protected void subscribeActual(Observer<? super Integer> observer) { observer.onSubscribe(Disposables.disposed()); } }.refCount(); o.test(); o.test(); assertEquals(1, calls[0]); }
### Question: MaybeToSingle extends Single<T> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeToSingle(MaybeSource<T> source, T defaultValue); @Override MaybeSource<T> source(); }### Answer: @Test public void source() { Maybe<Integer> m = Maybe.just(1); Single<Integer> s = m.toSingle(); assertTrue(s.getClass().toString(), s instanceof HasUpstreamMaybeSource); assertSame(m, (((HasUpstreamMaybeSource<?>)s).source())); }
### Question: MaybeCount extends Single<Long> implements HasUpstreamMaybeSource<T> { @Override public MaybeSource<T> source() { return source; } MaybeCount(MaybeSource<T> source); @Override MaybeSource<T> source(); }### Answer: @SuppressWarnings("unchecked") @Test public void hasSource() { assertSame(Maybe.empty(), ((HasUpstreamMaybeSource<Object>)(Maybe.empty().count())).source()); }
### Question: ObservableScalarXMap { public static <T, U> Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper) { return RxJavaObservablePlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper)); } private ObservableScalarXMap(); @SuppressWarnings("unchecked") static boolean tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> mapper); static Observable<U> scalarXMap(T value, Function<? super T, ? extends ObservableSource<? extends U>> mapper); }### Answer: @Test public void scalarMapToEmpty() { ObservableScalarXMap.scalarXMap(1, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer v) throws Exception { return Observable.empty(); } }) .test() .assertResult(); } @Test public void scalarMapToCrashingCallable() { ObservableScalarXMap.scalarXMap(1, new Function<Integer, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(Integer v) throws Exception { return new CallablePublisher(); } }) .test() .assertFailure(TestException.class); }
### Question: ObservableReplay extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, Disposable { @Override public ObservableSource<T> source() { return source; } private ObservableReplay(ObservableSource<T> onSubscribe, ObservableSource<T> source, final AtomicReference<ReplayObserver<T>> current, final BufferSupplier<T> bufferFactory); static Observable<R> multicastSelector( final Callable<? extends ConnectableObservable<U>> connectableFactory, final Function<? super Observable<U>, ? extends ObservableSource<R>> selector); static ConnectableObservable<T> observeOn(final ConnectableObservable<T> co, final Scheduler scheduler); @SuppressWarnings("unchecked") static ConnectableObservable<T> createFrom(ObservableSource<? extends T> source); static ConnectableObservable<T> create(ObservableSource<T> source, final int bufferSize); static ConnectableObservable<T> create(ObservableSource<T> source, long maxAge, TimeUnit unit, Scheduler scheduler); static ConnectableObservable<T> create(ObservableSource<T> source, final long maxAge, final TimeUnit unit, final Scheduler scheduler, final int bufferSize); @Override ObservableSource<T> source(); @Override void dispose(); @Override boolean isDisposed(); @Override void connect(Consumer<? super Disposable> connection); }### Answer: @Test public void source() { Observable<Integer> source = Observable.range(1, 3); assertSame(source, (((HasUpstreamObservableSource<?>)source.replay())).source()); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.