*            1番目の値の型
     * @param <T2>
     *            2番目の値の型
     * @param <T3>
     *            3番目の値の型
     * @param value1
     *            1番目の値
     * @param value2
     *            2番目の値
     * @param value3
     *            3番目の値
     * @return 3つの値の組
     */
    public static <T1, T2, T3> Tuple3<T1, T2, T3> tuple3(final T1 value1, final T2 value2, final T3 value3) {

/**
 * 4つの値の組です。
 *
 * @author koichik
 * @param <T1>
 *            1番目の値の型
 * @param <T2>
 *            2番目の値の型
 * @param <T3>
 *            3番目の値の型
 * @param <T4>
 *            4番目の値の型
 */
public class Tuple4<T1, T2, T3, T4> {

    /** 1番目の値 */
    protected T1 value1;

    /** 2番目の値 */
    protected T2 value2;

    /** 3番目の値 */
    protected T3 value3;

    /** 4番目の値 */

 *
 * @author koichik
 * @param <T1>
 *            1番目の値の型
 * @param <T2>
 *            2番目の値の型
 * @param <T3>
 *            3番目の値の型
 * @param <T4>
 *            4番目の値の型
 * @param <T5>
 *            5番目の値の型
 */
public class Tuple5<T1, T2, T3, T4, T5> {

    /** 1番目の値 */
    protected T1 value1;

    /** 2番目の値 */
    protected T2 value2;

    /** 3番目の値 */
    protected T3 value3;

    /** 4番目の値 */

    /**
     * @param <T1>
     * @param <T2>
     *
     */
    public interface Foo<T1, T2> {

        /**
         * @param foo
         * @return T2
         */
        T2 foo(T1 foo);
    }

    /**
     *
     */
    public interface Bar extends Foo<Integer, Long> {
    }

    /**
     * @param <T1>
     * @param <T2>
     *
     */

 *
 * @author koichik
 * @param <T1>
 *            1番目の値の型
 * @param <T2>
 *            2番目の値の型
 */
public class Pair<T1, T2> {

    /** 1番目の値 */
    protected T1 first;

    /** 2番目の値 */
    protected T2 second;

    /**
     * 二つの値のペアを作成して返します。
     *
     * @param <T1>
     *            1番目の値の型
     * @param <T2>
     *            2番目の値の型
     * @param first
     *            1番目の値

        public int compare(final MyToken t1, final MyToken t2) {
            if (t1.startOffset < t2.startOffset) {
                return -1;
            } else if (t1.startOffset > t2.startOffset) {
                return 1;
            }

            if (t1.endOffset < t2.endOffset) {
                return -1;
            } else if (t1.endOffset > t2.endOffset) {
                return 1;
            }

        // create the recessive DOM
        Xpp3Dom t2 = new Xpp3Dom("top");
        t2.setAttribute("attr2", "value2");
        t2.setValue("t2Value");
        t2.setInputLocation("t2top");

        // merge and check results.
        Xpp3Dom result = Xpp3Dom.mergeXpp3Dom(t1, t2);

        assertEquals(2, result.getAttributeNames().length);
        assertNull(result.getValue());

    assertThrows(IllegalArgumentException.class, () -> resolver.where(t, String.class));
  }

  public <T1, T2 extends List<T1>> void testWhere_recursiveMapping() {
    Type t1 = new TypeCapture<T1>() {}.capture();
    Type t2 = new TypeCapture<T2>() {}.capture();
    assertEquals(t2, new TypeResolver().where(t1, t2).resolveType(t1));
  }

  public <T> void testWhere_genericArrayMapping() {

      aa.set(i, (double) COUNTDOWN);
    }
    Counter c1 = new Counter(aa);
    Counter c2 = new Counter(aa);
    Thread t1 = newStartedThread(c1);
    Thread t2 = newStartedThread(c2);
    awaitTermination(t1);
    awaitTermination(t2);
    assertEquals(SIZE * COUNTDOWN, c1.counts + c2.counts);
  }

  /** a deserialized serialized array holds same values */
  public void testSerialization() throws Exception {

                + " -Durl=[url] -DrepositoryId=[id]" + LS + LS + "  Path to dependency: " + LS + "  \t1) dependency1"
                + LS + "  \t2) dependency2" + LS + LS;
        String actual = AbstractArtifactResolutionException.constructMissingArtifactMessage(
                message, indentation, groupId, artifactId, version, type, classifier, downloadUrl, path);