@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
/**
 * Annotation marking a test as flaky, and requires extra logging and linking against
 * a known github issue.  This does not ignore the failure.
 */

    // incomplete.
    val creator = cache.edit("k1")!!
    creator.newSink(0).buffer().use {
      it.writeUtf8("Hello")
    }

    // Simulate a severe Filesystem failure on the first initialization.
    filesystem.setFaultyDelete(cacheDir / "k1.0.tmp", true)
    filesystem.setFaultyDelete(cacheDir, true)
    cache =

  ) = logEvent(ConnectionEvent.ConnectStart(System.nanoTime(), route, call))

  override fun connectFailed(
    route: Route,
    call: Call,
    failure: IOException,
  ) = logEvent(
    ConnectionEvent.ConnectFailed(System.nanoTime(), route, call, failure),
  )

  override fun connectEnd(
    connection: Connection,
    route: Route,
    call: Call,
  ) {

		t.Run("", func(t *testing.T) {
			_, err := ExpToInt64(testCase.exp)
			if err != nil && !testCase.expectedFailure {
				t.Errorf("Expected success but got failure %s", err)
			}
			if err == nil && testCase.expectedFailure {
				t.Error("Expected failure but got success")
			}
		})
	}
}

func TestIsAccessKeyValid(t *testing.T) {
	testCases := []struct {
		accessKey      string
		expectedResult bool
	}{

type tierMetrics struct {
	sync.RWMutex  // protects requestsCount only
	requestsCount map[string]struct {
		success int64
		failure int64
	}
	histogram *prometheus.HistogramVec
}

var globalTierMetrics = tierMetrics{
	requestsCount: make(map[string]struct {
		success int64
		failure int64
	}),
	histogram: prometheus.NewHistogramVec(prometheus.HistogramOpts{
		Name:    "tier_ttlb_seconds",

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.repository;

import java.io.IOException;

/**
 * Signals a failure to store files within the local repository.
 *
 */
@Deprecated
public class LocalRepositoryNotAccessibleException extends IOException {

    public LocalRepositoryNotAccessibleException(String message, Throwable cause) {

4. The daemon runs the request, sending back data such as logging output or tooling API events and intermediate models while doing so.
5. The daemon sends the result back. For some requests, this might be a simple success/failure result, and for others this might also include a more complex object, such as a tooling API model.

     * <p>If the combiningCallable throws an {@code ExecutionException}, the cause of the thrown
     * {@code ExecutionException} will be extracted and used as the failure of the derived step.
     *
     * <p>If the combiningCallable throws any other exception, it will be used as the failure of the
     * derived step.
     *
     * <p>If an exception is thrown after the combiningCallable creates a {@code ClosingFuture},

            assertEquals(1, result.unmodifiedCount(), "Should have 1 unmodified POM");
            assertEquals(0, result.errorCount(), "Should have no errors");
        }

        @Test
        @DisplayName("should create failure result")
        void shouldCreateFailureResult() {
            Path pom1 = Paths.get("pom.xml");
            Path pom2 = Paths.get("module/pom.xml");

            UpgradeResult result = new UpgradeResult(

			claims["exp"] = testCase.exp
			err := updateClaimsExpiry(testCase.dsecs, claims)
			if err != nil && !testCase.expectedFailure {
				t.Errorf("Expected success, got failure %s", err)
			}
			if err == nil && testCase.expectedFailure {
				t.Error("Expected failure, got success")
			}
		})
	}
}

func initJWKSServer() *httptest.Server {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {