*   try {
   *     foo.bar();
   *   } catch (BarException | RuntimeException | Error t) {
   *     failure = t;
   *   }
   * }
   * if (failure != null) {
   *   throwIfInstanceOf(failure, BarException.class);
   *   throwIfUnchecked(failure);
   *   throw new AssertionError(failure);
   * }
   * </pre>
   *
   * @since 20.0
   */
  @GwtIncompatible // Class.cast, Class.isInstance

const val INDIVIDUAL_PERFORAMCE_TEST_ARTIFACT_RULES = """
testing/*/build/test-results-*.zip => results
testing/*/build/tmp/**/log.txt => failure-logs
testing/*/build/tmp/**/profile.log => failure-logs
testing/*/build/tmp/**/daemon-*.out.log => failure-logs
"""

// to avoid pathname too long error
fun BuildSteps.substDirOnWindows(os: Os) {
    if (os == Os.WINDOWS) {
        script {

        return new UpgradeResult(processedPoms, modifiedPoms, Collections.emptySet());
    }

    /**
     * Creates a failure result with the specified processed POMs and error POMs.
     */
    public static UpgradeResult failure(Set<Path> processedPoms, Set<Path> errorPoms) {
        return new UpgradeResult(processedPoms, Collections.emptySet(), errorPoms);
    }

    /**

      - name: Install Dependencies
        run: uv sync --locked --extra all
      - name: Run prek - pre-commit
        id: precommit
        run: uvx prek run --from-ref origin/${GITHUB_BASE_REF} --to-ref HEAD --show-diff-on-failure
        continue-on-error: true
      - name: Commit and push changes
        if: env.HAS_SECRETS == 'true'
        run: |
          git config user.name "github-actions[bot]"

   * reading, such as an {@code InputStream}. Unlike with writable resources, there's no chance that
   * a failure that occurs when closing the stream indicates a meaningful problem such as a failure
   * to flush all bytes to the underlying resource.
   *
   * @param inputStream the input stream to be closed, or {@code null} in which case this method
   *     does nothing

        verify(handle, times(1)).hasCapability(captor.capture());
        assertEquals(cap, captor.getValue());
    }

    @Test
    @DisplayName("hasCapability(cap): propagates CIFSException on failure")
    void hasCapability_throws() throws Exception {
        // Arrange
        when(handle.hasCapability(anyInt())).thenThrow(new CIFSException("capability check failed"));

        // Act + Assert

			sctx := &serverCtxt{}
			err := mergeServerCtxtFromConfigFile(testcase.config, sctx)
			if testcase.expectedErr && err == nil {
				t.Error("expected failure, got success")
			}
			if !testcase.expectedErr && err != nil {
				t.Error("expected success, got failure", err)
			}
			if err == nil {
				if len(sctx.Layout.pools) != 2 {
					t.Error("expected parsed pools to be 2, not", len(sctx.Layout.pools))
				}

              ? (isBoolean(method) ? Outcome.FAILURE : Outcome.HANG)
              : Outcome.SUCCESS);
      addTests(
          suite,
          method,
          Scenario.UNSATISFIED_AND_UNOCCUPIED_BEFORE_ENTERING,
          TimeoutsToUse.INFINITE,
          isGuarded(method)
              ? (isTryEnter(method) || isEnterIf(method) ? Outcome.FAILURE : Outcome.HANG)
              : Outcome.SUCCESS);

        processor.failure("testId2", testError2)
        processor.completed("rootId", rootCompleteEvent)

        then:
        1 * delegate.started(rootDescriptor, rootTestStartEvent)
        1 * delegate.started(testDescriptor1, testStartEvent1)
        1 * delegate.started(testDescriptor2, testStartEvent2)
        1 * delegate.failure("testId2", testError2)

				if err != nil {
					t.Fatalf("Unexpected failure %s", err)
				}
				argPatterns[i] = patterns
			}

			gotIndexes, err := getSetIndexes(testCase.args, testCase.totalSizes, testCase.envOverride, argPatterns)
			if err != nil && testCase.success {
				t.Errorf("Expected success but failed instead %s", err)
			}
			if err == nil && !testCase.success {
				t.Errorf("Expected failure but passed instead")
			}