detail="Not authenticated",
            headers={"WWW-Authenticate": "Bearer"},
        )

    async def __call__(self, request: Request) -> Optional[str]:
        authorization = request.headers.get("Authorization")
        if not authorization:
            if self.auto_error:
                raise self.make_not_authenticated_error()
            else:
                return None

	m.Set(scannerObjectsScanned, float64(globalScannerMetrics.lifetime(scannerMetricScanObject)))
	m.Set(scannerVersionsScanned, float64(globalScannerMetrics.lifetime(scannerMetricApplyVersion)))

	dui, err := c.dataUsageInfo.Get()
	if err != nil {
		metricsLogIf(ctx, err)
	} else {
		m.Set(scannerLastActivitySeconds, time.Since(dui.LastUpdate).Seconds())
	}

	return nil

			},
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			rec := httptest.NewRecorder()
			req := httptest.NewRequest("GET", "/test", nil)
			req.Header = testCase.headers

			opts, _ := getAndValidateAttributesOpts(ctx, rec, req, bucket, "testobject")

			if !reflect.DeepEqual(opts.ObjectAttributes, testCase.wantObjectAttrs) {

	// Add some files to the archive.
	var files = []struct {
		Name, Body string
	}{
		{"readme.txt", "This archive contains some text files."},
		{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
		{"todo.txt", "Get animal handling licence.\nWrite more examples."},
	}
	for _, file := range files {
		f, err := w.Create(file.Name)
		if err != nil {
			log.Fatal(err)
		}
		_, err = f.Write([]byte(file.Body))
		if err != nil {

        try {
            Field field = getField(obj.getClass(), fieldName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            throw new RuntimeException("Failed to get field value: " + fieldName, e);
        }
    }

    private void setFieldValue(Object obj, String fieldName, Object value) throws Exception {

    val t1 = makeSynchronousCall(client.newCall(newRequest("http://a/3")))
    ready.await(5, TimeUnit.SECONDS)
    executor.finishJob("http://a/2")
    assertThat(idle.get()).isFalse()
    proceed.countDown()
    t1.join()
    assertThat(idle.get()).isTrue()
  }

  @Test
  fun executionRejectedImmediately() {
    val request = newRequest("http://a/1")
    executor.shutdown()

                    throw new NoSuchFieldException(fieldName);
                }
                field.setAccessible(true);
                return field.get(this);
            } catch (Exception e) {
                throw new RuntimeException("Failed to get field " + fieldName, e);
            }
        }

        // Accessors for protected state
        int getTotalParameterCount() {

        final String filePath = preprocessUri(uri);
        responseData.setUrl(filePath);

        SmbFile file = null;
        final SmbAuthentication smbAuthentication = smbAuthenticationHolder.get(filePath);
        if (logger.isDebugEnabled()) {
            logger.debug("Creating SmbFile: {}", filePath);
        }
        try {
            if (smbAuthentication == null) {

  }

  @Override
  public ImmutableSortedSet<E> elementSet() {
    return forward.elementSet().descendingSet();
  }

  @Override
  Entry<E> getEntry(int index) {
    return forward.entrySet().asList().reverse().get(index);
  }

  @Override
  public ImmutableSortedMultiset<E> descendingMultiset() {
    return forward;
  }

  @Override
  public ImmutableSortedMultiset<E> headMultiset(E upperBound, BoundType boundType) {

    E connectingEdge = getConnectingEdge();
    return connectingEdge != null && connectingEdge.equals(edge);
  }

  private @Nullable E getConnectingEdge() {
    return nodeToOutEdge.get(targetNode);
  }