then:
        assertHasArguments(args, "-I", includes)
        assertHasArguments(args, "-isystem", systemIncludes)

        and:
        args.indexOf(includes.last().absoluteFile.toString()) < args.indexOf(systemIncludes.first().absoluteFile.toString())
    }

    boolean assertHasArguments(List<String> args, String option, List<File> files) {
        files.each { file ->

    return forward.floor(element);
  }

  @Override
  @CheckForNull
  public E higher(E element) {
    return forward.lower(element);
  }

  @Override
  int indexOf(@CheckForNull Object target) {
    int index = forward.indexOf(target);
    if (index == -1) {
      return index;
    } else {
      return size() - 1 - index;
    }
  }

  @Override
  boolean isPartialView() {

        }
        return compareSegments(taskName1, taskName2);
    }

    private int compareSegments(String taskName1, String taskName2) {
        int colon1 = taskName1.indexOf(':');
        int colon2 = taskName2.indexOf(':');
        if (colon1 > 0 && colon2 > 0) {
            int diff = taskName1.substring(0, colon1).compareTo(taskName2.substring(0, colon2));
            if (diff != 0) {
                return diff;

    return forward.floor(element);
  }

  @Override
  @CheckForNull
  public E higher(E element) {
    return forward.lower(element);
  }

  @Override
  int indexOf(@CheckForNull Object target) {
    int index = forward.indexOf(target);
    if (index == -1) {
      return index;
    } else {
      return size() - 1 - index;
    }
  }

  @Override
  boolean isPartialView() {

@ElementTypesAreNonnullByDefault
abstract class ForwardingImmutableList<E> extends ImmutableList<E> {

  ForwardingImmutableList() {}

  abstract List<E> delegateList();

  public int indexOf(@Nullable Object object) {
    return delegateList().indexOf(object);
  }

  public int lastIndexOf(@Nullable Object object) {
    return delegateList().lastIndexOf(object);
  }

  public E get(int index) {

@PackageScope
class SplitUtils {
    static LinkedList split(String source) {
        int lastFind = 0
        int currentFind = 0
        LinkedList result = new LinkedList()

        while ((currentFind = source.indexOf(' ', lastFind)) != -1) {
            String token = source.substring(lastFind)
            if (currentFind != -1) {
                token = token.substring(0, currentFind - lastFind)
            }

@PackageScope
class SplitUtils {
    static LinkedList split(String source) {
        int lastFind = 0
        int currentFind = 0
        LinkedList result = new LinkedList()

        while ((currentFind = source.indexOf(' ', lastFind)) != -1) {
            String token = source.substring(lastFind)
            if (currentFind != -1) {
                token = token.substring(0, currentFind - lastFind)
            }

abstract class GuavaRule implements ComponentMetadataRule {
    void execute(ComponentMetadataContext context) {
        def variantVersion = context.details.id.version
        def version = variantVersion.substring(0, variantVersion.indexOf("-"))
        ["compile", "runtime"].each { base ->
            [6: "android", 8: "jre"].each { targetJvmVersion, jarName ->
                context.details.addVariant("jdk$targetJvmVersion${base.capitalize()}", base) {

        return buf.toString();
    }

    private static String quoteEscape(final String original) {
        String result = original;

        if (result.indexOf('\"') >= 0) {
            result = result.replace("\"", "\"\"");
        }
        if (result.indexOf(',') >= 0) {
            return "\"" + result + "\"";
        }
        return result;
    }

        def collector = new FormattingValidationProblemCollector("<thing>", ModelType.of(String))
        collector.add(String.class.getMethod("indexOf", String), "rule", "is not annotated with anything.")

        expect:
        collector.format() == '''Type java.lang.String is not a valid <thing>:
- Method indexOf(java.lang.String) is not a valid rule method: is not annotated with anything.'''
    }