package org.example.app;

/**
 * A simple Java application that prints "Hello, world!" to stdout.
 */
public class HelloApp {
    /**
     * Application entry point.
     */
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }

	// file set fset.
	funcAST, fset := parseFunc("example_test.go", "printSelf")

	// Print the function body into buffer buf.
	// The file set is provided to the printer so that it knows
	// about the original source formatting and can add additional
	// line breaks where they were present in the source.
	var buf bytes.Buffer
	printer.Fprint(&buf, fset, funcAST.Body)

	// Remove braces {} enclosing the function body, unindent,

    }

    def "configure project group header is printed red if configuration fails with additional failures"() {
        given:
        buildFile << """
            afterEvaluate {
                println "executing after evaluate..."
                throw new RuntimeException("After Evaluate Failure...")
            }
            throw new RuntimeException('Config Failure...')
        """

        when:

}


internal
fun printAccessorsFor(schema: TypedProjectSchema) {
    for (sourceFragment in accessorSourceFragmentsFor(schema)) {
        println()
        println(sourceFragment.replaceIndent("    "))
        println()
    }
}


private
fun accessorSourceFragmentsFor(schema: TypedProjectSchema): Sequence<String> =
    accessorsFor(schema.map(::accessible)).flatMap { accessor ->

# Building a trivial non-main package should run compiler the first time.
go build -x -gcflags=-m lib.go
stderr 'compile( |\.exe"?)'
stderr 'lib.go:2.* can inline f'

# ... but not the second, even though it still prints the compiler output.
go build -x -gcflags=-m lib.go
! stderr 'compile( |\.exe"?)'
stderr 'lib.go:2.* can inline f'

# Building a trivial main package should run the compiler and linker the first time.

	// This example simulates that by sending a SIGINT signal to itself.
	if err := p.Signal(os.Interrupt); err != nil {
		log.Fatal(err)
	}

	select {
	case <-neverReady:
		fmt.Println("ready")
	case <-ctx.Done():
		fmt.Println(ctx.Err()) // prints "context canceled"
		stop()                 // stop receiving signal notifications as soon as possible.
	}

	// Output:
	// context canceled

        buildFile = new File(testProjectDir, 'build.gradle')
    }

    def "hello world task prints hello world"() {
        given:
        settingsFile << "rootProject.name = 'hello-world'"
        buildFile << """
            task helloWorld {
                doLast {
                    println 'Hello world!'
                }
            }
        """

        when:

// RUN: tf-opt %s -mlir-print-debuginfo -mlir-print-local-scope | tf-opt -mlir-print-debuginfo -mlir-print-op-generic -mlir-print-local-scope | FileCheck %s

// This file should be written in the generic form with debug locations.
// (that is, as if printed with `-mlir-print-debuginfo -mlir-print-op-generic`).
// The test parses the file, prints it in the pretty form with debug locations,
// then parses it back, then prints it in the generic form again.

import org.jetbrains.kotlin.analysis.test.framework.project.structure.KtTestModule
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder

val disableMe by tasks.registering {
    doLast {
        println("This should not be printed if the task is disabled.")
    }
}

disableMe {
    enabled = false