when:
        def featuresText = featuresFile.text

        then:
        def lines = featuresText.readLines()
        lines.size() <= 10
        lines.every { it.startsWith(" - ") || it.startsWith("   - ")}
        lines.every { it.length() <= 80 }
    }

 * message bus adds too much overhead.
 */
public abstract class KotlinModificationTrackerFactory : KotlinPlatformComponent {
    /**
     * Creates an out-of-block modification tracker which is incremented every time there is an out-of-block change in some source project
     * module.
     *
     * ### Out-of-block Modification (OOBM)
     *

 *
 * @since 8.0
 */
@HasInternalProtocol
@Incubating
public interface Cleanup {
    /**
     * Perform cache cleanup after every build session.
     */
    Cleanup ALWAYS = new DefaultCleanup(CleanupFrequency.ALWAYS);

    /**
     * Perform cache cleanup periodically (default is only once every 24 hours).
     */
    Cleanup DEFAULT = new DefaultCleanup(CleanupFrequency.DAILY);

    /**
     * Never perform cache cleanup.

        implementation project(':common')
    }
}
// end::cpp-dependency-mgmt[]

// tag::cpp-compiler-options-all-variants[]
tasks.withType(CppCompile).configureEach {
    // Define a preprocessor macro for every binary
    macros.put("NDEBUG", null)

    // Define a compiler options
    compilerArgs.add '-W3'

    // Define toolchain-specific compiler options
    compilerArgs.addAll toolChain.map { toolChain ->

    // Define a preprocessor macro for every binary
    macros.add("NDEBUG")

    // Define a compiler options
    compilerArgs.add("-O")
}
// end::swift-compiler-options-all-variants[]

// tag::swift-compiler-options-per-variants[]
application {
    binaries.configureEach(SwiftStaticLibrary::class.java) {
        // Define a preprocessor macro for every binary
        compileTask.get().macros.add("NDEBUG")

package sync

// OnceFunc returns a function that invokes f only once. The returned function
// may be called concurrently.
//
// If f panics, the returned function will panic with the same value on every call.
func OnceFunc(f func()) func() {
	var (
		once  Once
		valid bool
		p     any
	)
	// Construct the inner closure just once to reduce costs on the fast path.
	g := func() {
		defer func() {

        given:
        def table = new StyledTable(
            "",
            ["Very Long"],
            [
                new StyledTable.Row(["foo"], StyledTextOutput.Style.Normal)
            ]
        )

        expect:
        StyledTableUtil.toString(table) == """
            | Very Long |
            |-----------|
            | foo       |
        """.stripIndent(true).trim()
    }

    }
}
// end::cpp-dependency-mgmt[]

// tag::cpp-compiler-options-all-variants[]
tasks.withType(CppCompile::class.java).configureEach {
    // Define a preprocessor macro for every binary
    macros.put("NDEBUG", null)

    // Define a compiler options
    compilerArgs.add("-W3")

    // Define toolchain-specific compiler options
    compilerArgs.addAll(toolChain.map { toolChain ->

#ifndef BOOST_VERSION_HPP
#define BOOST_VERSION_HPP

//
//  Caution, this is the only boost header that is guaranteed
//  to change with every boost release, including this header
//  will cause a recompile every time a new boost version is
//  released.
//
//  BOOST_VERSION % 100 is the patch level
//  BOOST_VERSION / 100 % 1000 is the minor version
//  BOOST_VERSION / 100000 is the major version

		if r := (uint32(1) << (i + 1)) - 1; x != r || v != old {
			t.Fatalf("setting bit %#x: want %#x, got new %#x and old %#v", uint32(1<<i), r, x, v)
		}
	}

	// Start with every bit in array set to 0.
	a := make([]uint32, 1<<12)

	// Set every bit in array bit-by-bit in different goroutines.
	done := make(chan bool)
	for i := 0; i < 32; i++ {
		m := uint32(1 << i)
		go func() {
			for i := range a {