import org.jspecify.annotations.Nullable;

/**
 * Tests for {@code ForwardingQueue}.
 *
 * @author Robert Konigsberg
 * @author Louis Wasserman
 */
@NullUnmarked
public class ForwardingQueueTest extends TestCase {

  static final class StandardImplForwardingQueue<T> extends ForwardingQueue<T> {
    private final Queue<T> backingQueue;

    StandardImplForwardingQueue(Queue<T> backingQueue) {

import static java.lang.annotation.RetentionPolicy.CLASS;

import com.google.common.annotations.GwtCompatible;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

/**
 * Annotates a "top-level" type-variable usage that takes its nullness from the type argument
 * supplied by the user of the class. For example, {@code Multiset.Entry.getElement()} returns

# Custom Response Classes - File, HTML, Redirect, Streaming, etc.

There are several custom response classes you can use to create an instance and return them directly from your *path operations*.

Read more about it in the [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.tiangolo.com/advanced/custom-response/).

You can import them directly from `fastapi.responses`:

```python
from fastapi.responses import (
    FileResponse,

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.service;

/**
 * Abstract base class for Fess application services.
 * This class provides common functionality and utilities for service implementations
 * throughout the Fess search application.
 */
public abstract class FessAppService {

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

 */
public class MatchAllQueryCommand extends QueryCommand {

    /**
     * Default constructor.
     */
    public MatchAllQueryCommand() {
        super();
    }

    private static final Logger logger = LogManager.getLogger(MatchAllQueryCommand.class);

    @Override
    protected String getQueryClassName() {
        return MatchAllDocsQuery.class.getSimpleName();
    }

    @Override

  override fun <T : Any> tag(type: KClass<T>): T? = error("unexpected")

  override fun <T> tag(type: Class<out T>): T? = error("unexpected")

  override fun <T : Any> tag(
    type: KClass<T>,
    computeIfAbsent: () -> T,
  ): T = error("unexpected")

  override fun <T : Any> tag(
    type: Class<T>,
    computeIfAbsent: () -> T,
  ): T = error("unexpected")

package com.google.common.graph;

import org.jspecify.annotations.Nullable;

/**
 * This class provides a skeletal implementation of {@link Graph}. It is recommended to extend this
 * class rather than implement {@link Graph} directly.
 *
 * @author James Sexton
 * @param <N> Node parameter type
 * @since 20.0
 */
public abstract class AbstractGraph<N> extends AbstractBaseGraph<N> implements Graph<N> {

const val FINAL_RELEASE_BUILD_CONFIGURATION_ID = "Promotion_FinalRelease"
const val RELEASE_CANDIDATE_BUILD_CONFIGURATION_ID = "Promotion_ReleaseCandidate"
const val MILESTONE_BUILD_CONFIGURATION_ID = "Promotion_Milestone"

abstract class PublishRelease(
    prepTask: String,
    promoteTask: String,
    requiredConfirmationCode: String,
    promotedBranch: String,
    init: PublishRelease.() -> Unit = {},
) : PublishGradleDistributionFullBuild(

          }
      }.sorted()
  }
}

@Disabled("Don't run by default")
@Tag("Slow")
class AllMainsTest {
  @ParameterizedTest
  @ArgumentsSource(MainTestProvider::class)
  fun runMain(className: String) {
    val mainMethod =
      Class
        .forName(className)
        .methods
        .find { it.name == "main" }
    try {
      if (mainMethod != null) {

import static org.mockito.Mockito.when;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;

/**
 * Test class for DfsReferralData interface functionality
 */
@DisplayName("DfsReferralData Interface Tests")
class DfsReferralDataTest extends BaseTest {

    @Mock
    private DfsReferralData mockReferralData;

    @Test
    @DisplayName("Should define interface methods")