},
		},
	}

	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) {

            CommonServerMessageBlockRequest req;
            NotifyResponse resp = null;
            if (th.isSMB2()) {
                final Smb2ChangeNotifyRequest r = new Smb2ChangeNotifyRequest(th.getConfig(), this.handle.getFileId());
                r.setCompletionFilter(this.filter);
                r.setNotifyFlags(this.recursive ? Smb2ChangeNotifyRequest.SMB2_WATCH_TREE : 0);
                req = r;
            } else {

            return cookieSecure;
        }

        return LaRequestUtil.getOptionalRequest().map(req -> {
            String forwardedProto = req.getHeader("X-Forwarded-Proto");
            if ("https".equalsIgnoreCase(forwardedProto)) {
                return true;
            }
            return req.isSecure();
        }).orElse(false);
    }

    /**

		if testCase.removeAuthHeader {
			req.Header.Del("Authorization")
		}
		switch testCase.fault {
		case malformedEncoding:
			req, err = malformChunkSizeSigV4(req, testCase.chunkSize-1)
		case signatureMismatch:
			req, err = malformDataSigV4(req, 'z')
		case unexpectedEOF:
			req, err = truncateChunkByHalfSigv4(req)
		case tooBigDecodedLength:

        LaRequestUtil.getOptionalRequest().ifPresent(req -> {
            searchLog.setClientIp(StringUtils.abbreviate(ComponentUtil.getViewHelper().getClientIp(req), 100));
            searchLog.setReferer(StringUtils.abbreviate(req.getHeader("referer"), 1000));
            searchLog.setUserAgent(StringUtils.abbreviate(req.getHeader("user-agent"), 255));
            final Object accessType = req.getAttribute(Constants.SEARCH_LOG_ACCESS_TYPE);

            ensureOpen();
            final TransTransactNamedPipe req = new TransTransactNamedPipe(pipe.fid, b, off, len);
            if (dcePipe) {
                req.maxDataCount = 1024;
            }
            pipe.send(req, new TransTransactNamedPipeResponse(pipe));
        }
    }

        when(tree.acquire(false)).thenReturn(tree);

        CommonServerMessageBlockRequest req = mock(CommonServerMessageBlockRequest.class);
        CommonServerMessageBlockResponse resp = mock(CommonServerMessageBlockResponse.class);

        // Configure the tree to throw transport error on first call, succeed on second
        when(tree.send(eq(req), eq(resp), anySet()))

    // cat cert.cnf
    // [req]
    // distinguished_name=distinguished_name
    // req_extensions=req_extensions
    // x509_extensions=x509_extensions
    // [distinguished_name]
    // [req_extensions]
    // [x509_extensions]
    // subjectAltName=DNS:localhost.localdomain,DNS:localhost,IP:127.0.0.1
    //
    // $ openssl req -x509 -nodes -days 36500 -subj '/CN=localhost' -config ./cert.cnf \

			}
		}()
		if debugPrint {
			fmt.Printf("grid: Got a %s request for: %v\n", req.Method, req.URL)
		}
		ctx := req.Context()
		if err := authReq(req); err != nil {
			gridLogOnceIf(ctx, fmt.Errorf("auth %s: %w", req.RemoteAddr, err), req.RemoteAddr)
			w.WriteHeader(http.StatusForbidden)
			return
		}
		conn, _, _, err := ws.UpgradeHTTP(req, w)
		if err != nil {
			if debugPrint {

        byte ap = (byte) 0x7A;
        ASN1Sequence seq = buildMinimalApReqSeq(ap);

        // Act
        KerberosApRequest req = new KerberosApRequest(seq, null);

        // Assert
        assertEquals(ap, req.getApOptions(), "apOptions should reflect BIT STRING's first byte");
        assertNull(req.getTicket(), "ticket should be null when tag 3 is absent");
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 4, 6, 99 })