// This also avoids a race where if outputFuture is cancelled, it will call taskFuture.cancel,
      // which will call newFuture.setFuture(oldFuture), to allow the next task in the queue to run
      // without waiting for the user's executor to run our submitted Runnable. However, this can
      // interact poorly with the reentrancy-avoiding behavior of this executor - when the operation

      if (upper == POSITIVE_INFINITY) {
        // Return NaN when lower == NEGATIVE_INFINITY and upper == POSITIVE_INFINITY:
        return NaN;
      }
      // Return NEGATIVE_INFINITY when NEGATIVE_INFINITY == lower <= upper < POSITIVE_INFINITY:
      return NEGATIVE_INFINITY;
    }
    if (upper == POSITIVE_INFINITY) {
      // Return POSITIVE_INFINITY when NEGATIVE_INFINITY < lower <= upper == POSITIVE_INFINITY:

import java.io.File;

/**
 * Empty implementation of thumbnail generator that does not generate any thumbnails.
 * This class is used as a no-op thumbnail generator when thumbnail generation is disabled
 * or when no specific thumbnail generator is configured.
 */
public class EmptyGenerator extends BaseThumbnailGenerator {

    /**
     * Default constructor.
     */
    public EmptyGenerator() {

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).

import org.jspecify.annotations.Nullable;

/**
 * Captures a free type variable that can be used in {@link TypeToken#where}. For example:
 *
 * {@snippet :
 * static <T> TypeToken<List<T>> listOf(Class<T> elementType) {
 *   return new TypeToken<List<T>>() {}
 *       .where(new TypeParameter<T>() {}, elementType);
 * }
 * }
 *
 * @author Ben Yu
 * @since 12.0
 */
/*

 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingSortedMap}.
 *
 * <p>Each of the {@code standard} methods, where appropriate, use the comparator of the map to test
 * equality for both keys and values, unlike {@code ForwardingMap}.
 *

                }
            }
        """

        when:
        def result = WiremockFixture.withWireMock(mockRepoUrl, mockedContent) { server ->
            buildFile << repositoryMockSetup(server, jdkVendor, jdkVersion)
            gradleRunner("getJdk").build()
        }

        then:
        assertExtraction(result.output, expectedJavaBin);

        where:

        // only A, C, and E are whitelisted duplicates will occur. When scanning projects A, C, and E, those will be
        // added to 'filtered' as they are whitelisted. When scanning B and D, they are not whitelisted, and since
        // transitive is false, their downstream dependencies will be added to 'filtered'. E is a downstream dependency

	})

	if tx = queryTx.Find(dest, conds...); tx.RowsAffected == 0 {
		if c, ok := tx.Statement.Clauses["WHERE"]; ok {
			if where, ok := c.Expression.(clause.Where); ok {
				tx.assignInterfacesToValue(where.Exprs)
			}
		}

		// initialize with attrs, conds
		if len(tx.Statement.attrs) > 0 {
			tx.assignInterfacesToValue(tx.Statement.attrs...)
		}
	}

        assertEquals(1, d.getSetupCount(), "setupCount parsed");
        // When bufDataStart was zero it should be set to totalParameterCount
        assertEquals(5, d.getBufferDataStart(), "bufDataStart inferred from totalParameterCount");
    }

    /**
     * Exercise readBytesWireFormat where both parameter and data are
     * copied in a single call.
     */
    @Test