// Transition to DONE
        currentStatus = CrawlerStatus.DONE;
        assertEquals(CrawlerStatus.DONE, currentStatus);

        // Verify ordinal progression
        assertTrue(CrawlerStatus.INITIALIZING.ordinal() < CrawlerStatus.RUNNING.ordinal());
        assertTrue(CrawlerStatus.RUNNING.ordinal() < CrawlerStatus.DONE.ordinal());
    }

    /**

    }
    return total;
  }

  /** Max array length on JVM. */
  private static final int MAX_ARRAY_LEN = Integer.MAX_VALUE - 8;

  /** Large enough to never need to expand, given the geometric progression of buffer sizes. */
  private static final int TO_BYTE_ARRAY_DEQUE_SIZE = 20;

  /**
   * Returns a byte array containing the bytes from the buffers already in {@code bufs} (which have

      }
    } ]
  }, {
    "testId" : "org.gradle.performance.regression.android.RealLifeAndroidBuildPerformanceTest.calculate task graph with test finalizer",
    "groups" : [ {
      "testProject" : "largeAndroidBuild",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    } ]
  }, {

  "durations" : [ {
    "testProject" : "nowInAndroidBuild",
    "linux" : 348,
    "windows" : 461,
    "macOs" : 314
  }, {
    "testProject" : "santaTrackerAndroidBuild",
    "linux" : 461,
    "windows" : 823,
    "macOs" : 385
  } ]
}, {

    follow-ups. It independently shares connections when the IP addresses and certificates match,
    even if the host names do not. In 4.4.0 we introduced a regression where we shared a connection
    when certificates matched but the DNS addresses did not. This would only occur when following a
    redirect from one hostname to another, and where both hosts had common certificates.

    val channel: String,
    val extraParameters: String = "",
) {
    PER_COMMIT(
        displayName = "Performance Regression Test",
        timeout = 420,
        channel = "commits",
    ),
    PER_DAY(
        displayName = "Slow Performance Regression Test",
        timeout = 420,
        channel = "commits",
    ),
    PER_WEEK(
        displayName = "Performance Experiment",

  testandroidregression:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    if: contains(github.event.pull_request.labels.*.name, 'android-regression')

    strategy:
      fail-fast: false
      matrix:
        api-level:
          - 29
          - 34

    steps:
      - name: Checkout
        uses: actions/checkout@v5

        MinMaxPriorityQueue<Integer> q = MinMaxPriorityQueue.create(perm);
        q.removeAt(i);
        assertIntactUsingStartedWith(perm, q);
      }
    }
  }

  /** Regression test for bug found. */
  public void testCorrectOrdering_regression() {
    MinMaxPriorityQueue<Integer> q = MinMaxPriorityQueue.create(ImmutableList.of(3, 5, 1, 4, 7));

    /*
     * We don't "need" to schedule a thread completion at all here, but by doing
     * so, we come the closest we can to testing that the wait time is
     * appropriately decreased on each progressive join() call.
     */
    TimedThread thread = TimedThread.createWithDelay(LONG_DELAY_MS);
    repeatedlyInterruptTestThread(20, tearDownStack);
    thread.joinUnsuccessfully(70);
    assertInterrupted();
  }

  }

  /**
   * Returns a linear transformation giving the best fit to the data according to <a
   * href="http://mathworld.wolfram.com/LeastSquaresFitting.html">Ordinary Least Squares linear
   * regression</a> of {@code y} as a function of {@code x}. The count must be greater than one, and
   * either the {@code x} or {@code y} data must have a non-zero population variance (i.e. {@code