buf.append('{');
                boolean first2 = true;
                for (final Map.Entry<String, Object> entry : doc.entrySet()) {
                    final String name = entry.getKey();
                    if (StringUtil.isNotBlank(name) && entry.getValue() != null) {
                        if (!first2) {
                            buf.append(',');
                        } else {

        ntlmConnection.disconnect();

        // Assert
        verify(mockConnection).disconnect();
        // Connection should be closed after disconnect
    }

    /**
     * Test simple getter methods that should trigger the handshake.
     * We mock a simple 200 OK response to test the handshake is called.
     * @throws IOException
     */
    @Test
    void testGettersTriggerHandshake() throws IOException {

            KerberosCredentials credentials = new KerberosCredentials(LOGIN_CONTEXT_NAME);
            KerberosKey foundKey = credentials.getKey(KEY_TYPE_1);
            assertNotNull(foundKey);
            assertEquals(key1, foundKey);
        }
    }

    /**
     * Test getKey method when the requested key type does not exist.
     *
     * @throws LoginException if login fails.
     */
    @Test

        decodedContext.decode(buffer, 0, buffer.length);

        // Verify decoded values
        assertArrayEquals(originalKey.getKey(), decodedContext.getLeaseKey().getKey());
        assertEquals(originalLeaseState, decodedContext.getLeaseState());
        assertEquals(originalScope, decodedContext.getCacheScope());
        assertEquals(60000L, decodedContext.getMaxCacheAge());

    @Test
    @DisplayName("Should generate random lease key with correct size")
    void testRandomLeaseKeyGeneration() {
        Smb2LeaseKey key = new Smb2LeaseKey();

        assertNotNull(key.getKey());
        assertEquals(16, key.getKey().length);
        assertFalse(key.isZero());
    }

    @Test
    @DisplayName("Should create lease key from byte array")
    void testLeaseKeyFromBytes() {

        assertTrue(result);
        assertEquals(1, chain.changePasswordCalls.size());
        assertEquals("testuser", chain.changePasswordCalls.get(0).getKey());
        assertEquals("newpassword123", chain.changePasswordCalls.get(0).getValue());
    }

    // Test changePassword with failure
    public void test_changePassword_failure() {

        }

        @Test
        @DisplayName("Should get and set key")
        void testKey() {
            assertNull(referralData.getKey());
            referralData.setKey("cache-key-123");
            assertEquals("cache-key-123", referralData.getKey());
        }

        @Test
        @DisplayName("Should get server")
        void testGetServer() {
            assertNull(referralData.getServer());

        public int compare(Entry<AnEnum, String> left, Entry<AnEnum, String> right) {
          return left.getKey().compareTo(right.getKey());
        }
      }.sortedCopy(insertionOrder);
    }
  }

  public static class ImmutableMapValuesAsSingletonSetGenerator
      implements TestMapGenerator<String, Collection<Integer>> {

    @Override
    public SampleElements<Entry<String, Collection<Integer>>> samples() {

            when(mockReferralData.getKey()).thenReturn(key);
            doNothing().when(mockReferralData).setKey(key);

            mockReferralData.setKey(key);
            String retrievedKey = mockReferralData.getKey();

            assertEquals(key, retrievedKey);
            verify(mockReferralData, times(1)).setKey(key);
            verify(mockReferralData, times(1)).getKey();

            }
          }
        }
      }
    }
  }

  private void assertRelated(int groupNumber, int itemNumber, int relatedItemNumber) {
    Item<T> itemInfo = getItem(groupNumber, itemNumber);
    Item<T> relatedInfo = getItem(groupNumber, relatedItemNumber);

    T item = itemInfo.value;
    T related = relatedInfo.value;
    assertWithTemplate(
        "$ITEM must be $RELATIONSHIP to $OTHER",