this.nameFormat = nameFormat;
    return this;
  }

  /**
   * Sets daemon or not for new threads created with this ThreadFactory.
   *
   * @param daemon whether or not new Threads created with this ThreadFactory will be daemon threads
   * @return this for the builder pattern
   */
  @CanIgnoreReturnValue
  public ThreadFactoryBuilder setDaemon(boolean daemon) {

        List<GeneratedConstructor<T>> getConstructors();

        /**
         * Creates a serialization constructor. Note: this can be expensive and does not perform any caching.
         */
        SerializationConstructor<T> getSerializationConstructor(Class<? super T> baseClass);
    }

    interface SerializationConstructor<T> {
        /**

    def resolver = Mock(JansiRuntimeResolver)

    def setup() {
        factory.jansiRuntimeResolver = resolver
    }

    def "jansi library can be created for MacOSX"() {
        when:
        JansiLibrary jansiLibrary = factory.create()

        then:
        1 * resolver.operatingSystem >> JansiOperatingSystemSupport.MAC_OS_X.identifier
        0 * resolver.platform

    }

    @Benchmark
    public void createFileJava6(Blackhole blackhole) throws IOException {
        File file = new File(tempDirFile, "file-" + counter.incrementAndGet());
        boolean created = file.createNewFile();
        blackhole.consume(created);
    }

    @Benchmark
    public void createFileJava7(Blackhole blackhole) throws IOException {

LazyConsumer -> ToolingImplLoader: createConnection
create Connection
ToolingImplLoader -> Connection: new
Connection --> LazyConsumer: connection
note left
uses DistributionFactory to create classloader and instantiate DefaultConnection (provider side) using services lookup
then creates ConsumerConnection matching to capability of this DefaultConnection (DefaultToolingImplementationLoader.create())
ConnectionVersion4BackedConsumerConnection.java: pre 1.0m8

The build session state is managed by the `BuildSessionState` class.
An instance is created at the start of a Gradle invocation and discarded at the end of that invocation.

The build session state also includes "cross session" state that is shared with any "nested" sessions that need to be created.

     *
     * @return The class realm exposing the Maven API, never {@code null}.
     */
    ClassRealm getMavenApiRealm();

    /**
     * Creates a new class realm for the specified project and its build extensions.
     *
     * @param model The model of the project for which to create a realm, must not be {@code null}.
     * @param artifacts The artifacts to add to the class realm, may be {@code null}. Unresolved artifacts (i.e. with a

     * The {@link Properties} are passed to the closure as a parameter.
     * The closure can modify the Properties before they are written to the output file.
     * <p>
     * For examples see docs for {@link org.gradle.plugins.ide.eclipse.model.EclipseJdt} and others.
     *
     * @param closure The closure to execute when the Properties have been created.
     */

     */
    public void withXml(@DelegatesTo(XmlProvider.class) Closure closure) {
        xmlTransformer.addAction(closure);
    }

    /**
     * Adds an action to be called when the file has been created.
     * <p>
     * See {@link #withXml(Closure)}
     *
     * @param action The action to execute when the XML has been created.
     */

    public int selectCount(CBCall<ElevateWordCB> cbLambda) {
        return facadeSelectCount(createCB(cbLambda));
    }

    public OptionalEntity<ElevateWord> selectEntity(CBCall<ElevateWordCB> cbLambda) {
        return facadeSelectEntity(createCB(cbLambda));
    }

    protected OptionalEntity<ElevateWord> facadeSelectEntity(ElevateWordCB cb) {