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

    }

    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:

                        final MethodRuleDefinition<?, ?> methodRuleDefinition = details.method;
                        final Factory<? extends T> factory = getFactory();
                        return new ContextualizedModelAction<T>(methodRuleDefinition, mappedSubject, inputs, action, factory);
                    }
                }, target);
            }
        }

            return source;
        }

        public ModelType<?> getImplementationType() {
            return implementationType;
        }

        public ImplementationFactory<? super PUBLIC, ?> getFactory() {
            return factory;
        }
    }

    private static class InternalViewRegistration<T> {
        private final ModelRuleDescriptor source;
        private final ModelType<T> internalView;

LogConfigurationExce; public abstract Log getInstance(String) throws LogConfigurationExce; public abstract void release(); public abstract void removeAttribute(String); public abstract void setAttribute(String, Object); public static LogFactory getFactory() throws LogConfigurationExce; public static Log getLog(Class) throws LogConfigurationExce; public static Log getLog(String) throws LogConfigurationExce; public static void release(ClassLoader); public static void releaseAll(); protected static...

        _ * loggingServices.get(OutputEventListener) >> Mock(OutputEventListener)
        Factory<LoggingManagerInternal> loggingManagerFactory = Mock()
        _ * loggingServices.getFactory(LoggingManagerInternal) >> loggingManagerFactory
        _ * loggingManagerFactory.create() >> loggingManager
        StyledTextOutputFactory textOutputFactory = Mock()

        if (standardInput == null) {
            standardInput = SafeStreams.emptyInput();
        }
        if (Boolean.TRUE.equals(operationParameters.isEmbedded())) {
            loggingManager = sharedServices.getFactory(LoggingManagerInternal.class).create();
            loggingManager.captureSystemSources();

    public static final TestFile COMMON_TMP = new TestFile(new File("build/tmp"));

    static {
        LoggingManagerInternal loggingManager = GLOBAL_SERVICES.getFactory(LoggingManagerInternal.class).create();
        loggingManager.start();

        GLOBAL_SERVICES.get(AgentInitializer.class).maybeConfigureInstrumentationAgent();
    }

        }

        return new ToolingApiConnector(connector, stdout, stderr)
    }

    private createConnector() {
        if (isolatedToolingClient != null) {
            return isolatedToolingClient.getFactory(DefaultGradleConnector).create()
        }
        return GradleConnector.newConnector() as DefaultGradleConnector
    }

    private void isolateFromGradleOwnBuild(DefaultGradleConnector connector) {

            int lineOfSubAccessor = lineOf("public ${baseName}ProjectDependency get${getterPath}() { return new ${baseName}ProjectDependency(getFactory(), create(\"${projectPath}\")); }")
            lineOfSubAccessor
        }

        void hasSubprojectAccessors(String... paths) {
            def expectedOrderOfAccessors = paths.sort()