*/
    public static final int SID_TYPE_DOMAIN = 3;

    /**
     * SID type for an invalid SID.
     */
    public static final int SID_TYPE_INVALID = 7;

    /**
     * SID type for an unknown SID.
     */
    public static final int SID_TYPE_UNKNOWN = 8;

    /**
     * SID type for a non-use SID.
     */
    public static final int SID_TYPE_USE_NONE = 0;

    /**
     * SID type for a user.

//go:generate msgp -file $GOFILE -io=false -tests=false -unexported=false

// BackendType - represents different backend types.
type BackendType int

// Enum for different backend types.
const (
	Unknown = BackendType(madmin.Unknown)
	// Filesystem backend.
	BackendFS = BackendType(madmin.FS)
	// Multi disk BackendErasure (single, distributed) backend.
	BackendErasure = BackendType(madmin.Erasure)
	// Add your own backend.
)

            assertNotNull(resp.info);
            assertTrue(resp.info instanceof Trans2QueryPathInformationResponse.SmbQueryFileStandardInfo);
        }

        @Test
        @DisplayName("Should return 0 for unknown information level")
        void testReadDataUnknownLevel() {
            Trans2QueryPathInformationResponse resp = new Trans2QueryPathInformationResponse(0x999);

            byte[] buffer = new byte[100];

			}
			return errMalformedEncoding
		}
		key := strings.ToLower(line[:idx])
		value := line[idx+1:]
		if _, ok := wantTrailers[key]; !ok {
			if cr.debug {
				fmt.Printf("Unknown key %q - expected on of %v\n", key, cr.trailers)
			}
			return errMalformedEncoding
		}
		cr.trailers.Set(key, value)
		delete(wantTrailers, key)
	}

	// Check if we got all we want.

errors.failed_to_delete_doc_in_admin = Failed to delete a document.
errors.failed_to_send_testmail=Failed to send a test mail.
errors.invalid_query_unknown = The specified query has an unknown condition.
errors.invalid_query_parse_error = The given query is invalid.
errors.invalid_query_sort_value = The specified sort {0} is invalid.
errors.invalid_query_unsupported_sort_field = The specified sort {0} is unsupported.

errors.failed_to_delete_doc_in_admin = Failed to delete a document.
errors.failed_to_send_testmail=Failed to send a test mail.
errors.invalid_query_unknown = The specified query has an unknown condition.
errors.invalid_query_parse_error = The given query is invalid.
errors.invalid_query_sort_value = The specified sort {0} is invalid.
errors.invalid_query_unsupported_sort_field = The specified sort {0} is unsupported.

            return convertPrefixQuery(context, prefixQuery, boost);
        }
        throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**
     * Converts a prefix query to a query builder.
     *
     * @param context the query context
     * @param prefixQuery the prefix query

ECL0114=NoSuchAlgorithmException occurred, because {0}
ECL0115=Failed to set accessible to the field: {0}
ECL0116=Failed to set accessible to the method: {0}

WCL0013=Protocol of URL({1}) corresponding to route package({0}) is unknown.

		sftpLogOnceIf(context.Background(), err, "accept-channel-sftp")
	case xsftp.SSHKeyExchangeError:
		sftpLogOnceIf(context.Background(), err, "key-exchange-sftp")
	default:
		sftpLogOnceIf(context.Background(), err, "unknown-error-sftp")
	}
}

func filterAlgos(arg string, want []string, allowed []string) []string {
	var filteredAlgos []string
	found := false
	for _, algo := range want {
		if len(algo) == 0 {
			continue

            fail("Should throw InvalidQueryException");
        } catch (InvalidQueryException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("Unknown q:"));
        }
    }

    public void test_toLowercaseWildcard_enabled() {
        queryCommand.setLowercaseWildcard(true);

        assertEquals("test", queryCommand.toLowercaseWildcard("TEST"));