From 519e32be29c90d547472463395f1b036a756fa65 Mon Sep 17 00:00:00 2001 From: cpovirk Date: Tue, 13 Oct 2026 13:31:47 -0700 Subject: [PATCH] Fix and update Bazel build/test configuration: - Run Bazel CI tests under the configured matrix JDK runtimes rather than always using `.bazelrc`'s default runtime (which prior to this CL was JDK 21). - Standardize the version matrix on [8, 11, 25]. - I will have to bypass the Copybara presubmit for this CL because it will still be looking for a JDK 22 Flogger job instead of the new JDK 25 job (b/360096677). Maybe I should rename all our projects' "25" jobs to "latest LTS".... - I will "have to" update [the Flogger branch-protection rules](https://github.com/google/flogger/settings/branch_protection_rules/42636378) to require the new JDK 25 job instead of the JDK 22 job that I'm removing. (IIRC, nothing actually blocks on that, but it's nice for it to match our "real" rules.) - Huh, apparently GitHub is nudging me from branch-protection rules to ["rulesets."](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-rulesets/about-rulesets) I'm not going to worry about that now. - For Bazel toolchain/`exec` operations, use a JDK 25 (including allowing Java 25 language features), and for the `bazel`/`mvn` VM itself, have CI request JDK 27. - 25 (as the most recent LTS) is the newest version that Bazel has available for automatic download across all platforms. (It has 27 for Linux only.) - For selecting the language version, use `--java_language_version=8` instead of `--release` or `-source -target`. It's shorter and more standard, and Bazel even silences the deprecation warning that we'd otherwise see when targeting 8. - Remove redundant debug-info javac options (`-g`) in Flogger: `rules_java` enables it (along with `-parameters`) by default nowadays. - Enable `--experimental_one_version_enforcement=error` as widely as we can. - Upgrade Flogger's `bazel_common` dep. - Set `test --test_env=TZ=UTC`. - Configure `ci.yml` to cache the right(?) Bazel information (`~/.cache/bazel/*/cache`, including `cache/repos/v1`, instead of `~/.cache/bazel/*/*/external`). Prep work: - Skip Flogger tests that use Mockito under Java 8. Mockito 5+ requires Java 11+. (It would make sense to skip under Java 9 and Java 10, too, but meh.) - Set `--jvmopt=-Dnet.bytebuddy.experimental=true` for Flogger to enable support for Java-25 class files. Compare cl/996591293. RELNOTES=n/a PiperOrigin-RevId: 998856377 --- .bazelrc | 12 ++++++--- .github/workflows/ci.yml | 12 ++++----- MODULE.bazel | 2 +- .../common/flogger/MetadataKeyTest.java | 9 +++++++ .../backend/system/DefaultPlatformTest.java | 26 ++++++++++++++----- .../DefaultBraceStyleMessageParserTest.java | 7 +++++ .../DefaultPrintfMessageParserTest.java | 7 +++++ .../backend/slf4j/Slf4jBackendLoggerTest.java | 11 ++++++++ 8 files changed, 68 insertions(+), 18 deletions(-) diff --git a/.bazelrc b/.bazelrc index 4375f447..16404383 100644 --- a/.bazelrc +++ b/.bazelrc @@ -1,5 +1,9 @@ -# Include debug info in the compiled jars -build --javacopt=-g -build --host_javacopt=-g +build --java_language_version=8 --tool_java_language_version=25 +build --java_runtime_version=25 --tool_java_runtime_version=25 -build --java_runtime_version=21 --javacopt='-source 8 -target 8' +build --experimental_one_version_enforcement=error + +test --test_env=TZ=UTC + +# TODO(cpovirk): Remove after bumping version of ByteBuddy to support Java-25 class files by default. +test --jvmopt=-Dnet.bytebuddy.experimental=true diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1e50297d..52a17d62 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -21,7 +21,7 @@ jobs: name: "JDK ${{ matrix.java }}" strategy: matrix: - java: [8, 11, 22] + java: [8, 11, 25] runs-on: ubuntu-latest steps: - name: 'Check out repository' @@ -31,19 +31,19 @@ jobs: - name: 'Cache Bazel dependencies' uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 with: - path: ~/.cache/bazel/*/*/external + path: ~/.cache/bazel/*/cache key: bazel-${{ hashFiles('MODULE.bazel') }} restore-keys: | bazel- - - name: 'Set up JDK ${{ matrix.java }}' + - name: 'Set up JDK 27' uses: actions/setup-java@de7274f081f381c8f8158605e0321c36c376e2e6 # v6.0.1 with: - java-version: ${{ matrix.java }} + java-version: 27 distribution: 'temurin' - name: 'Test' shell: bash - run: bazelisk test --lockfile_mode=error --test_output=errors //... + run: bazelisk test --java_runtime_version=${{ matrix.java }} --lockfile_mode=error --test_output=errors //... - name: 'Test Deploy Script' - if: matrix.java == 22 + if: matrix.java == 25 shell: bash run: release/install-local-snapshot.sh diff --git a/MODULE.bazel b/MODULE.bazel index e9f3abb5..2a4941b9 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -17,6 +17,6 @@ bazel_dep(name = "rules_java", version = "9.9.0") bazel_dep(name = "google_bazel_common") git_override( module_name = "google_bazel_common", - commit = "3af0219202168b1e988307fdbadc7a477d2f1f5a", + commit = "d8b14684b16e91516a040c37c872bef9f396e441", remote = "https://github.com/google/bazel-common", ) diff --git a/api/src/test/java/com/google/common/flogger/MetadataKeyTest.java b/api/src/test/java/com/google/common/flogger/MetadataKeyTest.java index f37ad8d8..db58a3c1 100644 --- a/api/src/test/java/com/google/common/flogger/MetadataKeyTest.java +++ b/api/src/test/java/com/google/common/flogger/MetadataKeyTest.java @@ -16,7 +16,9 @@ package com.google.common.flogger; +import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION; import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.TruthJUnit.assume; import static java.util.Arrays.asList; import static org.junit.Assert.fail; @@ -107,6 +109,7 @@ public void testCasting() { @Test public void testDefaultEmit() { + assume().that(jvmTooOldForMockito5()).isFalse(); MetadataKey k = MetadataKey.single("foo", String.class); KeyValueHandler handler = Mockito.mock(KeyValueHandler.class); k.safeEmit("123", handler); @@ -115,6 +118,7 @@ public void testDefaultEmit() { @Test public void testDefaultEmitRepeated() { + assume().that(jvmTooOldForMockito5()).isFalse(); MetadataKey k = MetadataKey.repeated("foo", String.class); KeyValueHandler handler = Mockito.mock(KeyValueHandler.class); k.safeEmitRepeated(iterate("123", "abc"), handler); @@ -124,6 +128,7 @@ public void testDefaultEmitRepeated() { @Test public void testDefaultEmitRepeated_singleKeyFails() { + assume().that(jvmTooOldForMockito5()).isFalse(); MetadataKey k = MetadataKey.single("foo", String.class); KeyValueHandler handler = Mockito.mock(KeyValueHandler.class); try { @@ -203,4 +208,8 @@ public void testNulls() { } catch (NullPointerException expected) { } } + + private static boolean jvmTooOldForMockito5() { + return JAVA_SPECIFICATION_VERSION.value().equals("1.8"); + } } diff --git a/api/src/test/java/com/google/common/flogger/backend/system/DefaultPlatformTest.java b/api/src/test/java/com/google/common/flogger/backend/system/DefaultPlatformTest.java index aeed50e1..d4eec644 100644 --- a/api/src/test/java/com/google/common/flogger/backend/system/DefaultPlatformTest.java +++ b/api/src/test/java/com/google/common/flogger/backend/system/DefaultPlatformTest.java @@ -16,7 +16,9 @@ package com.google.common.flogger.backend.system; +import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION; import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.TruthJUnit.assume; import com.google.common.flogger.backend.LoggerBackend; import com.google.common.flogger.backend.Platform.LogCallerFinder; @@ -25,9 +27,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; -import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; /** * These tests check that the internal implementation of the configured platform "plugins" works as @@ -61,17 +61,25 @@ protected long getCurrentTimeNanosImpl() { } } - @Mock BackendFactory mockBackendFactory; - @Mock ContextDataProvider mockContext; - @Mock Clock mockClock; - @Mock LogCallerFinder mockCallerFinder; + /* + * We avoid `@Mock` so that we defer loading Mockito classes (which require Java 11+) until we + * know we're not running under Java 8. + */ + BackendFactory mockBackendFactory; + ContextDataProvider mockContext; + Clock mockClock; + LogCallerFinder mockCallerFinder; // The fake platform doesn't attempt to look up any real services, they are just injected mocks. private FakeDefaultPlatform platform; @Before public void initializeMocks() { - MockitoAnnotations.initMocks(this); + assume().that(jvmTooOldForMockito5()).isFalse(); + mockBackendFactory = Mockito.mock(BackendFactory.class); + mockContext = Mockito.mock(ContextDataProvider.class); + mockClock = Mockito.mock(Clock.class); + mockCallerFinder = Mockito.mock(LogCallerFinder.class); Mockito.when(mockBackendFactory.toString()).thenReturn("Mock Backend Factory"); Mockito.when(mockContext.toString()).thenReturn("Mock Logging Context"); Mockito.when(mockClock.toString()).thenReturn("Mock Clock"); @@ -111,4 +119,8 @@ public void testConfigString() { assertThat(platform.getConfigInfoImpl()).contains("ContextDataProvider: Mock Logging Context"); assertThat(platform.getConfigInfoImpl()).contains("LogCallerFinder: Mock Caller Finder"); } + + private static boolean jvmTooOldForMockito5() { + return JAVA_SPECIFICATION_VERSION.value().equals("1.8"); + } } diff --git a/api/src/test/java/com/google/common/flogger/parser/DefaultBraceStyleMessageParserTest.java b/api/src/test/java/com/google/common/flogger/parser/DefaultBraceStyleMessageParserTest.java index fdbad88a..bbcd5e81 100644 --- a/api/src/test/java/com/google/common/flogger/parser/DefaultBraceStyleMessageParserTest.java +++ b/api/src/test/java/com/google/common/flogger/parser/DefaultBraceStyleMessageParserTest.java @@ -16,7 +16,9 @@ package com.google.common.flogger.parser; +import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION; import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.TruthJUnit.assume; import static org.junit.Assert.fail; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; @@ -40,6 +42,7 @@ public class DefaultBraceStyleMessageParserTest { @Test public void testParseBraceFormat() throws ParseException { + assume().that(jvmTooOldForMockito5()).isFalse(); MessageBuilder builder = mock(MessageBuilder.class); // Parse just the 3 characters representing the brace format specifier between position 6 and 9. // The -1 indicates that there's no additional formatting information after the index. @@ -69,4 +72,8 @@ public void testTrailingFormatNotSupportedInBraceFormat() { assertThat(expected.getMessage()).contains("[:x]"); } } + + private static boolean jvmTooOldForMockito5() { + return JAVA_SPECIFICATION_VERSION.value().equals("1.8"); + } } diff --git a/api/src/test/java/com/google/common/flogger/parser/DefaultPrintfMessageParserTest.java b/api/src/test/java/com/google/common/flogger/parser/DefaultPrintfMessageParserTest.java index ca4d048b..e113f502 100644 --- a/api/src/test/java/com/google/common/flogger/parser/DefaultPrintfMessageParserTest.java +++ b/api/src/test/java/com/google/common/flogger/parser/DefaultPrintfMessageParserTest.java @@ -16,7 +16,9 @@ package com.google.common.flogger.parser; +import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION; import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.TruthJUnit.assume; import static org.junit.Assert.fail; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; @@ -37,6 +39,7 @@ public class DefaultPrintfMessageParserTest { @Test public void testParsePrintf() throws ParseException { + assume().that(jvmTooOldForMockito5()).isFalse(); MessageBuilder builder = mock(MessageBuilder.class); int unused = PARSER.parsePrintfTerm(builder, 1, "Hello %2$+06.2f World", 6, 9, 14); @@ -80,4 +83,8 @@ public void testInvalidPrintfFlags() { assertThat(expected.getMessage()).contains("[%0s]"); } } + + private static boolean jvmTooOldForMockito5() { + return JAVA_SPECIFICATION_VERSION.value().equals("1.8"); + } } diff --git a/slf4j/src/test/java/com/google/common/flogger/backend/slf4j/Slf4jBackendLoggerTest.java b/slf4j/src/test/java/com/google/common/flogger/backend/slf4j/Slf4jBackendLoggerTest.java index 8c94050e..7b952f53 100644 --- a/slf4j/src/test/java/com/google/common/flogger/backend/slf4j/Slf4jBackendLoggerTest.java +++ b/slf4j/src/test/java/com/google/common/flogger/backend/slf4j/Slf4jBackendLoggerTest.java @@ -16,6 +16,8 @@ package com.google.common.flogger.backend.slf4j; +import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION; +import static com.google.common.truth.TruthJUnit.assume; import static org.junit.Assert.fail; import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; @@ -46,6 +48,7 @@ private static LoggerBackend newBackend(Logger logger) { @Test public void testMessage() { + assume().that(jvmTooOldForMockito5()).isFalse(); Logger logger = mock(Logger.class); LoggerBackend backend = newBackend(logger); @@ -60,6 +63,7 @@ public void testMessage() { @Test public void testMetadata() { + assume().that(jvmTooOldForMockito5()).isFalse(); Logger logger = mock(Logger.class); LoggerBackend backend = newBackend(logger); @@ -74,6 +78,7 @@ public void testMetadata() { @Test public void testLevels() { + assume().that(jvmTooOldForMockito5()).isFalse(); Logger logger = mock(Logger.class); LoggerBackend backend = newBackend(logger); @@ -98,6 +103,7 @@ public void testLevels() { @Test public void testErrorHandling() { + assume().that(jvmTooOldForMockito5()).isFalse(); Logger logger = mock(Logger.class); LoggerBackend backend = newBackend(logger); @@ -130,6 +136,7 @@ public void testErrorHandling() { @Test public void testWithThrown() { + assume().that(jvmTooOldForMockito5()).isFalse(); Logger logger = mock(Logger.class); LoggerBackend backend = newBackend(logger); @@ -138,4 +145,8 @@ public void testWithThrown() { verify(logger).info("Hello World", cause); } + + private static boolean jvmTooOldForMockito5() { + return JAVA_SPECIFICATION_VERSION.value().equals("1.8"); + } }