_ = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPCNT, 5)

				// Wait time after successful probe in seconds.
				// ~ cat /proc/sys/net/ipv4/tcp_keepalive_intvl (defaults to 75 secs, we reduce it to 15 secs)
				_ = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPINTVL, 15)
			}

			// Set tcp user timeout in addition to the keep-alive - tcp-keepalive is not enough to close a socket

 * */
class ZincScalaCompilerOutputNormalizer implements OutputNormalizer {

    private static final PATTERN = Pattern.compile(
        "(Scala Compiler interface compilation took ([0-9]+ hrs )?([0-9]+ mins )?[0-9.]+ secs\n\n)" +
            "|(\\[Warn] : -target is deprecated: Use -release instead to compile against the correct platform API.\none warning found\n\n)",
        Pattern.MULTILINE
    )

    @Override

		// ignoring error from shmdt as there's nothing sensible to return here
		shmdt(addr)
		return nil, err
	}

	// Use unsafe to convert addr into a []byte.
	b := unsafe.Slice((*byte)(unsafe.Pointer(addr)), int(info.Segsz))
	return b, nil
}

// SysvShmDetach unmaps the shared memory slice returned from SysvShmAttach.
//
// It is not safe to use the slice after calling this function.
func SysvShmDetach(data []byte) error {

<td class="numeric">30.000s</td>
<td>Did No Work</td>
</tr>
</table>
</div>
</div>"""))
    }

    private static long time(int hour, int mins, int secs, int ms = 0) {
        def cal = new GregorianCalendar(2010, 1, 5, hour, mins, secs)
        cal.add(Calendar.MILLISECOND, ms)
        cal.getTimeInMillis()
    }

    def "the registry can be concurrently written to"() {
        when:
        // obtain localhost address ahead of time as the first call in a JVM can take multiple secs in some systems
        def localhost = Inet6Address.getLocalHost()
        def registry = registry("someDir").get(DaemonRegistry)
        5.times { idx ->
            concurrent.start {

    def "successfully normalizes Scala compiler output"() {
        given:
        String input = """
> Task :app:compileJava NO-SOURCE
> Task :app:compileScala
Scala Compiler interface compilation took 1 hrs 20 mins 41.884 secs

> Task :app:processResources NO-SOURCE
> Task :app:classes
> Task :app:jar
> Task :app:startScripts
> Task :app:distTar
> Task :app:distZip
> Task :app:assemble
> Task :app:compileTestJava NO-SOURCE

			// It recovers the panic, logs a stack trace to the server error log,
			// and either closes the network connection or sends an HTTP/2
			// RST_STREAM, depending on the HTTP protocol. To abort a handler so
			// the client sees an interrupted response but the server doesn't log
			// an error, panic with the value ErrAbortHandler.
			//
			// Note that HandleCrash function is actually crashing, after calling the handlers

            result.append((durationMillis % MILLIS_PER_HOUR) / MILLIS_PER_MINUTE).append(" mins ");
        }
        result.append((durationMillis % MILLIS_PER_MINUTE) / 1000.0).append(" secs");
        return result.toString();
    }

    public static String formatDurationTerse(long elapsedTimeInMs) {
        StringBuilder result = new StringBuilder();
        if (elapsedTimeInMs >= MILLIS_PER_HOUR) {

*Example 1:* Setting a project property via the *command line*:
====
----
$ gradle -PgradlePropertiesProp=commandLineValue
----
====

Gradle can also set project properties when it sees specially-named system properties or environment variables.
If the environment variable name looks like `ORG_GRADLE_PROJECT___prop__=somevalue`, then Gradle will set a `prop` property on your project object, with the value of `somevalue`.

        buildFile << """
            scaladoc.maxMemory = '234M'
        """
        when:
        succeeds scaladoc, "-i"

        then:
        // Looks like
        // Started Gradle worker daemon (0.399 secs) with fork options DaemonForkOptions{executable=/Library/Java/JavaVirtualMachines/adoptopenjdk-11.jdk/Contents/Home/bin/java, minHeapSize=null, maxHeapSize=234M, jvmArgs=[], keepAliveMode=DAEMON}.
        outputContains("maxHeapSize=234M")