switch (resp.getErrorCode()) {
        case NtStatus.NT_STATUS_SUCCESS:
            cont = true;
            break;
        case NtStatus.NT_STATUS_ACCESS_DENIED:
        case NtStatus.NT_STATUS_WRONG_PASSWORD:
        case NtStatus.NT_STATUS_LOGON_FAILURE:
        case NtStatus.NT_STATUS_ACCOUNT_RESTRICTION:
        case NtStatus.NT_STATUS_INVALID_LOGON_HOURS:
        case NtStatus.NT_STATUS_INVALID_WORKSTATION:

            c = value.charAt(i);
            String escaped = switch (c) {
            case '\\', '"' -> "\\" + c;
            case '/' -> "\\/";
            case '\b' -> "\\b";
            case '\t' -> "\\t";
            case '\n' -> "\\n";
            case '\f' -> "\\f";
            case '\r' -> "\\r";

        case QUERY -> "QUERY";
        case WACK -> "WACK";
        default -> Integer.toString(opCode);
        };
        resultCodeString = switch (resultCode) {
        case FMT_ERR -> "FMT_ERR";
        case SRV_ERR -> "SRV_ERR";
        case IMP_ERR -> "IMP_ERR";
        case RFS_ERR -> "RFS_ERR";
        case ACT_ERR -> "ACT_ERR";
        case CFT_ERR -> "CFT_ERR";

        opCodeString = switch (this.opCode) {
        case QUERY -> "QUERY";
        case WACK -> "WACK";
        default -> Integer.toString(this.opCode);
        };
        resultCodeString = switch (this.resultCode) {
        case FMT_ERR -> "FMT_ERR";
        case SRV_ERR -> "SRV_ERR";
        case IMP_ERR -> "IMP_ERR";
        case RFS_ERR -> "RFS_ERR";
        case ACT_ERR -> "ACT_ERR";
        case CFT_ERR -> "CFT_ERR";

        final int c = cmd & 0xFF;
        switch (c) {
        case SMB_COM_CHECK_DIRECTORY:
            return cfg.getBatchLimit("TreeConnectAndX.CheckDirectory");
        case SMB_COM_CREATE_DIRECTORY:
            return cfg.getBatchLimit("TreeConnectAndX.CreateDirectory");
        case SMB_COM_DELETE:
            return cfg.getBatchLimit("TreeConnectAndX.Delete");
        case SMB_COM_DELETE_DIRECTORY:

	}

	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)
		case testCase.expectedErr.Error() != err.Error():
			t.Fatalf("error: expected = %v, got = %v", testCase.expectedErr, err)

   *       simply switch over to use the JDK implementation wholesale if probable hash flooding is
   *       detected, sacrificing the compactness guarantee in very rare cases in exchange for much
   *       more reliable worst-case behavior.
   *   <li>null, if no entries have yet been added to the map
   * </ul>
   */
  private transient @Nullable Object table;

  /**

  // threadpool of GPU event mgr, as that can trigger more callbacks to be
  // scheduled on that same threadpool, causing a deadlock in cases where the
  // caller of event_mgr->ThenExecute() blocks on the completion of the callback
  // (as in the case of ConstOp kernel creation on GPU, which involves copying a
  // CPU tensor to GPU).
  // Setting a larger thread pool does not help with the Swift caller, as we use

	// prepend asterisks
	return append([]byte("***"), data...), nil
}

type Num int64

func (i *Num) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		n, _ := strconv.Atoi(string(s))
		*i = Num(n)
	case int64:
		*i = Num(s)
	default:
		return errors.New("Cannot scan NamedInt from " + reflect.ValueOf(src).String())
	}
	return nil
}

type StringsSlice []string

	switch reflectValue.Kind() {
	case reflect.Struct:
		switch rel.Type {
		case schema.HasMany, schema.Many2Many:
			tx.AddError(rel.Field.Set(tx.Statement.Context, reflectValue, reflect.MakeSlice(rel.Field.IndirectFieldType, 0, 10).Interface()))
		default:
			tx.AddError(rel.Field.Set(tx.Statement.Context, reflectValue, reflect.New(rel.Field.FieldType).Interface()))
		}
	case reflect.Slice, reflect.Array: