testFile("build.gradle").writelns("new BuildClass()");
        inTestDirectory().withTasks("help").run();
    }

    @Test
    public void canExtendTheDefaultBuildForBuildSrcProject() {
        ArtifactBuilder builder = artifactBuilder();
        builder.sourceFile("org/gradle/test/DepClass.java").writelns(
                "package org.gradle.test;",

            lines.add("empty=$configuration")
        } else {
            lines.addAll modules.toSorted().collect({ "$it=$configuration".toString() })
            lines.add("empty=")
        }
        lockFile.writelns(lines)
    }

    private void createLegacyLockfile(String configurationName, List<String> modules) {

            dependencies { testImplementation 'junit:junit:4.13' }
        """
    }

    @Override
    void createPassingFailingTest() {
        file('src/main/java/AppException.java').writelns(
            "public class AppException extends Exception { }"
        )

        file('src/test/java/SomeTest.java') << """
            public class SomeTest {
                @org.junit.Test

            }
            test {
                useJUnitPlatform()
            }
        """
    }

    @Override
    void createPassingFailingTest() {
        file('src/main/java/AppException.java').writelns(
            "public class AppException extends Exception { }"
        )

        file('src/test/java/SomeTest.java') << """
            public class SomeTest {
                @org.junit.jupiter.api.Test

        output.writeBytes(bytes, offset, count);
    }

    @Override
    public void writeLong(long value) {
        output.writeLong(value);
    }

    @Override
    public void writeSmallLong(long value) {
        output.writeLong(value, true);
    }

    @Override
    public void writeInt(int value) {
        output.writeInt(value);
    }

    @Override
    public void writeSmallInt(int value) {

	for i, test := range tests {
		ob := &OutBuf{
			buf:  make([]byte, test.bufLen),
			off:  test.off,
			heap: make([]byte, test.heapLen),
		}
		pos, buf := ob.writeLoc(test.lenToWrite)
		if pos != test.writePos {
			t.Errorf("[%d] position = %d, expected %d", i, pos, test.writePos)
		}
		message := "mmapped area"
		expected := ob.buf
		if test.addressInHeap {
			message = "heap"
			expected = ob.heap
		}

        encoder.writeInt(array.length);
        writeInts(encoder, array);
    }

    public static void writeInts(Encoder encoder, int[] array) throws IOException {
        for (int e : array) {
            encoder.writeInt(e);
        }
    }

    public static void writeLengthPrefixedLongs(Encoder encoder, long[] array) throws IOException {
        encoder.writeInt(array.length);

    }

    override fun writeChar(`val`: Int) = record {
        writeInt(`val`)
    }

    override fun writeBoolean(`val`: Boolean) = record {
        writeBoolean(`val`)
    }

    override fun writeShort(`val`: Int) = record {
        this.writeShort(`val`.toShort())
    }

    override fun writeLong(`val`: Long) = record {
        writeLong(`val`)
    }

    override fun writeFloat(`val`: Float) = record {

        this.outputStream = new DataOutputStream(outputStream);
    }

    @Override
    public void writeLong(long value) throws IOException {
        outputStream.writeLong(value);
    }

    @Override
    public void writeInt(int value) throws IOException {
        outputStream.writeInt(value);
    }

    @Override
    public void writeShort(short value) throws IOException {

   */
  @Override
  public void writeFloat(float v) throws IOException {
    writeInt(Float.floatToIntBits(v));
  }

  /**
   * Writes an {@code int} as specified by {@link DataOutputStream#writeInt(int)}, except using
   * little-endian byte order.
   *
   * @throws IOException if an I/O error occurs
   */
  @Override
  public void writeInt(int v) throws IOException {
    out.write(0xFF & v);