for (final Dependency dep : runtimeDependencies) {
            // we do not need compile-only dependencies here
            if (compileOnlyArtifacts.contains(dep.getGroup() + ":" + dep.getName() + ":" + dep.getVersion())) {
                continue;
            }

            // only external dependencies are checked
            if (dep instanceof ProjectDependency) {
                continue;

import org.gradle.api.tasks.TaskAction;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.*;

/**
 * Checks adoc files for reversed multi-language snippet order.
 * Only rule enforced:
 *   In a ==== ... ==== block, if there are at least two [.multi-language-sample] snippets,
 *   flag when the first is GROOVY and the second is KOTLIN.
 */
@CacheableTask

Do not rely on `@NullMarked` annotations.
Only enable checks for a project if all its dependencies have checks enabled, in order to avoid back-and-forth when refining the annotations.

Avoid writing the so-called `PolyNull` or `ParametricNull` methods (where nullability of the result depends on the nullability of the type argument).

  @GwtIncompatible // used only from other GwtIncompatible code
  private static final class BitSetMatcher extends NamedFastMatcher {

    private final BitSet table;

    private BitSetMatcher(BitSet table, String description) {
      super(description);
      if (table.length() + Long.SIZE < table.size()) {
        table = (BitSet) table.clone();
        // If only we could actually call BitSet.trimToSize() ourselves...

import org.junit.jupiter.api.Test;

public class ContainerNotAvailableExceptionTest extends UnitFessTestCase {

    @Test
    public void test_constructor_withComponentName() {
        // Test constructor with component name only
        String componentName = "testComponent";
        ContainerNotAvailableException exception = new ContainerNotAvailableException(componentName);

  @get:JvmName("maxStaleSeconds") val maxStaleSeconds: Int,
  @get:JvmName("minFreshSeconds") val minFreshSeconds: Int,
  /**
   * This field's name "only-if-cached" is misleading. It actually means "do not use the network".
   * It is set by a client who only wants to make a request if it can be fully satisfied by the
   * cache. Cached responses that would require validation (ie. conditional gets) are not permitted

JSON can only contain UTF-8 encoded strings, so it can't contain raw bytes.

Base64 can encode binary data in strings, but to do it, it needs to use more characters than the original binary data, so it would normally be less efficient than regular files.

Use base64 only if you definitely need to include binary data in JSON, and you can't use files for that.

import com.google.common.annotations.J2ktIncompatible;
import java.time.Duration;

/** This class is for {@code com.google.common.collect} use only! */
@J2ktIncompatible
@GwtIncompatible // java.time.Duration
@IgnoreJRERequirement // We use this method only from within APIs that require a Duration.
final class Internal {

  /**
   * Returns the number of nanoseconds of the given duration without throwing or overflowing.

Let's imagine that you have a database `fake_db` that only receives JSON compatible data.

For example, it doesn't receive `datetime` objects, as those are not compatible with JSON.

So, a `datetime` object would have to be converted to a `str` containing the data in [ISO format](https://en.wikipedia.org/wiki/ISO_8601).

The same way, this database wouldn't receive a Pydantic model (an object with attributes), only a `dict`.

  @J2ktIncompatible
  @GwtIncompatible // used only from suite
  public static final class ImmutableIntArrayAsListGenerator extends TestIntegerListGenerator {
    @Override
    protected List<Integer> create(Integer[] elements) {
      return makeArray(elements).asList();
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // used only from suite