- name: Compile with Gradle with Build Scan
      if: ${{ matrix.language == 'java' && github.repository_owner == 'gradle' }}
      run: ./gradlew --init-script .github/workflows/codeql-analysis.init.gradle -DcacheNode=us -S testClasses -Dhttp.keepAlive=false
      env:
        # Set the DEVELOCITY_ACCESS_KEY so that Gradle Build Scans are generated
        DEVELOCITY_ACCESS_KEY: ${{ secrets.DEVELOCITY_ACCESS_KEY }}

    public final File file() {
      return home;
    }

    /** Scans this location and returns all scanned resources. */
    public ImmutableSet<ResourceInfo> scanResources() throws IOException {
      return scanResources(new HashSet<File>());
    }

    /**
     * Scans this location and returns all scanned resources.
     *

  cancel-in-progress: true

env:
  # Set the DEVELOCITY_ACCESS_KEY so that Gradle Build Scans are generated
  DEVELOCITY_ACCESS_KEY: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
  # Enable debug for the `gradle-build-action` cache operations
  GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true

permissions: {}

jobs:

func healObject(bucket, object, versionID string, scan madmin.HealScanMode) error {
	// Get background heal sequence to send elements to heal
	bgSeq, ok := globalBackgroundHealState.getHealSequenceByToken(bgHealingUUID)
	if ok {
		return bgSeq.healObject(bucket, object, versionID, scan)
	}
	return nil

                "-PtestJavaVendor=openjdk",
                "-Dscan.tag.FunctionalTest",
                "-Dscan.value.coverageOs=windows",
                "-Dscan.value.coverageArch=amd64",
                "-Dscan.value.coverageJvmVendor=openjdk",
                "-Dscan.value.coverageJvmVersion=java23",
                "-PflakyTests=exclude",
                "-Dscan.tag.Check",
                "-PteamCityBuildId=%teamcity.build.id%",

		// Use a string range loop to validate the sequence of runes.
		for i, expect = range test {
			if !s.Scan() {
				break
			}
			runeCount++
			got, _ := utf8.DecodeRune(s.Bytes())
			if got != expect {
				t.Errorf("#%d: %d: expected %q got %q", n, i, expect, got)
			}
		}
		if s.Scan() {
			t.Errorf("#%d: scan ran too long, got %q", n, s.Text())
		}
		testRuneCount := utf8.RuneCountInString(test)

}

func BenchmarkScan(b *testing.B) {
	user := *GetUser("scan", Config{})
	DB.Create(&user)

	var u User
	b.ResetTimer()
	for x := 0; x < b.N; x++ {
		DB.Raw("select * from users where id = ?", user.ID).Scan(&u)
	}
}

func BenchmarkScanSlice(b *testing.B) {
	DB.Exec("delete from users")
	for i := 0; i < 10_000; i++ {
		user := *GetUser(fmt.Sprintf("scan-%d", i), Config{})
		DB.Create(&user)
	}

	var u []User

            "%additional.gradle.parameters%",
            "--daemon",
            "--continue",
            "-DbuildScan.PartOf=PullRequestFeedback,ReadyforNightly,ReadyforRelease",
            "-Dscan.tag.PerformanceTest"
        )

        assertEquals(
            (
                listOf(
                    "clean",
                    ":performance:largeTestProjectPerformanceTest",

	return string(result), err
}

// UnixSecondSerializer json serializer
type UnixSecondSerializer struct{}

// Scan implements serializer interface
func (UnixSecondSerializer) Scan(ctx context.Context, field *Field, dst reflect.Value, dbValue interface{}) (err error) {
	t := sql.NullTime{}
	if err = t.Scan(dbValue); err == nil && t.Valid {
		err = field.Set(ctx, dst, t.Time.Unix())
	}

	return
}

        return "-Dorg.gradle.workers.max=%maxParallelForks% -PmaxParallelForks=%maxParallelForks% $pluginPortalUrlOverride -s --no-configuration-cache %additional.gradle.parameters% $daemon --continue $extraParameters -Dscan.tag.Check -Dscan.tag.PullRequestFeedback -PteamCityBuildId=%teamcity.build.id% \"$expectedInstallationPaths\" -Porg.gradle.java.installations.auto-download=false -Porg.gradle.java.installations.auto-detect=false"
    }