if (resource != null) {
            resource.withContent(action);
        }
    }

    @Override
    public RepositoryResourceAccessor withImplicitInputRecorder(final ImplicitInputRecorder registrar) {
        return (relativePath, action) -> {
            ExternalResourceName location = new ExternalResourceName(rootUri, relativePath);

        1 * validator.isValid(cachePolicy, _) >> true
        1 * service.isUpToDate('/foo/bar', 'abcdef012') >> false
        1 * serviceRegistry.find(SomeService) >> service
        1 * service.withImplicitInputRecorder(_) >> service
        1 * store.put(_, { it.timestamp == timeProvider.currentTime })
        0 * _
        result.length == 6
    }

 * @param <SERVICE> the type of the service
 */
public interface ImplicitInputsProvidingService<IN, OUT, SERVICE> {

    SERVICE withImplicitInputRecorder(ImplicitInputRecorder registrar);

    boolean isUpToDate(IN in, @Nullable OUT oldValue);

            Object service = serviceRegistry.find(serviceType);
            if (service instanceof ImplicitInputsProvidingService) {
                return ((ImplicitInputsProvidingService)service).withImplicitInputRecorder(registrar);
            }
            return service;
        }

        @Override
        public <T> Factory<T> getFactory(Class<T> type) throws UnknownServiceException, ServiceLookupException {

        @Override
        public void withResource(String relativePath, Action<? super InputStream> action) {
            // No-op
        }

        @Override
        public RepositoryResourceAccessor withImplicitInputRecorder(ImplicitInputRecorder registrar) {
            // Service calls have no effect, no need to register them
            return this;
        }

        @Override

            def details = Mock(ComponentMetadataSupplierDetails)
            if (ruleClass == TestSupplierWithService) {
                // indicates that the service will be called
                1 * someService.withImplicitInputRecorder(_) >> someService
            }
            1 * onCacheMiss.transform(id) >> details
            1 * detailsToResult.transform(details) >> Mock(ComponentMetadata)
            1 * store.put(keyHash, _)
        }

            def details = Mock(ComponentMetadataContext)
            if (ruleClass == TestSupplierWithService) {
                // indicates that the service will be called
                1 * someService.withImplicitInputRecorder(_) >> someService
            }
            1 * onCacheMiss.transform(key) >> details
            1 * detailsToResult.transform(details) >> Mock(ModuleComponentResolveMetadata)
            1 * store.put(keyHash, _)