final Field field = getClass().getField("objectField");
        final Integer testData = Integer.valueOf(123);
        FieldUtil.set(field, this, testData);
        assertThat((Integer) FieldUtil.get(field, this), is(testData));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetIntField() throws Exception {
        final Field field = getClass().getField("intField");

        String accountName = (String) getField(obj, "accountName");
        String primaryDomain = (String) getField(obj, "primaryDomain");

        // The actual implementation keeps lowercase for guest when Unicode is not enabled
        assertEquals("guest", accountName);
        assertEquals("DOM", primaryDomain);

        byte[] lm = (byte[]) getField(obj, "lmHash");
        byte[] nt = (byte[]) getField(obj, "ntHash");

        // Validate parameter bytes using reflection since fields are private
        assertEquals(getField(cmd, "fid"), SMBUtil.readInt2(buffer, 0));
        assertEquals(getField(cmd, "typeOfLock"), buffer[2]);
        assertEquals(getField(cmd, "newOpLockLevel"), buffer[3]);
        assertEquals(getField(cmd, "timeout"), (long) SMBUtil.readInt4(buffer, 4));
        assertEquals(1, SMBUtil.readInt2(buffer, 8));

    void close_sharedFile_closesHandle_only() throws Exception {
        SmbRandomAccessFile raf = newInstance("rw", false, true, false);
        SmbFile file = (SmbFile) getField(raf, "file");
        SmbFileHandleImpl handle = (SmbFileHandleImpl) getField(raf, "handle");

        // Act
        raf.close();

        // Assert interactions
        verify(handle, atLeastOnce()).close();

   * Description} annotation on the {@code GOLF} constant of enum {@code Sport}, use {@code
   * Enums.getField(Sport.GOLF).getAnnotation(Description.class)}.
   *
   * @since 12.0
   */
  public static Field getField(Enum<?> enumValue) {
    Class<?>
        clazz = enumValue.getDeclaringClass();
    try {
      return clazz.getDeclaredField(enumValue.name());

   * Description} annotation on the {@code GOLF} constant of enum {@code Sport}, use {@code
   * Enums.getField(Sport.GOLF).getAnnotation(Description.class)}.
   *
   * @since 12.0
   */
  public static Field getField(Enum<?> enumValue) {
    Class<?>
        clazz = enumValue.getDeclaringClass();
    try {
      return clazz.getDeclaredField(enumValue.name());

        }
    }

    private void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
        Field field = getField(obj.getClass(), fieldName);
        field.setAccessible(true);
        field.set(obj, value);
    }

    private Field getField(Class<?> clazz, String fieldName) throws NoSuchFieldException {
        while (clazz != null) {
            try {

    @ExampleAnnotation
    FOO,
    BAR
  }

  @J2ktIncompatible
  public void testGetField() {
    Field foo = Enums.getField(AnEnum.FOO);
    assertThat(foo.getName()).isEqualTo("FOO");
    assertTrue(foo.isAnnotationPresent(ExampleAnnotation.class));

    Field bar = Enums.getField(AnEnum.BAR);
    assertThat(bar.getName()).isEqualTo("BAR");
    assertFalse(bar.isAnnotationPresent(ExampleAnnotation.class));
  }

    val settings = Settings()
    assertThat(settings.isSet(Settings.MAX_CONCURRENT_STREAMS)).isFalse()
    assertThat(settings.getMaxConcurrentStreams()).isEqualTo(Int.MAX_VALUE)
  }

  @Test
  fun setFields() {
    val settings = Settings()
    settings[Settings.HEADER_TABLE_SIZE] = 8096
    assertThat(settings.headerTableSize).isEqualTo(8096)
    assertThat(settings.getEnablePush(true)).isTrue()

        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final FieldDesc hoge = beanDesc.getFieldDesc("HOGE");
        assertThat(hoge.getBeanDesc(), is(sameInstance(beanDesc)));
        assertThat(hoge.getField(), is(MyBean.class.getDeclaredField("HOGE")));
        assertThat(hoge.getFieldName(), is("HOGE"));
        assertThat(hoge.getFieldType(), is(sameClass(String.class)));
        assertThat(hoge.isPublic(), is(true));