private void reduceEqualLinesFromHeadAndTail(
            List<String> original, List<String> revised, int contextSize) {
        int head = 0;
        int maxHead = min(original.size(), revised.size());
        while (head < maxHead && original.get(head).equals(revised.get(head))) {
            head++;
        }
        head = max(head - contextSize, 0);
        offsetHead = head;

        int tail = 0;

    OptionsVerifier(File processJsonFile) {
        this.processJsonFile = processJsonFile
    }

    void minHeap(String value) {
        options.add(new MinHeap(value))
    }

    void maxHeap(String value) {
        options.add(new MaxHeap(value))
    }

    void jvmArgs(String value) {
        options.add(new JvmArg(value))
    }

    void systemProperty(String name, String value) {

    }

    private JavaForkOptions javaForkOptions(String minHeap, String maxHeap, List<String> jvmArgs) {
        def options = TestFiles.execFactory().newJavaForkOptions()
        options.workingDir = systemSpecificAbsolutePath("foo")
        options.minHeapSize = minHeap
        options.maxHeapSize = maxHeap
        options.jvmArgs = jvmArgs
        return options
    }

	typeUnknownType     recType = 11
)

// keep the connection between web-server and responder open after request
const flagKeepConn = 1

const (
	maxWrite = 65535 // maximum record body
	maxPad   = 255
)

const (
	roleResponder = iota + 1 // only Responders are implemented.
	roleAuthorizer
	roleFilter
)

const (
	statusRequestComplete = iota
	statusCantMultiplex
	statusOverloaded

      case 2:
        return 1; // The lone element in the maxHeap is the maximum.
      default:
        // The max element must sit on the first level of the maxHeap. It is
        // actually the *lesser* of the two from the maxHeap's perspective.
        return (maxHeap.compareElements(1, 2) <= 0) ? 1 : 2;
    }
  }

  /**

                ? "The daemon will restart for the next build, which may increase subsequent build times"
                : "The memory settings for this project must be adjusted to avoid this failure";

            String maxHeap = heapStats.isValid() ? NumberUtil.formatBytes(heapStats.getMaxSizeInBytes()) : "unknown";
            String maxMetaspace = nonHeapStats.isValid() ? NumberUtil.formatBytes(nonHeapStats.getMaxSizeInBytes()) : "unknown";

      case 2:
        return 1; // The lone element in the maxHeap is the maximum.
      default:
        // The max element must sit on the first level of the maxHeap. It is
        // actually the *lesser* of the two from the maxHeap's perspective.
        return (maxHeap.compareElements(1, 2) <= 0) ? 1 : 2;
    }
  }

  /**

        if (typeof options.singleDatePicker === 'boolean')...

    new File(projectDirectory, "gradle.properties") << "\norg.gradle.workers.max=${maxWorkers}\n"

}

private void setMaxHeap(File projectDirectory, String maxHeap) {
    new File(projectDirectory, "gradle.properties") << "\norg.gradle.jvmargs=-Xmx${maxHeap}\n"

}

private void setParallel(File projectDirectory, boolean parallel) {
    new File(projectDirectory, "gradle.properties") << "\norg.gradle.parallel=${parallel}\n"

    def "interesting worker daemon fork options are honored"() {
        OptionsVerifier optionsVerifier = new OptionsVerifier(file('process.json'))
        optionsVerifier.with {
            minHeap("128m")
            maxHeap("128m")
            systemProperty("foo", "bar")
            jvmArgs("-Dbar=baz")
            defaultCharacterEncoding("UTF-8")
            enableAssertions()
            environmentVariable("foo", "bar")