private final boolean errors;

    private final T value;

    private final Iterable<? extends ModelProblem> problems;

    private Result(boolean errors, T model, Iterable<? extends ModelProblem> problems) {
        this.errors = errors;
        this.value = model;
        this.problems = problems;
    }

    public Iterable<? extends ModelProblem> getProblems() {
        return problems;
    }

  }

  public void testDoubler() {
    Iterable<Integer> doubled =
        new Iterable<Integer>() {
          @Override
          public Iterator<Integer> iterator() {
            return newDoubler(2, 32);
          }
        };
    assertThat(doubled).containsExactly(2, 4, 8, 16, 32).inOrder();
  }

  public void testSampleCode() {
    Iterable<Integer> actual =
        new Iterable<Integer>() {
          @Override

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllEmptyIterableOnAbsentKey() {
    Iterable<V> iterable =
        new Iterable<V>() {
          @Override
          public Iterator<V> iterator() {
            return ImmutableSet.<V>of().iterator();
          }
        };

    assertFalse(multimap().putAll(k3(), iterable));
    expectUnchanged();
  }

  @CollectionSize.Require(absent = ZERO)

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllEmptyIterableOnAbsentKey() {
    Iterable<V> iterable =
        new Iterable<V>() {
          @Override
          public Iterator<V> iterator() {
            return ImmutableSet.<V>of().iterator();
          }
        };

    assertFalse(multimap().putAll(k3(), iterable));
    expectUnchanged();
  }

  @CollectionSize.Require(absent = ZERO)

      default:
        return create(elements);
    }
  }

  public static <E> ImmutableSet<E> copyOf(Collection<? extends E> elements) {
    Iterable<? extends E> iterable = elements;
    return copyOf(iterable);
  }

  public static <E> ImmutableSet<E> copyOf(Iterable<? extends E> elements) {
    if (elements instanceof ImmutableSet && !(elements instanceof ImmutableSortedSet)) {

            parameters["file"] as File,
            parameters["gradleJars"] as Iterable<File>,
            parameters["pluginDependenciesSpecQualifiedName"] as String,
            parameters["pluginDependencySpecQualifiedName"] as String,
        )
    }
}


fun writeBuiltinPluginIdExtensionsTo(
    file: File,
    gradleJars: Iterable<File>,
    pluginDependenciesSpecQualifiedName: String,

    /**
     * for each構文で使用するために{@link Enumeration}をラップした{@link Iterable}を返します。
     *
     * @param <T>
     *            列挙する要素の型
     * @param enumeration
     *            {@link Enumeration}。{@literal null}であってはいけません
     * @return {@link Enumeration}をラップした{@link Iterable}
     */
    public static <T> Iterable<T> iterable(final Enumeration<T> enumeration) {
        assertArgumentNotNull("enumeration", enumeration);

  static final Tree h = new Tree('h', d, e, g);

  static String iterationOrder(Iterable<? extends Node> iterable) {
    StringBuilder builder = new StringBuilder();
    for (Node t : iterable) {
      builder.append(t.value);
    }
    StringBuilder forEachBuilder = new StringBuilder();
    iterable.forEach(t -> forEachBuilder.append(t.value));
    assertTrue(

final class LexicographicalOrdering<T extends @Nullable Object> extends Ordering<Iterable<T>>
    implements Serializable {
  final Comparator<? super T> elementOrder;

  LexicographicalOrdering(Comparator<? super T> elementOrder) {
    this.elementOrder = elementOrder;
  }

  @Override
  public int compare(Iterable<T> leftIterable, Iterable<T> rightIterable) {
    Iterator<T> left = leftIterable.iterator();

    return Reflection.newProxy(List.class, new DelegatingInvocationHandlerWithEquals(delegate));
  }

  @SuppressWarnings("unchecked") // proxy of Iterable<String>
  private static Iterable<String> newDelegatingIterableWithEquals(Iterable<String> delegate) {
    return Reflection.newProxy(Iterable.class, new DelegatingInvocationHandlerWithEquals(delegate));
  }

  @SuppressWarnings("unchecked") // proxy of List<String>