@Test(expected = IllegalPropertyRuntimeException.class)
    public void testGetValue_notReableWithField() throws Exception {
        final MyBean myBean = new MyBean();
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final PropertyDesc propDesc = beanDesc.getPropertyDesc("kkk");
        propDesc.getValue(myBean);
    }

    /**
     * @throws Exception
     */

        try {
          encoding.decode(cannotDecode);
          fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException expected) {
          if (expectedMessage != null) {
            assertThat(expected).hasCauseThat().hasMessageThat().isEqualTo(expectedMessage);
          }
        }
      }
    },
    DECODE_CHECKED {

  /** Checks that the current state is equal to the expected state. */
  @GuardedBy("monitor")
  private void checkCurrentState(State expected) {
    State actual = state();
    if (actual != expected) {
      if (actual == FAILED) {
        // Handle this specially so that we can include the failureCause, if there is one.
        throw new IllegalStateException(

              });
      fail("Expected NullPointerException or UnsupportedOperationException");
    } catch (NullPointerException | UnsupportedOperationException expected) {
    }
  }

  public void testMergeNullFunction() {
    try {
      getMap().merge(k0(), v3(), null);
      fail("Expected NullPointerException or UnsupportedOperationException");

    /**
     * Constructs a SMB2 query info response with the specified configuration and expected information types
     *
     * @param config
     *            the configuration to use for this response
     * @param expectInfoType
     *            the expected information type in the response
     * @param expectInfoClass
     *            the expected information class in the response
     */

    CharSource c2 = CharSource.wrap("");
    CharSource c3 = CharSource.wrap("de");

    String expected = "abcde";

    assertEquals(expected, CharSource.concat(ImmutableList.of(c1, c2, c3)).read());
    assertEquals(expected, CharSource.concat(c1, c2, c3).read());
    assertEquals(expected, CharSource.concat(ImmutableList.of(c1, c2, c3).iterator()).read());
    assertFalse(CharSource.concat(c1, c2, c3).isEmpty());

  fun receiveRequest(expected: String) =
    apply {
      actions += { stream ->
        val actual = stream.source.readUtf8(expected.utf8Size())
        if (actual != expected) throw AssertionError("$actual != $expected")
      }
    }

  fun exhaustRequest() =
    apply {
      actions += { stream ->
        if (!stream.source.exhausted()) throw AssertionError("expected exhausted")
      }
    }

      fail();
    } catch (TimeoutException expected) {
    } catch (ExecutionException e) {
      throw new AssertionError(e);
    }
  }

  static void verifyTimedGetOnPendingFuture(Future<?> future) {
    try {
      getUninterruptibly(future, 0, SECONDS);
      fail();
    } catch (TimeoutException expected) {
    } catch (ExecutionException e) {
      throw new AssertionError(e);
    }

        .build(),
    )
    val connection = server.url("/").toUrl().openConnection()
    try {
      connection.getInputStream().read()
      fail<Unit>()
    } catch (expected: IOException) {
      // Expected.
    }
  }

  @Test
  fun responseTimeout() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("ABC")
        .clearHeaders()

		if err != testCase.expectedErr {
			t.Errorf("TestXLStorage case %d: Expected: \"%s\", got: \"%s\"", i+1, testCase.expectedErr, err)
		}
		if err == nil {
			for _, expected := range testCase.expectedListDir {
				if !strings.Contains(strings.Join(dirList, ","), expected) {
					t.Errorf("TestXLStorage case %d: Expected the directory listing to be \"%v\", but got \"%v\"", i+1, testCase.expectedListDir, dirList)
				}