call: Call,
          e: IOException,
        ): Unit = throw AssertionError()

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          try {
            responseRef.put(response)
          } catch (e: InterruptedException) {
            throw AssertionError()
          }
        }
      },
    )

        return MethodUtil.invoke(method, target, args);
    }

    @Override
    public <T> T invokeStatic(final Object... args) {
        if (!isStatic()) {
            throw new MethodNotStaticRuntimeException(getBeanDesc().getBeanClass(), methodName);
        }
        return MethodUtil.invokeStatic(method, args);
    }

    try {
      while (true) {
        val event = takeEvent()
        if (eventClass.isInstance(event)) {
          return eventClass.cast(event)
        }
      }
    } catch (e: NoSuchElementException) {
      throw AssertionError("full event sequence: $fullEventSequence", e)
    }
  }

  /**
   * Remove and return the next event from the recorded sequence.
   *

                password = session.auth.getAnsiHash(session.transport.server.encryptionKey);
                passwordLength = password.length;
            } else if (DISABLE_PLAIN_TEXT_PASSWORDS) {
                throw new RuntimeException("Plain text passwords are disabled");
            } else {
                // plain text
                password = new byte[(session.auth.password.length() + 1) * 2];

            case 'b':
            case 'c':
            case 'd':
            case 'e':
            case 'f':
                value += 10 + arr[ai] - 'a';
                break;
            default:
                throw new IllegalArgumentException(new String(arr, offset, length));
            }
            count++;
        }

        return value;
    }

        try {
            Field field = SmbComWrite.class.getDeclaredField(fieldName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            throw new RuntimeException("Failed to access field " + fieldName, e);
        }
    }

    /**
     * Test that the constructor initializes all fields correctly
     */
    @Test
    public void testConstructor() {

  IncidentEdgeSet(ArchetypeGraph<N> graph, N node, EdgeType edgeType) {
    this.graph = graph;
    this.node = node;
    this.edgeType = edgeType;
  }

  @Override
  public boolean remove(@Nullable Object o) {
    throw new UnsupportedOperationException();
  }

  @Override
  public int size() {
    if (graph.isDirected()) {
      return predecessorsOrEmpty(node).size()
          + successorsOrEmpty(node).size()

/**
 * Tests for the {@link SmbComClose} class.
 */
public class SmbComCloseTest {

    private CIFSContext context;
    private PropertyConfiguration config;

    @BeforeEach
    public void setUp() throws CIFSException {
        // Create a mock configuration for testing
        Properties properties = new Properties();
        config = new PropertyConfiguration(properties);
        context = mock(CIFSContext.class);

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

    @BeforeEach
    void setUp() throws UnknownHostException {
        InetAddress localAddr = InetAddress.getByName("192.168.1.100");
        InetAddress remoteAddr = InetAddress.getByName("192.168.1.200");

        assertEquals("Incorrect function.", msgs[1]);
        assertEquals("Incorrect function.", msgs[2]);
    }

    @Test
    @DisplayName("Messages: accessing invalid index throws ArrayIndexOutOfBoundsException")
    void messagesOutOfBoundsThrows() {
        // Arrange
        String[] msgs = DosError.DOS_ERROR_MESSAGES;

        // Act & Assert: negative index