if (maxRetries <= 0) {
            delegate.execute(spec, testResultProcessor);
            return;
        }

        RerunTestResultProcessor retryTestResultProcessor = new RerunTestResultProcessor(testResultProcessor);

        int retryCount = 0;
        JvmTestExecutionSpec testExecutionSpec = spec;
        while (true) {
            try {

    //                                                                              ======
    @Override
    public Map<String, Object> toSource() {
        Map<String, Object> sourceMap = new HashMap<>();
        if (createdBy != null) {
            addFieldToSource(sourceMap, "createdBy", createdBy);
        }
        if (createdTime != null) {
            addFieldToSource(sourceMap, "createdTime", createdTime);

        }
    }

    private static String createLabel(final String name, final String value) {
        Map<String, Object> labelBody = new HashMap<>();
        labelBody.put("name", name);
        labelBody.put("value", value);
        Response response = checkMethodBase(labelBody).post("/api/admin/labeltype/setting");

@GwtIncompatible
final class RegularImmutableSortedMultiset<E> extends ImmutableSortedMultiset<E> {
  private static final long[] zeroCumulativeCounts = {0};

  static final ImmutableSortedMultiset<?> NATURAL_EMPTY_MULTISET =
      new RegularImmutableSortedMultiset<>(Ordering.natural());

  @VisibleForTesting final transient RegularImmutableSortedSet<E> elementSet;
  private final transient long[] cumulativeCounts;
  private final transient int offset;

  @LazyInit private transient @Nullable NavigableSet<E> elementSet;

  @Override
  public NavigableSet<E> elementSet() {
    NavigableSet<E> result = elementSet;
    if (result == null) {
      return elementSet = new SortedMultisets.NavigableElementSet<>(this);
    }
    return result;
  }

  @Override
  public @Nullable Entry<E> pollFirstEntry() {
    return forwardMultiset().pollLastEntry();
  }

  @Override

                                : null)
                .build();
    }

    @Nonnull
    static ToolchainsBuilderRequestBuilder builder() {
        return new ToolchainsBuilderRequestBuilder();
    }

    @NotThreadSafe
    class ToolchainsBuilderRequestBuilder {
        ProtoSession session;
        RequestTrace trace;
        Source installationToolchainsSource;

     * @throws XmlReaderException if an error occurs during the parsing
     * @see #toXmlString(Object)
     */
    @Nonnull
    default T fromXmlString(@Nonnull String xml) throws XmlReaderException {
        return read(new StringReader(xml));
    }

    /**
     * Converts the given content to an XML string.
     *
     * @param content the object to convert
     * @return the xml string representation

import org.junit.jupiter.api.Test;

public class DataConfigPagerTest extends UnitFessTestCase {

    @Test
    public void test_DataConfigPager() {
        DataConfigPager dataconfigpager = new DataConfigPager();

        dataconfigpager.clear();
        assertEquals(0, dataconfigpager.getAllRecordCount());
        assertEquals(0, dataconfigpager.getAllPageCount());

     */
    @Deprecated
    public InvalidProjectModelException(
            String projectId, String pomLocation, String message, ModelValidationResult validationResult) {
        this(projectId, message, new File(pomLocation), validationResult);
    }

    public InvalidProjectModelException(
            String projectId, String message, File pomFile, ModelValidationResult validationResult) {

    private final boolean aggregating;

    public TaskSegment(boolean aggregating) {
        this.aggregating = aggregating;
        tasks = new ArrayList<>();
    }

    public TaskSegment(boolean aggregating, Task... tasks) {
        this.aggregating = aggregating;
        this.tasks = new ArrayList<>(Arrays.asList(tasks));
    }

    @Override
    public String toString() {
        return getTasks().toString();
    }