}

        int toIndex = offset + size;
        if (toIndex > synonymItemList.size()) {
            toIndex = synonymItemList.size();
        }

        return new PagingList<>(synonymItemList.subList(offset, toIndex), offset, size, synonymItemList.size());
    }

    @Override
    public synchronized void insert(final SynonymItem item) {
        try (SynonymUpdater updater = new SynonymUpdater(item)) {

            }
            if (stringList.size() == 1) {
                return stringList.get(0);
            }
            int bound = stringList.size() - 1;
            return String.join(", ", stringList.subList(0, bound)) + " or " + stringList.get(bound);
        });
    }

                if (currentIndex < executionsLen - 1 && results.getVcsBranch() != null) {
                    for (PerformanceTestExecution execution : testHistory.getExecutions().subList(currentIndex + 1, executionsLen)) {
                        if (results.getVcsBranch().equals(execution.getVcsBranch())) {
                            previousResults = execution;
                            break;

                    "org:$repoType-runtime-dependency:1.0" {
                        expectGetMetadata()
                        expectGetArtifact()
                    }
                }
                repoTypes.subList(repoTypes.indexOf(repoType) + 1, repoTypes.size()).each { other ->
                    "org:$other:1.0" {
                        expectGetMetadataMissingThatIsFoundElsewhere()
                    }

          Object writeReplace() {
            return super.writeReplace();
          }
        };
    final ImmutableRangeMap<K, V> outer = this;
    return new ImmutableRangeMap<K, V>(subRanges, values.subList(lowerIndex, upperIndex)) {
      @Override
      public ImmutableRangeMap<K, V> subRangeMap(Range<K> subRange) {
        if (range.isConnected(subRange)) {
          return outer.subRangeMap(subRange.intersection(range));

            List<Expression> otherArgs = hasTrailingClosure ? arguments.getExpressions().subList(0, arguments.getExpressions().size() - 1) : arguments.getExpressions();
            if (!otherArgs.isEmpty() || !hasTrailingClosure) {
                builder.append("(");

                            ? Sets.newHashSet(Arrays.asList(elements).subList(0, size - 1))
                            : Sets.newHashSet(elements);
                    // Remove first element, if size > 0
                    Set<String> set2 =
                        (size > 0)
                            ? Sets.newHashSet(Arrays.asList(elements).subList(1, size))
                            : Sets.<String>newHashSet();

                            ? Sets.newHashSet(Arrays.asList(elements).subList(0, size - 1))
                            : Sets.newHashSet(elements);
                    // Remove first element, if size > 0
                    Set<String> set2 =
                        (size > 0)
                            ? Sets.newHashSet(Arrays.asList(elements).subList(1, size))
                            : Sets.<String>newHashSet();

                        assertTrue(workerJar.endsWith("gradle-worker.jar"));

                        // After, we expect the test runtime classpath.
                        List<URL> filteredSystemClasspath = systemClasspath.subList(1, systemClasspath.size());
                        List<URL> testRuntimeClasspath = getTestRuntimeClasspath(splitTestRuntimeClasspath);
                        assertEquals(testRuntimeClasspath, filteredSystemClasspath);

        upper = middle - 1;
      } else if (c > 0) {
        lower = middle + 1;
      } else {
        return lower
            + presentBehavior.resultIndex(
                comparator, key, list.subList(lower, upper + 1), middle - lower);
      }
    }
    return absentBehavior.resultIndex(lower);
  }