Fix parsing response codes (#730)

This commit is contained in:
Daniel Eggert authored and GitHub committed 2023-02-19 10:10:12 +01:00
1 parent 426a884a42
commit 511d4e799d
5 files changed
+230 -220

No files matched your search

@@ -29,6 +29,11 @@ public indirect enum ResponseTextCode: Hashable {
/// attention to the message.
case alert
/// The operation attempts to create something that already exists,
/// such as when the CREATE or RENAME directories attempt to create
/// a mailbox and there is already one of that name.
case alreadyExists
/// A SEARCH failed because the given charset is not supported by
/// this implementation. If the optional list of charsets is
/// given, this lists the charsets that are supported by this
@@ -254,11 +259,6 @@ public indirect enum ResponseTextCode: Hashable {
/// quota, but the client cannot find out what the quota is.
case overQuota
/// The operation attempts to create something that already exists,
/// such as when the CREATE or RENAME directories attempt to create
/// a mailbox and there is already one of that name.
case alreadyExists
/// The operation attempts to delete something that does not exist.
/// Similar to ALREADYEXISTS.
case nonExistent
@@ -46,26 +46,26 @@ extension GrammarParser {
}
// resp-code-apnd = "APPENDUID" SP nz-number SP append-uid
func parseResponseCodeAppend(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseCodeAppend {
try PL.composite(buffer: &buffer, tracker: tracker) { buffer, tracker -> ResponseCodeAppend in
try PL.parseFixedString("APPENDUID ", buffer: &buffer, tracker: tracker)
func parseSuffix_appendUID(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.composite(buffer: &buffer, tracker: tracker) { buffer, tracker -> ResponseTextCode in
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
let number = try self.parseUIDValidity(buffer: &buffer, tracker: tracker)
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
let uids = try self.parseUIDSetNonEmpty(buffer: &buffer, tracker: tracker)
return ResponseCodeAppend(uidValidity: number, uids: uids)
return .uidAppend(ResponseCodeAppend(uidValidity: number, uids: uids))
}
}
// resp-code-copy = "COPYUID" SP nz-number SP uid-set SP uid-set
func parseResponseCodeCopy(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseCodeCopy {
try PL.composite(buffer: &buffer, tracker: tracker) { buffer, tracker -> ResponseCodeCopy in
try PL.parseFixedString("COPYUID ", buffer: &buffer, tracker: tracker)
func parseSuffix_uidCopy(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.composite(buffer: &buffer, tracker: tracker) { buffer, tracker -> ResponseTextCode in
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
let uidValidity = try self.parseUIDValidity(buffer: &buffer, tracker: tracker)
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
let sourceUIDRanges = try self.parseUIDRangeArray(buffer: &buffer, tracker: tracker)
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
let destinationUIDRanges = try self.parseUIDRangeArray(buffer: &buffer, tracker: tracker)
return ResponseCodeCopy(destinationUIDValidity: uidValidity, sourceUIDs: sourceUIDRanges, destinationUIDs: destinationUIDRanges)
return .uidCopy(ResponseCodeCopy(destinationUIDValidity: uidValidity, sourceUIDs: sourceUIDRanges, destinationUIDs: destinationUIDRanges))
}
}
@@ -197,44 +197,24 @@ extension GrammarParser {
}
}
// resp-text-code = "ALERT" /
// "BADCHARSET" [SP "(" charset *(SP charset) ")" ] /
// capability-data / "PARSE" /
// "PERMANENTFLAGS" SP "("
// [flag-perm *(SP flag-perm)] ")" /
// "READ-ONLY" / "READ-WRITE" / "TRYCREATE" /
// "UIDNEXT" SP nz-number / "UIDVALIDITY" SP nz-number /
// "UNSEEN" SP nz-number
// atom [SP 1*<any TEXT-CHAR except "]">] /
// "NOTSAVED"
/// See https://www.iana.org/assignments/imap-response-codes/imap-response-codes.xhtml
func parseResponseTextCode(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
func parseResponseTextCode_alert(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("ALERT", buffer: &buffer, tracker: tracker)
return .alert
}
func parseResponseTextCode_noModifierSequence(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("NOMODSEQ", buffer: &buffer, tracker: tracker)
return .noModificationSequence
}
func parseResponseTextCode_modified(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("MODIFIED ", buffer: &buffer, tracker: tracker)
func parseSuffix_modified(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
return .modified(try self.parseMessageIdentifierSet(buffer: &buffer, tracker: tracker))
}
func parseResponseTextCode_highestModifiedSequence(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("HIGHESTMODSEQ ", buffer: &buffer, tracker: tracker)
func parseSuffix_highestModifiedSequence(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
return .highestModificationSequence(try self.parseModificationSequenceValue(buffer: &buffer, tracker: tracker))
}
func parseResponseTextCode_referral(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("REFERRAL ", buffer: &buffer, tracker: tracker)
func parseSuffix_referral(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
return .referral(try self.parseIMAPURL(buffer: &buffer, tracker: tracker))
}
func parseResponseTextCode_badCharset(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("BADCHARSET", buffer: &buffer, tracker: tracker)
func parseSuffix_badCharset(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
let charsets = try PL.parseOptional(buffer: &buffer, tracker: tracker) { (buffer, tracker) -> [String] in
try PL.parseFixedString(" (", buffer: &buffer, tracker: tracker)
var array = [try self.parseCharset(buffer: &buffer, tracker: tracker)]
@@ -248,17 +228,13 @@ extension GrammarParser {
return .badCharset(charsets)
}
func parseResponseTextCode_capabilityData(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
.capability(try self.parseCapabilityData(buffer: &buffer, tracker: tracker))
func parseSuffix_capability(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
.capability(try self.parseCapabilitySuffix(buffer: &buffer, tracker: tracker))
}
func parseResponseTextCode_parse(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("PARSE", buffer: &buffer, tracker: tracker)
return .parse
}
func parseResponseTextCode_permanentFlags(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("PERMANENTFLAGS (", buffer: &buffer, tracker: tracker)
func parseSuffix_permanentFlags(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
try PL.parseFixedString("(", buffer: &buffer, tracker: tracker)
let array = try PL.parseOptional(buffer: &buffer, tracker: tracker) { (buffer, tracker) -> [PermanentFlag] in
var array = [try self.parseFlagPerm(buffer: &buffer, tracker: tracker)]
try PL.parseZeroOrMore(buffer: &buffer, into: &array, tracker: tracker) { (buffer, tracker) in
@@ -271,38 +247,66 @@ extension GrammarParser {
return .permanentFlags(array ?? [])
}
func parseResponseTextCode_readOnly(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("READ-ONLY", buffer: &buffer, tracker: tracker)
return .readOnly
}
func parseResponseTextCode_readWrite(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("READ-WRITE", buffer: &buffer, tracker: tracker)
return .readWrite
}
func parseResponseTextCode_tryCreate(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("TRYCREATE", buffer: &buffer, tracker: tracker)
return .tryCreate
}
func parseResponseTextCode_uidNext(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("UIDNEXT ", buffer: &buffer, tracker: tracker)
func parseSuffix_uidNext(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
return .uidNext(try self.parseMessageIdentifier(buffer: &buffer, tracker: tracker))
}
func parseResponseTextCode_uidValidity(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("UIDVALIDITY ", buffer: &buffer, tracker: tracker)
func parseSuffix_uidValidity(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
return .uidValidity(try self.parseUIDValidity(buffer: &buffer, tracker: tracker))
}
func parseResponseTextCode_unseen(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("UNSEEN ", buffer: &buffer, tracker: tracker)
func parseSuffix_unseen(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
return .unseen(try self.parseMessageIdentifier(buffer: &buffer, tracker: tracker))
}
func parseResponseTextCode_namespace(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
.namespace(try self.parseNamespaceResponse(buffer: &buffer, tracker: tracker))
func parseSuffix_metadata(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
func parseSuffix_metadataLongEntries(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("LONGENTRIES ", buffer: &buffer, tracker: tracker)
let num = try self.parseNumber(buffer: &buffer, tracker: tracker)
return .metadataLongEntries(num)
}
func parseSuffix_metadataMaxSize(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("MAXSIZE ", buffer: &buffer, tracker: tracker)
let num = try self.parseNumber(buffer: &buffer, tracker: tracker)
return .metadataMaxsize(num)
}
func parseSuffix_metadataTooMany(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("TOOMANY", buffer: &buffer, tracker: tracker)
return .metadataTooMany
}
func parseSuffix_metadataNoPrivate(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("NOPRIVATE", buffer: &buffer, tracker: tracker)
return .metadataNoPrivate
}
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
return try PL.parseOneOf([
parseSuffix_metadataLongEntries,
parseSuffix_metadataMaxSize,
parseSuffix_metadataTooMany,
parseSuffix_metadataNoPrivate,
], buffer: &buffer, tracker: tracker)
}
func parseSuffix_urlMechanisms(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
try PL.parseFixedString("INTERNAL", buffer: &buffer, tracker: tracker)
let array = try PL.parseZeroOrMore(buffer: &buffer, tracker: tracker, parser: { buffer, tracker -> MechanismBase64 in
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
return try self.parseMechanismBase64(buffer: &buffer, tracker: tracker)
})
return .urlMechanisms(array)
}
func parseSuffix_namespace(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
.namespace(try self.parseNamespaceSuffix(buffer: &buffer, tracker: tracker))
}
func parseResponseTextCode_atom(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
@@ -318,88 +322,57 @@ extension GrammarParser {
return .other(atom, string)
}
func parseResponseTextCode_uidNotSticky(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("UIDNOTSTICKY", buffer: &buffer, tracker: tracker)
return .uidNotSticky
}
let commandParsers: [String: (inout ParseBuffer, StackTracker) throws -> ResponseTextCode] = [
"ALERT": { _, _ in .alert },
"ALREADYEXISTS": { _, _ in .alreadyExists },
"APPENDUID": parseSuffix_appendUID,
"AUTHENTICATIONFAILED": { _, _ in .authenticationFailed },
"AUTHORIZATIONFAILED": { _, _ in .authorizationFailed },
"BADCHARSET": parseSuffix_badCharset,
"CANNOT": { _, _ in .cannot },
"CAPABILITY": parseSuffix_capability,
"CLIENTBUG": { _, _ in .clientBug },
"CLOSED": { _, _ in .closed },
"COMPRESSIONACTIVE": { _, _ in .compressionActive },
"CONTACTADMIN": { _, _ in .contactAdmin },
"COPYUID": parseSuffix_uidCopy,
"CORRUPTION": { _, _ in .corruption },
"EXPIRED": { _, _ in .expired },
"EXPUNGEISSUED": { _, _ in .expungeIssued },
"HIGHESTMODSEQ": parseSuffix_highestModifiedSequence,
"INUSE": { _, _ in .inUse },
"LIMIT": { _, _ in .limit },
"METADATA": parseSuffix_metadata,
"MODIFIED": parseSuffix_modified,
"NAMESPACE": parseSuffix_namespace,
"NOMODSEQ": { _, _ in .noModificationSequence },
"NONEXISTENT": { _, _ in .nonExistent },
"NOPERM": { _, _ in .noPermission },
"NOTSAVED": { _, _ in .notSaved },
"OVERQUOTA": { _, _ in .overQuota },
"PARSE": { _, _ in .parse },
"PERMANENTFLAGS": parseSuffix_permanentFlags,
"PRIVACYREQUIRED": { _, _ in .privacyRequired },
"READ-ONLY": { _, _ in .readOnly },
"READ-WRITE": { _, _ in .readWrite },
"REFERRAL": parseSuffix_referral,
"SERVERBUG": { _, _ in .serverBug },
"TRYCREATE": { _, _ in .tryCreate },
"UIDNEXT": parseSuffix_uidNext,
"UIDNOTSTICKY": { _, _ in .uidNotSticky },
"UIDVALIDITY": parseSuffix_uidValidity,
"UNAVAILABLE": { _, _ in .unavailable },
"UNSEEN": parseSuffix_unseen,
"URLMECH": parseSuffix_urlMechanisms,
"USEATTR": { _, _ in .useAttribute },
]
func parseResponseTextCode_closed(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("CLOSED", buffer: &buffer, tracker: tracker)
return .closed
}
func parseResponseTextCode_uidCopy(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
.uidCopy(try self.parseResponseCodeCopy(buffer: &buffer, tracker: tracker))
}
func parseResponseTextCode_uidAppend(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
.uidAppend(try self.parseResponseCodeAppend(buffer: &buffer, tracker: tracker))
}
// RFC 5182
func parseResponseTextCode_notSaved(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("NOTSAVED", buffer: &buffer, tracker: tracker)
return .notSaved
}
func parseResponseTextCode_metadataLongEntries(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("METADATA LONGENTRIES ", buffer: &buffer, tracker: tracker)
let num = try self.parseNumber(buffer: &buffer, tracker: tracker)
return .metadataLongEntries(num)
}
func parseResponseTextCode_metadataMaxSize(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("METADATA MAXSIZE ", buffer: &buffer, tracker: tracker)
let num = try self.parseNumber(buffer: &buffer, tracker: tracker)
return .metadataMaxsize(num)
}
func parseResponseTextCode_metadataTooMany(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("METADATA TOOMANY", buffer: &buffer, tracker: tracker)
return .metadataTooMany
}
func parseResponseTextCode_metadataNoPrivate(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("METADATA NOPRIVATE", buffer: &buffer, tracker: tracker)
return .metadataNoPrivate
}
func parseResponseTextCode_urlMechanisms(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try PL.parseFixedString("URLMECH INTERNAL", buffer: &buffer, tracker: tracker)
let array = try PL.parseZeroOrMore(buffer: &buffer, tracker: tracker, parser: { buffer, tracker -> MechanismBase64 in
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
return try self.parseMechanismBase64(buffer: &buffer, tracker: tracker)
})
return .urlMechanisms(array)
func parseKnownResponseTextCode(buffer: inout ParseBuffer, tracker: StackTracker) throws -> ResponseTextCode {
try parseFromLookupTable(buffer: &buffer, tracker: tracker, parsers: commandParsers)
}
return try PL.parseOneOf([
parseResponseTextCode_alert,
parseResponseTextCode_noModifierSequence,
parseResponseTextCode_modified,
parseResponseTextCode_highestModifiedSequence,
parseResponseTextCode_badCharset,
parseResponseTextCode_capabilityData,
parseResponseTextCode_parse,
parseResponseTextCode_permanentFlags,
parseResponseTextCode_readOnly,
parseResponseTextCode_readWrite,
parseResponseTextCode_tryCreate,
parseResponseTextCode_uidNext,
parseResponseTextCode_uidValidity,
parseResponseTextCode_unseen,
parseResponseTextCode_namespace,
parseResponseTextCode_uidNotSticky,
parseResponseTextCode_notSaved,
parseResponseTextCode_uidCopy,
parseResponseTextCode_uidAppend,
parseResponseTextCode_closed,
parseResponseTextCode_metadataLongEntries,
parseResponseTextCode_metadataMaxSize,
parseResponseTextCode_metadataTooMany,
parseResponseTextCode_metadataNoPrivate,
parseResponseTextCode_urlMechanisms,
parseResponseTextCode_referral,
parseKnownResponseTextCode,
parseResponseTextCode_atom,
], buffer: &buffer, tracker: tracker)
}
@@ -193,10 +193,15 @@ extension GrammarParser {
func parseCapabilityData(buffer: inout ParseBuffer, tracker: StackTracker) throws -> [Capability] {
try PL.composite(buffer: &buffer, tracker: tracker) { buffer, tracker -> [Capability] in
try PL.parseFixedString("CAPABILITY", buffer: &buffer, tracker: tracker)
return try PL.parseOneOrMore(buffer: &buffer, tracker: tracker) { (buffer, tracker) in
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
return try self.parseCapability(buffer: &buffer, tracker: tracker)
}
return try self.parseCapabilitySuffix(buffer: &buffer, tracker: tracker)
}
}
// *(SP capability)
func parseCapabilitySuffix(buffer: inout ParseBuffer, tracker: StackTracker) throws -> [Capability] {
try PL.parseOneOrMore(buffer: &buffer, tracker: tracker) { (buffer, tracker) in
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
return try self.parseCapability(buffer: &buffer, tracker: tracker)
}
}
@@ -1551,7 +1556,15 @@ extension GrammarParser {
// SP Namespace SP Namespace
func parseNamespaceResponse(buffer: inout ParseBuffer, tracker: StackTracker) throws -> NamespaceResponse {
try PL.composite(buffer: &buffer, tracker: tracker) { buffer, tracker -> NamespaceResponse in
try PL.parseFixedString("NAMESPACE ", buffer: &buffer, tracker: tracker)
try PL.parseFixedString("NAMESPACE", buffer: &buffer, tracker: tracker)
return try parseNamespaceSuffix(buffer: &buffer, tracker: tracker)
}
}
// SP Namespace SP Namespace SP Namespace
func parseNamespaceSuffix(buffer: inout ParseBuffer, tracker: StackTracker) throws -> NamespaceResponse {
try PL.composite(buffer: &buffer, tracker: tracker) { buffer, tracker -> NamespaceResponse in
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
let n1 = try self.parseNamespace(buffer: &buffer, tracker: tracker)
try PL.parseSpaces(buffer: &buffer, tracker: tracker)
let n2 = try self.parseNamespace(buffer: &buffer, tracker: tracker)
@@ -24,61 +24,58 @@ extension ResponseTextCodeTests {
func testEncode() {
let inputs: [(ResponseTextCode, String, UInt)] = [
(.alert, "ALERT", #line),
(.alreadyExists, "ALREADYEXISTS", #line),
(.authenticationFailed, "AUTHENTICATIONFAILED", #line),
(.authorizationFailed, "AUTHORIZATIONFAILED", #line),
(.badCharset(["some", "string"]), "BADCHARSET (some string)", #line),
(.cannot, "CANNOT", #line),
(.capability([.unselect, .binary, .children]), "CAPABILITY UNSELECT BINARY CHILDREN", #line),
(.capability([.unselect]), "CAPABILITY UNSELECT", #line),
(.clientBug, "CLIENTBUG", #line),
(.closed, "CLOSED", #line),
(.compressionActive, "COMPRESSIONACTIVE", #line),
(.contactAdmin, "CONTACTADMIN", #line),
(.corruption, "CORRUPTION", #line),
(.expired, "EXPIRED", #line),
(.expungeIssued, "EXPUNGEISSUED", #line),
(.highestModificationSequence(1), "HIGHESTMODSEQ 1", #line),
(.inUse, "INUSE", #line),
(.limit, "LIMIT", #line),
(.metadataLongEntries(456), "METADATA LONGENTRIES 456", #line),
(.metadataMaxsize(123), "METADATA MAXSIZE 123", #line),
(.metadataNoPrivate, "METADATA NOPRIVATE", #line),
(.metadataTooMany, "METADATA TOOMANY", #line),
(.modified(.set(MessageIdentifierSet<UnknownMessageIdentifier>([1]))), "MODIFIED 1", #line),
(.modified(MessageIdentifierSet<SequenceNumber>([23 ... 873])), "MODIFIED 23:873", #line),
(.modified(MessageIdentifierSet<UID>([45, 77])), "MODIFIED 45,77", #line),
(.namespace(.init(userNamespace: [], otherUserNamespace: [], sharedNamespace: [])), "NAMESPACE NIL NIL NIL", #line),
(.noModificationSequence, "NOMODSEQ", #line),
(.noPermission, "NOPERM", #line),
(.nonExistent, "NONEXISTENT", #line),
(.notSaved, "NOTSAVED", #line),
(.overQuota, "OVERQUOTA", #line),
(.parse, "PARSE", #line),
(.permanentFlags([.flag(.deleted), .flag(.draft)]), #"PERMANENTFLAGS (\Deleted \Draft)"#, #line),
(.permanentFlags([.wildcard, .wildcard]), #"PERMANENTFLAGS (\* \*)"#, #line),
(.permanentFlags([.wildcard]), #"PERMANENTFLAGS (\*)"#, #line),
(.privacyRequired, "PRIVACYREQUIRED", #line),
(.readOnly, "READ-ONLY", #line),
(.readWrite, "READ-WRITE", #line),
(.referral(.init(server: .init(host: "localhost"), query: nil)), "REFERRAL imap://localhost/", #line),
(.serverBug, "SERVERBUG", #line),
(.tryCreate, "TRYCREATE", #line),
(.uidNext(123), "UIDNEXT 123", #line),
(.uidValidity(234), "UIDVALIDITY 234", #line),
(.unseen(345), "UNSEEN 345", #line),
(.badCharset(["some", "string"]), "BADCHARSET (some string)", #line),
(.permanentFlags([.wildcard]), #"PERMANENTFLAGS (\*)"#, #line),
(.permanentFlags([.wildcard, .wildcard]), #"PERMANENTFLAGS (\* \*)"#, #line),
(.permanentFlags([.flag(.deleted), .flag(.draft)]), #"PERMANENTFLAGS (\Deleted \Draft)"#, #line),
(.other("some", nil), "some", #line),
(.other("some", "thing"), "some thing", #line),
(.capability([.unselect]), "CAPABILITY UNSELECT", #line),
(.capability([.unselect, .binary, .children]), "CAPABILITY UNSELECT BINARY CHILDREN", #line),
(.namespace(.init(userNamespace: [], otherUserNamespace: [], sharedNamespace: [])), "NAMESPACE NIL NIL NIL", #line),
(.useAttribute, "USEATTR", #line),
(.notSaved, "NOTSAVED", #line),
(.closed, "CLOSED", #line),
(.noModificationSequence, "NOMODSEQ", #line),
(.modified(.set(MessageIdentifierSet<UnknownMessageIdentifier>([1]))), "MODIFIED 1", #line),
(.modified(MessageIdentifierSet<UID>([45, 77])), "MODIFIED 45,77", #line),
(.modified(MessageIdentifierSet<SequenceNumber>([23 ... 873])), "MODIFIED 23:873", #line),
(.highestModificationSequence(1), "HIGHESTMODSEQ 1", #line),
(.metadataMaxsize(123), "METADATA MAXSIZE 123", #line),
(.metadataLongEntries(456), "METADATA LONGENTRIES 456", #line),
(.metadataTooMany, "METADATA TOOMANY", #line),
(.metadataNoPrivate, "METADATA NOPRIVATE", #line),
(.urlMechanisms([]), "URLMECH INTERNAL", #line),
(.urlMechanisms([.init(mechanism: .internal, base64: nil)]), "URLMECH INTERNAL INTERNAL", #line),
(.urlMechanisms([.init(mechanism: .internal, base64: "test")]), "URLMECH INTERNAL INTERNAL=test", #line),
(
.urlMechanisms([.init(mechanism: .init("m1"), base64: "b1"), .init(mechanism: .init("m2"), base64: "b2")]),
"URLMECH INTERNAL m1=b1 m2=b2",
#line
),
(.referral(.init(server: .init(host: "localhost"), query: nil)), "REFERRAL imap://localhost/", #line),
(.unavailable, "UNAVAILABLE", #line),
(.authenticationFailed, "AUTHENTICATIONFAILED", #line),
(.authorizationFailed, "AUTHORIZATIONFAILED", #line),
(.expired, "EXPIRED", #line),
(.privacyRequired, "PRIVACYREQUIRED", #line),
(.contactAdmin, "CONTACTADMIN", #line),
(.noPermission, "NOPERM", #line),
(.inUse, "INUSE", #line),
(.expungeIssued, "EXPUNGEISSUED", #line),
(.corruption, "CORRUPTION", #line),
(.serverBug, "SERVERBUG", #line),
(.clientBug, "CLIENTBUG", #line),
(.cannot, "CANNOT", #line),
(.limit, "LIMIT", #line),
(.overQuota, "OVERQUOTA", #line),
(.alreadyExists, "ALREADYEXISTS", #line),
(.nonExistent, "NONEXISTENT", #line),
(.compressionActive, "COMPRESSIONACTIVE", #line),
(.unseen(345), "UNSEEN 345", #line),
(.urlMechanisms([.init(mechanism: .init("m1"), base64: "b1"), .init(mechanism: .init("m2"), base64: "b2")]), "URLMECH INTERNAL m1=b1 m2=b2", #line),
(.urlMechanisms([.init(mechanism: .internal, base64: "test")]), "URLMECH INTERNAL INTERNAL=test", #line),
(.urlMechanisms([.init(mechanism: .internal, base64: nil)]), "URLMECH INTERNAL INTERNAL", #line),
(.urlMechanisms([]), "URLMECH INTERNAL", #line),
(.useAttribute, "USEATTR", #line),
(.other("some", "thing"), "some thing", #line),
(.other("some", nil), "some", #line),
(.other("SOMETHING", nil), "SOMETHING", #line),
]
self.iterateInputs(inputs: inputs, encoder: { self.testBuffer.writeResponseTextCode($0) })
}
@@ -63,34 +63,61 @@ extension GrammarParser_Response_Tests {
testFunction: GrammarParser().parseResponseTextCode,
validInputs: [
("ALERT", "\r", .alert, #line),
("BADCHARSET", "\r", .badCharset([]), #line),
("BADCHARSET (UTF8)", "\r", .badCharset(["UTF8"]), #line),
("ALREADYEXISTS", "\r", .alreadyExists, #line),
("ALREADYEXISTS", "\r", .alreadyExists, #line),
("APPENDUID 1234 4:5", "\r", .uidAppend(.init(uidValidity: 1234, uids: [4, 5])), #line),
("AUTHENTICATIONFAILED", "\r", .authenticationFailed, #line),
("AUTHORIZATIONFAILED", "\r", .authorizationFailed, #line),
("BADCHARSET (UTF8 UTF9 UTF10)", "\r", .badCharset(["UTF8", "UTF9", "UTF10"]), #line),
("BADCHARSET (UTF8)", "\r", .badCharset(["UTF8"]), #line),
("BADCHARSET", "\r", .badCharset([]), #line),
("CANNOT", "\r", .cannot, #line),
("CAPABILITY IMAP4 IMAP4rev1", "\r", .capability([.imap4, .imap4rev1]), #line),
("CLIENTBUG", "\r", .clientBug, #line),
("CLOSED", "\r", .closed, #line),
("COMPRESSIONACTIVE", "\r", .compressionActive, #line),
("CONTACTADMIN", "\r", .contactAdmin, #line),
("COPYUID 443 3:5 6:8", "\r", .uidCopy(.init(destinationUIDValidity: 443, sourceUIDs: [3 ... 5], destinationUIDs: [6 ... 8])), #line),
("CORRUPTION", "\r", .corruption, #line),
("EXPIRED", "\r", .expired, #line),
("EXPUNGEISSUED", "\r", .expungeIssued, #line),
("HIGHESTMODSEQ 1", "\r", .highestModificationSequence(.init(integerLiteral: 1)), #line),
("INUSE", "\r", .inUse, #line),
("LIMIT", "\r", .limit, #line),
("METADATA LONGENTRIES 456", "\r", .metadataLongEntries(456), #line),
("METADATA MAXSIZE 123", "\r", .metadataMaxsize(123), #line),
("METADATA NOPRIVATE", "\r", .metadataNoPrivate, #line),
("METADATA TOOMANY", "\r", .metadataTooMany, #line),
("MODIFIED 1", "\r", .modified(.set([1])), #line),
(#"NAMESPACE (("Foo" NIL)) NIL (("Bar" NIL))"#, "\r", .namespace(.init(userNamespace: [.init(string: "Foo", responseExtensions: [:])], otherUserNamespace: [], sharedNamespace: [.init(string: "Bar", char: nil, responseExtensions: [:])])), #line),
("NAMESPACE NIL NIL NIL", "\r", .namespace(.init(userNamespace: [], otherUserNamespace: [], sharedNamespace: [])), #line),
("NOMODSEQ", "\r", .noModificationSequence, #line),
("NONEXISTENT", "\r", .nonExistent, #line),
("NOPERM", "\r", .noPermission, #line),
("NOTSAVED", "\r", .notSaved, #line),
("OVERQUOTA", "\r", .overQuota, #line),
("PARSE", "\r", .parse, #line),
("PERMANENTFLAGS ()", "\r", .permanentFlags([]), #line),
("PERMANENTFLAGS (\\Answered)", "\r", .permanentFlags([.flag(.answered)]), #line),
("PERMANENTFLAGS (\\Answered \\Seen \\*)", "\r", .permanentFlags([.flag(.answered), .flag(.seen), .wildcard]), #line),
("PERMANENTFLAGS (\\Answered)", "\r", .permanentFlags([.flag(.answered)]), #line),
("PRIVACYREQUIRED", "\r", .privacyRequired, #line),
("READ-ONLY", "\r", .readOnly, #line),
("READ-WRITE", "\r", .readWrite, #line),
("REFERRAL imap://localhost/", "\r", .referral(.init(server: .init(host: "localhost"), query: nil)), #line),
("SERVERBUG", "\r", .serverBug, #line),
("SOMETHING", "\r", .other("SOMETHING", nil), #line),
("TRYCREATE", "\r", .tryCreate, #line),
("UIDNEXT 12", "\r", .uidNext(12), #line),
("UIDNOTSTICKY", "\r", .uidNotSticky, #line),
("UIDVALIDITY 34", "\r", .uidValidity(34), #line),
("UNAVAILABLE", "\r", .unavailable, #line),
("UNSEEN 56", "\r", .unseen(56), #line),
("NOMODSEQ", "\r", .noModificationSequence, #line),
("MODIFIED 1", "\r", .modified(.set([1])), #line),
("HIGHESTMODSEQ 1", "\r", .highestModificationSequence(.init(integerLiteral: 1)), #line),
("NAMESPACE NIL NIL NIL", "\r", .namespace(.init(userNamespace: [], otherUserNamespace: [], sharedNamespace: [])), #line),
("some", "\r", .other("some", nil), #line),
("some thing", "\r", .other("some", "thing"), #line),
("NOTSAVED", "\r", .notSaved, #line),
("METADATA MAXSIZE 123", "\r", .metadataMaxsize(123), #line),
("METADATA LONGENTRIES 456", "\r", .metadataLongEntries(456), #line),
("METADATA TOOMANY", "\r", .metadataTooMany, #line),
("METADATA NOPRIVATE", "\r", .metadataNoPrivate, #line),
("URLMECH INTERNAL", "\r", .urlMechanisms([]), #line),
("URLMECH INTERNAL INTERNAL", "\r", .urlMechanisms([.init(mechanism: .internal, base64: nil)]), #line),
("URLMECH INTERNAL INTERNAL=YQ==", "\r", .urlMechanisms([.init(mechanism: .internal, base64: "a")]), #line),
("REFERRAL imap://localhost/", "\r", .referral(.init(server: .init(host: "localhost"), query: nil)), #line),
("URLMECH INTERNAL", "\r", .urlMechanisms([]), #line),
("USEATTR", "\r", .useAttribute, #line),
("some thing", "\r", .other("some", "thing"), #line),
("some", "\r", .other("some", nil), #line),
],
parserErrorInputs: [],
incompleteMessageInputs: []