<artifactId>modello-maven-plugin</artifactId>
          <executions>
            <execution>
              <id>modello-site-docs</id>
              <goals>
                <goal>xdoc</goal>
                <goal>xsd</goal>
              </goals>
              <phase>none</phase>
            </execution>
          </executions>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

            getOutputFilesProducedByWork() >> ImmutableSortedMap.of()
            getOriginMetadata() >> delegateOriginMetadata
        })
        0 * _
    }

    def "executes when outputs are not up to date"() {
        def delegateOutcome = Try.successful(Mock(Execution))
        def delegateAfterExecutionState = Stub(AfterExecutionState)

        delegateResult.execution >> delegateOutcome

                options.fork = true
            }
        """
    }

    @Override
    String logStatement() {
        "compiler daemon"
    }

    def setup() {
        executer.withArguments("-d")
    }

    def "respects fork options settings"() {
        goodCode()
        buildFile << """
            import org.gradle.workers.internal.WorkerDaemonClientsManager

import java.net.ServerSocket
import java.net.Socket
import java.util.concurrent.Executor
import java.util.concurrent.ThreadFactory


fun BindingsBuilder.unsupportedTypes() {

    // Live JVM state
    bind(unsupported<ClassLoader>())
    bind(unsupported<Thread>())
    bind(unsupported<ThreadFactory>())
    bind(unsupported<Executor>())
    bind(unsupported<FileDescriptor>())
    bind(unsupported<RandomAccessFile>())

            <param>packageModelV4=org.apache.maven.api.settings</param>
            <param>packageToolV4=org.apache.maven.settings.v4</param>
          </params>
        </configuration>
        <executions>
          <execution>
            <id>velocity</id>
            <goals>
              <goal>velocity</goal>
            </goals>
            <phase>generate-sources</phase>
            <configuration>

    TFTensorType:$result
  );

  let assemblyFormat = "attr-dict";
}

def ExecuteOp : TensorflowMlrt_Op<"executeop", []> {
  let summary = "The Fallback ExecuteOp";
  let description = [{
    The ExecuteOp executes an operation on the specified device.
  }];

  let arguments = (ins
    Variadic<TFTensorType>:$args,
    StrAttr:$node_def,
    I32Attr:$op_key
  );

  let results = (outs

package org.gradle.api

import org.gradle.integtests.fixtures.AbstractIntegrationTest
import org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects
import org.gradle.integtests.fixtures.executer.ArtifactBuilder
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.server.http.HttpServer
import org.gradle.test.matchers.UserAgentMatcher

    private String currentCommandExecution;
    private Object result;
    private String stopReason;
    private volatile DefaultBuildCancellationToken cancellationToken;

    private final ManagedExecutor executor;
    private final Runnable onStartCommand;
    private final Runnable onFinishCommand;
    private final Runnable onCancelCommand;

    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.codehaus.modello</groupId>
        <artifactId>modello-maven-plugin</artifactId>
        <executions>
          <execution>
            <id>plugin</id>
            <goals>
              <goal>velocity</goal>
            </goals>
            <phase>generate-sources</phase>
            <configuration>

func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)

// CompareAndSwapInt32 executes the compare-and-swap operation for an int32 value.
// Consider using the more ergonomic and less error-prone [Int32.CompareAndSwap] instead.
func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)

// CompareAndSwapInt64 executes the compare-and-swap operation for an int64 value.