return times(value, displaySingular, displaySingular);
    }

    protected abstract Units<Q> getBaseUnits();

    protected abstract List<Units<Q>> getUnitsForQuantity();

    protected abstract BigDecimal getFactor();

    protected abstract BigDecimal scaleTo(BigDecimal value, Units<Q> units);

    protected String format(BigDecimal value) {
        return value.compareTo(BigDecimal.ONE) == 0 ? displaySingular : displayPlural;

        BigDecimal base = normalised.abs();
        for (int i = allUnits.size()-1; i >= 0; i--) {
            Units<Q> candidate = allUnits.get(i);
            if (base.compareTo(candidate.getFactor()) >= 0) {
                BigDecimal scaled = units.scaleTo(value, candidate);
                return formatValue(scaled) + " " + candidate.format(scaled);
            }
        }

                return 123
            }
        })

        expect:
        10.times {
            start {
                assert registry.getFactory(Integer).create() == 12
                assert registry.getFactory(String).create() == "123"
            }
        }
    }

    def "multiple threads can locate all services"() {
        def registry = new DefaultServiceRegistry()

public interface ServiceLocator {
    <T> T get(Class<T> serviceType) throws UnknownServiceException;

    <T> List<T> getAll(Class<T> serviceType) throws UnknownServiceException;

    <T> DefaultServiceLocator.ServiceFactory<T> getFactory(Class<T> serviceType) throws UnknownServiceException;

    @Nullable
    <T> DefaultServiceLocator.ServiceFactory<T> findFactory(Class<T> serviceType);

    static {
        singletonRegistry = new ConnectorServiceRegistry();
    }

    public static DefaultGradleConnector createConnector() {
        return singletonRegistry.getFactory(DefaultGradleConnector.class).create();
    }

    public static CancellationTokenSource createCancellationTokenSource() {
        return new DefaultCancellationTokenSource();
    }

    public static void close() {

namespace tensorflow {
namespace {

class XlaHostSendRecvDeviceContextTest : public ::testing::Test {
 public:
  void SetDevice(const string& device_type) {
    auto device_factory = DeviceFactory::GetFactory(device_type);
    SessionOptions options;
    std::vector<std::unique_ptr<Device>> devices;
    Status s = device_factory->CreateDevices(
        options, "/job:worker/replica:0/task:0", &devices);

        }
        List<T> all = delegate.getAll(serviceType);
        allServices.put(serviceType, all);
        return all;
    }

    @Override
    public synchronized <T> DefaultServiceLocator.ServiceFactory<T> getFactory(Class<T> serviceType) throws UnknownServiceException {
        DefaultServiceLocator.ServiceFactory<T> factory = findFactory(serviceType);
        if (factory == null) {

            ServiceRegistryFactory serviceRegistryFactory = domainObject -> {
                final Factory<LoggingManagerInternal> loggingManagerFactory = buildServices.getFactory(LoggingManagerInternal.class);
                projectScopeServices = new ProjectScopeServices(buildServices, (ProjectInternal) domainObject, loggingManagerFactory);
                return projectScopeServices;
            };

    override fun <T> service(serviceType: Class<T>): T =
        gradle.services.get(serviceType)

    override fun <T> factory(serviceType: Class<T>): Factory<T> =
        gradle.services.getFactory(serviceType)

    private
    class DefaultVintageGradleBuild(override val state: BuildState) : VintageGradleBuild {
        override val isRootBuild: Boolean
            get() = state is RootBuildState