*
     * @param keyType the encryption type of the key to retrieve
     * @return the KerberosKey with the specified type, or null if not found
     */
    public KerberosKey getKey(int keyType) {
        KerberosKey serverKey = null;

        Set<Object> serverPrivateCredentials = this.subject.getPrivateCredentials();
        for (Object credential : serverPrivateCredentials) {

    }

    @Test
    @DisplayName("Test subCommand getter and setter")
    void testSubCommandGetterSetter() {
        byte subcommand = (byte) 0x05;
        response.setSubCommand(subcommand);
        assertEquals(subcommand, response.getSubCommand());
    }

    @Test
    @DisplayName("Test status getter and setter")
    void testStatusGetterSetter() {

    @DisplayName("Test Request methods inherited from CommonServerMessageBlockRequest")
    void testInheritedMethods() {
        // Given
        when(request.isResponseAsync()).thenReturn(true);
        when(request.getNext()).thenReturn(nextRequest);
        when(request.split()).thenReturn(nextRequest);
        when(request.allowChain(nextRequest)).thenReturn(true);
        when(request.createCancel()).thenReturn(nextRequest);

   * wish to override {@link #lower} to forward to this implementation.
   */
  protected @Nullable E standardLower(@ParametricNullness E e) {
    return Iterators.getNext(headSet(e, false).descendingIterator(), null);
  }

  @Override
  public @Nullable E floor(@ParametricNullness E e) {
    return delegate().floor(e);
  }

  /**

        assertThat(entry.getKey().getName(), is("T1"));
        assertThat(entry.getValue(), is(sameClass(Integer.class)));
        entry = it.next();
        assertThat(entry.getKey().getName(), is("T2"));
        assertThat(entry.getValue(), is(sameClass(Long.class)));
        entry = it.next();
        assertThat(entry.getKey().getName(), is("T1"));

      ImmutableList.Builder<V> valuesBuilder = new ImmutableList.Builder<>(entries.size());
      for (int i = 0; i < entries.size(); i++) {
        Range<K> range = entries.get(i).getKey();
        if (i > 0) {
          Range<K> prevRange = entries.get(i - 1).getKey();
          if (range.isConnected(prevRange) && !range.intersection(prevRange).isEmpty()) {
            throw new IllegalArgumentException(

            result.setRoles(toStringArray(source.get(ROLES)));
            result.setAttributes(source.entrySet()
                    .stream()
                    .filter(e -> isAttribute(e.getKey()))
                    .map(e -> new Pair<>(e.getKey(), (String) e.getValue()))
                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            return result;

    assertFalse(map.containsKey(getKey));
    assertSame(refreshKey, map.get(refreshKey));

    // let computation complete
    letGetFinishSignal.countDown();
    getFinishedSignal.await();
    checkNothingLogged();

    // asMap view should have been updated
    assertEquals(2, cache.size());
    assertEquals(getKey + suffix, map.get(getKey));

                    NavigableMap<String, String> map = new SafeTreeMap<>(Ordering.natural());
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return map;
                  }
                })
            .withFeatures(
                CollectionSize.ANY,

        FieldUtil.set(field, this, Integer.valueOf(testData));
        assertThat(FieldUtil.getInt(field, this), is(testData));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetIntFieldObject() throws Exception {
        final Field field = getClass().getField("INT_DATA");
        assertThat(FieldUtil.getInt(field), is(INT_DATA));
    }

    /**
     * @throws Exception
     */
    @Test