* second value, and so on.
   */
  static <K extends @Nullable Object, V extends @Nullable Object> void writeMap(
      Map<K, V> map, ObjectOutputStream stream) throws IOException {
    stream.writeInt(map.size());
    for (Map.Entry<K, V> entry : map.entrySet()) {
      stream.writeObject(entry.getKey());
      stream.writeObject(entry.getValue());
    }
  }

  /**

  public void testNewReference() throws Exception {
    assertThat(Atomics.newReference().get()).isNull();
  }

  public void testNewReference_withInitialValue() throws Exception {
    assertThat(Atomics.newReference(null).get()).isNull();
    assertEquals(OBJECT, Atomics.newReference(OBJECT).get());
  }

  public void testNewReferenceArray_withLength() throws Exception {
    int length = 42;

    /**
     * @throws Exception
     */
    @Test
    public void testGetFromStream() throws Exception {
        final String path = ClassUtil.getPackageName(this.getClass()).replaceAll("\\.", "/") + "/aaa.html";
        final String contentType = MimeTypeUtil.guessContentType(path);
        assertEquals("text/html", contentType);
    }

    /**
     * @throws Exception
     */
    @Test

  public void testBuildTesterRequirements_class_notAnnotated() throws Exception {
    class Tester {}

    TesterRequirements requirements = buildTesterRequirements(Tester.class);

    assertThat(requirements.getPresentFeatures()).isEmpty();
    assertThat(requirements.getAbsentFeatures()).isEmpty();
  }

  public void testBuildTesterRequirements_class_empty() throws Exception {
    @Require
    class Tester {}

    public void test_privateMethodAnnotation() throws NoSuchMethodException {
        Method method = PrivateMethodClass.class.getDeclaredMethod("privateMethod");
        Secured secured = method.getAnnotation(Secured.class);
        assertNotNull(secured);
        assertEquals("PRIVATE_ROLE", secured.value()[0]);
    }

    @Test
    public void test_protectedMethodAnnotation() throws NoSuchMethodException {

  protected ListenableFuture<Boolean> future;

  @Override
  protected void setUp() throws Exception {

    // Create a latch and a future that waits on the latch.
    latch = new CountDownLatch(1);
    future = createListenableFuture(Boolean.TRUE, null, latch);
  }

  @Override
  protected void tearDown() throws Exception {

    // Make sure we have no waiting threads.
    latch.countDown();
  }

        assertEquals("2014-11-16T00:16:00Z", format.format(secondTestDate));
    }

    @Test
    public void testShouldNotThrowExceptionOnReferenceToNonExistentValue() throws Exception {
        Model model = new Model(org.apache.maven.api.model.Model.newBuilder()
                .scm(org.apache.maven.api.model.Scm.newBuilder()
                        .connection("${test}/somepath")

     * @return The source of the requested POM, never {@code null}.
     * @throws UnresolvableModelException If the POM could not be resolved from any configured repository.
     */
    ModelSource resolveModel(String groupId, String artifactId, String version) throws UnresolvableModelException;

    /**

import org.codelibs.core.exception.ClIllegalArgumentException;
import org.junit.Test;

/**
 * @author koichik
 *
 */
public class ClassIteratorTest {

    /**
     * @throws Exception
     */
    @Test
    public void test() throws Exception {
        final ClassIterator it = new ClassIterator(Integer.class);
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Integer.class)));

import org.codelibs.core.exception.MethodNotStaticRuntimeException;
import org.junit.Test;

/**
 * @author koichik
 *
 */
public class MethodDescTest {

    /**
     * @throws Exception
     */
    @Test
    public void testFoo() throws Exception {
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final MethodDesc foo = beanDesc.getMethodDesc("foo");
        assertThat(foo, is(notNullValue()));