endpoint, err := NewEndpoint(url.String())
	if err != nil {
		t.Fatalf("NewEndpoint failed %v", endpoint)
	}

	if err = endpoint.UpdateIsLocal(); err != nil {
		t.Fatalf("UpdateIsLocal failed %v", err)
	}

	endpoint.PoolIdx = 0
	endpoint.SetIdx = 0
	endpoint.DiskIdx = 0

	poolEps := []PoolEndpoints{{
		Endpoints: Endpoints{endpoint},

        byte[] domain = {};
        if (domainStr != null) {
            try {
                domain = domainStr.getBytes(UNI_ENCODING);
            } catch (final IOException ex) {
                log.debug("Failed to get domain bytes", ex);
            }
        }
        final int domainLength = domain.length;
        byte[] server = {};
        final String host = tc.getNameServiceClient().getLocalHost().getHostName();

        val testNameParameterName = "testName"
        val testTaskOptionsParameterName = "testTaskOptions"
        applyDefaultSettings(os, arch, buildJvm = BuildToolBuildJvm, timeout = 0)

        // Show all failed tests here, since that is what we are interested in
        failureConditions.supportTestRetry = false

        val extraParameters =
            functionalTestExtraParameters(
                listOf("RerunFlakyTest"),

                                            <la:message key="labels.enabled"/>
                                        </c:if> <c:if test="${available=='false'}">
                                            <la:message key="labels.disabled"/>
                                        </c:if></td>
                                    </tr>
                                    <tr>

     */
    public void setFlag(final int flag) {
        this.flags |= flag;
    }

    /**
     * Get the result of the DCERPC call.
     * @return result exception, if the call failed
     */
    public DcerpcException getResult() {
        if (this.result != 0) {
            return new DcerpcException(this.result);
        }
        return null;
    }

        dosFileFilter = new DosFileFilter("*.*", SmbFile.ATTR_ARCHIVE);
        // and a mock file that throws an exception when getAttributes is called
        SmbException expectedException = new SmbException("Failed to get attributes");
        when(mockFile.getAttributes()).thenThrow(expectedException);

        // When calling accept
        // Then an SmbException should be thrown

func initConfig(objAPI ObjectLayer) (err error) {
	bootstrapTraceMsg("load the configuration")
	defer func() {
		if err != nil {
			bootstrapTraceMsg(fmt.Sprintf("loading configuration failed: %v", err))
		}
	}()

	if objAPI == nil {
		return errServerNotInitialized
	}

	srvCfg, err := readConfigWithoutMigrate(GlobalContext, objAPI)
	if err != nil {
		return err
	}

    }

    static String getStdout(String command) {
        ExecResult execResult = exec(command)

        assert execResult.returnCode == 0: "$command failed with return code: $execResult"
        return execResult.stdout
    }

    static Future<String> readStreamAsync(InputStream inputStream) {

        }
        try {
            return URLDecoder.decode(name, enc);
        } catch (final UnsupportedEncodingException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to decode URL: " + name + " with encoding: " + enc, e);
            }
            return name;
        }
    }

    /**
     * Returns the charset name.
     * @return the charsetName
     */

			}
			if err != nil && testCase.shouldPass {
				t.Errorf("Test %d: %s:  Expected to pass, but failed with: <ERROR> %s", i+1, instanceType, err.Error())
			}
			if err == nil && !testCase.shouldPass {
				t.Errorf("Test %d: %s: Expected to fail with <ERROR> \"%s\", but passed instead", i+1, instanceType, testCase.err.Error())
			}
			// Failed as expected, but does it fail for the expected reason.
			if err != nil && !testCase.shouldPass {