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);
            }
        }

template <typename T>
inline std::vector<T> GetVector(DenseElementsAttr elements);

// TODO(zichuanwei@): for each type, we need to make sure the element type
// matches the expected type otherwise an error should be thrown, but for now
// we're just returning empty vector
template <>
inline std::vector<bool> GetVector(DenseElementsAttr elements) {
  auto type = elements.getType();

            return method.getParameterTypes();
        }

        private Member getFactory() {
            return method.getMethod();
        }

        @Override
        protected String getFactoryDisplayName() {
            return String.format("method %s.%s()", format(getFactory().getDeclaringClass()), getFactory().getName());
        }

        @Override

                    assert !(this instanceof org.gradle.api.plugins.ExtensionAware)
                }

                @javax.inject.Inject
                ObjectFactory getFactory() { null }
            }

            def container = project.container(Bean)
            container.create("one") {
                assert name == "one"
            }
        """

        expect:

                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()

    def canGetServiceAsFactoryWhenTheServiceImplementsFactoryInterface() {
        expect:
        registry.getFactory(BigDecimal) instanceof TestFactory
        registry.getFactory(Number) instanceof TestFactory
        registry.getFactory(BigDecimal).is(registry.getFactory(BigDecimal))
        registry.getFactory(Number).is(registry.getFactory(BigDecimal))
    }

    def canLocateFactoryWhenServiceInterfaceExtendsFactory() {

        writeLn("     */");
        String returnType = toClassName(path, rootProjectName(descriptor));
        writeLn("    public " +  returnType + " get" + name + "() { return new " + returnType + "(getFactory(), create(\"" + path + "\")); }");
        writeLn();
    }

    protected void processChildren(ProjectDescriptor current) {
        current.getChildren()
            .stream()

    }

    def "getFactory() returns a factory which creates instances of implementation class"() {
        given:
        implementationDeclared(CharSequence, String)

        when:
        def factory = serviceLocator.getFactory(CharSequence)
        def obj1 = factory.create()
        def obj2 = factory.create()

        then:

            }
            return service;
        }

        @Override
        public <T> Factory<T> getFactory(Class<T> type) throws UnknownServiceException, ServiceLookupException {
            return serviceRegistry.getFactory(type);
        }

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