setImplementation(Appendable.class, StringBuilder.class);
    setImplementation(BlockingQueue.class, LinkedBlockingDeque.class);
    setImplementation(BlockingDeque.class, LinkedBlockingDeque.class);
    setImplementation(ConcurrentMap.class, ConcurrentHashMap.class);
    setImplementation(ConcurrentNavigableMap.class, ConcurrentSkipListMap.class);
    setImplementation(CountDownLatch.class, Dummies.DummyCountDownLatch.class);

    }

    /**
     *
     */
    @Test
    public void testGetWrapperClassIfWrapper() {
        assertThat(ClassUtil.getWrapperClassIfPrimitive(int.class), is(sameClass(Integer.class)));
        assertThat(ClassUtil.getWrapperClassIfPrimitive(String.class), is(sameClass(String.class)));
        assertThat(ClassUtil.getWrapperClassIfPrimitive(byte.class), is(sameClass(Byte.class)));
    }

     * <li>If the class loader that loaded the target class can be obtained, that class loader</li>
     * <li>If the class loader that loaded this class can be obtained, that class loader</li>
     * <li>If the system class loader can be obtained, that class loader</li>
     * </ol>
     * <p>

          .put(NullPointerException.class, e -> e instanceof NullPointerException)
          .put(NumberFormatException.class, e -> e instanceof NumberFormatException)
          .put(RuntimeException.class, e -> e instanceof RuntimeException)
          .put(TimeoutException.class, e -> e instanceof TimeoutException)

 * specify {@literal false} for the second argument of {@link #iterable(Class, boolean)} or {@link #ClassIterator(Class, boolean)}.
 * </p>
 *
 * @author koichik
 */
public class ClassIterator implements Iterator<Class<?>> {

    /** The class */
    protected Class<?> clazz;

    /** If {@link Object} class should also be iterated, set to {@literal true} */
    protected final boolean includeObject;

    /**

  override fun getSendBufferSize(): Int = delegate!!.sendBufferSize

  @Throws(SocketException::class)
  override fun getSoTimeout(): Int = delegate!!.soTimeout

  @Throws(SocketException::class)
  override fun getTcpNoDelay(): Boolean = delegate!!.tcpNoDelay

  @Throws(SocketException::class)
  override fun setKeepAlive(keepAlive: Boolean) {
    delegate!!.keepAlive = keepAlive
  }

        assertTrue("FessWebResourceRoot should extend StandardRoot", StandardRoot.class.isAssignableFrom(FessWebResourceRoot.class));
        assertTrue("FessWebResourceRoot should implement WebResourceRoot",
                WebResourceRoot.class.isAssignableFrom(FessWebResourceRoot.class));
    }

    public void test_classStructure() {
        // Basic class structure tests that don't require complex mocking

  private static Class<? extends Annotation> asAnnotation(Class<?> clazz) {
    if (clazz.isAnnotation()) {
      return (Class<? extends Annotation>) clazz;
    } else {
      throw new IllegalArgumentException(rootLocaleFormat("%s is not an annotation.", clazz));
    }
  }

  public void testFeatureEnums() throws Exception {
    assertGoodFeatureEnum(CollectionFeature.class);

import org.codelibs.core.exception.MethodNotStaticRuntimeException;
import org.codelibs.core.lang.MethodUtil;

/**
 * Implementation class of {@link MethodDesc}.
 *
 * @author koichik
 */
public class MethodDescImpl implements MethodDesc {

    /** The {@link BeanDesc} of the class that owns this method */
    protected final BeanDesc beanDesc;

    /** The method */
    protected final Method method;

        final PropertyDesc propDesc = beanDesc.getPropertyDesc("jjj");
        propDesc.setValue(myBean, null);
    }

    /**
     * @throws Exception
     */
    @Test(expected = IllegalPropertyRuntimeException.class)
    public void testSetValue_invalidType() throws Exception {
        final MyBean myBean = new MyBean();
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);