diff --git a/clustered/ehcache-client/src/test/java/org/ehcache/clustered/client/internal/service/DefaultClusteringServiceTest.java b/clustered/ehcache-client/src/test/java/org/ehcache/clustered/client/internal/service/DefaultClusteringServiceTest.java index 8100a13bb4..aad97920fc 100644 --- a/clustered/ehcache-client/src/test/java/org/ehcache/clustered/client/internal/service/DefaultClusteringServiceTest.java +++ b/clustered/ehcache-client/src/test/java/org/ehcache/clustered/client/internal/service/DefaultClusteringServiceTest.java @@ -49,6 +49,7 @@ import org.ehcache.core.config.store.StoreEventSourceConfiguration; import org.ehcache.core.spi.store.Store; import org.ehcache.core.store.StoreConfigurationImpl; +import org.ehcache.impl.internal.classes.DefaultInstantiatorService; import org.ehcache.impl.internal.spi.serialization.DefaultSerializationProvider; import org.ehcache.spi.persistence.PersistableResourceService; import org.ehcache.spi.persistence.StateRepository; @@ -537,7 +538,7 @@ public void testGetServerStoreProxySharedAutoCreate() throws Exception { service.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration storeConfiguration = getSharedStoreConfig(targetPool, serializationProvider, Long.class, String.class); @@ -598,7 +599,7 @@ public void testGetServerStoreProxySharedNoAutoCreateNonExistent() throws Except accessService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration storeConfiguration = getSharedStoreConfig(targetPool, serializationProvider, Long.class, String.class); @@ -644,7 +645,7 @@ public void testGetServerStoreProxySharedNoAutoCreateExists() throws Exception { creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration creationStoreConfig = getSharedStoreConfig(targetPool, serializationProvider, Long.class, String.class); @@ -725,7 +726,7 @@ public void testGetServerStoreProxySharedAutoCreateTwice() throws Exception { firstService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration firstSharedStoreConfig = getSharedStoreConfig(targetPool, serializationProvider, Long.class, String.class); @@ -787,7 +788,7 @@ public void testReleaseServerStoreProxyShared() throws Exception { creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration storeConfiguration = getSharedStoreConfig(targetPool, serializationProvider, Long.class, String.class); @@ -838,7 +839,7 @@ public void testGetServerStoreProxyDedicatedAutoCreate() throws Exception { service.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration storeConfiguration = getDedicatedStoreConfig(targetResource, serializationProvider, Long.class, String.class); @@ -901,7 +902,7 @@ public void testGetServerStoreProxyDedicatedNoAutoCreateNonExistent() throws Exc accessService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration storeConfiguration = getDedicatedStoreConfig(targetResource, serializationProvider, Long.class, String.class); @@ -949,7 +950,7 @@ public void testGetServerStoreProxyDedicatedNoAutoCreateExists() throws Exceptio creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration creationStoreConfig = getDedicatedStoreConfig(targetResource, serializationProvider, Long.class, String.class); @@ -1032,7 +1033,7 @@ public void testGetServerStoreProxyDedicatedAutoCreateTwice() throws Exception { firstService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration firstSharedStoreConfig = getDedicatedStoreConfig(targetResource, serializationProvider, Long.class, String.class); @@ -1099,7 +1100,7 @@ public void testReleaseServerStoreProxyDedicated() throws Exception { creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration storeConfiguration = getDedicatedStoreConfig(targetResource, serializationProvider, Long.class, String.class); @@ -1151,7 +1152,7 @@ public void testGetServerStoreProxySharedDestroy() throws Exception { creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration storeConfiguration = getSharedStoreConfig(targetPool, serializationProvider, Long.class, String.class); @@ -1204,7 +1205,7 @@ public void testGetServerStoreProxyDedicatedDestroy() throws Exception { creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration storeConfiguration = getDedicatedStoreConfig(targetResource, serializationProvider, Long.class, String.class); @@ -1316,7 +1317,7 @@ public void testDestroyAllWithStores() throws Exception { createService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration sharedStoreConfiguration = getSharedStoreConfig("sharedPrimary", serializationProvider, Long.class, String.class); @@ -1414,7 +1415,7 @@ public void testStoreValidation_autoCreateConfigGood_autoCreateConfigBad() throw creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration createStoreConfig = getSharedStoreConfig("sharedPrimary", serializationProvider, Long.class, String.class); @@ -1476,7 +1477,7 @@ public void testStoreValidation_autoCreateConfigGood_autoCreateConfigGood() thro creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration storeConfig = getSharedStoreConfig("sharedPrimary", serializationProvider, Long.class, String.class); @@ -1528,7 +1529,7 @@ public void testStoreValidation_autoCreateConfigBad() throws Exception { creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration storeConfig = getSharedStoreConfig("dedicatedPrimary", serializationProvider, Long.class, String.class); @@ -1575,7 +1576,7 @@ public void testStoreValidation_autoCreateConfigGood_noAutoCreateConfigBad() thr creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration creationStoreConfig = getSharedStoreConfig("sharedPrimary", serializationProvider, Long.class, String.class); @@ -1644,7 +1645,7 @@ public void testStoreValidation_autoCreateConfigGood_noAutoCreateConfigGood() th creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration storeConfig = getSharedStoreConfig("sharedPrimary", serializationProvider, Long.class, String.class); @@ -1705,7 +1706,7 @@ public void testStoreValidation_MismatchedPoolTypes_ConfiguredDedicatedValidateS creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration createStoreConfig = getDedicatedStoreConfig("serverResource1", serializationProvider, Long.class, String.class); @@ -1773,7 +1774,7 @@ public void testStoreValidation_MismatchedPoolTypes_ConfiguredSharedValidateDedi creationService.start(null); DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); Store.Configuration createStoreConfig = getSharedStoreConfig("sharedPrimary", serializationProvider, Long.class, String.class); diff --git a/clustered/ehcache-client/src/test/java/org/ehcache/clustered/client/internal/service/TestServiceProvider.java b/clustered/ehcache-client/src/test/java/org/ehcache/clustered/client/internal/service/TestServiceProvider.java index cab3ec2744..bc57ca4b0c 100644 --- a/clustered/ehcache-client/src/test/java/org/ehcache/clustered/client/internal/service/TestServiceProvider.java +++ b/clustered/ehcache-client/src/test/java/org/ehcache/clustered/client/internal/service/TestServiceProvider.java @@ -33,6 +33,11 @@ public static ServiceProvider providerContaining(final Service... servi for (Service s : services) { servicesMap.put(s.getClass(), s); + for (Class service : s.getClass().getInterfaces()) { + if (!service.equals(Service.class) && Service.class.isAssignableFrom(service)) { + servicesMap.put(service.asSubclass(Service.class), s); + } + } } return new ServiceProvider() { diff --git a/ehcache-107/src/main/java/org/ehcache/jsr107/EhcacheCachingProvider.java b/ehcache-107/src/main/java/org/ehcache/jsr107/EhcacheCachingProvider.java index 636ec3bbd2..a2c976d635 100644 --- a/ehcache-107/src/main/java/org/ehcache/jsr107/EhcacheCachingProvider.java +++ b/ehcache-107/src/main/java/org/ehcache/jsr107/EhcacheCachingProvider.java @@ -19,6 +19,7 @@ import org.ehcache.core.EhcacheManager; import org.ehcache.core.config.DefaultConfiguration; import org.ehcache.core.spi.ServiceLocator; +import org.ehcache.core.spi.service.InstantiatorService; import org.ehcache.core.spi.service.ServiceUtils; import org.ehcache.core.util.ClassLoading; import org.ehcache.impl.config.serializer.DefaultSerializationProviderConfiguration; @@ -169,6 +170,9 @@ private Eh107CacheManager createCacheManager(URI uri, Configuration config, Prop if (ServiceUtils.findSingletonAmongst(DefaultSerializationProviderConfiguration.class, serviceCreationConfigurations) == null) { d = d.with(serializerConfiguration); } + if(properties.containsKey("ehcache.service.instantiatorService")) { + d.with((InstantiatorService) properties.get("ehcache.service.instantiatorService")); + } return d; }; diff --git a/ehcache-core/build.gradle b/ehcache-core/build.gradle index adf8ced16a..c1a1b13029 100644 --- a/ehcache-core/build.gradle +++ b/ehcache-core/build.gradle @@ -16,6 +16,7 @@ plugins { id 'org.ehcache.build.internal-module' + id 'java-test-fixtures' } publishing.publications.withType(MavenPublication) { diff --git a/ehcache-core/src/main/java/org/ehcache/core/spi/ServiceLocator.java b/ehcache-core/src/main/java/org/ehcache/core/spi/ServiceLocator.java index 97bf72ed8e..c374028e58 100644 --- a/ehcache-core/src/main/java/org/ehcache/core/spi/ServiceLocator.java +++ b/ehcache-core/src/main/java/org/ehcache/core/spi/ServiceLocator.java @@ -40,6 +40,7 @@ import java.util.LinkedList; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.OptionalInt; import java.util.Set; import java.util.concurrent.atomic.AtomicBoolean; @@ -52,6 +53,7 @@ import static java.util.Collections.newSetFromMap; import static java.util.Collections.singleton; import static java.util.Collections.unmodifiableSet; +import static java.util.Comparator.comparing; import static java.util.stream.Collectors.groupingBy; import static java.util.stream.Collectors.toList; import static java.util.stream.StreamSupport.stream; @@ -262,11 +264,10 @@ public DependencySet with(ServiceCreationConfiguration .filter(f -> serviceType.isAssignableFrom(f.getServiceType())).map(f -> (ServiceFactory) f) .collect(toList()); - OptionalInt highestRank = typedServiceFactories.stream().mapToInt(ServiceFactory::rank).max(); + Optional> highestRank = typedServiceFactories.stream().max(comparing(ServiceFactory::rank)); if (highestRank.isPresent()) { - typedServiceFactories.stream().filter(f -> highestRank.getAsInt() == f.rank()).forEach(f -> with(f.create(config))); - return this; + return with(highestRank.get().create(config)); } else { throw new IllegalStateException("No factories exist for " + serviceType); } diff --git a/ehcache-core/src/main/java/org/ehcache/core/spi/service/InstantiatorService.java b/ehcache-core/src/main/java/org/ehcache/core/spi/service/InstantiatorService.java new file mode 100644 index 0000000000..f00124faf6 --- /dev/null +++ b/ehcache-core/src/main/java/org/ehcache/core/spi/service/InstantiatorService.java @@ -0,0 +1,23 @@ +/* + * Copyright Terracotta, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.ehcache.core.spi.service; + +import org.ehcache.spi.service.Service; + +public interface InstantiatorService extends Service { + + T instantiate(Class clazz, Object ... arguments) throws IllegalArgumentException; +} diff --git a/ehcache-core/src/testFixtures/java/org/ehcache/core/spi/ServiceLocatorUtils.java b/ehcache-core/src/testFixtures/java/org/ehcache/core/spi/ServiceLocatorUtils.java new file mode 100644 index 0000000000..2ca5a20ed2 --- /dev/null +++ b/ehcache-core/src/testFixtures/java/org/ehcache/core/spi/ServiceLocatorUtils.java @@ -0,0 +1,44 @@ +/* + * Copyright Terracotta, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.ehcache.core.spi; + +import org.ehcache.spi.service.Service; + +import java.util.function.UnaryOperator; + +public interface ServiceLocatorUtils { + + static void withServiceLocator(T service, ServiceTask task) throws Exception { + withServiceLocator(service, UnaryOperator.identity(), task); + } + + static void withServiceLocator(T service, UnaryOperator dependencies, ServiceTask task) throws Exception { + ServiceLocator serviceLocator = dependencies.apply(ServiceLocator.dependencySet().with(service)).build(); + serviceLocator.startAllServices(); + try { + task.execute(service); + } finally { + serviceLocator.stopAllServices(); + } + } + + @FunctionalInterface + interface ServiceTask { + + void execute(T service) throws Exception; + } + +} diff --git a/ehcache-impl/build.gradle b/ehcache-impl/build.gradle index 94674d88ef..e215c51e06 100644 --- a/ehcache-impl/build.gradle +++ b/ehcache-impl/build.gradle @@ -55,6 +55,7 @@ dependencies { implementation group: 'org.terracotta', name: 'terracotta-utilities-tools', version: parent.terracottaUtilitiesVersion compileOnly 'org.osgi:org.osgi.service.component.annotations:1.3.0' testImplementation project(':core-spi-test') + testImplementation testFixtures(project(':ehcache-core')) testImplementation 'org.ow2.asm:asm:6.2' testImplementation 'org.ow2.asm:asm-commons:6.2' testImplementation ("org.terracotta:statistics:$parent.statisticVersion") diff --git a/ehcache-impl/src/main/java/org/ehcache/config/builders/UserManagedCacheBuilder.java b/ehcache-impl/src/main/java/org/ehcache/config/builders/UserManagedCacheBuilder.java index c4cd118f38..e00d4b1339 100644 --- a/ehcache-impl/src/main/java/org/ehcache/config/builders/UserManagedCacheBuilder.java +++ b/ehcache-impl/src/main/java/org/ehcache/config/builders/UserManagedCacheBuilder.java @@ -54,7 +54,6 @@ import org.ehcache.impl.internal.events.DisabledCacheEventNotificationService; import org.ehcache.impl.internal.resilience.RobustLoaderWriterResilienceStrategy; import org.ehcache.impl.internal.resilience.RobustResilienceStrategy; -import org.ehcache.impl.internal.spi.event.DefaultCacheEventListenerProvider; import org.ehcache.spi.copy.Copier; import org.ehcache.spi.loaderwriter.CacheLoaderWriter; import org.ehcache.spi.persistence.PersistableResourceService; @@ -71,7 +70,6 @@ import java.util.ArrayList; import java.util.Arrays; -import java.util.HashSet; import java.util.List; import java.util.Set; @@ -80,10 +78,7 @@ import java.util.concurrent.atomic.AtomicReference; import static org.ehcache.config.ResourceType.Core.DISK; -import static org.ehcache.config.ResourceType.Core.OFFHEAP; import static org.ehcache.config.builders.ResourcePoolsBuilder.newResourcePoolsBuilder; -import static org.ehcache.core.spi.ServiceLocator.dependencySet; -import static org.ehcache.core.spi.service.ServiceUtils.findSingletonAmongst; /** * The {@code UserManagedCacheBuilder} enables building {@link UserManagedCache}s using a fluent style. @@ -107,8 +102,7 @@ public class UserManagedCacheBuilder> imp private final Class keyType; private final Class valueType; private String id; - private final Set services = new HashSet<>(); - private final Set> serviceCreationConfigurations = new HashSet<>(); + private ServiceLocator.DependencySet dependencySet = ServiceLocator.dependencySet().with(Store.Provider.class); private ExpiryPolicy expiry = ExpiryPolicy.NO_EXPIRY; private ClassLoader classLoader = ClassLoading.getDefaultClassLoader(); private EvictionAdvisor evictionAdvisor; @@ -143,8 +137,7 @@ private UserManagedCacheBuilder(UserManagedCacheBuilder toCopy) { this.keyType = toCopy.keyType; this.valueType = toCopy.valueType; this.id = toCopy.id; - this.services.addAll(toCopy.services); - this.serviceCreationConfigurations.addAll(toCopy.serviceCreationConfigurations); + this.dependencySet = toCopy.dependencySet; this.expiry = toCopy.expiry; this.classLoader = toCopy.classLoader; this.evictionAdvisor = toCopy.evictionAdvisor; @@ -166,8 +159,9 @@ private UserManagedCacheBuilder(UserManagedCacheBuilder toCopy) { this.sizeOfUnit = toCopy.sizeOfUnit; } - @SuppressWarnings("try") - T build(ServiceLocator.DependencySet serviceLocatorBuilder) throws IllegalStateException { + @SuppressWarnings({"try", "deprecation"}) + T internalBuild() throws IllegalStateException { + dependencySet.with(new org.ehcache.impl.config.store.heap.DefaultSizeOfEngineProviderConfiguration(maxObjectSize, sizeOfUnit, objectGraphSize)); String alias = id == null ? "UserManaged - " + instanceId.getAndIncrement() : id; try(EhcachePrefixLoggerFactory.Context ignored = EhcachePrefixLoggerFactory.withContext("cache-alias", alias)){ @@ -175,11 +169,7 @@ T build(ServiceLocator.DependencySet serviceLocatorBuilder) throws IllegalStateE ServiceLocator serviceLocator; try { - for (ServiceCreationConfiguration serviceCreationConfig : serviceCreationConfigurations) { - serviceLocatorBuilder = serviceLocatorBuilder.with(serviceCreationConfig); - } - serviceLocatorBuilder = serviceLocatorBuilder.with(Store.Provider.class); - serviceLocator = serviceLocatorBuilder.build(); + serviceLocator = dependencySet.build(); serviceLocator.startAllServices(); } catch (Exception e) { throw new IllegalStateException("UserManagedCacheBuilder failed to build.", e); @@ -354,13 +344,7 @@ private void validateListenerConfig() { private void registerListeners(Cache cache, ServiceProvider serviceProvider, List lifeCycledList) { if (!eventListenerConfigurations.isEmpty()) { - final CacheEventListenerProvider listenerProvider; - CacheEventListenerProvider provider; - if ((provider = serviceProvider.getService(CacheEventListenerProvider.class)) != null) { - listenerProvider = provider; - } else { - listenerProvider = new DefaultCacheEventListenerProvider(); - } + final CacheEventListenerProvider listenerProvider = serviceProvider.getService(CacheEventListenerProvider.class); for (CacheEventListenerConfiguration config : eventListenerConfigurations) { final CacheEventListener listener = listenerProvider.createEventListener(id, config); if (listener != null) { @@ -396,7 +380,7 @@ T cast(UserManagedCache cache) { * @throws IllegalStateException if the user managed cache cannot be built */ public final T build(final boolean init) throws IllegalStateException { - final T build = build(dependencySet().withoutMandatoryServices().with(services)); + final T build = internalBuild(); if (init) { build.init(); } @@ -557,6 +541,7 @@ public final UserManagedCacheBuilder withEventListeners(CacheEventListe */ public final UserManagedCacheBuilder withEventListeners(CacheEventListenerConfiguration ... cacheEventListenerConfigurations) { UserManagedCacheBuilder otherBuilder = new UserManagedCacheBuilder<>(this); + otherBuilder.dependencySet.with(CacheEventListenerProvider.class); otherBuilder.eventListenerConfigurations.addAll(Arrays.asList(cacheEventListenerConfigurations)); return otherBuilder; } @@ -737,9 +722,7 @@ public UserManagedCacheBuilder withValueSerializer(Serializer valueS @Deprecated public UserManagedCacheBuilder withSizeOfMaxObjectGraph(long size) { UserManagedCacheBuilder otherBuilder = new UserManagedCacheBuilder<>(this); - removeAnySizeOfEngine(otherBuilder); otherBuilder.objectGraphSize = size; - otherBuilder.serviceCreationConfigurations.add(new org.ehcache.impl.config.store.heap.DefaultSizeOfEngineProviderConfiguration(otherBuilder.maxObjectSize, otherBuilder.sizeOfUnit, otherBuilder.objectGraphSize)); return otherBuilder; } @@ -756,10 +739,8 @@ public UserManagedCacheBuilder withSizeOfMaxObjectGraph(long size) { @Deprecated public UserManagedCacheBuilder withSizeOfMaxObjectSize(long size, MemoryUnit unit) { UserManagedCacheBuilder otherBuilder = new UserManagedCacheBuilder<>(this); - removeAnySizeOfEngine(otherBuilder); otherBuilder.maxObjectSize = size; otherBuilder.sizeOfUnit = unit; - otherBuilder.serviceCreationConfigurations.add(new org.ehcache.impl.config.store.heap.DefaultSizeOfEngineProviderConfiguration(otherBuilder.maxObjectSize, otherBuilder.sizeOfUnit, otherBuilder.objectGraphSize)); return otherBuilder; } @@ -788,13 +769,9 @@ public static UserManagedCacheBuilder> newUs * * @see #using(ServiceCreationConfiguration) */ - @SuppressWarnings("deprecation") public UserManagedCacheBuilder using(Service service) { UserManagedCacheBuilder otherBuilder = new UserManagedCacheBuilder<>(this); - if (service instanceof org.ehcache.core.spi.store.heap.SizeOfEngineProvider) { - removeAnySizeOfEngine(otherBuilder); - } - otherBuilder.services.add(service); + otherBuilder.dependencySet.with(service); return otherBuilder; } @@ -812,20 +789,9 @@ public UserManagedCacheBuilder using(Service service) { * * @see #using(Service) */ - @SuppressWarnings("deprecation") public UserManagedCacheBuilder using(ServiceCreationConfiguration serviceConfiguration) { UserManagedCacheBuilder otherBuilder = new UserManagedCacheBuilder<>(this); - if (serviceConfiguration instanceof org.ehcache.impl.config.store.heap.DefaultSizeOfEngineProviderConfiguration) { - removeAnySizeOfEngine(otherBuilder); - } - otherBuilder.serviceCreationConfigurations.add(serviceConfiguration); + otherBuilder.dependencySet.with(serviceConfiguration); return otherBuilder; } - - @Deprecated - private static void removeAnySizeOfEngine(UserManagedCacheBuilder builder) { - builder.services.remove(findSingletonAmongst(org.ehcache.core.spi.store.heap.SizeOfEngineProvider.class, builder.services)); - builder.serviceCreationConfigurations.remove(findSingletonAmongst(org.ehcache.impl.config.store.heap.DefaultSizeOfEngineProviderConfiguration.class, builder.serviceCreationConfigurations)); - } - } diff --git a/ehcache-impl/src/main/java/org/ehcache/impl/internal/DefaultInstantiatorServiceFactory.java b/ehcache-impl/src/main/java/org/ehcache/impl/internal/DefaultInstantiatorServiceFactory.java new file mode 100644 index 0000000000..1e27078400 --- /dev/null +++ b/ehcache-impl/src/main/java/org/ehcache/impl/internal/DefaultInstantiatorServiceFactory.java @@ -0,0 +1,41 @@ +/* + * Copyright Terracotta, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.ehcache.impl.internal; + +import org.ehcache.core.spi.service.InstantiatorService; +import org.ehcache.core.spi.service.ServiceFactory; +import org.ehcache.impl.internal.classes.DefaultInstantiatorService; +import org.ehcache.spi.service.ServiceCreationConfiguration; +import org.osgi.service.component.annotations.Component; + +@Component +public class DefaultInstantiatorServiceFactory implements ServiceFactory { + + @Override + public int rank() { + return Integer.MIN_VALUE; + } + + @Override + public InstantiatorService create(ServiceCreationConfiguration configuration) { + return new DefaultInstantiatorService(); + } + + @Override + public Class getServiceType() { + return DefaultInstantiatorService.class; + } +} diff --git a/ehcache-impl/src/main/java/org/ehcache/impl/internal/classes/ClassInstanceProvider.java b/ehcache-impl/src/main/java/org/ehcache/impl/internal/classes/ClassInstanceProvider.java index 1e41f4313d..ca1a02a18f 100644 --- a/ehcache-impl/src/main/java/org/ehcache/impl/internal/classes/ClassInstanceProvider.java +++ b/ehcache-impl/src/main/java/org/ehcache/impl/internal/classes/ClassInstanceProvider.java @@ -17,6 +17,8 @@ package org.ehcache.impl.internal.classes; import org.ehcache.config.CacheConfiguration; +import org.ehcache.core.spi.service.InstantiatorService; +import org.ehcache.spi.service.ServiceDependencies; import org.ehcache.spi.service.ServiceProvider; import org.ehcache.spi.service.Service; import org.ehcache.spi.service.ServiceConfiguration; @@ -24,7 +26,6 @@ import java.io.Closeable; import java.io.IOException; -import java.lang.reflect.InvocationTargetException; import java.util.Collections; import java.util.Iterator; import java.util.LinkedHashMap; @@ -32,14 +33,14 @@ import java.util.Set; import java.util.concurrent.atomic.AtomicInteger; -import static org.ehcache.impl.internal.classes.commonslang.reflect.ConstructorUtils.invokeConstructor; import static org.ehcache.core.spi.service.ServiceUtils.findAmongst; import static org.ehcache.core.spi.service.ServiceUtils.findSingletonAmongst; /** * @author Alex Snaps */ -public class ClassInstanceProvider, T> { +@ServiceDependencies(InstantiatorService.class) +public class ClassInstanceProvider, T> implements Service { /** * The order in which entries are put in is kept. @@ -55,6 +56,8 @@ public class ClassInstanceProvider cacheLevelConfig; private final boolean uniqueClassLevelConfig; + private InstantiatorService instantiator; + protected ClassInstanceProvider(ClassInstanceProviderConfiguration factoryConfig, Class cacheLevelConfig) { this(factoryConfig, cacheLevelConfig, false); @@ -117,12 +120,8 @@ private T newInstance(K alias, ClassInstanceConfiguration config) { if(config.getInstance() != null) { instance = config.getInstance(); } else { - try { - instance = invokeConstructor(config.getClazz(), config.getArguments()); - instantiated.add(instance); - } catch (InstantiationException | InvocationTargetException | NoSuchMethodException | IllegalAccessException e) { - throw new RuntimeException(e); - } + instance = instantiator.instantiate(config.getClazz(), config.getArguments()); + instantiated.add(instance); } AtomicInteger currentCount = providedVsCount.putIfAbsent(instance, new AtomicInteger(1)); @@ -153,10 +152,10 @@ protected void releaseInstance(T instance) throws IOException { } public void start(ServiceProvider serviceProvider) { - // default no-op + this.instantiator = serviceProvider.getService(InstantiatorService.class); } public void stop() { - // default no-op + this.instantiator = null; } } diff --git a/ehcache-impl/src/main/java/org/ehcache/impl/internal/classes/DefaultInstantiatorService.java b/ehcache-impl/src/main/java/org/ehcache/impl/internal/classes/DefaultInstantiatorService.java new file mode 100644 index 0000000000..cd4f1a9f57 --- /dev/null +++ b/ehcache-impl/src/main/java/org/ehcache/impl/internal/classes/DefaultInstantiatorService.java @@ -0,0 +1,43 @@ +/* + * Copyright Terracotta, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.ehcache.impl.internal.classes; + +import org.ehcache.core.spi.service.InstantiatorService; +import org.ehcache.impl.internal.classes.commonslang.reflect.ConstructorUtils; +import org.ehcache.spi.service.Service; +import org.ehcache.spi.service.ServiceProvider; + +public class DefaultInstantiatorService implements InstantiatorService { + + @Override + public void start(ServiceProvider serviceProvider) { + + } + + @Override + public void stop() { + + } + + @Override + public T instantiate(Class clazz, Object ... arguments) { + try { + return ConstructorUtils.invokeConstructor(clazz, arguments); + } catch (ReflectiveOperationException e) { + throw new RuntimeException(e); + } + } +} diff --git a/ehcache-impl/src/main/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProvider.java b/ehcache-impl/src/main/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProvider.java index 0807f32cad..50b8aaa681 100644 --- a/ehcache-impl/src/main/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProvider.java +++ b/ehcache-impl/src/main/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProvider.java @@ -16,6 +16,7 @@ package org.ehcache.impl.internal.spi.resilience; import org.ehcache.config.CacheConfiguration; +import org.ehcache.core.spi.service.InstantiatorService; import org.ehcache.impl.config.resilience.DefaultResilienceStrategyConfiguration; import org.ehcache.impl.config.resilience.DefaultResilienceStrategyProviderConfiguration; import org.ehcache.impl.internal.classes.ClassInstanceProvider; @@ -24,10 +25,12 @@ import org.ehcache.spi.resilience.ResilienceStrategy; import org.ehcache.spi.resilience.ResilienceStrategyProvider; import org.ehcache.spi.service.Service; +import org.ehcache.spi.service.ServiceDependencies; import org.ehcache.spi.service.ServiceProvider; import static org.ehcache.core.spi.service.ServiceUtils.findSingletonAmongst; +@ServiceDependencies(InstantiatorService.class) public class DefaultResilienceStrategyProvider implements ResilienceStrategyProvider { private final ComponentProvider regularStrategies; diff --git a/ehcache-impl/src/main/java/org/ehcache/impl/internal/spi/serialization/DefaultSerializationProvider.java b/ehcache-impl/src/main/java/org/ehcache/impl/internal/spi/serialization/DefaultSerializationProvider.java index e5bfa39a3a..939349776f 100644 --- a/ehcache-impl/src/main/java/org/ehcache/impl/internal/spi/serialization/DefaultSerializationProvider.java +++ b/ehcache-impl/src/main/java/org/ehcache/impl/internal/spi/serialization/DefaultSerializationProvider.java @@ -16,6 +16,7 @@ package org.ehcache.impl.internal.spi.serialization; +import org.ehcache.core.spi.service.InstantiatorService; import org.ehcache.core.spi.service.ServiceUtils; import org.ehcache.impl.config.serializer.DefaultSerializationProviderConfiguration; import org.ehcache.impl.config.serializer.DefaultSerializerConfiguration; @@ -27,6 +28,7 @@ import org.ehcache.impl.serialization.IntegerSerializer; import org.ehcache.impl.serialization.LongSerializer; import org.ehcache.impl.serialization.StringSerializer; +import org.ehcache.spi.service.ServiceDependencies; import org.ehcache.spi.service.ServiceProvider; import org.ehcache.spi.serialization.SerializationProvider; import org.ehcache.spi.serialization.Serializer; @@ -41,8 +43,6 @@ import java.io.Closeable; import java.io.IOException; import java.io.Serializable; -import java.lang.reflect.Constructor; -import java.lang.reflect.InvocationTargetException; import java.util.Collection; import java.util.Collections; import java.util.LinkedHashMap; @@ -53,6 +53,7 @@ /** * @author Ludovic Orban */ +@ServiceDependencies(InstantiatorService.class) public class DefaultSerializationProvider implements SerializationProvider { private static final Logger LOG = LoggerFactory.getLogger(DefaultSerializationProvider.class); @@ -62,6 +63,8 @@ public class DefaultSerializationProvider implements SerializationProvider { final ConcurrentWeakIdentityHashMap, AtomicInteger> providedVsCount = new ConcurrentWeakIdentityHashMap<>(); final Set> instantiated = Collections.newSetFromMap(new ConcurrentWeakIdentityHashMap, Boolean>()); + private InstantiatorService instantiator; + public DefaultSerializationProvider(DefaultSerializationProviderConfiguration configuration) { if (configuration != null) { this.serializers = new LinkedHashMap<>(configuration.getDefaultSerializers()); @@ -105,11 +108,7 @@ private Serializer createSerializer(Class clazz, ClassLoader classLoad // Ideal } - try { - return constructSerializer(clazz, klazz.getConstructor(ClassLoader.class), classLoader); - } catch (NoSuchMethodException e) { - throw new RuntimeException(klazz + " does not have a constructor that takes in a ClassLoader.", e); - } + return instantiator.instantiate(klazz, classLoader); } @@ -136,18 +135,6 @@ private Class> getSerializerClassFor(Class clazz, throw new UnsupportedTypeException("No serializer found for type '" + clazz.getName() + "'"); } - private Serializer constructSerializer(Class clazz, Constructor> constructor, Object ... args) { - try { - Serializer serializer = constructor.newInstance(args); - LOG.debug("Serializer for <{}> : {}", clazz.getName(), serializer); - return serializer; - } catch (InstantiationException | InvocationTargetException | IllegalAccessException e) { - throw new RuntimeException(e); - } catch (IllegalArgumentException e) { - throw new AssertionError(e); - } - } - private void updateProvidedInstanceCounts(Serializer serializer) { AtomicInteger currentCount = providedVsCount.putIfAbsent(serializer, new AtomicInteger(1)); if(currentCount != null) { @@ -176,6 +163,7 @@ public void releaseSerializer(final Serializer serializer) throws IOException @Override public void start(ServiceProvider serviceProvider) { + this.instantiator = serviceProvider.getService(InstantiatorService.class); addDefaultSerializerIfNoneRegistered(serializers, Serializable.class, CompactJavaSerializer.asTypedSerializer()); addDefaultSerializerIfNoneRegistered(serializers, Long.class, LongSerializer.class); addDefaultSerializerIfNoneRegistered(serializers, Integer.class, IntegerSerializer.class); @@ -188,7 +176,7 @@ public void start(ServiceProvider serviceProvider) { @Override public void stop() { - // no-op + this.instantiator = null; } private static void addDefaultSerializerIfNoneRegistered(Map, Class>> serializers, Class clazz, Class> serializerClass) { diff --git a/ehcache-impl/src/main/resources/META-INF/services/org.ehcache.core.spi.service.ServiceFactory b/ehcache-impl/src/main/resources/META-INF/services/org.ehcache.core.spi.service.ServiceFactory index c2cf30fb9a..177a41633c 100644 --- a/ehcache-impl/src/main/resources/META-INF/services/org.ehcache.core.spi.service.ServiceFactory +++ b/ehcache-impl/src/main/resources/META-INF/services/org.ehcache.core.spi.service.ServiceFactory @@ -5,6 +5,7 @@ org.ehcache.impl.internal.store.tiering.TieredStoreProviderFactory org.ehcache.impl.internal.store.tiering.CompoundCachingTierProviderFactory org.ehcache.impl.internal.store.loaderwriter.LoaderWriterStoreProviderFactory +org.ehcache.impl.internal.DefaultInstantiatorServiceFactory org.ehcache.impl.internal.TimeSourceServiceFactory org.ehcache.impl.internal.spi.serialization.DefaultSerializationProviderFactory org.ehcache.impl.internal.spi.loaderwriter.DefaultCacheLoaderWriterProviderFactory diff --git a/ehcache-impl/src/test/java/org/ehcache/config/builders/UserManagedCacheBuilderTest.java b/ehcache-impl/src/test/java/org/ehcache/config/builders/UserManagedCacheBuilderTest.java index 48462b4a4d..419298ee3f 100644 --- a/ehcache-impl/src/test/java/org/ehcache/config/builders/UserManagedCacheBuilderTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/config/builders/UserManagedCacheBuilderTest.java @@ -45,7 +45,7 @@ public void testIsExtensible() { final UserManagedCacheConfiguration> cfg = builder -> new UserManagedCacheBuilder>(String.class, Object.class) { @Override - TestUserManagedCache build(final ServiceLocator.DependencySet dependencySet) { + TestUserManagedCache internalBuild() { return new TestUserManagedCache<>(); } }; diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/classes/ClassInstanceProviderTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/classes/ClassInstanceProviderTest.java index 0660471870..45165fd715 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/classes/ClassInstanceProviderTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/classes/ClassInstanceProviderTest.java @@ -24,8 +24,10 @@ import java.io.IOException; import java.util.concurrent.atomic.AtomicInteger; +import static org.ehcache.core.spi.ServiceLocatorUtils.withServiceLocator; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.instanceOf; import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.nullValue; import static org.hamcrest.Matchers.sameInstance; @@ -33,6 +35,7 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; +import static org.terracotta.utilities.test.matchers.ThrowsMatcher.threw; /** * @author Ludovic Orban @@ -44,32 +47,33 @@ public class ClassInstanceProviderTest { @Test public void testNewInstanceUsingAliasAndNoArgs() throws Exception { - ClassInstanceProvider, TestService> classInstanceProvider = new ClassInstanceProvider<>(null, configClass); + withServiceLocator(new ClassInstanceProvider<>(null, configClass), provider -> { - classInstanceProvider.preconfigured.put("test stuff", new ClassInstanceConfiguration(TestService.class)); - TestService obj = classInstanceProvider.newInstance("test stuff", (ServiceConfiguration) null); + provider.preconfigured.put("test stuff", new ClassInstanceConfiguration(TestService.class)); + TestService obj = provider.newInstance("test stuff", (ServiceConfiguration) null); - assertThat(obj.theString, is(nullValue())); + assertThat(obj.theString, is(nullValue())); + }); } @Test public void testNewInstanceUsingAliasAndArg() throws Exception { - ClassInstanceProvider, TestService> classInstanceProvider = new ClassInstanceProvider<>(null, configClass); + withServiceLocator(new ClassInstanceProvider<>(null, configClass), provider -> { + provider.preconfigured.put("test stuff", new ClassInstanceConfiguration<>(TestService.class, "test string")); + TestService obj = provider.newInstance("test stuff", (ServiceConfiguration) null); - classInstanceProvider.preconfigured.put("test stuff", new ClassInstanceConfiguration<>(TestService.class, "test string")); - TestService obj = classInstanceProvider.newInstance("test stuff", (ServiceConfiguration) null); - - assertThat(obj.theString, equalTo("test string")); + assertThat(obj.theString, equalTo("test string")); + }); } @Test public void testNewInstanceUsingServiceConfig() throws Exception { - ClassInstanceProvider, TestService> classInstanceProvider = new ClassInstanceProvider<>(null, configClass); - - TestServiceConfiguration config = new TestServiceConfiguration(); - TestService obj = classInstanceProvider.newInstance("test stuff", config); + withServiceLocator(new ClassInstanceProvider<>(null, configClass), provider -> { + TestServiceConfiguration config = new TestServiceConfiguration(); + TestService obj = provider.newInstance("test stuff", config); - assertThat(obj.theString, is(nullValue())); + assertThat(obj.theString, is(nullValue())); + }); } @Test @@ -77,92 +81,96 @@ public void testNewInstanceUsingServiceConfigFactory() throws Exception { TestServiceProviderConfiguration factoryConfig = new TestServiceProviderConfiguration(); factoryConfig.getDefaults().put("test stuff", new ClassInstanceConfiguration(TestService.class)); - ClassInstanceProvider, TestService> classInstanceProvider = new ClassInstanceProvider<>(factoryConfig, configClass); - classInstanceProvider.start(null); - - TestService obj = classInstanceProvider.newInstance("test stuff", (ServiceConfiguration) null); - assertThat(obj.theString, is(nullValue())); + withServiceLocator(new ClassInstanceProvider<>(factoryConfig, configClass), provider -> { + TestService obj = provider.newInstance("test stuff", (ServiceConfiguration) null); + assertThat(obj.theString, is(nullValue())); + }); } - @Test(expected = IllegalArgumentException.class) + @Test public void testReleaseInstanceByAnotherProvider() throws Exception { - ClassInstanceProvider, String> classInstanceProvider = new ClassInstanceProvider<>(null, null); - - classInstanceProvider.releaseInstance("foo"); + withServiceLocator(new ClassInstanceProvider<>(null, null), provider -> { + assertThat(() -> provider.releaseInstance("foo"), threw(instanceOf(IllegalArgumentException.class))); + }); } - @Test(expected = IllegalArgumentException.class) + @Test public void testReleaseSameInstanceMultipleTimesThrows() throws Exception { - ClassInstanceProvider, String> classInstanceProvider = new ClassInstanceProvider<>(null, null); - classInstanceProvider.providedVsCount.put("foo", new AtomicInteger(1)); + withServiceLocator(new ClassInstanceProvider<>(null, null), provider -> { + provider.providedVsCount.put("foo", new AtomicInteger(1)); - classInstanceProvider.releaseInstance("foo"); - classInstanceProvider.releaseInstance("foo"); + provider.releaseInstance("foo"); + assertThat(() -> provider.releaseInstance("foo"), threw(instanceOf(IllegalArgumentException.class))); + }); } @Test public void testReleaseCloseableInstance() throws Exception { - ClassInstanceProvider, Closeable> classInstanceProvider = new ClassInstanceProvider<>(null, null); - Closeable closeable = mock(Closeable.class); - classInstanceProvider.providedVsCount.put(closeable, new AtomicInteger(1)); - classInstanceProvider.instantiated.add(closeable); + withServiceLocator(new ClassInstanceProvider<>(null, null), provider -> { + Closeable closeable = mock(Closeable.class); + provider.providedVsCount.put(closeable, new AtomicInteger(1)); + provider.instantiated.add(closeable); - classInstanceProvider.releaseInstance(closeable); - verify(closeable).close(); + provider.releaseInstance(closeable); + verify(closeable).close(); + }); } @Test(expected = IOException.class) public void testReleaseCloseableInstanceThrows() throws Exception { - ClassInstanceProvider, Closeable> classInstanceProvider = new ClassInstanceProvider<>(null, null); - Closeable closeable = mock(Closeable.class); - doThrow(IOException.class).when(closeable).close(); - classInstanceProvider.providedVsCount.put(closeable, new AtomicInteger(1)); - classInstanceProvider.instantiated.add(closeable); + withServiceLocator(new ClassInstanceProvider<>(null, null), provider -> { + Closeable closeable = mock(Closeable.class); + doThrow(IOException.class).when(closeable).close(); + provider.providedVsCount.put(closeable, new AtomicInteger(1)); + provider.instantiated.add(closeable); - classInstanceProvider.releaseInstance(closeable); + provider.releaseInstance(closeable); + }); } @Test public void testNewInstanceWithActualInstanceInServiceConfig() throws Exception { - ClassInstanceProvider, TestService> classInstanceProvider = new ClassInstanceProvider<>(null, configClass); + withServiceLocator(new ClassInstanceProvider<>(null, configClass), provider -> { - TestService service = new TestService(); - TestServiceConfiguration config = new TestServiceConfiguration(service); + TestService service = new TestService(); + TestServiceConfiguration config = new TestServiceConfiguration(service); - TestService newService = classInstanceProvider.newInstance("test stuff", config); + TestService newService = provider.newInstance("test stuff", config); - assertThat(newService, sameInstance(service)); + assertThat(newService, sameInstance(service)); + }); } @Test public void testSameInstanceRetrievedMultipleTimesUpdatesTheProvidedCount() throws Exception { - ClassInstanceProvider, TestService> classInstanceProvider = new ClassInstanceProvider<>(null, configClass); + withServiceLocator(new ClassInstanceProvider<>(null, configClass), provider -> { - TestService service = new TestService(); - TestServiceConfiguration config = new TestServiceConfiguration(service); + TestService service = new TestService(); + TestServiceConfiguration config = new TestServiceConfiguration(service); - TestService newService = classInstanceProvider.newInstance("test stuff", config); - assertThat(newService, sameInstance(service)); - assertThat(classInstanceProvider.providedVsCount.get(service).get(), is(1)); - newService = classInstanceProvider.newInstance("test stuff", config); - assertThat(newService, sameInstance(service)); - assertThat(classInstanceProvider.providedVsCount.get(service).get(), is(2)); + TestService newService = provider.newInstance("test stuff", config); + assertThat(newService, sameInstance(service)); + assertThat(provider.providedVsCount.get(service).get(), is(1)); + newService = provider.newInstance("test stuff", config); + assertThat(newService, sameInstance(service)); + assertThat(provider.providedVsCount.get(service).get(), is(2)); + }); } @Test - public void testInstancesNotCreatedByProviderDoesNotClose() throws IOException { + public void testInstancesNotCreatedByProviderDoesNotClose() throws Exception { @SuppressWarnings("unchecked") Class> configClass = (Class) ClassInstanceConfiguration.class; - ClassInstanceProvider, TestCloseableService> classInstanceProvider = new ClassInstanceProvider<>(null, configClass); - - TestCloseableService service = mock(TestCloseableService.class); - TestCloaseableServiceConfig config = new TestCloaseableServiceConfig(service); + withServiceLocator(new ClassInstanceProvider<>(null, configClass), provider -> { - TestCloseableService newService = classInstanceProvider.newInstance("testClose", config); - assertThat(newService, sameInstance(service)); - classInstanceProvider.releaseInstance(newService); - verify(service, times(0)).close(); + TestCloseableService service = mock(TestCloseableService.class); + TestCloaseableServiceConfig config = new TestCloaseableServiceConfig(service); + TestCloseableService newService = provider.newInstance("testClose", config); + assertThat(newService, sameInstance(service)); + provider.releaseInstance(newService); + verify(service, times(0)).close(); + }); } diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/events/CacheEventDispatcherFactoryImplTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/events/CacheEventDispatcherFactoryImplTest.java index 1ca1625cda..d3f9feacf3 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/events/CacheEventDispatcherFactoryImplTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/events/CacheEventDispatcherFactoryImplTest.java @@ -16,18 +16,18 @@ package org.ehcache.impl.internal.events; +import org.ehcache.core.spi.ServiceLocatorUtils; import org.ehcache.impl.config.event.DefaultCacheEventDispatcherConfiguration; import org.ehcache.core.events.CacheEventDispatcher; import org.ehcache.impl.events.CacheEventDispatcherImpl; -import org.ehcache.spi.service.ServiceProvider; import org.ehcache.core.spi.store.Store; import org.ehcache.core.spi.service.ExecutionService; -import org.ehcache.spi.service.Service; import org.junit.Test; import java.util.concurrent.BlockingQueue; import java.util.concurrent.ExecutorService; +import static org.ehcache.core.spi.ServiceLocatorUtils.withServiceLocator; import static org.ehcache.test.MockitoUtil.uncheckedGenericMock; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; @@ -45,53 +45,45 @@ public class CacheEventDispatcherFactoryImplTest { @Test - public void testConfigurationOfThreadPoolAlias() { - ServiceProvider serviceProvider = uncheckedGenericMock(ServiceProvider.class); - when(serviceProvider.getService(ExecutionService.class)).thenReturn(mock(ExecutionService.class)); - CacheEventDispatcherFactoryImpl factory = new CacheEventDispatcherFactoryImpl(); - factory.start(serviceProvider); - DefaultCacheEventDispatcherConfiguration config = spy(new DefaultCacheEventDispatcherConfiguration("aName")); - @SuppressWarnings("unchecked") - Store store = mock(Store.class); - factory.createCacheEventDispatcher(store, config); - verify(config).getThreadPoolAlias(); + public void testConfigurationOfThreadPoolAlias() throws Exception { + withServiceLocator(new CacheEventDispatcherFactoryImpl(), provider -> { + DefaultCacheEventDispatcherConfiguration config = spy(new DefaultCacheEventDispatcherConfiguration("aName")); + @SuppressWarnings("unchecked") + Store store = mock(Store.class); + provider.createCacheEventDispatcher(store, config); + verify(config).getThreadPoolAlias(); + }); } @Test @SuppressWarnings("unchecked") public void testCreateCacheEventDispatcherReturnsDisabledDispatcherWhenNoThreadPool() throws Exception { - ServiceProvider serviceProvider = mock(ServiceProvider.class); ExecutionService executionService = mock(ExecutionService.class); - when(serviceProvider.getService(ExecutionService.class)).thenReturn(executionService); when(executionService.getOrderedExecutor(eq("myAlias"), any(BlockingQueue.class))).thenThrow(IllegalArgumentException.class); when(executionService.getUnorderedExecutor(eq("myAlias"), any(BlockingQueue.class))).thenThrow(IllegalArgumentException.class); - CacheEventDispatcherFactoryImpl cacheEventDispatcherFactory = new CacheEventDispatcherFactoryImpl(); - cacheEventDispatcherFactory.start(serviceProvider); - - Store store = uncheckedGenericMock(Store.class); - try { - cacheEventDispatcherFactory.createCacheEventDispatcher(store, new DefaultCacheEventDispatcherConfiguration("myAlias")); - fail("expected IllegalArgumentException"); - } catch (IllegalArgumentException iae) { - // expected - } + withServiceLocator(new CacheEventDispatcherFactoryImpl(), deps -> deps.with(executionService), cacheEventDispatcherFactory -> { + Store store = uncheckedGenericMock(Store.class); + try { + cacheEventDispatcherFactory.createCacheEventDispatcher(store, new DefaultCacheEventDispatcherConfiguration("myAlias")); + fail("expected IllegalArgumentException"); + } catch (IllegalArgumentException iae) { + // expected + } + }); } @Test @SuppressWarnings("unchecked") public void testCreateCacheEventReturnsDisabledDispatcherWhenThreadPoolFound() throws Exception { - ServiceProvider serviceProvider = mock(ServiceProvider.class); ExecutionService executionService = mock(ExecutionService.class); - when(serviceProvider.getService(ExecutionService.class)).thenReturn(executionService); when(executionService.getOrderedExecutor(eq("myAlias"), any(BlockingQueue.class))).thenReturn(mock(ExecutorService.class)); when(executionService.getUnorderedExecutor(eq("myAlias"), any(BlockingQueue.class))).thenReturn(mock(ExecutorService.class)); - CacheEventDispatcherFactoryImpl cacheEventDispatcherFactory = new CacheEventDispatcherFactoryImpl(); - cacheEventDispatcherFactory.start(serviceProvider); - - Store store = mock(Store.class); - CacheEventDispatcher dispatcher = cacheEventDispatcherFactory.createCacheEventDispatcher(store, new DefaultCacheEventDispatcherConfiguration("myAlias")); - assertThat(dispatcher, instanceOf(CacheEventDispatcherImpl.class)); + withServiceLocator(new CacheEventDispatcherFactoryImpl(), deps -> deps.with(executionService), cacheEventDispatcherFactory -> { + Store store = mock(Store.class); + CacheEventDispatcher dispatcher = cacheEventDispatcherFactory.createCacheEventDispatcher(store, new DefaultCacheEventDispatcherConfiguration("myAlias")); + assertThat(dispatcher, instanceOf(CacheEventDispatcherImpl.class)); + }); } } diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/TestServiceProvider.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/TestServiceProvider.java index be3986a16d..c073547fc3 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/TestServiceProvider.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/TestServiceProvider.java @@ -33,6 +33,11 @@ public static ServiceProvider providerContaining(final Service... servi for (Service s : services) { servicesMap.put(s.getClass(), s); + for (Class service : s.getClass().getInterfaces()) { + if (!service.equals(Service.class) && Service.class.isAssignableFrom(service)) { + servicesMap.put(service.asSubclass(Service.class), s); + } + } } return new ServiceProvider() { diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/copy/DefaultCopyProviderTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/copy/DefaultCopyProviderTest.java index 6df730ed83..0514b9e4fd 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/copy/DefaultCopyProviderTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/copy/DefaultCopyProviderTest.java @@ -27,6 +27,7 @@ import java.io.Closeable; import java.io.IOException; +import static org.ehcache.core.spi.ServiceLocatorUtils.withServiceLocator; import static org.ehcache.test.MockitoUtil.uncheckedGenericMock; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.instanceOf; @@ -39,74 +40,78 @@ public class DefaultCopyProviderTest { @Test - public void testCreateKeyCopierWithCustomCopierConfig() { - DefaultCopyProvider provider = new DefaultCopyProvider(null); - - @SuppressWarnings("unchecked") - DefaultCopierConfiguration config = new DefaultCopierConfiguration( + public void testCreateKeyCopierWithCustomCopierConfig() throws Exception { + withServiceLocator(new DefaultCopyProvider(null), provider -> { + @SuppressWarnings("unchecked") + DefaultCopierConfiguration config = new DefaultCopierConfiguration( (Class)TestCopier.class, DefaultCopierConfiguration.Type.KEY); - assertThat(provider.createKeyCopier(Long.class, null, config), instanceOf(TestCopier.class)); + assertThat(provider.createKeyCopier(Long.class, null, config), instanceOf(TestCopier.class)); + }); } @Test - public void testCreateKeyCopierWithoutConfig() { - DefaultCopyProvider provider = new DefaultCopyProvider(null); + public void testCreateKeyCopierWithoutConfig() throws Exception { + withServiceLocator(new DefaultCopyProvider(null), provider -> { - assertThat(provider.createKeyCopier(Long.class, null), instanceOf(IdentityCopier.class)); + assertThat(provider.createKeyCopier(Long.class, null), instanceOf(IdentityCopier.class)); + }); } @Test - public void testCreateKeyCopierWithSerializer() { - DefaultCopyProvider copyProvider = new DefaultCopyProvider(null); - DefaultCopierConfiguration config = new DefaultCopierConfiguration<>( - SerializingCopier.asCopierClass(), DefaultCopierConfiguration.Type.KEY); - - Serializer serializer = uncheckedGenericMock(Serializer.class); - assertThat(copyProvider.createKeyCopier(Long.class, serializer, config), instanceOf(SerializingCopier.class)); + public void testCreateKeyCopierWithSerializer() throws Exception { + withServiceLocator(new DefaultCopyProvider(null), provider -> { + DefaultCopierConfiguration config = new DefaultCopierConfiguration<>( + SerializingCopier.asCopierClass(), DefaultCopierConfiguration.Type.KEY); + + Serializer serializer = uncheckedGenericMock(Serializer.class); + assertThat(provider.createKeyCopier(Long.class, serializer, config), instanceOf(SerializingCopier.class)); + }); } @Test - public void testCreateValueCopierWithCustomCopierConfig() { - DefaultCopyProvider provider = new DefaultCopyProvider(null); - - @SuppressWarnings("unchecked") - DefaultCopierConfiguration config = new DefaultCopierConfiguration( - (Class)TestCopier.class, DefaultCopierConfiguration.Type.VALUE); - - assertThat(provider.createValueCopier(Long.class, null, config), instanceOf(TestCopier.class)); + public void testCreateValueCopierWithCustomCopierConfig() throws Exception { + withServiceLocator(new DefaultCopyProvider(null), provider -> { + @SuppressWarnings("unchecked") + DefaultCopierConfiguration config = new DefaultCopierConfiguration( + (Class) TestCopier.class, DefaultCopierConfiguration.Type.VALUE); + + assertThat(provider.createValueCopier(Long.class, null, config), instanceOf(TestCopier.class)); + }); } @Test - public void testCreateValueCopierWithoutConfig() { - DefaultCopyProvider provider = new DefaultCopyProvider(null); - - assertThat(provider.createValueCopier(Long.class, null), instanceOf(IdentityCopier.class)); + public void testCreateValueCopierWithoutConfig() throws Exception { + withServiceLocator(new DefaultCopyProvider(null), provider -> { + assertThat(provider.createValueCopier(Long.class, null), instanceOf(IdentityCopier.class)); + }); } @Test - public void testCreateValueCopierWithSerializer() { - DefaultCopyProvider copyProvider = new DefaultCopyProvider(null); - DefaultCopierConfiguration config = new DefaultCopierConfiguration<>( - SerializingCopier.asCopierClass(), DefaultCopierConfiguration.Type.VALUE); + public void testCreateValueCopierWithSerializer() throws Exception { + withServiceLocator(new DefaultCopyProvider(null), provider -> { + DefaultCopierConfiguration config = new DefaultCopierConfiguration<>( + SerializingCopier.asCopierClass(), DefaultCopierConfiguration.Type.VALUE); + + Serializer serializer = uncheckedGenericMock(Serializer.class); + assertThat(provider.createValueCopier(Long.class, serializer, config), instanceOf(SerializingCopier.class)); + }); - Serializer serializer = uncheckedGenericMock(Serializer.class); - assertThat(copyProvider.createValueCopier(Long.class, serializer, config), instanceOf(SerializingCopier.class)); } @Test public void testUserProvidedCloseableCopierInstanceDoesNotCloseOnRelease() throws Exception { - DefaultCopyProvider copyProvider = new DefaultCopyProvider(null); - TestCloseableCopier testCloseableCopier = new TestCloseableCopier<>(); - DefaultCopierConfiguration config = new DefaultCopierConfiguration<>(testCloseableCopier, DefaultCopierConfiguration.Type.KEY); - - Serializer serializer = uncheckedGenericMock(Serializer.class); - assertThat(copyProvider.createKeyCopier(Long.class, serializer, config), sameInstance((Copier)testCloseableCopier)); + withServiceLocator(new DefaultCopyProvider(null), provider -> { + TestCloseableCopier testCloseableCopier = new TestCloseableCopier<>(); + DefaultCopierConfiguration config = new DefaultCopierConfiguration<>(testCloseableCopier, DefaultCopierConfiguration.Type.KEY); - copyProvider.releaseCopier(testCloseableCopier); + Serializer serializer = uncheckedGenericMock(Serializer.class); + assertThat(provider.createKeyCopier(Long.class, serializer, config), sameInstance((Copier) testCloseableCopier)); - assertFalse(testCloseableCopier.isInvoked()); + provider.releaseCopier(testCloseableCopier); + assertFalse(testCloseableCopier.isInvoked()); + }); } private static class TestCloseableCopier extends ReadWriteCopier implements Closeable { diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/loaderwriter/DefaultCacheLoaderWriterProviderTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/loaderwriter/DefaultCacheLoaderWriterProviderTest.java index 3822961501..22b69bc080 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/loaderwriter/DefaultCacheLoaderWriterProviderTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/loaderwriter/DefaultCacheLoaderWriterProviderTest.java @@ -24,8 +24,6 @@ import org.ehcache.config.builders.CacheManagerBuilder; import org.ehcache.impl.config.loaderwriter.DefaultCacheLoaderWriterConfiguration; import org.ehcache.impl.config.loaderwriter.DefaultCacheLoaderWriterProviderConfiguration; -import org.ehcache.spi.service.Service; -import org.ehcache.spi.service.ServiceProvider; import org.ehcache.spi.loaderwriter.CacheLoaderWriter; import org.ehcache.spi.service.ServiceConfiguration; import org.junit.Test; @@ -35,6 +33,7 @@ import java.util.Map; import static org.ehcache.config.builders.ResourcePoolsBuilder.heap; +import static org.ehcache.core.spi.ServiceLocatorUtils.withServiceLocator; import static org.ehcache.test.MockitoUtil.uncheckedGenericMock; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.MatcherAssert.assertThat; @@ -103,20 +102,20 @@ public void testAddingCacheLoaderWriterConfigurationAtCacheLevel() { } @Test - public void testCreationConfigurationPreservedAfterStopStart() { + public void testCreationConfigurationPreservedAfterStopStart() throws Exception { DefaultCacheLoaderWriterProviderConfiguration configuration = new DefaultCacheLoaderWriterProviderConfiguration(); configuration.addLoaderFor("cache", MyLoader.class); - DefaultCacheLoaderWriterProvider loaderWriterProvider = new DefaultCacheLoaderWriterProvider(configuration); - ServiceProvider serviceProvider = uncheckedGenericMock(ServiceProvider.class); - loaderWriterProvider.start(serviceProvider); CacheConfiguration cacheConfiguration = uncheckedGenericMock(CacheConfiguration.class); - assertThat(loaderWriterProvider.createCacheLoaderWriter("cache", cacheConfiguration), instanceOf(MyLoader.class)); - loaderWriterProvider.stop(); - loaderWriterProvider.start(serviceProvider); + DefaultCacheLoaderWriterProvider service = new DefaultCacheLoaderWriterProvider(configuration); + withServiceLocator(service, provider -> { + assertThat(provider.createCacheLoaderWriter("cache", cacheConfiguration), instanceOf(MyLoader.class)); + }); - assertThat(loaderWriterProvider.createCacheLoaderWriter("cache", cacheConfiguration), instanceOf(MyLoader.class)); + withServiceLocator(service, provider -> { + assertThat(provider.createCacheLoaderWriter("cache", cacheConfiguration), instanceOf(MyLoader.class)); + }); } public static class MyLoader implements CacheLoaderWriter { diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProviderFactoryTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProviderFactoryTest.java index cff4419eb3..c0ab9d2905 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProviderFactoryTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProviderFactoryTest.java @@ -23,6 +23,7 @@ import org.ehcache.spi.service.ServiceCreationConfiguration; import org.junit.Test; +import static org.ehcache.core.spi.ServiceLocatorUtils.withServiceLocator; import static org.ehcache.test.MockitoUtil.uncheckedGenericMock; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.notNullValue; @@ -33,9 +34,10 @@ public class DefaultResilienceStrategyProviderFactoryTest { @Test - public void testNullGivesValidFactory() { - ResilienceStrategyProvider provider = new DefaultResilienceStrategyProviderFactory().create(null); - assertThat(provider.createResilienceStrategy("test", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class)), notNullValue()); + public void testNullGivesValidFactory() throws Exception { + withServiceLocator(new DefaultResilienceStrategyProviderFactory().create(null), provider -> { + assertThat(provider.createResilienceStrategy("test", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class)), notNullValue()); + }); } @Test diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProviderTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProviderTest.java index f76e2c404b..ec7be2c58a 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProviderTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/resilience/DefaultResilienceStrategyProviderTest.java @@ -26,6 +26,7 @@ import java.util.Collections; +import static org.ehcache.core.spi.ServiceLocatorUtils.withServiceLocator; import static org.hamcrest.MatcherAssert.assertThat; import static org.ehcache.test.MockitoUtil.uncheckedGenericMock; import static org.hamcrest.Matchers.instanceOf; @@ -37,152 +38,156 @@ public class DefaultResilienceStrategyProviderTest { @Test - public void testDefaultInstanceReturned() { + public void testDefaultInstanceReturned() throws Exception { ResilienceStrategy resilienceStrategy = mock(ResilienceStrategy.class); DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); configuration.setDefaultResilienceStrategy(resilienceStrategy); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - - assertThat(provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class)), sameInstance(resilienceStrategy)); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + assertThat(provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class)), sameInstance(resilienceStrategy)); + }); } @Test - public void testDefaultLoaderWriterInstanceReturned() { + public void testDefaultLoaderWriterInstanceReturned() throws Exception { ResilienceStrategy resilienceStrategy = mock(ResilienceStrategy.class); DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); configuration.setDefaultLoaderWriterResilienceStrategy(resilienceStrategy); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - - assertThat(provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)), sameInstance(resilienceStrategy)); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + assertThat(provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)), sameInstance(resilienceStrategy)); + }); } @Test - public void testDefaultInstanceConstructed() { + public void testDefaultInstanceConstructed() throws Exception { DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); configuration.setDefaultResilienceStrategy(TestResilienceStrategy.class, "FooBar"); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - - ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class)); - assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); - assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class)); + assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); + assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + }); } @Test - public void testDefaultLoaderWriterInstanceConstructed() { + public void testDefaultLoaderWriterInstanceConstructed() throws Exception { DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); configuration.setDefaultLoaderWriterResilienceStrategy(TestResilienceStrategy.class, "FooBar"); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - - ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)); - assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); - assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)); + assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); + assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + }); } @Test - public void testPreconfiguredInstanceReturned() { + public void testPreconfiguredInstanceReturned() throws Exception { ResilienceStrategy resilienceStrategy = mock(ResilienceStrategy.class); DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); configuration.addResilienceStrategyFor("foo", resilienceStrategy); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - - assertThat(provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class)), sameInstance(resilienceStrategy)); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + assertThat(provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class)), sameInstance(resilienceStrategy)); + }); } @Test - public void testPreconfiguredLoaderWriterInstanceReturned() { + public void testPreconfiguredLoaderWriterInstanceReturned() throws Exception { ResilienceStrategy resilienceStrategy = mock(ResilienceStrategy.class); DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); configuration.addResilienceStrategyFor("foo", resilienceStrategy); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - - assertThat(provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)), sameInstance(resilienceStrategy)); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + assertThat(provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)), sameInstance(resilienceStrategy)); + }); } @Test - public void testPreconfiguredInstanceConstructed() { + public void testPreconfiguredInstanceConstructed() throws Exception { DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); configuration.addResilienceStrategyFor("foo", TestResilienceStrategy.class, "FooBar"); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - - ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class)); - assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); - assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class)); + assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); + assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + }); } @Test - public void testPreconfiguredLoaderWriterInstanceConstructed() { + public void testPreconfiguredLoaderWriterInstanceConstructed() throws Exception { DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); configuration.addResilienceStrategyFor("foo", TestResilienceStrategy.class, "FooBar"); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - - ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)); - assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); - assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", uncheckedGenericMock(CacheConfiguration.class), uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)); + assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); + assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + }); } @Test - public void testProvidedInstanceReturned() { + public void testProvidedInstanceReturned() throws Exception { ResilienceStrategy resilienceStrategy = mock(ResilienceStrategy.class); DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - CacheConfiguration cacheConfiguration = mock(CacheConfiguration.class); - when(cacheConfiguration.getServiceConfigurations()).thenReturn(Collections.singleton(new DefaultResilienceStrategyConfiguration(resilienceStrategy))); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + CacheConfiguration cacheConfiguration = mock(CacheConfiguration.class); + when(cacheConfiguration.getServiceConfigurations()).thenReturn(Collections.singleton(new DefaultResilienceStrategyConfiguration(resilienceStrategy))); - assertThat(provider.createResilienceStrategy("foo", cacheConfiguration, uncheckedGenericMock(RecoveryStore.class)), sameInstance(resilienceStrategy)); + assertThat(provider.createResilienceStrategy("foo", cacheConfiguration, uncheckedGenericMock(RecoveryStore.class)), sameInstance(resilienceStrategy)); + }); } @Test - public void testProvidedLoaderWriterInstanceReturned() { + public void testProvidedLoaderWriterInstanceReturned() throws Exception { ResilienceStrategy resilienceStrategy = mock(ResilienceStrategy.class); DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - CacheConfiguration cacheConfiguration = mock(CacheConfiguration.class); - when(cacheConfiguration.getServiceConfigurations()).thenReturn(Collections.singleton(new DefaultResilienceStrategyConfiguration(resilienceStrategy))); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + CacheConfiguration cacheConfiguration = mock(CacheConfiguration.class); + when(cacheConfiguration.getServiceConfigurations()).thenReturn(Collections.singleton(new DefaultResilienceStrategyConfiguration(resilienceStrategy))); - assertThat(provider.createResilienceStrategy("foo", cacheConfiguration, uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)), sameInstance(resilienceStrategy)); + assertThat(provider.createResilienceStrategy("foo", cacheConfiguration, uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)), sameInstance(resilienceStrategy)); + }); } @Test - public void testProvidedInstanceConstructed() { + public void testProvidedInstanceConstructed() throws Exception { DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - CacheConfiguration cacheConfiguration = mock(CacheConfiguration.class); - when(cacheConfiguration.getServiceConfigurations()).thenReturn(Collections.singleton(new DefaultResilienceStrategyConfiguration(TestResilienceStrategy.class, "FooBar"))); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + CacheConfiguration cacheConfiguration = mock(CacheConfiguration.class); + when(cacheConfiguration.getServiceConfigurations()).thenReturn(Collections.singleton(new DefaultResilienceStrategyConfiguration(TestResilienceStrategy.class, "FooBar"))); - ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", cacheConfiguration, uncheckedGenericMock(RecoveryStore.class)); - assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); - assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", cacheConfiguration, uncheckedGenericMock(RecoveryStore.class)); + assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); + assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + }); } @Test - public void testProvidedLoaderWriterInstanceConstructed() { + public void testProvidedLoaderWriterInstanceConstructed() throws Exception { DefaultResilienceStrategyProviderConfiguration configuration = new DefaultResilienceStrategyProviderConfiguration(); - DefaultResilienceStrategyProvider provider = new DefaultResilienceStrategyProvider(configuration); - CacheConfiguration cacheConfiguration = mock(CacheConfiguration.class); - when(cacheConfiguration.getServiceConfigurations()).thenReturn(Collections.singleton(new DefaultResilienceStrategyConfiguration(TestResilienceStrategy.class, "FooBar"))); + withServiceLocator(new DefaultResilienceStrategyProvider(configuration), provider -> { + CacheConfiguration cacheConfiguration = mock(CacheConfiguration.class); + when(cacheConfiguration.getServiceConfigurations()).thenReturn(Collections.singleton(new DefaultResilienceStrategyConfiguration(TestResilienceStrategy.class, "FooBar"))); - ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", cacheConfiguration, uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)); - assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); - assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + ResilienceStrategy resilienceStrategy = provider.createResilienceStrategy("foo", cacheConfiguration, uncheckedGenericMock(RecoveryStore.class), uncheckedGenericMock(CacheLoaderWriter.class)); + assertThat(resilienceStrategy, instanceOf(TestResilienceStrategy.class)); + assertThat(((TestResilienceStrategy) resilienceStrategy).message, is("FooBar")); + }); } public static class TestResilienceStrategy extends RobustResilienceStrategy { diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/serialization/DefaultSerializationProviderTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/serialization/DefaultSerializationProviderTest.java index 9fd2d39f41..630d2bfe3b 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/serialization/DefaultSerializationProviderTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/spi/serialization/DefaultSerializationProviderTest.java @@ -15,9 +15,10 @@ */ package org.ehcache.impl.internal.spi.serialization; -import org.ehcache.CachePersistenceException; +import org.ehcache.core.spi.ServiceLocatorUtils; import org.ehcache.core.spi.service.DiskResourceService; import org.ehcache.core.spi.service.FileBasedPersistenceContext; +import org.ehcache.core.spi.service.InstantiatorService; import org.ehcache.impl.config.serializer.DefaultSerializationProviderConfiguration; import org.ehcache.impl.config.serializer.DefaultSerializerConfiguration; import org.ehcache.impl.serialization.ByteArraySerializer; @@ -34,8 +35,6 @@ import org.ehcache.spi.serialization.SerializerException; import org.ehcache.spi.serialization.StatefulSerializer; import org.ehcache.spi.serialization.UnsupportedTypeException; -import org.ehcache.spi.service.Service; -import org.ehcache.spi.service.ServiceProvider; import org.hamcrest.Matchers; import org.junit.Rule; import org.junit.Test; @@ -49,9 +48,10 @@ import java.util.concurrent.atomic.AtomicInteger; import static java.lang.ClassLoader.getSystemClassLoader; -import static org.ehcache.impl.internal.spi.TestServiceProvider.providerContaining; +import static org.ehcache.core.spi.ServiceLocatorUtils.withServiceLocator; import static org.ehcache.test.MockitoUtil.uncheckedGenericMock; import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsString; import static org.hamcrest.Matchers.endsWith; import static org.hamcrest.Matchers.hasProperty; import static org.hamcrest.Matchers.instanceOf; @@ -76,28 +76,26 @@ public class DefaultSerializationProviderTest { @Test public void testCreateSerializerNoConfig() throws Exception { DefaultSerializationProviderConfiguration dspfConfig = new DefaultSerializationProviderConfiguration(); - DefaultSerializationProvider dsp = new DefaultSerializationProvider(dspfConfig); - dsp.start(providerContaining()); - - assertThat(dsp.createValueSerializer(HashMap.class, ClassLoader.getSystemClassLoader()), instanceOf(CompactJavaSerializer.class)); - try { - dsp.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader()); - fail("expected UnsupportedTypeException"); - } catch (UnsupportedTypeException ute) { - // expected - } + withServiceLocator(new DefaultSerializationProvider(dspfConfig), locator -> locator.with(InstantiatorService.class), dsp -> { + assertThat(dsp.createValueSerializer(HashMap.class, ClassLoader.getSystemClassLoader()), instanceOf(CompactJavaSerializer.class)); + try { + dsp.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader()); + fail("expected UnsupportedTypeException"); + } catch (UnsupportedTypeException ute) { + // expected + } + }); } @Test public void testCreateSerializerWithConfig() throws Exception { DefaultSerializationProviderConfiguration dspfConfig = new DefaultSerializationProviderConfiguration(); - DefaultSerializationProvider dsp = new DefaultSerializationProvider(dspfConfig); - dsp.start(providerContaining()); - - DefaultSerializerConfiguration dspConfig = new DefaultSerializerConfiguration<>(getSerializerClass(), DefaultSerializerConfiguration.Type.VALUE); + withServiceLocator(new DefaultSerializationProvider(dspfConfig), locator -> locator.with(InstantiatorService.class), dsp -> { + DefaultSerializerConfiguration dspConfig = new DefaultSerializerConfiguration<>(getSerializerClass(), DefaultSerializerConfiguration.Type.VALUE); - assertThat(dsp.createValueSerializer(String.class, ClassLoader.getSystemClassLoader(), dspConfig), instanceOf(TestSerializer.class)); - assertThat(dsp.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), dspConfig), instanceOf(TestSerializer.class)); + assertThat(dsp.createValueSerializer(String.class, ClassLoader.getSystemClassLoader(), dspConfig), instanceOf(TestSerializer.class)); + assertThat(dsp.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), dspConfig), instanceOf(TestSerializer.class)); + }); } @Test @@ -105,11 +103,10 @@ public void testCreateSerializerWithFactoryConfig() throws Exception { DefaultSerializationProviderConfiguration dspfConfig = new DefaultSerializationProviderConfiguration(); Class> serializerClass = getSerializerClass(); dspfConfig.addSerializerFor(Long.class, serializerClass); - DefaultSerializationProvider dsp = new DefaultSerializationProvider(dspfConfig); - dsp.start(providerContaining()); - - assertThat(dsp.createValueSerializer(Long.class, ClassLoader.getSystemClassLoader()), instanceOf(TestSerializer.class)); - assertThat(dsp.createValueSerializer(HashMap.class, ClassLoader.getSystemClassLoader()), instanceOf(CompactJavaSerializer.class)); + withServiceLocator(new DefaultSerializationProvider(dspfConfig), locator -> locator.with(InstantiatorService.class), dsp -> { + assertThat(dsp.createValueSerializer(Long.class, ClassLoader.getSystemClassLoader()), instanceOf(TestSerializer.class)); + assertThat(dsp.createValueSerializer(HashMap.class, ClassLoader.getSystemClassLoader()), instanceOf(CompactJavaSerializer.class)); + }); } @SuppressWarnings("unchecked") @@ -123,12 +120,11 @@ public void testCreateTransientSerializers() throws Exception { Class> serializerClass = getSerializerClass(); dspfConfig.addSerializerFor(String.class, serializerClass); - DefaultSerializationProvider dsp = new DefaultSerializationProvider(dspfConfig); - dsp.start(providerContaining()); - - assertThat(dsp.createKeySerializer(String.class, getSystemClassLoader()), instanceOf(TestSerializer.class)); - assertThat(dsp.createKeySerializer(Serializable.class, getSystemClassLoader()), instanceOf(CompactJavaSerializer.class)); - assertThat(dsp.createKeySerializer(Integer.class, getSystemClassLoader()), instanceOf(IntegerSerializer.class)); + withServiceLocator(new DefaultSerializationProvider(dspfConfig), locator -> locator.with(InstantiatorService.class), dsp -> { + assertThat(dsp.createKeySerializer(String.class, getSystemClassLoader()), instanceOf(TestSerializer.class)); + assertThat(dsp.createKeySerializer(Serializable.class, getSystemClassLoader()), instanceOf(CompactJavaSerializer.class)); + assertThat(dsp.createKeySerializer(Integer.class, getSystemClassLoader()), instanceOf(IntegerSerializer.class)); + }); } @Test @@ -137,26 +133,25 @@ public void tesCreateTransientSerializersWithOverriddenSerializableType() throws Class> serializerClass = getSerializerClass(); dspfConfig.addSerializerFor(Serializable.class, serializerClass); - DefaultSerializationProvider dsp = new DefaultSerializationProvider(dspfConfig); - dsp.start(providerContaining()); - - assertThat(dsp.createKeySerializer(HashMap.class, getSystemClassLoader()), instanceOf(TestSerializer.class)); - assertThat(dsp.createKeySerializer(Serializable.class, getSystemClassLoader()), instanceOf(TestSerializer.class)); - assertThat(dsp.createKeySerializer(Integer.class, getSystemClassLoader()), instanceOf(IntegerSerializer.class)); + withServiceLocator(new DefaultSerializationProvider(dspfConfig), locator -> locator.with(InstantiatorService.class), dsp -> { + assertThat(dsp.createKeySerializer(HashMap.class, getSystemClassLoader()), instanceOf(TestSerializer.class)); + assertThat(dsp.createKeySerializer(Serializable.class, getSystemClassLoader()), instanceOf(TestSerializer.class)); + assertThat(dsp.createKeySerializer(Integer.class, getSystemClassLoader()), instanceOf(IntegerSerializer.class)); + }); } @Test - public void testRemembersCreationConfigurationAfterStopStart() throws UnsupportedTypeException { + public void testRemembersCreationConfigurationAfterStopStart() throws Exception { DefaultSerializationProviderConfiguration configuration = new DefaultSerializationProviderConfiguration(); Class> serializerClass = getSerializerClass(); configuration.addSerializerFor(String.class, serializerClass); - DefaultSerializationProvider serializationProvider = new DefaultSerializationProvider(configuration); - ServiceProvider serviceProvider = uncheckedGenericMock(ServiceProvider.class); - serializationProvider.start(serviceProvider); - assertThat(serializationProvider.createKeySerializer(String.class, getSystemClassLoader()), instanceOf(TestSerializer.class)); - serializationProvider.stop(); - serializationProvider.start(serviceProvider); - assertThat(serializationProvider.createKeySerializer(String.class, getSystemClassLoader()), instanceOf(TestSerializer.class)); + DefaultSerializationProvider provider = new DefaultSerializationProvider(configuration); + withServiceLocator(provider, locator -> locator.with(InstantiatorService.class), serializationProvider -> { + assertThat(serializationProvider.createKeySerializer(String.class, getSystemClassLoader()), instanceOf(TestSerializer.class)); + }); + withServiceLocator(provider, locator -> locator.with(InstantiatorService.class), serializationProvider -> { + assertThat(serializationProvider.createKeySerializer(String.class, getSystemClassLoader()), instanceOf(TestSerializer.class)); + }); } @Test @@ -174,11 +169,12 @@ public void testReleaseSerializerWithInstantiatedCloseableSerializerDoesClose() @SuppressWarnings("unchecked") Class> serializerClass = (Class) CloseableSerializer.class; DefaultSerializerConfiguration config = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.KEY); - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - Serializer serializer = provider.createKeySerializer(String.class, getSystemClassLoader(), config); + withServiceLocator(new DefaultSerializationProvider(null), locator -> locator.with(InstantiatorService.class), provider -> { + Serializer serializer = provider.createKeySerializer(String.class, getSystemClassLoader(), config); - provider.releaseSerializer(serializer); - assertTrue(((CloseableSerializer)serializer).closed); + provider.releaseSerializer(serializer); + assertTrue(((CloseableSerializer) serializer).closed); + }); } @Test(expected = IllegalArgumentException.class) @@ -225,304 +221,299 @@ public void testSameInstanceRetrievedMultipleTimesUpdatesTheProvidedCount() thro @Test public void testDefaultSerializableSerializer() throws Exception { - DefaultSerializationProvider provider = getStartedProvider(); - Serializer keySerializer = provider.createKeySerializer(Serializable.class, getSystemClassLoader()); - assertThat(keySerializer, instanceOf(CompactJavaSerializer.class)); + withPersistentProvider(provider -> { + Serializer keySerializer = provider.createKeySerializer(Serializable.class, getSystemClassLoader()); + assertThat(keySerializer, instanceOf(CompactJavaSerializer.class)); - keySerializer = provider.createKeySerializer(Serializable.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); - assertThat(keySerializer, instanceOf(CompactJavaSerializer.class)); + keySerializer = provider.createKeySerializer(Serializable.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); + assertThat(keySerializer, instanceOf(CompactJavaSerializer.class)); + }); } @Test public void testDefaultStringSerializer() throws Exception { - DefaultSerializationProvider provider = getStartedProvider(); - Serializer keySerializer = provider.createKeySerializer(String.class, getSystemClassLoader()); - assertThat(keySerializer, instanceOf(StringSerializer.class)); + withPersistentProvider(provider -> { + Serializer keySerializer = provider.createKeySerializer(String.class, getSystemClassLoader()); + assertThat(keySerializer, instanceOf(StringSerializer.class)); - keySerializer = provider.createKeySerializer(String.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); - assertThat(keySerializer, instanceOf(StringSerializer.class)); + keySerializer = provider.createKeySerializer(String.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); + assertThat(keySerializer, instanceOf(StringSerializer.class)); + }); } @Test public void testDefaultIntegerSerializer() throws Exception { - DefaultSerializationProvider provider = getStartedProvider(); - Serializer keySerializer = provider.createKeySerializer(Integer.class, getSystemClassLoader()); - assertThat(keySerializer, instanceOf(IntegerSerializer.class)); + withPersistentProvider(provider -> { + Serializer keySerializer = provider.createKeySerializer(Integer.class, getSystemClassLoader()); + assertThat(keySerializer, instanceOf(IntegerSerializer.class)); - keySerializer = provider.createKeySerializer(Integer.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); - assertThat(keySerializer, instanceOf(IntegerSerializer.class)); + keySerializer = provider.createKeySerializer(Integer.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); + assertThat(keySerializer, instanceOf(IntegerSerializer.class)); + }); } @Test public void testDefaultLongSerializer() throws Exception { - DefaultSerializationProvider provider = getStartedProvider(); - Serializer keySerializer = provider.createKeySerializer(Long.class, getSystemClassLoader()); - assertThat(keySerializer, instanceOf(LongSerializer.class)); + withPersistentProvider(provider -> { + Serializer keySerializer = provider.createKeySerializer(Long.class, getSystemClassLoader()); + assertThat(keySerializer, instanceOf(LongSerializer.class)); - keySerializer = provider.createKeySerializer(Long.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); - assertThat(keySerializer, instanceOf(LongSerializer.class)); + keySerializer = provider.createKeySerializer(Long.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); + assertThat(keySerializer, instanceOf(LongSerializer.class)); + }); } @Test public void testDefaultCharSerializer() throws Exception { - DefaultSerializationProvider provider = getStartedProvider(); - Serializer keySerializer = provider.createKeySerializer(Character.class, getSystemClassLoader()); - assertThat(keySerializer, instanceOf(CharSerializer.class)); + withPersistentProvider(provider -> { + Serializer keySerializer = provider.createKeySerializer(Character.class, getSystemClassLoader()); + assertThat(keySerializer, instanceOf(CharSerializer.class)); - keySerializer = provider.createKeySerializer(Character.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); - assertThat(keySerializer, instanceOf(CharSerializer.class)); + keySerializer = provider.createKeySerializer(Character.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); + assertThat(keySerializer, instanceOf(CharSerializer.class)); + }); } @Test public void testDefaultDoubleSerializer() throws Exception { - DefaultSerializationProvider provider = getStartedProvider(); - Serializer keySerializer = provider.createKeySerializer(Double.class, getSystemClassLoader()); - assertThat(keySerializer, instanceOf(DoubleSerializer.class)); + withPersistentProvider(provider -> { + Serializer keySerializer = provider.createKeySerializer(Double.class, getSystemClassLoader()); + assertThat(keySerializer, instanceOf(DoubleSerializer.class)); - keySerializer = provider.createKeySerializer(Double.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); - assertThat(keySerializer, instanceOf(DoubleSerializer.class)); + keySerializer = provider.createKeySerializer(Double.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); + assertThat(keySerializer, instanceOf(DoubleSerializer.class)); + }); } @Test public void testDefaultFloatSerializer() throws Exception { - DefaultSerializationProvider provider = getStartedProvider(); - Serializer keySerializer = provider.createKeySerializer(Float.class, getSystemClassLoader()); - assertThat(keySerializer, instanceOf(FloatSerializer.class)); + withPersistentProvider(provider -> { + Serializer keySerializer = provider.createKeySerializer(Float.class, getSystemClassLoader()); + assertThat(keySerializer, instanceOf(FloatSerializer.class)); - keySerializer = provider.createKeySerializer(Float.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); - assertThat(keySerializer, instanceOf(FloatSerializer.class)); + keySerializer = provider.createKeySerializer(Float.class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); + assertThat(keySerializer, instanceOf(FloatSerializer.class)); + }); } @Test public void testDefaultByteArraySerializer() throws Exception { - DefaultSerializationProvider provider = getStartedProvider(); - Serializer keySerializer = provider.createKeySerializer(byte[].class, getSystemClassLoader()); - assertThat(keySerializer, instanceOf(ByteArraySerializer.class)); + withPersistentProvider(provider -> { + Serializer keySerializer = provider.createKeySerializer(byte[].class, getSystemClassLoader()); + assertThat(keySerializer, instanceOf(ByteArraySerializer.class)); - keySerializer = provider.createKeySerializer(byte[].class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); - assertThat(keySerializer, instanceOf(ByteArraySerializer.class)); + keySerializer = provider.createKeySerializer(byte[].class, getSystemClassLoader(), getPersistenceSpaceIdentifierMock()); + assertThat(keySerializer, instanceOf(ByteArraySerializer.class)); + }); } @Test public void testCreateTransientSerializerWithoutConstructor() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) BaseSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration)); - assertThat(thrown, hasProperty("message", endsWith("does not have a constructor that takes in a ClassLoader."))); + withServiceLocator(new DefaultSerializationProvider(null), provider -> { + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) BaseSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration)); + assertThat(thrown, hasProperty("message", containsString("java.lang.NoSuchMethodException"))); + }); } @Test public void testCreatePersistentSerializerWithoutConstructor() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) BaseSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock())); - assertThat(thrown, hasProperty("message", endsWith("does not have a constructor that takes in a ClassLoader."))); + withServiceLocator(new DefaultSerializationProvider(null), provider -> { + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) BaseSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock())); + assertThat(thrown, hasProperty("message", containsString("java.lang.NoSuchMethodException"))); + }); } @Test public void testCreateTransientStatefulSerializerWithoutConstructor() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) StatefulBaseSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration)); - assertThat(thrown, hasProperty("message", endsWith("does not have a constructor that takes in a ClassLoader."))); + withServiceLocator(new DefaultSerializationProvider(null), locator -> locator.with(InstantiatorService.class), provider -> { + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) StatefulBaseSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration)); + assertThat(thrown, hasProperty("message", containsString("java.lang.NoSuchMethodException"))); + }); } @Test public void testCreatePersistentStatefulSerializerWithoutConstructor() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) StatefulBaseSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock())); - assertThat(thrown, hasProperty("message", endsWith("does not have a constructor that takes in a ClassLoader."))); + withServiceLocator(new DefaultSerializationProvider(null), locator -> locator.with(InstantiatorService.class), provider -> { + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) StatefulBaseSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock())); + assertThat(thrown, hasProperty("message", containsString("java.lang.NoSuchMethodException"))); + }); } @Test public void testCreateTransientMinimalSerializer() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - MinimalSerializer.baseConstructorInvoked = false; - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) MinimalSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - Serializer valueSerializer = - provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration); - assertThat(valueSerializer, instanceOf(MinimalSerializer.class)); - assertThat(MinimalSerializer.baseConstructorInvoked, is(true)); + withServiceLocator(new DefaultSerializationProvider(null), locator -> locator.with(InstantiatorService.class), provider -> { + MinimalSerializer.baseConstructorInvoked = false; + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) MinimalSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + Serializer valueSerializer = + provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration); + assertThat(valueSerializer, instanceOf(MinimalSerializer.class)); + assertThat(MinimalSerializer.baseConstructorInvoked, is(true)); + }); } @Test public void testCreatePersistentMinimalSerializer() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - MinimalSerializer.baseConstructorInvoked = false; - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) MinimalSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - Serializer valueSerializer = - provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock()); - assertThat(valueSerializer, instanceOf(MinimalSerializer.class)); - assertThat(MinimalSerializer.baseConstructorInvoked, is(true)); + withServiceLocator(new DefaultSerializationProvider(null), provider -> { + MinimalSerializer.baseConstructorInvoked = false; + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) MinimalSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + Serializer valueSerializer = + provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock()); + assertThat(valueSerializer, instanceOf(MinimalSerializer.class)); + assertThat(MinimalSerializer.baseConstructorInvoked, is(true)); + }); } @Test public void testTransientMinimalStatefulSerializer() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - MinimalStatefulSerializer.baseConstructorInvoked = false; - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) MinimalStatefulSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - Serializer valueSerializer = - provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration); - assertThat(valueSerializer, instanceOf(MinimalStatefulSerializer.class)); - assertThat(MinimalStatefulSerializer.baseConstructorInvoked, is(true)); + withServiceLocator(new DefaultSerializationProvider(null), provider -> { + MinimalStatefulSerializer.baseConstructorInvoked = false; + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) MinimalStatefulSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + Serializer valueSerializer = + provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration); + assertThat(valueSerializer, instanceOf(MinimalStatefulSerializer.class)); + assertThat(MinimalStatefulSerializer.baseConstructorInvoked, is(true)); + }); } @Test public void testPersistentMinimalStatefulSerializer() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - MinimalStatefulSerializer.baseConstructorInvoked = false; - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) MinimalStatefulSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - Serializer valueSerializer = - provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock()); - assertThat(valueSerializer, instanceOf(MinimalStatefulSerializer.class)); - assertThat(MinimalStatefulSerializer.baseConstructorInvoked, is(true)); + withServiceLocator(new DefaultSerializationProvider(null), provider -> { + MinimalStatefulSerializer.baseConstructorInvoked = false; + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) MinimalStatefulSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + Serializer valueSerializer = + provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock()); + assertThat(valueSerializer, instanceOf(MinimalStatefulSerializer.class)); + assertThat(MinimalStatefulSerializer.baseConstructorInvoked, is(true)); + }); } @Test public void testTransientLegacySerializer() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) LegacySerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration)); - assertThat(thrown, hasProperty("message", endsWith("does not have a constructor that takes in a ClassLoader."))); + withServiceLocator(new DefaultSerializationProvider(null), locator -> locator.with(InstantiatorService.class), provider -> { + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) LegacySerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration)); + assertThat(thrown, hasProperty("message", containsString("java.lang.NoSuchMethodException"))); + }); } @Test public void testPersistentLegacySerializer() throws Exception { - DefaultSerializationProvider provider = getStartedProvider(); - - LegacySerializer.legacyConstructorInvoked = false; - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) LegacySerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock())); - assertThat(thrown, hasProperty("message", endsWith("does not have a constructor that takes in a ClassLoader."))); + withPersistentProvider(provider -> { + LegacySerializer.legacyConstructorInvoked = false; + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) LegacySerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock())); + assertThat(thrown, hasProperty("message", containsString("java.lang.NoSuchMethodException"))); + }); } @Test public void testTransientLegacyComboSerializer() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - LegacyComboSerializer.baseConstructorInvoked = false; - LegacyComboSerializer.legacyConstructorInvoked = false; - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) LegacyComboSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - Serializer valueSerializer = - provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration); - assertThat(valueSerializer, instanceOf(LegacyComboSerializer.class)); - assertThat(LegacyComboSerializer.baseConstructorInvoked, is(true)); - assertThat(LegacyComboSerializer.legacyConstructorInvoked, is(false)); + withServiceLocator(new DefaultSerializationProvider(null), provider -> { + LegacyComboSerializer.baseConstructorInvoked = false; + LegacyComboSerializer.legacyConstructorInvoked = false; + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) LegacyComboSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + Serializer valueSerializer = + provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration); + assertThat(valueSerializer, instanceOf(LegacyComboSerializer.class)); + assertThat(LegacyComboSerializer.baseConstructorInvoked, is(true)); + assertThat(LegacyComboSerializer.legacyConstructorInvoked, is(false)); + }); } @Test public void testPersistentLegacyComboSerializer() throws Exception { - DefaultSerializationProvider provider = getStartedProvider(); - - LegacyComboSerializer.baseConstructorInvoked = false; - LegacyComboSerializer.legacyConstructorInvoked = false; - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) LegacyComboSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - Serializer valueSerializer = - provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock()); - assertThat(valueSerializer, instanceOf(LegacyComboSerializer.class)); - assertThat(LegacyComboSerializer.baseConstructorInvoked, is(true)); - assertThat(LegacyComboSerializer.legacyConstructorInvoked, is(false)); + withPersistentProvider(provider -> { + LegacyComboSerializer.baseConstructorInvoked = false; + LegacyComboSerializer.legacyConstructorInvoked = false; + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) LegacyComboSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + Serializer valueSerializer = + provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock()); + assertThat(valueSerializer, instanceOf(LegacyComboSerializer.class)); + assertThat(LegacyComboSerializer.baseConstructorInvoked, is(true)); + assertThat(LegacyComboSerializer.legacyConstructorInvoked, is(false)); + }); } @Test public void testCreateTransientStatefulLegacySerializer() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) StatefulLegacySerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration)); - assertThat(thrown, hasProperty("message", endsWith("does not have a constructor that takes in a ClassLoader."))); + withServiceLocator(new DefaultSerializationProvider(null),locator -> locator.with(InstantiatorService.class), provider -> { + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) StatefulLegacySerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration)); + assertThat(thrown, hasProperty("message", containsString("java.lang.NoSuchMethodException"))); + }); } @Test public void testCreatePersistentStatefulLegacySerializer() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) StatefulLegacySerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock())); - assertThat(thrown, hasProperty("message", endsWith("does not have a constructor that takes in a ClassLoader."))); + withServiceLocator(new DefaultSerializationProvider(null), provider -> { + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) StatefulLegacySerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + RuntimeException thrown = assertThrows(RuntimeException.class, () -> provider.createValueSerializer(Object.class, getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock())); + assertThat(thrown, hasProperty("message", containsString("java.lang.NoSuchMethodException"))); + }); } @Test public void testTransientStatefulLegacyComboSerializer() throws Exception { - DefaultSerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); - - StatefulLegacyComboSerializer.baseConstructorInvoked = false; - StatefulLegacyComboSerializer.legacyConstructorInvoked = false; - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) StatefulLegacyComboSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - Serializer valueSerializer = - provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration); - assertThat(valueSerializer, instanceOf(StatefulLegacyComboSerializer.class)); - assertThat(StatefulLegacyComboSerializer.baseConstructorInvoked, is(true)); - assertThat(StatefulLegacyComboSerializer.legacyConstructorInvoked, is(false)); + withServiceLocator(new DefaultSerializationProvider(null), provider -> { + StatefulLegacyComboSerializer.baseConstructorInvoked = false; + StatefulLegacyComboSerializer.legacyConstructorInvoked = false; + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) StatefulLegacyComboSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + Serializer valueSerializer = + provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration); + assertThat(valueSerializer, instanceOf(StatefulLegacyComboSerializer.class)); + assertThat(StatefulLegacyComboSerializer.baseConstructorInvoked, is(true)); + assertThat(StatefulLegacyComboSerializer.legacyConstructorInvoked, is(false)); + }); } @Test public void testPersistentStatefulLegacyComboSerializer() throws Exception { - DefaultSerializationProvider provider = getStartedProvider(); - - StatefulLegacyComboSerializer.baseConstructorInvoked = false; - StatefulLegacyComboSerializer.legacyConstructorInvoked = false; - @SuppressWarnings("unchecked") - Class> serializerClass = (Class) StatefulLegacyComboSerializer.class; - DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); - Serializer valueSerializer = - provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock()); - assertThat(valueSerializer, instanceOf(StatefulLegacyComboSerializer.class)); - assertThat(StatefulLegacyComboSerializer.baseConstructorInvoked, is(true)); - assertThat(StatefulLegacyComboSerializer.legacyConstructorInvoked, is(false)); + withPersistentProvider(provider -> { + StatefulLegacyComboSerializer.baseConstructorInvoked = false; + StatefulLegacyComboSerializer.legacyConstructorInvoked = false; + @SuppressWarnings("unchecked") + Class> serializerClass = (Class) StatefulLegacyComboSerializer.class; + DefaultSerializerConfiguration configuration = new DefaultSerializerConfiguration<>(serializerClass, DefaultSerializerConfiguration.Type.VALUE); + Serializer valueSerializer = + provider.createValueSerializer(Object.class, ClassLoader.getSystemClassLoader(), configuration, getPersistenceSpaceIdentifierMock()); + assertThat(valueSerializer, instanceOf(StatefulLegacyComboSerializer.class)); + assertThat(StatefulLegacyComboSerializer.baseConstructorInvoked, is(true)); + assertThat(StatefulLegacyComboSerializer.legacyConstructorInvoked, is(false)); + }); } private PersistableResourceService.PersistenceSpaceIdentifier getPersistenceSpaceIdentifierMock() { @@ -531,23 +522,19 @@ private PersistableResourceService.PersistenceSpaceIdentifier getPersistenceS return spaceIdentifier; } - private DefaultSerializationProvider getStartedProvider() throws CachePersistenceException { - DefaultSerializationProvider defaultProvider = new DefaultSerializationProvider(null); - - ServiceProvider serviceProvider = uncheckedGenericMock(ServiceProvider.class); + private void withPersistentProvider(ServiceLocatorUtils.ServiceTask task) throws Exception { DiskResourceService diskResourceService = mock(DiskResourceService.class); when(diskResourceService.createPersistenceContextWithin(any(PersistableResourceService.PersistenceSpaceIdentifier.class), anyString())) - .thenReturn(() -> { - try { - return tempFolder.newFolder(); - } catch (IOException e) { - fail("unable to create persistence "); - return null; - } - }); - when(serviceProvider.getService(DiskResourceService.class)).thenReturn(diskResourceService); - defaultProvider.start(serviceProvider); - return defaultProvider; + .thenReturn(() -> { + try { + return tempFolder.newFolder(); + } catch (IOException e) { + fail("unable to create persistence "); + return null; + } + }); + + withServiceLocator(new DefaultSerializationProvider(null), deps -> deps.with(InstantiatorService.class).with(diskResourceService), task); } public static class TestSerializer implements Serializer { diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/EhcachePersistentConcurrentOffHeapClockCacheTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/EhcachePersistentConcurrentOffHeapClockCacheTest.java index 132ae1aa9c..2e7e70339e 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/EhcachePersistentConcurrentOffHeapClockCacheTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/EhcachePersistentConcurrentOffHeapClockCacheTest.java @@ -17,6 +17,7 @@ package org.ehcache.impl.internal.store.disk; import org.ehcache.config.EvictionAdvisor; +import org.ehcache.impl.internal.classes.DefaultInstantiatorService; import org.ehcache.impl.internal.store.disk.factories.EhcachePersistentSegmentFactory; import org.ehcache.impl.internal.store.offheap.AbstractEhcacheOffHeapBackingMapTest; import org.ehcache.impl.internal.store.offheap.EhcacheOffHeapBackingMap; @@ -64,7 +65,7 @@ private EhcachePersistentConcurrentOffHeapClockCache createTestS try { HeuristicConfiguration configuration = new HeuristicConfiguration(1024 * 1024); SerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); MappedPageSource pageSource = new MappedPageSource(folder.newFile(), true, configuration.getMaximumSize()); Serializer keySerializer = serializationProvider.createKeySerializer(String.class, EhcachePersistentConcurrentOffHeapClockCacheTest.class.getClassLoader()); Serializer valueSerializer = serializationProvider.createValueSerializer(String.class, EhcachePersistentConcurrentOffHeapClockCacheTest.class.getClassLoader()); diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/OffHeapDiskStoreTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/OffHeapDiskStoreTest.java index 01ba84eb90..1c9c0ac5e8 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/OffHeapDiskStoreTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/OffHeapDiskStoreTest.java @@ -28,6 +28,7 @@ import org.ehcache.core.spi.service.CacheManagerProviderService; import org.ehcache.core.internal.statistics.DefaultStatisticsService; import org.ehcache.core.store.StoreConfigurationImpl; +import org.ehcache.impl.internal.classes.DefaultInstantiatorService; import org.ehcache.spi.resilience.StoreAccessException; import org.ehcache.core.statistics.LowerCachingTierOperationsOutcome; import org.ehcache.CachePersistenceException; @@ -247,7 +248,7 @@ public void testProvidingOffHeapDiskStoreConfiguration() throws Exception { protected OffHeapDiskStore createAndInitStore(final TimeSource timeSource, final ExpiryPolicy expiry) { try { SerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining(diskResourceService)); + serializationProvider.start(providerContaining(diskResourceService, new DefaultInstantiatorService())); ClassLoader classLoader = getClass().getClassLoader(); Serializer keySerializer = serializationProvider.createKeySerializer(String.class, classLoader); Serializer valueSerializer = serializationProvider.createValueSerializer(String.class, classLoader); @@ -275,7 +276,7 @@ protected OffHeapValueHolderPortability createValuePortability(Serialize protected OffHeapDiskStore createAndInitStore(TimeSource timeSource, ExpiryPolicy expiry, EvictionAdvisor evictionAdvisor) { try { SerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining(diskResourceService)); + serializationProvider.start(providerContaining(diskResourceService, new DefaultInstantiatorService())); ClassLoader classLoader = getClass().getClassLoader(); Serializer keySerializer = serializationProvider.createKeySerializer(String.class, classLoader); Serializer valueSerializer = serializationProvider.createValueSerializer(byte[].class, classLoader); diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/factories/EhcachePersistentSegmentTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/factories/EhcachePersistentSegmentTest.java index 0fe163d4d6..846deeefa8 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/factories/EhcachePersistentSegmentTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/disk/factories/EhcachePersistentSegmentTest.java @@ -17,6 +17,7 @@ package org.ehcache.impl.internal.store.disk.factories; import org.ehcache.config.EvictionAdvisor; +import org.ehcache.impl.internal.classes.DefaultInstantiatorService; import org.ehcache.impl.internal.store.disk.factories.EhcachePersistentSegmentFactory.EhcachePersistentSegment; import org.ehcache.impl.internal.store.offheap.SwitchableEvictionAdvisor; import org.ehcache.impl.internal.store.offheap.HeuristicConfiguration; @@ -70,7 +71,7 @@ private EhcachePersistentSegmentFactory.EhcachePersistentSegment try { HeuristicConfiguration configuration = new HeuristicConfiguration(1024 * 1024); SerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); MappedPageSource pageSource = new MappedPageSource(folder.newFile(), true, configuration.getMaximumSize()); Serializer keySerializer = serializationProvider.createKeySerializer(String.class, EhcachePersistentSegmentTest.class.getClassLoader()); Serializer valueSerializer = serializationProvider.createValueSerializer(String.class, EhcachePersistentSegmentTest.class.getClassLoader()); diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/EhcacheConcurrentOffHeapClockCacheTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/EhcacheConcurrentOffHeapClockCacheTest.java index e596aa9ca9..df5a0b2be9 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/EhcacheConcurrentOffHeapClockCacheTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/EhcacheConcurrentOffHeapClockCacheTest.java @@ -18,6 +18,7 @@ import org.ehcache.config.Eviction; import org.ehcache.config.EvictionAdvisor; +import org.ehcache.impl.internal.classes.DefaultInstantiatorService; import org.ehcache.impl.internal.spi.serialization.DefaultSerializationProvider; import org.ehcache.impl.internal.store.offheap.factories.EhcacheSegmentFactory; import org.ehcache.impl.internal.store.offheap.portability.SerializerPortability; @@ -57,7 +58,7 @@ private EhcacheConcurrentOffHeapClockCache createTestSegment(fin try { HeuristicConfiguration configuration = new HeuristicConfiguration(1024 * 1024); SerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); PageSource pageSource = new UpfrontAllocatingPageSource(getBufferSource(), configuration.getMaximumSize(), configuration.getMaximumChunkSize(), configuration.getMinimumChunkSize()); Serializer keySerializer = serializationProvider.createKeySerializer(String.class, EhcacheConcurrentOffHeapClockCacheTest.class.getClassLoader()); Serializer valueSerializer = serializationProvider.createValueSerializer(String.class, EhcacheConcurrentOffHeapClockCacheTest.class.getClassLoader()); diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/OffHeapStoreTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/OffHeapStoreTest.java index 20b2449444..3f0823c04f 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/OffHeapStoreTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/OffHeapStoreTest.java @@ -23,6 +23,7 @@ import org.ehcache.core.internal.statistics.DefaultStatisticsService; import org.ehcache.core.store.StoreConfigurationImpl; import org.ehcache.expiry.ExpiryPolicy; +import org.ehcache.impl.internal.classes.DefaultInstantiatorService; import org.ehcache.impl.internal.events.TestStoreEventDispatcher; import org.ehcache.impl.internal.spi.serialization.DefaultSerializationProvider; import org.ehcache.core.spi.time.TimeSource; @@ -51,7 +52,7 @@ public class OffHeapStoreTest extends AbstractOffHeapStoreTest { protected OffHeapStore createAndInitStore(TimeSource timeSource, ExpiryPolicy expiry) { try { SerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); ClassLoader classLoader = getClass().getClassLoader(); Serializer keySerializer = serializationProvider.createKeySerializer(String.class, classLoader); Serializer valueSerializer = serializationProvider.createValueSerializer(String.class, classLoader); @@ -75,7 +76,7 @@ protected OffHeapValueHolderPortability createValuePortability(Serialize protected OffHeapStore createAndInitStore(TimeSource timeSource, ExpiryPolicy expiry, EvictionAdvisor evictionAdvisor) { try { SerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); ClassLoader classLoader = getClass().getClassLoader(); Serializer keySerializer = serializationProvider.createValueSerializer(String.class, classLoader); Serializer valueSerializer = serializationProvider.createValueSerializer(byte[].class, classLoader); diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/OffHeapValueHolderPortabilityTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/OffHeapValueHolderPortabilityTest.java index aaeeeb4e39..512b77edcb 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/OffHeapValueHolderPortabilityTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/OffHeapValueHolderPortabilityTest.java @@ -16,6 +16,7 @@ package org.ehcache.impl.internal.store.offheap; +import org.ehcache.impl.internal.classes.DefaultInstantiatorService; import org.ehcache.impl.internal.store.offheap.portability.OffHeapValueHolderPortability; import org.ehcache.impl.internal.spi.serialization.DefaultSerializationProvider; import org.ehcache.impl.serialization.StringSerializer; @@ -46,7 +47,7 @@ public class OffHeapValueHolderPortabilityTest { @Before public void setup() throws UnsupportedTypeException { SerializationProvider provider = new DefaultSerializationProvider(null); - provider.start(providerContaining()); + provider.start(providerContaining(new DefaultInstantiatorService())); valueHolderPortability = new OffHeapValueHolderPortability<>(provider .createValueSerializer(String.class, getClass().getClassLoader())); diff --git a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/factories/EhcacheSegmentTest.java b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/factories/EhcacheSegmentTest.java index 24054fffdd..2117029060 100644 --- a/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/factories/EhcacheSegmentTest.java +++ b/ehcache-impl/src/test/java/org/ehcache/impl/internal/store/offheap/factories/EhcacheSegmentTest.java @@ -18,6 +18,7 @@ import org.ehcache.config.Eviction; import org.ehcache.config.EvictionAdvisor; +import org.ehcache.impl.internal.classes.DefaultInstantiatorService; import org.ehcache.impl.internal.store.offheap.SwitchableEvictionAdvisor; import org.ehcache.impl.internal.store.offheap.HeuristicConfiguration; import org.ehcache.impl.internal.store.offheap.portability.SerializerPortability; @@ -61,7 +62,7 @@ private EhcacheSegmentFactory.EhcacheSegment createTestSegmentWi try { HeuristicConfiguration configuration = new HeuristicConfiguration(1024 * 1024); SerializationProvider serializationProvider = new DefaultSerializationProvider(null); - serializationProvider.start(providerContaining()); + serializationProvider.start(providerContaining(new DefaultInstantiatorService())); PageSource pageSource = new UpfrontAllocatingPageSource(getBufferSource(), configuration.getMaximumSize(), configuration.getMaximumChunkSize(), configuration.getMinimumChunkSize()); Serializer keySerializer = serializationProvider.createKeySerializer(String.class, EhcacheSegmentTest.class.getClassLoader()); Serializer valueSerializer = serializationProvider.createValueSerializer(String.class, EhcacheSegmentTest.class.getClassLoader()); diff --git a/ehcache-transactions/src/jakarta/java/org/ehcache/transactions/xa/txmgr/provider/LookupTransactionManagerProvider.java b/ehcache-transactions/src/jakarta/java/org/ehcache/transactions/xa/txmgr/provider/LookupTransactionManagerProvider.java index 69d8edb413..83506918f8 100644 --- a/ehcache-transactions/src/jakarta/java/org/ehcache/transactions/xa/txmgr/provider/LookupTransactionManagerProvider.java +++ b/ehcache-transactions/src/jakarta/java/org/ehcache/transactions/xa/txmgr/provider/LookupTransactionManagerProvider.java @@ -17,7 +17,9 @@ package org.ehcache.transactions.xa.txmgr.provider; import jakarta.transaction.TransactionManager; +import org.ehcache.core.spi.service.InstantiatorService; import org.ehcache.spi.service.Service; +import org.ehcache.spi.service.ServiceDependencies; import org.ehcache.spi.service.ServiceProvider; import org.ehcache.transactions.xa.txmgr.TransactionManagerWrapper; @@ -37,10 +39,11 @@ * Note that in this scheme, the lookup instance is not expected to cache the {@code TransactionManagerWrapper} * unless it can be considered a singleton. */ +@ServiceDependencies(InstantiatorService.class) public class LookupTransactionManagerProvider implements TransactionManagerProvider { - private final TransactionManagerLookup lookup; - private volatile TransactionManagerWrapper transactionManagerWrapper; + private final LookupTransactionManagerProviderConfiguration config; + private TransactionManagerWrapper transactionManagerWrapper; /** * Creates a new instance with the provided configuration. @@ -53,11 +56,7 @@ public LookupTransactionManagerProvider(LookupTransactionManagerProviderConfigur if (config == null) { throw new NullPointerException("LookupTransactionManagerProviderConfiguration cannot be null"); } - try { - lookup = config.getTransactionManagerLookup().newInstance(); - } catch (InstantiationException | IllegalAccessException e) { - throw new IllegalArgumentException("Could not instantiate lookup class", e); - } + this.config = config; } /** @@ -73,7 +72,8 @@ public TransactionManagerWrapper getTransactionManagerWrappe */ @Override public void start(ServiceProvider serviceProvider) { - this.transactionManagerWrapper = lookup.lookupTransactionManagerWrapper(); + InstantiatorService instantiatorService = serviceProvider.getService(InstantiatorService.class); + this.transactionManagerWrapper = instantiatorService.instantiate(config.getTransactionManagerLookup()).lookupTransactionManagerWrapper(); } /** diff --git a/ehcache-transactions/src/main/java/org/ehcache/transactions/xa/txmgr/provider/LookupTransactionManagerProvider.java b/ehcache-transactions/src/main/java/org/ehcache/transactions/xa/txmgr/provider/LookupTransactionManagerProvider.java index c3d2918503..bdeb072d85 100644 --- a/ehcache-transactions/src/main/java/org/ehcache/transactions/xa/txmgr/provider/LookupTransactionManagerProvider.java +++ b/ehcache-transactions/src/main/java/org/ehcache/transactions/xa/txmgr/provider/LookupTransactionManagerProvider.java @@ -16,7 +16,9 @@ package org.ehcache.transactions.xa.txmgr.provider; +import org.ehcache.core.spi.service.InstantiatorService; import org.ehcache.spi.service.Service; +import org.ehcache.spi.service.ServiceDependencies; import org.ehcache.spi.service.ServiceProvider; import org.ehcache.transactions.xa.txmgr.TransactionManagerWrapper; @@ -38,10 +40,11 @@ * Note that in this scheme, the lookup instance is not expected to cache the {@code TransactionManagerWrapper} * unless it can be considered a singleton. */ +@ServiceDependencies(InstantiatorService.class) public class LookupTransactionManagerProvider implements TransactionManagerProvider { - private final TransactionManagerLookup lookup; - private volatile TransactionManagerWrapper transactionManagerWrapper; + private final LookupTransactionManagerProviderConfiguration config; + private TransactionManagerWrapper transactionManagerWrapper; /** * Creates a new instance with the provided configuration. @@ -54,11 +57,7 @@ public LookupTransactionManagerProvider(LookupTransactionManagerProviderConfigur if (config == null) { throw new NullPointerException("LookupTransactionManagerProviderConfiguration cannot be null"); } - try { - lookup = config.getTransactionManagerLookup().newInstance(); - } catch (InstantiationException | IllegalAccessException e) { - throw new IllegalArgumentException("Could not instantiate lookup class", e); - } + this.config = config; } /** @@ -74,7 +73,8 @@ public TransactionManagerWrapper getTransactionManagerWrappe */ @Override public void start(ServiceProvider serviceProvider) { - this.transactionManagerWrapper = lookup.lookupTransactionManagerWrapper(); + InstantiatorService instantiatorService = serviceProvider.getService(InstantiatorService.class); + this.transactionManagerWrapper = instantiatorService.instantiate(config.getTransactionManagerLookup()).lookupTransactionManagerWrapper(); } /** diff --git a/ehcache-transactions/src/test/java/org/ehcache/transactions/xa/internal/XAStoreTest.java b/ehcache-transactions/src/test/java/org/ehcache/transactions/xa/internal/XAStoreTest.java index 896ee04a57..290a8581e6 100644 --- a/ehcache-transactions/src/test/java/org/ehcache/transactions/xa/internal/XAStoreTest.java +++ b/ehcache-transactions/src/test/java/org/ehcache/transactions/xa/internal/XAStoreTest.java @@ -40,6 +40,7 @@ import org.ehcache.impl.internal.store.offheap.OffHeapStoreLifecycleHelper; import org.ehcache.impl.internal.store.tiering.TieredStore; import org.ehcache.internal.TestTimeSource; +import org.ehcache.spi.serialization.SerializationProvider; import org.ehcache.spi.service.ServiceProvider; import org.ehcache.spi.copy.Copier; import org.ehcache.spi.copy.CopyProvider; @@ -55,6 +56,7 @@ import org.ehcache.transactions.xa.txmgr.provider.TransactionManagerProvider; import org.ehcache.transactions.xa.utils.JavaSerializer; import org.ehcache.transactions.xa.utils.TestXid; +import org.junit.After; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -126,14 +128,20 @@ public class XAStoreTest { private final ExpiryPolicy expiry = timeToLiveExpiration(ofSeconds(1)); private Copier keyCopier; private Copier> valueCopier; + private ServiceLocator serviceLocator; @Before public void setUp() { transactionManagerWrapper = new TransactionManagerWrapper<>(testTransactionManager, new NullXAResourceRegistry()); + + serviceLocator = dependencySet().with(CopyProvider.class).build(); + serviceLocator.startAllServices(); + classLoader = ClassLoader.getSystemClassLoader(); keySerializer = new JavaSerializer<>(classLoader); valueSerializer = new JavaSerializer<>(classLoader); - CopyProvider copyProvider = new DefaultCopyProvider(new DefaultCopyProviderConfiguration()); + + CopyProvider copyProvider = serviceLocator.getService(CopyProvider.class); keyCopier = copyProvider.createKeyCopier(Long.class, keySerializer); valueCopier = copyProvider.createValueCopier(valueClass, valueSerializer); Store.Configuration> onHeapConfig = new StoreConfigurationImpl<>(Long.class, valueClass, @@ -147,6 +155,11 @@ public void setUp() { journal = new TransientJournal<>(); } + @After + public void stop() throws Exception { + serviceLocator.stopAllServices(); + } + @Test public void testXAStoreProviderFailsToRankWhenNoTMProviderConfigured() throws Exception { XAStore.Provider provider = new XAStore.Provider();