return this.subject;
        }

        @Override
        public void refresh() throws CIFSException {
            if (failOnRefresh) {
                throw new CIFSException("refresh failed");
            }
        }

        // ----- Credentials (super-interface) -----

        @Override
        public <T extends Credentials> T unwrap(Class<T> type) {
            if (type == null) {

			query.Set(key, value)
		}
		// Create a request to use.
		req, err := http.NewRequest(http.MethodGet, "http://host/a/b?"+query.Encode(), nil)
		if err != nil {
			t.Errorf("(%d) failed to create http.Request, got %v", i, err)
		}
		if testCase.expected != ErrNone {
			// Should be set since we are simulating a http server.
			req.RequestURI = req.URL.RequestURI()
			// Check if it matches!

            assertTrue(true);
        } catch (final InterruptedException e) {
            fail("Interrupted during execution");
        } catch (final ExecutionException e) {
            fail("Execution failed: " + e.getMessage());
        } finally {
            executor.shutdown();
            try {

	ctx, cancel := context.WithCancel(b.Context())
	defer cancel()
	objLayer, disks, err := prepareTestBackend(ctx, instanceType)
	if err != nil {
		b.Fatalf("Failed obtaining Temp Backend: <ERROR> %s", err)
	}
	// cleaning up the backend by removing all the directories and files created on function return.
	defer removeRoots(disks)

	// uses *testing.B and the object Layer to run the benchmark.

      extensionContext: ExtensionContext,
    ) {
      var failed = false
      try {
        invocation.proceed()
      } catch (e: TestAbortedException) {
        throw e
      } catch (e: Throwable) {
        failed = true
        rethrowIfNotExpected(e)
      } finally {
        resetPlatform()
      }
      if (!failed) {
        failIfExpected()
      }
    }

    fun setupPlatform() {

                relatedContentService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),
                        this::asEditHtml);
            }

                        try {
                            smbAuth.setPort(Integer.parseInt(port));
                        } catch (final NumberFormatException e) {
                            logger.warn("Failed to parse {}", port, e);
                        }
                    }
                    smbAuth.setUsername(username);
                    smbAuth.setPassword(password == null ? StringUtil.EMPTY : password);

    static {
        try {
            NTLMSSP_OID = new ASN1ObjectIdentifier("1.3.6.1.4.1.311.2.2.10");
        } catch (final IllegalArgumentException e) {
            log.error("Failed to parse OID", e);
        }
    }

    private final NtlmPasswordAuthenticator auth;
    private int ntlmsspFlags;
    private final String workstation;
    private boolean isEstablished = false;

		ongoingRestoreObj(),
		completedRestoreObj(time.Now().UTC()),
	}
	for i, tc := range testCases {
		actual, err := parseRestoreObjStatus(tc.String())
		if err != nil {
			t.Fatalf("Test %d: parse restore object failed: %v", i+1, err)
		}
		if actual.ongoing != tc.ongoing || actual.expiry.Format(http.TimeFormat) != tc.expiry.Format(http.TimeFormat) {
			t.Fatalf("Test %d: got %v expected %v", i+1, actual, tc)
		}
	}
}

                availableSendRegions.offer(region);
                totalAllocated.incrementAndGet();
            } catch (IOException e) {
                log.warn("Failed to pre-allocate send buffer", e);
            }
        }

        // Allocate receive buffers
        for (int i = 0; i < initialReceiveBuffers; i++) {
            try {