}
    }

    // Helper method to create test user
    private User createTestUser(String username) {
        User user = new User();
        user.setName(username);
        return user;
    }

    // Test implementation of AuthenticationChain
    private static class TestAuthenticationChain implements AuthenticationChain {
        int id;
        int updateCallCount = 0;

import org.opensearch.index.query.PrefixQueryBuilder;
import org.opensearch.index.query.QueryBuilder;

public class PrefixQueryCommandTest extends QueryTestBase {
    private PrefixQueryCommand queryCommand;
    private QueryFieldConfig queryFieldConfig;

    @Override
    protected void setUpChild() throws Exception {
        // Get the queryProcessor and queryFieldConfig that were registered in parent class

    /**
     * Helper method to create a valid notification buffer
     */
    private byte[] createValidNotificationBuffer(String fileName, int action) {
        return createNotificationBufferWithNextOffset(fileName, action, 0);
    }

    /**
     * Helper method to create a notification buffer with specified next offset
     */
    private byte[] createNotificationBufferWithNextOffset(String fileName, int action, int nextOffset) {

import jcifs.internal.smb2.Smb2Constants;

/**
 * Test class for Smb2QueryDirectoryRequest
 */
class Smb2QueryDirectoryRequestTest {

    @Mock
    private Configuration mockConfig;

    @Mock
    private CIFSContext mockContext;

    private Smb2QueryDirectoryRequest request;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);

 */
@SuppressWarnings("CheckReturnValue")
@NullUnmarked
public class ChainBenchmark {

  @Param({"1", "2", "3", "4", "5", "6"})
  int length;

  private Segment<Object, Object> segment;
  private ReferenceEntry<Object, Object> head;
  private @Nullable ReferenceEntry<Object, Object> chain;

  @SuppressWarnings("GuardedBy")
  @BeforeExperiment
  void setUp() {
    LocalCache<Object, Object> cache =

 *
 * @author James Sexton
 * @param <E> Edge parameter type
 */
final class EdgesConnecting<E> extends AbstractSet<E> {

  private final Map<?, E> nodeToOutEdge;
  private final Object targetNode;

  EdgesConnecting(Map<?, E> nodeToEdgeMap, Object targetNode) {
    this.nodeToOutEdge = checkNotNull(nodeToEdgeMap);
    this.targetNode = checkNotNull(targetNode);
  }

 */
@GwtCompatible
final class FunctionalEquivalence<F, T> extends Equivalence<F> implements Serializable {

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

  private final Function<? super F, ? extends @Nullable T> function;
  private final Equivalence<T> resultEquivalence;

  FunctionalEquivalence(
      Function<? super F, ? extends @Nullable T> function, Equivalence<T> resultEquivalence) {

  override fun hashCode(): Int = mediaType.hashCode()

  companion object {
    private const val TOKEN = "([a-zA-Z0-9-!#$%&'*+.^_`{|}~]+)"
    private const val QUOTED = "\"([^\"]*)\""
    private val TYPE_SUBTYPE = Regex("$TOKEN/$TOKEN")
    private val PARAMETER = Regex(";\\s*(?:$TOKEN=(?:$TOKEN|$QUOTED))?")

    /**
     * Returns a media type for this string.
     *

   */
  @SuppressWarnings("unchecked")
  public static <T> Collector<T, ?, Optional<T>> toOptional() {
    return (Collector) TO_OPTIONAL;
  }

  private static final Object NULL_PLACEHOLDER = new Object();

  private static final Collector<@Nullable Object, ?, @Nullable Object> ONLY_ELEMENT =
      Collector.<@Nullable Object, ToOptionalState, @Nullable Object>of(
          ToOptionalState::new,

 */
@ExtendWith(MockitoExtension.class)
class ChannelInfoTest {

    @Mock
    private SmbTransport mockTransport;

    @Mock
    private CommonServerMessageBlock mockOperation;

    private NetworkInterfaceInfo localInterface;
    private NetworkInterfaceInfo remoteInterface;
    private ChannelInfo channelInfo;

    @BeforeEach
    void setUp() throws UnknownHostException {