public void setExcludes(List<String> excludes) {
        this.excludes = excludes;
    }

    @OutputFile
    private File reportFile = new File(getProject().getBuildDir(), "reports/licenseHeaders/rat.xml");

    /**
     * Allowed license families for this project.
     */
    @Input
    private List<String> approvedLicenses = new ArrayList<String>(Arrays.asList("SSPL+Elastic License", "Generated", "Vendored", "Apache LZ4-Java"));

        hasAttribute(ctMethod, AttributePredicate.functionAttribute(KmFunction::isInfix))

    private
    fun hasAttribute(ctClass: CtClass, predicate: AttributePredicate): Boolean =
        queryKotlinMetadata(ctClass) { metadata ->
            metadata.hasAttribute(MemberType.TYPE, ctClass.name, predicate)
        }

    private
    fun hasAttribute(ctMember: CtMember, predicate: AttributePredicate): Boolean =

import okio.Buffer
import okio.BufferedSource
import okio.ByteString.Companion.encodeUtf8
import okio.Options

class ServerSentEventReader(
  private val source: BufferedSource,
  private val callback: Callback,
) {
  private var lastId: String? = null

  interface Callback {
    fun onEvent(
      id: String?,
      type: String?,
      data: String,
    )

 *
 * @since 3.0
 */
@Singleton
@Named
public class DefaultLifecyclePluginAnalyzer implements LifeCyclePluginAnalyzer {

    private final Logger logger = LoggerFactory.getLogger(getClass());

    private final Lookup lookup;

    private final DefaultLifecycles defaultLifeCycles;

    @Inject
    public DefaultLifecyclePluginAnalyzer(Lookup lookup, DefaultLifecycles defaultLifeCycles) {

      return new ReverseList<>(list);
    }
  }

  private static class ReverseList<T extends @Nullable Object> extends AbstractList<T> {
    private final List<T> forwardList;

    ReverseList(List<T> forwardList) {
      this.forwardList = checkNotNull(forwardList);
    }

    List<T> getForwardList() {
      return forwardList;
    }

    private int reverseIndex(int index) {
      int size = size();

@Tag("it")
public class ReqHeaderTests extends CrudTestBase {

    private static final String NAME_PREFIX = "reqHeaderTest_";
    private static final String API_PATH = "/api/admin/reqheader";
    private static final String LIST_ENDPOINT_SUFFIX = "settings";
    private static final String ITEM_ENDPOINT_SUFFIX = "setting";

    private static final String KEY_PROPERTY = "name";

    @Override

            }
        }

        private
        fun currentVersionEnabled(currentVersionUnderTest: String): Boolean {
            val versionUnderTest = GradleVersion.version(currentVersionUnderTest).baseVersion
            return GradleVersion.version(startVersionInclusive) <= versionUnderTest
                && versionUnderTest < GradleVersion.version(endVersionExclusive)
        }

        private

    // A tiny mock to illustrate Mockito interaction patterns.
    @Mock
    private SmbComTransactionResponse transactionMock;

    @BeforeEach
    void setUp() {
        transactionMock = mock(SmbComTransactionResponse.class);
    }

    @Test
    void testSmbComQueryInformationResponseGetters() throws Exception {
        // The constructor is package‑private; use an anonymous subclass

 *
 * @author Colin Decker
 */
@NullUnmarked
public final class TestByteSource extends ByteSource implements TestStreamSupplier {

  private final byte[] bytes;
  private final ImmutableSet<TestOption> options;

  private boolean inputStreamOpened;
  private boolean inputStreamClosed;

  TestByteSource(byte[] bytes, TestOption... options) {
    this.bytes = checkNotNull(bytes);

import java.lang.reflect.Method;

/**
 * Context for an exception thrown by a subscriber.
 *
 * @since 16.0
 */
public class SubscriberExceptionContext {
  private final EventBus eventBus;
  private final Object event;
  private final Object subscriber;
  private final Method subscriberMethod;

  /**
   * @param eventBus The {@link EventBus} that handled the event and the subscriber. Useful for