result.append("Not listening on called name");
                break;
            case NOT_LISTENING_CALLING:
                result.append("Not listening for calling name");
                break;
            case CALLED_NOT_PRESENT:
                result.append("Called name not present");
                break;
            case NO_RESOURCES:
                result.append("Called name present, but insufficient resources");

    }

    public void u(U u) {
      fail(
          "Method with parameter <U extends T> where <T extends @Nullable Object> should not be"
              + " called");
    }

    public <A extends @Nullable Object> void a(A a) {
      fail("Method with parameter <A extends @Nullable Object> should not be called");
    }

        // When
        String firstName = mockAddress.firstCalledName();

        // Then
        assertEquals(expectedFirstName, firstName, "Should return first called name");
        assertNotNull(firstName, "First called name should not be null");
    }

    @Test
    @DisplayName("nextCalledName should return valid name for fallback attempts")
    void testNextCalledNameContract() {
        // Given

    /**
     * Test that validateInputStream is called exactly once per getText call.
     */
    public void test_validateInputStream_calledOncePerGetText() {
        final InputStream in = new ByteArrayInputStream("test".getBytes());

        extractor.resetTestState();
        assertFalse("Should start with validate not called", extractor.isValidateCalled());

        extractor.getText(in, null);

        // Configure the mock NdrBuffer to return a specific value when dec_ndr_hyper is called
        when(mockNdrBuffer.dec_ndr_hyper()).thenReturn(decodedValue);

        // Call the decode method with the mocked NdrBuffer
        ndrHyper.decode(mockNdrBuffer);

        // Verify that dec_ndr_hyper was called exactly once
        verify(mockNdrBuffer, times(1)).dec_ndr_hyper();

     *
     * This method can only be called once.
     *
     * @param props the properties to use for initialization
     * @throws CIFSException if the singleton context is already initialized or there is an error during initialization
     */
    public static synchronized final void init(final Properties props) throws CIFSException {
        if (INSTANCE != null) {

            rpc.retval = 0;
            return null;
        }).when(mockDcerpcHandle).sendrecv(any(MsrpcSamrCloseHandle.class));

        // Act
        aliasHandle.close();

        // Assert
        // Verify that sendrecv was called with MsrpcSamrCloseHandle
        verify(mockDcerpcHandle).sendrecv(any(MsrpcSamrCloseHandle.class));
        // Verify that close was called only once on the mockDcerpcHandle for MsrpcSamrCloseHandle

    }

    @Test
    void testEquals() {
        // Test equals method
        mockName = new Name(mockConfig, "TEST1", 0x20, null);
        Name mockName2 = new Name(mockConfig, "TEST2", 0x20, null);
        Name mockName3 = new Name(mockConfig, "TEST3", 0x20, null);
        NbtAddress nbtAddress1 = new NbtAddress(mockName, testAddressInt, false, NbtAddress.H_NODE);

          private boolean called = false;

          @Override
          public void onSuccess(String result) {
            fail("Was not expecting onSuccess() to be called.");
          }

          @Override
          public void onFailure(Throwable t) {
            synchronized (monitor) {
              assertFalse(called);
              assertThat(t).isInstanceOf(CancellationException.class);

        // Configure the mock to return a specific value when dec_ndr_long is called
        when(mockNdrBuffer.dec_ndr_long()).thenReturn(decodedValue);

        NdrLong ndrLong = new NdrLong(0); // Initialize with a dummy value

        // Call the decode method
        ndrLong.decode(mockNdrBuffer);

        // Verify that dec_ndr_long was called exactly once
        verify(mockNdrBuffer, times(1)).dec_ndr_long();