* @throws TransportException if the connection fails or times out
     */
    public synchronized void connect(final long timeout) throws TransportException {
        try {
            switch (state) {
            case 0:
                break;
            case 3:
                return; // already connected
            case 4:
                state = 0;

type BatchJobReplicateResourceType string

// Validate validates if the replicate resource type is recognized and supported
func (t BatchJobReplicateResourceType) Validate() error {
	switch t {
	case BatchJobReplicateResourceMinIO:
	case BatchJobReplicateResourceS3:
	default:
		return errInvalidArgument
	}
	return nil
}

func (t BatchJobReplicateResourceType) isMinio() bool {

		}
	}
}

// Save various references we are going to need later.
func (f *File) saveExprs(x interface{}, context astContext) {
	switch x := x.(type) {
	case *ast.Expr:
		switch (*x).(type) {
		case *ast.SelectorExpr:
			f.saveRef(x, context)
		}
	case *ast.CallExpr:
		f.saveCall(x, context)
	}
}

// Save references to C.xxx for later processing.

	if len(data) <= 4 {
		return nil, errors.New("tierConfigInit: no data")
	}

	// Read header
	switch format := binary.LittleEndian.Uint16(data[0:2]); format {
	case tierConfigFormat:
	default:
		return nil, fmt.Errorf("tierConfigInit: unknown format: %d", format)
	}

	cfg := NewTierConfigMgr()
	switch version := binary.LittleEndian.Uint16(data[2:4]); version {
	case tierConfigV1, tierConfigVersion:

			return ctx.Err()
		}
		for i, r := range readers {
			if errs[i] != nil {
				hasErr++
				continue
			}
			entry, err := r.peek()
			switch err {
			case io.EOF:
				atEOF++
				continue
			case nil:
			default:
				switch err.Error() {
				case errFileNotFound.Error():
					atEOF++
					fnf++
					continue
				case errVolumeNotFound.Error():
					atEOF++

		expectedIPList set.StringSet
		expectedErr    error
	}{
		{"localhost", set.CreateStringSet("127.0.0.1"), nil},
	}

	for _, testCase := range testCases {
		ipList, err := getHostIP(testCase.host)
		switch {
		case testCase.expectedErr == nil:
			if err != nil {
				t.Fatalf("error: expected = <nil>, got = %v", err)
			}
		case err == nil:
			t.Fatalf("error: expected = %v, got = <nil>", testCase.expectedErr)

	capacityXMLObject = ".system-d26a9498-cb7c-4a87-a44a-8ae204f5ba6c/capacity.xml"
	veeamAgentSubstr  = "APN/1.0 Veeam/1.0"
)

func isVeeamSOSAPIObject(object string) bool {
	switch object {
	case systemXMLObject, capacityXMLObject:
		return true
	default:
		return false
	}
}

// isVeeamClient - returns true if the request is from Veeam client.

		// need to keep track of nested #if[n]defs.
		// We let #line through because it might affect errors.
		switch in.Stack.Text() {
		case "else", "endif", "ifdef", "ifndef", "line":
			// Press on.
		default:
			return false
		}
	}
	switch in.Stack.Text() {
	case "define":
		in.define()
	case "else":
		in.else_()
	case "endif":
		in.endif()
	case "ifdef":

  /*
   * The following methods are safe to call as long as both of the following hold:
   *
   * - allocArrays() has been called. Callers can confirm this by checking needsAllocArrays().
   *
   * - The map has not switched to delegating to a java.util implementation to mitigate hash
   *   flooding. Callers can confirm this by null-checking delegateOrNull().
   *

    }

    /**
     * Test switch statement usage
     */
    public void test_switchStatement() {
        for (CrawlerStatus status : CrawlerStatus.values()) {
            String description = getStatusDescription(status);
            assertNotNull(description);
            assertFalse(description.isEmpty());
        }
    }

    /**
     * Helper method to test switch statement
     */