public void testJoin() throws Exception {
    joinHelper(0);
    joinHelper(1);
    joinHelper(0, 0, 0);
    joinHelper(10, 20);
    joinHelper(10, 0, 20);
    joinHelper(0, 10, 20);
    joinHelper(10, 20, 0);
    joinHelper(10, 20, 1);
    joinHelper(1, 1, 1, 1, 1, 1, 1, 1);
    joinHelper(1, 0, 1, 0, 1, 0, 1, 0);
  }

  public void testOnlyOneOpen() throws Exception {

import org.junit.Test;

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

    /**
     * @throws Exception
     */
    @SuppressWarnings("rawtypes")
    @Test
    public void testDefaultConstructor() throws Exception {
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final ConstructorDesc ctor = beanDesc.getConstructorDesc();

    }

    @Test
    void testNullSafe() throws Exception {
        Profile p = Profile.newInstance();

        assertActivation(false, p, newContext(null, null));

        p = p.withActivation(Activation.newInstance());

        assertActivation(false, p, newContext(null, null));
    }

    @Test
    void testPrefix() throws Exception {
        Profile profile = newProfile("1.4");

    private File getPom(String name) {
        return new File(Paths.get(BASE_DIR, name + ".xml").toString()).getAbsoluteFile();
    }

    @Test
    void testCompleteWiring() throws Exception {
        ModelBuilder builder = new DefaultModelBuilderFactory().newInstance();
        assertNotNull(builder);

        DefaultModelBuildingRequest request = new DefaultModelBuildingRequest();

            } catch (Exception | LinkageError e) {
                logError("notify", e, eventSpy);
            }
        }
    }

    public void close() {
        if (eventSpies.isEmpty()) {
            return;
        }
        for (EventSpy eventSpy : eventSpies) {
            try {
                eventSpy.close();
            } catch (Exception | LinkageError e) {

          // by a previous one in the queue being interrupted.
          interruptedDuringTask |= Thread.interrupted();
          try {
            task.run();
          } catch (Exception e) { // sneaky checked exception
            log.get().log(Level.SEVERE, "Exception while executing runnable " + task, e);
          } finally {
            task = null;
          }
        }
      } finally {

          // by a previous one in the queue being interrupted.
          interruptedDuringTask |= Thread.interrupted();
          try {
            task.run();
          } catch (Exception e) { // sneaky checked exception
            log.get().log(Level.SEVERE, "Exception while executing runnable " + task, e);
          } finally {
            task = null;
          }
        }
      } finally {

import org.codelibs.fess.crawler.entity.RequestData;
import org.codelibs.fess.crawler.entity.ResponseData;
import org.codelibs.fess.crawler.exception.CrawlerSystemException;
import org.codelibs.fess.crawler.exception.MultipleCrawlingAccessException;
import org.dbflute.utflute.core.PlainTestCase;

/**
 * @author shinsuke
 *
 */
public class FaultTolerantClientTest extends PlainTestCase {

    tester.testAllPublicConstructors(MacHashFunction.class);
    tester.testAllPublicInstanceMethods(new MacHashFunction("HmacMD5", MD5_KEY, "toString"));
  }

  public void testHashing() throws Exception {
    for (String stringToTest : INPUTS) {
      for (Table.Cell<String, SecretKey, HashFunction> cell : ALGORITHMS.cellSet()) {
        String algorithm = cell.getRowKey();
        SecretKey key = cell.getColumnKey();

    }

    @Test
    void testOneProblem() {
        ProblemCollector problemCollector = ProblemCollectorFactory.newInstance(null);
        problemCollector.add(Problem.Severity.ERROR, "MESSAGE", 3, 5, new Exception());
        ToolchainsBuildingException e = new ToolchainsBuildingException(problemCollector.getProblems());
        assertEquals(
                "1 problem was encountered while building the effective toolchains" + LS