public static final field Companion Lokhttp3/logging/HttpLoggingInterceptor$Companion;
	public final fun -deprecated_level ()Lokhttp3/logging/HttpLoggingInterceptor$Level;
	public fun <init> ()V
	public fun <init> (Lokhttp3/logging/HttpLoggingInterceptor$Logger;)V
	public synthetic fun <init> (Lokhttp3/logging/HttpLoggingInterceptor$Logger;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
	public final fun getLevel ()Lokhttp3/logging/HttpLoggingInterceptor$Level;

Gradle comes with a built-in task, called `init`, that initializes a new Gradle project in an empty folder.
The `init` task uses the (also built-in) `wrapper` task to create a Gradle wrapper script, `gradlew`.

The first step is to create a folder for the new project and change directory into it.

[listing.terminal.sample-command]
----
\$ mkdir demo
\$ cd demo
----

== Run the init task

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class GroovyImportsIntegrationTest extends AbstractIntegrationSpec {

    def "can handle duplicate imports in init scripts"() {
        def initScript = file('init.gradle')
        initScript << """
initscript {
    repositories { ${mavenCentralRepository()} }
    dependencies {
        classpath 'org.apache.commons:commons-math3:3.6.1'
    }
}

executable: gradle
args: "build --init-script=customLogger.init.gradle.kts"

executable: gradle
args: showRepositories
flags: "--quiet --init-script=init.gradle"

        }
        sourceVersion == SourceVersion.RELEASE_8
        result.executionTimeInMillis == 3
    }

    def "tracks time for init()"() {
        def processingEnv = Stub(ProcessingEnvironment)

        when:
        tracker.init(processingEnv)

        then:
        1 * delegate.init(processingEnv) >> {
            simulateWorkWithDuration(5)
        }
        result.executionTimeInMillis == 5
    }

executable: gradle
args: showRepos
flags: "--init-script=init.gradle.kts --quiet"

    func.return %arg0 : tensor<f32>
  }

  func.func private @f() attributes {
    func.return
  }

  // Representation for init functions
  // CHECK: func @init
  // CHECK-SAME: exported_names = ["__tf_saved_model_session_initializer"]
  func.func @init(
    %arg0: tensor<!tf_type.string> {tf_saved_model.bound_input = @asset_sym_name},

done

# check all groupversions to make sure they're in the init.sh file.  This isn't perfect, but its slightly
# better than nothing
for external_group_version in "${external_group_versions[@]}"; do
	if ! grep -q "${external_group_version}" "${KUBE_ROOT}/hack/lib/init.sh" ; then
		echo "missing ${external_group_version} from hack/lib/init.sh:/KUBE_AVAILABLE_GROUP_VERSIONS or hack/init.sh:/KUBE_NONSERVER_GROUP_VERSIONS"
		exit 1
	fi

		// the likelihood of the first branch.
	case ir.ONOT:
		cond := cond.(*ir.UnaryExpr)
		s.stmtList(cond.Init())
		s.condBranch(cond.X, no, yes, -likely)
		return
	case ir.OCONVNOP:
		cond := cond.(*ir.ConvExpr)
		s.stmtList(cond.Init())
		s.condBranch(cond.X, yes, no, likely)
		return
	}
	c := s.expr(cond)
	b := s.endBlock()
	b.Kind = ssa.BlockIf
	b.SetControl(c)