diff --git a/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_Constants.swift b/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_Constants.swift index 6f5651f1..25d2f8e0 100644 --- a/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_Constants.swift +++ b/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_Constants.swift @@ -542,9 +542,9 @@ public enum Tekkon { /// 在這裡將二十六個字母寫全，也只是為了方便做 validity check。 /// 這裡提前對複音按鍵做處理，然後再用程式判斷介母類型、據此判斷是否需要做複音切換。 static let mapDachenCP26StaticKeys: [String: String] = [ - "a": "ㄇ", "b": "ㄖ", "c": "ㄏ", "d": "ㄎ", "e": "ㄍ", "f": "ㄑ", "g": "ㄕ", "h": "ㄘ", "i": "ㄛ", "j": "ㄨ", "k": "ㄜ", - "l": "ㄠ", "m": "ㄩ", "n": "ㄙ", "o": "ㄟ", "p": "ㄣ", "q": "ㄆ", "r": "ㄐ", "s": "ㄋ", "t": "ㄔ", "u": "ㄧ", "v": "ㄒ", - "w": "ㄊ", "x": "ㄌ", "y": "ㄗ", "z": "ㄈ", " ": " ", + "a": "ㄇ", "b": "ㄖ", "c": "ㄏ", "d": "ㄎ", "e": "ㄍ", "f": "ㄑ", "g": "ㄕ", "h": "ㄘ", "i": "ㄞ", "j": "ㄨ", "k": "ㄜ", + "l": "ㄤ", "m": "ㄩ", "n": "ㄙ", "o": "ㄢ", "p": "ㄦ", "q": "ㄅ", "r": "ㄐ", "s": "ㄋ", "t": "ㄓ", "u": "ㄧ", "v": "ㄒ", + "w": "ㄉ", "x": "ㄌ", "y": "ㄗ", "z": "ㄈ", " ": " ", ] /// 許氏排列專用處理陣列，但未包含全部的映射內容。 @@ -552,7 +552,7 @@ public enum Tekkon { /// 在這裡將二十六個字母寫全，也只是為了方便做 validity check。 /// 這裡提前對複音按鍵做處理，然後再用程式判斷介母類型、據此判斷是否需要做複音切換。 static let mapHsuStaticKeys: [String: String] = [ - "a": "ㄘ", "b": "ㄅ", "c": "ㄒ", "d": "ㄉ", "e": "ㄧ", "f": "ㄈ", "g": "ㄍ", "h": "ㄏ", "i": "ㄞ", "j": "ㄐ", "k": "ㄎ", + "a": "ㄘ", "b": "ㄅ", "c": "ㄕ", "d": "ㄉ", "e": "ㄧ", "f": "ㄈ", "g": "ㄍ", "h": "ㄏ", "i": "ㄞ", "j": "ㄐ", "k": "ㄎ", "l": "ㄌ", "m": "ㄇ", "n": "ㄋ", "o": "ㄡ", "p": "ㄆ", "r": "ㄖ", "s": "ㄙ", "t": "ㄊ", "u": "ㄩ", "v": "ㄔ", "w": "ㄠ", "x": "ㄨ", "y": "ㄚ", "z": "ㄗ", " ": " ", ] @@ -574,8 +574,18 @@ public enum Tekkon { static let mapStarlightStaticKeys: [String: String] = [ "a": "ㄚ", "b": "ㄅ", "c": "ㄘ", "d": "ㄉ", "e": "ㄜ", "f": "ㄈ", "g": "ㄍ", "h": "ㄏ", "i": "ㄧ", "j": "ㄓ", "k": "ㄎ", "l": "ㄌ", "m": "ㄇ", "n": "ㄋ", "o": "ㄛ", "p": "ㄆ", "q": "ㄔ", "r": "ㄖ", "s": "ㄙ", "t": "ㄊ", "u": "ㄨ", "v": "ㄩ", - "w": "ㄡ", "x": "ㄕ", "y": "ㄞ", "z": "ㄗ", " ": " ", "1": " ", "2": "ˊ", "3": "ˇ", "4": "ˋ", "5": "˙", "6": " ", - "7": "ˊ", "8": "ˇ", "9": "ˋ", "0": "˙", + "w": "ㄡ", "x": "ㄕ", "y": "ㄞ", "z": "ㄗ", "1": " ", "2": "ˊ", "3": "ˇ", "4": "ˋ", "5": "˙", "6": " ", + "7": "ˊ", "8": "ˇ", "9": "ˋ", "0": "˙", " ": " ", + ] + + /// 劉氏擬音注音排列預處理專用陣列，但未包含全部的映射內容。 + /// + /// 在這裡將二十六個字母寫全，也只是為了方便做 validity check。 + /// 這裡提前對複音按鍵做處理，然後再用程式判斷介母類型、據此判斷是否需要做複音切換。 + static let mapAlvinLiuStaticKeys: [String: String] = [ + "q": "ㄑ", "w": "ㄠ", "e": "ㄜ", "r": "ㄖ", "t": "ㄊ", "y": "ㄩ", "u": "ㄨ", "i": "ㄧ", "o": "ㄛ", "p": "ㄆ", "a": "ㄚ", + "s": "ㄙ", "d": "ㄉ", "f": "ㄈ", "g": "ㄍ", "h": "ㄏ", "j": "ㄐ", "k": "ㄎ", "l": "ㄦ", "z": "ㄗ", "x": "ㄒ", "c": "ㄘ", + "v": "ㄡ", "b": "ㄅ", "n": "ㄋ", "m": "ㄇ", " ": " ", ] /// 倚天傳統排列專用處理陣列。 diff --git a/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_Phonabets.swift b/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_Phonabets.swift index 7e288134..1c97f14d 100644 --- a/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_Phonabets.swift +++ b/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_Phonabets.swift @@ -32,6 +32,7 @@ public extension Tekkon { case ofSeigyou = 7 case ofFakeSeigyou = 8 case ofStarlight = 9 + case ofAlvinLiu = 10 case ofHanyuPinyin = 100 case ofSecondaryPinyin = 101 case ofYalePinyin = 102 @@ -61,6 +62,8 @@ public extension Tekkon { return "Seigyou" case .ofStarlight: return "Starlight" + case .ofAlvinLiu: + return "AlvinLiu" case .ofHanyuPinyin: return "HanyuPinyin" case .ofSecondaryPinyin: @@ -88,9 +91,8 @@ public extension Tekkon { public var type: PhoneType = .null private var valueStorage = "" public var value: String { valueStorage } - public var isEmpty: Bool { - value.isEmpty - } + public var isEmpty: Bool { value.isEmpty } + public var isValid: Bool { type != .null } /// 初期化，會根據傳入的 input 字串參數來自動判定自身的 PhoneType 類型屬性值。 public init(_ input: String = "") { diff --git a/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_SyllableComposer.swift b/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_SyllableComposer.swift index 76e789b9..f1d7d0d3 100644 --- a/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_SyllableComposer.swift +++ b/Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_SyllableComposer.swift @@ -49,6 +49,14 @@ public extension Tekkon { /// 當前注拼槽是否處於拼音模式。 public var isPinyinMode: Bool { parser.rawValue >= 100 } + /// 統計有效的聲介韻（調）個數。 + /// - Parameter withIntonation: 是否統計聲調。 + /// - Returns: 統計出的有效 Phonabet 個數。 + public func count(withIntonation: Bool = false) -> Int { + [consonant.isValid, semivowel.isValid, vowel.isValid] + .reduce((withIntonation && intonation.isValid) ? 1 : 0) { $0 + ($1 ? 1 : 0) } + } + /// 與 value 類似，這個函式就是用來決定輸入法組字區內顯示的注音/拼音內容， /// 但可以指定是否輸出教科書格式（拼音的調號在字母上方、注音的輕聲寫在左側）。 /// - Parameters: @@ -148,6 +156,8 @@ public extension Tekkon { return Tekkon.mapFakeSeigyou[input] != nil case .ofStarlight: return Tekkon.mapStarlightStaticKeys[input] != nil + case .ofAlvinLiu: + return Tekkon.mapAlvinLiuStaticKeys[input] != nil case .ofWadeGilesPinyin: return Tekkon.mapWadeGilesPinyinKeys.contains(input) case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin: @@ -167,24 +177,16 @@ public extension Tekkon { /// - strOf: 要取代的內容。 /// - strWith: 要取代成的內容。 mutating func fixValue(_ strOf: String, _ strWith: String = "") { + guard !strOf.isEmpty, !strWith.isEmpty else { return } let theOld = Phonabet(strOf) - if !strOf.isEmpty { - switch theOld.type { - case .consonant where consonant == theOld: consonant.clear() - case .semivowel where semivowel == theOld: semivowel.clear() - case .vowel where vowel == theOld: vowel.clear() - case .intonation where intonation == theOld: intonation.clear() - default: return - } - } - let theNew = Phonabet(strWith) - switch theNew.type { - case .consonant: consonant = theNew - case .semivowel: semivowel = theNew - case .vowel: vowel = theNew - case .intonation: intonation = theNew - case .null: return + switch theOld { + case consonant: consonant.clear() + case semivowel: semivowel.clear() + case vowel: vowel.clear() + case intonation: intonation.clear() + default: return } + receiveKey(fromPhonabet: strWith) } /// 接受傳入的按鍵訊號時的處理，處理對象為 String。 @@ -237,32 +239,32 @@ public extension Tekkon { case "ㄧ", "ㄩ": if vowel.value == "ㄜ" { vowel = "ㄝ" } case "ㄜ": - if "ㄨ".contains(semivowel.value) { semivowel = "ㄩ" } - if "ㄧㄩ".contains(semivowel.value) { thePhone = "ㄝ" } + if "ㄨ".doesHave(semivowel.value) { semivowel = "ㄩ" } + if "ㄧㄩ".doesHave(semivowel.value) { thePhone = "ㄝ" } case "ㄝ": - if "ㄨ".contains(semivowel.value) { semivowel = "ㄩ" } + if "ㄨ".doesHave(semivowel.value) { semivowel = "ㄩ" } case "ㄛ", "ㄥ": if phonabet == "ㄛ", semivowel.value == "ㄩ" { semivowel = "ㄨ" } - if "ㄅㄆㄇㄈ".contains(consonant.value), semivowel.value == "ㄨ" { semivowel.clear() } + if "ㄅㄆㄇㄈ".doesHave(consonant.value), semivowel.value == "ㄨ" { semivowel.clear() } case "ㄟ": - if "ㄋㄌ".contains(consonant.value), semivowel.value == "ㄨ" { semivowel.clear() } + if "ㄋㄌ".doesHave(consonant.value), semivowel.value == "ㄨ" { semivowel.clear() } case "ㄨ": - if "ㄅㄆㄇㄈ".contains(consonant.value), "ㄛㄥ".contains(vowel.value) { vowel.clear() } - if "ㄋㄌ".contains(consonant.value), "ㄟ".contains(vowel.value) { vowel.clear() } - if "ㄜ".contains(vowel.value) { vowel = "ㄝ" } - if "ㄝ".contains(vowel.value) { thePhone = "ㄩ" } + if "ㄅㄆㄇㄈ".doesHave(consonant.value), "ㄛㄥ".doesHave(vowel.value) { vowel.clear() } + if "ㄋㄌ".doesHave(consonant.value), "ㄟ".doesHave(vowel.value) { vowel.clear() } + if "ㄜ".doesHave(vowel.value) { vowel = "ㄝ" } + if "ㄝ".doesHave(vowel.value) { thePhone = "ㄩ" } case "ㄅ", "ㄆ", "ㄇ", "ㄈ": if ["ㄨㄛ", "ㄨㄥ"].contains(semivowel.value + vowel.value) { semivowel.clear() } default: break } - if [.vowel, .intonation].contains(thePhone.type), "ㄓㄔㄕㄗㄘㄙ".contains(consonant.value) { + if [.vowel, .intonation].contains(thePhone.type), "ㄓㄔㄕㄗㄘㄙ".doesHave(consonant.value) { switch semivowel.value { case "ㄧ": semivowel.clear() case "ㄩ": switch consonant { - case _ where "ㄓㄗ".contains(consonant.value): consonant = "ㄐ" - case _ where "ㄔㄘ".contains(consonant.value): consonant = "ㄑ" - case _ where "ㄕㄙ".contains(consonant.value): consonant = "ㄒ" + case _ where "ㄓㄗ".doesHave(consonant.value): consonant = "ㄐ" + case _ where "ㄔㄘ".doesHave(consonant.value): consonant = "ㄑ" + case _ where "ㄕㄙ".doesHave(consonant.value): consonant = "ㄒ" default: break } default: break @@ -410,12 +412,14 @@ public extension Tekkon { return Tekkon.mapFakeSeigyou[key] ?? "" case .ofStarlight: return handleStarlight(key: key) + case .ofAlvinLiu: + return handleAlvinLiu(key: key) default: return "" } } - /// 所有動態注音鍵盤佈局都會用到的共用糾錯處理步驟。 + /// 所有動態注音排列都會用到的共用糾錯處理步驟。 /// - Parameter incomingPhonabet: 傳入的注音 Phonabet。 public mutating func commonFixWhenHandlingDynamicArrangeInputs(target incomingPhonabet: Phonabet) { // 處理特殊情形。 @@ -424,7 +428,7 @@ public extension Tekkon { switch consonant { case "ㄍ": switch incomingPhonabet { - case "ㄧ": consonant = "ㄑ" // ㄑㄧ + // 這裡不處理「ㄍㄧ」到「ㄑㄧ」的轉換，因為只有倚天26需要處理這個。 case "ㄨ": consonant = "ㄍ" // ㄍㄨ case "ㄩ": consonant = "ㄑ" // ㄑㄩ default: break @@ -452,6 +456,11 @@ public extension Tekkon { } default: break } + if incomingPhonabet == "ㄨ" { + fixValue("ㄐ", "ㄓ") + fixValue("ㄑ", "ㄔ") + fixValue("ㄒ", "ㄕ") + } case .vowel: if semivowel.isEmpty { fixValue("ㄐ", "ㄓ") @@ -462,46 +471,41 @@ public extension Tekkon { } } - /// 倚天忘形注音排列比較麻煩，需要單獨處理。 + /// 倚天忘形注音排列是複合注音排列，需要單獨處理。 /// /// 回傳結果是空字串的話，不要緊，因為該函式內部已經處理過分配過程了。 /// - Parameters: /// - key: 傳入的 String 訊號。 public mutating func handleETen26(key: String = "") -> String { var strReturn = Tekkon.mapETen26StaticKeys[key] ?? "" - let incomingPhonabet = Phonabet(strReturn) + + let keysToHandleHere = "dfhjklmnpqtw" switch key { - case "d": if !isPronouncable { consonant = "ㄉ" } else { intonation = "˙" } - case "f": if !isPronouncable { consonant = "ㄈ" } else { intonation = "ˊ" } - case "j": if !isPronouncable { consonant = "ㄖ" } else { intonation = "ˇ" } - case "k": if !isPronouncable { consonant = "ㄎ" } else { intonation = "ˋ" } - case "h": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄏ" } else { vowel = "ㄦ" } - case "l": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄌ" } else { vowel = "ㄥ" } - case "m": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄇ" } else { vowel = "ㄢ" } - case "n": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄋ" } else { vowel = "ㄣ" } - case "q": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄗ" } else { vowel = "ㄟ" } - case "t": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄊ" } else { vowel = "ㄤ" } - case "w": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄘ" } else { vowel = "ㄝ" } - case "p": - if consonant.isEmpty, semivowel.isEmpty { - consonant = "ㄆ" - } else if consonant.isEmpty, semivowel == "ㄧ" { - vowel = "ㄡ" - } else if consonant.isEmpty { - consonant = "ㄆ" - } else { - vowel = "ㄡ" - } + case "d" where isPronouncable: strReturn = "˙" + case "f" where isPronouncable: strReturn = "ˊ" + case "j" where isPronouncable: strReturn = "ˇ" + case "k" where isPronouncable: strReturn = "ˋ" + case "e" where consonant == "ㄍ": consonant = "ㄑ" + case "p" where !consonant.isEmpty || semivowel == "ㄧ": strReturn = "ㄡ" + case "h" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄦ" + case "l" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄥ" + case "m" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄢ" + case "n" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄣ" + case "q" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄟ" + case "t" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄤ" + case "w" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄝ" default: break } - // 處理特殊情形。 - commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet) + if keysToHandleHere.doesHave(key) { + receiveKey(fromPhonabet: strReturn) + } - if "dfjk ".contains(key), - !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty - { + // 處理公共特殊情形。 + commonFixWhenHandlingDynamicArrangeInputs(target: Phonabet(strReturn)) + + if "dfjk ".doesHave(key), count() == 1 { fixValue("ㄆ", "ㄡ") fixValue("ㄇ", "ㄢ") fixValue("ㄊ", "ㄤ") @@ -514,131 +518,124 @@ public extension Tekkon { if value == "ㄍ˙" { consonant = "ㄑ" } // 這些按鍵在上文處理過了，就不要再回傳了。 - if "dfhjklmnpqtw".contains(key) { strReturn = "" } + if keysToHandleHere.doesHave(key) { strReturn = "" } // 回傳結果是空字串的話，不要緊，因為上文已經代處理過分配過程了。 return strReturn } - /// 許氏鍵盤與倚天忘形一樣同樣也比較麻煩，需要單獨處理。 + /// 許氏注音排列是複合注音排列，需要單獨處理。 /// /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。 /// - Parameters: /// - key: 傳入的 String 訊號。 public mutating func handleHsu(key: String = "") -> String { var strReturn = Tekkon.mapHsuStaticKeys[key] ?? "" - let incomingPhonabet = Phonabet(strReturn) - if key == " ", value == "ㄋ" { - consonant.clear() - vowel = "ㄣ" - } + let keysToHandleHere = "acdefghjklmns" switch key { - case "d": if isPronouncable { intonation = "ˊ" } else { consonant = "ㄉ" } - case "f": if isPronouncable { intonation = "ˇ" } else { consonant = "ㄈ" } - case "s": if isPronouncable { intonation = "˙" } else { consonant = "ㄙ" } - case "j": if isPronouncable { intonation = "ˋ" } else { consonant = "ㄓ" } - case "a": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄘ" } else { vowel = "ㄟ" } - case "v": if semivowel.isEmpty { consonant = "ㄔ" } else { consonant = "ㄑ" } - case "c": if semivowel.isEmpty { consonant = "ㄕ" } else { consonant = "ㄒ" } - case "e": if semivowel.isEmpty { semivowel = "ㄧ" } else { vowel = "ㄝ" } - case "g": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄍ" } else { vowel = "ㄜ" } - case "h": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄏ" } else { vowel = "ㄛ" } - case "k": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄎ" } else { vowel = "ㄤ" } - case "m": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄇ" } else { vowel = "ㄢ" } - case "n": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄋ" } else { vowel = "ㄣ" } + case "d" where isPronouncable: strReturn = "ˊ" + case "f" where isPronouncable: strReturn = "ˇ" + case "s" where isPronouncable: strReturn = "˙" + case "j" where isPronouncable: strReturn = "ˋ" + case "a" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄟ" + case "v" where !semivowel.isEmpty: strReturn = "ㄑ" + case "c" where !semivowel.isEmpty: strReturn = "ㄒ" + case "e" where !semivowel.isEmpty: strReturn = "ㄝ" + case "g" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄜ" + case "h" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄛ" + case "k" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄤ" + case "m" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄢ" + case "n" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄣ" case "l": if value.isEmpty, !consonant.isEmpty, !semivowel.isEmpty { - vowel = "ㄦ" + strReturn = "ㄦ" } else if consonant.isEmpty, semivowel.isEmpty { - consonant = "ㄌ" + strReturn = "ㄌ" } else { - vowel = "ㄥ" + strReturn = "ㄥ" } default: break } - // 處理特殊情形。 - commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet) + if keysToHandleHere.doesHave(key) { + receiveKey(fromPhonabet: strReturn) + } - if "dfjs ".contains(key) { - if !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty { - fixValue("ㄍ", "ㄜ") - fixValue("ㄋ", "ㄣ") - fixValue("ㄌ", "ㄦ") - fixValue("ㄎ", "ㄤ") - fixValue("ㄇ", "ㄢ") - } - if "ㄢㄣㄤㄥ".contains(vowel.value), semivowel.isEmpty { - fixValue("ㄐ", "ㄓ") - fixValue("ㄑ", "ㄔ") - fixValue("ㄒ", "ㄕ") - } - if "ㄐㄑㄒ".contains(consonant.value), semivowel.isEmpty { - fixValue("ㄐ", "ㄓ") - fixValue("ㄑ", "ㄔ") - fixValue("ㄒ", "ㄕ") - } - if consonant == "ㄏ", semivowel.isEmpty, vowel.isEmpty { - consonant.clear() - vowel = "ㄛ" - } + // 處理公共特殊情形。 + commonFixWhenHandlingDynamicArrangeInputs(target: Phonabet(strReturn)) + + if "dfjs ".doesHave(key), count() == 1 { + fixValue("ㄒ", "ㄕ") + fixValue("ㄍ", "ㄜ") + fixValue("ㄋ", "ㄣ") + fixValue("ㄌ", "ㄦ") + fixValue("ㄎ", "ㄤ") + fixValue("ㄇ", "ㄢ") + fixValue("ㄐ", "ㄓ") + fixValue("ㄑ", "ㄔ") + fixValue("ㄒ", "ㄕ") + fixValue("ㄏ", "ㄛ") } // 後置修正 if value == "ㄔ˙" { consonant = "ㄑ" } // 這些按鍵在上文處理過了，就不要再回傳了。 - if "acdefghjklmns".contains(key) { strReturn = "" } + if keysToHandleHere.doesHave(key) { strReturn = "" } // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。 return strReturn } - /// 星光排列一樣同樣也比較麻煩，需要單獨處理。 + /// 星光注音排列是複合注音排列，需要單獨處理。 /// /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。 /// - Parameters: /// - key: 傳入的 String 訊號。 public mutating func handleStarlight(key: String) -> String { var strReturn = Tekkon.mapStarlightStaticKeys[key] ?? "" - let incomingPhonabet = Phonabet(strReturn) + + let keysToHandleHere = "efgklmnt" + switch key { - case "e": return "ㄧㄩ".contains(semivowel.value) ? "ㄝ" : "ㄜ" - case "f": return vowel == "ㄠ" || !isPronouncable ? "ㄈ" : "ㄠ" - case "g": return vowel == "ㄥ" || !isPronouncable ? "ㄍ" : "ㄥ" - case "k": return vowel == "ㄤ" || !isPronouncable ? "ㄎ" : "ㄤ" - case "l": return vowel == "ㄦ" || !isPronouncable ? "ㄌ" : "ㄦ" - case "m": return vowel == "ㄢ" || !isPronouncable ? "ㄇ" : "ㄢ" - case "n": return vowel == "ㄣ" || !isPronouncable ? "ㄋ" : "ㄣ" - case "t": return vowel == "ㄟ" || !isPronouncable ? "ㄊ" : "ㄟ" + case "e" where "ㄧㄩ".doesHave(semivowel.value): strReturn = "ㄝ" + case "f" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄠ" + case "g" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄥ" + case "k" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄤ" + case "l" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄦ" + case "m" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄢ" + case "n" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄣ" + case "t" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄟ" default: break } - // 處理特殊情形。 - commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet) + if keysToHandleHere.doesHave(key) { + receiveKey(fromPhonabet: strReturn) + } - if "67890 ".contains(key) { - if !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty { - fixValue("ㄈ", "ㄠ") - fixValue("ㄍ", "ㄥ") - fixValue("ㄎ", "ㄤ") - fixValue("ㄌ", "ㄦ") - fixValue("ㄇ", "ㄢ") - fixValue("ㄋ", "ㄣ") - fixValue("ㄊ", "ㄟ") - } + // 處理公共特殊情形。 + commonFixWhenHandlingDynamicArrangeInputs(target: Phonabet(strReturn)) + + if "67890 ".doesHave(key), count() == 1 { + fixValue("ㄈ", "ㄠ") + fixValue("ㄍ", "ㄥ") + fixValue("ㄎ", "ㄤ") + fixValue("ㄌ", "ㄦ") + fixValue("ㄇ", "ㄢ") + fixValue("ㄋ", "ㄣ") + fixValue("ㄊ", "ㄟ") } // 這些按鍵在上文處理過了，就不要再回傳了。 - if "efgklmn".contains(key) { strReturn = "" } + if keysToHandleHere.doesHave(key) { strReturn = "" } // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。 return strReturn } - /// 大千忘形一樣同樣也比較麻煩，需要單獨處理。 + /// 酷音大千二十六鍵注音排列是複合注音排列，需要單獨處理。 /// /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。 /// - Parameters: @@ -647,61 +644,112 @@ public extension Tekkon { var strReturn = Tekkon.mapDachenCP26StaticKeys[key] ?? "" switch key { - case "e": if isPronouncable { intonation = "ˊ" } else { consonant = "ㄍ" } - case "r": if isPronouncable { intonation = "ˇ" } else { consonant = "ㄐ" } - case "d": if isPronouncable { intonation = "ˋ" } else { consonant = "ㄎ" } - case "y": if isPronouncable { intonation = "˙" } else { consonant = "ㄗ" } - case "b": if !consonant.isEmpty || !semivowel.isEmpty { vowel = "ㄝ" } else { consonant = "ㄖ" } - case "i": if vowel.isEmpty || vowel == "ㄞ" { vowel = "ㄛ" } else { vowel = "ㄞ" } - case "l": if vowel.isEmpty || vowel == "ㄤ" { vowel = "ㄠ" } else { vowel = "ㄤ" } - case "n": - if !consonant.isEmpty || !semivowel.isEmpty { - if consonant == "ㄙ", semivowel.isEmpty, vowel.isEmpty { consonant.clear() } - vowel = "ㄥ" - } else { - consonant = "ㄙ" - } - case "o": if vowel.isEmpty || vowel == "ㄢ" { vowel = "ㄟ" } else { vowel = "ㄢ" } - case "p": if vowel.isEmpty || vowel == "ㄦ" { vowel = "ㄣ" } else { vowel = "ㄦ" } - case "q": if consonant.isEmpty || consonant == "ㄅ" { consonant = "ㄆ" } else { consonant = "ㄅ" } - case "t": if consonant.isEmpty || consonant == "ㄓ" { consonant = "ㄔ" } else { consonant = "ㄓ" } - case "w": if consonant.isEmpty || consonant == "ㄉ" { consonant = "ㄊ" } else { consonant = "ㄉ" } + case "e" where isPronouncable: strReturn = "ˊ" + case "r" where isPronouncable: strReturn = "ˇ" + case "d" where isPronouncable: strReturn = "ˋ" + case "y" where isPronouncable: strReturn = "˙" + case "b" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄝ" + case "i" where vowel.isEmpty || vowel == "ㄞ": strReturn = "ㄛ" + case "l" where vowel.isEmpty || vowel == "ㄤ": strReturn = "ㄠ" + case "n" where !consonant.isEmpty || !semivowel.isEmpty: + if value == "ㄙ" { consonant.clear() } + strReturn = "ㄥ" + case "o" where vowel.isEmpty || vowel == "ㄢ": strReturn = "ㄟ" + case "p" where vowel.isEmpty || vowel == "ㄦ": strReturn = "ㄣ" + case "q" where consonant.isEmpty || consonant == "ㄅ": strReturn = "ㄆ" + case "t" where consonant.isEmpty || consonant == "ㄓ": strReturn = "ㄔ" + case "w" where consonant.isEmpty || consonant == "ㄉ": strReturn = "ㄊ" case "m": if semivowel == "ㄩ", vowel != "ㄡ" { semivowel.clear() - vowel = "ㄡ" + strReturn = "ㄡ" } else if semivowel != "ㄩ", vowel == "ㄡ" { - semivowel = "ㄩ" vowel.clear() + strReturn = "ㄩ" } else if !semivowel.isEmpty { - vowel = "ㄡ" + strReturn = "ㄡ" } else { - receiveKey(fromPhonabet: "ㄐㄑㄒ".contains(consonant.value) ? "ㄩ" : "ㄡ") + strReturn = "ㄐㄑㄒ".doesHave(consonant.value) ? "ㄩ" : "ㄡ" } case "u": if semivowel == "ㄧ", vowel != "ㄚ" { semivowel.clear() - vowel = "ㄚ" + strReturn = "ㄚ" } else if semivowel != "ㄧ", vowel == "ㄚ" { - semivowel = "ㄧ" + strReturn = "ㄧ" } else if semivowel == "ㄧ", vowel == "ㄚ" { semivowel.clear() vowel.clear() } else if !semivowel.isEmpty { - vowel = "ㄚ" + strReturn = "ㄚ" } else { - semivowel = "ㄧ" + strReturn = "ㄧ" } default: break } - // 這些按鍵在上文處理過了，就不要再回傳了。 - if "qwtilopnbmuerdy".contains(key) { strReturn = "" } - // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。 return strReturn } + /// 劉氏擬音注音排列是複合注音排列，需要單獨處理。 + /// + /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。 + /// - Remark: 該處理兼顧了「原旨排列方案」與「微軟新注音相容排列方案」。 + /// - Parameters: + /// - key: 傳入的 String 訊號。 + public mutating func handleAlvinLiu(key: String) -> String { + var strReturn = Tekkon.mapAlvinLiuStaticKeys[key] ?? "" + + // 前置處理專有特殊情形。 + if strReturn != "ㄦ" && !vowel.isEmpty { fixValue("ㄦ", "ㄌ") } + + let keysToHandleHere = "dfjlegnhkbmc" + + switch key { + case "d" where isPronouncable: strReturn = "˙" + case "f" where isPronouncable: strReturn = "ˊ" + case "j" where isPronouncable: strReturn = "ˇ" + case "l" where isPronouncable: strReturn = "ˋ" + case "e" where "ㄧㄩ".doesHave(semivowel.value): strReturn = "ㄝ" + case "g" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄤ" + case "n" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄣ" + case "h" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄞ" + case "k" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄟ" + case "b" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄢ" + case "m" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄥ" + case "c" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄝ" + default: break + } + + if keysToHandleHere.doesHave(key) { + receiveKey(fromPhonabet: strReturn) + } + + // 處理公共特殊情形。 + commonFixWhenHandlingDynamicArrangeInputs(target: Phonabet(strReturn)) + + if "dfjl ".doesHave(key), count() == 1 { + fixValue("ㄑ", "ㄔ") + fixValue("ㄊ", "ㄦ") + fixValue("ㄍ", "ㄤ") + fixValue("ㄏ", "ㄞ") + fixValue("ㄐ", "ㄓ") + fixValue("ㄎ", "ㄟ") + fixValue("ㄌ", "ㄦ") + fixValue("ㄒ", "ㄕ") + fixValue("ㄅ", "ㄢ") + fixValue("ㄋ", "ㄣ") + fixValue("ㄇ", "ㄥ") + } + + // 這些按鍵在上文處理過了，就不要再回傳了。 + if keysToHandleHere.doesHave(key) { strReturn = "" } + + // 回傳結果是空字串的話，不要緊，因為上文已經代處理過分配過程了。 + return strReturn + } + // MARK: - Misc Definitions /// 這些內容用來滿足 "Equatable, Hashable, ExpressibleByStringLiteral" 需求。 @@ -730,3 +778,9 @@ public extension Tekkon { } } } + +private extension String { + func doesHave(_ target: String) -> Bool { + target.isEmpty ? isEmpty : contains(target) + } +} diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_A.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_A.swift new file mode 100644 index 00000000..c64f447d --- /dev/null +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_A.swift @@ -0,0 +1,509 @@ +// (c) 2022 and onwards The vChewing Project (MIT-NTL License). +// ==================== +// This code is released under the MIT license (SPDX-License-Identifier: MIT) +// ... with NTL restriction stating that: +// No trademark license is granted to use the trade names, trademarks, service +// marks, or product names of Contributor, except as required to fulfill notice +// requirements defined in MIT License. + +import XCTest + +@testable import Tekkon + +extension TekkonTestsKeyboardArrangments { + func testAlvinLiuKeysTaigi() throws { + var c = Tekkon.Composer(arrange: .ofAlvinLiu) + XCTAssertEqual(c.cS2RC("kig"), "ㄎㄧㄤ") + XCTAssertEqual(c.cS2RC("giwf"), "ㄍㄧㄠˊ") + XCTAssertEqual(c.cS2RC("gin"), "ㄍㄧㄣ") + } + + func testAlvinLiuKeysA() throws { + var c = Tekkon.Composer(arrange: .ofAlvinLiu) + XCTAssertEqual(c.cS2RC("kig"), "ㄎㄧㄤ") + XCTAssertEqual(c.cS2RC("giwf"), "ㄍㄧㄠˊ") + XCTAssertEqual(c.cS2RC("gin"), "ㄍㄧㄣ") + XCTAssertEqual(c.cS2RC("bigf"), "ㄅㄧㄤˊ") + XCTAssertEqual(c.cS2RC("bigl"), "ㄅㄧㄤˋ") + XCTAssertEqual(c.cS2RC("dug"), "ㄉㄨㄤ") + XCTAssertEqual(c.cS2RC("ba"), "ㄅㄚ") + XCTAssertEqual(c.cS2RC("baf"), "ㄅㄚˊ") + XCTAssertEqual(c.cS2RC("baj"), "ㄅㄚˇ") + XCTAssertEqual(c.cS2RC("bal"), "ㄅㄚˋ") + XCTAssertEqual(c.cS2RC("bad"), "ㄅㄚ˙") + XCTAssertEqual(c.cS2RC("bo"), "ㄅㄛ") + XCTAssertEqual(c.cS2RC("bof"), "ㄅㄛˊ") + XCTAssertEqual(c.cS2RC("boj"), "ㄅㄛˇ") + XCTAssertEqual(c.cS2RC("bol"), "ㄅㄛˋ") + XCTAssertEqual(c.cS2RC("bod"), "ㄅㄛ˙") + XCTAssertEqual(c.cS2RC("bh"), "ㄅㄞ") + XCTAssertEqual(c.cS2RC("bhf"), "ㄅㄞˊ") + XCTAssertEqual(c.cS2RC("bhj"), "ㄅㄞˇ") + XCTAssertEqual(c.cS2RC("bhl"), "ㄅㄞˋ") + XCTAssertEqual(c.cS2RC("bhd"), "ㄅㄞ˙") + XCTAssertEqual(c.cS2RC("bk"), "ㄅㄟ") + XCTAssertEqual(c.cS2RC("bkj"), "ㄅㄟˇ") + XCTAssertEqual(c.cS2RC("bkl"), "ㄅㄟˋ") + XCTAssertEqual(c.cS2RC("bkd"), "ㄅㄟ˙") + XCTAssertEqual(c.cS2RC("bw"), "ㄅㄠ") + XCTAssertEqual(c.cS2RC("bwf"), "ㄅㄠˊ") + XCTAssertEqual(c.cS2RC("bwj"), "ㄅㄠˇ") + XCTAssertEqual(c.cS2RC("bwl"), "ㄅㄠˋ") + XCTAssertEqual(c.cS2RC("bb"), "ㄅㄢ") + XCTAssertEqual(c.cS2RC("bbj"), "ㄅㄢˇ") + XCTAssertEqual(c.cS2RC("bbl"), "ㄅㄢˋ") + XCTAssertEqual(c.cS2RC("bn"), "ㄅㄣ") + XCTAssertEqual(c.cS2RC("bnj"), "ㄅㄣˇ") + XCTAssertEqual(c.cS2RC("bnl"), "ㄅㄣˋ") + XCTAssertEqual(c.cS2RC("bg"), "ㄅㄤ") + XCTAssertEqual(c.cS2RC("bgj"), "ㄅㄤˇ") + XCTAssertEqual(c.cS2RC("bgl"), "ㄅㄤˋ") + XCTAssertEqual(c.cS2RC("bm"), "ㄅㄥ") + XCTAssertEqual(c.cS2RC("bmf"), "ㄅㄥˊ") + XCTAssertEqual(c.cS2RC("bmj"), "ㄅㄥˇ") + XCTAssertEqual(c.cS2RC("bml"), "ㄅㄥˋ") + XCTAssertEqual(c.cS2RC("bi"), "ㄅㄧ") + XCTAssertEqual(c.cS2RC("bif"), "ㄅㄧˊ") + XCTAssertEqual(c.cS2RC("bij"), "ㄅㄧˇ") + XCTAssertEqual(c.cS2RC("bil"), "ㄅㄧˋ") + XCTAssertEqual(c.cS2RC("bie"), "ㄅㄧㄝ") + XCTAssertEqual(c.cS2RC("bief"), "ㄅㄧㄝˊ") + XCTAssertEqual(c.cS2RC("biej"), "ㄅㄧㄝˇ") + XCTAssertEqual(c.cS2RC("biel"), "ㄅㄧㄝˋ") + XCTAssertEqual(c.cS2RC("biw"), "ㄅㄧㄠ") + XCTAssertEqual(c.cS2RC("biwj"), "ㄅㄧㄠˇ") + XCTAssertEqual(c.cS2RC("biwl"), "ㄅㄧㄠˋ") + XCTAssertEqual(c.cS2RC("bib"), "ㄅㄧㄢ") + XCTAssertEqual(c.cS2RC("bibf"), "ㄅㄧㄢˊ") + XCTAssertEqual(c.cS2RC("bibj"), "ㄅㄧㄢˇ") + XCTAssertEqual(c.cS2RC("bibl"), "ㄅㄧㄢˋ") + XCTAssertEqual(c.cS2RC("bin"), "ㄅㄧㄣ") + XCTAssertEqual(c.cS2RC("binj"), "ㄅㄧㄣˇ") + XCTAssertEqual(c.cS2RC("binl"), "ㄅㄧㄣˋ") + XCTAssertEqual(c.cS2RC("bim"), "ㄅㄧㄥ") + XCTAssertEqual(c.cS2RC("bimj"), "ㄅㄧㄥˇ") + XCTAssertEqual(c.cS2RC("biml"), "ㄅㄧㄥˋ") + XCTAssertEqual(c.cS2RC("bu"), "ㄅㄨ") + XCTAssertEqual(c.cS2RC("buf"), "ㄅㄨˊ") + XCTAssertEqual(c.cS2RC("buj"), "ㄅㄨˇ") + XCTAssertEqual(c.cS2RC("bul"), "ㄅㄨˋ") + XCTAssertEqual(c.cS2RC("pa"), "ㄆㄚ") + XCTAssertEqual(c.cS2RC("paf"), "ㄆㄚˊ") + XCTAssertEqual(c.cS2RC("paj"), "ㄆㄚˇ") + XCTAssertEqual(c.cS2RC("pal"), "ㄆㄚˋ") + XCTAssertEqual(c.cS2RC("pad"), "ㄆㄚ˙") + XCTAssertEqual(c.cS2RC("po"), "ㄆㄛ") + XCTAssertEqual(c.cS2RC("pof"), "ㄆㄛˊ") + XCTAssertEqual(c.cS2RC("poj"), "ㄆㄛˇ") + XCTAssertEqual(c.cS2RC("pol"), "ㄆㄛˋ") + XCTAssertEqual(c.cS2RC("ph"), "ㄆㄞ") + XCTAssertEqual(c.cS2RC("phf"), "ㄆㄞˊ") + XCTAssertEqual(c.cS2RC("phj"), "ㄆㄞˇ") + XCTAssertEqual(c.cS2RC("phl"), "ㄆㄞˋ") + XCTAssertEqual(c.cS2RC("pk"), "ㄆㄟ") + XCTAssertEqual(c.cS2RC("pkf"), "ㄆㄟˊ") + XCTAssertEqual(c.cS2RC("pkj"), "ㄆㄟˇ") + XCTAssertEqual(c.cS2RC("pkl"), "ㄆㄟˋ") + XCTAssertEqual(c.cS2RC("pw"), "ㄆㄠ") + XCTAssertEqual(c.cS2RC("pwf"), "ㄆㄠˊ") + XCTAssertEqual(c.cS2RC("pwj"), "ㄆㄠˇ") + XCTAssertEqual(c.cS2RC("pwl"), "ㄆㄠˋ") + XCTAssertEqual(c.cS2RC("pv"), "ㄆㄡ") + XCTAssertEqual(c.cS2RC("pvf"), "ㄆㄡˊ") + XCTAssertEqual(c.cS2RC("pvj"), "ㄆㄡˇ") + XCTAssertEqual(c.cS2RC("pvl"), "ㄆㄡˋ") + XCTAssertEqual(c.cS2RC("pb"), "ㄆㄢ") + XCTAssertEqual(c.cS2RC("pbf"), "ㄆㄢˊ") + XCTAssertEqual(c.cS2RC("pbj"), "ㄆㄢˇ") + XCTAssertEqual(c.cS2RC("pbl"), "ㄆㄢˋ") + XCTAssertEqual(c.cS2RC("pn"), "ㄆㄣ") + XCTAssertEqual(c.cS2RC("pnf"), "ㄆㄣˊ") + XCTAssertEqual(c.cS2RC("pnj"), "ㄆㄣˇ") + XCTAssertEqual(c.cS2RC("pnl"), "ㄆㄣˋ") + XCTAssertEqual(c.cS2RC("pg"), "ㄆㄤ") + XCTAssertEqual(c.cS2RC("pgf"), "ㄆㄤˊ") + XCTAssertEqual(c.cS2RC("pgj"), "ㄆㄤˇ") + XCTAssertEqual(c.cS2RC("pgl"), "ㄆㄤˋ") + XCTAssertEqual(c.cS2RC("pm"), "ㄆㄥ") + XCTAssertEqual(c.cS2RC("pmf"), "ㄆㄥˊ") + XCTAssertEqual(c.cS2RC("pmj"), "ㄆㄥˇ") + XCTAssertEqual(c.cS2RC("pml"), "ㄆㄥˋ") + XCTAssertEqual(c.cS2RC("pi"), "ㄆㄧ") + XCTAssertEqual(c.cS2RC("pif"), "ㄆㄧˊ") + XCTAssertEqual(c.cS2RC("pij"), "ㄆㄧˇ") + XCTAssertEqual(c.cS2RC("pil"), "ㄆㄧˋ") + XCTAssertEqual(c.cS2RC("pia"), "ㄆㄧㄚ") + XCTAssertEqual(c.cS2RC("pie"), "ㄆㄧㄝ") + XCTAssertEqual(c.cS2RC("piej"), "ㄆㄧㄝˇ") + XCTAssertEqual(c.cS2RC("piel"), "ㄆㄧㄝˋ") + XCTAssertEqual(c.cS2RC("piw"), "ㄆㄧㄠ") + XCTAssertEqual(c.cS2RC("piwf"), "ㄆㄧㄠˊ") + XCTAssertEqual(c.cS2RC("piwj"), "ㄆㄧㄠˇ") + XCTAssertEqual(c.cS2RC("piwl"), "ㄆㄧㄠˋ") + XCTAssertEqual(c.cS2RC("pib"), "ㄆㄧㄢ") + XCTAssertEqual(c.cS2RC("pibf"), "ㄆㄧㄢˊ") + XCTAssertEqual(c.cS2RC("pibj"), "ㄆㄧㄢˇ") + XCTAssertEqual(c.cS2RC("pibl"), "ㄆㄧㄢˋ") + XCTAssertEqual(c.cS2RC("pin"), "ㄆㄧㄣ") + XCTAssertEqual(c.cS2RC("pinf"), "ㄆㄧㄣˊ") + XCTAssertEqual(c.cS2RC("pinj"), "ㄆㄧㄣˇ") + XCTAssertEqual(c.cS2RC("pinl"), "ㄆㄧㄣˋ") + XCTAssertEqual(c.cS2RC("pim"), "ㄆㄧㄥ") + XCTAssertEqual(c.cS2RC("pimf"), "ㄆㄧㄥˊ") + XCTAssertEqual(c.cS2RC("pimj"), "ㄆㄧㄥˇ") + XCTAssertEqual(c.cS2RC("piml"), "ㄆㄧㄥˋ") + XCTAssertEqual(c.cS2RC("pu"), "ㄆㄨ") + XCTAssertEqual(c.cS2RC("puf"), "ㄆㄨˊ") + XCTAssertEqual(c.cS2RC("puj"), "ㄆㄨˇ") + XCTAssertEqual(c.cS2RC("pul"), "ㄆㄨˋ") + XCTAssertEqual(c.cS2RC("ma"), "ㄇㄚ") + XCTAssertEqual(c.cS2RC("maf"), "ㄇㄚˊ") + XCTAssertEqual(c.cS2RC("maj"), "ㄇㄚˇ") + XCTAssertEqual(c.cS2RC("mal"), "ㄇㄚˋ") + XCTAssertEqual(c.cS2RC("mad"), "ㄇㄚ˙") + XCTAssertEqual(c.cS2RC("mo"), "ㄇㄛ") + XCTAssertEqual(c.cS2RC("mof"), "ㄇㄛˊ") + XCTAssertEqual(c.cS2RC("moj"), "ㄇㄛˇ") + XCTAssertEqual(c.cS2RC("mol"), "ㄇㄛˋ") + XCTAssertEqual(c.cS2RC("mod"), "ㄇㄛ˙") + XCTAssertEqual(c.cS2RC("me"), "ㄇㄜ") + XCTAssertEqual(c.cS2RC("mel"), "ㄇㄜˋ") + XCTAssertEqual(c.cS2RC("med"), "ㄇㄜ˙") + XCTAssertEqual(c.cS2RC("mh"), "ㄇㄞ") + XCTAssertEqual(c.cS2RC("mhf"), "ㄇㄞˊ") + XCTAssertEqual(c.cS2RC("mhj"), "ㄇㄞˇ") + XCTAssertEqual(c.cS2RC("mhl"), "ㄇㄞˋ") + XCTAssertEqual(c.cS2RC("mkf"), "ㄇㄟˊ") + XCTAssertEqual(c.cS2RC("mkj"), "ㄇㄟˇ") + XCTAssertEqual(c.cS2RC("mkl"), "ㄇㄟˋ") + XCTAssertEqual(c.cS2RC("mw"), "ㄇㄠ") + XCTAssertEqual(c.cS2RC("mwf"), "ㄇㄠˊ") + XCTAssertEqual(c.cS2RC("mwj"), "ㄇㄠˇ") + XCTAssertEqual(c.cS2RC("mwl"), "ㄇㄠˋ") + XCTAssertEqual(c.cS2RC("mvf"), "ㄇㄡˊ") + XCTAssertEqual(c.cS2RC("mvj"), "ㄇㄡˇ") + XCTAssertEqual(c.cS2RC("mvl"), "ㄇㄡˋ") + XCTAssertEqual(c.cS2RC("mb"), "ㄇㄢ") + XCTAssertEqual(c.cS2RC("mbf"), "ㄇㄢˊ") + XCTAssertEqual(c.cS2RC("mbj"), "ㄇㄢˇ") + XCTAssertEqual(c.cS2RC("mbl"), "ㄇㄢˋ") + XCTAssertEqual(c.cS2RC("mn"), "ㄇㄣ") + XCTAssertEqual(c.cS2RC("mnf"), "ㄇㄣˊ") + XCTAssertEqual(c.cS2RC("mnj"), "ㄇㄣˇ") + XCTAssertEqual(c.cS2RC("mnl"), "ㄇㄣˋ") + XCTAssertEqual(c.cS2RC("mnd"), "ㄇㄣ˙") + XCTAssertEqual(c.cS2RC("mg"), "ㄇㄤ") + XCTAssertEqual(c.cS2RC("mgf"), "ㄇㄤˊ") + XCTAssertEqual(c.cS2RC("mgj"), "ㄇㄤˇ") + XCTAssertEqual(c.cS2RC("mgl"), "ㄇㄤˋ") + XCTAssertEqual(c.cS2RC("mm"), "ㄇㄥ") + XCTAssertEqual(c.cS2RC("mmf"), "ㄇㄥˊ") + XCTAssertEqual(c.cS2RC("mmj"), "ㄇㄥˇ") + XCTAssertEqual(c.cS2RC("mml"), "ㄇㄥˋ") + XCTAssertEqual(c.cS2RC("mi"), "ㄇㄧ") + XCTAssertEqual(c.cS2RC("mif"), "ㄇㄧˊ") + XCTAssertEqual(c.cS2RC("mij"), "ㄇㄧˇ") + XCTAssertEqual(c.cS2RC("mil"), "ㄇㄧˋ") + XCTAssertEqual(c.cS2RC("mie"), "ㄇㄧㄝ") + XCTAssertEqual(c.cS2RC("mief"), "ㄇㄧㄝˊ") + XCTAssertEqual(c.cS2RC("miel"), "ㄇㄧㄝˋ") + XCTAssertEqual(c.cS2RC("miw"), "ㄇㄧㄠ") + XCTAssertEqual(c.cS2RC("miwf"), "ㄇㄧㄠˊ") + XCTAssertEqual(c.cS2RC("miwj"), "ㄇㄧㄠˇ") + XCTAssertEqual(c.cS2RC("miwl"), "ㄇㄧㄠˋ") + XCTAssertEqual(c.cS2RC("mivf"), "ㄇㄧㄡˊ") + XCTAssertEqual(c.cS2RC("mivj"), "ㄇㄧㄡˇ") + XCTAssertEqual(c.cS2RC("mivl"), "ㄇㄧㄡˋ") + XCTAssertEqual(c.cS2RC("mib"), "ㄇㄧㄢ") + XCTAssertEqual(c.cS2RC("mibf"), "ㄇㄧㄢˊ") + XCTAssertEqual(c.cS2RC("mibj"), "ㄇㄧㄢˇ") + XCTAssertEqual(c.cS2RC("mibl"), "ㄇㄧㄢˋ") + XCTAssertEqual(c.cS2RC("min"), "ㄇㄧㄣ") + XCTAssertEqual(c.cS2RC("minf"), "ㄇㄧㄣˊ") + XCTAssertEqual(c.cS2RC("minj"), "ㄇㄧㄣˇ") + XCTAssertEqual(c.cS2RC("mimf"), "ㄇㄧㄥˊ") + XCTAssertEqual(c.cS2RC("mimj"), "ㄇㄧㄥˇ") + XCTAssertEqual(c.cS2RC("miml"), "ㄇㄧㄥˋ") + XCTAssertEqual(c.cS2RC("muf"), "ㄇㄨˊ") + XCTAssertEqual(c.cS2RC("muj"), "ㄇㄨˇ") + XCTAssertEqual(c.cS2RC("mul"), "ㄇㄨˋ") + XCTAssertEqual(c.cS2RC("fa"), "ㄈㄚ") + XCTAssertEqual(c.cS2RC("faf"), "ㄈㄚˊ") + XCTAssertEqual(c.cS2RC("faj"), "ㄈㄚˇ") + XCTAssertEqual(c.cS2RC("fal"), "ㄈㄚˋ") + XCTAssertEqual(c.cS2RC("fof"), "ㄈㄛˊ") + XCTAssertEqual(c.cS2RC("fk"), "ㄈㄟ") + XCTAssertEqual(c.cS2RC("fkf"), "ㄈㄟˊ") + XCTAssertEqual(c.cS2RC("fkj"), "ㄈㄟˇ") + XCTAssertEqual(c.cS2RC("fkl"), "ㄈㄟˋ") + XCTAssertEqual(c.cS2RC("fv"), "ㄈㄡ") + XCTAssertEqual(c.cS2RC("fvf"), "ㄈㄡˊ") + XCTAssertEqual(c.cS2RC("fvj"), "ㄈㄡˇ") + XCTAssertEqual(c.cS2RC("fvl"), "ㄈㄡˋ") + XCTAssertEqual(c.cS2RC("fb"), "ㄈㄢ") + XCTAssertEqual(c.cS2RC("fbf"), "ㄈㄢˊ") + XCTAssertEqual(c.cS2RC("fbj"), "ㄈㄢˇ") + XCTAssertEqual(c.cS2RC("fbl"), "ㄈㄢˋ") + XCTAssertEqual(c.cS2RC("fn"), "ㄈㄣ") + XCTAssertEqual(c.cS2RC("fnf"), "ㄈㄣˊ") + XCTAssertEqual(c.cS2RC("fnj"), "ㄈㄣˇ") + XCTAssertEqual(c.cS2RC("fnl"), "ㄈㄣˋ") + XCTAssertEqual(c.cS2RC("fnd"), "ㄈㄣ˙") + XCTAssertEqual(c.cS2RC("fg"), "ㄈㄤ") + XCTAssertEqual(c.cS2RC("fgf"), "ㄈㄤˊ") + XCTAssertEqual(c.cS2RC("fgj"), "ㄈㄤˇ") + XCTAssertEqual(c.cS2RC("fgl"), "ㄈㄤˋ") + XCTAssertEqual(c.cS2RC("fm"), "ㄈㄥ") + XCTAssertEqual(c.cS2RC("fmf"), "ㄈㄥˊ") + XCTAssertEqual(c.cS2RC("fmj"), "ㄈㄥˇ") + XCTAssertEqual(c.cS2RC("fml"), "ㄈㄥˋ") + XCTAssertEqual(c.cS2RC("fiwl"), "ㄈㄧㄠˋ") + XCTAssertEqual(c.cS2RC("fu"), "ㄈㄨ") + XCTAssertEqual(c.cS2RC("fuf"), "ㄈㄨˊ") + XCTAssertEqual(c.cS2RC("fuj"), "ㄈㄨˇ") + XCTAssertEqual(c.cS2RC("ful"), "ㄈㄨˋ") + XCTAssertEqual(c.cS2RC("da"), "ㄉㄚ") + XCTAssertEqual(c.cS2RC("daf"), "ㄉㄚˊ") + XCTAssertEqual(c.cS2RC("daj"), "ㄉㄚˇ") + XCTAssertEqual(c.cS2RC("dal"), "ㄉㄚˋ") + XCTAssertEqual(c.cS2RC("dad"), "ㄉㄚ˙") + XCTAssertEqual(c.cS2RC("de"), "ㄉㄜ") + XCTAssertEqual(c.cS2RC("def"), "ㄉㄜˊ") + XCTAssertEqual(c.cS2RC("ded"), "ㄉㄜ˙") + XCTAssertEqual(c.cS2RC("dh"), "ㄉㄞ") + XCTAssertEqual(c.cS2RC("dhj"), "ㄉㄞˇ") + XCTAssertEqual(c.cS2RC("dhl"), "ㄉㄞˋ") + XCTAssertEqual(c.cS2RC("dkj"), "ㄉㄟˇ") + XCTAssertEqual(c.cS2RC("dw"), "ㄉㄠ") + XCTAssertEqual(c.cS2RC("dwf"), "ㄉㄠˊ") + XCTAssertEqual(c.cS2RC("dwj"), "ㄉㄠˇ") + XCTAssertEqual(c.cS2RC("dwl"), "ㄉㄠˋ") + XCTAssertEqual(c.cS2RC("dv"), "ㄉㄡ") + XCTAssertEqual(c.cS2RC("dvf"), "ㄉㄡˊ") + XCTAssertEqual(c.cS2RC("dvj"), "ㄉㄡˇ") + XCTAssertEqual(c.cS2RC("dvl"), "ㄉㄡˋ") + XCTAssertEqual(c.cS2RC("db"), "ㄉㄢ") + XCTAssertEqual(c.cS2RC("dbj"), "ㄉㄢˇ") + XCTAssertEqual(c.cS2RC("dbl"), "ㄉㄢˋ") + XCTAssertEqual(c.cS2RC("dnl"), "ㄉㄣˋ") + XCTAssertEqual(c.cS2RC("dg"), "ㄉㄤ") + XCTAssertEqual(c.cS2RC("dgj"), "ㄉㄤˇ") + XCTAssertEqual(c.cS2RC("dgl"), "ㄉㄤˋ") + XCTAssertEqual(c.cS2RC("dm"), "ㄉㄥ") + XCTAssertEqual(c.cS2RC("dmj"), "ㄉㄥˇ") + XCTAssertEqual(c.cS2RC("dml"), "ㄉㄥˋ") + XCTAssertEqual(c.cS2RC("di"), "ㄉㄧ") + XCTAssertEqual(c.cS2RC("dif"), "ㄉㄧˊ") + XCTAssertEqual(c.cS2RC("dij"), "ㄉㄧˇ") + XCTAssertEqual(c.cS2RC("dil"), "ㄉㄧˋ") + XCTAssertEqual(c.cS2RC("diaj"), "ㄉㄧㄚˇ") + XCTAssertEqual(c.cS2RC("die"), "ㄉㄧㄝ") + XCTAssertEqual(c.cS2RC("dief"), "ㄉㄧㄝˊ") + XCTAssertEqual(c.cS2RC("diej"), "ㄉㄧㄝˇ") + XCTAssertEqual(c.cS2RC("diel"), "ㄉㄧㄝˋ") + XCTAssertEqual(c.cS2RC("diw"), "ㄉㄧㄠ") + XCTAssertEqual(c.cS2RC("diwj"), "ㄉㄧㄠˇ") + XCTAssertEqual(c.cS2RC("diwl"), "ㄉㄧㄠˋ") + XCTAssertEqual(c.cS2RC("div"), "ㄉㄧㄡ") + XCTAssertEqual(c.cS2RC("dib"), "ㄉㄧㄢ") + XCTAssertEqual(c.cS2RC("dibf"), "ㄉㄧㄢˊ") + XCTAssertEqual(c.cS2RC("dibj"), "ㄉㄧㄢˇ") + XCTAssertEqual(c.cS2RC("dibl"), "ㄉㄧㄢˋ") + XCTAssertEqual(c.cS2RC("dim"), "ㄉㄧㄥ") + XCTAssertEqual(c.cS2RC("dimf"), "ㄉㄧㄥˊ") + XCTAssertEqual(c.cS2RC("dimj"), "ㄉㄧㄥˇ") + XCTAssertEqual(c.cS2RC("diml"), "ㄉㄧㄥˋ") + XCTAssertEqual(c.cS2RC("du"), "ㄉㄨ") + XCTAssertEqual(c.cS2RC("duf"), "ㄉㄨˊ") + XCTAssertEqual(c.cS2RC("duj"), "ㄉㄨˇ") + XCTAssertEqual(c.cS2RC("dul"), "ㄉㄨˋ") + XCTAssertEqual(c.cS2RC("duo"), "ㄉㄨㄛ") + XCTAssertEqual(c.cS2RC("duof"), "ㄉㄨㄛˊ") + XCTAssertEqual(c.cS2RC("duoj"), "ㄉㄨㄛˇ") + XCTAssertEqual(c.cS2RC("duol"), "ㄉㄨㄛˋ") + XCTAssertEqual(c.cS2RC("duod"), "ㄉㄨㄛ˙") + XCTAssertEqual(c.cS2RC("duk"), "ㄉㄨㄟ") + XCTAssertEqual(c.cS2RC("dukj"), "ㄉㄨㄟˇ") + XCTAssertEqual(c.cS2RC("dukl"), "ㄉㄨㄟˋ") + XCTAssertEqual(c.cS2RC("dub"), "ㄉㄨㄢ") + XCTAssertEqual(c.cS2RC("dubj"), "ㄉㄨㄢˇ") + XCTAssertEqual(c.cS2RC("dubl"), "ㄉㄨㄢˋ") + XCTAssertEqual(c.cS2RC("dun"), "ㄉㄨㄣ") + XCTAssertEqual(c.cS2RC("dunj"), "ㄉㄨㄣˇ") + XCTAssertEqual(c.cS2RC("dunl"), "ㄉㄨㄣˋ") + XCTAssertEqual(c.cS2RC("dum"), "ㄉㄨㄥ") + XCTAssertEqual(c.cS2RC("dumj"), "ㄉㄨㄥˇ") + XCTAssertEqual(c.cS2RC("duml"), "ㄉㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ta"), "ㄊㄚ") + XCTAssertEqual(c.cS2RC("taj"), "ㄊㄚˇ") + XCTAssertEqual(c.cS2RC("tal"), "ㄊㄚˋ") + XCTAssertEqual(c.cS2RC("tel"), "ㄊㄜˋ") + XCTAssertEqual(c.cS2RC("th"), "ㄊㄞ") + XCTAssertEqual(c.cS2RC("thf"), "ㄊㄞˊ") + XCTAssertEqual(c.cS2RC("thj"), "ㄊㄞˇ") + XCTAssertEqual(c.cS2RC("thl"), "ㄊㄞˋ") + XCTAssertEqual(c.cS2RC("thd"), "ㄊㄞ˙") + XCTAssertEqual(c.cS2RC("tw"), "ㄊㄠ") + XCTAssertEqual(c.cS2RC("twf"), "ㄊㄠˊ") + XCTAssertEqual(c.cS2RC("twj"), "ㄊㄠˇ") + XCTAssertEqual(c.cS2RC("twl"), "ㄊㄠˋ") + XCTAssertEqual(c.cS2RC("twd"), "ㄊㄠ˙") + XCTAssertEqual(c.cS2RC("tv"), "ㄊㄡ") + XCTAssertEqual(c.cS2RC("tvf"), "ㄊㄡˊ") + XCTAssertEqual(c.cS2RC("tvj"), "ㄊㄡˇ") + XCTAssertEqual(c.cS2RC("tvl"), "ㄊㄡˋ") + XCTAssertEqual(c.cS2RC("tvd"), "ㄊㄡ˙") + XCTAssertEqual(c.cS2RC("tb"), "ㄊㄢ") + XCTAssertEqual(c.cS2RC("tbf"), "ㄊㄢˊ") + XCTAssertEqual(c.cS2RC("tbj"), "ㄊㄢˇ") + XCTAssertEqual(c.cS2RC("tbl"), "ㄊㄢˋ") + XCTAssertEqual(c.cS2RC("tg"), "ㄊㄤ") + XCTAssertEqual(c.cS2RC("tgf"), "ㄊㄤˊ") + XCTAssertEqual(c.cS2RC("tgj"), "ㄊㄤˇ") + XCTAssertEqual(c.cS2RC("tgl"), "ㄊㄤˋ") + XCTAssertEqual(c.cS2RC("tm"), "ㄊㄥ") + XCTAssertEqual(c.cS2RC("tmf"), "ㄊㄥˊ") + XCTAssertEqual(c.cS2RC("tml"), "ㄊㄥˋ") + XCTAssertEqual(c.cS2RC("ti"), "ㄊㄧ") + XCTAssertEqual(c.cS2RC("tif"), "ㄊㄧˊ") + XCTAssertEqual(c.cS2RC("tij"), "ㄊㄧˇ") + XCTAssertEqual(c.cS2RC("til"), "ㄊㄧˋ") + XCTAssertEqual(c.cS2RC("tie"), "ㄊㄧㄝ") + XCTAssertEqual(c.cS2RC("tief"), "ㄊㄧㄝˊ") + XCTAssertEqual(c.cS2RC("tiej"), "ㄊㄧㄝˇ") + XCTAssertEqual(c.cS2RC("tiel"), "ㄊㄧㄝˋ") + XCTAssertEqual(c.cS2RC("tiw"), "ㄊㄧㄠ") + XCTAssertEqual(c.cS2RC("tiwf"), "ㄊㄧㄠˊ") + XCTAssertEqual(c.cS2RC("tiwj"), "ㄊㄧㄠˇ") + XCTAssertEqual(c.cS2RC("tiwl"), "ㄊㄧㄠˋ") + XCTAssertEqual(c.cS2RC("tib"), "ㄊㄧㄢ") + XCTAssertEqual(c.cS2RC("tibf"), "ㄊㄧㄢˊ") + XCTAssertEqual(c.cS2RC("tibj"), "ㄊㄧㄢˇ") + XCTAssertEqual(c.cS2RC("tibl"), "ㄊㄧㄢˋ") + XCTAssertEqual(c.cS2RC("tim"), "ㄊㄧㄥ") + XCTAssertEqual(c.cS2RC("timf"), "ㄊㄧㄥˊ") + XCTAssertEqual(c.cS2RC("timj"), "ㄊㄧㄥˇ") + XCTAssertEqual(c.cS2RC("timl"), "ㄊㄧㄥˋ") + XCTAssertEqual(c.cS2RC("tu"), "ㄊㄨ") + XCTAssertEqual(c.cS2RC("tuf"), "ㄊㄨˊ") + XCTAssertEqual(c.cS2RC("tuj"), "ㄊㄨˇ") + XCTAssertEqual(c.cS2RC("tul"), "ㄊㄨˋ") + XCTAssertEqual(c.cS2RC("tuo"), "ㄊㄨㄛ") + XCTAssertEqual(c.cS2RC("tuof"), "ㄊㄨㄛˊ") + XCTAssertEqual(c.cS2RC("tuoj"), "ㄊㄨㄛˇ") + XCTAssertEqual(c.cS2RC("tuol"), "ㄊㄨㄛˋ") + XCTAssertEqual(c.cS2RC("tuk"), "ㄊㄨㄟ") + XCTAssertEqual(c.cS2RC("tukf"), "ㄊㄨㄟˊ") + XCTAssertEqual(c.cS2RC("tukj"), "ㄊㄨㄟˇ") + XCTAssertEqual(c.cS2RC("tukl"), "ㄊㄨㄟˋ") + XCTAssertEqual(c.cS2RC("tub"), "ㄊㄨㄢ") + XCTAssertEqual(c.cS2RC("tubf"), "ㄊㄨㄢˊ") + XCTAssertEqual(c.cS2RC("tubj"), "ㄊㄨㄢˇ") + XCTAssertEqual(c.cS2RC("tubl"), "ㄊㄨㄢˋ") + XCTAssertEqual(c.cS2RC("tun"), "ㄊㄨㄣ") + XCTAssertEqual(c.cS2RC("tunf"), "ㄊㄨㄣˊ") + XCTAssertEqual(c.cS2RC("tunj"), "ㄊㄨㄣˇ") + XCTAssertEqual(c.cS2RC("tunl"), "ㄊㄨㄣˋ") + XCTAssertEqual(c.cS2RC("tum"), "ㄊㄨㄥ") + XCTAssertEqual(c.cS2RC("tumf"), "ㄊㄨㄥˊ") + XCTAssertEqual(c.cS2RC("tumj"), "ㄊㄨㄥˇ") + XCTAssertEqual(c.cS2RC("tuml"), "ㄊㄨㄥˋ") + XCTAssertEqual(c.cS2RC("na"), "ㄋㄚ") + XCTAssertEqual(c.cS2RC("naf"), "ㄋㄚˊ") + XCTAssertEqual(c.cS2RC("naj"), "ㄋㄚˇ") + XCTAssertEqual(c.cS2RC("nal"), "ㄋㄚˋ") + XCTAssertEqual(c.cS2RC("nad"), "ㄋㄚ˙") + XCTAssertEqual(c.cS2RC("nel"), "ㄋㄜˋ") + XCTAssertEqual(c.cS2RC("ned"), "ㄋㄜ˙") + XCTAssertEqual(c.cS2RC("nhf"), "ㄋㄞˊ") + XCTAssertEqual(c.cS2RC("nhj"), "ㄋㄞˇ") + XCTAssertEqual(c.cS2RC("nhl"), "ㄋㄞˋ") + XCTAssertEqual(c.cS2RC("nkf"), "ㄋㄟˊ") + XCTAssertEqual(c.cS2RC("nkj"), "ㄋㄟˇ") + XCTAssertEqual(c.cS2RC("nkl"), "ㄋㄟˋ") + XCTAssertEqual(c.cS2RC("nw"), "ㄋㄠ") + XCTAssertEqual(c.cS2RC("nwf"), "ㄋㄠˊ") + XCTAssertEqual(c.cS2RC("nwj"), "ㄋㄠˇ") + XCTAssertEqual(c.cS2RC("nwl"), "ㄋㄠˋ") + XCTAssertEqual(c.cS2RC("nvf"), "ㄋㄡˊ") + XCTAssertEqual(c.cS2RC("nvj"), "ㄋㄡˇ") + XCTAssertEqual(c.cS2RC("nvl"), "ㄋㄡˋ") + XCTAssertEqual(c.cS2RC("nb"), "ㄋㄢ") + XCTAssertEqual(c.cS2RC("nbf"), "ㄋㄢˊ") + XCTAssertEqual(c.cS2RC("nbj"), "ㄋㄢˇ") + XCTAssertEqual(c.cS2RC("nbl"), "ㄋㄢˋ") + XCTAssertEqual(c.cS2RC("nnj"), "ㄋㄣˇ") + XCTAssertEqual(c.cS2RC("nnl"), "ㄋㄣˋ") + XCTAssertEqual(c.cS2RC("ng"), "ㄋㄤ") + XCTAssertEqual(c.cS2RC("ngf"), "ㄋㄤˊ") + XCTAssertEqual(c.cS2RC("ngj"), "ㄋㄤˇ") + XCTAssertEqual(c.cS2RC("ngl"), "ㄋㄤˋ") + XCTAssertEqual(c.cS2RC("ngd"), "ㄋㄤ˙") + XCTAssertEqual(c.cS2RC("nmf"), "ㄋㄥˊ") + XCTAssertEqual(c.cS2RC("nmj"), "ㄋㄥˇ") + XCTAssertEqual(c.cS2RC("ni"), "ㄋㄧ") + XCTAssertEqual(c.cS2RC("nif"), "ㄋㄧˊ") + XCTAssertEqual(c.cS2RC("nij"), "ㄋㄧˇ") + XCTAssertEqual(c.cS2RC("nil"), "ㄋㄧˋ") + XCTAssertEqual(c.cS2RC("nie"), "ㄋㄧㄝ") + XCTAssertEqual(c.cS2RC("nief"), "ㄋㄧㄝˊ") + XCTAssertEqual(c.cS2RC("niel"), "ㄋㄧㄝˋ") + XCTAssertEqual(c.cS2RC("niwj"), "ㄋㄧㄠˇ") + XCTAssertEqual(c.cS2RC("niwl"), "ㄋㄧㄠˋ") + XCTAssertEqual(c.cS2RC("niv"), "ㄋㄧㄡ") + XCTAssertEqual(c.cS2RC("nivf"), "ㄋㄧㄡˊ") + XCTAssertEqual(c.cS2RC("nivj"), "ㄋㄧㄡˇ") + XCTAssertEqual(c.cS2RC("nivl"), "ㄋㄧㄡˋ") + XCTAssertEqual(c.cS2RC("nib"), "ㄋㄧㄢ") + XCTAssertEqual(c.cS2RC("nibf"), "ㄋㄧㄢˊ") + XCTAssertEqual(c.cS2RC("nibj"), "ㄋㄧㄢˇ") + XCTAssertEqual(c.cS2RC("nibl"), "ㄋㄧㄢˋ") + XCTAssertEqual(c.cS2RC("nin"), "ㄋㄧㄣ") + XCTAssertEqual(c.cS2RC("ninf"), "ㄋㄧㄣˊ") + XCTAssertEqual(c.cS2RC("ninj"), "ㄋㄧㄣˇ") + XCTAssertEqual(c.cS2RC("ninl"), "ㄋㄧㄣˋ") + XCTAssertEqual(c.cS2RC("nigf"), "ㄋㄧㄤˊ") + XCTAssertEqual(c.cS2RC("nigj"), "ㄋㄧㄤˇ") + XCTAssertEqual(c.cS2RC("nigl"), "ㄋㄧㄤˋ") + XCTAssertEqual(c.cS2RC("nimf"), "ㄋㄧㄥˊ") + XCTAssertEqual(c.cS2RC("nimj"), "ㄋㄧㄥˇ") + XCTAssertEqual(c.cS2RC("niml"), "ㄋㄧㄥˋ") + XCTAssertEqual(c.cS2RC("nuf"), "ㄋㄨˊ") + XCTAssertEqual(c.cS2RC("nuj"), "ㄋㄨˇ") + XCTAssertEqual(c.cS2RC("nul"), "ㄋㄨˋ") + XCTAssertEqual(c.cS2RC("nuof"), "ㄋㄨㄛˊ") + XCTAssertEqual(c.cS2RC("nuoj"), "ㄋㄨㄛˇ") + XCTAssertEqual(c.cS2RC("nuol"), "ㄋㄨㄛˋ") + XCTAssertEqual(c.cS2RC("nukf"), "ㄋㄨㄟˊ") + XCTAssertEqual(c.cS2RC("nubf"), "ㄋㄨㄢˊ") + XCTAssertEqual(c.cS2RC("nubj"), "ㄋㄨㄢˇ") + XCTAssertEqual(c.cS2RC("nubl"), "ㄋㄨㄢˋ") + XCTAssertEqual(c.cS2RC("nunf"), "ㄋㄨㄣˊ") + XCTAssertEqual(c.cS2RC("numf"), "ㄋㄨㄥˊ") + XCTAssertEqual(c.cS2RC("numj"), "ㄋㄨㄥˇ") + XCTAssertEqual(c.cS2RC("numl"), "ㄋㄨㄥˋ") + XCTAssertEqual(c.cS2RC("nyf"), "ㄋㄩˊ") + XCTAssertEqual(c.cS2RC("nyj"), "ㄋㄩˇ") + XCTAssertEqual(c.cS2RC("nyl"), "ㄋㄩˋ") + XCTAssertEqual(c.cS2RC("nyel"), "ㄋㄩㄝˋ") + XCTAssertEqual(c.cS2RC("la"), "ㄌㄚ") + XCTAssertEqual(c.cS2RC("laf"), "ㄌㄚˊ") + XCTAssertEqual(c.cS2RC("laj"), "ㄌㄚˇ") + XCTAssertEqual(c.cS2RC("lal"), "ㄌㄚˋ") + XCTAssertEqual(c.cS2RC("lad"), "ㄌㄚ˙") + XCTAssertEqual(c.cS2RC("lo"), "ㄌㄛ") + XCTAssertEqual(c.cS2RC("lod"), "ㄌㄛ˙") + XCTAssertEqual(c.cS2RC("le"), "ㄌㄜ") + XCTAssertEqual(c.cS2RC("lef"), "ㄌㄜˊ") + XCTAssertEqual(c.cS2RC("lel"), "ㄌㄜˋ") + XCTAssertEqual(c.cS2RC("led"), "ㄌㄜ˙") + XCTAssertEqual(c.cS2RC("lhf"), "ㄌㄞˊ") + XCTAssertEqual(c.cS2RC("lhj"), "ㄌㄞˇ") + XCTAssertEqual(c.cS2RC("lhl"), "ㄌㄞˋ") + XCTAssertEqual(c.cS2RC("lk"), "ㄌㄟ") + XCTAssertEqual(c.cS2RC("lkf"), "ㄌㄟˊ") + XCTAssertEqual(c.cS2RC("lkj"), "ㄌㄟˇ") + XCTAssertEqual(c.cS2RC("lkl"), "ㄌㄟˋ") + XCTAssertEqual(c.cS2RC("lkd"), "ㄌㄟ˙") + } +} diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_B.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_B.swift new file mode 100644 index 00000000..d9cef545 --- /dev/null +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_B.swift @@ -0,0 +1,501 @@ +// (c) 2022 and onwards The vChewing Project (MIT-NTL License). +// ==================== +// This code is released under the MIT license (SPDX-License-Identifier: MIT) +// ... with NTL restriction stating that: +// No trademark license is granted to use the trade names, trademarks, service +// marks, or product names of Contributor, except as required to fulfill notice +// requirements defined in MIT License. + +import XCTest + +@testable import Tekkon + +extension TekkonTestsKeyboardArrangments { + func testAlvinLiuKeysB() throws { + var c = Tekkon.Composer(arrange: .ofAlvinLiu) + XCTAssertEqual(c.cS2RC("lw"), "ㄌㄠ") + XCTAssertEqual(c.cS2RC("lwf"), "ㄌㄠˊ") + XCTAssertEqual(c.cS2RC("lwj"), "ㄌㄠˇ") + XCTAssertEqual(c.cS2RC("lwl"), "ㄌㄠˋ") + XCTAssertEqual(c.cS2RC("lv"), "ㄌㄡ") + XCTAssertEqual(c.cS2RC("lvf"), "ㄌㄡˊ") + XCTAssertEqual(c.cS2RC("lvj"), "ㄌㄡˇ") + XCTAssertEqual(c.cS2RC("lvl"), "ㄌㄡˋ") + XCTAssertEqual(c.cS2RC("lvd"), "ㄌㄡ˙") + XCTAssertEqual(c.cS2RC("lbf"), "ㄌㄢˊ") + XCTAssertEqual(c.cS2RC("lbj"), "ㄌㄢˇ") + XCTAssertEqual(c.cS2RC("lbl"), "ㄌㄢˋ") + XCTAssertEqual(c.cS2RC("lg"), "ㄌㄤ") + XCTAssertEqual(c.cS2RC("lgf"), "ㄌㄤˊ") + XCTAssertEqual(c.cS2RC("lgj"), "ㄌㄤˇ") + XCTAssertEqual(c.cS2RC("lgl"), "ㄌㄤˋ") + XCTAssertEqual(c.cS2RC("lm"), "ㄌㄥ") + XCTAssertEqual(c.cS2RC("lmf"), "ㄌㄥˊ") + XCTAssertEqual(c.cS2RC("lmj"), "ㄌㄥˇ") + XCTAssertEqual(c.cS2RC("lml"), "ㄌㄥˋ") + XCTAssertEqual(c.cS2RC("li"), "ㄌㄧ") + XCTAssertEqual(c.cS2RC("lif"), "ㄌㄧˊ") + XCTAssertEqual(c.cS2RC("lij"), "ㄌㄧˇ") + XCTAssertEqual(c.cS2RC("lil"), "ㄌㄧˋ") + XCTAssertEqual(c.cS2RC("lid"), "ㄌㄧ˙") + XCTAssertEqual(c.cS2RC("liaj"), "ㄌㄧㄚˇ") + XCTAssertEqual(c.cS2RC("lie"), "ㄌㄧㄝ") + XCTAssertEqual(c.cS2RC("lief"), "ㄌㄧㄝˊ") + XCTAssertEqual(c.cS2RC("liej"), "ㄌㄧㄝˇ") + XCTAssertEqual(c.cS2RC("liel"), "ㄌㄧㄝˋ") + XCTAssertEqual(c.cS2RC("liw"), "ㄌㄧㄠ") + XCTAssertEqual(c.cS2RC("liwf"), "ㄌㄧㄠˊ") + XCTAssertEqual(c.cS2RC("liwj"), "ㄌㄧㄠˇ") + XCTAssertEqual(c.cS2RC("liwl"), "ㄌㄧㄠˋ") + XCTAssertEqual(c.cS2RC("liv"), "ㄌㄧㄡ") + XCTAssertEqual(c.cS2RC("livf"), "ㄌㄧㄡˊ") + XCTAssertEqual(c.cS2RC("livj"), "ㄌㄧㄡˇ") + XCTAssertEqual(c.cS2RC("livl"), "ㄌㄧㄡˋ") + XCTAssertEqual(c.cS2RC("lib"), "ㄌㄧㄢ") + XCTAssertEqual(c.cS2RC("libf"), "ㄌㄧㄢˊ") + XCTAssertEqual(c.cS2RC("libj"), "ㄌㄧㄢˇ") + XCTAssertEqual(c.cS2RC("libl"), "ㄌㄧㄢˋ") + XCTAssertEqual(c.cS2RC("linf"), "ㄌㄧㄣˊ") + XCTAssertEqual(c.cS2RC("linj"), "ㄌㄧㄣˇ") + XCTAssertEqual(c.cS2RC("linl"), "ㄌㄧㄣˋ") + XCTAssertEqual(c.cS2RC("ligf"), "ㄌㄧㄤˊ") + XCTAssertEqual(c.cS2RC("ligj"), "ㄌㄧㄤˇ") + XCTAssertEqual(c.cS2RC("ligl"), "ㄌㄧㄤˋ") + XCTAssertEqual(c.cS2RC("lim"), "ㄌㄧㄥ") + XCTAssertEqual(c.cS2RC("limf"), "ㄌㄧㄥˊ") + XCTAssertEqual(c.cS2RC("limj"), "ㄌㄧㄥˇ") + XCTAssertEqual(c.cS2RC("liml"), "ㄌㄧㄥˋ") + XCTAssertEqual(c.cS2RC("lu"), "ㄌㄨ") + XCTAssertEqual(c.cS2RC("luf"), "ㄌㄨˊ") + XCTAssertEqual(c.cS2RC("luj"), "ㄌㄨˇ") + XCTAssertEqual(c.cS2RC("lul"), "ㄌㄨˋ") + XCTAssertEqual(c.cS2RC("luo"), "ㄌㄨㄛ") + XCTAssertEqual(c.cS2RC("luof"), "ㄌㄨㄛˊ") + XCTAssertEqual(c.cS2RC("luoj"), "ㄌㄨㄛˇ") + XCTAssertEqual(c.cS2RC("luol"), "ㄌㄨㄛˋ") + XCTAssertEqual(c.cS2RC("luod"), "ㄌㄨㄛ˙") + XCTAssertEqual(c.cS2RC("lubf"), "ㄌㄨㄢˊ") + XCTAssertEqual(c.cS2RC("lubj"), "ㄌㄨㄢˇ") + XCTAssertEqual(c.cS2RC("lubl"), "ㄌㄨㄢˋ") + XCTAssertEqual(c.cS2RC("lun"), "ㄌㄨㄣ") + XCTAssertEqual(c.cS2RC("lunf"), "ㄌㄨㄣˊ") + XCTAssertEqual(c.cS2RC("lunj"), "ㄌㄨㄣˇ") + XCTAssertEqual(c.cS2RC("lunl"), "ㄌㄨㄣˋ") + XCTAssertEqual(c.cS2RC("lum"), "ㄌㄨㄥ") + XCTAssertEqual(c.cS2RC("lumf"), "ㄌㄨㄥˊ") + XCTAssertEqual(c.cS2RC("lumj"), "ㄌㄨㄥˇ") + XCTAssertEqual(c.cS2RC("luml"), "ㄌㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ly"), "ㄌㄩ") + XCTAssertEqual(c.cS2RC("lyf"), "ㄌㄩˊ") + XCTAssertEqual(c.cS2RC("lyj"), "ㄌㄩˇ") + XCTAssertEqual(c.cS2RC("lyl"), "ㄌㄩˋ") + XCTAssertEqual(c.cS2RC("lye"), "ㄌㄩㄝ") + XCTAssertEqual(c.cS2RC("lyej"), "ㄌㄩㄝˇ") + XCTAssertEqual(c.cS2RC("lyel"), "ㄌㄩㄝˋ") + XCTAssertEqual(c.cS2RC("lybf"), "ㄌㄩㄢˊ") + XCTAssertEqual(c.cS2RC("lybj"), "ㄌㄩㄢˇ") + XCTAssertEqual(c.cS2RC("ga"), "ㄍㄚ") + XCTAssertEqual(c.cS2RC("gaf"), "ㄍㄚˊ") + XCTAssertEqual(c.cS2RC("gaj"), "ㄍㄚˇ") + XCTAssertEqual(c.cS2RC("gal"), "ㄍㄚˋ") + XCTAssertEqual(c.cS2RC("gad"), "ㄍㄚ˙") + XCTAssertEqual(c.cS2RC("ge"), "ㄍㄜ") + XCTAssertEqual(c.cS2RC("gef"), "ㄍㄜˊ") + XCTAssertEqual(c.cS2RC("gej"), "ㄍㄜˇ") + XCTAssertEqual(c.cS2RC("gel"), "ㄍㄜˋ") + XCTAssertEqual(c.cS2RC("ged"), "ㄍㄜ˙") + XCTAssertEqual(c.cS2RC("gh"), "ㄍㄞ") + XCTAssertEqual(c.cS2RC("ghj"), "ㄍㄞˇ") + XCTAssertEqual(c.cS2RC("ghl"), "ㄍㄞˋ") + XCTAssertEqual(c.cS2RC("gkj"), "ㄍㄟˇ") + XCTAssertEqual(c.cS2RC("gw"), "ㄍㄠ") + XCTAssertEqual(c.cS2RC("gwj"), "ㄍㄠˇ") + XCTAssertEqual(c.cS2RC("gwl"), "ㄍㄠˋ") + XCTAssertEqual(c.cS2RC("gv"), "ㄍㄡ") + XCTAssertEqual(c.cS2RC("gvj"), "ㄍㄡˇ") + XCTAssertEqual(c.cS2RC("gvl"), "ㄍㄡˋ") + XCTAssertEqual(c.cS2RC("gb"), "ㄍㄢ") + XCTAssertEqual(c.cS2RC("gbj"), "ㄍㄢˇ") + XCTAssertEqual(c.cS2RC("gbl"), "ㄍㄢˋ") + XCTAssertEqual(c.cS2RC("gn"), "ㄍㄣ") + XCTAssertEqual(c.cS2RC("gnf"), "ㄍㄣˊ") + XCTAssertEqual(c.cS2RC("gnj"), "ㄍㄣˇ") + XCTAssertEqual(c.cS2RC("gnl"), "ㄍㄣˋ") + XCTAssertEqual(c.cS2RC("gg"), "ㄍㄤ") + XCTAssertEqual(c.cS2RC("ggj"), "ㄍㄤˇ") + XCTAssertEqual(c.cS2RC("ggl"), "ㄍㄤˋ") + XCTAssertEqual(c.cS2RC("gm"), "ㄍㄥ") + XCTAssertEqual(c.cS2RC("gmj"), "ㄍㄥˇ") + XCTAssertEqual(c.cS2RC("gml"), "ㄍㄥˋ") + XCTAssertEqual(c.cS2RC("gu"), "ㄍㄨ") + XCTAssertEqual(c.cS2RC("guf"), "ㄍㄨˊ") + XCTAssertEqual(c.cS2RC("guj"), "ㄍㄨˇ") + XCTAssertEqual(c.cS2RC("gul"), "ㄍㄨˋ") + XCTAssertEqual(c.cS2RC("gua"), "ㄍㄨㄚ") + XCTAssertEqual(c.cS2RC("guaf"), "ㄍㄨㄚˊ") + XCTAssertEqual(c.cS2RC("guaj"), "ㄍㄨㄚˇ") + XCTAssertEqual(c.cS2RC("gual"), "ㄍㄨㄚˋ") + XCTAssertEqual(c.cS2RC("guo"), "ㄍㄨㄛ") + XCTAssertEqual(c.cS2RC("guof"), "ㄍㄨㄛˊ") + XCTAssertEqual(c.cS2RC("guoj"), "ㄍㄨㄛˇ") + XCTAssertEqual(c.cS2RC("guol"), "ㄍㄨㄛˋ") + XCTAssertEqual(c.cS2RC("guh"), "ㄍㄨㄞ") + XCTAssertEqual(c.cS2RC("guhj"), "ㄍㄨㄞˇ") + XCTAssertEqual(c.cS2RC("guhl"), "ㄍㄨㄞˋ") + XCTAssertEqual(c.cS2RC("guk"), "ㄍㄨㄟ") + XCTAssertEqual(c.cS2RC("gukj"), "ㄍㄨㄟˇ") + XCTAssertEqual(c.cS2RC("gukl"), "ㄍㄨㄟˋ") + XCTAssertEqual(c.cS2RC("gub"), "ㄍㄨㄢ") + XCTAssertEqual(c.cS2RC("gubj"), "ㄍㄨㄢˇ") + XCTAssertEqual(c.cS2RC("gubl"), "ㄍㄨㄢˋ") + XCTAssertEqual(c.cS2RC("gun"), "ㄍㄨㄣ") + XCTAssertEqual(c.cS2RC("gunj"), "ㄍㄨㄣˇ") + XCTAssertEqual(c.cS2RC("gunl"), "ㄍㄨㄣˋ") + XCTAssertEqual(c.cS2RC("gug"), "ㄍㄨㄤ") + XCTAssertEqual(c.cS2RC("gugj"), "ㄍㄨㄤˇ") + XCTAssertEqual(c.cS2RC("gugl"), "ㄍㄨㄤˋ") + XCTAssertEqual(c.cS2RC("gum"), "ㄍㄨㄥ") + XCTAssertEqual(c.cS2RC("gumf"), "ㄍㄨㄥˊ") + XCTAssertEqual(c.cS2RC("gumj"), "ㄍㄨㄥˇ") + XCTAssertEqual(c.cS2RC("guml"), "ㄍㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ka"), "ㄎㄚ") + XCTAssertEqual(c.cS2RC("kaj"), "ㄎㄚˇ") + XCTAssertEqual(c.cS2RC("kal"), "ㄎㄚˋ") + XCTAssertEqual(c.cS2RC("ke"), "ㄎㄜ") + XCTAssertEqual(c.cS2RC("kef"), "ㄎㄜˊ") + XCTAssertEqual(c.cS2RC("kej"), "ㄎㄜˇ") + XCTAssertEqual(c.cS2RC("kel"), "ㄎㄜˋ") + XCTAssertEqual(c.cS2RC("kh"), "ㄎㄞ") + XCTAssertEqual(c.cS2RC("khj"), "ㄎㄞˇ") + XCTAssertEqual(c.cS2RC("khl"), "ㄎㄞˋ") + XCTAssertEqual(c.cS2RC("kw"), "ㄎㄠ") + XCTAssertEqual(c.cS2RC("kwj"), "ㄎㄠˇ") + XCTAssertEqual(c.cS2RC("kwl"), "ㄎㄠˋ") + XCTAssertEqual(c.cS2RC("kv"), "ㄎㄡ") + XCTAssertEqual(c.cS2RC("kvj"), "ㄎㄡˇ") + XCTAssertEqual(c.cS2RC("kvl"), "ㄎㄡˋ") + XCTAssertEqual(c.cS2RC("kb"), "ㄎㄢ") + XCTAssertEqual(c.cS2RC("kbj"), "ㄎㄢˇ") + XCTAssertEqual(c.cS2RC("kbl"), "ㄎㄢˋ") + XCTAssertEqual(c.cS2RC("kn"), "ㄎㄣ") + XCTAssertEqual(c.cS2RC("knj"), "ㄎㄣˇ") + XCTAssertEqual(c.cS2RC("knl"), "ㄎㄣˋ") + XCTAssertEqual(c.cS2RC("kg"), "ㄎㄤ") + XCTAssertEqual(c.cS2RC("kgf"), "ㄎㄤˊ") + XCTAssertEqual(c.cS2RC("kgj"), "ㄎㄤˇ") + XCTAssertEqual(c.cS2RC("kgl"), "ㄎㄤˋ") + XCTAssertEqual(c.cS2RC("km"), "ㄎㄥ") + XCTAssertEqual(c.cS2RC("kmj"), "ㄎㄥˇ") + XCTAssertEqual(c.cS2RC("ku"), "ㄎㄨ") + XCTAssertEqual(c.cS2RC("kuf"), "ㄎㄨˊ") + XCTAssertEqual(c.cS2RC("kuj"), "ㄎㄨˇ") + XCTAssertEqual(c.cS2RC("kul"), "ㄎㄨˋ") + XCTAssertEqual(c.cS2RC("kua"), "ㄎㄨㄚ") + XCTAssertEqual(c.cS2RC("kuaj"), "ㄎㄨㄚˇ") + XCTAssertEqual(c.cS2RC("kual"), "ㄎㄨㄚˋ") + XCTAssertEqual(c.cS2RC("kuol"), "ㄎㄨㄛˋ") + XCTAssertEqual(c.cS2RC("kuh"), "ㄎㄨㄞ") + XCTAssertEqual(c.cS2RC("kuhj"), "ㄎㄨㄞˇ") + XCTAssertEqual(c.cS2RC("kuhl"), "ㄎㄨㄞˋ") + XCTAssertEqual(c.cS2RC("kuk"), "ㄎㄨㄟ") + XCTAssertEqual(c.cS2RC("kukf"), "ㄎㄨㄟˊ") + XCTAssertEqual(c.cS2RC("kukj"), "ㄎㄨㄟˇ") + XCTAssertEqual(c.cS2RC("kukl"), "ㄎㄨㄟˋ") + XCTAssertEqual(c.cS2RC("kub"), "ㄎㄨㄢ") + XCTAssertEqual(c.cS2RC("kubj"), "ㄎㄨㄢˇ") + XCTAssertEqual(c.cS2RC("kubl"), "ㄎㄨㄢˋ") + XCTAssertEqual(c.cS2RC("kun"), "ㄎㄨㄣ") + XCTAssertEqual(c.cS2RC("kunj"), "ㄎㄨㄣˇ") + XCTAssertEqual(c.cS2RC("kunl"), "ㄎㄨㄣˋ") + XCTAssertEqual(c.cS2RC("kug"), "ㄎㄨㄤ") + XCTAssertEqual(c.cS2RC("kugf"), "ㄎㄨㄤˊ") + XCTAssertEqual(c.cS2RC("kugj"), "ㄎㄨㄤˇ") + XCTAssertEqual(c.cS2RC("kugl"), "ㄎㄨㄤˋ") + XCTAssertEqual(c.cS2RC("kum"), "ㄎㄨㄥ") + XCTAssertEqual(c.cS2RC("kumj"), "ㄎㄨㄥˇ") + XCTAssertEqual(c.cS2RC("kuml"), "ㄎㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ha"), "ㄏㄚ") + XCTAssertEqual(c.cS2RC("haf"), "ㄏㄚˊ") + XCTAssertEqual(c.cS2RC("haj"), "ㄏㄚˇ") + XCTAssertEqual(c.cS2RC("he"), "ㄏㄜ") + XCTAssertEqual(c.cS2RC("hef"), "ㄏㄜˊ") + XCTAssertEqual(c.cS2RC("hej"), "ㄏㄜˇ") + XCTAssertEqual(c.cS2RC("hel"), "ㄏㄜˋ") + XCTAssertEqual(c.cS2RC("hh"), "ㄏㄞ") + XCTAssertEqual(c.cS2RC("hhf"), "ㄏㄞˊ") + XCTAssertEqual(c.cS2RC("hhj"), "ㄏㄞˇ") + XCTAssertEqual(c.cS2RC("hhl"), "ㄏㄞˋ") + XCTAssertEqual(c.cS2RC("hk"), "ㄏㄟ") + XCTAssertEqual(c.cS2RC("hkj"), "ㄏㄟˇ") + XCTAssertEqual(c.cS2RC("hw"), "ㄏㄠ") + XCTAssertEqual(c.cS2RC("hwf"), "ㄏㄠˊ") + XCTAssertEqual(c.cS2RC("hwj"), "ㄏㄠˇ") + XCTAssertEqual(c.cS2RC("hwl"), "ㄏㄠˋ") + XCTAssertEqual(c.cS2RC("hv"), "ㄏㄡ") + XCTAssertEqual(c.cS2RC("hvf"), "ㄏㄡˊ") + XCTAssertEqual(c.cS2RC("hvj"), "ㄏㄡˇ") + XCTAssertEqual(c.cS2RC("hvl"), "ㄏㄡˋ") + XCTAssertEqual(c.cS2RC("hb"), "ㄏㄢ") + XCTAssertEqual(c.cS2RC("hbf"), "ㄏㄢˊ") + XCTAssertEqual(c.cS2RC("hbj"), "ㄏㄢˇ") + XCTAssertEqual(c.cS2RC("hbl"), "ㄏㄢˋ") + XCTAssertEqual(c.cS2RC("hn"), "ㄏㄣ") + XCTAssertEqual(c.cS2RC("hnf"), "ㄏㄣˊ") + XCTAssertEqual(c.cS2RC("hnj"), "ㄏㄣˇ") + XCTAssertEqual(c.cS2RC("hnl"), "ㄏㄣˋ") + XCTAssertEqual(c.cS2RC("hg"), "ㄏㄤ") + XCTAssertEqual(c.cS2RC("hgf"), "ㄏㄤˊ") + XCTAssertEqual(c.cS2RC("hgj"), "ㄏㄤˇ") + XCTAssertEqual(c.cS2RC("hgl"), "ㄏㄤˋ") + XCTAssertEqual(c.cS2RC("hm"), "ㄏㄥ") + XCTAssertEqual(c.cS2RC("hmf"), "ㄏㄥˊ") + XCTAssertEqual(c.cS2RC("hml"), "ㄏㄥˋ") + XCTAssertEqual(c.cS2RC("hu"), "ㄏㄨ") + XCTAssertEqual(c.cS2RC("huf"), "ㄏㄨˊ") + XCTAssertEqual(c.cS2RC("huj"), "ㄏㄨˇ") + XCTAssertEqual(c.cS2RC("hul"), "ㄏㄨˋ") + XCTAssertEqual(c.cS2RC("hua"), "ㄏㄨㄚ") + XCTAssertEqual(c.cS2RC("huaf"), "ㄏㄨㄚˊ") + XCTAssertEqual(c.cS2RC("huaj"), "ㄏㄨㄚˇ") + XCTAssertEqual(c.cS2RC("hual"), "ㄏㄨㄚˋ") + XCTAssertEqual(c.cS2RC("huo"), "ㄏㄨㄛ") + XCTAssertEqual(c.cS2RC("huof"), "ㄏㄨㄛˊ") + XCTAssertEqual(c.cS2RC("huoj"), "ㄏㄨㄛˇ") + XCTAssertEqual(c.cS2RC("huol"), "ㄏㄨㄛˋ") + XCTAssertEqual(c.cS2RC("huod"), "ㄏㄨㄛ˙") + XCTAssertEqual(c.cS2RC("huhf"), "ㄏㄨㄞˊ") + XCTAssertEqual(c.cS2RC("huhl"), "ㄏㄨㄞˋ") + XCTAssertEqual(c.cS2RC("huk"), "ㄏㄨㄟ") + XCTAssertEqual(c.cS2RC("hukf"), "ㄏㄨㄟˊ") + XCTAssertEqual(c.cS2RC("hukj"), "ㄏㄨㄟˇ") + XCTAssertEqual(c.cS2RC("hukl"), "ㄏㄨㄟˋ") + XCTAssertEqual(c.cS2RC("hub"), "ㄏㄨㄢ") + XCTAssertEqual(c.cS2RC("hubf"), "ㄏㄨㄢˊ") + XCTAssertEqual(c.cS2RC("hubj"), "ㄏㄨㄢˇ") + XCTAssertEqual(c.cS2RC("hubl"), "ㄏㄨㄢˋ") + XCTAssertEqual(c.cS2RC("hun"), "ㄏㄨㄣ") + XCTAssertEqual(c.cS2RC("hunf"), "ㄏㄨㄣˊ") + XCTAssertEqual(c.cS2RC("hunj"), "ㄏㄨㄣˇ") + XCTAssertEqual(c.cS2RC("hunl"), "ㄏㄨㄣˋ") + XCTAssertEqual(c.cS2RC("hug"), "ㄏㄨㄤ") + XCTAssertEqual(c.cS2RC("hugf"), "ㄏㄨㄤˊ") + XCTAssertEqual(c.cS2RC("hugj"), "ㄏㄨㄤˇ") + XCTAssertEqual(c.cS2RC("hugl"), "ㄏㄨㄤˋ") + XCTAssertEqual(c.cS2RC("hugd"), "ㄏㄨㄤ˙") + XCTAssertEqual(c.cS2RC("hum"), "ㄏㄨㄥ") + XCTAssertEqual(c.cS2RC("humf"), "ㄏㄨㄥˊ") + XCTAssertEqual(c.cS2RC("humj"), "ㄏㄨㄥˇ") + XCTAssertEqual(c.cS2RC("huml"), "ㄏㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ji"), "ㄐㄧ") + XCTAssertEqual(c.cS2RC("jif"), "ㄐㄧˊ") + XCTAssertEqual(c.cS2RC("jij"), "ㄐㄧˇ") + XCTAssertEqual(c.cS2RC("jil"), "ㄐㄧˋ") + XCTAssertEqual(c.cS2RC("jia"), "ㄐㄧㄚ") + XCTAssertEqual(c.cS2RC("jiaf"), "ㄐㄧㄚˊ") + XCTAssertEqual(c.cS2RC("jiaj"), "ㄐㄧㄚˇ") + XCTAssertEqual(c.cS2RC("jial"), "ㄐㄧㄚˋ") + XCTAssertEqual(c.cS2RC("jie"), "ㄐㄧㄝ") + XCTAssertEqual(c.cS2RC("jief"), "ㄐㄧㄝˊ") + XCTAssertEqual(c.cS2RC("jiej"), "ㄐㄧㄝˇ") + XCTAssertEqual(c.cS2RC("jiel"), "ㄐㄧㄝˋ") + XCTAssertEqual(c.cS2RC("jied"), "ㄐㄧㄝ˙") + XCTAssertEqual(c.cS2RC("jiw"), "ㄐㄧㄠ") + XCTAssertEqual(c.cS2RC("jiwf"), "ㄐㄧㄠˊ") + XCTAssertEqual(c.cS2RC("jiwj"), "ㄐㄧㄠˇ") + XCTAssertEqual(c.cS2RC("jiwl"), "ㄐㄧㄠˋ") + XCTAssertEqual(c.cS2RC("jiv"), "ㄐㄧㄡ") + XCTAssertEqual(c.cS2RC("jivj"), "ㄐㄧㄡˇ") + XCTAssertEqual(c.cS2RC("jivl"), "ㄐㄧㄡˋ") + XCTAssertEqual(c.cS2RC("jib"), "ㄐㄧㄢ") + XCTAssertEqual(c.cS2RC("jibj"), "ㄐㄧㄢˇ") + XCTAssertEqual(c.cS2RC("jibl"), "ㄐㄧㄢˋ") + XCTAssertEqual(c.cS2RC("jin"), "ㄐㄧㄣ") + XCTAssertEqual(c.cS2RC("jinj"), "ㄐㄧㄣˇ") + XCTAssertEqual(c.cS2RC("jinl"), "ㄐㄧㄣˋ") + XCTAssertEqual(c.cS2RC("jig"), "ㄐㄧㄤ") + XCTAssertEqual(c.cS2RC("jigf"), "ㄐㄧㄤˊ") + XCTAssertEqual(c.cS2RC("jigj"), "ㄐㄧㄤˇ") + XCTAssertEqual(c.cS2RC("jigl"), "ㄐㄧㄤˋ") + XCTAssertEqual(c.cS2RC("jim"), "ㄐㄧㄥ") + XCTAssertEqual(c.cS2RC("jimj"), "ㄐㄧㄥˇ") + XCTAssertEqual(c.cS2RC("jiml"), "ㄐㄧㄥˋ") + XCTAssertEqual(c.cS2RC("jy"), "ㄐㄩ") + XCTAssertEqual(c.cS2RC("jyf"), "ㄐㄩˊ") + XCTAssertEqual(c.cS2RC("jyj"), "ㄐㄩˇ") + XCTAssertEqual(c.cS2RC("jyl"), "ㄐㄩˋ") + XCTAssertEqual(c.cS2RC("jye"), "ㄐㄩㄝ") + XCTAssertEqual(c.cS2RC("jyef"), "ㄐㄩㄝˊ") + XCTAssertEqual(c.cS2RC("jyej"), "ㄐㄩㄝˇ") + XCTAssertEqual(c.cS2RC("jyel"), "ㄐㄩㄝˋ") + XCTAssertEqual(c.cS2RC("jyb"), "ㄐㄩㄢ") + XCTAssertEqual(c.cS2RC("jybj"), "ㄐㄩㄢˇ") + XCTAssertEqual(c.cS2RC("jybl"), "ㄐㄩㄢˋ") + XCTAssertEqual(c.cS2RC("jyn"), "ㄐㄩㄣ") + XCTAssertEqual(c.cS2RC("jynf"), "ㄐㄩㄣˊ") + XCTAssertEqual(c.cS2RC("jynj"), "ㄐㄩㄣˇ") + XCTAssertEqual(c.cS2RC("jynl"), "ㄐㄩㄣˋ") + XCTAssertEqual(c.cS2RC("jym"), "ㄐㄩㄥ") + XCTAssertEqual(c.cS2RC("jymj"), "ㄐㄩㄥˇ") + XCTAssertEqual(c.cS2RC("jyml"), "ㄐㄩㄥˋ") + // XCTAssertEqual(c.cS2RC("qd"), "ㄑ˙") + XCTAssertEqual(c.cS2RC("qi"), "ㄑㄧ") + XCTAssertEqual(c.cS2RC("qif"), "ㄑㄧˊ") + XCTAssertEqual(c.cS2RC("qij"), "ㄑㄧˇ") + XCTAssertEqual(c.cS2RC("qil"), "ㄑㄧˋ") + XCTAssertEqual(c.cS2RC("qia"), "ㄑㄧㄚ") + XCTAssertEqual(c.cS2RC("qiaf"), "ㄑㄧㄚˊ") + XCTAssertEqual(c.cS2RC("qiaj"), "ㄑㄧㄚˇ") + XCTAssertEqual(c.cS2RC("qial"), "ㄑㄧㄚˋ") + XCTAssertEqual(c.cS2RC("qie"), "ㄑㄧㄝ") + XCTAssertEqual(c.cS2RC("qief"), "ㄑㄧㄝˊ") + XCTAssertEqual(c.cS2RC("qiej"), "ㄑㄧㄝˇ") + XCTAssertEqual(c.cS2RC("qiel"), "ㄑㄧㄝˋ") + XCTAssertEqual(c.cS2RC("qiw"), "ㄑㄧㄠ") + XCTAssertEqual(c.cS2RC("qiwf"), "ㄑㄧㄠˊ") + XCTAssertEqual(c.cS2RC("qiwj"), "ㄑㄧㄠˇ") + XCTAssertEqual(c.cS2RC("qiwl"), "ㄑㄧㄠˋ") + XCTAssertEqual(c.cS2RC("qiv"), "ㄑㄧㄡ") + XCTAssertEqual(c.cS2RC("qivf"), "ㄑㄧㄡˊ") + XCTAssertEqual(c.cS2RC("qivj"), "ㄑㄧㄡˇ") + XCTAssertEqual(c.cS2RC("qivl"), "ㄑㄧㄡˋ") + XCTAssertEqual(c.cS2RC("qib"), "ㄑㄧㄢ") + XCTAssertEqual(c.cS2RC("qibf"), "ㄑㄧㄢˊ") + XCTAssertEqual(c.cS2RC("qibj"), "ㄑㄧㄢˇ") + XCTAssertEqual(c.cS2RC("qibl"), "ㄑㄧㄢˋ") + XCTAssertEqual(c.cS2RC("qin"), "ㄑㄧㄣ") + XCTAssertEqual(c.cS2RC("qinf"), "ㄑㄧㄣˊ") + XCTAssertEqual(c.cS2RC("qinj"), "ㄑㄧㄣˇ") + XCTAssertEqual(c.cS2RC("qinl"), "ㄑㄧㄣˋ") + XCTAssertEqual(c.cS2RC("qig"), "ㄑㄧㄤ") + XCTAssertEqual(c.cS2RC("qigf"), "ㄑㄧㄤˊ") + XCTAssertEqual(c.cS2RC("qigj"), "ㄑㄧㄤˇ") + XCTAssertEqual(c.cS2RC("qigl"), "ㄑㄧㄤˋ") + XCTAssertEqual(c.cS2RC("qim"), "ㄑㄧㄥ") + XCTAssertEqual(c.cS2RC("qimf"), "ㄑㄧㄥˊ") + XCTAssertEqual(c.cS2RC("qimj"), "ㄑㄧㄥˇ") + XCTAssertEqual(c.cS2RC("qiml"), "ㄑㄧㄥˋ") + XCTAssertEqual(c.cS2RC("qy"), "ㄑㄩ") + XCTAssertEqual(c.cS2RC("qyf"), "ㄑㄩˊ") + XCTAssertEqual(c.cS2RC("qyj"), "ㄑㄩˇ") + XCTAssertEqual(c.cS2RC("qyl"), "ㄑㄩˋ") + XCTAssertEqual(c.cS2RC("qye"), "ㄑㄩㄝ") + XCTAssertEqual(c.cS2RC("qyef"), "ㄑㄩㄝˊ") + XCTAssertEqual(c.cS2RC("qyel"), "ㄑㄩㄝˋ") + XCTAssertEqual(c.cS2RC("qyb"), "ㄑㄩㄢ") + XCTAssertEqual(c.cS2RC("qybf"), "ㄑㄩㄢˊ") + XCTAssertEqual(c.cS2RC("qybj"), "ㄑㄩㄢˇ") + XCTAssertEqual(c.cS2RC("qybl"), "ㄑㄩㄢˋ") + XCTAssertEqual(c.cS2RC("qyn"), "ㄑㄩㄣ") + XCTAssertEqual(c.cS2RC("qynf"), "ㄑㄩㄣˊ") + XCTAssertEqual(c.cS2RC("qynj"), "ㄑㄩㄣˇ") + XCTAssertEqual(c.cS2RC("qynl"), "ㄑㄩㄣˋ") + XCTAssertEqual(c.cS2RC("qym"), "ㄑㄩㄥ") + XCTAssertEqual(c.cS2RC("qymf"), "ㄑㄩㄥˊ") + XCTAssertEqual(c.cS2RC("qymj"), "ㄑㄩㄥˇ") + XCTAssertEqual(c.cS2RC("qyml"), "ㄑㄩㄥˋ") + XCTAssertEqual(c.cS2RC("xi"), "ㄒㄧ") + XCTAssertEqual(c.cS2RC("xif"), "ㄒㄧˊ") + XCTAssertEqual(c.cS2RC("xij"), "ㄒㄧˇ") + XCTAssertEqual(c.cS2RC("xil"), "ㄒㄧˋ") + XCTAssertEqual(c.cS2RC("xia"), "ㄒㄧㄚ") + XCTAssertEqual(c.cS2RC("xiaf"), "ㄒㄧㄚˊ") + XCTAssertEqual(c.cS2RC("xiaj"), "ㄒㄧㄚˇ") + XCTAssertEqual(c.cS2RC("xial"), "ㄒㄧㄚˋ") + XCTAssertEqual(c.cS2RC("xie"), "ㄒㄧㄝ") + XCTAssertEqual(c.cS2RC("xief"), "ㄒㄧㄝˊ") + XCTAssertEqual(c.cS2RC("xiej"), "ㄒㄧㄝˇ") + XCTAssertEqual(c.cS2RC("xiel"), "ㄒㄧㄝˋ") + XCTAssertEqual(c.cS2RC("xiw"), "ㄒㄧㄠ") + XCTAssertEqual(c.cS2RC("xiwf"), "ㄒㄧㄠˊ") + XCTAssertEqual(c.cS2RC("xiwj"), "ㄒㄧㄠˇ") + XCTAssertEqual(c.cS2RC("xiwl"), "ㄒㄧㄠˋ") + XCTAssertEqual(c.cS2RC("xiv"), "ㄒㄧㄡ") + XCTAssertEqual(c.cS2RC("xivf"), "ㄒㄧㄡˊ") + XCTAssertEqual(c.cS2RC("xivj"), "ㄒㄧㄡˇ") + XCTAssertEqual(c.cS2RC("xivl"), "ㄒㄧㄡˋ") + XCTAssertEqual(c.cS2RC("xib"), "ㄒㄧㄢ") + XCTAssertEqual(c.cS2RC("xibf"), "ㄒㄧㄢˊ") + XCTAssertEqual(c.cS2RC("xibj"), "ㄒㄧㄢˇ") + XCTAssertEqual(c.cS2RC("xibl"), "ㄒㄧㄢˋ") + XCTAssertEqual(c.cS2RC("xin"), "ㄒㄧㄣ") + XCTAssertEqual(c.cS2RC("xinf"), "ㄒㄧㄣˊ") + XCTAssertEqual(c.cS2RC("xinj"), "ㄒㄧㄣˇ") + XCTAssertEqual(c.cS2RC("xinl"), "ㄒㄧㄣˋ") + XCTAssertEqual(c.cS2RC("xig"), "ㄒㄧㄤ") + XCTAssertEqual(c.cS2RC("xigf"), "ㄒㄧㄤˊ") + XCTAssertEqual(c.cS2RC("xigj"), "ㄒㄧㄤˇ") + XCTAssertEqual(c.cS2RC("xigl"), "ㄒㄧㄤˋ") + XCTAssertEqual(c.cS2RC("xim"), "ㄒㄧㄥ") + XCTAssertEqual(c.cS2RC("ximf"), "ㄒㄧㄥˊ") + XCTAssertEqual(c.cS2RC("ximj"), "ㄒㄧㄥˇ") + XCTAssertEqual(c.cS2RC("ximl"), "ㄒㄧㄥˋ") + XCTAssertEqual(c.cS2RC("xy"), "ㄒㄩ") + XCTAssertEqual(c.cS2RC("xyf"), "ㄒㄩˊ") + XCTAssertEqual(c.cS2RC("xyj"), "ㄒㄩˇ") + XCTAssertEqual(c.cS2RC("xyl"), "ㄒㄩˋ") + XCTAssertEqual(c.cS2RC("xye"), "ㄒㄩㄝ") + XCTAssertEqual(c.cS2RC("xyef"), "ㄒㄩㄝˊ") + XCTAssertEqual(c.cS2RC("xyej"), "ㄒㄩㄝˇ") + XCTAssertEqual(c.cS2RC("xyel"), "ㄒㄩㄝˋ") + XCTAssertEqual(c.cS2RC("xyb"), "ㄒㄩㄢ") + XCTAssertEqual(c.cS2RC("xybf"), "ㄒㄩㄢˊ") + XCTAssertEqual(c.cS2RC("xybj"), "ㄒㄩㄢˇ") + XCTAssertEqual(c.cS2RC("xybl"), "ㄒㄩㄢˋ") + XCTAssertEqual(c.cS2RC("xyn"), "ㄒㄩㄣ") + XCTAssertEqual(c.cS2RC("xynf"), "ㄒㄩㄣˊ") + XCTAssertEqual(c.cS2RC("xynl"), "ㄒㄩㄣˋ") + XCTAssertEqual(c.cS2RC("xym"), "ㄒㄩㄥ") + XCTAssertEqual(c.cS2RC("xymf"), "ㄒㄩㄥˊ") + XCTAssertEqual(c.cS2RC("xymj"), "ㄒㄩㄥˇ") + XCTAssertEqual(c.cS2RC("xyml"), "ㄒㄩㄥˋ") + XCTAssertEqual(c.cS2RC("j"), "ㄓ") + XCTAssertEqual(c.cS2RC("jf"), "ㄓˊ") + XCTAssertEqual(c.cS2RC("jj"), "ㄓˇ") + XCTAssertEqual(c.cS2RC("jl"), "ㄓˋ") + XCTAssertEqual(c.cS2RC("ja"), "ㄓㄚ") + XCTAssertEqual(c.cS2RC("jaf"), "ㄓㄚˊ") + XCTAssertEqual(c.cS2RC("jaj"), "ㄓㄚˇ") + XCTAssertEqual(c.cS2RC("jal"), "ㄓㄚˋ") + XCTAssertEqual(c.cS2RC("je"), "ㄓㄜ") + XCTAssertEqual(c.cS2RC("jef"), "ㄓㄜˊ") + XCTAssertEqual(c.cS2RC("jej"), "ㄓㄜˇ") + XCTAssertEqual(c.cS2RC("jel"), "ㄓㄜˋ") + XCTAssertEqual(c.cS2RC("jed"), "ㄓㄜ˙") + XCTAssertEqual(c.cS2RC("jh"), "ㄓㄞ") + XCTAssertEqual(c.cS2RC("jhf"), "ㄓㄞˊ") + XCTAssertEqual(c.cS2RC("jhj"), "ㄓㄞˇ") + XCTAssertEqual(c.cS2RC("jhl"), "ㄓㄞˋ") + XCTAssertEqual(c.cS2RC("jkl"), "ㄓㄟˋ") + XCTAssertEqual(c.cS2RC("jw"), "ㄓㄠ") + XCTAssertEqual(c.cS2RC("jwf"), "ㄓㄠˊ") + XCTAssertEqual(c.cS2RC("jwj"), "ㄓㄠˇ") + XCTAssertEqual(c.cS2RC("jwl"), "ㄓㄠˋ") + XCTAssertEqual(c.cS2RC("jv"), "ㄓㄡ") + XCTAssertEqual(c.cS2RC("jvf"), "ㄓㄡˊ") + XCTAssertEqual(c.cS2RC("jvj"), "ㄓㄡˇ") + XCTAssertEqual(c.cS2RC("jvl"), "ㄓㄡˋ") + XCTAssertEqual(c.cS2RC("jb"), "ㄓㄢ") + XCTAssertEqual(c.cS2RC("jbj"), "ㄓㄢˇ") + XCTAssertEqual(c.cS2RC("jbl"), "ㄓㄢˋ") + XCTAssertEqual(c.cS2RC("jn"), "ㄓㄣ") + XCTAssertEqual(c.cS2RC("jnf"), "ㄓㄣˊ") + XCTAssertEqual(c.cS2RC("jnj"), "ㄓㄣˇ") + XCTAssertEqual(c.cS2RC("jnl"), "ㄓㄣˋ") + XCTAssertEqual(c.cS2RC("jg"), "ㄓㄤ") + XCTAssertEqual(c.cS2RC("jgj"), "ㄓㄤˇ") + XCTAssertEqual(c.cS2RC("jgl"), "ㄓㄤˋ") + XCTAssertEqual(c.cS2RC("jm"), "ㄓㄥ") + XCTAssertEqual(c.cS2RC("jmj"), "ㄓㄥˇ") + XCTAssertEqual(c.cS2RC("jml"), "ㄓㄥˋ") + XCTAssertEqual(c.cS2RC("ju"), "ㄓㄨ") + XCTAssertEqual(c.cS2RC("juf"), "ㄓㄨˊ") + XCTAssertEqual(c.cS2RC("juj"), "ㄓㄨˇ") + XCTAssertEqual(c.cS2RC("jul"), "ㄓㄨˋ") + XCTAssertEqual(c.cS2RC("jua"), "ㄓㄨㄚ") + XCTAssertEqual(c.cS2RC("juaj"), "ㄓㄨㄚˇ") + XCTAssertEqual(c.cS2RC("juo"), "ㄓㄨㄛ") + XCTAssertEqual(c.cS2RC("juof"), "ㄓㄨㄛˊ") + XCTAssertEqual(c.cS2RC("juol"), "ㄓㄨㄛˋ") + XCTAssertEqual(c.cS2RC("juh"), "ㄓㄨㄞ") + } +} diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_C.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_C.swift new file mode 100644 index 00000000..52f88498 --- /dev/null +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_C.swift @@ -0,0 +1,521 @@ +// (c) 2022 and onwards The vChewing Project (MIT-NTL License). +// ==================== +// This code is released under the MIT license (SPDX-License-Identifier: MIT) +// ... with NTL restriction stating that: +// No trademark license is granted to use the trade names, trademarks, service +// marks, or product names of Contributor, except as required to fulfill notice +// requirements defined in MIT License. + +import XCTest + +@testable import Tekkon + +extension TekkonTestsKeyboardArrangments { + func testAlvinLiuKeysC() throws { + var c = Tekkon.Composer(arrange: .ofAlvinLiu) + XCTAssertEqual(c.cS2RC("juhj"), "ㄓㄨㄞˇ") + XCTAssertEqual(c.cS2RC("juhl"), "ㄓㄨㄞˋ") + XCTAssertEqual(c.cS2RC("juk"), "ㄓㄨㄟ") + XCTAssertEqual(c.cS2RC("jukj"), "ㄓㄨㄟˇ") + XCTAssertEqual(c.cS2RC("jukl"), "ㄓㄨㄟˋ") + XCTAssertEqual(c.cS2RC("jub"), "ㄓㄨㄢ") + XCTAssertEqual(c.cS2RC("jubj"), "ㄓㄨㄢˇ") + XCTAssertEqual(c.cS2RC("jubl"), "ㄓㄨㄢˋ") + XCTAssertEqual(c.cS2RC("jun"), "ㄓㄨㄣ") + XCTAssertEqual(c.cS2RC("junj"), "ㄓㄨㄣˇ") + XCTAssertEqual(c.cS2RC("junl"), "ㄓㄨㄣˋ") + XCTAssertEqual(c.cS2RC("jug"), "ㄓㄨㄤ") + XCTAssertEqual(c.cS2RC("jugj"), "ㄓㄨㄤˇ") + XCTAssertEqual(c.cS2RC("jugl"), "ㄓㄨㄤˋ") + XCTAssertEqual(c.cS2RC("jum"), "ㄓㄨㄥ") + XCTAssertEqual(c.cS2RC("jumj"), "ㄓㄨㄥˇ") + XCTAssertEqual(c.cS2RC("juml"), "ㄓㄨㄥˋ") + XCTAssertEqual(c.cS2RC("q "), "ㄔ ") + XCTAssertEqual(c.cS2RC("qf"), "ㄔˊ") + XCTAssertEqual(c.cS2RC("qj"), "ㄔˇ") + XCTAssertEqual(c.cS2RC("ql"), "ㄔˋ") + XCTAssertEqual(c.cS2RC("qa"), "ㄔㄚ") + XCTAssertEqual(c.cS2RC("qaf"), "ㄔㄚˊ") + XCTAssertEqual(c.cS2RC("qaj"), "ㄔㄚˇ") + XCTAssertEqual(c.cS2RC("qal"), "ㄔㄚˋ") + XCTAssertEqual(c.cS2RC("qe"), "ㄔㄜ") + XCTAssertEqual(c.cS2RC("qej"), "ㄔㄜˇ") + XCTAssertEqual(c.cS2RC("qel"), "ㄔㄜˋ") + XCTAssertEqual(c.cS2RC("qh"), "ㄔㄞ") + XCTAssertEqual(c.cS2RC("qhf"), "ㄔㄞˊ") + XCTAssertEqual(c.cS2RC("qhj"), "ㄔㄞˇ") + XCTAssertEqual(c.cS2RC("qhl"), "ㄔㄞˋ") + XCTAssertEqual(c.cS2RC("qw"), "ㄔㄠ") + XCTAssertEqual(c.cS2RC("qwf"), "ㄔㄠˊ") + XCTAssertEqual(c.cS2RC("qwj"), "ㄔㄠˇ") + XCTAssertEqual(c.cS2RC("qwl"), "ㄔㄠˋ") + XCTAssertEqual(c.cS2RC("qv"), "ㄔㄡ") + XCTAssertEqual(c.cS2RC("qvf"), "ㄔㄡˊ") + XCTAssertEqual(c.cS2RC("qvj"), "ㄔㄡˇ") + XCTAssertEqual(c.cS2RC("qvl"), "ㄔㄡˋ") + XCTAssertEqual(c.cS2RC("qb"), "ㄔㄢ") + XCTAssertEqual(c.cS2RC("qbf"), "ㄔㄢˊ") + XCTAssertEqual(c.cS2RC("qbj"), "ㄔㄢˇ") + XCTAssertEqual(c.cS2RC("qbl"), "ㄔㄢˋ") + XCTAssertEqual(c.cS2RC("qn"), "ㄔㄣ") + XCTAssertEqual(c.cS2RC("qnf"), "ㄔㄣˊ") + XCTAssertEqual(c.cS2RC("qnj"), "ㄔㄣˇ") + XCTAssertEqual(c.cS2RC("qnl"), "ㄔㄣˋ") + XCTAssertEqual(c.cS2RC("qnd"), "ㄔㄣ˙") + XCTAssertEqual(c.cS2RC("qg"), "ㄔㄤ") + XCTAssertEqual(c.cS2RC("qgf"), "ㄔㄤˊ") + XCTAssertEqual(c.cS2RC("qgj"), "ㄔㄤˇ") + XCTAssertEqual(c.cS2RC("qgl"), "ㄔㄤˋ") + XCTAssertEqual(c.cS2RC("qm"), "ㄔㄥ") + XCTAssertEqual(c.cS2RC("qmf"), "ㄔㄥˊ") + XCTAssertEqual(c.cS2RC("qmj"), "ㄔㄥˇ") + XCTAssertEqual(c.cS2RC("qml"), "ㄔㄥˋ") + XCTAssertEqual(c.cS2RC("qu"), "ㄔㄨ") + XCTAssertEqual(c.cS2RC("quf"), "ㄔㄨˊ") + XCTAssertEqual(c.cS2RC("quj"), "ㄔㄨˇ") + XCTAssertEqual(c.cS2RC("qul"), "ㄔㄨˋ") + XCTAssertEqual(c.cS2RC("qua"), "ㄔㄨㄚ") + XCTAssertEqual(c.cS2RC("quaj"), "ㄔㄨㄚˇ") + XCTAssertEqual(c.cS2RC("qual"), "ㄔㄨㄚˋ") + XCTAssertEqual(c.cS2RC("quo"), "ㄔㄨㄛ") + XCTAssertEqual(c.cS2RC("quol"), "ㄔㄨㄛˋ") + XCTAssertEqual(c.cS2RC("quh"), "ㄔㄨㄞ") + XCTAssertEqual(c.cS2RC("quhf"), "ㄔㄨㄞˊ") + XCTAssertEqual(c.cS2RC("quhj"), "ㄔㄨㄞˇ") + XCTAssertEqual(c.cS2RC("quhl"), "ㄔㄨㄞˋ") + XCTAssertEqual(c.cS2RC("quk"), "ㄔㄨㄟ") + XCTAssertEqual(c.cS2RC("qukf"), "ㄔㄨㄟˊ") + XCTAssertEqual(c.cS2RC("qukj"), "ㄔㄨㄟˇ") + XCTAssertEqual(c.cS2RC("qukl"), "ㄔㄨㄟˋ") + XCTAssertEqual(c.cS2RC("qub"), "ㄔㄨㄢ") + XCTAssertEqual(c.cS2RC("qubf"), "ㄔㄨㄢˊ") + XCTAssertEqual(c.cS2RC("qubj"), "ㄔㄨㄢˇ") + XCTAssertEqual(c.cS2RC("qubl"), "ㄔㄨㄢˋ") + XCTAssertEqual(c.cS2RC("qun"), "ㄔㄨㄣ") + XCTAssertEqual(c.cS2RC("qunf"), "ㄔㄨㄣˊ") + XCTAssertEqual(c.cS2RC("qunj"), "ㄔㄨㄣˇ") + XCTAssertEqual(c.cS2RC("qug"), "ㄔㄨㄤ") + XCTAssertEqual(c.cS2RC("qugf"), "ㄔㄨㄤˊ") + XCTAssertEqual(c.cS2RC("qugj"), "ㄔㄨㄤˇ") + XCTAssertEqual(c.cS2RC("qugl"), "ㄔㄨㄤˋ") + XCTAssertEqual(c.cS2RC("qum"), "ㄔㄨㄥ") + XCTAssertEqual(c.cS2RC("qumf"), "ㄔㄨㄥˊ") + XCTAssertEqual(c.cS2RC("qumj"), "ㄔㄨㄥˇ") + XCTAssertEqual(c.cS2RC("quml"), "ㄔㄨㄥˋ") + XCTAssertEqual(c.cS2RC("x "), "ㄕ ") + XCTAssertEqual(c.cS2RC("xf"), "ㄕˊ") + XCTAssertEqual(c.cS2RC("xj"), "ㄕˇ") + XCTAssertEqual(c.cS2RC("xl"), "ㄕˋ") + XCTAssertEqual(c.cS2RC("xd"), "ㄕ˙") + XCTAssertEqual(c.cS2RC("xa"), "ㄕㄚ") + XCTAssertEqual(c.cS2RC("xaf"), "ㄕㄚˊ") + XCTAssertEqual(c.cS2RC("xaj"), "ㄕㄚˇ") + XCTAssertEqual(c.cS2RC("xal"), "ㄕㄚˋ") + XCTAssertEqual(c.cS2RC("xad"), "ㄕㄚ˙") + XCTAssertEqual(c.cS2RC("xe"), "ㄕㄜ") + XCTAssertEqual(c.cS2RC("xef"), "ㄕㄜˊ") + XCTAssertEqual(c.cS2RC("xej"), "ㄕㄜˇ") + XCTAssertEqual(c.cS2RC("xel"), "ㄕㄜˋ") + XCTAssertEqual(c.cS2RC("xh"), "ㄕㄞ") + XCTAssertEqual(c.cS2RC("xhj"), "ㄕㄞˇ") + XCTAssertEqual(c.cS2RC("xhl"), "ㄕㄞˋ") + XCTAssertEqual(c.cS2RC("xkf"), "ㄕㄟˊ") + XCTAssertEqual(c.cS2RC("xw"), "ㄕㄠ") + XCTAssertEqual(c.cS2RC("xwf"), "ㄕㄠˊ") + XCTAssertEqual(c.cS2RC("xwj"), "ㄕㄠˇ") + XCTAssertEqual(c.cS2RC("xwl"), "ㄕㄠˋ") + XCTAssertEqual(c.cS2RC("xv"), "ㄕㄡ") + XCTAssertEqual(c.cS2RC("xvf"), "ㄕㄡˊ") + XCTAssertEqual(c.cS2RC("xvj"), "ㄕㄡˇ") + XCTAssertEqual(c.cS2RC("xvl"), "ㄕㄡˋ") + XCTAssertEqual(c.cS2RC("xb"), "ㄕㄢ") + XCTAssertEqual(c.cS2RC("xbf"), "ㄕㄢˊ") + XCTAssertEqual(c.cS2RC("xbj"), "ㄕㄢˇ") + XCTAssertEqual(c.cS2RC("xbl"), "ㄕㄢˋ") + XCTAssertEqual(c.cS2RC("xn"), "ㄕㄣ") + XCTAssertEqual(c.cS2RC("xnf"), "ㄕㄣˊ") + XCTAssertEqual(c.cS2RC("xnj"), "ㄕㄣˇ") + XCTAssertEqual(c.cS2RC("xnl"), "ㄕㄣˋ") + XCTAssertEqual(c.cS2RC("xg"), "ㄕㄤ") + XCTAssertEqual(c.cS2RC("xgj"), "ㄕㄤˇ") + XCTAssertEqual(c.cS2RC("xgl"), "ㄕㄤˋ") + XCTAssertEqual(c.cS2RC("xgd"), "ㄕㄤ˙") + XCTAssertEqual(c.cS2RC("xm"), "ㄕㄥ") + XCTAssertEqual(c.cS2RC("xmf"), "ㄕㄥˊ") + XCTAssertEqual(c.cS2RC("xmj"), "ㄕㄥˇ") + XCTAssertEqual(c.cS2RC("xml"), "ㄕㄥˋ") + XCTAssertEqual(c.cS2RC("xu"), "ㄕㄨ") + XCTAssertEqual(c.cS2RC("xuf"), "ㄕㄨˊ") + XCTAssertEqual(c.cS2RC("xuj"), "ㄕㄨˇ") + XCTAssertEqual(c.cS2RC("xul"), "ㄕㄨˋ") + XCTAssertEqual(c.cS2RC("xua"), "ㄕㄨㄚ") + XCTAssertEqual(c.cS2RC("xuaj"), "ㄕㄨㄚˇ") + XCTAssertEqual(c.cS2RC("xual"), "ㄕㄨㄚˋ") + XCTAssertEqual(c.cS2RC("xuo"), "ㄕㄨㄛ") + XCTAssertEqual(c.cS2RC("xuol"), "ㄕㄨㄛˋ") + XCTAssertEqual(c.cS2RC("xuh"), "ㄕㄨㄞ") + XCTAssertEqual(c.cS2RC("xuhj"), "ㄕㄨㄞˇ") + XCTAssertEqual(c.cS2RC("xuhl"), "ㄕㄨㄞˋ") + XCTAssertEqual(c.cS2RC("xuk"), "ㄕㄨㄟ") + XCTAssertEqual(c.cS2RC("xukf"), "ㄕㄨㄟˊ") + XCTAssertEqual(c.cS2RC("xukj"), "ㄕㄨㄟˇ") + XCTAssertEqual(c.cS2RC("xukl"), "ㄕㄨㄟˋ") + XCTAssertEqual(c.cS2RC("xub"), "ㄕㄨㄢ") + XCTAssertEqual(c.cS2RC("xubl"), "ㄕㄨㄢˋ") + XCTAssertEqual(c.cS2RC("xunj"), "ㄕㄨㄣˇ") + XCTAssertEqual(c.cS2RC("xunl"), "ㄕㄨㄣˋ") + XCTAssertEqual(c.cS2RC("xug"), "ㄕㄨㄤ") + XCTAssertEqual(c.cS2RC("xugf"), "ㄕㄨㄤˊ") + XCTAssertEqual(c.cS2RC("xugj"), "ㄕㄨㄤˇ") + XCTAssertEqual(c.cS2RC("xugl"), "ㄕㄨㄤˋ") + XCTAssertEqual(c.cS2RC("rl"), "ㄖˋ") + XCTAssertEqual(c.cS2RC("rej"), "ㄖㄜˇ") + XCTAssertEqual(c.cS2RC("rel"), "ㄖㄜˋ") + XCTAssertEqual(c.cS2RC("rwf"), "ㄖㄠˊ") + XCTAssertEqual(c.cS2RC("rwj"), "ㄖㄠˇ") + XCTAssertEqual(c.cS2RC("rwl"), "ㄖㄠˋ") + XCTAssertEqual(c.cS2RC("rvf"), "ㄖㄡˊ") + XCTAssertEqual(c.cS2RC("rvj"), "ㄖㄡˇ") + XCTAssertEqual(c.cS2RC("rvl"), "ㄖㄡˋ") + XCTAssertEqual(c.cS2RC("rbf"), "ㄖㄢˊ") + XCTAssertEqual(c.cS2RC("rbj"), "ㄖㄢˇ") + XCTAssertEqual(c.cS2RC("rbl"), "ㄖㄢˋ") + XCTAssertEqual(c.cS2RC("rnf"), "ㄖㄣˊ") + XCTAssertEqual(c.cS2RC("rnj"), "ㄖㄣˇ") + XCTAssertEqual(c.cS2RC("rnl"), "ㄖㄣˋ") + XCTAssertEqual(c.cS2RC("rg"), "ㄖㄤ") + XCTAssertEqual(c.cS2RC("rgf"), "ㄖㄤˊ") + XCTAssertEqual(c.cS2RC("rgj"), "ㄖㄤˇ") + XCTAssertEqual(c.cS2RC("rgl"), "ㄖㄤˋ") + XCTAssertEqual(c.cS2RC("rm"), "ㄖㄥ") + XCTAssertEqual(c.cS2RC("rmf"), "ㄖㄥˊ") + XCTAssertEqual(c.cS2RC("rmj"), "ㄖㄥˇ") + XCTAssertEqual(c.cS2RC("rml"), "ㄖㄥˋ") + XCTAssertEqual(c.cS2RC("ruf"), "ㄖㄨˊ") + XCTAssertEqual(c.cS2RC("ruj"), "ㄖㄨˇ") + XCTAssertEqual(c.cS2RC("rul"), "ㄖㄨˋ") + XCTAssertEqual(c.cS2RC("ruof"), "ㄖㄨㄛˊ") + XCTAssertEqual(c.cS2RC("ruol"), "ㄖㄨㄛˋ") + XCTAssertEqual(c.cS2RC("rukf"), "ㄖㄨㄟˊ") + XCTAssertEqual(c.cS2RC("rukj"), "ㄖㄨㄟˇ") + XCTAssertEqual(c.cS2RC("rukl"), "ㄖㄨㄟˋ") + XCTAssertEqual(c.cS2RC("rubf"), "ㄖㄨㄢˊ") + XCTAssertEqual(c.cS2RC("rubj"), "ㄖㄨㄢˇ") + XCTAssertEqual(c.cS2RC("rubl"), "ㄖㄨㄢˋ") + XCTAssertEqual(c.cS2RC("runf"), "ㄖㄨㄣˊ") + XCTAssertEqual(c.cS2RC("runj"), "ㄖㄨㄣˇ") + XCTAssertEqual(c.cS2RC("runl"), "ㄖㄨㄣˋ") + XCTAssertEqual(c.cS2RC("rumf"), "ㄖㄨㄥˊ") + XCTAssertEqual(c.cS2RC("rumj"), "ㄖㄨㄥˇ") + XCTAssertEqual(c.cS2RC("ruml"), "ㄖㄨㄥˋ") + XCTAssertEqual(c.cS2RC("z"), "ㄗ") + XCTAssertEqual(c.cS2RC("zf"), "ㄗˊ") + XCTAssertEqual(c.cS2RC("zj"), "ㄗˇ") + XCTAssertEqual(c.cS2RC("zl"), "ㄗˋ") + XCTAssertEqual(c.cS2RC("zd"), "ㄗ˙") + XCTAssertEqual(c.cS2RC("za"), "ㄗㄚ") + XCTAssertEqual(c.cS2RC("zaf"), "ㄗㄚˊ") + XCTAssertEqual(c.cS2RC("zaj"), "ㄗㄚˇ") + XCTAssertEqual(c.cS2RC("zef"), "ㄗㄜˊ") + XCTAssertEqual(c.cS2RC("zej"), "ㄗㄜˇ") + XCTAssertEqual(c.cS2RC("zel"), "ㄗㄜˋ") + XCTAssertEqual(c.cS2RC("zh"), "ㄗㄞ") + XCTAssertEqual(c.cS2RC("zhj"), "ㄗㄞˇ") + XCTAssertEqual(c.cS2RC("zhl"), "ㄗㄞˋ") + XCTAssertEqual(c.cS2RC("zkf"), "ㄗㄟˊ") + XCTAssertEqual(c.cS2RC("zw"), "ㄗㄠ") + XCTAssertEqual(c.cS2RC("zwf"), "ㄗㄠˊ") + XCTAssertEqual(c.cS2RC("zwj"), "ㄗㄠˇ") + XCTAssertEqual(c.cS2RC("zwl"), "ㄗㄠˋ") + XCTAssertEqual(c.cS2RC("zv"), "ㄗㄡ") + XCTAssertEqual(c.cS2RC("zvj"), "ㄗㄡˇ") + XCTAssertEqual(c.cS2RC("zvl"), "ㄗㄡˋ") + XCTAssertEqual(c.cS2RC("zb"), "ㄗㄢ") + XCTAssertEqual(c.cS2RC("zbf"), "ㄗㄢˊ") + XCTAssertEqual(c.cS2RC("zbj"), "ㄗㄢˇ") + XCTAssertEqual(c.cS2RC("zbl"), "ㄗㄢˋ") + XCTAssertEqual(c.cS2RC("zn"), "ㄗㄣ") + XCTAssertEqual(c.cS2RC("znj"), "ㄗㄣˇ") + XCTAssertEqual(c.cS2RC("znl"), "ㄗㄣˋ") + XCTAssertEqual(c.cS2RC("zg"), "ㄗㄤ") + XCTAssertEqual(c.cS2RC("zgj"), "ㄗㄤˇ") + XCTAssertEqual(c.cS2RC("zgl"), "ㄗㄤˋ") + XCTAssertEqual(c.cS2RC("zm"), "ㄗㄥ") + XCTAssertEqual(c.cS2RC("zmj"), "ㄗㄥˇ") + XCTAssertEqual(c.cS2RC("zml"), "ㄗㄥˋ") + XCTAssertEqual(c.cS2RC("zu"), "ㄗㄨ") + XCTAssertEqual(c.cS2RC("zuf"), "ㄗㄨˊ") + XCTAssertEqual(c.cS2RC("zuj"), "ㄗㄨˇ") + XCTAssertEqual(c.cS2RC("zul"), "ㄗㄨˋ") + XCTAssertEqual(c.cS2RC("zuo"), "ㄗㄨㄛ") + XCTAssertEqual(c.cS2RC("zuof"), "ㄗㄨㄛˊ") + XCTAssertEqual(c.cS2RC("zuoj"), "ㄗㄨㄛˇ") + XCTAssertEqual(c.cS2RC("zuol"), "ㄗㄨㄛˋ") + XCTAssertEqual(c.cS2RC("zuod"), "ㄗㄨㄛ˙") + XCTAssertEqual(c.cS2RC("zuk"), "ㄗㄨㄟ") + XCTAssertEqual(c.cS2RC("zukj"), "ㄗㄨㄟˇ") + XCTAssertEqual(c.cS2RC("zukl"), "ㄗㄨㄟˋ") + XCTAssertEqual(c.cS2RC("zub"), "ㄗㄨㄢ") + XCTAssertEqual(c.cS2RC("zubj"), "ㄗㄨㄢˇ") + XCTAssertEqual(c.cS2RC("zubl"), "ㄗㄨㄢˋ") + XCTAssertEqual(c.cS2RC("zun"), "ㄗㄨㄣ") + XCTAssertEqual(c.cS2RC("zunj"), "ㄗㄨㄣˇ") + XCTAssertEqual(c.cS2RC("zunl"), "ㄗㄨㄣˋ") + XCTAssertEqual(c.cS2RC("zum"), "ㄗㄨㄥ") + XCTAssertEqual(c.cS2RC("zumj"), "ㄗㄨㄥˇ") + XCTAssertEqual(c.cS2RC("zuml"), "ㄗㄨㄥˋ") + XCTAssertEqual(c.cS2RC("c"), "ㄘ") + XCTAssertEqual(c.cS2RC("cf"), "ㄘˊ") + XCTAssertEqual(c.cS2RC("cj"), "ㄘˇ") + XCTAssertEqual(c.cS2RC("cl"), "ㄘˋ") + XCTAssertEqual(c.cS2RC("ca"), "ㄘㄚ") + XCTAssertEqual(c.cS2RC("caj"), "ㄘㄚˇ") + XCTAssertEqual(c.cS2RC("cal"), "ㄘㄚˋ") + XCTAssertEqual(c.cS2RC("cel"), "ㄘㄜˋ") + XCTAssertEqual(c.cS2RC("ch"), "ㄘㄞ") + XCTAssertEqual(c.cS2RC("chf"), "ㄘㄞˊ") + XCTAssertEqual(c.cS2RC("chj"), "ㄘㄞˇ") + XCTAssertEqual(c.cS2RC("chl"), "ㄘㄞˋ") + XCTAssertEqual(c.cS2RC("cw"), "ㄘㄠ") + XCTAssertEqual(c.cS2RC("cwf"), "ㄘㄠˊ") + XCTAssertEqual(c.cS2RC("cwj"), "ㄘㄠˇ") + XCTAssertEqual(c.cS2RC("cwl"), "ㄘㄠˋ") + XCTAssertEqual(c.cS2RC("cv"), "ㄘㄡ") + XCTAssertEqual(c.cS2RC("cvf"), "ㄘㄡˊ") + XCTAssertEqual(c.cS2RC("cvj"), "ㄘㄡˇ") + XCTAssertEqual(c.cS2RC("cvl"), "ㄘㄡˋ") + XCTAssertEqual(c.cS2RC("cb"), "ㄘㄢ") + XCTAssertEqual(c.cS2RC("cbf"), "ㄘㄢˊ") + XCTAssertEqual(c.cS2RC("cbj"), "ㄘㄢˇ") + XCTAssertEqual(c.cS2RC("cbl"), "ㄘㄢˋ") + XCTAssertEqual(c.cS2RC("cn"), "ㄘㄣ") + XCTAssertEqual(c.cS2RC("cnf"), "ㄘㄣˊ") + XCTAssertEqual(c.cS2RC("cg"), "ㄘㄤ") + XCTAssertEqual(c.cS2RC("cgf"), "ㄘㄤˊ") + XCTAssertEqual(c.cS2RC("cgj"), "ㄘㄤˇ") + XCTAssertEqual(c.cS2RC("cgl"), "ㄘㄤˋ") + XCTAssertEqual(c.cS2RC("cm"), "ㄘㄥ") + XCTAssertEqual(c.cS2RC("cmf"), "ㄘㄥˊ") + XCTAssertEqual(c.cS2RC("cmj"), "ㄘㄥˇ") + XCTAssertEqual(c.cS2RC("cml"), "ㄘㄥˋ") + XCTAssertEqual(c.cS2RC("cu"), "ㄘㄨ") + XCTAssertEqual(c.cS2RC("cuf"), "ㄘㄨˊ") + XCTAssertEqual(c.cS2RC("cuj"), "ㄘㄨˇ") + XCTAssertEqual(c.cS2RC("cul"), "ㄘㄨˋ") + XCTAssertEqual(c.cS2RC("cuo"), "ㄘㄨㄛ") + XCTAssertEqual(c.cS2RC("cuof"), "ㄘㄨㄛˊ") + XCTAssertEqual(c.cS2RC("cuoj"), "ㄘㄨㄛˇ") + XCTAssertEqual(c.cS2RC("cuol"), "ㄘㄨㄛˋ") + XCTAssertEqual(c.cS2RC("cuk"), "ㄘㄨㄟ") + XCTAssertEqual(c.cS2RC("cukj"), "ㄘㄨㄟˇ") + XCTAssertEqual(c.cS2RC("cukl"), "ㄘㄨㄟˋ") + XCTAssertEqual(c.cS2RC("cub"), "ㄘㄨㄢ") + XCTAssertEqual(c.cS2RC("cubf"), "ㄘㄨㄢˊ") + XCTAssertEqual(c.cS2RC("cubj"), "ㄘㄨㄢˇ") + XCTAssertEqual(c.cS2RC("cubl"), "ㄘㄨㄢˋ") + XCTAssertEqual(c.cS2RC("cun"), "ㄘㄨㄣ") + XCTAssertEqual(c.cS2RC("cunf"), "ㄘㄨㄣˊ") + XCTAssertEqual(c.cS2RC("cunj"), "ㄘㄨㄣˇ") + XCTAssertEqual(c.cS2RC("cunl"), "ㄘㄨㄣˋ") + XCTAssertEqual(c.cS2RC("cum"), "ㄘㄨㄥ") + XCTAssertEqual(c.cS2RC("cumf"), "ㄘㄨㄥˊ") + XCTAssertEqual(c.cS2RC("cumj"), "ㄘㄨㄥˇ") + XCTAssertEqual(c.cS2RC("cuml"), "ㄘㄨㄥˋ") + XCTAssertEqual(c.cS2RC("s"), "ㄙ") + XCTAssertEqual(c.cS2RC("sj"), "ㄙˇ") + XCTAssertEqual(c.cS2RC("sl"), "ㄙˋ") + XCTAssertEqual(c.cS2RC("sa"), "ㄙㄚ") + XCTAssertEqual(c.cS2RC("saj"), "ㄙㄚˇ") + XCTAssertEqual(c.cS2RC("sal"), "ㄙㄚˋ") + XCTAssertEqual(c.cS2RC("sad"), "ㄙㄚ˙") + XCTAssertEqual(c.cS2RC("se"), "ㄙㄜ") + XCTAssertEqual(c.cS2RC("sel"), "ㄙㄜˋ") + XCTAssertEqual(c.cS2RC("sh"), "ㄙㄞ") + XCTAssertEqual(c.cS2RC("shf"), "ㄙㄞˊ") + XCTAssertEqual(c.cS2RC("shj"), "ㄙㄞˇ") + XCTAssertEqual(c.cS2RC("shl"), "ㄙㄞˋ") + XCTAssertEqual(c.cS2RC("sk"), "ㄙㄟ") + XCTAssertEqual(c.cS2RC("sw"), "ㄙㄠ") + XCTAssertEqual(c.cS2RC("swj"), "ㄙㄠˇ") + XCTAssertEqual(c.cS2RC("swl"), "ㄙㄠˋ") + XCTAssertEqual(c.cS2RC("sv"), "ㄙㄡ") + XCTAssertEqual(c.cS2RC("svj"), "ㄙㄡˇ") + XCTAssertEqual(c.cS2RC("svl"), "ㄙㄡˋ") + XCTAssertEqual(c.cS2RC("sb"), "ㄙㄢ") + XCTAssertEqual(c.cS2RC("sbj"), "ㄙㄢˇ") + XCTAssertEqual(c.cS2RC("sbl"), "ㄙㄢˋ") + XCTAssertEqual(c.cS2RC("sn"), "ㄙㄣ") + XCTAssertEqual(c.cS2RC("snj"), "ㄙㄣˇ") + XCTAssertEqual(c.cS2RC("sg"), "ㄙㄤ") + XCTAssertEqual(c.cS2RC("sgj"), "ㄙㄤˇ") + XCTAssertEqual(c.cS2RC("sgl"), "ㄙㄤˋ") + XCTAssertEqual(c.cS2RC("sm"), "ㄙㄥ") + XCTAssertEqual(c.cS2RC("sml"), "ㄙㄥˋ") + XCTAssertEqual(c.cS2RC("su"), "ㄙㄨ") + XCTAssertEqual(c.cS2RC("suf"), "ㄙㄨˊ") + XCTAssertEqual(c.cS2RC("suj"), "ㄙㄨˇ") + XCTAssertEqual(c.cS2RC("sul"), "ㄙㄨˋ") + XCTAssertEqual(c.cS2RC("suo"), "ㄙㄨㄛ") + XCTAssertEqual(c.cS2RC("suof"), "ㄙㄨㄛˊ") + XCTAssertEqual(c.cS2RC("suoj"), "ㄙㄨㄛˇ") + XCTAssertEqual(c.cS2RC("suol"), "ㄙㄨㄛˋ") + XCTAssertEqual(c.cS2RC("suk"), "ㄙㄨㄟ") + XCTAssertEqual(c.cS2RC("sukf"), "ㄙㄨㄟˊ") + XCTAssertEqual(c.cS2RC("sukj"), "ㄙㄨㄟˇ") + XCTAssertEqual(c.cS2RC("sukl"), "ㄙㄨㄟˋ") + XCTAssertEqual(c.cS2RC("sub"), "ㄙㄨㄢ") + XCTAssertEqual(c.cS2RC("subj"), "ㄙㄨㄢˇ") + XCTAssertEqual(c.cS2RC("subl"), "ㄙㄨㄢˋ") + XCTAssertEqual(c.cS2RC("sun"), "ㄙㄨㄣ") + XCTAssertEqual(c.cS2RC("sunj"), "ㄙㄨㄣˇ") + XCTAssertEqual(c.cS2RC("sunl"), "ㄙㄨㄣˋ") + XCTAssertEqual(c.cS2RC("sum"), "ㄙㄨㄥ") + XCTAssertEqual(c.cS2RC("sumf"), "ㄙㄨㄥˊ") + XCTAssertEqual(c.cS2RC("sumj"), "ㄙㄨㄥˇ") + XCTAssertEqual(c.cS2RC("suml"), "ㄙㄨㄥˋ") + XCTAssertEqual(c.cS2RC("a"), "ㄚ") + XCTAssertEqual(c.cS2RC("af"), "ㄚˊ") + XCTAssertEqual(c.cS2RC("al"), "ㄚˋ") + XCTAssertEqual(c.cS2RC("ad"), "ㄚ˙") + XCTAssertEqual(c.cS2RC("o"), "ㄛ") + XCTAssertEqual(c.cS2RC("of"), "ㄛˊ") + XCTAssertEqual(c.cS2RC("oj"), "ㄛˇ") + XCTAssertEqual(c.cS2RC("ol"), "ㄛˋ") + XCTAssertEqual(c.cS2RC("e"), "ㄜ") + XCTAssertEqual(c.cS2RC("ef"), "ㄜˊ") + XCTAssertEqual(c.cS2RC("ej"), "ㄜˇ") + XCTAssertEqual(c.cS2RC("el"), "ㄜˋ") + // XCTAssertEqual(c.cS2RC("ef"), "ㄝˊ") + // XCTAssertEqual(c.cS2RC("ej"), "ㄝˇ") + // XCTAssertEqual(c.cS2RC("el"), "ㄝˋ") + // XCTAssertEqual(c.cS2RC("ed"), "ㄝ˙") + // XCTAssertEqual(c.cS2RC("h"), "ㄞ") + XCTAssertEqual(c.cS2RC("hf"), "ㄞˊ") + XCTAssertEqual(c.cS2RC("hj"), "ㄞˇ") + XCTAssertEqual(c.cS2RC("hl"), "ㄞˋ") + XCTAssertEqual(c.cS2RC("kl"), "ㄟˋ") + XCTAssertEqual(c.cS2RC("w"), "ㄠ") + XCTAssertEqual(c.cS2RC("wf"), "ㄠˊ") + XCTAssertEqual(c.cS2RC("wj"), "ㄠˇ") + XCTAssertEqual(c.cS2RC("wl"), "ㄠˋ") + XCTAssertEqual(c.cS2RC("v"), "ㄡ") + XCTAssertEqual(c.cS2RC("vf"), "ㄡˊ") + XCTAssertEqual(c.cS2RC("vj"), "ㄡˇ") + XCTAssertEqual(c.cS2RC("vl"), "ㄡˋ") + XCTAssertEqual(c.cS2RC("vd"), "ㄡ˙") + XCTAssertEqual(c.cS2RC("b "), "ㄢ ") + XCTAssertEqual(c.cS2RC("bf"), "ㄢˊ") + XCTAssertEqual(c.cS2RC("bj"), "ㄢˇ") + XCTAssertEqual(c.cS2RC("bl"), "ㄢˋ") + XCTAssertEqual(c.cS2RC("n "), "ㄣ ") + XCTAssertEqual(c.cS2RC("nf"), "ㄣˊ") + XCTAssertEqual(c.cS2RC("nj"), "ㄣˇ") + XCTAssertEqual(c.cS2RC("nl"), "ㄣˋ") + XCTAssertEqual(c.cS2RC("nd"), "ㄣ˙") + XCTAssertEqual(c.cS2RC("g "), "ㄤ ") + XCTAssertEqual(c.cS2RC("gf"), "ㄤˊ") + XCTAssertEqual(c.cS2RC("gj"), "ㄤˇ") + XCTAssertEqual(c.cS2RC("gl"), "ㄤˋ") + XCTAssertEqual(c.cS2RC("m "), "ㄥ ") + XCTAssertEqual(c.cS2RC("ml"), "ㄥˋ") + XCTAssertEqual(c.cS2RC("l "), "ㄦ ") + XCTAssertEqual(c.cS2RC("lf"), "ㄦˊ") + XCTAssertEqual(c.cS2RC("lj"), "ㄦˇ") + XCTAssertEqual(c.cS2RC("ll"), "ㄦˋ") + XCTAssertEqual(c.cS2RC("ld"), "ㄦ˙") + XCTAssertEqual(c.cS2RC("i"), "ㄧ") + XCTAssertEqual(c.cS2RC("if"), "ㄧˊ") + XCTAssertEqual(c.cS2RC("ij"), "ㄧˇ") + XCTAssertEqual(c.cS2RC("il"), "ㄧˋ") + XCTAssertEqual(c.cS2RC("ia"), "ㄧㄚ") + XCTAssertEqual(c.cS2RC("iaf"), "ㄧㄚˊ") + XCTAssertEqual(c.cS2RC("iaj"), "ㄧㄚˇ") + XCTAssertEqual(c.cS2RC("ial"), "ㄧㄚˋ") + XCTAssertEqual(c.cS2RC("iad"), "ㄧㄚ˙") + XCTAssertEqual(c.cS2RC("io"), "ㄧㄛ") + XCTAssertEqual(c.cS2RC("iod"), "ㄧㄛ˙") + XCTAssertEqual(c.cS2RC("ie"), "ㄧㄝ") + XCTAssertEqual(c.cS2RC("ief"), "ㄧㄝˊ") + XCTAssertEqual(c.cS2RC("iej"), "ㄧㄝˇ") + XCTAssertEqual(c.cS2RC("iel"), "ㄧㄝˋ") + XCTAssertEqual(c.cS2RC("ied"), "ㄧㄝ˙") + XCTAssertEqual(c.cS2RC("ihf"), "ㄧㄞˊ") + XCTAssertEqual(c.cS2RC("iw"), "ㄧㄠ") + XCTAssertEqual(c.cS2RC("iwf"), "ㄧㄠˊ") + XCTAssertEqual(c.cS2RC("iwj"), "ㄧㄠˇ") + XCTAssertEqual(c.cS2RC("iwl"), "ㄧㄠˋ") + XCTAssertEqual(c.cS2RC("iv"), "ㄧㄡ") + XCTAssertEqual(c.cS2RC("ivf"), "ㄧㄡˊ") + XCTAssertEqual(c.cS2RC("ivj"), "ㄧㄡˇ") + XCTAssertEqual(c.cS2RC("ivl"), "ㄧㄡˋ") + XCTAssertEqual(c.cS2RC("ib"), "ㄧㄢ") + XCTAssertEqual(c.cS2RC("ibf"), "ㄧㄢˊ") + XCTAssertEqual(c.cS2RC("ibj"), "ㄧㄢˇ") + XCTAssertEqual(c.cS2RC("ibl"), "ㄧㄢˋ") + XCTAssertEqual(c.cS2RC("in"), "ㄧㄣ") + XCTAssertEqual(c.cS2RC("inf"), "ㄧㄣˊ") + XCTAssertEqual(c.cS2RC("inj"), "ㄧㄣˇ") + XCTAssertEqual(c.cS2RC("inl"), "ㄧㄣˋ") + XCTAssertEqual(c.cS2RC("ig"), "ㄧㄤ") + XCTAssertEqual(c.cS2RC("igf"), "ㄧㄤˊ") + XCTAssertEqual(c.cS2RC("igj"), "ㄧㄤˇ") + XCTAssertEqual(c.cS2RC("igl"), "ㄧㄤˋ") + XCTAssertEqual(c.cS2RC("im"), "ㄧㄥ") + XCTAssertEqual(c.cS2RC("imf"), "ㄧㄥˊ") + XCTAssertEqual(c.cS2RC("imj"), "ㄧㄥˇ") + XCTAssertEqual(c.cS2RC("iml"), "ㄧㄥˋ") + XCTAssertEqual(c.cS2RC("u"), "ㄨ") + XCTAssertEqual(c.cS2RC("uf"), "ㄨˊ") + XCTAssertEqual(c.cS2RC("uj"), "ㄨˇ") + XCTAssertEqual(c.cS2RC("ul"), "ㄨˋ") + XCTAssertEqual(c.cS2RC("ua"), "ㄨㄚ") + XCTAssertEqual(c.cS2RC("uaf"), "ㄨㄚˊ") + XCTAssertEqual(c.cS2RC("uaj"), "ㄨㄚˇ") + XCTAssertEqual(c.cS2RC("ual"), "ㄨㄚˋ") + XCTAssertEqual(c.cS2RC("uad"), "ㄨㄚ˙") + XCTAssertEqual(c.cS2RC("uo"), "ㄨㄛ") + XCTAssertEqual(c.cS2RC("uoj"), "ㄨㄛˇ") + XCTAssertEqual(c.cS2RC("uol"), "ㄨㄛˋ") + XCTAssertEqual(c.cS2RC("uh"), "ㄨㄞ") + XCTAssertEqual(c.cS2RC("uhj"), "ㄨㄞˇ") + XCTAssertEqual(c.cS2RC("uhl"), "ㄨㄞˋ") + XCTAssertEqual(c.cS2RC("uk"), "ㄨㄟ") + XCTAssertEqual(c.cS2RC("ukf"), "ㄨㄟˊ") + XCTAssertEqual(c.cS2RC("ukj"), "ㄨㄟˇ") + XCTAssertEqual(c.cS2RC("ukl"), "ㄨㄟˋ") + XCTAssertEqual(c.cS2RC("ub"), "ㄨㄢ") + XCTAssertEqual(c.cS2RC("ubf"), "ㄨㄢˊ") + XCTAssertEqual(c.cS2RC("ubj"), "ㄨㄢˇ") + XCTAssertEqual(c.cS2RC("ubl"), "ㄨㄢˋ") + XCTAssertEqual(c.cS2RC("un"), "ㄨㄣ") + XCTAssertEqual(c.cS2RC("unf"), "ㄨㄣˊ") + XCTAssertEqual(c.cS2RC("unj"), "ㄨㄣˇ") + XCTAssertEqual(c.cS2RC("unl"), "ㄨㄣˋ") + XCTAssertEqual(c.cS2RC("ug"), "ㄨㄤ") + XCTAssertEqual(c.cS2RC("ugf"), "ㄨㄤˊ") + XCTAssertEqual(c.cS2RC("ugj"), "ㄨㄤˇ") + XCTAssertEqual(c.cS2RC("ugl"), "ㄨㄤˋ") + XCTAssertEqual(c.cS2RC("um"), "ㄨㄥ") + XCTAssertEqual(c.cS2RC("umj"), "ㄨㄥˇ") + XCTAssertEqual(c.cS2RC("uml"), "ㄨㄥˋ") + XCTAssertEqual(c.cS2RC("y"), "ㄩ") + XCTAssertEqual(c.cS2RC("yf"), "ㄩˊ") + XCTAssertEqual(c.cS2RC("yj"), "ㄩˇ") + XCTAssertEqual(c.cS2RC("yl"), "ㄩˋ") + XCTAssertEqual(c.cS2RC("ye"), "ㄩㄝ") + XCTAssertEqual(c.cS2RC("yej"), "ㄩㄝˇ") + XCTAssertEqual(c.cS2RC("yel"), "ㄩㄝˋ") + XCTAssertEqual(c.cS2RC("yb"), "ㄩㄢ") + XCTAssertEqual(c.cS2RC("ybf"), "ㄩㄢˊ") + XCTAssertEqual(c.cS2RC("ybj"), "ㄩㄢˇ") + XCTAssertEqual(c.cS2RC("ybl"), "ㄩㄢˋ") + XCTAssertEqual(c.cS2RC("yn"), "ㄩㄣ") + XCTAssertEqual(c.cS2RC("ynf"), "ㄩㄣˊ") + XCTAssertEqual(c.cS2RC("ynj"), "ㄩㄣˇ") + XCTAssertEqual(c.cS2RC("ynl"), "ㄩㄣˋ") + XCTAssertEqual(c.cS2RC("ym"), "ㄩㄥ") + XCTAssertEqual(c.cS2RC("ymf"), "ㄩㄥˊ") + XCTAssertEqual(c.cS2RC("ymj"), "ㄩㄥˇ") + XCTAssertEqual(c.cS2RC("yml"), "ㄩㄥˋ") + } +} diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_D.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_D.swift new file mode 100644 index 00000000..fcdbd184 --- /dev/null +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_D.swift @@ -0,0 +1,88 @@ +// (c) 2022 and onwards The vChewing Project (MIT-NTL License). +// ==================== +// This code is released under the MIT license (SPDX-License-Identifier: MIT) +// ... with NTL restriction stating that: +// No trademark license is granted to use the trade names, trademarks, service +// marks, or product names of Contributor, except as required to fulfill notice +// requirements defined in MIT License. + +import XCTest + +@testable import Tekkon + +extension TekkonTestsKeyboardArrangments { + func testAlvinLiuKeysMicrosoftCompatible() throws { + var c = Tekkon.Composer(arrange: .ofAlvinLiu) + XCTAssertEqual(c.cS2RC("bic"), "ㄅㄧㄝ") + XCTAssertEqual(c.cS2RC("bicf"), "ㄅㄧㄝˊ") + XCTAssertEqual(c.cS2RC("bicj"), "ㄅㄧㄝˇ") + XCTAssertEqual(c.cS2RC("bicl"), "ㄅㄧㄝˋ") + XCTAssertEqual(c.cS2RC("pic"), "ㄆㄧㄝ") + XCTAssertEqual(c.cS2RC("picj"), "ㄆㄧㄝˇ") + XCTAssertEqual(c.cS2RC("picl"), "ㄆㄧㄝˋ") + XCTAssertEqual(c.cS2RC("mic"), "ㄇㄧㄝ") + XCTAssertEqual(c.cS2RC("micf"), "ㄇㄧㄝˊ") + XCTAssertEqual(c.cS2RC("micl"), "ㄇㄧㄝˋ") + XCTAssertEqual(c.cS2RC("dic"), "ㄉㄧㄝ") + XCTAssertEqual(c.cS2RC("dicf"), "ㄉㄧㄝˊ") + XCTAssertEqual(c.cS2RC("dicj"), "ㄉㄧㄝˇ") + XCTAssertEqual(c.cS2RC("dicl"), "ㄉㄧㄝˋ") + XCTAssertEqual(c.cS2RC("tic"), "ㄊㄧㄝ") + XCTAssertEqual(c.cS2RC("ticf"), "ㄊㄧㄝˊ") + XCTAssertEqual(c.cS2RC("ticj"), "ㄊㄧㄝˇ") + XCTAssertEqual(c.cS2RC("ticl"), "ㄊㄧㄝˋ") + XCTAssertEqual(c.cS2RC("nic"), "ㄋㄧㄝ") + XCTAssertEqual(c.cS2RC("nicf"), "ㄋㄧㄝˊ") + XCTAssertEqual(c.cS2RC("nicl"), "ㄋㄧㄝˋ") + XCTAssertEqual(c.cS2RC("nycl"), "ㄋㄩㄝˋ") + XCTAssertEqual(c.cS2RC("lic"), "ㄌㄧㄝ") + XCTAssertEqual(c.cS2RC("licf"), "ㄌㄧㄝˊ") + XCTAssertEqual(c.cS2RC("licj"), "ㄌㄧㄝˇ") + XCTAssertEqual(c.cS2RC("licl"), "ㄌㄧㄝˋ") + XCTAssertEqual(c.cS2RC("lyc"), "ㄌㄩㄝ") + XCTAssertEqual(c.cS2RC("lycj"), "ㄌㄩㄝˇ") + XCTAssertEqual(c.cS2RC("lycl"), "ㄌㄩㄝˋ") + XCTAssertEqual(c.cS2RC("jic"), "ㄐㄧㄝ") + XCTAssertEqual(c.cS2RC("jicf"), "ㄐㄧㄝˊ") + XCTAssertEqual(c.cS2RC("jicj"), "ㄐㄧㄝˇ") + XCTAssertEqual(c.cS2RC("jicl"), "ㄐㄧㄝˋ") + XCTAssertEqual(c.cS2RC("jicd"), "ㄐㄧㄝ˙") + XCTAssertEqual(c.cS2RC("jyc"), "ㄐㄩㄝ") + XCTAssertEqual(c.cS2RC("jycf"), "ㄐㄩㄝˊ") + XCTAssertEqual(c.cS2RC("jycj"), "ㄐㄩㄝˇ") + XCTAssertEqual(c.cS2RC("jycl"), "ㄐㄩㄝˋ") + XCTAssertEqual(c.cS2RC("qic"), "ㄑㄧㄝ") + XCTAssertEqual(c.cS2RC("qicf"), "ㄑㄧㄝˊ") + XCTAssertEqual(c.cS2RC("qicj"), "ㄑㄧㄝˇ") + XCTAssertEqual(c.cS2RC("qicl"), "ㄑㄧㄝˋ") + XCTAssertEqual(c.cS2RC("qyc"), "ㄑㄩㄝ") + XCTAssertEqual(c.cS2RC("qycf"), "ㄑㄩㄝˊ") + XCTAssertEqual(c.cS2RC("qycl"), "ㄑㄩㄝˋ") + XCTAssertEqual(c.cS2RC("xic"), "ㄒㄧㄝ") + XCTAssertEqual(c.cS2RC("xicf"), "ㄒㄧㄝˊ") + XCTAssertEqual(c.cS2RC("xicj"), "ㄒㄧㄝˇ") + XCTAssertEqual(c.cS2RC("xicl"), "ㄒㄧㄝˋ") + XCTAssertEqual(c.cS2RC("xyc"), "ㄒㄩㄝ") + XCTAssertEqual(c.cS2RC("xycf"), "ㄒㄩㄝˊ") + XCTAssertEqual(c.cS2RC("xycj"), "ㄒㄩㄝˇ") + XCTAssertEqual(c.cS2RC("xycl"), "ㄒㄩㄝˋ") + // XCTAssertEqual(c.cS2RC("cf"), "ㄝˊ") + // XCTAssertEqual(c.cS2RC("cj"), "ㄝˇ") + // XCTAssertEqual(c.cS2RC("cl"), "ㄝˋ") + // XCTAssertEqual(c.cS2RC("cd"), "ㄝ˙") + XCTAssertEqual(c.cS2RC("h "), "ㄞ ") + XCTAssertEqual(c.cS2RC("t "), "ㄦ ") + XCTAssertEqual(c.cS2RC("tf"), "ㄦˊ") + XCTAssertEqual(c.cS2RC("tj"), "ㄦˇ") + XCTAssertEqual(c.cS2RC("tl"), "ㄦˋ") + XCTAssertEqual(c.cS2RC("td"), "ㄦ˙") + XCTAssertEqual(c.cS2RC("ic"), "ㄧㄝ") + XCTAssertEqual(c.cS2RC("icf"), "ㄧㄝˊ") + XCTAssertEqual(c.cS2RC("icj"), "ㄧㄝˇ") + XCTAssertEqual(c.cS2RC("icl"), "ㄧㄝˋ") + XCTAssertEqual(c.cS2RC("icd"), "ㄧㄝ˙") + XCTAssertEqual(c.cS2RC("yc"), "ㄩㄝ") + XCTAssertEqual(c.cS2RC("ycj"), "ㄩㄝˇ") + XCTAssertEqual(c.cS2RC("ycl"), "ㄩㄝˋ") + } +} diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Basic_DachenTrad.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Basic_DachenTrad.swift index 9e8cf7ae..8e4df47a 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Basic_DachenTrad.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Basic_DachenTrad.swift @@ -13,20 +13,28 @@ import XCTest final class TekkonTestsKeyboardArrangments: XCTestCase { func testQwertyDachenKeys() throws { // Testing Dachen Traditional Mapping (QWERTY) - var composer = Tekkon.Composer(arrange: .ofDachen) - XCTAssertEqual(composer.convertSequenceToRawComposition("18 "), "ㄅㄚ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("m,4"), "ㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("5j/ "), "ㄓㄨㄥ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fu."), "ㄑㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("g0 "), "ㄕㄢ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xup6"), "ㄌㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xu;6"), "ㄌㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("z/"), "ㄈㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjo "), "ㄔㄨㄟ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("284"), "ㄉㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("2u4"), "ㄉㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hl3"), "ㄘㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("5 "), "ㄓ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("193"), "ㄅㄞˇ") + var c = Tekkon.Composer(arrange: .ofDachen) + XCTAssertEqual(c.cS2RC("18 "), "ㄅㄚ ") + XCTAssertEqual(c.cS2RC("m,4"), "ㄩㄝˋ") + XCTAssertEqual(c.cS2RC("5j/ "), "ㄓㄨㄥ ") + XCTAssertEqual(c.cS2RC("fu."), "ㄑㄧㄡ") + XCTAssertEqual(c.cS2RC("g0 "), "ㄕㄢ ") + XCTAssertEqual(c.cS2RC("xup6"), "ㄌㄧㄣˊ") + XCTAssertEqual(c.cS2RC("xu;6"), "ㄌㄧㄤˊ") + XCTAssertEqual(c.cS2RC("z/"), "ㄈㄥ") + XCTAssertEqual(c.cS2RC("tjo "), "ㄔㄨㄟ ") + XCTAssertEqual(c.cS2RC("284"), "ㄉㄚˋ") + XCTAssertEqual(c.cS2RC("2u4"), "ㄉㄧˋ") + XCTAssertEqual(c.cS2RC("hl3"), "ㄘㄠˇ") + XCTAssertEqual(c.cS2RC("5 "), "ㄓ ") + XCTAssertEqual(c.cS2RC("193"), "ㄅㄞˇ") + } +} + +internal extension Tekkon.Composer { + // Exactly "convertSequenceToRawComposition()" but with shorter symbol name. + mutating func cS2RC(_ givenSequence: String = "") -> String { + receiveSequence(givenSequence) + return value } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_A.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_A.swift index 111236ad..8d9e4227 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_A.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_A.swift @@ -11,492 +11,496 @@ import XCTest @testable import Tekkon extension TekkonTestsKeyboardArrangments { + func testDachen26KeysTaigi() throws { + var c = Tekkon.Composer(arrange: .ofDachen26) + XCTAssertEqual(c.cS2RC("dull"), "ㄎㄧㄤ") + XCTAssertEqual(c.cS2RC("eule"), "ㄍㄧㄠˊ") + XCTAssertEqual(c.cS2RC("eup"), "ㄍㄧㄣ") + } + func testDachen26KeysA() throws { - var composer = Tekkon.Composer(arrange: .ofDachen26) - XCTAssertEqual(composer.convertSequenceToRawComposition("dull"), "ㄎㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eule"), "ㄍㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eup"), "ㄍㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqulle"), "ㄅㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqulld"), "ㄅㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjll"), "ㄉㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qquu"), "ㄅㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qquue"), "ㄅㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qquur"), "ㄅㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qquud"), "ㄅㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qquuy"), "ㄅㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqi"), "ㄅㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqie"), "ㄅㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqir"), "ㄅㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqid"), "ㄅㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqiy"), "ㄅㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqii"), "ㄅㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqiie"), "ㄅㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqiir"), "ㄅㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqiid"), "ㄅㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqiiy"), "ㄅㄞ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqo"), "ㄅㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqor"), "ㄅㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqod"), "ㄅㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqoy"), "ㄅㄟ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("qql"), "ㄅㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqle"), "ㄅㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqlr"), "ㄅㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqld"), "ㄅㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqoo"), "ㄅㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqoor"), "ㄅㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqood"), "ㄅㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqp"), "ㄅㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqpr"), "ㄅㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqpd"), "ㄅㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqll"), "ㄅㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqllr"), "ㄅㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqlld"), "ㄅㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqn"), "ㄅㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqne"), "ㄅㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqnr"), "ㄅㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqnd"), "ㄅㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqu"), "ㄅㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qque"), "ㄅㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqur"), "ㄅㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqud"), "ㄅㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqub"), "ㄅㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqube"), "ㄅㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqubr"), "ㄅㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqubd"), "ㄅㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqul"), "ㄅㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqulr"), "ㄅㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qquld"), "ㄅㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qquoo"), "ㄅㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qquooe"), "ㄅㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qquoor"), "ㄅㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qquood"), "ㄅㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqup"), "ㄅㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqupr"), "ㄅㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqupd"), "ㄅㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqun"), "ㄅㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqunr"), "ㄅㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqund"), "ㄅㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqj"), "ㄅㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqje"), "ㄅㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqjr"), "ㄅㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqjd"), "ㄅㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quu"), "ㄆㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quue"), "ㄆㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quur"), "ㄆㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quud"), "ㄆㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quuy"), "ㄆㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("qi"), "ㄆㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qie"), "ㄆㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qir"), "ㄆㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qid"), "ㄆㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qii"), "ㄆㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qiie"), "ㄆㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qiir"), "ㄆㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qiid"), "ㄆㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qo"), "ㄆㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qoe"), "ㄆㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qor"), "ㄆㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qod"), "ㄆㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ql"), "ㄆㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qle"), "ㄆㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qlr"), "ㄆㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qld"), "ㄆㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qm"), "ㄆㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qme"), "ㄆㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qmr"), "ㄆㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qmd"), "ㄆㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qoo"), "ㄆㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qooe"), "ㄆㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qoor"), "ㄆㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qood"), "ㄆㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qp"), "ㄆㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qpe"), "ㄆㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qpr"), "ㄆㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qpd"), "ㄆㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qll"), "ㄆㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qlle"), "ㄆㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qllr"), "ㄆㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qlld"), "ㄆㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qn"), "ㄆㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qne"), "ㄆㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qnr"), "ㄆㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qnd"), "ㄆㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qu"), "ㄆㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("que"), "ㄆㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qur"), "ㄆㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qud"), "ㄆㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quuu"), "ㄆㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qub"), "ㄆㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qubr"), "ㄆㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qubd"), "ㄆㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qul"), "ㄆㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qule"), "ㄆㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qulr"), "ㄆㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quld"), "ㄆㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quoo"), "ㄆㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quooe"), "ㄆㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quoor"), "ㄆㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quood"), "ㄆㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qup"), "ㄆㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qupe"), "ㄆㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qupr"), "ㄆㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qupd"), "ㄆㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qun"), "ㄆㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qune"), "ㄆㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qunr"), "ㄆㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qund"), "ㄆㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qj"), "ㄆㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qje"), "ㄆㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qjr"), "ㄆㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qjd"), "ㄆㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("auu"), "ㄇㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("auue"), "ㄇㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("auur"), "ㄇㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("auud"), "ㄇㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("auuy"), "ㄇㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ai"), "ㄇㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aie"), "ㄇㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("air"), "ㄇㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aid"), "ㄇㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aiy"), "ㄇㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ak"), "ㄇㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("akd"), "ㄇㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aky"), "ㄇㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("aii"), "ㄇㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aiie"), "ㄇㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aiir"), "ㄇㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aiid"), "ㄇㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aoe"), "ㄇㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aor"), "ㄇㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aod"), "ㄇㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("al"), "ㄇㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ale"), "ㄇㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("alr"), "ㄇㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ald"), "ㄇㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ame"), "ㄇㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("amr"), "ㄇㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("amd"), "ㄇㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aoo"), "ㄇㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aooe"), "ㄇㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aoor"), "ㄇㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aood"), "ㄇㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ap"), "ㄇㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ape"), "ㄇㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("apr"), "ㄇㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("apd"), "ㄇㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("apy"), "ㄇㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("all"), "ㄇㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("alle"), "ㄇㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("allr"), "ㄇㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("alld"), "ㄇㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("an"), "ㄇㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ane"), "ㄇㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("anr"), "ㄇㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("and"), "ㄇㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("au"), "ㄇㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aue"), "ㄇㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aur"), "ㄇㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aud"), "ㄇㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aub"), "ㄇㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aube"), "ㄇㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aubd"), "ㄇㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aul"), "ㄇㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aule"), "ㄇㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aulr"), "ㄇㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("auld"), "ㄇㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aume"), "ㄇㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aumr"), "ㄇㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aumd"), "ㄇㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("auoo"), "ㄇㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("auooe"), "ㄇㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("auoor"), "ㄇㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("auood"), "ㄇㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aup"), "ㄇㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aupe"), "ㄇㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aupr"), "ㄇㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aune"), "ㄇㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aunr"), "ㄇㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aund"), "ㄇㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aje"), "ㄇㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ajr"), "ㄇㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ajd"), "ㄇㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zuu"), "ㄈㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zuue"), "ㄈㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zuur"), "ㄈㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zuud"), "ㄈㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zie"), "ㄈㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zo"), "ㄈㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zoe"), "ㄈㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zor"), "ㄈㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zod"), "ㄈㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zm"), "ㄈㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zme"), "ㄈㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zmr"), "ㄈㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zmd"), "ㄈㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zoo"), "ㄈㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zooe"), "ㄈㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zoor"), "ㄈㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zood"), "ㄈㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zp"), "ㄈㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zpe"), "ㄈㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zpr"), "ㄈㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zpd"), "ㄈㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zpy"), "ㄈㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("zll"), "ㄈㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zlle"), "ㄈㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zllr"), "ㄈㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zlld"), "ㄈㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zn"), "ㄈㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zne"), "ㄈㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("znr"), "ㄈㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("znd"), "ㄈㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zuld"), "ㄈㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zj"), "ㄈㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zje"), "ㄈㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zjr"), "ㄈㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zjd"), "ㄈㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwuu"), "ㄉㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwuue"), "ㄉㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwuur"), "ㄉㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwuud"), "ㄉㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwuuy"), "ㄉㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwk"), "ㄉㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwke"), "ㄉㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwky"), "ㄉㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwii"), "ㄉㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwiir"), "ㄉㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwiid"), "ㄉㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwor"), "ㄉㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwl"), "ㄉㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwle"), "ㄉㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwlr"), "ㄉㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwld"), "ㄉㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwm"), "ㄉㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwme"), "ㄉㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwmr"), "ㄉㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwmd"), "ㄉㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwoo"), "ㄉㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwoor"), "ㄉㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwood"), "ㄉㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwpd"), "ㄉㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwll"), "ㄉㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwllr"), "ㄉㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwlld"), "ㄉㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwn"), "ㄉㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwnr"), "ㄉㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwnd"), "ㄉㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwu"), "ㄉㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwue"), "ㄉㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwur"), "ㄉㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwud"), "ㄉㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwuuur"), "ㄉㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwub"), "ㄉㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwube"), "ㄉㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwubr"), "ㄉㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwubd"), "ㄉㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwul"), "ㄉㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwulr"), "ㄉㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwuld"), "ㄉㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwum"), "ㄉㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwuoo"), "ㄉㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwuooe"), "ㄉㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwuoor"), "ㄉㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwuood"), "ㄉㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwun"), "ㄉㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwune"), "ㄉㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwunr"), "ㄉㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwund"), "ㄉㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwj"), "ㄉㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwje"), "ㄉㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjr"), "ㄉㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjd"), "ㄉㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwji"), "ㄉㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjie"), "ㄉㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjir"), "ㄉㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjid"), "ㄉㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjiy"), "ㄉㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjo"), "ㄉㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjor"), "ㄉㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjod"), "ㄉㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjoo"), "ㄉㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjoor"), "ㄉㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjood"), "ㄉㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjp"), "ㄉㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjpr"), "ㄉㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjpd"), "ㄉㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjn"), "ㄉㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjnr"), "ㄉㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wwjnd"), "ㄉㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wuu"), "ㄊㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wuur"), "ㄊㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wuud"), "ㄊㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wkd"), "ㄊㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wii"), "ㄊㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wiie"), "ㄊㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wiir"), "ㄊㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wiid"), "ㄊㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wiiy"), "ㄊㄞ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("wl"), "ㄊㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wle"), "ㄊㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wlr"), "ㄊㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wld"), "ㄊㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wly"), "ㄊㄠ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("wm"), "ㄊㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wme"), "ㄊㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wmr"), "ㄊㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wmd"), "ㄊㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wmy"), "ㄊㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("woo"), "ㄊㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wooe"), "ㄊㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("woor"), "ㄊㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wood"), "ㄊㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wll"), "ㄊㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wlle"), "ㄊㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wllr"), "ㄊㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wlld"), "ㄊㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wn"), "ㄊㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wne"), "ㄊㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wnd"), "ㄊㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wu"), "ㄊㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wue"), "ㄊㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wur"), "ㄊㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wud"), "ㄊㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wub"), "ㄊㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wube"), "ㄊㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wubr"), "ㄊㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wubd"), "ㄊㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wul"), "ㄊㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wule"), "ㄊㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wulr"), "ㄊㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wuld"), "ㄊㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wuoo"), "ㄊㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wuooe"), "ㄊㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wuoor"), "ㄊㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wuood"), "ㄊㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wun"), "ㄊㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wune"), "ㄊㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wunr"), "ㄊㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wund"), "ㄊㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wj"), "ㄊㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wje"), "ㄊㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjr"), "ㄊㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjd"), "ㄊㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wji"), "ㄊㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjie"), "ㄊㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjir"), "ㄊㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjid"), "ㄊㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjo"), "ㄊㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjoe"), "ㄊㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjor"), "ㄊㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjod"), "ㄊㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjoo"), "ㄊㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjooe"), "ㄊㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjoor"), "ㄊㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjood"), "ㄊㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjp"), "ㄊㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjpe"), "ㄊㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjpr"), "ㄊㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjpd"), "ㄊㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjn"), "ㄊㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjne"), "ㄊㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjnr"), "ㄊㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wjnd"), "ㄊㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suu"), "ㄋㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suue"), "ㄋㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suur"), "ㄋㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suud"), "ㄋㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suuy"), "ㄋㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("skd"), "ㄋㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sky"), "ㄋㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("siie"), "ㄋㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("siir"), "ㄋㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("siid"), "ㄋㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("soe"), "ㄋㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sor"), "ㄋㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sod"), "ㄋㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sl"), "ㄋㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sle"), "ㄋㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("slr"), "ㄋㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sld"), "ㄋㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sme"), "ㄋㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("smr"), "ㄋㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("smd"), "ㄋㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("soo"), "ㄋㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sooe"), "ㄋㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("soor"), "ㄋㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sood"), "ㄋㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("spr"), "ㄋㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("spd"), "ㄋㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sll"), "ㄋㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("slle"), "ㄋㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sllr"), "ㄋㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("slld"), "ㄋㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("slly"), "ㄋㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("sne"), "ㄋㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("snr"), "ㄋㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("su"), "ㄋㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sue"), "ㄋㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sur"), "ㄋㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sud"), "ㄋㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sub"), "ㄋㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sube"), "ㄋㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("subd"), "ㄋㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sulr"), "ㄋㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suld"), "ㄋㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sum"), "ㄋㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sume"), "ㄋㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sumr"), "ㄋㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sumd"), "ㄋㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suoo"), "ㄋㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suooe"), "ㄋㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suoor"), "ㄋㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suood"), "ㄋㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sup"), "ㄋㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("supe"), "ㄋㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("supr"), "ㄋㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("supd"), "ㄋㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sulle"), "ㄋㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sullr"), "ㄋㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sulld"), "ㄋㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sune"), "ㄋㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sunr"), "ㄋㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sund"), "ㄋㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sje"), "ㄋㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjr"), "ㄋㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjd"), "ㄋㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjie"), "ㄋㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjir"), "ㄋㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjid"), "ㄋㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjoe"), "ㄋㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjooe"), "ㄋㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjoor"), "ㄋㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjood"), "ㄋㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjpe"), "ㄋㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjne"), "ㄋㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjnr"), "ㄋㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sjnd"), "ㄋㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("smme"), "ㄋㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("smmr"), "ㄋㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("smmd"), "ㄋㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("smmbd"), "ㄋㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuu"), "ㄌㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuue"), "ㄌㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuur"), "ㄌㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuud"), "ㄌㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuuy"), "ㄌㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("xi"), "ㄌㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xiy"), "ㄌㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("xk"), "ㄌㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xke"), "ㄌㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xkd"), "ㄌㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xky"), "ㄌㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("xiie"), "ㄌㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xiir"), "ㄌㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xiid"), "ㄌㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xo"), "ㄌㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xoe"), "ㄌㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xor"), "ㄌㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xod"), "ㄌㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xoy"), "ㄌㄟ˙") + var c = Tekkon.Composer(arrange: .ofDachen26) + XCTAssertEqual(c.cS2RC("qqulle"), "ㄅㄧㄤˊ") + XCTAssertEqual(c.cS2RC("qqulld"), "ㄅㄧㄤˋ") + XCTAssertEqual(c.cS2RC("wwjll"), "ㄉㄨㄤ") + XCTAssertEqual(c.cS2RC("qquu"), "ㄅㄚ") + XCTAssertEqual(c.cS2RC("qquue"), "ㄅㄚˊ") + XCTAssertEqual(c.cS2RC("qquur"), "ㄅㄚˇ") + XCTAssertEqual(c.cS2RC("qquud"), "ㄅㄚˋ") + XCTAssertEqual(c.cS2RC("qquuy"), "ㄅㄚ˙") + XCTAssertEqual(c.cS2RC("qqi"), "ㄅㄛ") + XCTAssertEqual(c.cS2RC("qqie"), "ㄅㄛˊ") + XCTAssertEqual(c.cS2RC("qqir"), "ㄅㄛˇ") + XCTAssertEqual(c.cS2RC("qqid"), "ㄅㄛˋ") + XCTAssertEqual(c.cS2RC("qqiy"), "ㄅㄛ˙") + XCTAssertEqual(c.cS2RC("qqii"), "ㄅㄞ") + XCTAssertEqual(c.cS2RC("qqiie"), "ㄅㄞˊ") + XCTAssertEqual(c.cS2RC("qqiir"), "ㄅㄞˇ") + XCTAssertEqual(c.cS2RC("qqiid"), "ㄅㄞˋ") + XCTAssertEqual(c.cS2RC("qqiiy"), "ㄅㄞ˙") + XCTAssertEqual(c.cS2RC("qqo"), "ㄅㄟ") + XCTAssertEqual(c.cS2RC("qqor"), "ㄅㄟˇ") + XCTAssertEqual(c.cS2RC("qqod"), "ㄅㄟˋ") + XCTAssertEqual(c.cS2RC("qqoy"), "ㄅㄟ˙") + XCTAssertEqual(c.cS2RC("qql"), "ㄅㄠ") + XCTAssertEqual(c.cS2RC("qqle"), "ㄅㄠˊ") + XCTAssertEqual(c.cS2RC("qqlr"), "ㄅㄠˇ") + XCTAssertEqual(c.cS2RC("qqld"), "ㄅㄠˋ") + XCTAssertEqual(c.cS2RC("qqoo"), "ㄅㄢ") + XCTAssertEqual(c.cS2RC("qqoor"), "ㄅㄢˇ") + XCTAssertEqual(c.cS2RC("qqood"), "ㄅㄢˋ") + XCTAssertEqual(c.cS2RC("qqp"), "ㄅㄣ") + XCTAssertEqual(c.cS2RC("qqpr"), "ㄅㄣˇ") + XCTAssertEqual(c.cS2RC("qqpd"), "ㄅㄣˋ") + XCTAssertEqual(c.cS2RC("qqll"), "ㄅㄤ") + XCTAssertEqual(c.cS2RC("qqllr"), "ㄅㄤˇ") + XCTAssertEqual(c.cS2RC("qqlld"), "ㄅㄤˋ") + XCTAssertEqual(c.cS2RC("qqn"), "ㄅㄥ") + XCTAssertEqual(c.cS2RC("qqne"), "ㄅㄥˊ") + XCTAssertEqual(c.cS2RC("qqnr"), "ㄅㄥˇ") + XCTAssertEqual(c.cS2RC("qqnd"), "ㄅㄥˋ") + XCTAssertEqual(c.cS2RC("qqu"), "ㄅㄧ") + XCTAssertEqual(c.cS2RC("qque"), "ㄅㄧˊ") + XCTAssertEqual(c.cS2RC("qqur"), "ㄅㄧˇ") + XCTAssertEqual(c.cS2RC("qqud"), "ㄅㄧˋ") + XCTAssertEqual(c.cS2RC("qqub"), "ㄅㄧㄝ") + XCTAssertEqual(c.cS2RC("qqube"), "ㄅㄧㄝˊ") + XCTAssertEqual(c.cS2RC("qqubr"), "ㄅㄧㄝˇ") + XCTAssertEqual(c.cS2RC("qqubd"), "ㄅㄧㄝˋ") + XCTAssertEqual(c.cS2RC("qqul"), "ㄅㄧㄠ") + XCTAssertEqual(c.cS2RC("qqulr"), "ㄅㄧㄠˇ") + XCTAssertEqual(c.cS2RC("qquld"), "ㄅㄧㄠˋ") + XCTAssertEqual(c.cS2RC("qquoo"), "ㄅㄧㄢ") + XCTAssertEqual(c.cS2RC("qquooe"), "ㄅㄧㄢˊ") + XCTAssertEqual(c.cS2RC("qquoor"), "ㄅㄧㄢˇ") + XCTAssertEqual(c.cS2RC("qquood"), "ㄅㄧㄢˋ") + XCTAssertEqual(c.cS2RC("qqup"), "ㄅㄧㄣ") + XCTAssertEqual(c.cS2RC("qqupr"), "ㄅㄧㄣˇ") + XCTAssertEqual(c.cS2RC("qqupd"), "ㄅㄧㄣˋ") + XCTAssertEqual(c.cS2RC("qqun"), "ㄅㄧㄥ") + XCTAssertEqual(c.cS2RC("qqunr"), "ㄅㄧㄥˇ") + XCTAssertEqual(c.cS2RC("qqund"), "ㄅㄧㄥˋ") + XCTAssertEqual(c.cS2RC("qqj"), "ㄅㄨ") + XCTAssertEqual(c.cS2RC("qqje"), "ㄅㄨˊ") + XCTAssertEqual(c.cS2RC("qqjr"), "ㄅㄨˇ") + XCTAssertEqual(c.cS2RC("qqjd"), "ㄅㄨˋ") + XCTAssertEqual(c.cS2RC("quu"), "ㄆㄚ") + XCTAssertEqual(c.cS2RC("quue"), "ㄆㄚˊ") + XCTAssertEqual(c.cS2RC("quur"), "ㄆㄚˇ") + XCTAssertEqual(c.cS2RC("quud"), "ㄆㄚˋ") + XCTAssertEqual(c.cS2RC("quuy"), "ㄆㄚ˙") + XCTAssertEqual(c.cS2RC("qi"), "ㄆㄛ") + XCTAssertEqual(c.cS2RC("qie"), "ㄆㄛˊ") + XCTAssertEqual(c.cS2RC("qir"), "ㄆㄛˇ") + XCTAssertEqual(c.cS2RC("qid"), "ㄆㄛˋ") + XCTAssertEqual(c.cS2RC("qii"), "ㄆㄞ") + XCTAssertEqual(c.cS2RC("qiie"), "ㄆㄞˊ") + XCTAssertEqual(c.cS2RC("qiir"), "ㄆㄞˇ") + XCTAssertEqual(c.cS2RC("qiid"), "ㄆㄞˋ") + XCTAssertEqual(c.cS2RC("qo"), "ㄆㄟ") + XCTAssertEqual(c.cS2RC("qoe"), "ㄆㄟˊ") + XCTAssertEqual(c.cS2RC("qor"), "ㄆㄟˇ") + XCTAssertEqual(c.cS2RC("qod"), "ㄆㄟˋ") + XCTAssertEqual(c.cS2RC("ql"), "ㄆㄠ") + XCTAssertEqual(c.cS2RC("qle"), "ㄆㄠˊ") + XCTAssertEqual(c.cS2RC("qlr"), "ㄆㄠˇ") + XCTAssertEqual(c.cS2RC("qld"), "ㄆㄠˋ") + XCTAssertEqual(c.cS2RC("qm"), "ㄆㄡ") + XCTAssertEqual(c.cS2RC("qme"), "ㄆㄡˊ") + XCTAssertEqual(c.cS2RC("qmr"), "ㄆㄡˇ") + XCTAssertEqual(c.cS2RC("qmd"), "ㄆㄡˋ") + XCTAssertEqual(c.cS2RC("qoo"), "ㄆㄢ") + XCTAssertEqual(c.cS2RC("qooe"), "ㄆㄢˊ") + XCTAssertEqual(c.cS2RC("qoor"), "ㄆㄢˇ") + XCTAssertEqual(c.cS2RC("qood"), "ㄆㄢˋ") + XCTAssertEqual(c.cS2RC("qp"), "ㄆㄣ") + XCTAssertEqual(c.cS2RC("qpe"), "ㄆㄣˊ") + XCTAssertEqual(c.cS2RC("qpr"), "ㄆㄣˇ") + XCTAssertEqual(c.cS2RC("qpd"), "ㄆㄣˋ") + XCTAssertEqual(c.cS2RC("qll"), "ㄆㄤ") + XCTAssertEqual(c.cS2RC("qlle"), "ㄆㄤˊ") + XCTAssertEqual(c.cS2RC("qllr"), "ㄆㄤˇ") + XCTAssertEqual(c.cS2RC("qlld"), "ㄆㄤˋ") + XCTAssertEqual(c.cS2RC("qn"), "ㄆㄥ") + XCTAssertEqual(c.cS2RC("qne"), "ㄆㄥˊ") + XCTAssertEqual(c.cS2RC("qnr"), "ㄆㄥˇ") + XCTAssertEqual(c.cS2RC("qnd"), "ㄆㄥˋ") + XCTAssertEqual(c.cS2RC("qu"), "ㄆㄧ") + XCTAssertEqual(c.cS2RC("que"), "ㄆㄧˊ") + XCTAssertEqual(c.cS2RC("qur"), "ㄆㄧˇ") + XCTAssertEqual(c.cS2RC("qud"), "ㄆㄧˋ") + XCTAssertEqual(c.cS2RC("quuu"), "ㄆㄧㄚ") + XCTAssertEqual(c.cS2RC("qub"), "ㄆㄧㄝ") + XCTAssertEqual(c.cS2RC("qubr"), "ㄆㄧㄝˇ") + XCTAssertEqual(c.cS2RC("qubd"), "ㄆㄧㄝˋ") + XCTAssertEqual(c.cS2RC("qul"), "ㄆㄧㄠ") + XCTAssertEqual(c.cS2RC("qule"), "ㄆㄧㄠˊ") + XCTAssertEqual(c.cS2RC("qulr"), "ㄆㄧㄠˇ") + XCTAssertEqual(c.cS2RC("quld"), "ㄆㄧㄠˋ") + XCTAssertEqual(c.cS2RC("quoo"), "ㄆㄧㄢ") + XCTAssertEqual(c.cS2RC("quooe"), "ㄆㄧㄢˊ") + XCTAssertEqual(c.cS2RC("quoor"), "ㄆㄧㄢˇ") + XCTAssertEqual(c.cS2RC("quood"), "ㄆㄧㄢˋ") + XCTAssertEqual(c.cS2RC("qup"), "ㄆㄧㄣ") + XCTAssertEqual(c.cS2RC("qupe"), "ㄆㄧㄣˊ") + XCTAssertEqual(c.cS2RC("qupr"), "ㄆㄧㄣˇ") + XCTAssertEqual(c.cS2RC("qupd"), "ㄆㄧㄣˋ") + XCTAssertEqual(c.cS2RC("qun"), "ㄆㄧㄥ") + XCTAssertEqual(c.cS2RC("qune"), "ㄆㄧㄥˊ") + XCTAssertEqual(c.cS2RC("qunr"), "ㄆㄧㄥˇ") + XCTAssertEqual(c.cS2RC("qund"), "ㄆㄧㄥˋ") + XCTAssertEqual(c.cS2RC("qj"), "ㄆㄨ") + XCTAssertEqual(c.cS2RC("qje"), "ㄆㄨˊ") + XCTAssertEqual(c.cS2RC("qjr"), "ㄆㄨˇ") + XCTAssertEqual(c.cS2RC("qjd"), "ㄆㄨˋ") + XCTAssertEqual(c.cS2RC("auu"), "ㄇㄚ") + XCTAssertEqual(c.cS2RC("auue"), "ㄇㄚˊ") + XCTAssertEqual(c.cS2RC("auur"), "ㄇㄚˇ") + XCTAssertEqual(c.cS2RC("auud"), "ㄇㄚˋ") + XCTAssertEqual(c.cS2RC("auuy"), "ㄇㄚ˙") + XCTAssertEqual(c.cS2RC("ai"), "ㄇㄛ") + XCTAssertEqual(c.cS2RC("aie"), "ㄇㄛˊ") + XCTAssertEqual(c.cS2RC("air"), "ㄇㄛˇ") + XCTAssertEqual(c.cS2RC("aid"), "ㄇㄛˋ") + XCTAssertEqual(c.cS2RC("aiy"), "ㄇㄛ˙") + XCTAssertEqual(c.cS2RC("ak"), "ㄇㄜ") + XCTAssertEqual(c.cS2RC("akd"), "ㄇㄜˋ") + XCTAssertEqual(c.cS2RC("aky"), "ㄇㄜ˙") + XCTAssertEqual(c.cS2RC("aii"), "ㄇㄞ") + XCTAssertEqual(c.cS2RC("aiie"), "ㄇㄞˊ") + XCTAssertEqual(c.cS2RC("aiir"), "ㄇㄞˇ") + XCTAssertEqual(c.cS2RC("aiid"), "ㄇㄞˋ") + XCTAssertEqual(c.cS2RC("aoe"), "ㄇㄟˊ") + XCTAssertEqual(c.cS2RC("aor"), "ㄇㄟˇ") + XCTAssertEqual(c.cS2RC("aod"), "ㄇㄟˋ") + XCTAssertEqual(c.cS2RC("al"), "ㄇㄠ") + XCTAssertEqual(c.cS2RC("ale"), "ㄇㄠˊ") + XCTAssertEqual(c.cS2RC("alr"), "ㄇㄠˇ") + XCTAssertEqual(c.cS2RC("ald"), "ㄇㄠˋ") + XCTAssertEqual(c.cS2RC("ame"), "ㄇㄡˊ") + XCTAssertEqual(c.cS2RC("amr"), "ㄇㄡˇ") + XCTAssertEqual(c.cS2RC("amd"), "ㄇㄡˋ") + XCTAssertEqual(c.cS2RC("aoo"), "ㄇㄢ") + XCTAssertEqual(c.cS2RC("aooe"), "ㄇㄢˊ") + XCTAssertEqual(c.cS2RC("aoor"), "ㄇㄢˇ") + XCTAssertEqual(c.cS2RC("aood"), "ㄇㄢˋ") + XCTAssertEqual(c.cS2RC("ap"), "ㄇㄣ") + XCTAssertEqual(c.cS2RC("ape"), "ㄇㄣˊ") + XCTAssertEqual(c.cS2RC("apr"), "ㄇㄣˇ") + XCTAssertEqual(c.cS2RC("apd"), "ㄇㄣˋ") + XCTAssertEqual(c.cS2RC("apy"), "ㄇㄣ˙") + XCTAssertEqual(c.cS2RC("all"), "ㄇㄤ") + XCTAssertEqual(c.cS2RC("alle"), "ㄇㄤˊ") + XCTAssertEqual(c.cS2RC("allr"), "ㄇㄤˇ") + XCTAssertEqual(c.cS2RC("alld"), "ㄇㄤˋ") + XCTAssertEqual(c.cS2RC("an"), "ㄇㄥ") + XCTAssertEqual(c.cS2RC("ane"), "ㄇㄥˊ") + XCTAssertEqual(c.cS2RC("anr"), "ㄇㄥˇ") + XCTAssertEqual(c.cS2RC("and"), "ㄇㄥˋ") + XCTAssertEqual(c.cS2RC("au"), "ㄇㄧ") + XCTAssertEqual(c.cS2RC("aue"), "ㄇㄧˊ") + XCTAssertEqual(c.cS2RC("aur"), "ㄇㄧˇ") + XCTAssertEqual(c.cS2RC("aud"), "ㄇㄧˋ") + XCTAssertEqual(c.cS2RC("aub"), "ㄇㄧㄝ") + XCTAssertEqual(c.cS2RC("aube"), "ㄇㄧㄝˊ") + XCTAssertEqual(c.cS2RC("aubd"), "ㄇㄧㄝˋ") + XCTAssertEqual(c.cS2RC("aul"), "ㄇㄧㄠ") + XCTAssertEqual(c.cS2RC("aule"), "ㄇㄧㄠˊ") + XCTAssertEqual(c.cS2RC("aulr"), "ㄇㄧㄠˇ") + XCTAssertEqual(c.cS2RC("auld"), "ㄇㄧㄠˋ") + XCTAssertEqual(c.cS2RC("aume"), "ㄇㄧㄡˊ") + XCTAssertEqual(c.cS2RC("aumr"), "ㄇㄧㄡˇ") + XCTAssertEqual(c.cS2RC("aumd"), "ㄇㄧㄡˋ") + XCTAssertEqual(c.cS2RC("auoo"), "ㄇㄧㄢ") + XCTAssertEqual(c.cS2RC("auooe"), "ㄇㄧㄢˊ") + XCTAssertEqual(c.cS2RC("auoor"), "ㄇㄧㄢˇ") + XCTAssertEqual(c.cS2RC("auood"), "ㄇㄧㄢˋ") + XCTAssertEqual(c.cS2RC("aup"), "ㄇㄧㄣ") + XCTAssertEqual(c.cS2RC("aupe"), "ㄇㄧㄣˊ") + XCTAssertEqual(c.cS2RC("aupr"), "ㄇㄧㄣˇ") + XCTAssertEqual(c.cS2RC("aune"), "ㄇㄧㄥˊ") + XCTAssertEqual(c.cS2RC("aunr"), "ㄇㄧㄥˇ") + XCTAssertEqual(c.cS2RC("aund"), "ㄇㄧㄥˋ") + XCTAssertEqual(c.cS2RC("aje"), "ㄇㄨˊ") + XCTAssertEqual(c.cS2RC("ajr"), "ㄇㄨˇ") + XCTAssertEqual(c.cS2RC("ajd"), "ㄇㄨˋ") + XCTAssertEqual(c.cS2RC("zuu"), "ㄈㄚ") + XCTAssertEqual(c.cS2RC("zuue"), "ㄈㄚˊ") + XCTAssertEqual(c.cS2RC("zuur"), "ㄈㄚˇ") + XCTAssertEqual(c.cS2RC("zuud"), "ㄈㄚˋ") + XCTAssertEqual(c.cS2RC("zie"), "ㄈㄛˊ") + XCTAssertEqual(c.cS2RC("zo"), "ㄈㄟ") + XCTAssertEqual(c.cS2RC("zoe"), "ㄈㄟˊ") + XCTAssertEqual(c.cS2RC("zor"), "ㄈㄟˇ") + XCTAssertEqual(c.cS2RC("zod"), "ㄈㄟˋ") + XCTAssertEqual(c.cS2RC("zm"), "ㄈㄡ") + XCTAssertEqual(c.cS2RC("zme"), "ㄈㄡˊ") + XCTAssertEqual(c.cS2RC("zmr"), "ㄈㄡˇ") + XCTAssertEqual(c.cS2RC("zmd"), "ㄈㄡˋ") + XCTAssertEqual(c.cS2RC("zoo"), "ㄈㄢ") + XCTAssertEqual(c.cS2RC("zooe"), "ㄈㄢˊ") + XCTAssertEqual(c.cS2RC("zoor"), "ㄈㄢˇ") + XCTAssertEqual(c.cS2RC("zood"), "ㄈㄢˋ") + XCTAssertEqual(c.cS2RC("zp"), "ㄈㄣ") + XCTAssertEqual(c.cS2RC("zpe"), "ㄈㄣˊ") + XCTAssertEqual(c.cS2RC("zpr"), "ㄈㄣˇ") + XCTAssertEqual(c.cS2RC("zpd"), "ㄈㄣˋ") + XCTAssertEqual(c.cS2RC("zpy"), "ㄈㄣ˙") + XCTAssertEqual(c.cS2RC("zll"), "ㄈㄤ") + XCTAssertEqual(c.cS2RC("zlle"), "ㄈㄤˊ") + XCTAssertEqual(c.cS2RC("zllr"), "ㄈㄤˇ") + XCTAssertEqual(c.cS2RC("zlld"), "ㄈㄤˋ") + XCTAssertEqual(c.cS2RC("zn"), "ㄈㄥ") + XCTAssertEqual(c.cS2RC("zne"), "ㄈㄥˊ") + XCTAssertEqual(c.cS2RC("znr"), "ㄈㄥˇ") + XCTAssertEqual(c.cS2RC("znd"), "ㄈㄥˋ") + XCTAssertEqual(c.cS2RC("zuld"), "ㄈㄧㄠˋ") + XCTAssertEqual(c.cS2RC("zj"), "ㄈㄨ") + XCTAssertEqual(c.cS2RC("zje"), "ㄈㄨˊ") + XCTAssertEqual(c.cS2RC("zjr"), "ㄈㄨˇ") + XCTAssertEqual(c.cS2RC("zjd"), "ㄈㄨˋ") + XCTAssertEqual(c.cS2RC("wwuu"), "ㄉㄚ") + XCTAssertEqual(c.cS2RC("wwuue"), "ㄉㄚˊ") + XCTAssertEqual(c.cS2RC("wwuur"), "ㄉㄚˇ") + XCTAssertEqual(c.cS2RC("wwuud"), "ㄉㄚˋ") + XCTAssertEqual(c.cS2RC("wwuuy"), "ㄉㄚ˙") + XCTAssertEqual(c.cS2RC("wwk"), "ㄉㄜ") + XCTAssertEqual(c.cS2RC("wwke"), "ㄉㄜˊ") + XCTAssertEqual(c.cS2RC("wwky"), "ㄉㄜ˙") + XCTAssertEqual(c.cS2RC("wwii"), "ㄉㄞ") + XCTAssertEqual(c.cS2RC("wwiir"), "ㄉㄞˇ") + XCTAssertEqual(c.cS2RC("wwiid"), "ㄉㄞˋ") + XCTAssertEqual(c.cS2RC("wwor"), "ㄉㄟˇ") + XCTAssertEqual(c.cS2RC("wwl"), "ㄉㄠ") + XCTAssertEqual(c.cS2RC("wwle"), "ㄉㄠˊ") + XCTAssertEqual(c.cS2RC("wwlr"), "ㄉㄠˇ") + XCTAssertEqual(c.cS2RC("wwld"), "ㄉㄠˋ") + XCTAssertEqual(c.cS2RC("wwm"), "ㄉㄡ") + XCTAssertEqual(c.cS2RC("wwme"), "ㄉㄡˊ") + XCTAssertEqual(c.cS2RC("wwmr"), "ㄉㄡˇ") + XCTAssertEqual(c.cS2RC("wwmd"), "ㄉㄡˋ") + XCTAssertEqual(c.cS2RC("wwoo"), "ㄉㄢ") + XCTAssertEqual(c.cS2RC("wwoor"), "ㄉㄢˇ") + XCTAssertEqual(c.cS2RC("wwood"), "ㄉㄢˋ") + XCTAssertEqual(c.cS2RC("wwpd"), "ㄉㄣˋ") + XCTAssertEqual(c.cS2RC("wwll"), "ㄉㄤ") + XCTAssertEqual(c.cS2RC("wwllr"), "ㄉㄤˇ") + XCTAssertEqual(c.cS2RC("wwlld"), "ㄉㄤˋ") + XCTAssertEqual(c.cS2RC("wwn"), "ㄉㄥ") + XCTAssertEqual(c.cS2RC("wwnr"), "ㄉㄥˇ") + XCTAssertEqual(c.cS2RC("wwnd"), "ㄉㄥˋ") + XCTAssertEqual(c.cS2RC("wwu"), "ㄉㄧ") + XCTAssertEqual(c.cS2RC("wwue"), "ㄉㄧˊ") + XCTAssertEqual(c.cS2RC("wwur"), "ㄉㄧˇ") + XCTAssertEqual(c.cS2RC("wwud"), "ㄉㄧˋ") + XCTAssertEqual(c.cS2RC("wwuuur"), "ㄉㄧㄚˇ") + XCTAssertEqual(c.cS2RC("wwub"), "ㄉㄧㄝ") + XCTAssertEqual(c.cS2RC("wwube"), "ㄉㄧㄝˊ") + XCTAssertEqual(c.cS2RC("wwubr"), "ㄉㄧㄝˇ") + XCTAssertEqual(c.cS2RC("wwubd"), "ㄉㄧㄝˋ") + XCTAssertEqual(c.cS2RC("wwul"), "ㄉㄧㄠ") + XCTAssertEqual(c.cS2RC("wwulr"), "ㄉㄧㄠˇ") + XCTAssertEqual(c.cS2RC("wwuld"), "ㄉㄧㄠˋ") + XCTAssertEqual(c.cS2RC("wwum"), "ㄉㄧㄡ") + XCTAssertEqual(c.cS2RC("wwuoo"), "ㄉㄧㄢ") + XCTAssertEqual(c.cS2RC("wwuooe"), "ㄉㄧㄢˊ") + XCTAssertEqual(c.cS2RC("wwuoor"), "ㄉㄧㄢˇ") + XCTAssertEqual(c.cS2RC("wwuood"), "ㄉㄧㄢˋ") + XCTAssertEqual(c.cS2RC("wwun"), "ㄉㄧㄥ") + XCTAssertEqual(c.cS2RC("wwune"), "ㄉㄧㄥˊ") + XCTAssertEqual(c.cS2RC("wwunr"), "ㄉㄧㄥˇ") + XCTAssertEqual(c.cS2RC("wwund"), "ㄉㄧㄥˋ") + XCTAssertEqual(c.cS2RC("wwj"), "ㄉㄨ") + XCTAssertEqual(c.cS2RC("wwje"), "ㄉㄨˊ") + XCTAssertEqual(c.cS2RC("wwjr"), "ㄉㄨˇ") + XCTAssertEqual(c.cS2RC("wwjd"), "ㄉㄨˋ") + XCTAssertEqual(c.cS2RC("wwji"), "ㄉㄨㄛ") + XCTAssertEqual(c.cS2RC("wwjie"), "ㄉㄨㄛˊ") + XCTAssertEqual(c.cS2RC("wwjir"), "ㄉㄨㄛˇ") + XCTAssertEqual(c.cS2RC("wwjid"), "ㄉㄨㄛˋ") + XCTAssertEqual(c.cS2RC("wwjiy"), "ㄉㄨㄛ˙") + XCTAssertEqual(c.cS2RC("wwjo"), "ㄉㄨㄟ") + XCTAssertEqual(c.cS2RC("wwjor"), "ㄉㄨㄟˇ") + XCTAssertEqual(c.cS2RC("wwjod"), "ㄉㄨㄟˋ") + XCTAssertEqual(c.cS2RC("wwjoo"), "ㄉㄨㄢ") + XCTAssertEqual(c.cS2RC("wwjoor"), "ㄉㄨㄢˇ") + XCTAssertEqual(c.cS2RC("wwjood"), "ㄉㄨㄢˋ") + XCTAssertEqual(c.cS2RC("wwjp"), "ㄉㄨㄣ") + XCTAssertEqual(c.cS2RC("wwjpr"), "ㄉㄨㄣˇ") + XCTAssertEqual(c.cS2RC("wwjpd"), "ㄉㄨㄣˋ") + XCTAssertEqual(c.cS2RC("wwjn"), "ㄉㄨㄥ") + XCTAssertEqual(c.cS2RC("wwjnr"), "ㄉㄨㄥˇ") + XCTAssertEqual(c.cS2RC("wwjnd"), "ㄉㄨㄥˋ") + XCTAssertEqual(c.cS2RC("wuu"), "ㄊㄚ") + XCTAssertEqual(c.cS2RC("wuur"), "ㄊㄚˇ") + XCTAssertEqual(c.cS2RC("wuud"), "ㄊㄚˋ") + XCTAssertEqual(c.cS2RC("wkd"), "ㄊㄜˋ") + XCTAssertEqual(c.cS2RC("wii"), "ㄊㄞ") + XCTAssertEqual(c.cS2RC("wiie"), "ㄊㄞˊ") + XCTAssertEqual(c.cS2RC("wiir"), "ㄊㄞˇ") + XCTAssertEqual(c.cS2RC("wiid"), "ㄊㄞˋ") + XCTAssertEqual(c.cS2RC("wiiy"), "ㄊㄞ˙") + XCTAssertEqual(c.cS2RC("wl"), "ㄊㄠ") + XCTAssertEqual(c.cS2RC("wle"), "ㄊㄠˊ") + XCTAssertEqual(c.cS2RC("wlr"), "ㄊㄠˇ") + XCTAssertEqual(c.cS2RC("wld"), "ㄊㄠˋ") + XCTAssertEqual(c.cS2RC("wly"), "ㄊㄠ˙") + XCTAssertEqual(c.cS2RC("wm"), "ㄊㄡ") + XCTAssertEqual(c.cS2RC("wme"), "ㄊㄡˊ") + XCTAssertEqual(c.cS2RC("wmr"), "ㄊㄡˇ") + XCTAssertEqual(c.cS2RC("wmd"), "ㄊㄡˋ") + XCTAssertEqual(c.cS2RC("wmy"), "ㄊㄡ˙") + XCTAssertEqual(c.cS2RC("woo"), "ㄊㄢ") + XCTAssertEqual(c.cS2RC("wooe"), "ㄊㄢˊ") + XCTAssertEqual(c.cS2RC("woor"), "ㄊㄢˇ") + XCTAssertEqual(c.cS2RC("wood"), "ㄊㄢˋ") + XCTAssertEqual(c.cS2RC("wll"), "ㄊㄤ") + XCTAssertEqual(c.cS2RC("wlle"), "ㄊㄤˊ") + XCTAssertEqual(c.cS2RC("wllr"), "ㄊㄤˇ") + XCTAssertEqual(c.cS2RC("wlld"), "ㄊㄤˋ") + XCTAssertEqual(c.cS2RC("wn"), "ㄊㄥ") + XCTAssertEqual(c.cS2RC("wne"), "ㄊㄥˊ") + XCTAssertEqual(c.cS2RC("wnd"), "ㄊㄥˋ") + XCTAssertEqual(c.cS2RC("wu"), "ㄊㄧ") + XCTAssertEqual(c.cS2RC("wue"), "ㄊㄧˊ") + XCTAssertEqual(c.cS2RC("wur"), "ㄊㄧˇ") + XCTAssertEqual(c.cS2RC("wud"), "ㄊㄧˋ") + XCTAssertEqual(c.cS2RC("wub"), "ㄊㄧㄝ") + XCTAssertEqual(c.cS2RC("wube"), "ㄊㄧㄝˊ") + XCTAssertEqual(c.cS2RC("wubr"), "ㄊㄧㄝˇ") + XCTAssertEqual(c.cS2RC("wubd"), "ㄊㄧㄝˋ") + XCTAssertEqual(c.cS2RC("wul"), "ㄊㄧㄠ") + XCTAssertEqual(c.cS2RC("wule"), "ㄊㄧㄠˊ") + XCTAssertEqual(c.cS2RC("wulr"), "ㄊㄧㄠˇ") + XCTAssertEqual(c.cS2RC("wuld"), "ㄊㄧㄠˋ") + XCTAssertEqual(c.cS2RC("wuoo"), "ㄊㄧㄢ") + XCTAssertEqual(c.cS2RC("wuooe"), "ㄊㄧㄢˊ") + XCTAssertEqual(c.cS2RC("wuoor"), "ㄊㄧㄢˇ") + XCTAssertEqual(c.cS2RC("wuood"), "ㄊㄧㄢˋ") + XCTAssertEqual(c.cS2RC("wun"), "ㄊㄧㄥ") + XCTAssertEqual(c.cS2RC("wune"), "ㄊㄧㄥˊ") + XCTAssertEqual(c.cS2RC("wunr"), "ㄊㄧㄥˇ") + XCTAssertEqual(c.cS2RC("wund"), "ㄊㄧㄥˋ") + XCTAssertEqual(c.cS2RC("wj"), "ㄊㄨ") + XCTAssertEqual(c.cS2RC("wje"), "ㄊㄨˊ") + XCTAssertEqual(c.cS2RC("wjr"), "ㄊㄨˇ") + XCTAssertEqual(c.cS2RC("wjd"), "ㄊㄨˋ") + XCTAssertEqual(c.cS2RC("wji"), "ㄊㄨㄛ") + XCTAssertEqual(c.cS2RC("wjie"), "ㄊㄨㄛˊ") + XCTAssertEqual(c.cS2RC("wjir"), "ㄊㄨㄛˇ") + XCTAssertEqual(c.cS2RC("wjid"), "ㄊㄨㄛˋ") + XCTAssertEqual(c.cS2RC("wjo"), "ㄊㄨㄟ") + XCTAssertEqual(c.cS2RC("wjoe"), "ㄊㄨㄟˊ") + XCTAssertEqual(c.cS2RC("wjor"), "ㄊㄨㄟˇ") + XCTAssertEqual(c.cS2RC("wjod"), "ㄊㄨㄟˋ") + XCTAssertEqual(c.cS2RC("wjoo"), "ㄊㄨㄢ") + XCTAssertEqual(c.cS2RC("wjooe"), "ㄊㄨㄢˊ") + XCTAssertEqual(c.cS2RC("wjoor"), "ㄊㄨㄢˇ") + XCTAssertEqual(c.cS2RC("wjood"), "ㄊㄨㄢˋ") + XCTAssertEqual(c.cS2RC("wjp"), "ㄊㄨㄣ") + XCTAssertEqual(c.cS2RC("wjpe"), "ㄊㄨㄣˊ") + XCTAssertEqual(c.cS2RC("wjpr"), "ㄊㄨㄣˇ") + XCTAssertEqual(c.cS2RC("wjpd"), "ㄊㄨㄣˋ") + XCTAssertEqual(c.cS2RC("wjn"), "ㄊㄨㄥ") + XCTAssertEqual(c.cS2RC("wjne"), "ㄊㄨㄥˊ") + XCTAssertEqual(c.cS2RC("wjnr"), "ㄊㄨㄥˇ") + XCTAssertEqual(c.cS2RC("wjnd"), "ㄊㄨㄥˋ") + XCTAssertEqual(c.cS2RC("suu"), "ㄋㄚ") + XCTAssertEqual(c.cS2RC("suue"), "ㄋㄚˊ") + XCTAssertEqual(c.cS2RC("suur"), "ㄋㄚˇ") + XCTAssertEqual(c.cS2RC("suud"), "ㄋㄚˋ") + XCTAssertEqual(c.cS2RC("suuy"), "ㄋㄚ˙") + XCTAssertEqual(c.cS2RC("skd"), "ㄋㄜˋ") + XCTAssertEqual(c.cS2RC("sky"), "ㄋㄜ˙") + XCTAssertEqual(c.cS2RC("siie"), "ㄋㄞˊ") + XCTAssertEqual(c.cS2RC("siir"), "ㄋㄞˇ") + XCTAssertEqual(c.cS2RC("siid"), "ㄋㄞˋ") + XCTAssertEqual(c.cS2RC("soe"), "ㄋㄟˊ") + XCTAssertEqual(c.cS2RC("sor"), "ㄋㄟˇ") + XCTAssertEqual(c.cS2RC("sod"), "ㄋㄟˋ") + XCTAssertEqual(c.cS2RC("sl"), "ㄋㄠ") + XCTAssertEqual(c.cS2RC("sle"), "ㄋㄠˊ") + XCTAssertEqual(c.cS2RC("slr"), "ㄋㄠˇ") + XCTAssertEqual(c.cS2RC("sld"), "ㄋㄠˋ") + XCTAssertEqual(c.cS2RC("sme"), "ㄋㄡˊ") + XCTAssertEqual(c.cS2RC("smr"), "ㄋㄡˇ") + XCTAssertEqual(c.cS2RC("smd"), "ㄋㄡˋ") + XCTAssertEqual(c.cS2RC("soo"), "ㄋㄢ") + XCTAssertEqual(c.cS2RC("sooe"), "ㄋㄢˊ") + XCTAssertEqual(c.cS2RC("soor"), "ㄋㄢˇ") + XCTAssertEqual(c.cS2RC("sood"), "ㄋㄢˋ") + XCTAssertEqual(c.cS2RC("spr"), "ㄋㄣˇ") + XCTAssertEqual(c.cS2RC("spd"), "ㄋㄣˋ") + XCTAssertEqual(c.cS2RC("sll"), "ㄋㄤ") + XCTAssertEqual(c.cS2RC("slle"), "ㄋㄤˊ") + XCTAssertEqual(c.cS2RC("sllr"), "ㄋㄤˇ") + XCTAssertEqual(c.cS2RC("slld"), "ㄋㄤˋ") + XCTAssertEqual(c.cS2RC("slly"), "ㄋㄤ˙") + XCTAssertEqual(c.cS2RC("sne"), "ㄋㄥˊ") + XCTAssertEqual(c.cS2RC("snr"), "ㄋㄥˇ") + XCTAssertEqual(c.cS2RC("su"), "ㄋㄧ") + XCTAssertEqual(c.cS2RC("sue"), "ㄋㄧˊ") + XCTAssertEqual(c.cS2RC("sur"), "ㄋㄧˇ") + XCTAssertEqual(c.cS2RC("sud"), "ㄋㄧˋ") + XCTAssertEqual(c.cS2RC("sub"), "ㄋㄧㄝ") + XCTAssertEqual(c.cS2RC("sube"), "ㄋㄧㄝˊ") + XCTAssertEqual(c.cS2RC("subd"), "ㄋㄧㄝˋ") + XCTAssertEqual(c.cS2RC("sulr"), "ㄋㄧㄠˇ") + XCTAssertEqual(c.cS2RC("suld"), "ㄋㄧㄠˋ") + XCTAssertEqual(c.cS2RC("sum"), "ㄋㄧㄡ") + XCTAssertEqual(c.cS2RC("sume"), "ㄋㄧㄡˊ") + XCTAssertEqual(c.cS2RC("sumr"), "ㄋㄧㄡˇ") + XCTAssertEqual(c.cS2RC("sumd"), "ㄋㄧㄡˋ") + XCTAssertEqual(c.cS2RC("suoo"), "ㄋㄧㄢ") + XCTAssertEqual(c.cS2RC("suooe"), "ㄋㄧㄢˊ") + XCTAssertEqual(c.cS2RC("suoor"), "ㄋㄧㄢˇ") + XCTAssertEqual(c.cS2RC("suood"), "ㄋㄧㄢˋ") + XCTAssertEqual(c.cS2RC("sup"), "ㄋㄧㄣ") + XCTAssertEqual(c.cS2RC("supe"), "ㄋㄧㄣˊ") + XCTAssertEqual(c.cS2RC("supr"), "ㄋㄧㄣˇ") + XCTAssertEqual(c.cS2RC("supd"), "ㄋㄧㄣˋ") + XCTAssertEqual(c.cS2RC("sulle"), "ㄋㄧㄤˊ") + XCTAssertEqual(c.cS2RC("sullr"), "ㄋㄧㄤˇ") + XCTAssertEqual(c.cS2RC("sulld"), "ㄋㄧㄤˋ") + XCTAssertEqual(c.cS2RC("sune"), "ㄋㄧㄥˊ") + XCTAssertEqual(c.cS2RC("sunr"), "ㄋㄧㄥˇ") + XCTAssertEqual(c.cS2RC("sund"), "ㄋㄧㄥˋ") + XCTAssertEqual(c.cS2RC("sje"), "ㄋㄨˊ") + XCTAssertEqual(c.cS2RC("sjr"), "ㄋㄨˇ") + XCTAssertEqual(c.cS2RC("sjd"), "ㄋㄨˋ") + XCTAssertEqual(c.cS2RC("sjie"), "ㄋㄨㄛˊ") + XCTAssertEqual(c.cS2RC("sjir"), "ㄋㄨㄛˇ") + XCTAssertEqual(c.cS2RC("sjid"), "ㄋㄨㄛˋ") + XCTAssertEqual(c.cS2RC("sjoe"), "ㄋㄨㄟˊ") + XCTAssertEqual(c.cS2RC("sjooe"), "ㄋㄨㄢˊ") + XCTAssertEqual(c.cS2RC("sjoor"), "ㄋㄨㄢˇ") + XCTAssertEqual(c.cS2RC("sjood"), "ㄋㄨㄢˋ") + XCTAssertEqual(c.cS2RC("sjpe"), "ㄋㄨㄣˊ") + XCTAssertEqual(c.cS2RC("sjne"), "ㄋㄨㄥˊ") + XCTAssertEqual(c.cS2RC("sjnr"), "ㄋㄨㄥˇ") + XCTAssertEqual(c.cS2RC("sjnd"), "ㄋㄨㄥˋ") + XCTAssertEqual(c.cS2RC("smme"), "ㄋㄩˊ") + XCTAssertEqual(c.cS2RC("smmr"), "ㄋㄩˇ") + XCTAssertEqual(c.cS2RC("smmd"), "ㄋㄩˋ") + XCTAssertEqual(c.cS2RC("smmbd"), "ㄋㄩㄝˋ") + XCTAssertEqual(c.cS2RC("xuu"), "ㄌㄚ") + XCTAssertEqual(c.cS2RC("xuue"), "ㄌㄚˊ") + XCTAssertEqual(c.cS2RC("xuur"), "ㄌㄚˇ") + XCTAssertEqual(c.cS2RC("xuud"), "ㄌㄚˋ") + XCTAssertEqual(c.cS2RC("xuuy"), "ㄌㄚ˙") + XCTAssertEqual(c.cS2RC("xi"), "ㄌㄛ") + XCTAssertEqual(c.cS2RC("xiy"), "ㄌㄛ˙") + XCTAssertEqual(c.cS2RC("xk"), "ㄌㄜ") + XCTAssertEqual(c.cS2RC("xke"), "ㄌㄜˊ") + XCTAssertEqual(c.cS2RC("xkd"), "ㄌㄜˋ") + XCTAssertEqual(c.cS2RC("xky"), "ㄌㄜ˙") + XCTAssertEqual(c.cS2RC("xiie"), "ㄌㄞˊ") + XCTAssertEqual(c.cS2RC("xiir"), "ㄌㄞˇ") + XCTAssertEqual(c.cS2RC("xiid"), "ㄌㄞˋ") + XCTAssertEqual(c.cS2RC("xo"), "ㄌㄟ") + XCTAssertEqual(c.cS2RC("xoe"), "ㄌㄟˊ") + XCTAssertEqual(c.cS2RC("xor"), "ㄌㄟˇ") + XCTAssertEqual(c.cS2RC("xod"), "ㄌㄟˋ") + XCTAssertEqual(c.cS2RC("xoy"), "ㄌㄟ˙") } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_B.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_B.swift index ed42c697..8adb9a20 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_B.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_B.swift @@ -12,491 +12,491 @@ import XCTest extension TekkonTestsKeyboardArrangments { func testDachen26KeysB() throws { - var composer = Tekkon.Composer(arrange: .ofDachen26) - XCTAssertEqual(composer.convertSequenceToRawComposition("xl"), "ㄌㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xle"), "ㄌㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xlr"), "ㄌㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xld"), "ㄌㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xm"), "ㄌㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xme"), "ㄌㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmr"), "ㄌㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmd"), "ㄌㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmy"), "ㄌㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("xooe"), "ㄌㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xoor"), "ㄌㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xood"), "ㄌㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xll"), "ㄌㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xlle"), "ㄌㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xllr"), "ㄌㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xlld"), "ㄌㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xn"), "ㄌㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xne"), "ㄌㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xnr"), "ㄌㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xnd"), "ㄌㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xu"), "ㄌㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xue"), "ㄌㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xur"), "ㄌㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xud"), "ㄌㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuy"), "ㄌㄧ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuuur"), "ㄌㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xub"), "ㄌㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xube"), "ㄌㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xubr"), "ㄌㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xubd"), "ㄌㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xul"), "ㄌㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xule"), "ㄌㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xulr"), "ㄌㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuld"), "ㄌㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xum"), "ㄌㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xume"), "ㄌㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xumr"), "ㄌㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xumd"), "ㄌㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuoo"), "ㄌㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuooe"), "ㄌㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuoor"), "ㄌㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuood"), "ㄌㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xupe"), "ㄌㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xupr"), "ㄌㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xupd"), "ㄌㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xulle"), "ㄌㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xullr"), "ㄌㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xulld"), "ㄌㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xun"), "ㄌㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xune"), "ㄌㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xunr"), "ㄌㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xund"), "ㄌㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xj"), "ㄌㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xje"), "ㄌㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjr"), "ㄌㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjd"), "ㄌㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xji"), "ㄌㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjie"), "ㄌㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjir"), "ㄌㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjid"), "ㄌㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjiy"), "ㄌㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjooe"), "ㄌㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjoor"), "ㄌㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjood"), "ㄌㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjp"), "ㄌㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjpe"), "ㄌㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjpr"), "ㄌㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjpd"), "ㄌㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjn"), "ㄌㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjne"), "ㄌㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjnr"), "ㄌㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xjnd"), "ㄌㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmm"), "ㄌㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmme"), "ㄌㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmmr"), "ㄌㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmmd"), "ㄌㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmmb"), "ㄌㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmmbr"), "ㄌㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmmbd"), "ㄌㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmmooe"), "ㄌㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmmoor"), "ㄌㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("euu"), "ㄍㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("euue"), "ㄍㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("euur"), "ㄍㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("euud"), "ㄍㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("euuy"), "ㄍㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ek"), "ㄍㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eke"), "ㄍㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ekr"), "ㄍㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ekd"), "ㄍㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eky"), "ㄍㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("eii"), "ㄍㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eiir"), "ㄍㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eiid"), "ㄍㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eor"), "ㄍㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("el"), "ㄍㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("elr"), "ㄍㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eld"), "ㄍㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("em"), "ㄍㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("emr"), "ㄍㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("emd"), "ㄍㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eoo"), "ㄍㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eoor"), "ㄍㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eood"), "ㄍㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ep"), "ㄍㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("epe"), "ㄍㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("epr"), "ㄍㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("epd"), "ㄍㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ell"), "ㄍㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ellr"), "ㄍㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("elld"), "ㄍㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("en"), "ㄍㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("enr"), "ㄍㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("end"), "ㄍㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ej"), "ㄍㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eje"), "ㄍㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejr"), "ㄍㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejd"), "ㄍㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eju"), "ㄍㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejue"), "ㄍㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejur"), "ㄍㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejud"), "ㄍㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eji"), "ㄍㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejie"), "ㄍㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejir"), "ㄍㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejid"), "ㄍㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejii"), "ㄍㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejiir"), "ㄍㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejiid"), "ㄍㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejo"), "ㄍㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejor"), "ㄍㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejod"), "ㄍㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejoo"), "ㄍㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejoor"), "ㄍㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejood"), "ㄍㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejp"), "ㄍㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejpr"), "ㄍㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejpd"), "ㄍㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejll"), "ㄍㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejllr"), "ㄍㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejlld"), "ㄍㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejn"), "ㄍㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejne"), "ㄍㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejnr"), "ㄍㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ejnd"), "ㄍㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("duu"), "ㄎㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("duur"), "ㄎㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("duud"), "ㄎㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dk"), "ㄎㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dke"), "ㄎㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dkr"), "ㄎㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dkd"), "ㄎㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dii"), "ㄎㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("diir"), "ㄎㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("diid"), "ㄎㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dl"), "ㄎㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dlr"), "ㄎㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dld"), "ㄎㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dm"), "ㄎㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dmr"), "ㄎㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dmd"), "ㄎㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("doo"), "ㄎㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("door"), "ㄎㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dood"), "ㄎㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dp"), "ㄎㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dpr"), "ㄎㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dpd"), "ㄎㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dll"), "ㄎㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dlle"), "ㄎㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dllr"), "ㄎㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dlld"), "ㄎㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dn"), "ㄎㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dnr"), "ㄎㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dj"), "ㄎㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dje"), "ㄎㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djr"), "ㄎㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djd"), "ㄎㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dju"), "ㄎㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djur"), "ㄎㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djud"), "ㄎㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djid"), "ㄎㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djii"), "ㄎㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djiir"), "ㄎㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djiid"), "ㄎㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djo"), "ㄎㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djoe"), "ㄎㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djor"), "ㄎㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djod"), "ㄎㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djoo"), "ㄎㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djoor"), "ㄎㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djood"), "ㄎㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djp"), "ㄎㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djpr"), "ㄎㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djpd"), "ㄎㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djll"), "ㄎㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djlle"), "ㄎㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djllr"), "ㄎㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djlld"), "ㄎㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djn"), "ㄎㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djnr"), "ㄎㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("djnd"), "ㄎㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuu"), "ㄏㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuue"), "ㄏㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuur"), "ㄏㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ck"), "ㄏㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cke"), "ㄏㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ckr"), "ㄏㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ckd"), "ㄏㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cii"), "ㄏㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ciie"), "ㄏㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ciir"), "ㄏㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ciid"), "ㄏㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("co"), "ㄏㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cor"), "ㄏㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cl"), "ㄏㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cle"), "ㄏㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("clr"), "ㄏㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cld"), "ㄏㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cm"), "ㄏㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cme"), "ㄏㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cmr"), "ㄏㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cmd"), "ㄏㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("coo"), "ㄏㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cooe"), "ㄏㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("coor"), "ㄏㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cood"), "ㄏㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cp"), "ㄏㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cpe"), "ㄏㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cpr"), "ㄏㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cpd"), "ㄏㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cll"), "ㄏㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("clle"), "ㄏㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cllr"), "ㄏㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("clld"), "ㄏㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cn"), "ㄏㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cne"), "ㄏㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cnd"), "ㄏㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cj"), "ㄏㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cje"), "ㄏㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjr"), "ㄏㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjd"), "ㄏㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cju"), "ㄏㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjue"), "ㄏㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjur"), "ㄏㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjud"), "ㄏㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cji"), "ㄏㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjie"), "ㄏㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjir"), "ㄏㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjid"), "ㄏㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjiy"), "ㄏㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjiie"), "ㄏㄨㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjiid"), "ㄏㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjo"), "ㄏㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjoe"), "ㄏㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjor"), "ㄏㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjod"), "ㄏㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjoo"), "ㄏㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjooe"), "ㄏㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjoor"), "ㄏㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjood"), "ㄏㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjp"), "ㄏㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjpe"), "ㄏㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjpr"), "ㄏㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjpd"), "ㄏㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjll"), "ㄏㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjlle"), "ㄏㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjllr"), "ㄏㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjlld"), "ㄏㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjlly"), "ㄏㄨㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjn"), "ㄏㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjne"), "ㄏㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjnr"), "ㄏㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cjnd"), "ㄏㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ru"), "ㄐㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rue"), "ㄐㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rur"), "ㄐㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rud"), "ㄐㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ruuu"), "ㄐㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ruuue"), "ㄐㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ruuur"), "ㄐㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ruuud"), "ㄐㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rub"), "ㄐㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rube"), "ㄐㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rubr"), "ㄐㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rubd"), "ㄐㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ruby"), "ㄐㄧㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("rul"), "ㄐㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rule"), "ㄐㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rulr"), "ㄐㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ruld"), "ㄐㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rum"), "ㄐㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rumr"), "ㄐㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rumd"), "ㄐㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ruoo"), "ㄐㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ruoor"), "ㄐㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ruood"), "ㄐㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rup"), "ㄐㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rupr"), "ㄐㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rupd"), "ㄐㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rull"), "ㄐㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rulle"), "ㄐㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rullr"), "ㄐㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rulld"), "ㄐㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("run"), "ㄐㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("runr"), "ㄐㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rund"), "ㄐㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rm"), "ㄐㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rme"), "ㄐㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmr"), "ㄐㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmd"), "ㄐㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmb"), "ㄐㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmbe"), "ㄐㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmbr"), "ㄐㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmbd"), "ㄐㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmoo"), "ㄐㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmoor"), "ㄐㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmood"), "ㄐㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmp"), "ㄐㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmpe"), "ㄐㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmpr"), "ㄐㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmpd"), "ㄐㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmn"), "ㄐㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmnr"), "ㄐㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmnd"), "ㄐㄩㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fy"), "ㄑ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("fu"), "ㄑㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fue"), "ㄑㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fur"), "ㄑㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fud"), "ㄑㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fuuu"), "ㄑㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fuuue"), "ㄑㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fuuur"), "ㄑㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fuuud"), "ㄑㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fub"), "ㄑㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fube"), "ㄑㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fubr"), "ㄑㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fubd"), "ㄑㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ful"), "ㄑㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fule"), "ㄑㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fulr"), "ㄑㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fuld"), "ㄑㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fum"), "ㄑㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fume"), "ㄑㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fumr"), "ㄑㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fumd"), "ㄑㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fuoo"), "ㄑㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fuooe"), "ㄑㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fuoor"), "ㄑㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fuood"), "ㄑㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fup"), "ㄑㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fupe"), "ㄑㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fupr"), "ㄑㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fupd"), "ㄑㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("full"), "ㄑㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fulle"), "ㄑㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fullr"), "ㄑㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fulld"), "ㄑㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fun"), "ㄑㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fune"), "ㄑㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("funr"), "ㄑㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fund"), "ㄑㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fm"), "ㄑㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fme"), "ㄑㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmr"), "ㄑㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmd"), "ㄑㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmb"), "ㄑㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmbe"), "ㄑㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmbd"), "ㄑㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmoo"), "ㄑㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmooe"), "ㄑㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmoor"), "ㄑㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmood"), "ㄑㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmp"), "ㄑㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmpe"), "ㄑㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmpr"), "ㄑㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmpd"), "ㄑㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmn"), "ㄑㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmne"), "ㄑㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmnr"), "ㄑㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmnd"), "ㄑㄩㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vu"), "ㄒㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vue"), "ㄒㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vur"), "ㄒㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vud"), "ㄒㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuuu"), "ㄒㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuuue"), "ㄒㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuuur"), "ㄒㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuuud"), "ㄒㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vub"), "ㄒㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vube"), "ㄒㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vubr"), "ㄒㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vubd"), "ㄒㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vul"), "ㄒㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vule"), "ㄒㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vulr"), "ㄒㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuld"), "ㄒㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vum"), "ㄒㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vume"), "ㄒㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vumr"), "ㄒㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vumd"), "ㄒㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuoo"), "ㄒㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuooe"), "ㄒㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuoor"), "ㄒㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuood"), "ㄒㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vup"), "ㄒㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vupe"), "ㄒㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vupr"), "ㄒㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vupd"), "ㄒㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vull"), "ㄒㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vulle"), "ㄒㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vullr"), "ㄒㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vulld"), "ㄒㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vun"), "ㄒㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vune"), "ㄒㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vunr"), "ㄒㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vund"), "ㄒㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vm"), "ㄒㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vme"), "ㄒㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmr"), "ㄒㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmd"), "ㄒㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmb"), "ㄒㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmbe"), "ㄒㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmbr"), "ㄒㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmbd"), "ㄒㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmoo"), "ㄒㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmooe"), "ㄒㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmoor"), "ㄒㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmood"), "ㄒㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmp"), "ㄒㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmpe"), "ㄒㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmpd"), "ㄒㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmn"), "ㄒㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmne"), "ㄒㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmnr"), "ㄒㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmnd"), "ㄒㄩㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tt"), "ㄓ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tte"), "ㄓˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttr"), "ㄓˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttd"), "ㄓˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttuu"), "ㄓㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttuue"), "ㄓㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttuur"), "ㄓㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttuud"), "ㄓㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttk"), "ㄓㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttke"), "ㄓㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttkr"), "ㄓㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttkd"), "ㄓㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttky"), "ㄓㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttii"), "ㄓㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttiie"), "ㄓㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttiir"), "ㄓㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttiid"), "ㄓㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttod"), "ㄓㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttl"), "ㄓㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttle"), "ㄓㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttlr"), "ㄓㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttld"), "ㄓㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttm"), "ㄓㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttme"), "ㄓㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttmr"), "ㄓㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttmd"), "ㄓㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttoo"), "ㄓㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttoor"), "ㄓㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttood"), "ㄓㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttp"), "ㄓㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttpe"), "ㄓㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttpr"), "ㄓㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttpd"), "ㄓㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttll"), "ㄓㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttllr"), "ㄓㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttlld"), "ㄓㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttn"), "ㄓㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttnr"), "ㄓㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttnd"), "ㄓㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttj"), "ㄓㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttje"), "ㄓㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjr"), "ㄓㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjd"), "ㄓㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttju"), "ㄓㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjur"), "ㄓㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttji"), "ㄓㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjie"), "ㄓㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjid"), "ㄓㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjii"), "ㄓㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjiir"), "ㄓㄨㄞˇ") + var c = Tekkon.Composer(arrange: .ofDachen26) + XCTAssertEqual(c.cS2RC("xl"), "ㄌㄠ") + XCTAssertEqual(c.cS2RC("xle"), "ㄌㄠˊ") + XCTAssertEqual(c.cS2RC("xlr"), "ㄌㄠˇ") + XCTAssertEqual(c.cS2RC("xld"), "ㄌㄠˋ") + XCTAssertEqual(c.cS2RC("xm"), "ㄌㄡ") + XCTAssertEqual(c.cS2RC("xme"), "ㄌㄡˊ") + XCTAssertEqual(c.cS2RC("xmr"), "ㄌㄡˇ") + XCTAssertEqual(c.cS2RC("xmd"), "ㄌㄡˋ") + XCTAssertEqual(c.cS2RC("xmy"), "ㄌㄡ˙") + XCTAssertEqual(c.cS2RC("xooe"), "ㄌㄢˊ") + XCTAssertEqual(c.cS2RC("xoor"), "ㄌㄢˇ") + XCTAssertEqual(c.cS2RC("xood"), "ㄌㄢˋ") + XCTAssertEqual(c.cS2RC("xll"), "ㄌㄤ") + XCTAssertEqual(c.cS2RC("xlle"), "ㄌㄤˊ") + XCTAssertEqual(c.cS2RC("xllr"), "ㄌㄤˇ") + XCTAssertEqual(c.cS2RC("xlld"), "ㄌㄤˋ") + XCTAssertEqual(c.cS2RC("xn"), "ㄌㄥ") + XCTAssertEqual(c.cS2RC("xne"), "ㄌㄥˊ") + XCTAssertEqual(c.cS2RC("xnr"), "ㄌㄥˇ") + XCTAssertEqual(c.cS2RC("xnd"), "ㄌㄥˋ") + XCTAssertEqual(c.cS2RC("xu"), "ㄌㄧ") + XCTAssertEqual(c.cS2RC("xue"), "ㄌㄧˊ") + XCTAssertEqual(c.cS2RC("xur"), "ㄌㄧˇ") + XCTAssertEqual(c.cS2RC("xud"), "ㄌㄧˋ") + XCTAssertEqual(c.cS2RC("xuy"), "ㄌㄧ˙") + XCTAssertEqual(c.cS2RC("xuuur"), "ㄌㄧㄚˇ") + XCTAssertEqual(c.cS2RC("xub"), "ㄌㄧㄝ") + XCTAssertEqual(c.cS2RC("xube"), "ㄌㄧㄝˊ") + XCTAssertEqual(c.cS2RC("xubr"), "ㄌㄧㄝˇ") + XCTAssertEqual(c.cS2RC("xubd"), "ㄌㄧㄝˋ") + XCTAssertEqual(c.cS2RC("xul"), "ㄌㄧㄠ") + XCTAssertEqual(c.cS2RC("xule"), "ㄌㄧㄠˊ") + XCTAssertEqual(c.cS2RC("xulr"), "ㄌㄧㄠˇ") + XCTAssertEqual(c.cS2RC("xuld"), "ㄌㄧㄠˋ") + XCTAssertEqual(c.cS2RC("xum"), "ㄌㄧㄡ") + XCTAssertEqual(c.cS2RC("xume"), "ㄌㄧㄡˊ") + XCTAssertEqual(c.cS2RC("xumr"), "ㄌㄧㄡˇ") + XCTAssertEqual(c.cS2RC("xumd"), "ㄌㄧㄡˋ") + XCTAssertEqual(c.cS2RC("xuoo"), "ㄌㄧㄢ") + XCTAssertEqual(c.cS2RC("xuooe"), "ㄌㄧㄢˊ") + XCTAssertEqual(c.cS2RC("xuoor"), "ㄌㄧㄢˇ") + XCTAssertEqual(c.cS2RC("xuood"), "ㄌㄧㄢˋ") + XCTAssertEqual(c.cS2RC("xupe"), "ㄌㄧㄣˊ") + XCTAssertEqual(c.cS2RC("xupr"), "ㄌㄧㄣˇ") + XCTAssertEqual(c.cS2RC("xupd"), "ㄌㄧㄣˋ") + XCTAssertEqual(c.cS2RC("xulle"), "ㄌㄧㄤˊ") + XCTAssertEqual(c.cS2RC("xullr"), "ㄌㄧㄤˇ") + XCTAssertEqual(c.cS2RC("xulld"), "ㄌㄧㄤˋ") + XCTAssertEqual(c.cS2RC("xun"), "ㄌㄧㄥ") + XCTAssertEqual(c.cS2RC("xune"), "ㄌㄧㄥˊ") + XCTAssertEqual(c.cS2RC("xunr"), "ㄌㄧㄥˇ") + XCTAssertEqual(c.cS2RC("xund"), "ㄌㄧㄥˋ") + XCTAssertEqual(c.cS2RC("xj"), "ㄌㄨ") + XCTAssertEqual(c.cS2RC("xje"), "ㄌㄨˊ") + XCTAssertEqual(c.cS2RC("xjr"), "ㄌㄨˇ") + XCTAssertEqual(c.cS2RC("xjd"), "ㄌㄨˋ") + XCTAssertEqual(c.cS2RC("xji"), "ㄌㄨㄛ") + XCTAssertEqual(c.cS2RC("xjie"), "ㄌㄨㄛˊ") + XCTAssertEqual(c.cS2RC("xjir"), "ㄌㄨㄛˇ") + XCTAssertEqual(c.cS2RC("xjid"), "ㄌㄨㄛˋ") + XCTAssertEqual(c.cS2RC("xjiy"), "ㄌㄨㄛ˙") + XCTAssertEqual(c.cS2RC("xjooe"), "ㄌㄨㄢˊ") + XCTAssertEqual(c.cS2RC("xjoor"), "ㄌㄨㄢˇ") + XCTAssertEqual(c.cS2RC("xjood"), "ㄌㄨㄢˋ") + XCTAssertEqual(c.cS2RC("xjp"), "ㄌㄨㄣ") + XCTAssertEqual(c.cS2RC("xjpe"), "ㄌㄨㄣˊ") + XCTAssertEqual(c.cS2RC("xjpr"), "ㄌㄨㄣˇ") + XCTAssertEqual(c.cS2RC("xjpd"), "ㄌㄨㄣˋ") + XCTAssertEqual(c.cS2RC("xjn"), "ㄌㄨㄥ") + XCTAssertEqual(c.cS2RC("xjne"), "ㄌㄨㄥˊ") + XCTAssertEqual(c.cS2RC("xjnr"), "ㄌㄨㄥˇ") + XCTAssertEqual(c.cS2RC("xjnd"), "ㄌㄨㄥˋ") + XCTAssertEqual(c.cS2RC("xmm"), "ㄌㄩ") + XCTAssertEqual(c.cS2RC("xmme"), "ㄌㄩˊ") + XCTAssertEqual(c.cS2RC("xmmr"), "ㄌㄩˇ") + XCTAssertEqual(c.cS2RC("xmmd"), "ㄌㄩˋ") + XCTAssertEqual(c.cS2RC("xmmb"), "ㄌㄩㄝ") + XCTAssertEqual(c.cS2RC("xmmbr"), "ㄌㄩㄝˇ") + XCTAssertEqual(c.cS2RC("xmmbd"), "ㄌㄩㄝˋ") + XCTAssertEqual(c.cS2RC("xmmooe"), "ㄌㄩㄢˊ") + XCTAssertEqual(c.cS2RC("xmmoor"), "ㄌㄩㄢˇ") + XCTAssertEqual(c.cS2RC("euu"), "ㄍㄚ") + XCTAssertEqual(c.cS2RC("euue"), "ㄍㄚˊ") + XCTAssertEqual(c.cS2RC("euur"), "ㄍㄚˇ") + XCTAssertEqual(c.cS2RC("euud"), "ㄍㄚˋ") + XCTAssertEqual(c.cS2RC("euuy"), "ㄍㄚ˙") + XCTAssertEqual(c.cS2RC("ek"), "ㄍㄜ") + XCTAssertEqual(c.cS2RC("eke"), "ㄍㄜˊ") + XCTAssertEqual(c.cS2RC("ekr"), "ㄍㄜˇ") + XCTAssertEqual(c.cS2RC("ekd"), "ㄍㄜˋ") + XCTAssertEqual(c.cS2RC("eky"), "ㄍㄜ˙") + XCTAssertEqual(c.cS2RC("eii"), "ㄍㄞ") + XCTAssertEqual(c.cS2RC("eiir"), "ㄍㄞˇ") + XCTAssertEqual(c.cS2RC("eiid"), "ㄍㄞˋ") + XCTAssertEqual(c.cS2RC("eor"), "ㄍㄟˇ") + XCTAssertEqual(c.cS2RC("el"), "ㄍㄠ") + XCTAssertEqual(c.cS2RC("elr"), "ㄍㄠˇ") + XCTAssertEqual(c.cS2RC("eld"), "ㄍㄠˋ") + XCTAssertEqual(c.cS2RC("em"), "ㄍㄡ") + XCTAssertEqual(c.cS2RC("emr"), "ㄍㄡˇ") + XCTAssertEqual(c.cS2RC("emd"), "ㄍㄡˋ") + XCTAssertEqual(c.cS2RC("eoo"), "ㄍㄢ") + XCTAssertEqual(c.cS2RC("eoor"), "ㄍㄢˇ") + XCTAssertEqual(c.cS2RC("eood"), "ㄍㄢˋ") + XCTAssertEqual(c.cS2RC("ep"), "ㄍㄣ") + XCTAssertEqual(c.cS2RC("epe"), "ㄍㄣˊ") + XCTAssertEqual(c.cS2RC("epr"), "ㄍㄣˇ") + XCTAssertEqual(c.cS2RC("epd"), "ㄍㄣˋ") + XCTAssertEqual(c.cS2RC("ell"), "ㄍㄤ") + XCTAssertEqual(c.cS2RC("ellr"), "ㄍㄤˇ") + XCTAssertEqual(c.cS2RC("elld"), "ㄍㄤˋ") + XCTAssertEqual(c.cS2RC("en"), "ㄍㄥ") + XCTAssertEqual(c.cS2RC("enr"), "ㄍㄥˇ") + XCTAssertEqual(c.cS2RC("end"), "ㄍㄥˋ") + XCTAssertEqual(c.cS2RC("ej"), "ㄍㄨ") + XCTAssertEqual(c.cS2RC("eje"), "ㄍㄨˊ") + XCTAssertEqual(c.cS2RC("ejr"), "ㄍㄨˇ") + XCTAssertEqual(c.cS2RC("ejd"), "ㄍㄨˋ") + XCTAssertEqual(c.cS2RC("eju"), "ㄍㄨㄚ") + XCTAssertEqual(c.cS2RC("ejue"), "ㄍㄨㄚˊ") + XCTAssertEqual(c.cS2RC("ejur"), "ㄍㄨㄚˇ") + XCTAssertEqual(c.cS2RC("ejud"), "ㄍㄨㄚˋ") + XCTAssertEqual(c.cS2RC("eji"), "ㄍㄨㄛ") + XCTAssertEqual(c.cS2RC("ejie"), "ㄍㄨㄛˊ") + XCTAssertEqual(c.cS2RC("ejir"), "ㄍㄨㄛˇ") + XCTAssertEqual(c.cS2RC("ejid"), "ㄍㄨㄛˋ") + XCTAssertEqual(c.cS2RC("ejii"), "ㄍㄨㄞ") + XCTAssertEqual(c.cS2RC("ejiir"), "ㄍㄨㄞˇ") + XCTAssertEqual(c.cS2RC("ejiid"), "ㄍㄨㄞˋ") + XCTAssertEqual(c.cS2RC("ejo"), "ㄍㄨㄟ") + XCTAssertEqual(c.cS2RC("ejor"), "ㄍㄨㄟˇ") + XCTAssertEqual(c.cS2RC("ejod"), "ㄍㄨㄟˋ") + XCTAssertEqual(c.cS2RC("ejoo"), "ㄍㄨㄢ") + XCTAssertEqual(c.cS2RC("ejoor"), "ㄍㄨㄢˇ") + XCTAssertEqual(c.cS2RC("ejood"), "ㄍㄨㄢˋ") + XCTAssertEqual(c.cS2RC("ejp"), "ㄍㄨㄣ") + XCTAssertEqual(c.cS2RC("ejpr"), "ㄍㄨㄣˇ") + XCTAssertEqual(c.cS2RC("ejpd"), "ㄍㄨㄣˋ") + XCTAssertEqual(c.cS2RC("ejll"), "ㄍㄨㄤ") + XCTAssertEqual(c.cS2RC("ejllr"), "ㄍㄨㄤˇ") + XCTAssertEqual(c.cS2RC("ejlld"), "ㄍㄨㄤˋ") + XCTAssertEqual(c.cS2RC("ejn"), "ㄍㄨㄥ") + XCTAssertEqual(c.cS2RC("ejne"), "ㄍㄨㄥˊ") + XCTAssertEqual(c.cS2RC("ejnr"), "ㄍㄨㄥˇ") + XCTAssertEqual(c.cS2RC("ejnd"), "ㄍㄨㄥˋ") + XCTAssertEqual(c.cS2RC("duu"), "ㄎㄚ") + XCTAssertEqual(c.cS2RC("duur"), "ㄎㄚˇ") + XCTAssertEqual(c.cS2RC("duud"), "ㄎㄚˋ") + XCTAssertEqual(c.cS2RC("dk"), "ㄎㄜ") + XCTAssertEqual(c.cS2RC("dke"), "ㄎㄜˊ") + XCTAssertEqual(c.cS2RC("dkr"), "ㄎㄜˇ") + XCTAssertEqual(c.cS2RC("dkd"), "ㄎㄜˋ") + XCTAssertEqual(c.cS2RC("dii"), "ㄎㄞ") + XCTAssertEqual(c.cS2RC("diir"), "ㄎㄞˇ") + XCTAssertEqual(c.cS2RC("diid"), "ㄎㄞˋ") + XCTAssertEqual(c.cS2RC("dl"), "ㄎㄠ") + XCTAssertEqual(c.cS2RC("dlr"), "ㄎㄠˇ") + XCTAssertEqual(c.cS2RC("dld"), "ㄎㄠˋ") + XCTAssertEqual(c.cS2RC("dm"), "ㄎㄡ") + XCTAssertEqual(c.cS2RC("dmr"), "ㄎㄡˇ") + XCTAssertEqual(c.cS2RC("dmd"), "ㄎㄡˋ") + XCTAssertEqual(c.cS2RC("doo"), "ㄎㄢ") + XCTAssertEqual(c.cS2RC("door"), "ㄎㄢˇ") + XCTAssertEqual(c.cS2RC("dood"), "ㄎㄢˋ") + XCTAssertEqual(c.cS2RC("dp"), "ㄎㄣ") + XCTAssertEqual(c.cS2RC("dpr"), "ㄎㄣˇ") + XCTAssertEqual(c.cS2RC("dpd"), "ㄎㄣˋ") + XCTAssertEqual(c.cS2RC("dll"), "ㄎㄤ") + XCTAssertEqual(c.cS2RC("dlle"), "ㄎㄤˊ") + XCTAssertEqual(c.cS2RC("dllr"), "ㄎㄤˇ") + XCTAssertEqual(c.cS2RC("dlld"), "ㄎㄤˋ") + XCTAssertEqual(c.cS2RC("dn"), "ㄎㄥ") + XCTAssertEqual(c.cS2RC("dnr"), "ㄎㄥˇ") + XCTAssertEqual(c.cS2RC("dj"), "ㄎㄨ") + XCTAssertEqual(c.cS2RC("dje"), "ㄎㄨˊ") + XCTAssertEqual(c.cS2RC("djr"), "ㄎㄨˇ") + XCTAssertEqual(c.cS2RC("djd"), "ㄎㄨˋ") + XCTAssertEqual(c.cS2RC("dju"), "ㄎㄨㄚ") + XCTAssertEqual(c.cS2RC("djur"), "ㄎㄨㄚˇ") + XCTAssertEqual(c.cS2RC("djud"), "ㄎㄨㄚˋ") + XCTAssertEqual(c.cS2RC("djid"), "ㄎㄨㄛˋ") + XCTAssertEqual(c.cS2RC("djii"), "ㄎㄨㄞ") + XCTAssertEqual(c.cS2RC("djiir"), "ㄎㄨㄞˇ") + XCTAssertEqual(c.cS2RC("djiid"), "ㄎㄨㄞˋ") + XCTAssertEqual(c.cS2RC("djo"), "ㄎㄨㄟ") + XCTAssertEqual(c.cS2RC("djoe"), "ㄎㄨㄟˊ") + XCTAssertEqual(c.cS2RC("djor"), "ㄎㄨㄟˇ") + XCTAssertEqual(c.cS2RC("djod"), "ㄎㄨㄟˋ") + XCTAssertEqual(c.cS2RC("djoo"), "ㄎㄨㄢ") + XCTAssertEqual(c.cS2RC("djoor"), "ㄎㄨㄢˇ") + XCTAssertEqual(c.cS2RC("djood"), "ㄎㄨㄢˋ") + XCTAssertEqual(c.cS2RC("djp"), "ㄎㄨㄣ") + XCTAssertEqual(c.cS2RC("djpr"), "ㄎㄨㄣˇ") + XCTAssertEqual(c.cS2RC("djpd"), "ㄎㄨㄣˋ") + XCTAssertEqual(c.cS2RC("djll"), "ㄎㄨㄤ") + XCTAssertEqual(c.cS2RC("djlle"), "ㄎㄨㄤˊ") + XCTAssertEqual(c.cS2RC("djllr"), "ㄎㄨㄤˇ") + XCTAssertEqual(c.cS2RC("djlld"), "ㄎㄨㄤˋ") + XCTAssertEqual(c.cS2RC("djn"), "ㄎㄨㄥ") + XCTAssertEqual(c.cS2RC("djnr"), "ㄎㄨㄥˇ") + XCTAssertEqual(c.cS2RC("djnd"), "ㄎㄨㄥˋ") + XCTAssertEqual(c.cS2RC("cuu"), "ㄏㄚ") + XCTAssertEqual(c.cS2RC("cuue"), "ㄏㄚˊ") + XCTAssertEqual(c.cS2RC("cuur"), "ㄏㄚˇ") + XCTAssertEqual(c.cS2RC("ck"), "ㄏㄜ") + XCTAssertEqual(c.cS2RC("cke"), "ㄏㄜˊ") + XCTAssertEqual(c.cS2RC("ckr"), "ㄏㄜˇ") + XCTAssertEqual(c.cS2RC("ckd"), "ㄏㄜˋ") + XCTAssertEqual(c.cS2RC("cii"), "ㄏㄞ") + XCTAssertEqual(c.cS2RC("ciie"), "ㄏㄞˊ") + XCTAssertEqual(c.cS2RC("ciir"), "ㄏㄞˇ") + XCTAssertEqual(c.cS2RC("ciid"), "ㄏㄞˋ") + XCTAssertEqual(c.cS2RC("co"), "ㄏㄟ") + XCTAssertEqual(c.cS2RC("cor"), "ㄏㄟˇ") + XCTAssertEqual(c.cS2RC("cl"), "ㄏㄠ") + XCTAssertEqual(c.cS2RC("cle"), "ㄏㄠˊ") + XCTAssertEqual(c.cS2RC("clr"), "ㄏㄠˇ") + XCTAssertEqual(c.cS2RC("cld"), "ㄏㄠˋ") + XCTAssertEqual(c.cS2RC("cm"), "ㄏㄡ") + XCTAssertEqual(c.cS2RC("cme"), "ㄏㄡˊ") + XCTAssertEqual(c.cS2RC("cmr"), "ㄏㄡˇ") + XCTAssertEqual(c.cS2RC("cmd"), "ㄏㄡˋ") + XCTAssertEqual(c.cS2RC("coo"), "ㄏㄢ") + XCTAssertEqual(c.cS2RC("cooe"), "ㄏㄢˊ") + XCTAssertEqual(c.cS2RC("coor"), "ㄏㄢˇ") + XCTAssertEqual(c.cS2RC("cood"), "ㄏㄢˋ") + XCTAssertEqual(c.cS2RC("cp"), "ㄏㄣ") + XCTAssertEqual(c.cS2RC("cpe"), "ㄏㄣˊ") + XCTAssertEqual(c.cS2RC("cpr"), "ㄏㄣˇ") + XCTAssertEqual(c.cS2RC("cpd"), "ㄏㄣˋ") + XCTAssertEqual(c.cS2RC("cll"), "ㄏㄤ") + XCTAssertEqual(c.cS2RC("clle"), "ㄏㄤˊ") + XCTAssertEqual(c.cS2RC("cllr"), "ㄏㄤˇ") + XCTAssertEqual(c.cS2RC("clld"), "ㄏㄤˋ") + XCTAssertEqual(c.cS2RC("cn"), "ㄏㄥ") + XCTAssertEqual(c.cS2RC("cne"), "ㄏㄥˊ") + XCTAssertEqual(c.cS2RC("cnd"), "ㄏㄥˋ") + XCTAssertEqual(c.cS2RC("cj"), "ㄏㄨ") + XCTAssertEqual(c.cS2RC("cje"), "ㄏㄨˊ") + XCTAssertEqual(c.cS2RC("cjr"), "ㄏㄨˇ") + XCTAssertEqual(c.cS2RC("cjd"), "ㄏㄨˋ") + XCTAssertEqual(c.cS2RC("cju"), "ㄏㄨㄚ") + XCTAssertEqual(c.cS2RC("cjue"), "ㄏㄨㄚˊ") + XCTAssertEqual(c.cS2RC("cjur"), "ㄏㄨㄚˇ") + XCTAssertEqual(c.cS2RC("cjud"), "ㄏㄨㄚˋ") + XCTAssertEqual(c.cS2RC("cji"), "ㄏㄨㄛ") + XCTAssertEqual(c.cS2RC("cjie"), "ㄏㄨㄛˊ") + XCTAssertEqual(c.cS2RC("cjir"), "ㄏㄨㄛˇ") + XCTAssertEqual(c.cS2RC("cjid"), "ㄏㄨㄛˋ") + XCTAssertEqual(c.cS2RC("cjiy"), "ㄏㄨㄛ˙") + XCTAssertEqual(c.cS2RC("cjiie"), "ㄏㄨㄞˊ") + XCTAssertEqual(c.cS2RC("cjiid"), "ㄏㄨㄞˋ") + XCTAssertEqual(c.cS2RC("cjo"), "ㄏㄨㄟ") + XCTAssertEqual(c.cS2RC("cjoe"), "ㄏㄨㄟˊ") + XCTAssertEqual(c.cS2RC("cjor"), "ㄏㄨㄟˇ") + XCTAssertEqual(c.cS2RC("cjod"), "ㄏㄨㄟˋ") + XCTAssertEqual(c.cS2RC("cjoo"), "ㄏㄨㄢ") + XCTAssertEqual(c.cS2RC("cjooe"), "ㄏㄨㄢˊ") + XCTAssertEqual(c.cS2RC("cjoor"), "ㄏㄨㄢˇ") + XCTAssertEqual(c.cS2RC("cjood"), "ㄏㄨㄢˋ") + XCTAssertEqual(c.cS2RC("cjp"), "ㄏㄨㄣ") + XCTAssertEqual(c.cS2RC("cjpe"), "ㄏㄨㄣˊ") + XCTAssertEqual(c.cS2RC("cjpr"), "ㄏㄨㄣˇ") + XCTAssertEqual(c.cS2RC("cjpd"), "ㄏㄨㄣˋ") + XCTAssertEqual(c.cS2RC("cjll"), "ㄏㄨㄤ") + XCTAssertEqual(c.cS2RC("cjlle"), "ㄏㄨㄤˊ") + XCTAssertEqual(c.cS2RC("cjllr"), "ㄏㄨㄤˇ") + XCTAssertEqual(c.cS2RC("cjlld"), "ㄏㄨㄤˋ") + XCTAssertEqual(c.cS2RC("cjlly"), "ㄏㄨㄤ˙") + XCTAssertEqual(c.cS2RC("cjn"), "ㄏㄨㄥ") + XCTAssertEqual(c.cS2RC("cjne"), "ㄏㄨㄥˊ") + XCTAssertEqual(c.cS2RC("cjnr"), "ㄏㄨㄥˇ") + XCTAssertEqual(c.cS2RC("cjnd"), "ㄏㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ru"), "ㄐㄧ") + XCTAssertEqual(c.cS2RC("rue"), "ㄐㄧˊ") + XCTAssertEqual(c.cS2RC("rur"), "ㄐㄧˇ") + XCTAssertEqual(c.cS2RC("rud"), "ㄐㄧˋ") + XCTAssertEqual(c.cS2RC("ruuu"), "ㄐㄧㄚ") + XCTAssertEqual(c.cS2RC("ruuue"), "ㄐㄧㄚˊ") + XCTAssertEqual(c.cS2RC("ruuur"), "ㄐㄧㄚˇ") + XCTAssertEqual(c.cS2RC("ruuud"), "ㄐㄧㄚˋ") + XCTAssertEqual(c.cS2RC("rub"), "ㄐㄧㄝ") + XCTAssertEqual(c.cS2RC("rube"), "ㄐㄧㄝˊ") + XCTAssertEqual(c.cS2RC("rubr"), "ㄐㄧㄝˇ") + XCTAssertEqual(c.cS2RC("rubd"), "ㄐㄧㄝˋ") + XCTAssertEqual(c.cS2RC("ruby"), "ㄐㄧㄝ˙") + XCTAssertEqual(c.cS2RC("rul"), "ㄐㄧㄠ") + XCTAssertEqual(c.cS2RC("rule"), "ㄐㄧㄠˊ") + XCTAssertEqual(c.cS2RC("rulr"), "ㄐㄧㄠˇ") + XCTAssertEqual(c.cS2RC("ruld"), "ㄐㄧㄠˋ") + XCTAssertEqual(c.cS2RC("rum"), "ㄐㄧㄡ") + XCTAssertEqual(c.cS2RC("rumr"), "ㄐㄧㄡˇ") + XCTAssertEqual(c.cS2RC("rumd"), "ㄐㄧㄡˋ") + XCTAssertEqual(c.cS2RC("ruoo"), "ㄐㄧㄢ") + XCTAssertEqual(c.cS2RC("ruoor"), "ㄐㄧㄢˇ") + XCTAssertEqual(c.cS2RC("ruood"), "ㄐㄧㄢˋ") + XCTAssertEqual(c.cS2RC("rup"), "ㄐㄧㄣ") + XCTAssertEqual(c.cS2RC("rupr"), "ㄐㄧㄣˇ") + XCTAssertEqual(c.cS2RC("rupd"), "ㄐㄧㄣˋ") + XCTAssertEqual(c.cS2RC("rull"), "ㄐㄧㄤ") + XCTAssertEqual(c.cS2RC("rulle"), "ㄐㄧㄤˊ") + XCTAssertEqual(c.cS2RC("rullr"), "ㄐㄧㄤˇ") + XCTAssertEqual(c.cS2RC("rulld"), "ㄐㄧㄤˋ") + XCTAssertEqual(c.cS2RC("run"), "ㄐㄧㄥ") + XCTAssertEqual(c.cS2RC("runr"), "ㄐㄧㄥˇ") + XCTAssertEqual(c.cS2RC("rund"), "ㄐㄧㄥˋ") + XCTAssertEqual(c.cS2RC("rm"), "ㄐㄩ") + XCTAssertEqual(c.cS2RC("rme"), "ㄐㄩˊ") + XCTAssertEqual(c.cS2RC("rmr"), "ㄐㄩˇ") + XCTAssertEqual(c.cS2RC("rmd"), "ㄐㄩˋ") + XCTAssertEqual(c.cS2RC("rmb"), "ㄐㄩㄝ") + XCTAssertEqual(c.cS2RC("rmbe"), "ㄐㄩㄝˊ") + XCTAssertEqual(c.cS2RC("rmbr"), "ㄐㄩㄝˇ") + XCTAssertEqual(c.cS2RC("rmbd"), "ㄐㄩㄝˋ") + XCTAssertEqual(c.cS2RC("rmoo"), "ㄐㄩㄢ") + XCTAssertEqual(c.cS2RC("rmoor"), "ㄐㄩㄢˇ") + XCTAssertEqual(c.cS2RC("rmood"), "ㄐㄩㄢˋ") + XCTAssertEqual(c.cS2RC("rmp"), "ㄐㄩㄣ") + XCTAssertEqual(c.cS2RC("rmpe"), "ㄐㄩㄣˊ") + XCTAssertEqual(c.cS2RC("rmpr"), "ㄐㄩㄣˇ") + XCTAssertEqual(c.cS2RC("rmpd"), "ㄐㄩㄣˋ") + XCTAssertEqual(c.cS2RC("rmn"), "ㄐㄩㄥ") + XCTAssertEqual(c.cS2RC("rmnr"), "ㄐㄩㄥˇ") + XCTAssertEqual(c.cS2RC("rmnd"), "ㄐㄩㄥˋ") + XCTAssertEqual(c.cS2RC("fy"), "ㄑ˙") + XCTAssertEqual(c.cS2RC("fu"), "ㄑㄧ") + XCTAssertEqual(c.cS2RC("fue"), "ㄑㄧˊ") + XCTAssertEqual(c.cS2RC("fur"), "ㄑㄧˇ") + XCTAssertEqual(c.cS2RC("fud"), "ㄑㄧˋ") + XCTAssertEqual(c.cS2RC("fuuu"), "ㄑㄧㄚ") + XCTAssertEqual(c.cS2RC("fuuue"), "ㄑㄧㄚˊ") + XCTAssertEqual(c.cS2RC("fuuur"), "ㄑㄧㄚˇ") + XCTAssertEqual(c.cS2RC("fuuud"), "ㄑㄧㄚˋ") + XCTAssertEqual(c.cS2RC("fub"), "ㄑㄧㄝ") + XCTAssertEqual(c.cS2RC("fube"), "ㄑㄧㄝˊ") + XCTAssertEqual(c.cS2RC("fubr"), "ㄑㄧㄝˇ") + XCTAssertEqual(c.cS2RC("fubd"), "ㄑㄧㄝˋ") + XCTAssertEqual(c.cS2RC("ful"), "ㄑㄧㄠ") + XCTAssertEqual(c.cS2RC("fule"), "ㄑㄧㄠˊ") + XCTAssertEqual(c.cS2RC("fulr"), "ㄑㄧㄠˇ") + XCTAssertEqual(c.cS2RC("fuld"), "ㄑㄧㄠˋ") + XCTAssertEqual(c.cS2RC("fum"), "ㄑㄧㄡ") + XCTAssertEqual(c.cS2RC("fume"), "ㄑㄧㄡˊ") + XCTAssertEqual(c.cS2RC("fumr"), "ㄑㄧㄡˇ") + XCTAssertEqual(c.cS2RC("fumd"), "ㄑㄧㄡˋ") + XCTAssertEqual(c.cS2RC("fuoo"), "ㄑㄧㄢ") + XCTAssertEqual(c.cS2RC("fuooe"), "ㄑㄧㄢˊ") + XCTAssertEqual(c.cS2RC("fuoor"), "ㄑㄧㄢˇ") + XCTAssertEqual(c.cS2RC("fuood"), "ㄑㄧㄢˋ") + XCTAssertEqual(c.cS2RC("fup"), "ㄑㄧㄣ") + XCTAssertEqual(c.cS2RC("fupe"), "ㄑㄧㄣˊ") + XCTAssertEqual(c.cS2RC("fupr"), "ㄑㄧㄣˇ") + XCTAssertEqual(c.cS2RC("fupd"), "ㄑㄧㄣˋ") + XCTAssertEqual(c.cS2RC("full"), "ㄑㄧㄤ") + XCTAssertEqual(c.cS2RC("fulle"), "ㄑㄧㄤˊ") + XCTAssertEqual(c.cS2RC("fullr"), "ㄑㄧㄤˇ") + XCTAssertEqual(c.cS2RC("fulld"), "ㄑㄧㄤˋ") + XCTAssertEqual(c.cS2RC("fun"), "ㄑㄧㄥ") + XCTAssertEqual(c.cS2RC("fune"), "ㄑㄧㄥˊ") + XCTAssertEqual(c.cS2RC("funr"), "ㄑㄧㄥˇ") + XCTAssertEqual(c.cS2RC("fund"), "ㄑㄧㄥˋ") + XCTAssertEqual(c.cS2RC("fm"), "ㄑㄩ") + XCTAssertEqual(c.cS2RC("fme"), "ㄑㄩˊ") + XCTAssertEqual(c.cS2RC("fmr"), "ㄑㄩˇ") + XCTAssertEqual(c.cS2RC("fmd"), "ㄑㄩˋ") + XCTAssertEqual(c.cS2RC("fmb"), "ㄑㄩㄝ") + XCTAssertEqual(c.cS2RC("fmbe"), "ㄑㄩㄝˊ") + XCTAssertEqual(c.cS2RC("fmbd"), "ㄑㄩㄝˋ") + XCTAssertEqual(c.cS2RC("fmoo"), "ㄑㄩㄢ") + XCTAssertEqual(c.cS2RC("fmooe"), "ㄑㄩㄢˊ") + XCTAssertEqual(c.cS2RC("fmoor"), "ㄑㄩㄢˇ") + XCTAssertEqual(c.cS2RC("fmood"), "ㄑㄩㄢˋ") + XCTAssertEqual(c.cS2RC("fmp"), "ㄑㄩㄣ") + XCTAssertEqual(c.cS2RC("fmpe"), "ㄑㄩㄣˊ") + XCTAssertEqual(c.cS2RC("fmpr"), "ㄑㄩㄣˇ") + XCTAssertEqual(c.cS2RC("fmpd"), "ㄑㄩㄣˋ") + XCTAssertEqual(c.cS2RC("fmn"), "ㄑㄩㄥ") + XCTAssertEqual(c.cS2RC("fmne"), "ㄑㄩㄥˊ") + XCTAssertEqual(c.cS2RC("fmnr"), "ㄑㄩㄥˇ") + XCTAssertEqual(c.cS2RC("fmnd"), "ㄑㄩㄥˋ") + XCTAssertEqual(c.cS2RC("vu"), "ㄒㄧ") + XCTAssertEqual(c.cS2RC("vue"), "ㄒㄧˊ") + XCTAssertEqual(c.cS2RC("vur"), "ㄒㄧˇ") + XCTAssertEqual(c.cS2RC("vud"), "ㄒㄧˋ") + XCTAssertEqual(c.cS2RC("vuuu"), "ㄒㄧㄚ") + XCTAssertEqual(c.cS2RC("vuuue"), "ㄒㄧㄚˊ") + XCTAssertEqual(c.cS2RC("vuuur"), "ㄒㄧㄚˇ") + XCTAssertEqual(c.cS2RC("vuuud"), "ㄒㄧㄚˋ") + XCTAssertEqual(c.cS2RC("vub"), "ㄒㄧㄝ") + XCTAssertEqual(c.cS2RC("vube"), "ㄒㄧㄝˊ") + XCTAssertEqual(c.cS2RC("vubr"), "ㄒㄧㄝˇ") + XCTAssertEqual(c.cS2RC("vubd"), "ㄒㄧㄝˋ") + XCTAssertEqual(c.cS2RC("vul"), "ㄒㄧㄠ") + XCTAssertEqual(c.cS2RC("vule"), "ㄒㄧㄠˊ") + XCTAssertEqual(c.cS2RC("vulr"), "ㄒㄧㄠˇ") + XCTAssertEqual(c.cS2RC("vuld"), "ㄒㄧㄠˋ") + XCTAssertEqual(c.cS2RC("vum"), "ㄒㄧㄡ") + XCTAssertEqual(c.cS2RC("vume"), "ㄒㄧㄡˊ") + XCTAssertEqual(c.cS2RC("vumr"), "ㄒㄧㄡˇ") + XCTAssertEqual(c.cS2RC("vumd"), "ㄒㄧㄡˋ") + XCTAssertEqual(c.cS2RC("vuoo"), "ㄒㄧㄢ") + XCTAssertEqual(c.cS2RC("vuooe"), "ㄒㄧㄢˊ") + XCTAssertEqual(c.cS2RC("vuoor"), "ㄒㄧㄢˇ") + XCTAssertEqual(c.cS2RC("vuood"), "ㄒㄧㄢˋ") + XCTAssertEqual(c.cS2RC("vup"), "ㄒㄧㄣ") + XCTAssertEqual(c.cS2RC("vupe"), "ㄒㄧㄣˊ") + XCTAssertEqual(c.cS2RC("vupr"), "ㄒㄧㄣˇ") + XCTAssertEqual(c.cS2RC("vupd"), "ㄒㄧㄣˋ") + XCTAssertEqual(c.cS2RC("vull"), "ㄒㄧㄤ") + XCTAssertEqual(c.cS2RC("vulle"), "ㄒㄧㄤˊ") + XCTAssertEqual(c.cS2RC("vullr"), "ㄒㄧㄤˇ") + XCTAssertEqual(c.cS2RC("vulld"), "ㄒㄧㄤˋ") + XCTAssertEqual(c.cS2RC("vun"), "ㄒㄧㄥ") + XCTAssertEqual(c.cS2RC("vune"), "ㄒㄧㄥˊ") + XCTAssertEqual(c.cS2RC("vunr"), "ㄒㄧㄥˇ") + XCTAssertEqual(c.cS2RC("vund"), "ㄒㄧㄥˋ") + XCTAssertEqual(c.cS2RC("vm"), "ㄒㄩ") + XCTAssertEqual(c.cS2RC("vme"), "ㄒㄩˊ") + XCTAssertEqual(c.cS2RC("vmr"), "ㄒㄩˇ") + XCTAssertEqual(c.cS2RC("vmd"), "ㄒㄩˋ") + XCTAssertEqual(c.cS2RC("vmb"), "ㄒㄩㄝ") + XCTAssertEqual(c.cS2RC("vmbe"), "ㄒㄩㄝˊ") + XCTAssertEqual(c.cS2RC("vmbr"), "ㄒㄩㄝˇ") + XCTAssertEqual(c.cS2RC("vmbd"), "ㄒㄩㄝˋ") + XCTAssertEqual(c.cS2RC("vmoo"), "ㄒㄩㄢ") + XCTAssertEqual(c.cS2RC("vmooe"), "ㄒㄩㄢˊ") + XCTAssertEqual(c.cS2RC("vmoor"), "ㄒㄩㄢˇ") + XCTAssertEqual(c.cS2RC("vmood"), "ㄒㄩㄢˋ") + XCTAssertEqual(c.cS2RC("vmp"), "ㄒㄩㄣ") + XCTAssertEqual(c.cS2RC("vmpe"), "ㄒㄩㄣˊ") + XCTAssertEqual(c.cS2RC("vmpd"), "ㄒㄩㄣˋ") + XCTAssertEqual(c.cS2RC("vmn"), "ㄒㄩㄥ") + XCTAssertEqual(c.cS2RC("vmne"), "ㄒㄩㄥˊ") + XCTAssertEqual(c.cS2RC("vmnr"), "ㄒㄩㄥˇ") + XCTAssertEqual(c.cS2RC("vmnd"), "ㄒㄩㄥˋ") + XCTAssertEqual(c.cS2RC("tt"), "ㄓ") + XCTAssertEqual(c.cS2RC("tte"), "ㄓˊ") + XCTAssertEqual(c.cS2RC("ttr"), "ㄓˇ") + XCTAssertEqual(c.cS2RC("ttd"), "ㄓˋ") + XCTAssertEqual(c.cS2RC("ttuu"), "ㄓㄚ") + XCTAssertEqual(c.cS2RC("ttuue"), "ㄓㄚˊ") + XCTAssertEqual(c.cS2RC("ttuur"), "ㄓㄚˇ") + XCTAssertEqual(c.cS2RC("ttuud"), "ㄓㄚˋ") + XCTAssertEqual(c.cS2RC("ttk"), "ㄓㄜ") + XCTAssertEqual(c.cS2RC("ttke"), "ㄓㄜˊ") + XCTAssertEqual(c.cS2RC("ttkr"), "ㄓㄜˇ") + XCTAssertEqual(c.cS2RC("ttkd"), "ㄓㄜˋ") + XCTAssertEqual(c.cS2RC("ttky"), "ㄓㄜ˙") + XCTAssertEqual(c.cS2RC("ttii"), "ㄓㄞ") + XCTAssertEqual(c.cS2RC("ttiie"), "ㄓㄞˊ") + XCTAssertEqual(c.cS2RC("ttiir"), "ㄓㄞˇ") + XCTAssertEqual(c.cS2RC("ttiid"), "ㄓㄞˋ") + XCTAssertEqual(c.cS2RC("ttod"), "ㄓㄟˋ") + XCTAssertEqual(c.cS2RC("ttl"), "ㄓㄠ") + XCTAssertEqual(c.cS2RC("ttle"), "ㄓㄠˊ") + XCTAssertEqual(c.cS2RC("ttlr"), "ㄓㄠˇ") + XCTAssertEqual(c.cS2RC("ttld"), "ㄓㄠˋ") + XCTAssertEqual(c.cS2RC("ttm"), "ㄓㄡ") + XCTAssertEqual(c.cS2RC("ttme"), "ㄓㄡˊ") + XCTAssertEqual(c.cS2RC("ttmr"), "ㄓㄡˇ") + XCTAssertEqual(c.cS2RC("ttmd"), "ㄓㄡˋ") + XCTAssertEqual(c.cS2RC("ttoo"), "ㄓㄢ") + XCTAssertEqual(c.cS2RC("ttoor"), "ㄓㄢˇ") + XCTAssertEqual(c.cS2RC("ttood"), "ㄓㄢˋ") + XCTAssertEqual(c.cS2RC("ttp"), "ㄓㄣ") + XCTAssertEqual(c.cS2RC("ttpe"), "ㄓㄣˊ") + XCTAssertEqual(c.cS2RC("ttpr"), "ㄓㄣˇ") + XCTAssertEqual(c.cS2RC("ttpd"), "ㄓㄣˋ") + XCTAssertEqual(c.cS2RC("ttll"), "ㄓㄤ") + XCTAssertEqual(c.cS2RC("ttllr"), "ㄓㄤˇ") + XCTAssertEqual(c.cS2RC("ttlld"), "ㄓㄤˋ") + XCTAssertEqual(c.cS2RC("ttn"), "ㄓㄥ") + XCTAssertEqual(c.cS2RC("ttnr"), "ㄓㄥˇ") + XCTAssertEqual(c.cS2RC("ttnd"), "ㄓㄥˋ") + XCTAssertEqual(c.cS2RC("ttj"), "ㄓㄨ") + XCTAssertEqual(c.cS2RC("ttje"), "ㄓㄨˊ") + XCTAssertEqual(c.cS2RC("ttjr"), "ㄓㄨˇ") + XCTAssertEqual(c.cS2RC("ttjd"), "ㄓㄨˋ") + XCTAssertEqual(c.cS2RC("ttju"), "ㄓㄨㄚ") + XCTAssertEqual(c.cS2RC("ttjur"), "ㄓㄨㄚˇ") + XCTAssertEqual(c.cS2RC("ttji"), "ㄓㄨㄛ") + XCTAssertEqual(c.cS2RC("ttjie"), "ㄓㄨㄛˊ") + XCTAssertEqual(c.cS2RC("ttjid"), "ㄓㄨㄛˋ") + XCTAssertEqual(c.cS2RC("ttjii"), "ㄓㄨㄞ") + XCTAssertEqual(c.cS2RC("ttjiir"), "ㄓㄨㄞˇ") } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_C.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_C.swift index b7798e16..7b04c1c7 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_C.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_C.swift @@ -12,509 +12,509 @@ import XCTest extension TekkonTestsKeyboardArrangments { func testDachen26KeysC() throws { - var composer = Tekkon.Composer(arrange: .ofDachen26) - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjiid"), "ㄓㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjo"), "ㄓㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjor"), "ㄓㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjod"), "ㄓㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjoo"), "ㄓㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjoor"), "ㄓㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjood"), "ㄓㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjp"), "ㄓㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjpr"), "ㄓㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjpd"), "ㄓㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjll"), "ㄓㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjllr"), "ㄓㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjlld"), "ㄓㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjn"), "ㄓㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjnr"), "ㄓㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttjnd"), "ㄓㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("t "), "ㄔ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("te"), "ㄔˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tr"), "ㄔˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("td"), "ㄔˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tuu"), "ㄔㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tuue"), "ㄔㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tuur"), "ㄔㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tuud"), "ㄔㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tk "), "ㄔㄜ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tkr"), "ㄔㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tkd"), "ㄔㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tii"), "ㄔㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tiie"), "ㄔㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tiir"), "ㄔㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tiid"), "ㄔㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tl"), "ㄔㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tle"), "ㄔㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tlr"), "ㄔㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tld"), "ㄔㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tm"), "ㄔㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tme"), "ㄔㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tmr"), "ㄔㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tmd"), "ㄔㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("too "), "ㄔㄢ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tooe"), "ㄔㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("toor"), "ㄔㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tood"), "ㄔㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tp "), "ㄔㄣ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tpe"), "ㄔㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tpr"), "ㄔㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tpd"), "ㄔㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tpy"), "ㄔㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("tll "), "ㄔㄤ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tlle"), "ㄔㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tllr"), "ㄔㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tlld"), "ㄔㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tn "), "ㄔㄥ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tne"), "ㄔㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tnr"), "ㄔㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tnd"), "ㄔㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tj"), "ㄔㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tje"), "ㄔㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjr"), "ㄔㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjd"), "ㄔㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tju"), "ㄔㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjur"), "ㄔㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjud"), "ㄔㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tji"), "ㄔㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjid"), "ㄔㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjii"), "ㄔㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjiie"), "ㄔㄨㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjiir"), "ㄔㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjiid"), "ㄔㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjo"), "ㄔㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjoe"), "ㄔㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjor"), "ㄔㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjod"), "ㄔㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjoo"), "ㄔㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjooe"), "ㄔㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjoor"), "ㄔㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjood"), "ㄔㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjp"), "ㄔㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjpe"), "ㄔㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjpr"), "ㄔㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjll"), "ㄔㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjlle"), "ㄔㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjllr"), "ㄔㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjlld"), "ㄔㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjn"), "ㄔㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjne"), "ㄔㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjnr"), "ㄔㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tjnd"), "ㄔㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("g"), "ㄕ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ge"), "ㄕˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gr"), "ㄕˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gd"), "ㄕˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gy"), "ㄕ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("guu"), "ㄕㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guue"), "ㄕㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guur"), "ㄕㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guud"), "ㄕㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guuy"), "ㄕㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("gk"), "ㄕㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gke"), "ㄕㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gkr"), "ㄕㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gkd"), "ㄕㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gii"), "ㄕㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("giir"), "ㄕㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("giid"), "ㄕㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("goe"), "ㄕㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gl"), "ㄕㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gle"), "ㄕㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("glr"), "ㄕㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gld"), "ㄕㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gm"), "ㄕㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gme"), "ㄕㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gmr"), "ㄕㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gmd"), "ㄕㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("goo"), "ㄕㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gooe"), "ㄕㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("goor"), "ㄕㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("good"), "ㄕㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gp"), "ㄕㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gpe"), "ㄕㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gpr"), "ㄕㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gpd"), "ㄕㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gll"), "ㄕㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gllr"), "ㄕㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("glld"), "ㄕㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("glly"), "ㄕㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("gn"), "ㄕㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gne"), "ㄕㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gnr"), "ㄕㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gnd"), "ㄕㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gj"), "ㄕㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gje"), "ㄕㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjr"), "ㄕㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjd"), "ㄕㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gju"), "ㄕㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjur"), "ㄕㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjud"), "ㄕㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gji"), "ㄕㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjid"), "ㄕㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjii"), "ㄕㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjiir"), "ㄕㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjiid"), "ㄕㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjo"), "ㄕㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjoe"), "ㄕㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjor"), "ㄕㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjod"), "ㄕㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjoo"), "ㄕㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjood"), "ㄕㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjpr"), "ㄕㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjpd"), "ㄕㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjll"), "ㄕㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjlle"), "ㄕㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjllr"), "ㄕㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gjlld"), "ㄕㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bd"), "ㄖˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bkr"), "ㄖㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bkd"), "ㄖㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ble"), "ㄖㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("blr"), "ㄖㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bld"), "ㄖㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bme"), "ㄖㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bmr"), "ㄖㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bmd"), "ㄖㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("booe"), "ㄖㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("boor"), "ㄖㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bood"), "ㄖㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bpe"), "ㄖㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bpr"), "ㄖㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bpd"), "ㄖㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bll"), "ㄖㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("blle"), "ㄖㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bllr"), "ㄖㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("blld"), "ㄖㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bn"), "ㄖㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bne"), "ㄖㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bnr"), "ㄖㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bnd"), "ㄖㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bje"), "ㄖㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjr"), "ㄖㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjd"), "ㄖㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjie"), "ㄖㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjid"), "ㄖㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjoe"), "ㄖㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjor"), "ㄖㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjod"), "ㄖㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjooe"), "ㄖㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjoor"), "ㄖㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjood"), "ㄖㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjpe"), "ㄖㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjpr"), "ㄖㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjpd"), "ㄖㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjne"), "ㄖㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjnr"), "ㄖㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bjnd"), "ㄖㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("y"), "ㄗ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ye"), "ㄗˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yr"), "ㄗˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yd"), "ㄗˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yy"), "ㄗ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("yuu"), "ㄗㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yuue"), "ㄗㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yuur"), "ㄗㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yke"), "ㄗㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ykr"), "ㄗㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ykd"), "ㄗㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yii"), "ㄗㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yiir"), "ㄗㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yiid"), "ㄗㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yoe"), "ㄗㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yl"), "ㄗㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yle"), "ㄗㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ylr"), "ㄗㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yld"), "ㄗㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ym"), "ㄗㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ymr"), "ㄗㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ymd"), "ㄗㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yoo"), "ㄗㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yooe"), "ㄗㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yoor"), "ㄗㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yood"), "ㄗㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yp"), "ㄗㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ypr"), "ㄗㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ypd"), "ㄗㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yll"), "ㄗㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yllr"), "ㄗㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ylld"), "ㄗㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yn"), "ㄗㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ynr"), "ㄗㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ynd"), "ㄗㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yj"), "ㄗㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yje"), "ㄗㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjr"), "ㄗㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjd"), "ㄗㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yji"), "ㄗㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjie"), "ㄗㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjir"), "ㄗㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjid"), "ㄗㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjiy"), "ㄗㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjo"), "ㄗㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjor"), "ㄗㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjod"), "ㄗㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjoo"), "ㄗㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjoor"), "ㄗㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjood"), "ㄗㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjp"), "ㄗㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjpr"), "ㄗㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjpd"), "ㄗㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjn"), "ㄗㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjnr"), "ㄗㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yjnd"), "ㄗㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("h"), "ㄘ") - XCTAssertEqual(composer.convertSequenceToRawComposition("he"), "ㄘˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hr"), "ㄘˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hd"), "ㄘˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huu"), "ㄘㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huur"), "ㄘㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huud"), "ㄘㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hkd"), "ㄘㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hii"), "ㄘㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hiie"), "ㄘㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hiir"), "ㄘㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hiid"), "ㄘㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hl"), "ㄘㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hle"), "ㄘㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hlr"), "ㄘㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hld"), "ㄘㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hm"), "ㄘㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hme"), "ㄘㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hmr"), "ㄘㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hmd"), "ㄘㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hoo"), "ㄘㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hooe"), "ㄘㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hoor"), "ㄘㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hood"), "ㄘㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hp"), "ㄘㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hpe"), "ㄘㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hll"), "ㄘㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hlle"), "ㄘㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hllr"), "ㄘㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hlld"), "ㄘㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hn"), "ㄘㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hne"), "ㄘㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hnr"), "ㄘㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hnd"), "ㄘㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hj"), "ㄘㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hje"), "ㄘㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjr"), "ㄘㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjd"), "ㄘㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hji"), "ㄘㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjie"), "ㄘㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjir"), "ㄘㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjid"), "ㄘㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjo"), "ㄘㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjor"), "ㄘㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjod"), "ㄘㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjoo"), "ㄘㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjooe"), "ㄘㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjoor"), "ㄘㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjood"), "ㄘㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjp"), "ㄘㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjpe"), "ㄘㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjpr"), "ㄘㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjpd"), "ㄘㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjn"), "ㄘㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjne"), "ㄘㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjnr"), "ㄘㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hjnd"), "ㄘㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("n"), "ㄙ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nr"), "ㄙˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nd"), "ㄙˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuu"), "ㄙㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuur"), "ㄙㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuud"), "ㄙㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuuy"), "ㄙㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("nk"), "ㄙㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nkd"), "ㄙㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nii"), "ㄙㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("niie"), "ㄙㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("niir"), "ㄙㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("niid"), "ㄙㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("no"), "ㄙㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nl"), "ㄙㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nlr"), "ㄙㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nld"), "ㄙㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nm"), "ㄙㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nmr"), "ㄙㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nmd"), "ㄙㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("noo"), "ㄙㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("noor"), "ㄙㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nood"), "ㄙㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("np"), "ㄙㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("npr"), "ㄙㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nll"), "ㄙㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nllr"), "ㄙㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nlld"), "ㄙㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nnn"), "ㄙㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nnnd"), "ㄙㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nj"), "ㄙㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nje"), "ㄙㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njr"), "ㄙㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njd"), "ㄙㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nji"), "ㄙㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njie"), "ㄙㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njir"), "ㄙㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njid"), "ㄙㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njo"), "ㄙㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njoe"), "ㄙㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njor"), "ㄙㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njod"), "ㄙㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njoo"), "ㄙㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njoor"), "ㄙㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njood"), "ㄙㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njp"), "ㄙㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njpr"), "ㄙㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njpd"), "ㄙㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njn"), "ㄙㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njne"), "ㄙㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njnr"), "ㄙㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("njnd"), "ㄙㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uu"), "ㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uue"), "ㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uud"), "ㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uuy"), "ㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("i "), "ㄛ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ie"), "ㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ir"), "ㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("id"), "ㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("k "), "ㄜ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ke"), "ㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kr"), "ㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kd"), "ㄜˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("be"), "ㄝˊ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("br"), "ㄝˇ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("bd"), "ㄝˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("by"), "ㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ii"), "ㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("iie"), "ㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("iir"), "ㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("iid"), "ㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("od"), "ㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("l"), "ㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("le"), "ㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lr"), "ㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ld"), "ㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("m"), "ㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("me"), "ㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mr"), "ㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("md"), "ㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("my"), "ㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("oo "), "ㄢ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ooe"), "ㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("oor"), "ㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ood"), "ㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("p "), "ㄣ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pe"), "ㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pr"), "ㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pd"), "ㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("py"), "ㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ll "), "ㄤ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lle"), "ㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("llr"), "ㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lld"), "ㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nn "), "ㄥ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nnd"), "ㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pp "), "ㄦ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ppe"), "ㄦˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ppr"), "ㄦˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ppd"), "ㄦˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ppy"), "ㄦ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("u"), "ㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ue"), "ㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ur"), "ㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ud"), "ㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uuu"), "ㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uuue"), "ㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uuur"), "ㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uuud"), "ㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uuuy"), "ㄧㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ui"), "ㄧㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uiy"), "ㄧㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ub"), "ㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ube"), "ㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ubr"), "ㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ubd"), "ㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uby"), "ㄧㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("uiie"), "ㄧㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ul"), "ㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ule"), "ㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ulr"), "ㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uld"), "ㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("um"), "ㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ume"), "ㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("umr"), "ㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("umd"), "ㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uoo"), "ㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uooe"), "ㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uoor"), "ㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uood"), "ㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("up"), "ㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("upe"), "ㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("upr"), "ㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("upd"), "ㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ull"), "ㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ulle"), "ㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ullr"), "ㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ulld"), "ㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("un"), "ㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("une"), "ㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("unr"), "ㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("und"), "ㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("j"), "ㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("je"), "ㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jr"), "ㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jd"), "ㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ju"), "ㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jue"), "ㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jur"), "ㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jud"), "ㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juy"), "ㄨㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ji"), "ㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jir"), "ㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jid"), "ㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jii"), "ㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jiir"), "ㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jiid"), "ㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jo"), "ㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("joe"), "ㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jor"), "ㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jod"), "ㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("joo"), "ㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jooe"), "ㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("joor"), "ㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jood"), "ㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jp"), "ㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jpe"), "ㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jpr"), "ㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jpd"), "ㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jll"), "ㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jlle"), "ㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jllr"), "ㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jlld"), "ㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jn"), "ㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jnr"), "ㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jnd"), "ㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mm"), "ㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mme"), "ㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmr"), "ㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmd"), "ㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmb"), "ㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmbr"), "ㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmbd"), "ㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmoo"), "ㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmooe"), "ㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmoor"), "ㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmood"), "ㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmp"), "ㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmpe"), "ㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmpr"), "ㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmpd"), "ㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmn"), "ㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmne"), "ㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmnr"), "ㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmnd"), "ㄩㄥˋ") + var c = Tekkon.Composer(arrange: .ofDachen26) + XCTAssertEqual(c.cS2RC("ttjiid"), "ㄓㄨㄞˋ") + XCTAssertEqual(c.cS2RC("ttjo"), "ㄓㄨㄟ") + XCTAssertEqual(c.cS2RC("ttjor"), "ㄓㄨㄟˇ") + XCTAssertEqual(c.cS2RC("ttjod"), "ㄓㄨㄟˋ") + XCTAssertEqual(c.cS2RC("ttjoo"), "ㄓㄨㄢ") + XCTAssertEqual(c.cS2RC("ttjoor"), "ㄓㄨㄢˇ") + XCTAssertEqual(c.cS2RC("ttjood"), "ㄓㄨㄢˋ") + XCTAssertEqual(c.cS2RC("ttjp"), "ㄓㄨㄣ") + XCTAssertEqual(c.cS2RC("ttjpr"), "ㄓㄨㄣˇ") + XCTAssertEqual(c.cS2RC("ttjpd"), "ㄓㄨㄣˋ") + XCTAssertEqual(c.cS2RC("ttjll"), "ㄓㄨㄤ") + XCTAssertEqual(c.cS2RC("ttjllr"), "ㄓㄨㄤˇ") + XCTAssertEqual(c.cS2RC("ttjlld"), "ㄓㄨㄤˋ") + XCTAssertEqual(c.cS2RC("ttjn"), "ㄓㄨㄥ") + XCTAssertEqual(c.cS2RC("ttjnr"), "ㄓㄨㄥˇ") + XCTAssertEqual(c.cS2RC("ttjnd"), "ㄓㄨㄥˋ") + XCTAssertEqual(c.cS2RC("t "), "ㄔ ") + XCTAssertEqual(c.cS2RC("te"), "ㄔˊ") + XCTAssertEqual(c.cS2RC("tr"), "ㄔˇ") + XCTAssertEqual(c.cS2RC("td"), "ㄔˋ") + XCTAssertEqual(c.cS2RC("tuu"), "ㄔㄚ") + XCTAssertEqual(c.cS2RC("tuue"), "ㄔㄚˊ") + XCTAssertEqual(c.cS2RC("tuur"), "ㄔㄚˇ") + XCTAssertEqual(c.cS2RC("tuud"), "ㄔㄚˋ") + XCTAssertEqual(c.cS2RC("tk "), "ㄔㄜ ") + XCTAssertEqual(c.cS2RC("tkr"), "ㄔㄜˇ") + XCTAssertEqual(c.cS2RC("tkd"), "ㄔㄜˋ") + XCTAssertEqual(c.cS2RC("tii"), "ㄔㄞ") + XCTAssertEqual(c.cS2RC("tiie"), "ㄔㄞˊ") + XCTAssertEqual(c.cS2RC("tiir"), "ㄔㄞˇ") + XCTAssertEqual(c.cS2RC("tiid"), "ㄔㄞˋ") + XCTAssertEqual(c.cS2RC("tl"), "ㄔㄠ") + XCTAssertEqual(c.cS2RC("tle"), "ㄔㄠˊ") + XCTAssertEqual(c.cS2RC("tlr"), "ㄔㄠˇ") + XCTAssertEqual(c.cS2RC("tld"), "ㄔㄠˋ") + XCTAssertEqual(c.cS2RC("tm"), "ㄔㄡ") + XCTAssertEqual(c.cS2RC("tme"), "ㄔㄡˊ") + XCTAssertEqual(c.cS2RC("tmr"), "ㄔㄡˇ") + XCTAssertEqual(c.cS2RC("tmd"), "ㄔㄡˋ") + XCTAssertEqual(c.cS2RC("too "), "ㄔㄢ ") + XCTAssertEqual(c.cS2RC("tooe"), "ㄔㄢˊ") + XCTAssertEqual(c.cS2RC("toor"), "ㄔㄢˇ") + XCTAssertEqual(c.cS2RC("tood"), "ㄔㄢˋ") + XCTAssertEqual(c.cS2RC("tp "), "ㄔㄣ ") + XCTAssertEqual(c.cS2RC("tpe"), "ㄔㄣˊ") + XCTAssertEqual(c.cS2RC("tpr"), "ㄔㄣˇ") + XCTAssertEqual(c.cS2RC("tpd"), "ㄔㄣˋ") + XCTAssertEqual(c.cS2RC("tpy"), "ㄔㄣ˙") + XCTAssertEqual(c.cS2RC("tll "), "ㄔㄤ ") + XCTAssertEqual(c.cS2RC("tlle"), "ㄔㄤˊ") + XCTAssertEqual(c.cS2RC("tllr"), "ㄔㄤˇ") + XCTAssertEqual(c.cS2RC("tlld"), "ㄔㄤˋ") + XCTAssertEqual(c.cS2RC("tn "), "ㄔㄥ ") + XCTAssertEqual(c.cS2RC("tne"), "ㄔㄥˊ") + XCTAssertEqual(c.cS2RC("tnr"), "ㄔㄥˇ") + XCTAssertEqual(c.cS2RC("tnd"), "ㄔㄥˋ") + XCTAssertEqual(c.cS2RC("tj"), "ㄔㄨ") + XCTAssertEqual(c.cS2RC("tje"), "ㄔㄨˊ") + XCTAssertEqual(c.cS2RC("tjr"), "ㄔㄨˇ") + XCTAssertEqual(c.cS2RC("tjd"), "ㄔㄨˋ") + XCTAssertEqual(c.cS2RC("tju"), "ㄔㄨㄚ") + XCTAssertEqual(c.cS2RC("tjur"), "ㄔㄨㄚˇ") + XCTAssertEqual(c.cS2RC("tjud"), "ㄔㄨㄚˋ") + XCTAssertEqual(c.cS2RC("tji"), "ㄔㄨㄛ") + XCTAssertEqual(c.cS2RC("tjid"), "ㄔㄨㄛˋ") + XCTAssertEqual(c.cS2RC("tjii"), "ㄔㄨㄞ") + XCTAssertEqual(c.cS2RC("tjiie"), "ㄔㄨㄞˊ") + XCTAssertEqual(c.cS2RC("tjiir"), "ㄔㄨㄞˇ") + XCTAssertEqual(c.cS2RC("tjiid"), "ㄔㄨㄞˋ") + XCTAssertEqual(c.cS2RC("tjo"), "ㄔㄨㄟ") + XCTAssertEqual(c.cS2RC("tjoe"), "ㄔㄨㄟˊ") + XCTAssertEqual(c.cS2RC("tjor"), "ㄔㄨㄟˇ") + XCTAssertEqual(c.cS2RC("tjod"), "ㄔㄨㄟˋ") + XCTAssertEqual(c.cS2RC("tjoo"), "ㄔㄨㄢ") + XCTAssertEqual(c.cS2RC("tjooe"), "ㄔㄨㄢˊ") + XCTAssertEqual(c.cS2RC("tjoor"), "ㄔㄨㄢˇ") + XCTAssertEqual(c.cS2RC("tjood"), "ㄔㄨㄢˋ") + XCTAssertEqual(c.cS2RC("tjp"), "ㄔㄨㄣ") + XCTAssertEqual(c.cS2RC("tjpe"), "ㄔㄨㄣˊ") + XCTAssertEqual(c.cS2RC("tjpr"), "ㄔㄨㄣˇ") + XCTAssertEqual(c.cS2RC("tjll"), "ㄔㄨㄤ") + XCTAssertEqual(c.cS2RC("tjlle"), "ㄔㄨㄤˊ") + XCTAssertEqual(c.cS2RC("tjllr"), "ㄔㄨㄤˇ") + XCTAssertEqual(c.cS2RC("tjlld"), "ㄔㄨㄤˋ") + XCTAssertEqual(c.cS2RC("tjn"), "ㄔㄨㄥ") + XCTAssertEqual(c.cS2RC("tjne"), "ㄔㄨㄥˊ") + XCTAssertEqual(c.cS2RC("tjnr"), "ㄔㄨㄥˇ") + XCTAssertEqual(c.cS2RC("tjnd"), "ㄔㄨㄥˋ") + XCTAssertEqual(c.cS2RC("g"), "ㄕ") + XCTAssertEqual(c.cS2RC("ge"), "ㄕˊ") + XCTAssertEqual(c.cS2RC("gr"), "ㄕˇ") + XCTAssertEqual(c.cS2RC("gd"), "ㄕˋ") + XCTAssertEqual(c.cS2RC("gy"), "ㄕ˙") + XCTAssertEqual(c.cS2RC("guu"), "ㄕㄚ") + XCTAssertEqual(c.cS2RC("guue"), "ㄕㄚˊ") + XCTAssertEqual(c.cS2RC("guur"), "ㄕㄚˇ") + XCTAssertEqual(c.cS2RC("guud"), "ㄕㄚˋ") + XCTAssertEqual(c.cS2RC("guuy"), "ㄕㄚ˙") + XCTAssertEqual(c.cS2RC("gk"), "ㄕㄜ") + XCTAssertEqual(c.cS2RC("gke"), "ㄕㄜˊ") + XCTAssertEqual(c.cS2RC("gkr"), "ㄕㄜˇ") + XCTAssertEqual(c.cS2RC("gkd"), "ㄕㄜˋ") + XCTAssertEqual(c.cS2RC("gii"), "ㄕㄞ") + XCTAssertEqual(c.cS2RC("giir"), "ㄕㄞˇ") + XCTAssertEqual(c.cS2RC("giid"), "ㄕㄞˋ") + XCTAssertEqual(c.cS2RC("goe"), "ㄕㄟˊ") + XCTAssertEqual(c.cS2RC("gl"), "ㄕㄠ") + XCTAssertEqual(c.cS2RC("gle"), "ㄕㄠˊ") + XCTAssertEqual(c.cS2RC("glr"), "ㄕㄠˇ") + XCTAssertEqual(c.cS2RC("gld"), "ㄕㄠˋ") + XCTAssertEqual(c.cS2RC("gm"), "ㄕㄡ") + XCTAssertEqual(c.cS2RC("gme"), "ㄕㄡˊ") + XCTAssertEqual(c.cS2RC("gmr"), "ㄕㄡˇ") + XCTAssertEqual(c.cS2RC("gmd"), "ㄕㄡˋ") + XCTAssertEqual(c.cS2RC("goo"), "ㄕㄢ") + XCTAssertEqual(c.cS2RC("gooe"), "ㄕㄢˊ") + XCTAssertEqual(c.cS2RC("goor"), "ㄕㄢˇ") + XCTAssertEqual(c.cS2RC("good"), "ㄕㄢˋ") + XCTAssertEqual(c.cS2RC("gp"), "ㄕㄣ") + XCTAssertEqual(c.cS2RC("gpe"), "ㄕㄣˊ") + XCTAssertEqual(c.cS2RC("gpr"), "ㄕㄣˇ") + XCTAssertEqual(c.cS2RC("gpd"), "ㄕㄣˋ") + XCTAssertEqual(c.cS2RC("gll"), "ㄕㄤ") + XCTAssertEqual(c.cS2RC("gllr"), "ㄕㄤˇ") + XCTAssertEqual(c.cS2RC("glld"), "ㄕㄤˋ") + XCTAssertEqual(c.cS2RC("glly"), "ㄕㄤ˙") + XCTAssertEqual(c.cS2RC("gn"), "ㄕㄥ") + XCTAssertEqual(c.cS2RC("gne"), "ㄕㄥˊ") + XCTAssertEqual(c.cS2RC("gnr"), "ㄕㄥˇ") + XCTAssertEqual(c.cS2RC("gnd"), "ㄕㄥˋ") + XCTAssertEqual(c.cS2RC("gj"), "ㄕㄨ") + XCTAssertEqual(c.cS2RC("gje"), "ㄕㄨˊ") + XCTAssertEqual(c.cS2RC("gjr"), "ㄕㄨˇ") + XCTAssertEqual(c.cS2RC("gjd"), "ㄕㄨˋ") + XCTAssertEqual(c.cS2RC("gju"), "ㄕㄨㄚ") + XCTAssertEqual(c.cS2RC("gjur"), "ㄕㄨㄚˇ") + XCTAssertEqual(c.cS2RC("gjud"), "ㄕㄨㄚˋ") + XCTAssertEqual(c.cS2RC("gji"), "ㄕㄨㄛ") + XCTAssertEqual(c.cS2RC("gjid"), "ㄕㄨㄛˋ") + XCTAssertEqual(c.cS2RC("gjii"), "ㄕㄨㄞ") + XCTAssertEqual(c.cS2RC("gjiir"), "ㄕㄨㄞˇ") + XCTAssertEqual(c.cS2RC("gjiid"), "ㄕㄨㄞˋ") + XCTAssertEqual(c.cS2RC("gjo"), "ㄕㄨㄟ") + XCTAssertEqual(c.cS2RC("gjoe"), "ㄕㄨㄟˊ") + XCTAssertEqual(c.cS2RC("gjor"), "ㄕㄨㄟˇ") + XCTAssertEqual(c.cS2RC("gjod"), "ㄕㄨㄟˋ") + XCTAssertEqual(c.cS2RC("gjoo"), "ㄕㄨㄢ") + XCTAssertEqual(c.cS2RC("gjood"), "ㄕㄨㄢˋ") + XCTAssertEqual(c.cS2RC("gjpr"), "ㄕㄨㄣˇ") + XCTAssertEqual(c.cS2RC("gjpd"), "ㄕㄨㄣˋ") + XCTAssertEqual(c.cS2RC("gjll"), "ㄕㄨㄤ") + XCTAssertEqual(c.cS2RC("gjlle"), "ㄕㄨㄤˊ") + XCTAssertEqual(c.cS2RC("gjllr"), "ㄕㄨㄤˇ") + XCTAssertEqual(c.cS2RC("gjlld"), "ㄕㄨㄤˋ") + XCTAssertEqual(c.cS2RC("bd"), "ㄖˋ") + XCTAssertEqual(c.cS2RC("bkr"), "ㄖㄜˇ") + XCTAssertEqual(c.cS2RC("bkd"), "ㄖㄜˋ") + XCTAssertEqual(c.cS2RC("ble"), "ㄖㄠˊ") + XCTAssertEqual(c.cS2RC("blr"), "ㄖㄠˇ") + XCTAssertEqual(c.cS2RC("bld"), "ㄖㄠˋ") + XCTAssertEqual(c.cS2RC("bme"), "ㄖㄡˊ") + XCTAssertEqual(c.cS2RC("bmr"), "ㄖㄡˇ") + XCTAssertEqual(c.cS2RC("bmd"), "ㄖㄡˋ") + XCTAssertEqual(c.cS2RC("booe"), "ㄖㄢˊ") + XCTAssertEqual(c.cS2RC("boor"), "ㄖㄢˇ") + XCTAssertEqual(c.cS2RC("bood"), "ㄖㄢˋ") + XCTAssertEqual(c.cS2RC("bpe"), "ㄖㄣˊ") + XCTAssertEqual(c.cS2RC("bpr"), "ㄖㄣˇ") + XCTAssertEqual(c.cS2RC("bpd"), "ㄖㄣˋ") + XCTAssertEqual(c.cS2RC("bll"), "ㄖㄤ") + XCTAssertEqual(c.cS2RC("blle"), "ㄖㄤˊ") + XCTAssertEqual(c.cS2RC("bllr"), "ㄖㄤˇ") + XCTAssertEqual(c.cS2RC("blld"), "ㄖㄤˋ") + XCTAssertEqual(c.cS2RC("bn"), "ㄖㄥ") + XCTAssertEqual(c.cS2RC("bne"), "ㄖㄥˊ") + XCTAssertEqual(c.cS2RC("bnr"), "ㄖㄥˇ") + XCTAssertEqual(c.cS2RC("bnd"), "ㄖㄥˋ") + XCTAssertEqual(c.cS2RC("bje"), "ㄖㄨˊ") + XCTAssertEqual(c.cS2RC("bjr"), "ㄖㄨˇ") + XCTAssertEqual(c.cS2RC("bjd"), "ㄖㄨˋ") + XCTAssertEqual(c.cS2RC("bjie"), "ㄖㄨㄛˊ") + XCTAssertEqual(c.cS2RC("bjid"), "ㄖㄨㄛˋ") + XCTAssertEqual(c.cS2RC("bjoe"), "ㄖㄨㄟˊ") + XCTAssertEqual(c.cS2RC("bjor"), "ㄖㄨㄟˇ") + XCTAssertEqual(c.cS2RC("bjod"), "ㄖㄨㄟˋ") + XCTAssertEqual(c.cS2RC("bjooe"), "ㄖㄨㄢˊ") + XCTAssertEqual(c.cS2RC("bjoor"), "ㄖㄨㄢˇ") + XCTAssertEqual(c.cS2RC("bjood"), "ㄖㄨㄢˋ") + XCTAssertEqual(c.cS2RC("bjpe"), "ㄖㄨㄣˊ") + XCTAssertEqual(c.cS2RC("bjpr"), "ㄖㄨㄣˇ") + XCTAssertEqual(c.cS2RC("bjpd"), "ㄖㄨㄣˋ") + XCTAssertEqual(c.cS2RC("bjne"), "ㄖㄨㄥˊ") + XCTAssertEqual(c.cS2RC("bjnr"), "ㄖㄨㄥˇ") + XCTAssertEqual(c.cS2RC("bjnd"), "ㄖㄨㄥˋ") + XCTAssertEqual(c.cS2RC("y"), "ㄗ") + XCTAssertEqual(c.cS2RC("ye"), "ㄗˊ") + XCTAssertEqual(c.cS2RC("yr"), "ㄗˇ") + XCTAssertEqual(c.cS2RC("yd"), "ㄗˋ") + XCTAssertEqual(c.cS2RC("yy"), "ㄗ˙") + XCTAssertEqual(c.cS2RC("yuu"), "ㄗㄚ") + XCTAssertEqual(c.cS2RC("yuue"), "ㄗㄚˊ") + XCTAssertEqual(c.cS2RC("yuur"), "ㄗㄚˇ") + XCTAssertEqual(c.cS2RC("yke"), "ㄗㄜˊ") + XCTAssertEqual(c.cS2RC("ykr"), "ㄗㄜˇ") + XCTAssertEqual(c.cS2RC("ykd"), "ㄗㄜˋ") + XCTAssertEqual(c.cS2RC("yii"), "ㄗㄞ") + XCTAssertEqual(c.cS2RC("yiir"), "ㄗㄞˇ") + XCTAssertEqual(c.cS2RC("yiid"), "ㄗㄞˋ") + XCTAssertEqual(c.cS2RC("yoe"), "ㄗㄟˊ") + XCTAssertEqual(c.cS2RC("yl"), "ㄗㄠ") + XCTAssertEqual(c.cS2RC("yle"), "ㄗㄠˊ") + XCTAssertEqual(c.cS2RC("ylr"), "ㄗㄠˇ") + XCTAssertEqual(c.cS2RC("yld"), "ㄗㄠˋ") + XCTAssertEqual(c.cS2RC("ym"), "ㄗㄡ") + XCTAssertEqual(c.cS2RC("ymr"), "ㄗㄡˇ") + XCTAssertEqual(c.cS2RC("ymd"), "ㄗㄡˋ") + XCTAssertEqual(c.cS2RC("yoo"), "ㄗㄢ") + XCTAssertEqual(c.cS2RC("yooe"), "ㄗㄢˊ") + XCTAssertEqual(c.cS2RC("yoor"), "ㄗㄢˇ") + XCTAssertEqual(c.cS2RC("yood"), "ㄗㄢˋ") + XCTAssertEqual(c.cS2RC("yp"), "ㄗㄣ") + XCTAssertEqual(c.cS2RC("ypr"), "ㄗㄣˇ") + XCTAssertEqual(c.cS2RC("ypd"), "ㄗㄣˋ") + XCTAssertEqual(c.cS2RC("yll"), "ㄗㄤ") + XCTAssertEqual(c.cS2RC("yllr"), "ㄗㄤˇ") + XCTAssertEqual(c.cS2RC("ylld"), "ㄗㄤˋ") + XCTAssertEqual(c.cS2RC("yn"), "ㄗㄥ") + XCTAssertEqual(c.cS2RC("ynr"), "ㄗㄥˇ") + XCTAssertEqual(c.cS2RC("ynd"), "ㄗㄥˋ") + XCTAssertEqual(c.cS2RC("yj"), "ㄗㄨ") + XCTAssertEqual(c.cS2RC("yje"), "ㄗㄨˊ") + XCTAssertEqual(c.cS2RC("yjr"), "ㄗㄨˇ") + XCTAssertEqual(c.cS2RC("yjd"), "ㄗㄨˋ") + XCTAssertEqual(c.cS2RC("yji"), "ㄗㄨㄛ") + XCTAssertEqual(c.cS2RC("yjie"), "ㄗㄨㄛˊ") + XCTAssertEqual(c.cS2RC("yjir"), "ㄗㄨㄛˇ") + XCTAssertEqual(c.cS2RC("yjid"), "ㄗㄨㄛˋ") + XCTAssertEqual(c.cS2RC("yjiy"), "ㄗㄨㄛ˙") + XCTAssertEqual(c.cS2RC("yjo"), "ㄗㄨㄟ") + XCTAssertEqual(c.cS2RC("yjor"), "ㄗㄨㄟˇ") + XCTAssertEqual(c.cS2RC("yjod"), "ㄗㄨㄟˋ") + XCTAssertEqual(c.cS2RC("yjoo"), "ㄗㄨㄢ") + XCTAssertEqual(c.cS2RC("yjoor"), "ㄗㄨㄢˇ") + XCTAssertEqual(c.cS2RC("yjood"), "ㄗㄨㄢˋ") + XCTAssertEqual(c.cS2RC("yjp"), "ㄗㄨㄣ") + XCTAssertEqual(c.cS2RC("yjpr"), "ㄗㄨㄣˇ") + XCTAssertEqual(c.cS2RC("yjpd"), "ㄗㄨㄣˋ") + XCTAssertEqual(c.cS2RC("yjn"), "ㄗㄨㄥ") + XCTAssertEqual(c.cS2RC("yjnr"), "ㄗㄨㄥˇ") + XCTAssertEqual(c.cS2RC("yjnd"), "ㄗㄨㄥˋ") + XCTAssertEqual(c.cS2RC("h"), "ㄘ") + XCTAssertEqual(c.cS2RC("he"), "ㄘˊ") + XCTAssertEqual(c.cS2RC("hr"), "ㄘˇ") + XCTAssertEqual(c.cS2RC("hd"), "ㄘˋ") + XCTAssertEqual(c.cS2RC("huu"), "ㄘㄚ") + XCTAssertEqual(c.cS2RC("huur"), "ㄘㄚˇ") + XCTAssertEqual(c.cS2RC("huud"), "ㄘㄚˋ") + XCTAssertEqual(c.cS2RC("hkd"), "ㄘㄜˋ") + XCTAssertEqual(c.cS2RC("hii"), "ㄘㄞ") + XCTAssertEqual(c.cS2RC("hiie"), "ㄘㄞˊ") + XCTAssertEqual(c.cS2RC("hiir"), "ㄘㄞˇ") + XCTAssertEqual(c.cS2RC("hiid"), "ㄘㄞˋ") + XCTAssertEqual(c.cS2RC("hl"), "ㄘㄠ") + XCTAssertEqual(c.cS2RC("hle"), "ㄘㄠˊ") + XCTAssertEqual(c.cS2RC("hlr"), "ㄘㄠˇ") + XCTAssertEqual(c.cS2RC("hld"), "ㄘㄠˋ") + XCTAssertEqual(c.cS2RC("hm"), "ㄘㄡ") + XCTAssertEqual(c.cS2RC("hme"), "ㄘㄡˊ") + XCTAssertEqual(c.cS2RC("hmr"), "ㄘㄡˇ") + XCTAssertEqual(c.cS2RC("hmd"), "ㄘㄡˋ") + XCTAssertEqual(c.cS2RC("hoo"), "ㄘㄢ") + XCTAssertEqual(c.cS2RC("hooe"), "ㄘㄢˊ") + XCTAssertEqual(c.cS2RC("hoor"), "ㄘㄢˇ") + XCTAssertEqual(c.cS2RC("hood"), "ㄘㄢˋ") + XCTAssertEqual(c.cS2RC("hp"), "ㄘㄣ") + XCTAssertEqual(c.cS2RC("hpe"), "ㄘㄣˊ") + XCTAssertEqual(c.cS2RC("hll"), "ㄘㄤ") + XCTAssertEqual(c.cS2RC("hlle"), "ㄘㄤˊ") + XCTAssertEqual(c.cS2RC("hllr"), "ㄘㄤˇ") + XCTAssertEqual(c.cS2RC("hlld"), "ㄘㄤˋ") + XCTAssertEqual(c.cS2RC("hn"), "ㄘㄥ") + XCTAssertEqual(c.cS2RC("hne"), "ㄘㄥˊ") + XCTAssertEqual(c.cS2RC("hnr"), "ㄘㄥˇ") + XCTAssertEqual(c.cS2RC("hnd"), "ㄘㄥˋ") + XCTAssertEqual(c.cS2RC("hj"), "ㄘㄨ") + XCTAssertEqual(c.cS2RC("hje"), "ㄘㄨˊ") + XCTAssertEqual(c.cS2RC("hjr"), "ㄘㄨˇ") + XCTAssertEqual(c.cS2RC("hjd"), "ㄘㄨˋ") + XCTAssertEqual(c.cS2RC("hji"), "ㄘㄨㄛ") + XCTAssertEqual(c.cS2RC("hjie"), "ㄘㄨㄛˊ") + XCTAssertEqual(c.cS2RC("hjir"), "ㄘㄨㄛˇ") + XCTAssertEqual(c.cS2RC("hjid"), "ㄘㄨㄛˋ") + XCTAssertEqual(c.cS2RC("hjo"), "ㄘㄨㄟ") + XCTAssertEqual(c.cS2RC("hjor"), "ㄘㄨㄟˇ") + XCTAssertEqual(c.cS2RC("hjod"), "ㄘㄨㄟˋ") + XCTAssertEqual(c.cS2RC("hjoo"), "ㄘㄨㄢ") + XCTAssertEqual(c.cS2RC("hjooe"), "ㄘㄨㄢˊ") + XCTAssertEqual(c.cS2RC("hjoor"), "ㄘㄨㄢˇ") + XCTAssertEqual(c.cS2RC("hjood"), "ㄘㄨㄢˋ") + XCTAssertEqual(c.cS2RC("hjp"), "ㄘㄨㄣ") + XCTAssertEqual(c.cS2RC("hjpe"), "ㄘㄨㄣˊ") + XCTAssertEqual(c.cS2RC("hjpr"), "ㄘㄨㄣˇ") + XCTAssertEqual(c.cS2RC("hjpd"), "ㄘㄨㄣˋ") + XCTAssertEqual(c.cS2RC("hjn"), "ㄘㄨㄥ") + XCTAssertEqual(c.cS2RC("hjne"), "ㄘㄨㄥˊ") + XCTAssertEqual(c.cS2RC("hjnr"), "ㄘㄨㄥˇ") + XCTAssertEqual(c.cS2RC("hjnd"), "ㄘㄨㄥˋ") + XCTAssertEqual(c.cS2RC("n"), "ㄙ") + XCTAssertEqual(c.cS2RC("nr"), "ㄙˇ") + XCTAssertEqual(c.cS2RC("nd"), "ㄙˋ") + XCTAssertEqual(c.cS2RC("nuu"), "ㄙㄚ") + XCTAssertEqual(c.cS2RC("nuur"), "ㄙㄚˇ") + XCTAssertEqual(c.cS2RC("nuud"), "ㄙㄚˋ") + XCTAssertEqual(c.cS2RC("nuuy"), "ㄙㄚ˙") + XCTAssertEqual(c.cS2RC("nk"), "ㄙㄜ") + XCTAssertEqual(c.cS2RC("nkd"), "ㄙㄜˋ") + XCTAssertEqual(c.cS2RC("nii"), "ㄙㄞ") + XCTAssertEqual(c.cS2RC("niie"), "ㄙㄞˊ") + XCTAssertEqual(c.cS2RC("niir"), "ㄙㄞˇ") + XCTAssertEqual(c.cS2RC("niid"), "ㄙㄞˋ") + XCTAssertEqual(c.cS2RC("no"), "ㄙㄟ") + XCTAssertEqual(c.cS2RC("nl"), "ㄙㄠ") + XCTAssertEqual(c.cS2RC("nlr"), "ㄙㄠˇ") + XCTAssertEqual(c.cS2RC("nld"), "ㄙㄠˋ") + XCTAssertEqual(c.cS2RC("nm"), "ㄙㄡ") + XCTAssertEqual(c.cS2RC("nmr"), "ㄙㄡˇ") + XCTAssertEqual(c.cS2RC("nmd"), "ㄙㄡˋ") + XCTAssertEqual(c.cS2RC("noo"), "ㄙㄢ") + XCTAssertEqual(c.cS2RC("noor"), "ㄙㄢˇ") + XCTAssertEqual(c.cS2RC("nood"), "ㄙㄢˋ") + XCTAssertEqual(c.cS2RC("np"), "ㄙㄣ") + XCTAssertEqual(c.cS2RC("npr"), "ㄙㄣˇ") + XCTAssertEqual(c.cS2RC("nll"), "ㄙㄤ") + XCTAssertEqual(c.cS2RC("nllr"), "ㄙㄤˇ") + XCTAssertEqual(c.cS2RC("nlld"), "ㄙㄤˋ") + XCTAssertEqual(c.cS2RC("nnn"), "ㄙㄥ") + XCTAssertEqual(c.cS2RC("nnnd"), "ㄙㄥˋ") + XCTAssertEqual(c.cS2RC("nj"), "ㄙㄨ") + XCTAssertEqual(c.cS2RC("nje"), "ㄙㄨˊ") + XCTAssertEqual(c.cS2RC("njr"), "ㄙㄨˇ") + XCTAssertEqual(c.cS2RC("njd"), "ㄙㄨˋ") + XCTAssertEqual(c.cS2RC("nji"), "ㄙㄨㄛ") + XCTAssertEqual(c.cS2RC("njie"), "ㄙㄨㄛˊ") + XCTAssertEqual(c.cS2RC("njir"), "ㄙㄨㄛˇ") + XCTAssertEqual(c.cS2RC("njid"), "ㄙㄨㄛˋ") + XCTAssertEqual(c.cS2RC("njo"), "ㄙㄨㄟ") + XCTAssertEqual(c.cS2RC("njoe"), "ㄙㄨㄟˊ") + XCTAssertEqual(c.cS2RC("njor"), "ㄙㄨㄟˇ") + XCTAssertEqual(c.cS2RC("njod"), "ㄙㄨㄟˋ") + XCTAssertEqual(c.cS2RC("njoo"), "ㄙㄨㄢ") + XCTAssertEqual(c.cS2RC("njoor"), "ㄙㄨㄢˇ") + XCTAssertEqual(c.cS2RC("njood"), "ㄙㄨㄢˋ") + XCTAssertEqual(c.cS2RC("njp"), "ㄙㄨㄣ") + XCTAssertEqual(c.cS2RC("njpr"), "ㄙㄨㄣˇ") + XCTAssertEqual(c.cS2RC("njpd"), "ㄙㄨㄣˋ") + XCTAssertEqual(c.cS2RC("njn"), "ㄙㄨㄥ") + XCTAssertEqual(c.cS2RC("njne"), "ㄙㄨㄥˊ") + XCTAssertEqual(c.cS2RC("njnr"), "ㄙㄨㄥˇ") + XCTAssertEqual(c.cS2RC("njnd"), "ㄙㄨㄥˋ") + XCTAssertEqual(c.cS2RC("uu"), "ㄚ") + XCTAssertEqual(c.cS2RC("uue"), "ㄚˊ") + XCTAssertEqual(c.cS2RC("uud"), "ㄚˋ") + XCTAssertEqual(c.cS2RC("uuy"), "ㄚ˙") + XCTAssertEqual(c.cS2RC("i "), "ㄛ ") + XCTAssertEqual(c.cS2RC("ie"), "ㄛˊ") + XCTAssertEqual(c.cS2RC("ir"), "ㄛˇ") + XCTAssertEqual(c.cS2RC("id"), "ㄛˋ") + XCTAssertEqual(c.cS2RC("k "), "ㄜ ") + XCTAssertEqual(c.cS2RC("ke"), "ㄜˊ") + XCTAssertEqual(c.cS2RC("kr"), "ㄜˇ") + XCTAssertEqual(c.cS2RC("kd"), "ㄜˋ") + // XCTAssertEqual(c.cS2RC("be"), "ㄝˊ") + // XCTAssertEqual(c.cS2RC("br"), "ㄝˇ") + // XCTAssertEqual(c.cS2RC("bd"), "ㄝˋ") + // XCTAssertEqual(c.cS2RC("by"), "ㄝ˙") + XCTAssertEqual(c.cS2RC("ii"), "ㄞ") + XCTAssertEqual(c.cS2RC("iie"), "ㄞˊ") + XCTAssertEqual(c.cS2RC("iir"), "ㄞˇ") + XCTAssertEqual(c.cS2RC("iid"), "ㄞˋ") + XCTAssertEqual(c.cS2RC("od"), "ㄟˋ") + XCTAssertEqual(c.cS2RC("l"), "ㄠ") + XCTAssertEqual(c.cS2RC("le"), "ㄠˊ") + XCTAssertEqual(c.cS2RC("lr"), "ㄠˇ") + XCTAssertEqual(c.cS2RC("ld"), "ㄠˋ") + XCTAssertEqual(c.cS2RC("m"), "ㄡ") + XCTAssertEqual(c.cS2RC("me"), "ㄡˊ") + XCTAssertEqual(c.cS2RC("mr"), "ㄡˇ") + XCTAssertEqual(c.cS2RC("md"), "ㄡˋ") + XCTAssertEqual(c.cS2RC("my"), "ㄡ˙") + XCTAssertEqual(c.cS2RC("oo "), "ㄢ ") + XCTAssertEqual(c.cS2RC("ooe"), "ㄢˊ") + XCTAssertEqual(c.cS2RC("oor"), "ㄢˇ") + XCTAssertEqual(c.cS2RC("ood"), "ㄢˋ") + XCTAssertEqual(c.cS2RC("p "), "ㄣ ") + XCTAssertEqual(c.cS2RC("pe"), "ㄣˊ") + XCTAssertEqual(c.cS2RC("pr"), "ㄣˇ") + XCTAssertEqual(c.cS2RC("pd"), "ㄣˋ") + XCTAssertEqual(c.cS2RC("py"), "ㄣ˙") + XCTAssertEqual(c.cS2RC("ll "), "ㄤ ") + XCTAssertEqual(c.cS2RC("lle"), "ㄤˊ") + XCTAssertEqual(c.cS2RC("llr"), "ㄤˇ") + XCTAssertEqual(c.cS2RC("lld"), "ㄤˋ") + XCTAssertEqual(c.cS2RC("nn "), "ㄥ ") + XCTAssertEqual(c.cS2RC("nnd"), "ㄥˋ") + XCTAssertEqual(c.cS2RC("pp "), "ㄦ ") + XCTAssertEqual(c.cS2RC("ppe"), "ㄦˊ") + XCTAssertEqual(c.cS2RC("ppr"), "ㄦˇ") + XCTAssertEqual(c.cS2RC("ppd"), "ㄦˋ") + XCTAssertEqual(c.cS2RC("ppy"), "ㄦ˙") + XCTAssertEqual(c.cS2RC("u"), "ㄧ") + XCTAssertEqual(c.cS2RC("ue"), "ㄧˊ") + XCTAssertEqual(c.cS2RC("ur"), "ㄧˇ") + XCTAssertEqual(c.cS2RC("ud"), "ㄧˋ") + XCTAssertEqual(c.cS2RC("uuu"), "ㄧㄚ") + XCTAssertEqual(c.cS2RC("uuue"), "ㄧㄚˊ") + XCTAssertEqual(c.cS2RC("uuur"), "ㄧㄚˇ") + XCTAssertEqual(c.cS2RC("uuud"), "ㄧㄚˋ") + XCTAssertEqual(c.cS2RC("uuuy"), "ㄧㄚ˙") + XCTAssertEqual(c.cS2RC("ui"), "ㄧㄛ") + XCTAssertEqual(c.cS2RC("uiy"), "ㄧㄛ˙") + XCTAssertEqual(c.cS2RC("ub"), "ㄧㄝ") + XCTAssertEqual(c.cS2RC("ube"), "ㄧㄝˊ") + XCTAssertEqual(c.cS2RC("ubr"), "ㄧㄝˇ") + XCTAssertEqual(c.cS2RC("ubd"), "ㄧㄝˋ") + XCTAssertEqual(c.cS2RC("uby"), "ㄧㄝ˙") + XCTAssertEqual(c.cS2RC("uiie"), "ㄧㄞˊ") + XCTAssertEqual(c.cS2RC("ul"), "ㄧㄠ") + XCTAssertEqual(c.cS2RC("ule"), "ㄧㄠˊ") + XCTAssertEqual(c.cS2RC("ulr"), "ㄧㄠˇ") + XCTAssertEqual(c.cS2RC("uld"), "ㄧㄠˋ") + XCTAssertEqual(c.cS2RC("um"), "ㄧㄡ") + XCTAssertEqual(c.cS2RC("ume"), "ㄧㄡˊ") + XCTAssertEqual(c.cS2RC("umr"), "ㄧㄡˇ") + XCTAssertEqual(c.cS2RC("umd"), "ㄧㄡˋ") + XCTAssertEqual(c.cS2RC("uoo"), "ㄧㄢ") + XCTAssertEqual(c.cS2RC("uooe"), "ㄧㄢˊ") + XCTAssertEqual(c.cS2RC("uoor"), "ㄧㄢˇ") + XCTAssertEqual(c.cS2RC("uood"), "ㄧㄢˋ") + XCTAssertEqual(c.cS2RC("up"), "ㄧㄣ") + XCTAssertEqual(c.cS2RC("upe"), "ㄧㄣˊ") + XCTAssertEqual(c.cS2RC("upr"), "ㄧㄣˇ") + XCTAssertEqual(c.cS2RC("upd"), "ㄧㄣˋ") + XCTAssertEqual(c.cS2RC("ull"), "ㄧㄤ") + XCTAssertEqual(c.cS2RC("ulle"), "ㄧㄤˊ") + XCTAssertEqual(c.cS2RC("ullr"), "ㄧㄤˇ") + XCTAssertEqual(c.cS2RC("ulld"), "ㄧㄤˋ") + XCTAssertEqual(c.cS2RC("un"), "ㄧㄥ") + XCTAssertEqual(c.cS2RC("une"), "ㄧㄥˊ") + XCTAssertEqual(c.cS2RC("unr"), "ㄧㄥˇ") + XCTAssertEqual(c.cS2RC("und"), "ㄧㄥˋ") + XCTAssertEqual(c.cS2RC("j"), "ㄨ") + XCTAssertEqual(c.cS2RC("je"), "ㄨˊ") + XCTAssertEqual(c.cS2RC("jr"), "ㄨˇ") + XCTAssertEqual(c.cS2RC("jd"), "ㄨˋ") + XCTAssertEqual(c.cS2RC("ju"), "ㄨㄚ") + XCTAssertEqual(c.cS2RC("jue"), "ㄨㄚˊ") + XCTAssertEqual(c.cS2RC("jur"), "ㄨㄚˇ") + XCTAssertEqual(c.cS2RC("jud"), "ㄨㄚˋ") + XCTAssertEqual(c.cS2RC("juy"), "ㄨㄚ˙") + XCTAssertEqual(c.cS2RC("ji"), "ㄨㄛ") + XCTAssertEqual(c.cS2RC("jir"), "ㄨㄛˇ") + XCTAssertEqual(c.cS2RC("jid"), "ㄨㄛˋ") + XCTAssertEqual(c.cS2RC("jii"), "ㄨㄞ") + XCTAssertEqual(c.cS2RC("jiir"), "ㄨㄞˇ") + XCTAssertEqual(c.cS2RC("jiid"), "ㄨㄞˋ") + XCTAssertEqual(c.cS2RC("jo"), "ㄨㄟ") + XCTAssertEqual(c.cS2RC("joe"), "ㄨㄟˊ") + XCTAssertEqual(c.cS2RC("jor"), "ㄨㄟˇ") + XCTAssertEqual(c.cS2RC("jod"), "ㄨㄟˋ") + XCTAssertEqual(c.cS2RC("joo"), "ㄨㄢ") + XCTAssertEqual(c.cS2RC("jooe"), "ㄨㄢˊ") + XCTAssertEqual(c.cS2RC("joor"), "ㄨㄢˇ") + XCTAssertEqual(c.cS2RC("jood"), "ㄨㄢˋ") + XCTAssertEqual(c.cS2RC("jp"), "ㄨㄣ") + XCTAssertEqual(c.cS2RC("jpe"), "ㄨㄣˊ") + XCTAssertEqual(c.cS2RC("jpr"), "ㄨㄣˇ") + XCTAssertEqual(c.cS2RC("jpd"), "ㄨㄣˋ") + XCTAssertEqual(c.cS2RC("jll"), "ㄨㄤ") + XCTAssertEqual(c.cS2RC("jlle"), "ㄨㄤˊ") + XCTAssertEqual(c.cS2RC("jllr"), "ㄨㄤˇ") + XCTAssertEqual(c.cS2RC("jlld"), "ㄨㄤˋ") + XCTAssertEqual(c.cS2RC("jn"), "ㄨㄥ") + XCTAssertEqual(c.cS2RC("jnr"), "ㄨㄥˇ") + XCTAssertEqual(c.cS2RC("jnd"), "ㄨㄥˋ") + XCTAssertEqual(c.cS2RC("mm"), "ㄩ") + XCTAssertEqual(c.cS2RC("mme"), "ㄩˊ") + XCTAssertEqual(c.cS2RC("mmr"), "ㄩˇ") + XCTAssertEqual(c.cS2RC("mmd"), "ㄩˋ") + XCTAssertEqual(c.cS2RC("mmb"), "ㄩㄝ") + XCTAssertEqual(c.cS2RC("mmbr"), "ㄩㄝˇ") + XCTAssertEqual(c.cS2RC("mmbd"), "ㄩㄝˋ") + XCTAssertEqual(c.cS2RC("mmoo"), "ㄩㄢ") + XCTAssertEqual(c.cS2RC("mmooe"), "ㄩㄢˊ") + XCTAssertEqual(c.cS2RC("mmoor"), "ㄩㄢˇ") + XCTAssertEqual(c.cS2RC("mmood"), "ㄩㄢˋ") + XCTAssertEqual(c.cS2RC("mmp"), "ㄩㄣ") + XCTAssertEqual(c.cS2RC("mmpe"), "ㄩㄣˊ") + XCTAssertEqual(c.cS2RC("mmpr"), "ㄩㄣˇ") + XCTAssertEqual(c.cS2RC("mmpd"), "ㄩㄣˋ") + XCTAssertEqual(c.cS2RC("mmn"), "ㄩㄥ") + XCTAssertEqual(c.cS2RC("mmne"), "ㄩㄥˊ") + XCTAssertEqual(c.cS2RC("mmnr"), "ㄩㄥˇ") + XCTAssertEqual(c.cS2RC("mmnd"), "ㄩㄥˋ") } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_A.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_A.swift index a6d87e12..89c9ecf1 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_A.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_A.swift @@ -11,492 +11,496 @@ import XCTest @testable import Tekkon extension TekkonTestsKeyboardArrangments { + func testETen26KeysTaigi() throws { + var c = Tekkon.Composer(arrange: .ofETen26) + XCTAssertEqual(c.cS2RC("ket"), "ㄎㄧㄤ") + // XCTAssertEqual(c.cS2RC("vezf"), "ㄍㄧㄠˊ") + // XCTAssertEqual(c.cS2RC("ven"), "ㄍㄧㄣ") + } + func testETen26KeysA() throws { - var composer = Tekkon.Composer(arrange: .ofETen26) - XCTAssertEqual(composer.convertSequenceToRawComposition("ket"), "ㄎㄧㄤ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("vezf"), "ㄍㄧㄠˊ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("ven"), "ㄍㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("betf"), "ㄅㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("betk"), "ㄅㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxt"), "ㄉㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ba"), "ㄅㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("baf"), "ㄅㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("baj"), "ㄅㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bak"), "ㄅㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bad"), "ㄅㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("bo"), "ㄅㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bof"), "ㄅㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("boj"), "ㄅㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bok"), "ㄅㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bod"), "ㄅㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("bi"), "ㄅㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bif"), "ㄅㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bij"), "ㄅㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bik"), "ㄅㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bid"), "ㄅㄞ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("bq"), "ㄅㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bqj"), "ㄅㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bqk"), "ㄅㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bqd"), "ㄅㄟ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("bz"), "ㄅㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bzf"), "ㄅㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bzj"), "ㄅㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bzk"), "ㄅㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bm"), "ㄅㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bmj"), "ㄅㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bmk"), "ㄅㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bn"), "ㄅㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bnj"), "ㄅㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bnk"), "ㄅㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bt"), "ㄅㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("btj"), "ㄅㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("btk"), "ㄅㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bl"), "ㄅㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("blf"), "ㄅㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("blj"), "ㄅㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("blk"), "ㄅㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("be"), "ㄅㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bef"), "ㄅㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bej"), "ㄅㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bek"), "ㄅㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bew"), "ㄅㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bewf"), "ㄅㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bewj"), "ㄅㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bewk"), "ㄅㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bez"), "ㄅㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bezj"), "ㄅㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bezk"), "ㄅㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bem"), "ㄅㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bemf"), "ㄅㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bemj"), "ㄅㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bemk"), "ㄅㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ben"), "ㄅㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("benj"), "ㄅㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("benk"), "ㄅㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bel"), "ㄅㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("belj"), "ㄅㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("belk"), "ㄅㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bx"), "ㄅㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bxf"), "ㄅㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bxj"), "ㄅㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bxk"), "ㄅㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pa"), "ㄆㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("paf"), "ㄆㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("paj"), "ㄆㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pak"), "ㄆㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pad"), "ㄆㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("po"), "ㄆㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pof"), "ㄆㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("poj"), "ㄆㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pok"), "ㄆㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pi"), "ㄆㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pif"), "ㄆㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pij"), "ㄆㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pik"), "ㄆㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pq"), "ㄆㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pqf"), "ㄆㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pqj"), "ㄆㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pqk"), "ㄆㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pz"), "ㄆㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pzf"), "ㄆㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pzj"), "ㄆㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pzk"), "ㄆㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pp"), "ㄆㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ppf"), "ㄆㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ppj"), "ㄆㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ppk"), "ㄆㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pm"), "ㄆㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pmf"), "ㄆㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pmj"), "ㄆㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pmk"), "ㄆㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pn"), "ㄆㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pnf"), "ㄆㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pnj"), "ㄆㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pnk"), "ㄆㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pt"), "ㄆㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ptf"), "ㄆㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ptj"), "ㄆㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ptk"), "ㄆㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pl"), "ㄆㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("plf"), "ㄆㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("plj"), "ㄆㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("plk"), "ㄆㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pe"), "ㄆㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pef"), "ㄆㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pej"), "ㄆㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pek"), "ㄆㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pea"), "ㄆㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pew"), "ㄆㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pewj"), "ㄆㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pewk"), "ㄆㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pez"), "ㄆㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pezf"), "ㄆㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pezj"), "ㄆㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pezk"), "ㄆㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pem"), "ㄆㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pemf"), "ㄆㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pemj"), "ㄆㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pemk"), "ㄆㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pen"), "ㄆㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("penf"), "ㄆㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("penj"), "ㄆㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("penk"), "ㄆㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pel"), "ㄆㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pelf"), "ㄆㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pelj"), "ㄆㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pelk"), "ㄆㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("px"), "ㄆㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pxf"), "ㄆㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pxj"), "ㄆㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pxk"), "ㄆㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ma"), "ㄇㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("maf"), "ㄇㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("maj"), "ㄇㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mak"), "ㄇㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mad"), "ㄇㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("mo"), "ㄇㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mof"), "ㄇㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("moj"), "ㄇㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mok"), "ㄇㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mod"), "ㄇㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("mr"), "ㄇㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mrk"), "ㄇㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mrd"), "ㄇㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("mi"), "ㄇㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mif"), "ㄇㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mij"), "ㄇㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mik"), "ㄇㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mqf"), "ㄇㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mqj"), "ㄇㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mqk"), "ㄇㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mz"), "ㄇㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mzf"), "ㄇㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mzj"), "ㄇㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mzk"), "ㄇㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mpf"), "ㄇㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mpj"), "ㄇㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mpk"), "ㄇㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mm"), "ㄇㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmf"), "ㄇㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmj"), "ㄇㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmk"), "ㄇㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mn"), "ㄇㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mnf"), "ㄇㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mnj"), "ㄇㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mnk"), "ㄇㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mnd"), "ㄇㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("mt"), "ㄇㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mtf"), "ㄇㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mtj"), "ㄇㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mtk"), "ㄇㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ml"), "ㄇㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mlf"), "ㄇㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mlj"), "ㄇㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mlk"), "ㄇㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("me"), "ㄇㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mef"), "ㄇㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mej"), "ㄇㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mek"), "ㄇㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mew"), "ㄇㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mewf"), "ㄇㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mewk"), "ㄇㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mez"), "ㄇㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mezf"), "ㄇㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mezj"), "ㄇㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mezk"), "ㄇㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mepf"), "ㄇㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mepj"), "ㄇㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mepk"), "ㄇㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mem"), "ㄇㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("memf"), "ㄇㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("memj"), "ㄇㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("memk"), "ㄇㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("men"), "ㄇㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("menf"), "ㄇㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("menj"), "ㄇㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("melf"), "ㄇㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("melj"), "ㄇㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("melk"), "ㄇㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mxf"), "ㄇㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mxj"), "ㄇㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mxk"), "ㄇㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fa"), "ㄈㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("faf"), "ㄈㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("faj"), "ㄈㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fak"), "ㄈㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fof"), "ㄈㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fq"), "ㄈㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fqf"), "ㄈㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fqj"), "ㄈㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fqk"), "ㄈㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fp"), "ㄈㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fpf"), "ㄈㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fpj"), "ㄈㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fpk"), "ㄈㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fm"), "ㄈㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmf"), "ㄈㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmj"), "ㄈㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmk"), "ㄈㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fn"), "ㄈㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fnf"), "ㄈㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fnj"), "ㄈㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fnk"), "ㄈㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fnd"), "ㄈㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ft"), "ㄈㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ftf"), "ㄈㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ftj"), "ㄈㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ftk"), "ㄈㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fl"), "ㄈㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("flf"), "ㄈㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("flj"), "ㄈㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("flk"), "ㄈㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fezk"), "ㄈㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fx"), "ㄈㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fxf"), "ㄈㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fxj"), "ㄈㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fxk"), "ㄈㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("da"), "ㄉㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("daf"), "ㄉㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("daj"), "ㄉㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dak"), "ㄉㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dad"), "ㄉㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("dr"), "ㄉㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("drf"), "ㄉㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("drd"), "ㄉㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("di"), "ㄉㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dij"), "ㄉㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dik"), "ㄉㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dqj"), "ㄉㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dz"), "ㄉㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dzf"), "ㄉㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dzj"), "ㄉㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dzk"), "ㄉㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dp"), "ㄉㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dpf"), "ㄉㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dpj"), "ㄉㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dpk"), "ㄉㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dm"), "ㄉㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dmj"), "ㄉㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dmk"), "ㄉㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dnk"), "ㄉㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dt"), "ㄉㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dtj"), "ㄉㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dtk"), "ㄉㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dl"), "ㄉㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dlj"), "ㄉㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dlk"), "ㄉㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("de"), "ㄉㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("def"), "ㄉㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dej"), "ㄉㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dek"), "ㄉㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("deaj"), "ㄉㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dew"), "ㄉㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dewf"), "ㄉㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dewj"), "ㄉㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dewk"), "ㄉㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dez"), "ㄉㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dezj"), "ㄉㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dezk"), "ㄉㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dep"), "ㄉㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dem"), "ㄉㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("demf"), "ㄉㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("demj"), "ㄉㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("demk"), "ㄉㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("del"), "ㄉㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("delf"), "ㄉㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("delj"), "ㄉㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("delk"), "ㄉㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dx"), "ㄉㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxf"), "ㄉㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxj"), "ㄉㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxk"), "ㄉㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxo"), "ㄉㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxof"), "ㄉㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxoj"), "ㄉㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxok"), "ㄉㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxod"), "ㄉㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxq"), "ㄉㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxqj"), "ㄉㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxqk"), "ㄉㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxm"), "ㄉㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxmj"), "ㄉㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxmk"), "ㄉㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxn"), "ㄉㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxnj"), "ㄉㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxnk"), "ㄉㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxl"), "ㄉㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxlj"), "ㄉㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxlk"), "ㄉㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ta"), "ㄊㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("taj"), "ㄊㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tak"), "ㄊㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("trk"), "ㄊㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ti"), "ㄊㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tif"), "ㄊㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tij"), "ㄊㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tik"), "ㄊㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tid"), "ㄊㄞ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("tz"), "ㄊㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tzf"), "ㄊㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tzj"), "ㄊㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tzk"), "ㄊㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tzd"), "ㄊㄠ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("tp"), "ㄊㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tpf"), "ㄊㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tpj"), "ㄊㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tpk"), "ㄊㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tpd"), "ㄊㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("tm"), "ㄊㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tmf"), "ㄊㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tmj"), "ㄊㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tmk"), "ㄊㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tt"), "ㄊㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttf"), "ㄊㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttj"), "ㄊㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ttk"), "ㄊㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tl"), "ㄊㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tlf"), "ㄊㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tlk"), "ㄊㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("te"), "ㄊㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tef"), "ㄊㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tej"), "ㄊㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tek"), "ㄊㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tew"), "ㄊㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tewf"), "ㄊㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tewj"), "ㄊㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tewk"), "ㄊㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tez"), "ㄊㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tezf"), "ㄊㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tezj"), "ㄊㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tezk"), "ㄊㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tem"), "ㄊㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("temf"), "ㄊㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("temj"), "ㄊㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("temk"), "ㄊㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tel"), "ㄊㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("telf"), "ㄊㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("telj"), "ㄊㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("telk"), "ㄊㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tx"), "ㄊㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txf"), "ㄊㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txj"), "ㄊㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txk"), "ㄊㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txo"), "ㄊㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txof"), "ㄊㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txoj"), "ㄊㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txok"), "ㄊㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txq"), "ㄊㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txqf"), "ㄊㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txqj"), "ㄊㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txqk"), "ㄊㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txm"), "ㄊㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txmf"), "ㄊㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txmj"), "ㄊㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txmk"), "ㄊㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txn"), "ㄊㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txnf"), "ㄊㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txnj"), "ㄊㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txnk"), "ㄊㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txl"), "ㄊㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txlf"), "ㄊㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txlj"), "ㄊㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txlk"), "ㄊㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("na"), "ㄋㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("naf"), "ㄋㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("naj"), "ㄋㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nak"), "ㄋㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nad"), "ㄋㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("nrk"), "ㄋㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nrd"), "ㄋㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("nif"), "ㄋㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nij"), "ㄋㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nik"), "ㄋㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nqf"), "ㄋㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nqj"), "ㄋㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nqk"), "ㄋㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nz"), "ㄋㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nzf"), "ㄋㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nzj"), "ㄋㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nzk"), "ㄋㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("npf"), "ㄋㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("npj"), "ㄋㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("npk"), "ㄋㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nm"), "ㄋㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nmf"), "ㄋㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nmj"), "ㄋㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nmk"), "ㄋㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nnj"), "ㄋㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nnk"), "ㄋㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nt"), "ㄋㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ntf"), "ㄋㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ntj"), "ㄋㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ntk"), "ㄋㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ntd"), "ㄋㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("nlf"), "ㄋㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nlj"), "ㄋㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ne"), "ㄋㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nef"), "ㄋㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nej"), "ㄋㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nek"), "ㄋㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("new"), "ㄋㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("newf"), "ㄋㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("newk"), "ㄋㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nezj"), "ㄋㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nezk"), "ㄋㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nep"), "ㄋㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nepf"), "ㄋㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nepj"), "ㄋㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nepk"), "ㄋㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nem"), "ㄋㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nemf"), "ㄋㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nemj"), "ㄋㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nemk"), "ㄋㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nen"), "ㄋㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nenf"), "ㄋㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nenj"), "ㄋㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nenk"), "ㄋㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("netf"), "ㄋㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("netj"), "ㄋㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("netk"), "ㄋㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nelf"), "ㄋㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nelj"), "ㄋㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nelk"), "ㄋㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxf"), "ㄋㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxj"), "ㄋㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxk"), "ㄋㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxof"), "ㄋㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxoj"), "ㄋㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxok"), "ㄋㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxqf"), "ㄋㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxmf"), "ㄋㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxmj"), "ㄋㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxmk"), "ㄋㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxnf"), "ㄋㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxlf"), "ㄋㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxlj"), "ㄋㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxlk"), "ㄋㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuf"), "ㄋㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuj"), "ㄋㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuk"), "ㄋㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuwk"), "ㄋㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("la"), "ㄌㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("laf"), "ㄌㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("laj"), "ㄌㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lak"), "ㄌㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lad"), "ㄌㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lo"), "ㄌㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lod"), "ㄌㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lr"), "ㄌㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lrf"), "ㄌㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lrk"), "ㄌㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lrd"), "ㄌㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lif"), "ㄌㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lij"), "ㄌㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lik"), "ㄌㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lq"), "ㄌㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lqf"), "ㄌㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lqj"), "ㄌㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lqk"), "ㄌㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lqd"), "ㄌㄟ˙") + var c = Tekkon.Composer(arrange: .ofETen26) + XCTAssertEqual(c.cS2RC("betf"), "ㄅㄧㄤˊ") + XCTAssertEqual(c.cS2RC("betk"), "ㄅㄧㄤˋ") + XCTAssertEqual(c.cS2RC("dxt"), "ㄉㄨㄤ") + XCTAssertEqual(c.cS2RC("ba"), "ㄅㄚ") + XCTAssertEqual(c.cS2RC("baf"), "ㄅㄚˊ") + XCTAssertEqual(c.cS2RC("baj"), "ㄅㄚˇ") + XCTAssertEqual(c.cS2RC("bak"), "ㄅㄚˋ") + XCTAssertEqual(c.cS2RC("bad"), "ㄅㄚ˙") + XCTAssertEqual(c.cS2RC("bo"), "ㄅㄛ") + XCTAssertEqual(c.cS2RC("bof"), "ㄅㄛˊ") + XCTAssertEqual(c.cS2RC("boj"), "ㄅㄛˇ") + XCTAssertEqual(c.cS2RC("bok"), "ㄅㄛˋ") + XCTAssertEqual(c.cS2RC("bod"), "ㄅㄛ˙") + XCTAssertEqual(c.cS2RC("bi"), "ㄅㄞ") + XCTAssertEqual(c.cS2RC("bif"), "ㄅㄞˊ") + XCTAssertEqual(c.cS2RC("bij"), "ㄅㄞˇ") + XCTAssertEqual(c.cS2RC("bik"), "ㄅㄞˋ") + XCTAssertEqual(c.cS2RC("bid"), "ㄅㄞ˙") + XCTAssertEqual(c.cS2RC("bq"), "ㄅㄟ") + XCTAssertEqual(c.cS2RC("bqj"), "ㄅㄟˇ") + XCTAssertEqual(c.cS2RC("bqk"), "ㄅㄟˋ") + XCTAssertEqual(c.cS2RC("bqd"), "ㄅㄟ˙") + XCTAssertEqual(c.cS2RC("bz"), "ㄅㄠ") + XCTAssertEqual(c.cS2RC("bzf"), "ㄅㄠˊ") + XCTAssertEqual(c.cS2RC("bzj"), "ㄅㄠˇ") + XCTAssertEqual(c.cS2RC("bzk"), "ㄅㄠˋ") + XCTAssertEqual(c.cS2RC("bm"), "ㄅㄢ") + XCTAssertEqual(c.cS2RC("bmj"), "ㄅㄢˇ") + XCTAssertEqual(c.cS2RC("bmk"), "ㄅㄢˋ") + XCTAssertEqual(c.cS2RC("bn"), "ㄅㄣ") + XCTAssertEqual(c.cS2RC("bnj"), "ㄅㄣˇ") + XCTAssertEqual(c.cS2RC("bnk"), "ㄅㄣˋ") + XCTAssertEqual(c.cS2RC("bt"), "ㄅㄤ") + XCTAssertEqual(c.cS2RC("btj"), "ㄅㄤˇ") + XCTAssertEqual(c.cS2RC("btk"), "ㄅㄤˋ") + XCTAssertEqual(c.cS2RC("bl"), "ㄅㄥ") + XCTAssertEqual(c.cS2RC("blf"), "ㄅㄥˊ") + XCTAssertEqual(c.cS2RC("blj"), "ㄅㄥˇ") + XCTAssertEqual(c.cS2RC("blk"), "ㄅㄥˋ") + XCTAssertEqual(c.cS2RC("be"), "ㄅㄧ") + XCTAssertEqual(c.cS2RC("bef"), "ㄅㄧˊ") + XCTAssertEqual(c.cS2RC("bej"), "ㄅㄧˇ") + XCTAssertEqual(c.cS2RC("bek"), "ㄅㄧˋ") + XCTAssertEqual(c.cS2RC("bew"), "ㄅㄧㄝ") + XCTAssertEqual(c.cS2RC("bewf"), "ㄅㄧㄝˊ") + XCTAssertEqual(c.cS2RC("bewj"), "ㄅㄧㄝˇ") + XCTAssertEqual(c.cS2RC("bewk"), "ㄅㄧㄝˋ") + XCTAssertEqual(c.cS2RC("bez"), "ㄅㄧㄠ") + XCTAssertEqual(c.cS2RC("bezj"), "ㄅㄧㄠˇ") + XCTAssertEqual(c.cS2RC("bezk"), "ㄅㄧㄠˋ") + XCTAssertEqual(c.cS2RC("bem"), "ㄅㄧㄢ") + XCTAssertEqual(c.cS2RC("bemf"), "ㄅㄧㄢˊ") + XCTAssertEqual(c.cS2RC("bemj"), "ㄅㄧㄢˇ") + XCTAssertEqual(c.cS2RC("bemk"), "ㄅㄧㄢˋ") + XCTAssertEqual(c.cS2RC("ben"), "ㄅㄧㄣ") + XCTAssertEqual(c.cS2RC("benj"), "ㄅㄧㄣˇ") + XCTAssertEqual(c.cS2RC("benk"), "ㄅㄧㄣˋ") + XCTAssertEqual(c.cS2RC("bel"), "ㄅㄧㄥ") + XCTAssertEqual(c.cS2RC("belj"), "ㄅㄧㄥˇ") + XCTAssertEqual(c.cS2RC("belk"), "ㄅㄧㄥˋ") + XCTAssertEqual(c.cS2RC("bx"), "ㄅㄨ") + XCTAssertEqual(c.cS2RC("bxf"), "ㄅㄨˊ") + XCTAssertEqual(c.cS2RC("bxj"), "ㄅㄨˇ") + XCTAssertEqual(c.cS2RC("bxk"), "ㄅㄨˋ") + XCTAssertEqual(c.cS2RC("pa"), "ㄆㄚ") + XCTAssertEqual(c.cS2RC("paf"), "ㄆㄚˊ") + XCTAssertEqual(c.cS2RC("paj"), "ㄆㄚˇ") + XCTAssertEqual(c.cS2RC("pak"), "ㄆㄚˋ") + XCTAssertEqual(c.cS2RC("pad"), "ㄆㄚ˙") + XCTAssertEqual(c.cS2RC("po"), "ㄆㄛ") + XCTAssertEqual(c.cS2RC("pof"), "ㄆㄛˊ") + XCTAssertEqual(c.cS2RC("poj"), "ㄆㄛˇ") + XCTAssertEqual(c.cS2RC("pok"), "ㄆㄛˋ") + XCTAssertEqual(c.cS2RC("pi"), "ㄆㄞ") + XCTAssertEqual(c.cS2RC("pif"), "ㄆㄞˊ") + XCTAssertEqual(c.cS2RC("pij"), "ㄆㄞˇ") + XCTAssertEqual(c.cS2RC("pik"), "ㄆㄞˋ") + XCTAssertEqual(c.cS2RC("pq"), "ㄆㄟ") + XCTAssertEqual(c.cS2RC("pqf"), "ㄆㄟˊ") + XCTAssertEqual(c.cS2RC("pqj"), "ㄆㄟˇ") + XCTAssertEqual(c.cS2RC("pqk"), "ㄆㄟˋ") + XCTAssertEqual(c.cS2RC("pz"), "ㄆㄠ") + XCTAssertEqual(c.cS2RC("pzf"), "ㄆㄠˊ") + XCTAssertEqual(c.cS2RC("pzj"), "ㄆㄠˇ") + XCTAssertEqual(c.cS2RC("pzk"), "ㄆㄠˋ") + XCTAssertEqual(c.cS2RC("pp"), "ㄆㄡ") + XCTAssertEqual(c.cS2RC("ppf"), "ㄆㄡˊ") + XCTAssertEqual(c.cS2RC("ppj"), "ㄆㄡˇ") + XCTAssertEqual(c.cS2RC("ppk"), "ㄆㄡˋ") + XCTAssertEqual(c.cS2RC("pm"), "ㄆㄢ") + XCTAssertEqual(c.cS2RC("pmf"), "ㄆㄢˊ") + XCTAssertEqual(c.cS2RC("pmj"), "ㄆㄢˇ") + XCTAssertEqual(c.cS2RC("pmk"), "ㄆㄢˋ") + XCTAssertEqual(c.cS2RC("pn"), "ㄆㄣ") + XCTAssertEqual(c.cS2RC("pnf"), "ㄆㄣˊ") + XCTAssertEqual(c.cS2RC("pnj"), "ㄆㄣˇ") + XCTAssertEqual(c.cS2RC("pnk"), "ㄆㄣˋ") + XCTAssertEqual(c.cS2RC("pt"), "ㄆㄤ") + XCTAssertEqual(c.cS2RC("ptf"), "ㄆㄤˊ") + XCTAssertEqual(c.cS2RC("ptj"), "ㄆㄤˇ") + XCTAssertEqual(c.cS2RC("ptk"), "ㄆㄤˋ") + XCTAssertEqual(c.cS2RC("pl"), "ㄆㄥ") + XCTAssertEqual(c.cS2RC("plf"), "ㄆㄥˊ") + XCTAssertEqual(c.cS2RC("plj"), "ㄆㄥˇ") + XCTAssertEqual(c.cS2RC("plk"), "ㄆㄥˋ") + XCTAssertEqual(c.cS2RC("pe"), "ㄆㄧ") + XCTAssertEqual(c.cS2RC("pef"), "ㄆㄧˊ") + XCTAssertEqual(c.cS2RC("pej"), "ㄆㄧˇ") + XCTAssertEqual(c.cS2RC("pek"), "ㄆㄧˋ") + XCTAssertEqual(c.cS2RC("pea"), "ㄆㄧㄚ") + XCTAssertEqual(c.cS2RC("pew"), "ㄆㄧㄝ") + XCTAssertEqual(c.cS2RC("pewj"), "ㄆㄧㄝˇ") + XCTAssertEqual(c.cS2RC("pewk"), "ㄆㄧㄝˋ") + XCTAssertEqual(c.cS2RC("pez"), "ㄆㄧㄠ") + XCTAssertEqual(c.cS2RC("pezf"), "ㄆㄧㄠˊ") + XCTAssertEqual(c.cS2RC("pezj"), "ㄆㄧㄠˇ") + XCTAssertEqual(c.cS2RC("pezk"), "ㄆㄧㄠˋ") + XCTAssertEqual(c.cS2RC("pem"), "ㄆㄧㄢ") + XCTAssertEqual(c.cS2RC("pemf"), "ㄆㄧㄢˊ") + XCTAssertEqual(c.cS2RC("pemj"), "ㄆㄧㄢˇ") + XCTAssertEqual(c.cS2RC("pemk"), "ㄆㄧㄢˋ") + XCTAssertEqual(c.cS2RC("pen"), "ㄆㄧㄣ") + XCTAssertEqual(c.cS2RC("penf"), "ㄆㄧㄣˊ") + XCTAssertEqual(c.cS2RC("penj"), "ㄆㄧㄣˇ") + XCTAssertEqual(c.cS2RC("penk"), "ㄆㄧㄣˋ") + XCTAssertEqual(c.cS2RC("pel"), "ㄆㄧㄥ") + XCTAssertEqual(c.cS2RC("pelf"), "ㄆㄧㄥˊ") + XCTAssertEqual(c.cS2RC("pelj"), "ㄆㄧㄥˇ") + XCTAssertEqual(c.cS2RC("pelk"), "ㄆㄧㄥˋ") + XCTAssertEqual(c.cS2RC("px"), "ㄆㄨ") + XCTAssertEqual(c.cS2RC("pxf"), "ㄆㄨˊ") + XCTAssertEqual(c.cS2RC("pxj"), "ㄆㄨˇ") + XCTAssertEqual(c.cS2RC("pxk"), "ㄆㄨˋ") + XCTAssertEqual(c.cS2RC("ma"), "ㄇㄚ") + XCTAssertEqual(c.cS2RC("maf"), "ㄇㄚˊ") + XCTAssertEqual(c.cS2RC("maj"), "ㄇㄚˇ") + XCTAssertEqual(c.cS2RC("mak"), "ㄇㄚˋ") + XCTAssertEqual(c.cS2RC("mad"), "ㄇㄚ˙") + XCTAssertEqual(c.cS2RC("mo"), "ㄇㄛ") + XCTAssertEqual(c.cS2RC("mof"), "ㄇㄛˊ") + XCTAssertEqual(c.cS2RC("moj"), "ㄇㄛˇ") + XCTAssertEqual(c.cS2RC("mok"), "ㄇㄛˋ") + XCTAssertEqual(c.cS2RC("mod"), "ㄇㄛ˙") + XCTAssertEqual(c.cS2RC("mr"), "ㄇㄜ") + XCTAssertEqual(c.cS2RC("mrk"), "ㄇㄜˋ") + XCTAssertEqual(c.cS2RC("mrd"), "ㄇㄜ˙") + XCTAssertEqual(c.cS2RC("mi"), "ㄇㄞ") + XCTAssertEqual(c.cS2RC("mif"), "ㄇㄞˊ") + XCTAssertEqual(c.cS2RC("mij"), "ㄇㄞˇ") + XCTAssertEqual(c.cS2RC("mik"), "ㄇㄞˋ") + XCTAssertEqual(c.cS2RC("mqf"), "ㄇㄟˊ") + XCTAssertEqual(c.cS2RC("mqj"), "ㄇㄟˇ") + XCTAssertEqual(c.cS2RC("mqk"), "ㄇㄟˋ") + XCTAssertEqual(c.cS2RC("mz"), "ㄇㄠ") + XCTAssertEqual(c.cS2RC("mzf"), "ㄇㄠˊ") + XCTAssertEqual(c.cS2RC("mzj"), "ㄇㄠˇ") + XCTAssertEqual(c.cS2RC("mzk"), "ㄇㄠˋ") + XCTAssertEqual(c.cS2RC("mpf"), "ㄇㄡˊ") + XCTAssertEqual(c.cS2RC("mpj"), "ㄇㄡˇ") + XCTAssertEqual(c.cS2RC("mpk"), "ㄇㄡˋ") + XCTAssertEqual(c.cS2RC("mm"), "ㄇㄢ") + XCTAssertEqual(c.cS2RC("mmf"), "ㄇㄢˊ") + XCTAssertEqual(c.cS2RC("mmj"), "ㄇㄢˇ") + XCTAssertEqual(c.cS2RC("mmk"), "ㄇㄢˋ") + XCTAssertEqual(c.cS2RC("mn"), "ㄇㄣ") + XCTAssertEqual(c.cS2RC("mnf"), "ㄇㄣˊ") + XCTAssertEqual(c.cS2RC("mnj"), "ㄇㄣˇ") + XCTAssertEqual(c.cS2RC("mnk"), "ㄇㄣˋ") + XCTAssertEqual(c.cS2RC("mnd"), "ㄇㄣ˙") + XCTAssertEqual(c.cS2RC("mt"), "ㄇㄤ") + XCTAssertEqual(c.cS2RC("mtf"), "ㄇㄤˊ") + XCTAssertEqual(c.cS2RC("mtj"), "ㄇㄤˇ") + XCTAssertEqual(c.cS2RC("mtk"), "ㄇㄤˋ") + XCTAssertEqual(c.cS2RC("ml"), "ㄇㄥ") + XCTAssertEqual(c.cS2RC("mlf"), "ㄇㄥˊ") + XCTAssertEqual(c.cS2RC("mlj"), "ㄇㄥˇ") + XCTAssertEqual(c.cS2RC("mlk"), "ㄇㄥˋ") + XCTAssertEqual(c.cS2RC("me"), "ㄇㄧ") + XCTAssertEqual(c.cS2RC("mef"), "ㄇㄧˊ") + XCTAssertEqual(c.cS2RC("mej"), "ㄇㄧˇ") + XCTAssertEqual(c.cS2RC("mek"), "ㄇㄧˋ") + XCTAssertEqual(c.cS2RC("mew"), "ㄇㄧㄝ") + XCTAssertEqual(c.cS2RC("mewf"), "ㄇㄧㄝˊ") + XCTAssertEqual(c.cS2RC("mewk"), "ㄇㄧㄝˋ") + XCTAssertEqual(c.cS2RC("mez"), "ㄇㄧㄠ") + XCTAssertEqual(c.cS2RC("mezf"), "ㄇㄧㄠˊ") + XCTAssertEqual(c.cS2RC("mezj"), "ㄇㄧㄠˇ") + XCTAssertEqual(c.cS2RC("mezk"), "ㄇㄧㄠˋ") + XCTAssertEqual(c.cS2RC("mepf"), "ㄇㄧㄡˊ") + XCTAssertEqual(c.cS2RC("mepj"), "ㄇㄧㄡˇ") + XCTAssertEqual(c.cS2RC("mepk"), "ㄇㄧㄡˋ") + XCTAssertEqual(c.cS2RC("mem"), "ㄇㄧㄢ") + XCTAssertEqual(c.cS2RC("memf"), "ㄇㄧㄢˊ") + XCTAssertEqual(c.cS2RC("memj"), "ㄇㄧㄢˇ") + XCTAssertEqual(c.cS2RC("memk"), "ㄇㄧㄢˋ") + XCTAssertEqual(c.cS2RC("men"), "ㄇㄧㄣ") + XCTAssertEqual(c.cS2RC("menf"), "ㄇㄧㄣˊ") + XCTAssertEqual(c.cS2RC("menj"), "ㄇㄧㄣˇ") + XCTAssertEqual(c.cS2RC("melf"), "ㄇㄧㄥˊ") + XCTAssertEqual(c.cS2RC("melj"), "ㄇㄧㄥˇ") + XCTAssertEqual(c.cS2RC("melk"), "ㄇㄧㄥˋ") + XCTAssertEqual(c.cS2RC("mxf"), "ㄇㄨˊ") + XCTAssertEqual(c.cS2RC("mxj"), "ㄇㄨˇ") + XCTAssertEqual(c.cS2RC("mxk"), "ㄇㄨˋ") + XCTAssertEqual(c.cS2RC("fa"), "ㄈㄚ") + XCTAssertEqual(c.cS2RC("faf"), "ㄈㄚˊ") + XCTAssertEqual(c.cS2RC("faj"), "ㄈㄚˇ") + XCTAssertEqual(c.cS2RC("fak"), "ㄈㄚˋ") + XCTAssertEqual(c.cS2RC("fof"), "ㄈㄛˊ") + XCTAssertEqual(c.cS2RC("fq"), "ㄈㄟ") + XCTAssertEqual(c.cS2RC("fqf"), "ㄈㄟˊ") + XCTAssertEqual(c.cS2RC("fqj"), "ㄈㄟˇ") + XCTAssertEqual(c.cS2RC("fqk"), "ㄈㄟˋ") + XCTAssertEqual(c.cS2RC("fp"), "ㄈㄡ") + XCTAssertEqual(c.cS2RC("fpf"), "ㄈㄡˊ") + XCTAssertEqual(c.cS2RC("fpj"), "ㄈㄡˇ") + XCTAssertEqual(c.cS2RC("fpk"), "ㄈㄡˋ") + XCTAssertEqual(c.cS2RC("fm"), "ㄈㄢ") + XCTAssertEqual(c.cS2RC("fmf"), "ㄈㄢˊ") + XCTAssertEqual(c.cS2RC("fmj"), "ㄈㄢˇ") + XCTAssertEqual(c.cS2RC("fmk"), "ㄈㄢˋ") + XCTAssertEqual(c.cS2RC("fn"), "ㄈㄣ") + XCTAssertEqual(c.cS2RC("fnf"), "ㄈㄣˊ") + XCTAssertEqual(c.cS2RC("fnj"), "ㄈㄣˇ") + XCTAssertEqual(c.cS2RC("fnk"), "ㄈㄣˋ") + XCTAssertEqual(c.cS2RC("fnd"), "ㄈㄣ˙") + XCTAssertEqual(c.cS2RC("ft"), "ㄈㄤ") + XCTAssertEqual(c.cS2RC("ftf"), "ㄈㄤˊ") + XCTAssertEqual(c.cS2RC("ftj"), "ㄈㄤˇ") + XCTAssertEqual(c.cS2RC("ftk"), "ㄈㄤˋ") + XCTAssertEqual(c.cS2RC("fl"), "ㄈㄥ") + XCTAssertEqual(c.cS2RC("flf"), "ㄈㄥˊ") + XCTAssertEqual(c.cS2RC("flj"), "ㄈㄥˇ") + XCTAssertEqual(c.cS2RC("flk"), "ㄈㄥˋ") + XCTAssertEqual(c.cS2RC("fezk"), "ㄈㄧㄠˋ") + XCTAssertEqual(c.cS2RC("fx"), "ㄈㄨ") + XCTAssertEqual(c.cS2RC("fxf"), "ㄈㄨˊ") + XCTAssertEqual(c.cS2RC("fxj"), "ㄈㄨˇ") + XCTAssertEqual(c.cS2RC("fxk"), "ㄈㄨˋ") + XCTAssertEqual(c.cS2RC("da"), "ㄉㄚ") + XCTAssertEqual(c.cS2RC("daf"), "ㄉㄚˊ") + XCTAssertEqual(c.cS2RC("daj"), "ㄉㄚˇ") + XCTAssertEqual(c.cS2RC("dak"), "ㄉㄚˋ") + XCTAssertEqual(c.cS2RC("dad"), "ㄉㄚ˙") + XCTAssertEqual(c.cS2RC("dr"), "ㄉㄜ") + XCTAssertEqual(c.cS2RC("drf"), "ㄉㄜˊ") + XCTAssertEqual(c.cS2RC("drd"), "ㄉㄜ˙") + XCTAssertEqual(c.cS2RC("di"), "ㄉㄞ") + XCTAssertEqual(c.cS2RC("dij"), "ㄉㄞˇ") + XCTAssertEqual(c.cS2RC("dik"), "ㄉㄞˋ") + XCTAssertEqual(c.cS2RC("dqj"), "ㄉㄟˇ") + XCTAssertEqual(c.cS2RC("dz"), "ㄉㄠ") + XCTAssertEqual(c.cS2RC("dzf"), "ㄉㄠˊ") + XCTAssertEqual(c.cS2RC("dzj"), "ㄉㄠˇ") + XCTAssertEqual(c.cS2RC("dzk"), "ㄉㄠˋ") + XCTAssertEqual(c.cS2RC("dp"), "ㄉㄡ") + XCTAssertEqual(c.cS2RC("dpf"), "ㄉㄡˊ") + XCTAssertEqual(c.cS2RC("dpj"), "ㄉㄡˇ") + XCTAssertEqual(c.cS2RC("dpk"), "ㄉㄡˋ") + XCTAssertEqual(c.cS2RC("dm"), "ㄉㄢ") + XCTAssertEqual(c.cS2RC("dmj"), "ㄉㄢˇ") + XCTAssertEqual(c.cS2RC("dmk"), "ㄉㄢˋ") + XCTAssertEqual(c.cS2RC("dnk"), "ㄉㄣˋ") + XCTAssertEqual(c.cS2RC("dt"), "ㄉㄤ") + XCTAssertEqual(c.cS2RC("dtj"), "ㄉㄤˇ") + XCTAssertEqual(c.cS2RC("dtk"), "ㄉㄤˋ") + XCTAssertEqual(c.cS2RC("dl"), "ㄉㄥ") + XCTAssertEqual(c.cS2RC("dlj"), "ㄉㄥˇ") + XCTAssertEqual(c.cS2RC("dlk"), "ㄉㄥˋ") + XCTAssertEqual(c.cS2RC("de"), "ㄉㄧ") + XCTAssertEqual(c.cS2RC("def"), "ㄉㄧˊ") + XCTAssertEqual(c.cS2RC("dej"), "ㄉㄧˇ") + XCTAssertEqual(c.cS2RC("dek"), "ㄉㄧˋ") + XCTAssertEqual(c.cS2RC("deaj"), "ㄉㄧㄚˇ") + XCTAssertEqual(c.cS2RC("dew"), "ㄉㄧㄝ") + XCTAssertEqual(c.cS2RC("dewf"), "ㄉㄧㄝˊ") + XCTAssertEqual(c.cS2RC("dewj"), "ㄉㄧㄝˇ") + XCTAssertEqual(c.cS2RC("dewk"), "ㄉㄧㄝˋ") + XCTAssertEqual(c.cS2RC("dez"), "ㄉㄧㄠ") + XCTAssertEqual(c.cS2RC("dezj"), "ㄉㄧㄠˇ") + XCTAssertEqual(c.cS2RC("dezk"), "ㄉㄧㄠˋ") + XCTAssertEqual(c.cS2RC("dep"), "ㄉㄧㄡ") + XCTAssertEqual(c.cS2RC("dem"), "ㄉㄧㄢ") + XCTAssertEqual(c.cS2RC("demf"), "ㄉㄧㄢˊ") + XCTAssertEqual(c.cS2RC("demj"), "ㄉㄧㄢˇ") + XCTAssertEqual(c.cS2RC("demk"), "ㄉㄧㄢˋ") + XCTAssertEqual(c.cS2RC("del"), "ㄉㄧㄥ") + XCTAssertEqual(c.cS2RC("delf"), "ㄉㄧㄥˊ") + XCTAssertEqual(c.cS2RC("delj"), "ㄉㄧㄥˇ") + XCTAssertEqual(c.cS2RC("delk"), "ㄉㄧㄥˋ") + XCTAssertEqual(c.cS2RC("dx"), "ㄉㄨ") + XCTAssertEqual(c.cS2RC("dxf"), "ㄉㄨˊ") + XCTAssertEqual(c.cS2RC("dxj"), "ㄉㄨˇ") + XCTAssertEqual(c.cS2RC("dxk"), "ㄉㄨˋ") + XCTAssertEqual(c.cS2RC("dxo"), "ㄉㄨㄛ") + XCTAssertEqual(c.cS2RC("dxof"), "ㄉㄨㄛˊ") + XCTAssertEqual(c.cS2RC("dxoj"), "ㄉㄨㄛˇ") + XCTAssertEqual(c.cS2RC("dxok"), "ㄉㄨㄛˋ") + XCTAssertEqual(c.cS2RC("dxod"), "ㄉㄨㄛ˙") + XCTAssertEqual(c.cS2RC("dxq"), "ㄉㄨㄟ") + XCTAssertEqual(c.cS2RC("dxqj"), "ㄉㄨㄟˇ") + XCTAssertEqual(c.cS2RC("dxqk"), "ㄉㄨㄟˋ") + XCTAssertEqual(c.cS2RC("dxm"), "ㄉㄨㄢ") + XCTAssertEqual(c.cS2RC("dxmj"), "ㄉㄨㄢˇ") + XCTAssertEqual(c.cS2RC("dxmk"), "ㄉㄨㄢˋ") + XCTAssertEqual(c.cS2RC("dxn"), "ㄉㄨㄣ") + XCTAssertEqual(c.cS2RC("dxnj"), "ㄉㄨㄣˇ") + XCTAssertEqual(c.cS2RC("dxnk"), "ㄉㄨㄣˋ") + XCTAssertEqual(c.cS2RC("dxl"), "ㄉㄨㄥ") + XCTAssertEqual(c.cS2RC("dxlj"), "ㄉㄨㄥˇ") + XCTAssertEqual(c.cS2RC("dxlk"), "ㄉㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ta"), "ㄊㄚ") + XCTAssertEqual(c.cS2RC("taj"), "ㄊㄚˇ") + XCTAssertEqual(c.cS2RC("tak"), "ㄊㄚˋ") + XCTAssertEqual(c.cS2RC("trk"), "ㄊㄜˋ") + XCTAssertEqual(c.cS2RC("ti"), "ㄊㄞ") + XCTAssertEqual(c.cS2RC("tif"), "ㄊㄞˊ") + XCTAssertEqual(c.cS2RC("tij"), "ㄊㄞˇ") + XCTAssertEqual(c.cS2RC("tik"), "ㄊㄞˋ") + XCTAssertEqual(c.cS2RC("tid"), "ㄊㄞ˙") + XCTAssertEqual(c.cS2RC("tz"), "ㄊㄠ") + XCTAssertEqual(c.cS2RC("tzf"), "ㄊㄠˊ") + XCTAssertEqual(c.cS2RC("tzj"), "ㄊㄠˇ") + XCTAssertEqual(c.cS2RC("tzk"), "ㄊㄠˋ") + XCTAssertEqual(c.cS2RC("tzd"), "ㄊㄠ˙") + XCTAssertEqual(c.cS2RC("tp"), "ㄊㄡ") + XCTAssertEqual(c.cS2RC("tpf"), "ㄊㄡˊ") + XCTAssertEqual(c.cS2RC("tpj"), "ㄊㄡˇ") + XCTAssertEqual(c.cS2RC("tpk"), "ㄊㄡˋ") + XCTAssertEqual(c.cS2RC("tpd"), "ㄊㄡ˙") + XCTAssertEqual(c.cS2RC("tm"), "ㄊㄢ") + XCTAssertEqual(c.cS2RC("tmf"), "ㄊㄢˊ") + XCTAssertEqual(c.cS2RC("tmj"), "ㄊㄢˇ") + XCTAssertEqual(c.cS2RC("tmk"), "ㄊㄢˋ") + XCTAssertEqual(c.cS2RC("tt"), "ㄊㄤ") + XCTAssertEqual(c.cS2RC("ttf"), "ㄊㄤˊ") + XCTAssertEqual(c.cS2RC("ttj"), "ㄊㄤˇ") + XCTAssertEqual(c.cS2RC("ttk"), "ㄊㄤˋ") + XCTAssertEqual(c.cS2RC("tl"), "ㄊㄥ") + XCTAssertEqual(c.cS2RC("tlf"), "ㄊㄥˊ") + XCTAssertEqual(c.cS2RC("tlk"), "ㄊㄥˋ") + XCTAssertEqual(c.cS2RC("te"), "ㄊㄧ") + XCTAssertEqual(c.cS2RC("tef"), "ㄊㄧˊ") + XCTAssertEqual(c.cS2RC("tej"), "ㄊㄧˇ") + XCTAssertEqual(c.cS2RC("tek"), "ㄊㄧˋ") + XCTAssertEqual(c.cS2RC("tew"), "ㄊㄧㄝ") + XCTAssertEqual(c.cS2RC("tewf"), "ㄊㄧㄝˊ") + XCTAssertEqual(c.cS2RC("tewj"), "ㄊㄧㄝˇ") + XCTAssertEqual(c.cS2RC("tewk"), "ㄊㄧㄝˋ") + XCTAssertEqual(c.cS2RC("tez"), "ㄊㄧㄠ") + XCTAssertEqual(c.cS2RC("tezf"), "ㄊㄧㄠˊ") + XCTAssertEqual(c.cS2RC("tezj"), "ㄊㄧㄠˇ") + XCTAssertEqual(c.cS2RC("tezk"), "ㄊㄧㄠˋ") + XCTAssertEqual(c.cS2RC("tem"), "ㄊㄧㄢ") + XCTAssertEqual(c.cS2RC("temf"), "ㄊㄧㄢˊ") + XCTAssertEqual(c.cS2RC("temj"), "ㄊㄧㄢˇ") + XCTAssertEqual(c.cS2RC("temk"), "ㄊㄧㄢˋ") + XCTAssertEqual(c.cS2RC("tel"), "ㄊㄧㄥ") + XCTAssertEqual(c.cS2RC("telf"), "ㄊㄧㄥˊ") + XCTAssertEqual(c.cS2RC("telj"), "ㄊㄧㄥˇ") + XCTAssertEqual(c.cS2RC("telk"), "ㄊㄧㄥˋ") + XCTAssertEqual(c.cS2RC("tx"), "ㄊㄨ") + XCTAssertEqual(c.cS2RC("txf"), "ㄊㄨˊ") + XCTAssertEqual(c.cS2RC("txj"), "ㄊㄨˇ") + XCTAssertEqual(c.cS2RC("txk"), "ㄊㄨˋ") + XCTAssertEqual(c.cS2RC("txo"), "ㄊㄨㄛ") + XCTAssertEqual(c.cS2RC("txof"), "ㄊㄨㄛˊ") + XCTAssertEqual(c.cS2RC("txoj"), "ㄊㄨㄛˇ") + XCTAssertEqual(c.cS2RC("txok"), "ㄊㄨㄛˋ") + XCTAssertEqual(c.cS2RC("txq"), "ㄊㄨㄟ") + XCTAssertEqual(c.cS2RC("txqf"), "ㄊㄨㄟˊ") + XCTAssertEqual(c.cS2RC("txqj"), "ㄊㄨㄟˇ") + XCTAssertEqual(c.cS2RC("txqk"), "ㄊㄨㄟˋ") + XCTAssertEqual(c.cS2RC("txm"), "ㄊㄨㄢ") + XCTAssertEqual(c.cS2RC("txmf"), "ㄊㄨㄢˊ") + XCTAssertEqual(c.cS2RC("txmj"), "ㄊㄨㄢˇ") + XCTAssertEqual(c.cS2RC("txmk"), "ㄊㄨㄢˋ") + XCTAssertEqual(c.cS2RC("txn"), "ㄊㄨㄣ") + XCTAssertEqual(c.cS2RC("txnf"), "ㄊㄨㄣˊ") + XCTAssertEqual(c.cS2RC("txnj"), "ㄊㄨㄣˇ") + XCTAssertEqual(c.cS2RC("txnk"), "ㄊㄨㄣˋ") + XCTAssertEqual(c.cS2RC("txl"), "ㄊㄨㄥ") + XCTAssertEqual(c.cS2RC("txlf"), "ㄊㄨㄥˊ") + XCTAssertEqual(c.cS2RC("txlj"), "ㄊㄨㄥˇ") + XCTAssertEqual(c.cS2RC("txlk"), "ㄊㄨㄥˋ") + XCTAssertEqual(c.cS2RC("na"), "ㄋㄚ") + XCTAssertEqual(c.cS2RC("naf"), "ㄋㄚˊ") + XCTAssertEqual(c.cS2RC("naj"), "ㄋㄚˇ") + XCTAssertEqual(c.cS2RC("nak"), "ㄋㄚˋ") + XCTAssertEqual(c.cS2RC("nad"), "ㄋㄚ˙") + XCTAssertEqual(c.cS2RC("nrk"), "ㄋㄜˋ") + XCTAssertEqual(c.cS2RC("nrd"), "ㄋㄜ˙") + XCTAssertEqual(c.cS2RC("nif"), "ㄋㄞˊ") + XCTAssertEqual(c.cS2RC("nij"), "ㄋㄞˇ") + XCTAssertEqual(c.cS2RC("nik"), "ㄋㄞˋ") + XCTAssertEqual(c.cS2RC("nqf"), "ㄋㄟˊ") + XCTAssertEqual(c.cS2RC("nqj"), "ㄋㄟˇ") + XCTAssertEqual(c.cS2RC("nqk"), "ㄋㄟˋ") + XCTAssertEqual(c.cS2RC("nz"), "ㄋㄠ") + XCTAssertEqual(c.cS2RC("nzf"), "ㄋㄠˊ") + XCTAssertEqual(c.cS2RC("nzj"), "ㄋㄠˇ") + XCTAssertEqual(c.cS2RC("nzk"), "ㄋㄠˋ") + XCTAssertEqual(c.cS2RC("npf"), "ㄋㄡˊ") + XCTAssertEqual(c.cS2RC("npj"), "ㄋㄡˇ") + XCTAssertEqual(c.cS2RC("npk"), "ㄋㄡˋ") + XCTAssertEqual(c.cS2RC("nm"), "ㄋㄢ") + XCTAssertEqual(c.cS2RC("nmf"), "ㄋㄢˊ") + XCTAssertEqual(c.cS2RC("nmj"), "ㄋㄢˇ") + XCTAssertEqual(c.cS2RC("nmk"), "ㄋㄢˋ") + XCTAssertEqual(c.cS2RC("nnj"), "ㄋㄣˇ") + XCTAssertEqual(c.cS2RC("nnk"), "ㄋㄣˋ") + XCTAssertEqual(c.cS2RC("nt"), "ㄋㄤ") + XCTAssertEqual(c.cS2RC("ntf"), "ㄋㄤˊ") + XCTAssertEqual(c.cS2RC("ntj"), "ㄋㄤˇ") + XCTAssertEqual(c.cS2RC("ntk"), "ㄋㄤˋ") + XCTAssertEqual(c.cS2RC("ntd"), "ㄋㄤ˙") + XCTAssertEqual(c.cS2RC("nlf"), "ㄋㄥˊ") + XCTAssertEqual(c.cS2RC("nlj"), "ㄋㄥˇ") + XCTAssertEqual(c.cS2RC("ne"), "ㄋㄧ") + XCTAssertEqual(c.cS2RC("nef"), "ㄋㄧˊ") + XCTAssertEqual(c.cS2RC("nej"), "ㄋㄧˇ") + XCTAssertEqual(c.cS2RC("nek"), "ㄋㄧˋ") + XCTAssertEqual(c.cS2RC("new"), "ㄋㄧㄝ") + XCTAssertEqual(c.cS2RC("newf"), "ㄋㄧㄝˊ") + XCTAssertEqual(c.cS2RC("newk"), "ㄋㄧㄝˋ") + XCTAssertEqual(c.cS2RC("nezj"), "ㄋㄧㄠˇ") + XCTAssertEqual(c.cS2RC("nezk"), "ㄋㄧㄠˋ") + XCTAssertEqual(c.cS2RC("nep"), "ㄋㄧㄡ") + XCTAssertEqual(c.cS2RC("nepf"), "ㄋㄧㄡˊ") + XCTAssertEqual(c.cS2RC("nepj"), "ㄋㄧㄡˇ") + XCTAssertEqual(c.cS2RC("nepk"), "ㄋㄧㄡˋ") + XCTAssertEqual(c.cS2RC("nem"), "ㄋㄧㄢ") + XCTAssertEqual(c.cS2RC("nemf"), "ㄋㄧㄢˊ") + XCTAssertEqual(c.cS2RC("nemj"), "ㄋㄧㄢˇ") + XCTAssertEqual(c.cS2RC("nemk"), "ㄋㄧㄢˋ") + XCTAssertEqual(c.cS2RC("nen"), "ㄋㄧㄣ") + XCTAssertEqual(c.cS2RC("nenf"), "ㄋㄧㄣˊ") + XCTAssertEqual(c.cS2RC("nenj"), "ㄋㄧㄣˇ") + XCTAssertEqual(c.cS2RC("nenk"), "ㄋㄧㄣˋ") + XCTAssertEqual(c.cS2RC("netf"), "ㄋㄧㄤˊ") + XCTAssertEqual(c.cS2RC("netj"), "ㄋㄧㄤˇ") + XCTAssertEqual(c.cS2RC("netk"), "ㄋㄧㄤˋ") + XCTAssertEqual(c.cS2RC("nelf"), "ㄋㄧㄥˊ") + XCTAssertEqual(c.cS2RC("nelj"), "ㄋㄧㄥˇ") + XCTAssertEqual(c.cS2RC("nelk"), "ㄋㄧㄥˋ") + XCTAssertEqual(c.cS2RC("nxf"), "ㄋㄨˊ") + XCTAssertEqual(c.cS2RC("nxj"), "ㄋㄨˇ") + XCTAssertEqual(c.cS2RC("nxk"), "ㄋㄨˋ") + XCTAssertEqual(c.cS2RC("nxof"), "ㄋㄨㄛˊ") + XCTAssertEqual(c.cS2RC("nxoj"), "ㄋㄨㄛˇ") + XCTAssertEqual(c.cS2RC("nxok"), "ㄋㄨㄛˋ") + XCTAssertEqual(c.cS2RC("nxqf"), "ㄋㄨㄟˊ") + XCTAssertEqual(c.cS2RC("nxmf"), "ㄋㄨㄢˊ") + XCTAssertEqual(c.cS2RC("nxmj"), "ㄋㄨㄢˇ") + XCTAssertEqual(c.cS2RC("nxmk"), "ㄋㄨㄢˋ") + XCTAssertEqual(c.cS2RC("nxnf"), "ㄋㄨㄣˊ") + XCTAssertEqual(c.cS2RC("nxlf"), "ㄋㄨㄥˊ") + XCTAssertEqual(c.cS2RC("nxlj"), "ㄋㄨㄥˇ") + XCTAssertEqual(c.cS2RC("nxlk"), "ㄋㄨㄥˋ") + XCTAssertEqual(c.cS2RC("nuf"), "ㄋㄩˊ") + XCTAssertEqual(c.cS2RC("nuj"), "ㄋㄩˇ") + XCTAssertEqual(c.cS2RC("nuk"), "ㄋㄩˋ") + XCTAssertEqual(c.cS2RC("nuwk"), "ㄋㄩㄝˋ") + XCTAssertEqual(c.cS2RC("la"), "ㄌㄚ") + XCTAssertEqual(c.cS2RC("laf"), "ㄌㄚˊ") + XCTAssertEqual(c.cS2RC("laj"), "ㄌㄚˇ") + XCTAssertEqual(c.cS2RC("lak"), "ㄌㄚˋ") + XCTAssertEqual(c.cS2RC("lad"), "ㄌㄚ˙") + XCTAssertEqual(c.cS2RC("lo"), "ㄌㄛ") + XCTAssertEqual(c.cS2RC("lod"), "ㄌㄛ˙") + XCTAssertEqual(c.cS2RC("lr"), "ㄌㄜ") + XCTAssertEqual(c.cS2RC("lrf"), "ㄌㄜˊ") + XCTAssertEqual(c.cS2RC("lrk"), "ㄌㄜˋ") + XCTAssertEqual(c.cS2RC("lrd"), "ㄌㄜ˙") + XCTAssertEqual(c.cS2RC("lif"), "ㄌㄞˊ") + XCTAssertEqual(c.cS2RC("lij"), "ㄌㄞˇ") + XCTAssertEqual(c.cS2RC("lik"), "ㄌㄞˋ") + XCTAssertEqual(c.cS2RC("lq"), "ㄌㄟ") + XCTAssertEqual(c.cS2RC("lqf"), "ㄌㄟˊ") + XCTAssertEqual(c.cS2RC("lqj"), "ㄌㄟˇ") + XCTAssertEqual(c.cS2RC("lqk"), "ㄌㄟˋ") + XCTAssertEqual(c.cS2RC("lqd"), "ㄌㄟ˙") } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_B.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_B.swift index 8219f00c..61c00f40 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_B.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_B.swift @@ -12,490 +12,490 @@ import XCTest extension TekkonTestsKeyboardArrangments { func testETen26KeysB() throws { - var composer = Tekkon.Composer(arrange: .ofETen26) - XCTAssertEqual(composer.convertSequenceToRawComposition("lz"), "ㄌㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lzf"), "ㄌㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lzj"), "ㄌㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lzk"), "ㄌㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lp"), "ㄌㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lpf"), "ㄌㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lpj"), "ㄌㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lpk"), "ㄌㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lpd"), "ㄌㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lmf"), "ㄌㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lmj"), "ㄌㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lmk"), "ㄌㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lt"), "ㄌㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ltf"), "ㄌㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ltj"), "ㄌㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ltk"), "ㄌㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ll"), "ㄌㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("llf"), "ㄌㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("llj"), "ㄌㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("llk"), "ㄌㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("le"), "ㄌㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lef"), "ㄌㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lej"), "ㄌㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lek"), "ㄌㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("led"), "ㄌㄧ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("leaj"), "ㄌㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lew"), "ㄌㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lewf"), "ㄌㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lewj"), "ㄌㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lewk"), "ㄌㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lez"), "ㄌㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lezf"), "ㄌㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lezj"), "ㄌㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lezk"), "ㄌㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lep"), "ㄌㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lepf"), "ㄌㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lepj"), "ㄌㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lepk"), "ㄌㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lem"), "ㄌㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lemf"), "ㄌㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lemj"), "ㄌㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lemk"), "ㄌㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lenf"), "ㄌㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lenj"), "ㄌㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lenk"), "ㄌㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("letf"), "ㄌㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("letj"), "ㄌㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("letk"), "ㄌㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lel"), "ㄌㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lelf"), "ㄌㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lelj"), "ㄌㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lelk"), "ㄌㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lx"), "ㄌㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxf"), "ㄌㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxj"), "ㄌㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxk"), "ㄌㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxo"), "ㄌㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxof"), "ㄌㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxoj"), "ㄌㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxok"), "ㄌㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxod"), "ㄌㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxmf"), "ㄌㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxmj"), "ㄌㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxmk"), "ㄌㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxn"), "ㄌㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxnf"), "ㄌㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxnj"), "ㄌㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxnk"), "ㄌㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxl"), "ㄌㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxlf"), "ㄌㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxlj"), "ㄌㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxlk"), "ㄌㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lu"), "ㄌㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luf"), "ㄌㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luj"), "ㄌㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luk"), "ㄌㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luw"), "ㄌㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luwj"), "ㄌㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luwk"), "ㄌㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lumf"), "ㄌㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lumj"), "ㄌㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("va"), "ㄍㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vaf"), "ㄍㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vaj"), "ㄍㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vak"), "ㄍㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vad"), "ㄍㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("vr"), "ㄍㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vrf"), "ㄍㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vrj"), "ㄍㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vrk"), "ㄍㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vrd"), "ㄍㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("vi"), "ㄍㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vij"), "ㄍㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vik"), "ㄍㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vqj"), "ㄍㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vz"), "ㄍㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vzj"), "ㄍㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vzk"), "ㄍㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vp"), "ㄍㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vpj"), "ㄍㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vpk"), "ㄍㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vm"), "ㄍㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmj"), "ㄍㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmk"), "ㄍㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vn"), "ㄍㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vnf"), "ㄍㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vnj"), "ㄍㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vnk"), "ㄍㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vt"), "ㄍㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vtj"), "ㄍㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vtk"), "ㄍㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vl"), "ㄍㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vlj"), "ㄍㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vlk"), "ㄍㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vx"), "ㄍㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxf"), "ㄍㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxj"), "ㄍㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxk"), "ㄍㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxa"), "ㄍㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxaf"), "ㄍㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxaj"), "ㄍㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxak"), "ㄍㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxo"), "ㄍㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxof"), "ㄍㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxoj"), "ㄍㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxok"), "ㄍㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxi"), "ㄍㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxij"), "ㄍㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxik"), "ㄍㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxq"), "ㄍㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxqj"), "ㄍㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxqk"), "ㄍㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxm"), "ㄍㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxmj"), "ㄍㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxmk"), "ㄍㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxn"), "ㄍㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxnj"), "ㄍㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxnk"), "ㄍㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxt"), "ㄍㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxtj"), "ㄍㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxtk"), "ㄍㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxl"), "ㄍㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxlf"), "ㄍㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxlj"), "ㄍㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxlk"), "ㄍㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ka"), "ㄎㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kaj"), "ㄎㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kak"), "ㄎㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kr"), "ㄎㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("krf"), "ㄎㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("krj"), "ㄎㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("krk"), "ㄎㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ki"), "ㄎㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kij"), "ㄎㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kik"), "ㄎㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kz"), "ㄎㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kzj"), "ㄎㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kzk"), "ㄎㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kp"), "ㄎㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kpj"), "ㄎㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kpk"), "ㄎㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("km"), "ㄎㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kmj"), "ㄎㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kmk"), "ㄎㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kn"), "ㄎㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("knj"), "ㄎㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("knk"), "ㄎㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kt"), "ㄎㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ktf"), "ㄎㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ktj"), "ㄎㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ktk"), "ㄎㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kl"), "ㄎㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("klj"), "ㄎㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kx"), "ㄎㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxf"), "ㄎㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxj"), "ㄎㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxk"), "ㄎㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxa"), "ㄎㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxaj"), "ㄎㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxak"), "ㄎㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxok"), "ㄎㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxi"), "ㄎㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxij"), "ㄎㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxik"), "ㄎㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxq"), "ㄎㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxqf"), "ㄎㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxqj"), "ㄎㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxqk"), "ㄎㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxm"), "ㄎㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxmj"), "ㄎㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxmk"), "ㄎㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxn"), "ㄎㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxnj"), "ㄎㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxnk"), "ㄎㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxt"), "ㄎㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxtf"), "ㄎㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxtj"), "ㄎㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxtk"), "ㄎㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxl"), "ㄎㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxlj"), "ㄎㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxlk"), "ㄎㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ha"), "ㄏㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("haf"), "ㄏㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("haj"), "ㄏㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hr"), "ㄏㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hrf"), "ㄏㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hrj"), "ㄏㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hrk"), "ㄏㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hi"), "ㄏㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hif"), "ㄏㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hij"), "ㄏㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hik"), "ㄏㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hq"), "ㄏㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hqj"), "ㄏㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hz"), "ㄏㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hzf"), "ㄏㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hzj"), "ㄏㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hzk"), "ㄏㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hp"), "ㄏㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hpf"), "ㄏㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hpj"), "ㄏㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hpk"), "ㄏㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hm"), "ㄏㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hmf"), "ㄏㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hmj"), "ㄏㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hmk"), "ㄏㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hn"), "ㄏㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hnf"), "ㄏㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hnj"), "ㄏㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hnk"), "ㄏㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ht"), "ㄏㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("htf"), "ㄏㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("htj"), "ㄏㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("htk"), "ㄏㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hl"), "ㄏㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hlf"), "ㄏㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hlk"), "ㄏㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hx"), "ㄏㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxf"), "ㄏㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxj"), "ㄏㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxk"), "ㄏㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxa"), "ㄏㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxaf"), "ㄏㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxaj"), "ㄏㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxak"), "ㄏㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxo"), "ㄏㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxof"), "ㄏㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxoj"), "ㄏㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxok"), "ㄏㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxod"), "ㄏㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxif"), "ㄏㄨㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxik"), "ㄏㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxq"), "ㄏㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxqf"), "ㄏㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxqj"), "ㄏㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxqk"), "ㄏㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxm"), "ㄏㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxmf"), "ㄏㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxmj"), "ㄏㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxmk"), "ㄏㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxn"), "ㄏㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxnf"), "ㄏㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxnj"), "ㄏㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxnk"), "ㄏㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxt"), "ㄏㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxtf"), "ㄏㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxtj"), "ㄏㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxtk"), "ㄏㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxtd"), "ㄏㄨㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxl"), "ㄏㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxlf"), "ㄏㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxlj"), "ㄏㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxlk"), "ㄏㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ge"), "ㄐㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gef"), "ㄐㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gej"), "ㄐㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gek"), "ㄐㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gea"), "ㄐㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("geaf"), "ㄐㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("geaj"), "ㄐㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("geak"), "ㄐㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gew"), "ㄐㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gewf"), "ㄐㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gewj"), "ㄐㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gewk"), "ㄐㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gewd"), "ㄐㄧㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("gez"), "ㄐㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gezf"), "ㄐㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gezj"), "ㄐㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gezk"), "ㄐㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gep"), "ㄐㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gepj"), "ㄐㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gepk"), "ㄐㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gem"), "ㄐㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gemj"), "ㄐㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gemk"), "ㄐㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gen"), "ㄐㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("genj"), "ㄐㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("genk"), "ㄐㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("get"), "ㄐㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("getf"), "ㄐㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("getj"), "ㄐㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("getk"), "ㄐㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gel"), "ㄐㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gelj"), "ㄐㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gelk"), "ㄐㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gu"), "ㄐㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guf"), "ㄐㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guj"), "ㄐㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guk"), "ㄐㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guw"), "ㄐㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guwf"), "ㄐㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guwj"), "ㄐㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guwk"), "ㄐㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gum"), "ㄐㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gumj"), "ㄐㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gumk"), "ㄐㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gun"), "ㄐㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gunf"), "ㄐㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gunj"), "ㄐㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gunk"), "ㄐㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gul"), "ㄐㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gulj"), "ㄐㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gulk"), "ㄐㄩㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vd"), "ㄑ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ve"), "ㄑㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vef"), "ㄑㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vej"), "ㄑㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vek"), "ㄑㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vea"), "ㄑㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veaf"), "ㄑㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veaj"), "ㄑㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veak"), "ㄑㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vew"), "ㄑㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vewf"), "ㄑㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vewj"), "ㄑㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vewk"), "ㄑㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vez"), "ㄑㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vezf"), "ㄑㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vezj"), "ㄑㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vezk"), "ㄑㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vep"), "ㄑㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vepf"), "ㄑㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vepj"), "ㄑㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vepk"), "ㄑㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vem"), "ㄑㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vemf"), "ㄑㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vemj"), "ㄑㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vemk"), "ㄑㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ven"), "ㄑㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("venf"), "ㄑㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("venj"), "ㄑㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("venk"), "ㄑㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vet"), "ㄑㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vetf"), "ㄑㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vetj"), "ㄑㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vetk"), "ㄑㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vel"), "ㄑㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("velf"), "ㄑㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("velj"), "ㄑㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("velk"), "ㄑㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vu"), "ㄑㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuf"), "ㄑㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuj"), "ㄑㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuk"), "ㄑㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuw"), "ㄑㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuwf"), "ㄑㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuwk"), "ㄑㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vum"), "ㄑㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vumf"), "ㄑㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vumj"), "ㄑㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vumk"), "ㄑㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vun"), "ㄑㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vunf"), "ㄑㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vunj"), "ㄑㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vunk"), "ㄑㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vul"), "ㄑㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vulf"), "ㄑㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vulj"), "ㄑㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vulk"), "ㄑㄩㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ce"), "ㄒㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cef"), "ㄒㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cej"), "ㄒㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cek"), "ㄒㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cea"), "ㄒㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceaf"), "ㄒㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceaj"), "ㄒㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceak"), "ㄒㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cew"), "ㄒㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cewf"), "ㄒㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cewj"), "ㄒㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cewk"), "ㄒㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cez"), "ㄒㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cezf"), "ㄒㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cezj"), "ㄒㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cezk"), "ㄒㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cep"), "ㄒㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cepf"), "ㄒㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cepj"), "ㄒㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cepk"), "ㄒㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cem"), "ㄒㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cemf"), "ㄒㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cemj"), "ㄒㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cemk"), "ㄒㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cen"), "ㄒㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cenf"), "ㄒㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cenj"), "ㄒㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cenk"), "ㄒㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cet"), "ㄒㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cetf"), "ㄒㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cetj"), "ㄒㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cetk"), "ㄒㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cel"), "ㄒㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("celf"), "ㄒㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("celj"), "ㄒㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("celk"), "ㄒㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cu"), "ㄒㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuf"), "ㄒㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuj"), "ㄒㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuk"), "ㄒㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuw"), "ㄒㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuwf"), "ㄒㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuwj"), "ㄒㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuwk"), "ㄒㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cum"), "ㄒㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cumf"), "ㄒㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cumj"), "ㄒㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cumk"), "ㄒㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cun"), "ㄒㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cunf"), "ㄒㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cunk"), "ㄒㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cul"), "ㄒㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("culf"), "ㄒㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("culj"), "ㄒㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("culk"), "ㄒㄩㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("g"), "ㄓ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gf"), "ㄓˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gj"), "ㄓˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gk"), "ㄓˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ga"), "ㄓㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gaf"), "ㄓㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gaj"), "ㄓㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gak"), "ㄓㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gr"), "ㄓㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("grf"), "ㄓㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("grj"), "ㄓㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("grk"), "ㄓㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("grd"), "ㄓㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("gi"), "ㄓㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gif"), "ㄓㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gij"), "ㄓㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gik"), "ㄓㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gqk"), "ㄓㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gz"), "ㄓㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gzf"), "ㄓㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gzj"), "ㄓㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gzk"), "ㄓㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gp"), "ㄓㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gpf"), "ㄓㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gpj"), "ㄓㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gpk"), "ㄓㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gm"), "ㄓㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gmj"), "ㄓㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gmk"), "ㄓㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gn"), "ㄓㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gnf"), "ㄓㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gnj"), "ㄓㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gnk"), "ㄓㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gt"), "ㄓㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gtj"), "ㄓㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gtk"), "ㄓㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gl"), "ㄓㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("glj"), "ㄓㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("glk"), "ㄓㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gx"), "ㄓㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxf"), "ㄓㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxj"), "ㄓㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxk"), "ㄓㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxa"), "ㄓㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxaj"), "ㄓㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxo"), "ㄓㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxof"), "ㄓㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxok"), "ㄓㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxi"), "ㄓㄨㄞ") + var c = Tekkon.Composer(arrange: .ofETen26) + XCTAssertEqual(c.cS2RC("lz"), "ㄌㄠ") + XCTAssertEqual(c.cS2RC("lzf"), "ㄌㄠˊ") + XCTAssertEqual(c.cS2RC("lzj"), "ㄌㄠˇ") + XCTAssertEqual(c.cS2RC("lzk"), "ㄌㄠˋ") + XCTAssertEqual(c.cS2RC("lp"), "ㄌㄡ") + XCTAssertEqual(c.cS2RC("lpf"), "ㄌㄡˊ") + XCTAssertEqual(c.cS2RC("lpj"), "ㄌㄡˇ") + XCTAssertEqual(c.cS2RC("lpk"), "ㄌㄡˋ") + XCTAssertEqual(c.cS2RC("lpd"), "ㄌㄡ˙") + XCTAssertEqual(c.cS2RC("lmf"), "ㄌㄢˊ") + XCTAssertEqual(c.cS2RC("lmj"), "ㄌㄢˇ") + XCTAssertEqual(c.cS2RC("lmk"), "ㄌㄢˋ") + XCTAssertEqual(c.cS2RC("lt"), "ㄌㄤ") + XCTAssertEqual(c.cS2RC("ltf"), "ㄌㄤˊ") + XCTAssertEqual(c.cS2RC("ltj"), "ㄌㄤˇ") + XCTAssertEqual(c.cS2RC("ltk"), "ㄌㄤˋ") + XCTAssertEqual(c.cS2RC("ll"), "ㄌㄥ") + XCTAssertEqual(c.cS2RC("llf"), "ㄌㄥˊ") + XCTAssertEqual(c.cS2RC("llj"), "ㄌㄥˇ") + XCTAssertEqual(c.cS2RC("llk"), "ㄌㄥˋ") + XCTAssertEqual(c.cS2RC("le"), "ㄌㄧ") + XCTAssertEqual(c.cS2RC("lef"), "ㄌㄧˊ") + XCTAssertEqual(c.cS2RC("lej"), "ㄌㄧˇ") + XCTAssertEqual(c.cS2RC("lek"), "ㄌㄧˋ") + XCTAssertEqual(c.cS2RC("led"), "ㄌㄧ˙") + XCTAssertEqual(c.cS2RC("leaj"), "ㄌㄧㄚˇ") + XCTAssertEqual(c.cS2RC("lew"), "ㄌㄧㄝ") + XCTAssertEqual(c.cS2RC("lewf"), "ㄌㄧㄝˊ") + XCTAssertEqual(c.cS2RC("lewj"), "ㄌㄧㄝˇ") + XCTAssertEqual(c.cS2RC("lewk"), "ㄌㄧㄝˋ") + XCTAssertEqual(c.cS2RC("lez"), "ㄌㄧㄠ") + XCTAssertEqual(c.cS2RC("lezf"), "ㄌㄧㄠˊ") + XCTAssertEqual(c.cS2RC("lezj"), "ㄌㄧㄠˇ") + XCTAssertEqual(c.cS2RC("lezk"), "ㄌㄧㄠˋ") + XCTAssertEqual(c.cS2RC("lep"), "ㄌㄧㄡ") + XCTAssertEqual(c.cS2RC("lepf"), "ㄌㄧㄡˊ") + XCTAssertEqual(c.cS2RC("lepj"), "ㄌㄧㄡˇ") + XCTAssertEqual(c.cS2RC("lepk"), "ㄌㄧㄡˋ") + XCTAssertEqual(c.cS2RC("lem"), "ㄌㄧㄢ") + XCTAssertEqual(c.cS2RC("lemf"), "ㄌㄧㄢˊ") + XCTAssertEqual(c.cS2RC("lemj"), "ㄌㄧㄢˇ") + XCTAssertEqual(c.cS2RC("lemk"), "ㄌㄧㄢˋ") + XCTAssertEqual(c.cS2RC("lenf"), "ㄌㄧㄣˊ") + XCTAssertEqual(c.cS2RC("lenj"), "ㄌㄧㄣˇ") + XCTAssertEqual(c.cS2RC("lenk"), "ㄌㄧㄣˋ") + XCTAssertEqual(c.cS2RC("letf"), "ㄌㄧㄤˊ") + XCTAssertEqual(c.cS2RC("letj"), "ㄌㄧㄤˇ") + XCTAssertEqual(c.cS2RC("letk"), "ㄌㄧㄤˋ") + XCTAssertEqual(c.cS2RC("lel"), "ㄌㄧㄥ") + XCTAssertEqual(c.cS2RC("lelf"), "ㄌㄧㄥˊ") + XCTAssertEqual(c.cS2RC("lelj"), "ㄌㄧㄥˇ") + XCTAssertEqual(c.cS2RC("lelk"), "ㄌㄧㄥˋ") + XCTAssertEqual(c.cS2RC("lx"), "ㄌㄨ") + XCTAssertEqual(c.cS2RC("lxf"), "ㄌㄨˊ") + XCTAssertEqual(c.cS2RC("lxj"), "ㄌㄨˇ") + XCTAssertEqual(c.cS2RC("lxk"), "ㄌㄨˋ") + XCTAssertEqual(c.cS2RC("lxo"), "ㄌㄨㄛ") + XCTAssertEqual(c.cS2RC("lxof"), "ㄌㄨㄛˊ") + XCTAssertEqual(c.cS2RC("lxoj"), "ㄌㄨㄛˇ") + XCTAssertEqual(c.cS2RC("lxok"), "ㄌㄨㄛˋ") + XCTAssertEqual(c.cS2RC("lxod"), "ㄌㄨㄛ˙") + XCTAssertEqual(c.cS2RC("lxmf"), "ㄌㄨㄢˊ") + XCTAssertEqual(c.cS2RC("lxmj"), "ㄌㄨㄢˇ") + XCTAssertEqual(c.cS2RC("lxmk"), "ㄌㄨㄢˋ") + XCTAssertEqual(c.cS2RC("lxn"), "ㄌㄨㄣ") + XCTAssertEqual(c.cS2RC("lxnf"), "ㄌㄨㄣˊ") + XCTAssertEqual(c.cS2RC("lxnj"), "ㄌㄨㄣˇ") + XCTAssertEqual(c.cS2RC("lxnk"), "ㄌㄨㄣˋ") + XCTAssertEqual(c.cS2RC("lxl"), "ㄌㄨㄥ") + XCTAssertEqual(c.cS2RC("lxlf"), "ㄌㄨㄥˊ") + XCTAssertEqual(c.cS2RC("lxlj"), "ㄌㄨㄥˇ") + XCTAssertEqual(c.cS2RC("lxlk"), "ㄌㄨㄥˋ") + XCTAssertEqual(c.cS2RC("lu"), "ㄌㄩ") + XCTAssertEqual(c.cS2RC("luf"), "ㄌㄩˊ") + XCTAssertEqual(c.cS2RC("luj"), "ㄌㄩˇ") + XCTAssertEqual(c.cS2RC("luk"), "ㄌㄩˋ") + XCTAssertEqual(c.cS2RC("luw"), "ㄌㄩㄝ") + XCTAssertEqual(c.cS2RC("luwj"), "ㄌㄩㄝˇ") + XCTAssertEqual(c.cS2RC("luwk"), "ㄌㄩㄝˋ") + XCTAssertEqual(c.cS2RC("lumf"), "ㄌㄩㄢˊ") + XCTAssertEqual(c.cS2RC("lumj"), "ㄌㄩㄢˇ") + XCTAssertEqual(c.cS2RC("va"), "ㄍㄚ") + XCTAssertEqual(c.cS2RC("vaf"), "ㄍㄚˊ") + XCTAssertEqual(c.cS2RC("vaj"), "ㄍㄚˇ") + XCTAssertEqual(c.cS2RC("vak"), "ㄍㄚˋ") + XCTAssertEqual(c.cS2RC("vad"), "ㄍㄚ˙") + XCTAssertEqual(c.cS2RC("vr"), "ㄍㄜ") + XCTAssertEqual(c.cS2RC("vrf"), "ㄍㄜˊ") + XCTAssertEqual(c.cS2RC("vrj"), "ㄍㄜˇ") + XCTAssertEqual(c.cS2RC("vrk"), "ㄍㄜˋ") + XCTAssertEqual(c.cS2RC("vrd"), "ㄍㄜ˙") + XCTAssertEqual(c.cS2RC("vi"), "ㄍㄞ") + XCTAssertEqual(c.cS2RC("vij"), "ㄍㄞˇ") + XCTAssertEqual(c.cS2RC("vik"), "ㄍㄞˋ") + XCTAssertEqual(c.cS2RC("vqj"), "ㄍㄟˇ") + XCTAssertEqual(c.cS2RC("vz"), "ㄍㄠ") + XCTAssertEqual(c.cS2RC("vzj"), "ㄍㄠˇ") + XCTAssertEqual(c.cS2RC("vzk"), "ㄍㄠˋ") + XCTAssertEqual(c.cS2RC("vp"), "ㄍㄡ") + XCTAssertEqual(c.cS2RC("vpj"), "ㄍㄡˇ") + XCTAssertEqual(c.cS2RC("vpk"), "ㄍㄡˋ") + XCTAssertEqual(c.cS2RC("vm"), "ㄍㄢ") + XCTAssertEqual(c.cS2RC("vmj"), "ㄍㄢˇ") + XCTAssertEqual(c.cS2RC("vmk"), "ㄍㄢˋ") + XCTAssertEqual(c.cS2RC("vn"), "ㄍㄣ") + XCTAssertEqual(c.cS2RC("vnf"), "ㄍㄣˊ") + XCTAssertEqual(c.cS2RC("vnj"), "ㄍㄣˇ") + XCTAssertEqual(c.cS2RC("vnk"), "ㄍㄣˋ") + XCTAssertEqual(c.cS2RC("vt"), "ㄍㄤ") + XCTAssertEqual(c.cS2RC("vtj"), "ㄍㄤˇ") + XCTAssertEqual(c.cS2RC("vtk"), "ㄍㄤˋ") + XCTAssertEqual(c.cS2RC("vl"), "ㄍㄥ") + XCTAssertEqual(c.cS2RC("vlj"), "ㄍㄥˇ") + XCTAssertEqual(c.cS2RC("vlk"), "ㄍㄥˋ") + XCTAssertEqual(c.cS2RC("vx"), "ㄍㄨ") + XCTAssertEqual(c.cS2RC("vxf"), "ㄍㄨˊ") + XCTAssertEqual(c.cS2RC("vxj"), "ㄍㄨˇ") + XCTAssertEqual(c.cS2RC("vxk"), "ㄍㄨˋ") + XCTAssertEqual(c.cS2RC("vxa"), "ㄍㄨㄚ") + XCTAssertEqual(c.cS2RC("vxaf"), "ㄍㄨㄚˊ") + XCTAssertEqual(c.cS2RC("vxaj"), "ㄍㄨㄚˇ") + XCTAssertEqual(c.cS2RC("vxak"), "ㄍㄨㄚˋ") + XCTAssertEqual(c.cS2RC("vxo"), "ㄍㄨㄛ") + XCTAssertEqual(c.cS2RC("vxof"), "ㄍㄨㄛˊ") + XCTAssertEqual(c.cS2RC("vxoj"), "ㄍㄨㄛˇ") + XCTAssertEqual(c.cS2RC("vxok"), "ㄍㄨㄛˋ") + XCTAssertEqual(c.cS2RC("vxi"), "ㄍㄨㄞ") + XCTAssertEqual(c.cS2RC("vxij"), "ㄍㄨㄞˇ") + XCTAssertEqual(c.cS2RC("vxik"), "ㄍㄨㄞˋ") + XCTAssertEqual(c.cS2RC("vxq"), "ㄍㄨㄟ") + XCTAssertEqual(c.cS2RC("vxqj"), "ㄍㄨㄟˇ") + XCTAssertEqual(c.cS2RC("vxqk"), "ㄍㄨㄟˋ") + XCTAssertEqual(c.cS2RC("vxm"), "ㄍㄨㄢ") + XCTAssertEqual(c.cS2RC("vxmj"), "ㄍㄨㄢˇ") + XCTAssertEqual(c.cS2RC("vxmk"), "ㄍㄨㄢˋ") + XCTAssertEqual(c.cS2RC("vxn"), "ㄍㄨㄣ") + XCTAssertEqual(c.cS2RC("vxnj"), "ㄍㄨㄣˇ") + XCTAssertEqual(c.cS2RC("vxnk"), "ㄍㄨㄣˋ") + XCTAssertEqual(c.cS2RC("vxt"), "ㄍㄨㄤ") + XCTAssertEqual(c.cS2RC("vxtj"), "ㄍㄨㄤˇ") + XCTAssertEqual(c.cS2RC("vxtk"), "ㄍㄨㄤˋ") + XCTAssertEqual(c.cS2RC("vxl"), "ㄍㄨㄥ") + XCTAssertEqual(c.cS2RC("vxlf"), "ㄍㄨㄥˊ") + XCTAssertEqual(c.cS2RC("vxlj"), "ㄍㄨㄥˇ") + XCTAssertEqual(c.cS2RC("vxlk"), "ㄍㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ka"), "ㄎㄚ") + XCTAssertEqual(c.cS2RC("kaj"), "ㄎㄚˇ") + XCTAssertEqual(c.cS2RC("kak"), "ㄎㄚˋ") + XCTAssertEqual(c.cS2RC("kr"), "ㄎㄜ") + XCTAssertEqual(c.cS2RC("krf"), "ㄎㄜˊ") + XCTAssertEqual(c.cS2RC("krj"), "ㄎㄜˇ") + XCTAssertEqual(c.cS2RC("krk"), "ㄎㄜˋ") + XCTAssertEqual(c.cS2RC("ki"), "ㄎㄞ") + XCTAssertEqual(c.cS2RC("kij"), "ㄎㄞˇ") + XCTAssertEqual(c.cS2RC("kik"), "ㄎㄞˋ") + XCTAssertEqual(c.cS2RC("kz"), "ㄎㄠ") + XCTAssertEqual(c.cS2RC("kzj"), "ㄎㄠˇ") + XCTAssertEqual(c.cS2RC("kzk"), "ㄎㄠˋ") + XCTAssertEqual(c.cS2RC("kp"), "ㄎㄡ") + XCTAssertEqual(c.cS2RC("kpj"), "ㄎㄡˇ") + XCTAssertEqual(c.cS2RC("kpk"), "ㄎㄡˋ") + XCTAssertEqual(c.cS2RC("km"), "ㄎㄢ") + XCTAssertEqual(c.cS2RC("kmj"), "ㄎㄢˇ") + XCTAssertEqual(c.cS2RC("kmk"), "ㄎㄢˋ") + XCTAssertEqual(c.cS2RC("kn"), "ㄎㄣ") + XCTAssertEqual(c.cS2RC("knj"), "ㄎㄣˇ") + XCTAssertEqual(c.cS2RC("knk"), "ㄎㄣˋ") + XCTAssertEqual(c.cS2RC("kt"), "ㄎㄤ") + XCTAssertEqual(c.cS2RC("ktf"), "ㄎㄤˊ") + XCTAssertEqual(c.cS2RC("ktj"), "ㄎㄤˇ") + XCTAssertEqual(c.cS2RC("ktk"), "ㄎㄤˋ") + XCTAssertEqual(c.cS2RC("kl"), "ㄎㄥ") + XCTAssertEqual(c.cS2RC("klj"), "ㄎㄥˇ") + XCTAssertEqual(c.cS2RC("kx"), "ㄎㄨ") + XCTAssertEqual(c.cS2RC("kxf"), "ㄎㄨˊ") + XCTAssertEqual(c.cS2RC("kxj"), "ㄎㄨˇ") + XCTAssertEqual(c.cS2RC("kxk"), "ㄎㄨˋ") + XCTAssertEqual(c.cS2RC("kxa"), "ㄎㄨㄚ") + XCTAssertEqual(c.cS2RC("kxaj"), "ㄎㄨㄚˇ") + XCTAssertEqual(c.cS2RC("kxak"), "ㄎㄨㄚˋ") + XCTAssertEqual(c.cS2RC("kxok"), "ㄎㄨㄛˋ") + XCTAssertEqual(c.cS2RC("kxi"), "ㄎㄨㄞ") + XCTAssertEqual(c.cS2RC("kxij"), "ㄎㄨㄞˇ") + XCTAssertEqual(c.cS2RC("kxik"), "ㄎㄨㄞˋ") + XCTAssertEqual(c.cS2RC("kxq"), "ㄎㄨㄟ") + XCTAssertEqual(c.cS2RC("kxqf"), "ㄎㄨㄟˊ") + XCTAssertEqual(c.cS2RC("kxqj"), "ㄎㄨㄟˇ") + XCTAssertEqual(c.cS2RC("kxqk"), "ㄎㄨㄟˋ") + XCTAssertEqual(c.cS2RC("kxm"), "ㄎㄨㄢ") + XCTAssertEqual(c.cS2RC("kxmj"), "ㄎㄨㄢˇ") + XCTAssertEqual(c.cS2RC("kxmk"), "ㄎㄨㄢˋ") + XCTAssertEqual(c.cS2RC("kxn"), "ㄎㄨㄣ") + XCTAssertEqual(c.cS2RC("kxnj"), "ㄎㄨㄣˇ") + XCTAssertEqual(c.cS2RC("kxnk"), "ㄎㄨㄣˋ") + XCTAssertEqual(c.cS2RC("kxt"), "ㄎㄨㄤ") + XCTAssertEqual(c.cS2RC("kxtf"), "ㄎㄨㄤˊ") + XCTAssertEqual(c.cS2RC("kxtj"), "ㄎㄨㄤˇ") + XCTAssertEqual(c.cS2RC("kxtk"), "ㄎㄨㄤˋ") + XCTAssertEqual(c.cS2RC("kxl"), "ㄎㄨㄥ") + XCTAssertEqual(c.cS2RC("kxlj"), "ㄎㄨㄥˇ") + XCTAssertEqual(c.cS2RC("kxlk"), "ㄎㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ha"), "ㄏㄚ") + XCTAssertEqual(c.cS2RC("haf"), "ㄏㄚˊ") + XCTAssertEqual(c.cS2RC("haj"), "ㄏㄚˇ") + XCTAssertEqual(c.cS2RC("hr"), "ㄏㄜ") + XCTAssertEqual(c.cS2RC("hrf"), "ㄏㄜˊ") + XCTAssertEqual(c.cS2RC("hrj"), "ㄏㄜˇ") + XCTAssertEqual(c.cS2RC("hrk"), "ㄏㄜˋ") + XCTAssertEqual(c.cS2RC("hi"), "ㄏㄞ") + XCTAssertEqual(c.cS2RC("hif"), "ㄏㄞˊ") + XCTAssertEqual(c.cS2RC("hij"), "ㄏㄞˇ") + XCTAssertEqual(c.cS2RC("hik"), "ㄏㄞˋ") + XCTAssertEqual(c.cS2RC("hq"), "ㄏㄟ") + XCTAssertEqual(c.cS2RC("hqj"), "ㄏㄟˇ") + XCTAssertEqual(c.cS2RC("hz"), "ㄏㄠ") + XCTAssertEqual(c.cS2RC("hzf"), "ㄏㄠˊ") + XCTAssertEqual(c.cS2RC("hzj"), "ㄏㄠˇ") + XCTAssertEqual(c.cS2RC("hzk"), "ㄏㄠˋ") + XCTAssertEqual(c.cS2RC("hp"), "ㄏㄡ") + XCTAssertEqual(c.cS2RC("hpf"), "ㄏㄡˊ") + XCTAssertEqual(c.cS2RC("hpj"), "ㄏㄡˇ") + XCTAssertEqual(c.cS2RC("hpk"), "ㄏㄡˋ") + XCTAssertEqual(c.cS2RC("hm"), "ㄏㄢ") + XCTAssertEqual(c.cS2RC("hmf"), "ㄏㄢˊ") + XCTAssertEqual(c.cS2RC("hmj"), "ㄏㄢˇ") + XCTAssertEqual(c.cS2RC("hmk"), "ㄏㄢˋ") + XCTAssertEqual(c.cS2RC("hn"), "ㄏㄣ") + XCTAssertEqual(c.cS2RC("hnf"), "ㄏㄣˊ") + XCTAssertEqual(c.cS2RC("hnj"), "ㄏㄣˇ") + XCTAssertEqual(c.cS2RC("hnk"), "ㄏㄣˋ") + XCTAssertEqual(c.cS2RC("ht"), "ㄏㄤ") + XCTAssertEqual(c.cS2RC("htf"), "ㄏㄤˊ") + XCTAssertEqual(c.cS2RC("htj"), "ㄏㄤˇ") + XCTAssertEqual(c.cS2RC("htk"), "ㄏㄤˋ") + XCTAssertEqual(c.cS2RC("hl"), "ㄏㄥ") + XCTAssertEqual(c.cS2RC("hlf"), "ㄏㄥˊ") + XCTAssertEqual(c.cS2RC("hlk"), "ㄏㄥˋ") + XCTAssertEqual(c.cS2RC("hx"), "ㄏㄨ") + XCTAssertEqual(c.cS2RC("hxf"), "ㄏㄨˊ") + XCTAssertEqual(c.cS2RC("hxj"), "ㄏㄨˇ") + XCTAssertEqual(c.cS2RC("hxk"), "ㄏㄨˋ") + XCTAssertEqual(c.cS2RC("hxa"), "ㄏㄨㄚ") + XCTAssertEqual(c.cS2RC("hxaf"), "ㄏㄨㄚˊ") + XCTAssertEqual(c.cS2RC("hxaj"), "ㄏㄨㄚˇ") + XCTAssertEqual(c.cS2RC("hxak"), "ㄏㄨㄚˋ") + XCTAssertEqual(c.cS2RC("hxo"), "ㄏㄨㄛ") + XCTAssertEqual(c.cS2RC("hxof"), "ㄏㄨㄛˊ") + XCTAssertEqual(c.cS2RC("hxoj"), "ㄏㄨㄛˇ") + XCTAssertEqual(c.cS2RC("hxok"), "ㄏㄨㄛˋ") + XCTAssertEqual(c.cS2RC("hxod"), "ㄏㄨㄛ˙") + XCTAssertEqual(c.cS2RC("hxif"), "ㄏㄨㄞˊ") + XCTAssertEqual(c.cS2RC("hxik"), "ㄏㄨㄞˋ") + XCTAssertEqual(c.cS2RC("hxq"), "ㄏㄨㄟ") + XCTAssertEqual(c.cS2RC("hxqf"), "ㄏㄨㄟˊ") + XCTAssertEqual(c.cS2RC("hxqj"), "ㄏㄨㄟˇ") + XCTAssertEqual(c.cS2RC("hxqk"), "ㄏㄨㄟˋ") + XCTAssertEqual(c.cS2RC("hxm"), "ㄏㄨㄢ") + XCTAssertEqual(c.cS2RC("hxmf"), "ㄏㄨㄢˊ") + XCTAssertEqual(c.cS2RC("hxmj"), "ㄏㄨㄢˇ") + XCTAssertEqual(c.cS2RC("hxmk"), "ㄏㄨㄢˋ") + XCTAssertEqual(c.cS2RC("hxn"), "ㄏㄨㄣ") + XCTAssertEqual(c.cS2RC("hxnf"), "ㄏㄨㄣˊ") + XCTAssertEqual(c.cS2RC("hxnj"), "ㄏㄨㄣˇ") + XCTAssertEqual(c.cS2RC("hxnk"), "ㄏㄨㄣˋ") + XCTAssertEqual(c.cS2RC("hxt"), "ㄏㄨㄤ") + XCTAssertEqual(c.cS2RC("hxtf"), "ㄏㄨㄤˊ") + XCTAssertEqual(c.cS2RC("hxtj"), "ㄏㄨㄤˇ") + XCTAssertEqual(c.cS2RC("hxtk"), "ㄏㄨㄤˋ") + XCTAssertEqual(c.cS2RC("hxtd"), "ㄏㄨㄤ˙") + XCTAssertEqual(c.cS2RC("hxl"), "ㄏㄨㄥ") + XCTAssertEqual(c.cS2RC("hxlf"), "ㄏㄨㄥˊ") + XCTAssertEqual(c.cS2RC("hxlj"), "ㄏㄨㄥˇ") + XCTAssertEqual(c.cS2RC("hxlk"), "ㄏㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ge"), "ㄐㄧ") + XCTAssertEqual(c.cS2RC("gef"), "ㄐㄧˊ") + XCTAssertEqual(c.cS2RC("gej"), "ㄐㄧˇ") + XCTAssertEqual(c.cS2RC("gek"), "ㄐㄧˋ") + XCTAssertEqual(c.cS2RC("gea"), "ㄐㄧㄚ") + XCTAssertEqual(c.cS2RC("geaf"), "ㄐㄧㄚˊ") + XCTAssertEqual(c.cS2RC("geaj"), "ㄐㄧㄚˇ") + XCTAssertEqual(c.cS2RC("geak"), "ㄐㄧㄚˋ") + XCTAssertEqual(c.cS2RC("gew"), "ㄐㄧㄝ") + XCTAssertEqual(c.cS2RC("gewf"), "ㄐㄧㄝˊ") + XCTAssertEqual(c.cS2RC("gewj"), "ㄐㄧㄝˇ") + XCTAssertEqual(c.cS2RC("gewk"), "ㄐㄧㄝˋ") + XCTAssertEqual(c.cS2RC("gewd"), "ㄐㄧㄝ˙") + XCTAssertEqual(c.cS2RC("gez"), "ㄐㄧㄠ") + XCTAssertEqual(c.cS2RC("gezf"), "ㄐㄧㄠˊ") + XCTAssertEqual(c.cS2RC("gezj"), "ㄐㄧㄠˇ") + XCTAssertEqual(c.cS2RC("gezk"), "ㄐㄧㄠˋ") + XCTAssertEqual(c.cS2RC("gep"), "ㄐㄧㄡ") + XCTAssertEqual(c.cS2RC("gepj"), "ㄐㄧㄡˇ") + XCTAssertEqual(c.cS2RC("gepk"), "ㄐㄧㄡˋ") + XCTAssertEqual(c.cS2RC("gem"), "ㄐㄧㄢ") + XCTAssertEqual(c.cS2RC("gemj"), "ㄐㄧㄢˇ") + XCTAssertEqual(c.cS2RC("gemk"), "ㄐㄧㄢˋ") + XCTAssertEqual(c.cS2RC("gen"), "ㄐㄧㄣ") + XCTAssertEqual(c.cS2RC("genj"), "ㄐㄧㄣˇ") + XCTAssertEqual(c.cS2RC("genk"), "ㄐㄧㄣˋ") + XCTAssertEqual(c.cS2RC("get"), "ㄐㄧㄤ") + XCTAssertEqual(c.cS2RC("getf"), "ㄐㄧㄤˊ") + XCTAssertEqual(c.cS2RC("getj"), "ㄐㄧㄤˇ") + XCTAssertEqual(c.cS2RC("getk"), "ㄐㄧㄤˋ") + XCTAssertEqual(c.cS2RC("gel"), "ㄐㄧㄥ") + XCTAssertEqual(c.cS2RC("gelj"), "ㄐㄧㄥˇ") + XCTAssertEqual(c.cS2RC("gelk"), "ㄐㄧㄥˋ") + XCTAssertEqual(c.cS2RC("gu"), "ㄐㄩ") + XCTAssertEqual(c.cS2RC("guf"), "ㄐㄩˊ") + XCTAssertEqual(c.cS2RC("guj"), "ㄐㄩˇ") + XCTAssertEqual(c.cS2RC("guk"), "ㄐㄩˋ") + XCTAssertEqual(c.cS2RC("guw"), "ㄐㄩㄝ") + XCTAssertEqual(c.cS2RC("guwf"), "ㄐㄩㄝˊ") + XCTAssertEqual(c.cS2RC("guwj"), "ㄐㄩㄝˇ") + XCTAssertEqual(c.cS2RC("guwk"), "ㄐㄩㄝˋ") + XCTAssertEqual(c.cS2RC("gum"), "ㄐㄩㄢ") + XCTAssertEqual(c.cS2RC("gumj"), "ㄐㄩㄢˇ") + XCTAssertEqual(c.cS2RC("gumk"), "ㄐㄩㄢˋ") + XCTAssertEqual(c.cS2RC("gun"), "ㄐㄩㄣ") + XCTAssertEqual(c.cS2RC("gunf"), "ㄐㄩㄣˊ") + XCTAssertEqual(c.cS2RC("gunj"), "ㄐㄩㄣˇ") + XCTAssertEqual(c.cS2RC("gunk"), "ㄐㄩㄣˋ") + XCTAssertEqual(c.cS2RC("gul"), "ㄐㄩㄥ") + XCTAssertEqual(c.cS2RC("gulj"), "ㄐㄩㄥˇ") + XCTAssertEqual(c.cS2RC("gulk"), "ㄐㄩㄥˋ") + XCTAssertEqual(c.cS2RC("vd"), "ㄑ˙") + XCTAssertEqual(c.cS2RC("ve"), "ㄑㄧ") + XCTAssertEqual(c.cS2RC("vef"), "ㄑㄧˊ") + XCTAssertEqual(c.cS2RC("vej"), "ㄑㄧˇ") + XCTAssertEqual(c.cS2RC("vek"), "ㄑㄧˋ") + XCTAssertEqual(c.cS2RC("vea"), "ㄑㄧㄚ") + XCTAssertEqual(c.cS2RC("veaf"), "ㄑㄧㄚˊ") + XCTAssertEqual(c.cS2RC("veaj"), "ㄑㄧㄚˇ") + XCTAssertEqual(c.cS2RC("veak"), "ㄑㄧㄚˋ") + XCTAssertEqual(c.cS2RC("vew"), "ㄑㄧㄝ") + XCTAssertEqual(c.cS2RC("vewf"), "ㄑㄧㄝˊ") + XCTAssertEqual(c.cS2RC("vewj"), "ㄑㄧㄝˇ") + XCTAssertEqual(c.cS2RC("vewk"), "ㄑㄧㄝˋ") + XCTAssertEqual(c.cS2RC("vez"), "ㄑㄧㄠ") + XCTAssertEqual(c.cS2RC("vezf"), "ㄑㄧㄠˊ") + XCTAssertEqual(c.cS2RC("vezj"), "ㄑㄧㄠˇ") + XCTAssertEqual(c.cS2RC("vezk"), "ㄑㄧㄠˋ") + XCTAssertEqual(c.cS2RC("vep"), "ㄑㄧㄡ") + XCTAssertEqual(c.cS2RC("vepf"), "ㄑㄧㄡˊ") + XCTAssertEqual(c.cS2RC("vepj"), "ㄑㄧㄡˇ") + XCTAssertEqual(c.cS2RC("vepk"), "ㄑㄧㄡˋ") + XCTAssertEqual(c.cS2RC("vem"), "ㄑㄧㄢ") + XCTAssertEqual(c.cS2RC("vemf"), "ㄑㄧㄢˊ") + XCTAssertEqual(c.cS2RC("vemj"), "ㄑㄧㄢˇ") + XCTAssertEqual(c.cS2RC("vemk"), "ㄑㄧㄢˋ") + XCTAssertEqual(c.cS2RC("ven"), "ㄑㄧㄣ") + XCTAssertEqual(c.cS2RC("venf"), "ㄑㄧㄣˊ") + XCTAssertEqual(c.cS2RC("venj"), "ㄑㄧㄣˇ") + XCTAssertEqual(c.cS2RC("venk"), "ㄑㄧㄣˋ") + XCTAssertEqual(c.cS2RC("vet"), "ㄑㄧㄤ") + XCTAssertEqual(c.cS2RC("vetf"), "ㄑㄧㄤˊ") + XCTAssertEqual(c.cS2RC("vetj"), "ㄑㄧㄤˇ") + XCTAssertEqual(c.cS2RC("vetk"), "ㄑㄧㄤˋ") + XCTAssertEqual(c.cS2RC("vel"), "ㄑㄧㄥ") + XCTAssertEqual(c.cS2RC("velf"), "ㄑㄧㄥˊ") + XCTAssertEqual(c.cS2RC("velj"), "ㄑㄧㄥˇ") + XCTAssertEqual(c.cS2RC("velk"), "ㄑㄧㄥˋ") + XCTAssertEqual(c.cS2RC("vu"), "ㄑㄩ") + XCTAssertEqual(c.cS2RC("vuf"), "ㄑㄩˊ") + XCTAssertEqual(c.cS2RC("vuj"), "ㄑㄩˇ") + XCTAssertEqual(c.cS2RC("vuk"), "ㄑㄩˋ") + XCTAssertEqual(c.cS2RC("vuw"), "ㄑㄩㄝ") + XCTAssertEqual(c.cS2RC("vuwf"), "ㄑㄩㄝˊ") + XCTAssertEqual(c.cS2RC("vuwk"), "ㄑㄩㄝˋ") + XCTAssertEqual(c.cS2RC("vum"), "ㄑㄩㄢ") + XCTAssertEqual(c.cS2RC("vumf"), "ㄑㄩㄢˊ") + XCTAssertEqual(c.cS2RC("vumj"), "ㄑㄩㄢˇ") + XCTAssertEqual(c.cS2RC("vumk"), "ㄑㄩㄢˋ") + XCTAssertEqual(c.cS2RC("vun"), "ㄑㄩㄣ") + XCTAssertEqual(c.cS2RC("vunf"), "ㄑㄩㄣˊ") + XCTAssertEqual(c.cS2RC("vunj"), "ㄑㄩㄣˇ") + XCTAssertEqual(c.cS2RC("vunk"), "ㄑㄩㄣˋ") + XCTAssertEqual(c.cS2RC("vul"), "ㄑㄩㄥ") + XCTAssertEqual(c.cS2RC("vulf"), "ㄑㄩㄥˊ") + XCTAssertEqual(c.cS2RC("vulj"), "ㄑㄩㄥˇ") + XCTAssertEqual(c.cS2RC("vulk"), "ㄑㄩㄥˋ") + XCTAssertEqual(c.cS2RC("ce"), "ㄒㄧ") + XCTAssertEqual(c.cS2RC("cef"), "ㄒㄧˊ") + XCTAssertEqual(c.cS2RC("cej"), "ㄒㄧˇ") + XCTAssertEqual(c.cS2RC("cek"), "ㄒㄧˋ") + XCTAssertEqual(c.cS2RC("cea"), "ㄒㄧㄚ") + XCTAssertEqual(c.cS2RC("ceaf"), "ㄒㄧㄚˊ") + XCTAssertEqual(c.cS2RC("ceaj"), "ㄒㄧㄚˇ") + XCTAssertEqual(c.cS2RC("ceak"), "ㄒㄧㄚˋ") + XCTAssertEqual(c.cS2RC("cew"), "ㄒㄧㄝ") + XCTAssertEqual(c.cS2RC("cewf"), "ㄒㄧㄝˊ") + XCTAssertEqual(c.cS2RC("cewj"), "ㄒㄧㄝˇ") + XCTAssertEqual(c.cS2RC("cewk"), "ㄒㄧㄝˋ") + XCTAssertEqual(c.cS2RC("cez"), "ㄒㄧㄠ") + XCTAssertEqual(c.cS2RC("cezf"), "ㄒㄧㄠˊ") + XCTAssertEqual(c.cS2RC("cezj"), "ㄒㄧㄠˇ") + XCTAssertEqual(c.cS2RC("cezk"), "ㄒㄧㄠˋ") + XCTAssertEqual(c.cS2RC("cep"), "ㄒㄧㄡ") + XCTAssertEqual(c.cS2RC("cepf"), "ㄒㄧㄡˊ") + XCTAssertEqual(c.cS2RC("cepj"), "ㄒㄧㄡˇ") + XCTAssertEqual(c.cS2RC("cepk"), "ㄒㄧㄡˋ") + XCTAssertEqual(c.cS2RC("cem"), "ㄒㄧㄢ") + XCTAssertEqual(c.cS2RC("cemf"), "ㄒㄧㄢˊ") + XCTAssertEqual(c.cS2RC("cemj"), "ㄒㄧㄢˇ") + XCTAssertEqual(c.cS2RC("cemk"), "ㄒㄧㄢˋ") + XCTAssertEqual(c.cS2RC("cen"), "ㄒㄧㄣ") + XCTAssertEqual(c.cS2RC("cenf"), "ㄒㄧㄣˊ") + XCTAssertEqual(c.cS2RC("cenj"), "ㄒㄧㄣˇ") + XCTAssertEqual(c.cS2RC("cenk"), "ㄒㄧㄣˋ") + XCTAssertEqual(c.cS2RC("cet"), "ㄒㄧㄤ") + XCTAssertEqual(c.cS2RC("cetf"), "ㄒㄧㄤˊ") + XCTAssertEqual(c.cS2RC("cetj"), "ㄒㄧㄤˇ") + XCTAssertEqual(c.cS2RC("cetk"), "ㄒㄧㄤˋ") + XCTAssertEqual(c.cS2RC("cel"), "ㄒㄧㄥ") + XCTAssertEqual(c.cS2RC("celf"), "ㄒㄧㄥˊ") + XCTAssertEqual(c.cS2RC("celj"), "ㄒㄧㄥˇ") + XCTAssertEqual(c.cS2RC("celk"), "ㄒㄧㄥˋ") + XCTAssertEqual(c.cS2RC("cu"), "ㄒㄩ") + XCTAssertEqual(c.cS2RC("cuf"), "ㄒㄩˊ") + XCTAssertEqual(c.cS2RC("cuj"), "ㄒㄩˇ") + XCTAssertEqual(c.cS2RC("cuk"), "ㄒㄩˋ") + XCTAssertEqual(c.cS2RC("cuw"), "ㄒㄩㄝ") + XCTAssertEqual(c.cS2RC("cuwf"), "ㄒㄩㄝˊ") + XCTAssertEqual(c.cS2RC("cuwj"), "ㄒㄩㄝˇ") + XCTAssertEqual(c.cS2RC("cuwk"), "ㄒㄩㄝˋ") + XCTAssertEqual(c.cS2RC("cum"), "ㄒㄩㄢ") + XCTAssertEqual(c.cS2RC("cumf"), "ㄒㄩㄢˊ") + XCTAssertEqual(c.cS2RC("cumj"), "ㄒㄩㄢˇ") + XCTAssertEqual(c.cS2RC("cumk"), "ㄒㄩㄢˋ") + XCTAssertEqual(c.cS2RC("cun"), "ㄒㄩㄣ") + XCTAssertEqual(c.cS2RC("cunf"), "ㄒㄩㄣˊ") + XCTAssertEqual(c.cS2RC("cunk"), "ㄒㄩㄣˋ") + XCTAssertEqual(c.cS2RC("cul"), "ㄒㄩㄥ") + XCTAssertEqual(c.cS2RC("culf"), "ㄒㄩㄥˊ") + XCTAssertEqual(c.cS2RC("culj"), "ㄒㄩㄥˇ") + XCTAssertEqual(c.cS2RC("culk"), "ㄒㄩㄥˋ") + XCTAssertEqual(c.cS2RC("g"), "ㄓ") + XCTAssertEqual(c.cS2RC("gf"), "ㄓˊ") + XCTAssertEqual(c.cS2RC("gj"), "ㄓˇ") + XCTAssertEqual(c.cS2RC("gk"), "ㄓˋ") + XCTAssertEqual(c.cS2RC("ga"), "ㄓㄚ") + XCTAssertEqual(c.cS2RC("gaf"), "ㄓㄚˊ") + XCTAssertEqual(c.cS2RC("gaj"), "ㄓㄚˇ") + XCTAssertEqual(c.cS2RC("gak"), "ㄓㄚˋ") + XCTAssertEqual(c.cS2RC("gr"), "ㄓㄜ") + XCTAssertEqual(c.cS2RC("grf"), "ㄓㄜˊ") + XCTAssertEqual(c.cS2RC("grj"), "ㄓㄜˇ") + XCTAssertEqual(c.cS2RC("grk"), "ㄓㄜˋ") + XCTAssertEqual(c.cS2RC("grd"), "ㄓㄜ˙") + XCTAssertEqual(c.cS2RC("gi"), "ㄓㄞ") + XCTAssertEqual(c.cS2RC("gif"), "ㄓㄞˊ") + XCTAssertEqual(c.cS2RC("gij"), "ㄓㄞˇ") + XCTAssertEqual(c.cS2RC("gik"), "ㄓㄞˋ") + XCTAssertEqual(c.cS2RC("gqk"), "ㄓㄟˋ") + XCTAssertEqual(c.cS2RC("gz"), "ㄓㄠ") + XCTAssertEqual(c.cS2RC("gzf"), "ㄓㄠˊ") + XCTAssertEqual(c.cS2RC("gzj"), "ㄓㄠˇ") + XCTAssertEqual(c.cS2RC("gzk"), "ㄓㄠˋ") + XCTAssertEqual(c.cS2RC("gp"), "ㄓㄡ") + XCTAssertEqual(c.cS2RC("gpf"), "ㄓㄡˊ") + XCTAssertEqual(c.cS2RC("gpj"), "ㄓㄡˇ") + XCTAssertEqual(c.cS2RC("gpk"), "ㄓㄡˋ") + XCTAssertEqual(c.cS2RC("gm"), "ㄓㄢ") + XCTAssertEqual(c.cS2RC("gmj"), "ㄓㄢˇ") + XCTAssertEqual(c.cS2RC("gmk"), "ㄓㄢˋ") + XCTAssertEqual(c.cS2RC("gn"), "ㄓㄣ") + XCTAssertEqual(c.cS2RC("gnf"), "ㄓㄣˊ") + XCTAssertEqual(c.cS2RC("gnj"), "ㄓㄣˇ") + XCTAssertEqual(c.cS2RC("gnk"), "ㄓㄣˋ") + XCTAssertEqual(c.cS2RC("gt"), "ㄓㄤ") + XCTAssertEqual(c.cS2RC("gtj"), "ㄓㄤˇ") + XCTAssertEqual(c.cS2RC("gtk"), "ㄓㄤˋ") + XCTAssertEqual(c.cS2RC("gl"), "ㄓㄥ") + XCTAssertEqual(c.cS2RC("glj"), "ㄓㄥˇ") + XCTAssertEqual(c.cS2RC("glk"), "ㄓㄥˋ") + XCTAssertEqual(c.cS2RC("gx"), "ㄓㄨ") + XCTAssertEqual(c.cS2RC("gxf"), "ㄓㄨˊ") + XCTAssertEqual(c.cS2RC("gxj"), "ㄓㄨˇ") + XCTAssertEqual(c.cS2RC("gxk"), "ㄓㄨˋ") + XCTAssertEqual(c.cS2RC("gxa"), "ㄓㄨㄚ") + XCTAssertEqual(c.cS2RC("gxaj"), "ㄓㄨㄚˇ") + XCTAssertEqual(c.cS2RC("gxo"), "ㄓㄨㄛ") + XCTAssertEqual(c.cS2RC("gxof"), "ㄓㄨㄛˊ") + XCTAssertEqual(c.cS2RC("gxok"), "ㄓㄨㄛˋ") + XCTAssertEqual(c.cS2RC("gxi"), "ㄓㄨㄞ") } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_C.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_C.swift index 5da4b127..4c9b92c5 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_C.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_C.swift @@ -12,510 +12,510 @@ import XCTest extension TekkonTestsKeyboardArrangments { func testETen26KeysC() throws { - var composer = Tekkon.Composer(arrange: .ofETen26) - XCTAssertEqual(composer.convertSequenceToRawComposition("gxij"), "ㄓㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxik"), "ㄓㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxq"), "ㄓㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxqj"), "ㄓㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxqk"), "ㄓㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxm"), "ㄓㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxmj"), "ㄓㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxmk"), "ㄓㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxn"), "ㄓㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxnj"), "ㄓㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxnk"), "ㄓㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxt"), "ㄓㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxtj"), "ㄓㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxtk"), "ㄓㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxl"), "ㄓㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxlj"), "ㄓㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxlk"), "ㄓㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("y"), "ㄔ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yf"), "ㄔˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yj"), "ㄔˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yk"), "ㄔˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ya"), "ㄔㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yaf"), "ㄔㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yaj"), "ㄔㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yak"), "ㄔㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yr"), "ㄔㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yrj"), "ㄔㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yrk"), "ㄔㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yi"), "ㄔㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yif"), "ㄔㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yij"), "ㄔㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yik"), "ㄔㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yz"), "ㄔㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yzf"), "ㄔㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yzj"), "ㄔㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yzk"), "ㄔㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yp"), "ㄔㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ypf"), "ㄔㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ypj"), "ㄔㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ypk"), "ㄔㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ym"), "ㄔㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ymf"), "ㄔㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ymj"), "ㄔㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ymk"), "ㄔㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yn"), "ㄔㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ynf"), "ㄔㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ynj"), "ㄔㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ynk"), "ㄔㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ynd"), "ㄔㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("yt"), "ㄔㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ytf"), "ㄔㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ytj"), "ㄔㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ytk"), "ㄔㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yl"), "ㄔㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ylf"), "ㄔㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ylj"), "ㄔㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ylk"), "ㄔㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yx"), "ㄔㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxf"), "ㄔㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxj"), "ㄔㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxk"), "ㄔㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxa"), "ㄔㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxaj"), "ㄔㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxak"), "ㄔㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxo"), "ㄔㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxok"), "ㄔㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxi"), "ㄔㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxif"), "ㄔㄨㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxij"), "ㄔㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxik"), "ㄔㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxq"), "ㄔㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxqf"), "ㄔㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxqj"), "ㄔㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxqk"), "ㄔㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxm"), "ㄔㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxmf"), "ㄔㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxmj"), "ㄔㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxmk"), "ㄔㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxn"), "ㄔㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxnf"), "ㄔㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxnj"), "ㄔㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxt"), "ㄔㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxtf"), "ㄔㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxtj"), "ㄔㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxtk"), "ㄔㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxl"), "ㄔㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxlf"), "ㄔㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxlj"), "ㄔㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yxlk"), "ㄔㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("c"), "ㄕ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cf"), "ㄕˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cj"), "ㄕˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ck"), "ㄕˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cd"), "ㄕ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ca"), "ㄕㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("caf"), "ㄕㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("caj"), "ㄕㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cak"), "ㄕㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cad"), "ㄕㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("cr"), "ㄕㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("crf"), "ㄕㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("crj"), "ㄕㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("crk"), "ㄕㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ci"), "ㄕㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cij"), "ㄕㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cik"), "ㄕㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cqf"), "ㄕㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cz"), "ㄕㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("czf"), "ㄕㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("czj"), "ㄕㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("czk"), "ㄕㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cp"), "ㄕㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cpf"), "ㄕㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cpj"), "ㄕㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cpk"), "ㄕㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cm"), "ㄕㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cmf"), "ㄕㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cmj"), "ㄕㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cmk"), "ㄕㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cn"), "ㄕㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cnf"), "ㄕㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cnj"), "ㄕㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cnk"), "ㄕㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ct"), "ㄕㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ctj"), "ㄕㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ctk"), "ㄕㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ctd"), "ㄕㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("cl"), "ㄕㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("clf"), "ㄕㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("clj"), "ㄕㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("clk"), "ㄕㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cx"), "ㄕㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxf"), "ㄕㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxj"), "ㄕㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxk"), "ㄕㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxa"), "ㄕㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxaj"), "ㄕㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxak"), "ㄕㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxo"), "ㄕㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxok"), "ㄕㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxi"), "ㄕㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxij"), "ㄕㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxik"), "ㄕㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxq"), "ㄕㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxqf"), "ㄕㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxqj"), "ㄕㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxqk"), "ㄕㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxm"), "ㄕㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxmk"), "ㄕㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxnj"), "ㄕㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxnk"), "ㄕㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxt"), "ㄕㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxtf"), "ㄕㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxtj"), "ㄕㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxtk"), "ㄕㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jk"), "ㄖˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jrj"), "ㄖㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jrk"), "ㄖㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jzf"), "ㄖㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jzj"), "ㄖㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jzk"), "ㄖㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jpf"), "ㄖㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jpj"), "ㄖㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jpk"), "ㄖㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jmf"), "ㄖㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jmj"), "ㄖㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jmk"), "ㄖㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jnf"), "ㄖㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jnj"), "ㄖㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jnk"), "ㄖㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jt"), "ㄖㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jtf"), "ㄖㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jtj"), "ㄖㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jtk"), "ㄖㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jl"), "ㄖㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jlf"), "ㄖㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jlj"), "ㄖㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jlk"), "ㄖㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxf"), "ㄖㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxj"), "ㄖㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxk"), "ㄖㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxof"), "ㄖㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxok"), "ㄖㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxqf"), "ㄖㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxqj"), "ㄖㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxqk"), "ㄖㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxmf"), "ㄖㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxmj"), "ㄖㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxmk"), "ㄖㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxnf"), "ㄖㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxnj"), "ㄖㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxnk"), "ㄖㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxlf"), "ㄖㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxlj"), "ㄖㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxlk"), "ㄖㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("q"), "ㄗ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qf"), "ㄗˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qj"), "ㄗˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qk"), "ㄗˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qd"), "ㄗ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("qa"), "ㄗㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qaf"), "ㄗㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qaj"), "ㄗㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qrf"), "ㄗㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qrj"), "ㄗㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qrk"), "ㄗㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qi"), "ㄗㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qij"), "ㄗㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qik"), "ㄗㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qqf"), "ㄗㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qz"), "ㄗㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qzf"), "ㄗㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qzj"), "ㄗㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qzk"), "ㄗㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qp"), "ㄗㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qpj"), "ㄗㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qpk"), "ㄗㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qm"), "ㄗㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qmf"), "ㄗㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qmj"), "ㄗㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qmk"), "ㄗㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qn"), "ㄗㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qnj"), "ㄗㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qnk"), "ㄗㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qt"), "ㄗㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qtj"), "ㄗㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qtk"), "ㄗㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ql"), "ㄗㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qlj"), "ㄗㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qlk"), "ㄗㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qx"), "ㄗㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxf"), "ㄗㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxj"), "ㄗㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxk"), "ㄗㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxo"), "ㄗㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxof"), "ㄗㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxoj"), "ㄗㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxok"), "ㄗㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxod"), "ㄗㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxq"), "ㄗㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxqj"), "ㄗㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxqk"), "ㄗㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxm"), "ㄗㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxmj"), "ㄗㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxmk"), "ㄗㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxn"), "ㄗㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxnj"), "ㄗㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxnk"), "ㄗㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxl"), "ㄗㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxlj"), "ㄗㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qxlk"), "ㄗㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("w"), "ㄘ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wf"), "ㄘˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wj"), "ㄘˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wk"), "ㄘˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wa"), "ㄘㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("waj"), "ㄘㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wak"), "ㄘㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wrk"), "ㄘㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wi"), "ㄘㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wif"), "ㄘㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wij"), "ㄘㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wik"), "ㄘㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wz"), "ㄘㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wzf"), "ㄘㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wzj"), "ㄘㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wzk"), "ㄘㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wp"), "ㄘㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wpf"), "ㄘㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wpj"), "ㄘㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wpk"), "ㄘㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wm"), "ㄘㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wmf"), "ㄘㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wmj"), "ㄘㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wmk"), "ㄘㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wn"), "ㄘㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wnf"), "ㄘㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wt"), "ㄘㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wtf"), "ㄘㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wtj"), "ㄘㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wtk"), "ㄘㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wl"), "ㄘㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wlf"), "ㄘㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wlj"), "ㄘㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wlk"), "ㄘㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wx"), "ㄘㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxf"), "ㄘㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxj"), "ㄘㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxk"), "ㄘㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxo"), "ㄘㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxof"), "ㄘㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxoj"), "ㄘㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxok"), "ㄘㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxq"), "ㄘㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxqj"), "ㄘㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxqk"), "ㄘㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxm"), "ㄘㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxmf"), "ㄘㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxmj"), "ㄘㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxmk"), "ㄘㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxn"), "ㄘㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxnf"), "ㄘㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxnj"), "ㄘㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxnk"), "ㄘㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxl"), "ㄘㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxlf"), "ㄘㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxlj"), "ㄘㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wxlk"), "ㄘㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("s"), "ㄙ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sj"), "ㄙˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sk"), "ㄙˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sa"), "ㄙㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("saj"), "ㄙㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sak"), "ㄙㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sad"), "ㄙㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("sr"), "ㄙㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("srk"), "ㄙㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("si"), "ㄙㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sif"), "ㄙㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sij"), "ㄙㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sik"), "ㄙㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sq"), "ㄙㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sz"), "ㄙㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("szj"), "ㄙㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("szk"), "ㄙㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sp"), "ㄙㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("spj"), "ㄙㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("spk"), "ㄙㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sm"), "ㄙㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("smj"), "ㄙㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("smk"), "ㄙㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sn"), "ㄙㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("snj"), "ㄙㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("st"), "ㄙㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("stj"), "ㄙㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("stk"), "ㄙㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sl"), "ㄙㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("slk"), "ㄙㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sx"), "ㄙㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxf"), "ㄙㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxj"), "ㄙㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxk"), "ㄙㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxo"), "ㄙㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxof"), "ㄙㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxoj"), "ㄙㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxok"), "ㄙㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxq"), "ㄙㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxqf"), "ㄙㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxqj"), "ㄙㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxqk"), "ㄙㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxm"), "ㄙㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxmj"), "ㄙㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxmk"), "ㄙㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxn"), "ㄙㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxnj"), "ㄙㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxnk"), "ㄙㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxl"), "ㄙㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxlf"), "ㄙㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxlj"), "ㄙㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxlk"), "ㄙㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("a"), "ㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("af"), "ㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ak"), "ㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ad"), "ㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("o"), "ㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("of"), "ㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("oj"), "ㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ok"), "ㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("r"), "ㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rf"), "ㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rj"), "ㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rk"), "ㄜˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("wf"), "ㄝˊ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("wj"), "ㄝˇ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("wk"), "ㄝˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("wd"), "ㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("i"), "ㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("if"), "ㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ij"), "ㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ik"), "ㄞˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("qk"), "ㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("z"), "ㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zf"), "ㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zj"), "ㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zk"), "ㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("p "), "ㄡ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pf"), "ㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pj"), "ㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pk"), "ㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pd"), "ㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("m "), "ㄢ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mf"), "ㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mj"), "ㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mk"), "ㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("n "), "ㄣ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nf"), "ㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nj"), "ㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nk"), "ㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nd"), "ㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("t "), "ㄤ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tf"), "ㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tj"), "ㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tk"), "ㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("l "), "ㄥ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lk"), "ㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("h "), "ㄦ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hf"), "ㄦˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hj"), "ㄦˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hk"), "ㄦˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hd"), "ㄦ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("e"), "ㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ef"), "ㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ej"), "ㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ek"), "ㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ea"), "ㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eaf"), "ㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eaj"), "ㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eak"), "ㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ead"), "ㄧㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("eo"), "ㄧㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eod"), "ㄧㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ew"), "ㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ewf"), "ㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ewj"), "ㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ewk"), "ㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ewd"), "ㄧㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("eif"), "ㄧㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ez"), "ㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ezf"), "ㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ezj"), "ㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ezk"), "ㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ep"), "ㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("epf"), "ㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("epj"), "ㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("epk"), "ㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("em"), "ㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("emf"), "ㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("emj"), "ㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("emk"), "ㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("en"), "ㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("enf"), "ㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("enj"), "ㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("enk"), "ㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("et"), "ㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("etf"), "ㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("etj"), "ㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("etk"), "ㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("el"), "ㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("elf"), "ㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("elj"), "ㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("elk"), "ㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("x"), "ㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xf"), "ㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xj"), "ㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xk"), "ㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xa"), "ㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xaf"), "ㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xaj"), "ㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xak"), "ㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xad"), "ㄨㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("xo"), "ㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xoj"), "ㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xok"), "ㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xi"), "ㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xij"), "ㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xik"), "ㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xq"), "ㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xqf"), "ㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xqj"), "ㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xqk"), "ㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xm"), "ㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmf"), "ㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmj"), "ㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmk"), "ㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xn"), "ㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xnf"), "ㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xnj"), "ㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xnk"), "ㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xt"), "ㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xtf"), "ㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xtj"), "ㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xtk"), "ㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xl"), "ㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xlj"), "ㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xlk"), "ㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("u"), "ㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uf"), "ㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uj"), "ㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uk"), "ㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uw"), "ㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uwj"), "ㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uwk"), "ㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("um"), "ㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("umf"), "ㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("umj"), "ㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("umk"), "ㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("un"), "ㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("unf"), "ㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("unj"), "ㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("unk"), "ㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ul"), "ㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ulf"), "ㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ulj"), "ㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ulk"), "ㄩㄥˋ") + var c = Tekkon.Composer(arrange: .ofETen26) + XCTAssertEqual(c.cS2RC("gxij"), "ㄓㄨㄞˇ") + XCTAssertEqual(c.cS2RC("gxik"), "ㄓㄨㄞˋ") + XCTAssertEqual(c.cS2RC("gxq"), "ㄓㄨㄟ") + XCTAssertEqual(c.cS2RC("gxqj"), "ㄓㄨㄟˇ") + XCTAssertEqual(c.cS2RC("gxqk"), "ㄓㄨㄟˋ") + XCTAssertEqual(c.cS2RC("gxm"), "ㄓㄨㄢ") + XCTAssertEqual(c.cS2RC("gxmj"), "ㄓㄨㄢˇ") + XCTAssertEqual(c.cS2RC("gxmk"), "ㄓㄨㄢˋ") + XCTAssertEqual(c.cS2RC("gxn"), "ㄓㄨㄣ") + XCTAssertEqual(c.cS2RC("gxnj"), "ㄓㄨㄣˇ") + XCTAssertEqual(c.cS2RC("gxnk"), "ㄓㄨㄣˋ") + XCTAssertEqual(c.cS2RC("gxt"), "ㄓㄨㄤ") + XCTAssertEqual(c.cS2RC("gxtj"), "ㄓㄨㄤˇ") + XCTAssertEqual(c.cS2RC("gxtk"), "ㄓㄨㄤˋ") + XCTAssertEqual(c.cS2RC("gxl"), "ㄓㄨㄥ") + XCTAssertEqual(c.cS2RC("gxlj"), "ㄓㄨㄥˇ") + XCTAssertEqual(c.cS2RC("gxlk"), "ㄓㄨㄥˋ") + XCTAssertEqual(c.cS2RC("y"), "ㄔ") + XCTAssertEqual(c.cS2RC("yf"), "ㄔˊ") + XCTAssertEqual(c.cS2RC("yj"), "ㄔˇ") + XCTAssertEqual(c.cS2RC("yk"), "ㄔˋ") + XCTAssertEqual(c.cS2RC("ya"), "ㄔㄚ") + XCTAssertEqual(c.cS2RC("yaf"), "ㄔㄚˊ") + XCTAssertEqual(c.cS2RC("yaj"), "ㄔㄚˇ") + XCTAssertEqual(c.cS2RC("yak"), "ㄔㄚˋ") + XCTAssertEqual(c.cS2RC("yr"), "ㄔㄜ") + XCTAssertEqual(c.cS2RC("yrj"), "ㄔㄜˇ") + XCTAssertEqual(c.cS2RC("yrk"), "ㄔㄜˋ") + XCTAssertEqual(c.cS2RC("yi"), "ㄔㄞ") + XCTAssertEqual(c.cS2RC("yif"), "ㄔㄞˊ") + XCTAssertEqual(c.cS2RC("yij"), "ㄔㄞˇ") + XCTAssertEqual(c.cS2RC("yik"), "ㄔㄞˋ") + XCTAssertEqual(c.cS2RC("yz"), "ㄔㄠ") + XCTAssertEqual(c.cS2RC("yzf"), "ㄔㄠˊ") + XCTAssertEqual(c.cS2RC("yzj"), "ㄔㄠˇ") + XCTAssertEqual(c.cS2RC("yzk"), "ㄔㄠˋ") + XCTAssertEqual(c.cS2RC("yp"), "ㄔㄡ") + XCTAssertEqual(c.cS2RC("ypf"), "ㄔㄡˊ") + XCTAssertEqual(c.cS2RC("ypj"), "ㄔㄡˇ") + XCTAssertEqual(c.cS2RC("ypk"), "ㄔㄡˋ") + XCTAssertEqual(c.cS2RC("ym"), "ㄔㄢ") + XCTAssertEqual(c.cS2RC("ymf"), "ㄔㄢˊ") + XCTAssertEqual(c.cS2RC("ymj"), "ㄔㄢˇ") + XCTAssertEqual(c.cS2RC("ymk"), "ㄔㄢˋ") + XCTAssertEqual(c.cS2RC("yn"), "ㄔㄣ") + XCTAssertEqual(c.cS2RC("ynf"), "ㄔㄣˊ") + XCTAssertEqual(c.cS2RC("ynj"), "ㄔㄣˇ") + XCTAssertEqual(c.cS2RC("ynk"), "ㄔㄣˋ") + XCTAssertEqual(c.cS2RC("ynd"), "ㄔㄣ˙") + XCTAssertEqual(c.cS2RC("yt"), "ㄔㄤ") + XCTAssertEqual(c.cS2RC("ytf"), "ㄔㄤˊ") + XCTAssertEqual(c.cS2RC("ytj"), "ㄔㄤˇ") + XCTAssertEqual(c.cS2RC("ytk"), "ㄔㄤˋ") + XCTAssertEqual(c.cS2RC("yl"), "ㄔㄥ") + XCTAssertEqual(c.cS2RC("ylf"), "ㄔㄥˊ") + XCTAssertEqual(c.cS2RC("ylj"), "ㄔㄥˇ") + XCTAssertEqual(c.cS2RC("ylk"), "ㄔㄥˋ") + XCTAssertEqual(c.cS2RC("yx"), "ㄔㄨ") + XCTAssertEqual(c.cS2RC("yxf"), "ㄔㄨˊ") + XCTAssertEqual(c.cS2RC("yxj"), "ㄔㄨˇ") + XCTAssertEqual(c.cS2RC("yxk"), "ㄔㄨˋ") + XCTAssertEqual(c.cS2RC("yxa"), "ㄔㄨㄚ") + XCTAssertEqual(c.cS2RC("yxaj"), "ㄔㄨㄚˇ") + XCTAssertEqual(c.cS2RC("yxak"), "ㄔㄨㄚˋ") + XCTAssertEqual(c.cS2RC("yxo"), "ㄔㄨㄛ") + XCTAssertEqual(c.cS2RC("yxok"), "ㄔㄨㄛˋ") + XCTAssertEqual(c.cS2RC("yxi"), "ㄔㄨㄞ") + XCTAssertEqual(c.cS2RC("yxif"), "ㄔㄨㄞˊ") + XCTAssertEqual(c.cS2RC("yxij"), "ㄔㄨㄞˇ") + XCTAssertEqual(c.cS2RC("yxik"), "ㄔㄨㄞˋ") + XCTAssertEqual(c.cS2RC("yxq"), "ㄔㄨㄟ") + XCTAssertEqual(c.cS2RC("yxqf"), "ㄔㄨㄟˊ") + XCTAssertEqual(c.cS2RC("yxqj"), "ㄔㄨㄟˇ") + XCTAssertEqual(c.cS2RC("yxqk"), "ㄔㄨㄟˋ") + XCTAssertEqual(c.cS2RC("yxm"), "ㄔㄨㄢ") + XCTAssertEqual(c.cS2RC("yxmf"), "ㄔㄨㄢˊ") + XCTAssertEqual(c.cS2RC("yxmj"), "ㄔㄨㄢˇ") + XCTAssertEqual(c.cS2RC("yxmk"), "ㄔㄨㄢˋ") + XCTAssertEqual(c.cS2RC("yxn"), "ㄔㄨㄣ") + XCTAssertEqual(c.cS2RC("yxnf"), "ㄔㄨㄣˊ") + XCTAssertEqual(c.cS2RC("yxnj"), "ㄔㄨㄣˇ") + XCTAssertEqual(c.cS2RC("yxt"), "ㄔㄨㄤ") + XCTAssertEqual(c.cS2RC("yxtf"), "ㄔㄨㄤˊ") + XCTAssertEqual(c.cS2RC("yxtj"), "ㄔㄨㄤˇ") + XCTAssertEqual(c.cS2RC("yxtk"), "ㄔㄨㄤˋ") + XCTAssertEqual(c.cS2RC("yxl"), "ㄔㄨㄥ") + XCTAssertEqual(c.cS2RC("yxlf"), "ㄔㄨㄥˊ") + XCTAssertEqual(c.cS2RC("yxlj"), "ㄔㄨㄥˇ") + XCTAssertEqual(c.cS2RC("yxlk"), "ㄔㄨㄥˋ") + XCTAssertEqual(c.cS2RC("c"), "ㄕ") + XCTAssertEqual(c.cS2RC("cf"), "ㄕˊ") + XCTAssertEqual(c.cS2RC("cj"), "ㄕˇ") + XCTAssertEqual(c.cS2RC("ck"), "ㄕˋ") + XCTAssertEqual(c.cS2RC("cd"), "ㄕ˙") + XCTAssertEqual(c.cS2RC("ca"), "ㄕㄚ") + XCTAssertEqual(c.cS2RC("caf"), "ㄕㄚˊ") + XCTAssertEqual(c.cS2RC("caj"), "ㄕㄚˇ") + XCTAssertEqual(c.cS2RC("cak"), "ㄕㄚˋ") + XCTAssertEqual(c.cS2RC("cad"), "ㄕㄚ˙") + XCTAssertEqual(c.cS2RC("cr"), "ㄕㄜ") + XCTAssertEqual(c.cS2RC("crf"), "ㄕㄜˊ") + XCTAssertEqual(c.cS2RC("crj"), "ㄕㄜˇ") + XCTAssertEqual(c.cS2RC("crk"), "ㄕㄜˋ") + XCTAssertEqual(c.cS2RC("ci"), "ㄕㄞ") + XCTAssertEqual(c.cS2RC("cij"), "ㄕㄞˇ") + XCTAssertEqual(c.cS2RC("cik"), "ㄕㄞˋ") + XCTAssertEqual(c.cS2RC("cqf"), "ㄕㄟˊ") + XCTAssertEqual(c.cS2RC("cz"), "ㄕㄠ") + XCTAssertEqual(c.cS2RC("czf"), "ㄕㄠˊ") + XCTAssertEqual(c.cS2RC("czj"), "ㄕㄠˇ") + XCTAssertEqual(c.cS2RC("czk"), "ㄕㄠˋ") + XCTAssertEqual(c.cS2RC("cp"), "ㄕㄡ") + XCTAssertEqual(c.cS2RC("cpf"), "ㄕㄡˊ") + XCTAssertEqual(c.cS2RC("cpj"), "ㄕㄡˇ") + XCTAssertEqual(c.cS2RC("cpk"), "ㄕㄡˋ") + XCTAssertEqual(c.cS2RC("cm"), "ㄕㄢ") + XCTAssertEqual(c.cS2RC("cmf"), "ㄕㄢˊ") + XCTAssertEqual(c.cS2RC("cmj"), "ㄕㄢˇ") + XCTAssertEqual(c.cS2RC("cmk"), "ㄕㄢˋ") + XCTAssertEqual(c.cS2RC("cn"), "ㄕㄣ") + XCTAssertEqual(c.cS2RC("cnf"), "ㄕㄣˊ") + XCTAssertEqual(c.cS2RC("cnj"), "ㄕㄣˇ") + XCTAssertEqual(c.cS2RC("cnk"), "ㄕㄣˋ") + XCTAssertEqual(c.cS2RC("ct"), "ㄕㄤ") + XCTAssertEqual(c.cS2RC("ctj"), "ㄕㄤˇ") + XCTAssertEqual(c.cS2RC("ctk"), "ㄕㄤˋ") + XCTAssertEqual(c.cS2RC("ctd"), "ㄕㄤ˙") + XCTAssertEqual(c.cS2RC("cl"), "ㄕㄥ") + XCTAssertEqual(c.cS2RC("clf"), "ㄕㄥˊ") + XCTAssertEqual(c.cS2RC("clj"), "ㄕㄥˇ") + XCTAssertEqual(c.cS2RC("clk"), "ㄕㄥˋ") + XCTAssertEqual(c.cS2RC("cx"), "ㄕㄨ") + XCTAssertEqual(c.cS2RC("cxf"), "ㄕㄨˊ") + XCTAssertEqual(c.cS2RC("cxj"), "ㄕㄨˇ") + XCTAssertEqual(c.cS2RC("cxk"), "ㄕㄨˋ") + XCTAssertEqual(c.cS2RC("cxa"), "ㄕㄨㄚ") + XCTAssertEqual(c.cS2RC("cxaj"), "ㄕㄨㄚˇ") + XCTAssertEqual(c.cS2RC("cxak"), "ㄕㄨㄚˋ") + XCTAssertEqual(c.cS2RC("cxo"), "ㄕㄨㄛ") + XCTAssertEqual(c.cS2RC("cxok"), "ㄕㄨㄛˋ") + XCTAssertEqual(c.cS2RC("cxi"), "ㄕㄨㄞ") + XCTAssertEqual(c.cS2RC("cxij"), "ㄕㄨㄞˇ") + XCTAssertEqual(c.cS2RC("cxik"), "ㄕㄨㄞˋ") + XCTAssertEqual(c.cS2RC("cxq"), "ㄕㄨㄟ") + XCTAssertEqual(c.cS2RC("cxqf"), "ㄕㄨㄟˊ") + XCTAssertEqual(c.cS2RC("cxqj"), "ㄕㄨㄟˇ") + XCTAssertEqual(c.cS2RC("cxqk"), "ㄕㄨㄟˋ") + XCTAssertEqual(c.cS2RC("cxm"), "ㄕㄨㄢ") + XCTAssertEqual(c.cS2RC("cxmk"), "ㄕㄨㄢˋ") + XCTAssertEqual(c.cS2RC("cxnj"), "ㄕㄨㄣˇ") + XCTAssertEqual(c.cS2RC("cxnk"), "ㄕㄨㄣˋ") + XCTAssertEqual(c.cS2RC("cxt"), "ㄕㄨㄤ") + XCTAssertEqual(c.cS2RC("cxtf"), "ㄕㄨㄤˊ") + XCTAssertEqual(c.cS2RC("cxtj"), "ㄕㄨㄤˇ") + XCTAssertEqual(c.cS2RC("cxtk"), "ㄕㄨㄤˋ") + XCTAssertEqual(c.cS2RC("jk"), "ㄖˋ") + XCTAssertEqual(c.cS2RC("jrj"), "ㄖㄜˇ") + XCTAssertEqual(c.cS2RC("jrk"), "ㄖㄜˋ") + XCTAssertEqual(c.cS2RC("jzf"), "ㄖㄠˊ") + XCTAssertEqual(c.cS2RC("jzj"), "ㄖㄠˇ") + XCTAssertEqual(c.cS2RC("jzk"), "ㄖㄠˋ") + XCTAssertEqual(c.cS2RC("jpf"), "ㄖㄡˊ") + XCTAssertEqual(c.cS2RC("jpj"), "ㄖㄡˇ") + XCTAssertEqual(c.cS2RC("jpk"), "ㄖㄡˋ") + XCTAssertEqual(c.cS2RC("jmf"), "ㄖㄢˊ") + XCTAssertEqual(c.cS2RC("jmj"), "ㄖㄢˇ") + XCTAssertEqual(c.cS2RC("jmk"), "ㄖㄢˋ") + XCTAssertEqual(c.cS2RC("jnf"), "ㄖㄣˊ") + XCTAssertEqual(c.cS2RC("jnj"), "ㄖㄣˇ") + XCTAssertEqual(c.cS2RC("jnk"), "ㄖㄣˋ") + XCTAssertEqual(c.cS2RC("jt"), "ㄖㄤ") + XCTAssertEqual(c.cS2RC("jtf"), "ㄖㄤˊ") + XCTAssertEqual(c.cS2RC("jtj"), "ㄖㄤˇ") + XCTAssertEqual(c.cS2RC("jtk"), "ㄖㄤˋ") + XCTAssertEqual(c.cS2RC("jl"), "ㄖㄥ") + XCTAssertEqual(c.cS2RC("jlf"), "ㄖㄥˊ") + XCTAssertEqual(c.cS2RC("jlj"), "ㄖㄥˇ") + XCTAssertEqual(c.cS2RC("jlk"), "ㄖㄥˋ") + XCTAssertEqual(c.cS2RC("jxf"), "ㄖㄨˊ") + XCTAssertEqual(c.cS2RC("jxj"), "ㄖㄨˇ") + XCTAssertEqual(c.cS2RC("jxk"), "ㄖㄨˋ") + XCTAssertEqual(c.cS2RC("jxof"), "ㄖㄨㄛˊ") + XCTAssertEqual(c.cS2RC("jxok"), "ㄖㄨㄛˋ") + XCTAssertEqual(c.cS2RC("jxqf"), "ㄖㄨㄟˊ") + XCTAssertEqual(c.cS2RC("jxqj"), "ㄖㄨㄟˇ") + XCTAssertEqual(c.cS2RC("jxqk"), "ㄖㄨㄟˋ") + XCTAssertEqual(c.cS2RC("jxmf"), "ㄖㄨㄢˊ") + XCTAssertEqual(c.cS2RC("jxmj"), "ㄖㄨㄢˇ") + XCTAssertEqual(c.cS2RC("jxmk"), "ㄖㄨㄢˋ") + XCTAssertEqual(c.cS2RC("jxnf"), "ㄖㄨㄣˊ") + XCTAssertEqual(c.cS2RC("jxnj"), "ㄖㄨㄣˇ") + XCTAssertEqual(c.cS2RC("jxnk"), "ㄖㄨㄣˋ") + XCTAssertEqual(c.cS2RC("jxlf"), "ㄖㄨㄥˊ") + XCTAssertEqual(c.cS2RC("jxlj"), "ㄖㄨㄥˇ") + XCTAssertEqual(c.cS2RC("jxlk"), "ㄖㄨㄥˋ") + XCTAssertEqual(c.cS2RC("q"), "ㄗ") + XCTAssertEqual(c.cS2RC("qf"), "ㄗˊ") + XCTAssertEqual(c.cS2RC("qj"), "ㄗˇ") + XCTAssertEqual(c.cS2RC("qk"), "ㄗˋ") + XCTAssertEqual(c.cS2RC("qd"), "ㄗ˙") + XCTAssertEqual(c.cS2RC("qa"), "ㄗㄚ") + XCTAssertEqual(c.cS2RC("qaf"), "ㄗㄚˊ") + XCTAssertEqual(c.cS2RC("qaj"), "ㄗㄚˇ") + XCTAssertEqual(c.cS2RC("qrf"), "ㄗㄜˊ") + XCTAssertEqual(c.cS2RC("qrj"), "ㄗㄜˇ") + XCTAssertEqual(c.cS2RC("qrk"), "ㄗㄜˋ") + XCTAssertEqual(c.cS2RC("qi"), "ㄗㄞ") + XCTAssertEqual(c.cS2RC("qij"), "ㄗㄞˇ") + XCTAssertEqual(c.cS2RC("qik"), "ㄗㄞˋ") + XCTAssertEqual(c.cS2RC("qqf"), "ㄗㄟˊ") + XCTAssertEqual(c.cS2RC("qz"), "ㄗㄠ") + XCTAssertEqual(c.cS2RC("qzf"), "ㄗㄠˊ") + XCTAssertEqual(c.cS2RC("qzj"), "ㄗㄠˇ") + XCTAssertEqual(c.cS2RC("qzk"), "ㄗㄠˋ") + XCTAssertEqual(c.cS2RC("qp"), "ㄗㄡ") + XCTAssertEqual(c.cS2RC("qpj"), "ㄗㄡˇ") + XCTAssertEqual(c.cS2RC("qpk"), "ㄗㄡˋ") + XCTAssertEqual(c.cS2RC("qm"), "ㄗㄢ") + XCTAssertEqual(c.cS2RC("qmf"), "ㄗㄢˊ") + XCTAssertEqual(c.cS2RC("qmj"), "ㄗㄢˇ") + XCTAssertEqual(c.cS2RC("qmk"), "ㄗㄢˋ") + XCTAssertEqual(c.cS2RC("qn"), "ㄗㄣ") + XCTAssertEqual(c.cS2RC("qnj"), "ㄗㄣˇ") + XCTAssertEqual(c.cS2RC("qnk"), "ㄗㄣˋ") + XCTAssertEqual(c.cS2RC("qt"), "ㄗㄤ") + XCTAssertEqual(c.cS2RC("qtj"), "ㄗㄤˇ") + XCTAssertEqual(c.cS2RC("qtk"), "ㄗㄤˋ") + XCTAssertEqual(c.cS2RC("ql"), "ㄗㄥ") + XCTAssertEqual(c.cS2RC("qlj"), "ㄗㄥˇ") + XCTAssertEqual(c.cS2RC("qlk"), "ㄗㄥˋ") + XCTAssertEqual(c.cS2RC("qx"), "ㄗㄨ") + XCTAssertEqual(c.cS2RC("qxf"), "ㄗㄨˊ") + XCTAssertEqual(c.cS2RC("qxj"), "ㄗㄨˇ") + XCTAssertEqual(c.cS2RC("qxk"), "ㄗㄨˋ") + XCTAssertEqual(c.cS2RC("qxo"), "ㄗㄨㄛ") + XCTAssertEqual(c.cS2RC("qxof"), "ㄗㄨㄛˊ") + XCTAssertEqual(c.cS2RC("qxoj"), "ㄗㄨㄛˇ") + XCTAssertEqual(c.cS2RC("qxok"), "ㄗㄨㄛˋ") + XCTAssertEqual(c.cS2RC("qxod"), "ㄗㄨㄛ˙") + XCTAssertEqual(c.cS2RC("qxq"), "ㄗㄨㄟ") + XCTAssertEqual(c.cS2RC("qxqj"), "ㄗㄨㄟˇ") + XCTAssertEqual(c.cS2RC("qxqk"), "ㄗㄨㄟˋ") + XCTAssertEqual(c.cS2RC("qxm"), "ㄗㄨㄢ") + XCTAssertEqual(c.cS2RC("qxmj"), "ㄗㄨㄢˇ") + XCTAssertEqual(c.cS2RC("qxmk"), "ㄗㄨㄢˋ") + XCTAssertEqual(c.cS2RC("qxn"), "ㄗㄨㄣ") + XCTAssertEqual(c.cS2RC("qxnj"), "ㄗㄨㄣˇ") + XCTAssertEqual(c.cS2RC("qxnk"), "ㄗㄨㄣˋ") + XCTAssertEqual(c.cS2RC("qxl"), "ㄗㄨㄥ") + XCTAssertEqual(c.cS2RC("qxlj"), "ㄗㄨㄥˇ") + XCTAssertEqual(c.cS2RC("qxlk"), "ㄗㄨㄥˋ") + XCTAssertEqual(c.cS2RC("w"), "ㄘ") + XCTAssertEqual(c.cS2RC("wf"), "ㄘˊ") + XCTAssertEqual(c.cS2RC("wj"), "ㄘˇ") + XCTAssertEqual(c.cS2RC("wk"), "ㄘˋ") + XCTAssertEqual(c.cS2RC("wa"), "ㄘㄚ") + XCTAssertEqual(c.cS2RC("waj"), "ㄘㄚˇ") + XCTAssertEqual(c.cS2RC("wak"), "ㄘㄚˋ") + XCTAssertEqual(c.cS2RC("wrk"), "ㄘㄜˋ") + XCTAssertEqual(c.cS2RC("wi"), "ㄘㄞ") + XCTAssertEqual(c.cS2RC("wif"), "ㄘㄞˊ") + XCTAssertEqual(c.cS2RC("wij"), "ㄘㄞˇ") + XCTAssertEqual(c.cS2RC("wik"), "ㄘㄞˋ") + XCTAssertEqual(c.cS2RC("wz"), "ㄘㄠ") + XCTAssertEqual(c.cS2RC("wzf"), "ㄘㄠˊ") + XCTAssertEqual(c.cS2RC("wzj"), "ㄘㄠˇ") + XCTAssertEqual(c.cS2RC("wzk"), "ㄘㄠˋ") + XCTAssertEqual(c.cS2RC("wp"), "ㄘㄡ") + XCTAssertEqual(c.cS2RC("wpf"), "ㄘㄡˊ") + XCTAssertEqual(c.cS2RC("wpj"), "ㄘㄡˇ") + XCTAssertEqual(c.cS2RC("wpk"), "ㄘㄡˋ") + XCTAssertEqual(c.cS2RC("wm"), "ㄘㄢ") + XCTAssertEqual(c.cS2RC("wmf"), "ㄘㄢˊ") + XCTAssertEqual(c.cS2RC("wmj"), "ㄘㄢˇ") + XCTAssertEqual(c.cS2RC("wmk"), "ㄘㄢˋ") + XCTAssertEqual(c.cS2RC("wn"), "ㄘㄣ") + XCTAssertEqual(c.cS2RC("wnf"), "ㄘㄣˊ") + XCTAssertEqual(c.cS2RC("wt"), "ㄘㄤ") + XCTAssertEqual(c.cS2RC("wtf"), "ㄘㄤˊ") + XCTAssertEqual(c.cS2RC("wtj"), "ㄘㄤˇ") + XCTAssertEqual(c.cS2RC("wtk"), "ㄘㄤˋ") + XCTAssertEqual(c.cS2RC("wl"), "ㄘㄥ") + XCTAssertEqual(c.cS2RC("wlf"), "ㄘㄥˊ") + XCTAssertEqual(c.cS2RC("wlj"), "ㄘㄥˇ") + XCTAssertEqual(c.cS2RC("wlk"), "ㄘㄥˋ") + XCTAssertEqual(c.cS2RC("wx"), "ㄘㄨ") + XCTAssertEqual(c.cS2RC("wxf"), "ㄘㄨˊ") + XCTAssertEqual(c.cS2RC("wxj"), "ㄘㄨˇ") + XCTAssertEqual(c.cS2RC("wxk"), "ㄘㄨˋ") + XCTAssertEqual(c.cS2RC("wxo"), "ㄘㄨㄛ") + XCTAssertEqual(c.cS2RC("wxof"), "ㄘㄨㄛˊ") + XCTAssertEqual(c.cS2RC("wxoj"), "ㄘㄨㄛˇ") + XCTAssertEqual(c.cS2RC("wxok"), "ㄘㄨㄛˋ") + XCTAssertEqual(c.cS2RC("wxq"), "ㄘㄨㄟ") + XCTAssertEqual(c.cS2RC("wxqj"), "ㄘㄨㄟˇ") + XCTAssertEqual(c.cS2RC("wxqk"), "ㄘㄨㄟˋ") + XCTAssertEqual(c.cS2RC("wxm"), "ㄘㄨㄢ") + XCTAssertEqual(c.cS2RC("wxmf"), "ㄘㄨㄢˊ") + XCTAssertEqual(c.cS2RC("wxmj"), "ㄘㄨㄢˇ") + XCTAssertEqual(c.cS2RC("wxmk"), "ㄘㄨㄢˋ") + XCTAssertEqual(c.cS2RC("wxn"), "ㄘㄨㄣ") + XCTAssertEqual(c.cS2RC("wxnf"), "ㄘㄨㄣˊ") + XCTAssertEqual(c.cS2RC("wxnj"), "ㄘㄨㄣˇ") + XCTAssertEqual(c.cS2RC("wxnk"), "ㄘㄨㄣˋ") + XCTAssertEqual(c.cS2RC("wxl"), "ㄘㄨㄥ") + XCTAssertEqual(c.cS2RC("wxlf"), "ㄘㄨㄥˊ") + XCTAssertEqual(c.cS2RC("wxlj"), "ㄘㄨㄥˇ") + XCTAssertEqual(c.cS2RC("wxlk"), "ㄘㄨㄥˋ") + XCTAssertEqual(c.cS2RC("s"), "ㄙ") + XCTAssertEqual(c.cS2RC("sj"), "ㄙˇ") + XCTAssertEqual(c.cS2RC("sk"), "ㄙˋ") + XCTAssertEqual(c.cS2RC("sa"), "ㄙㄚ") + XCTAssertEqual(c.cS2RC("saj"), "ㄙㄚˇ") + XCTAssertEqual(c.cS2RC("sak"), "ㄙㄚˋ") + XCTAssertEqual(c.cS2RC("sad"), "ㄙㄚ˙") + XCTAssertEqual(c.cS2RC("sr"), "ㄙㄜ") + XCTAssertEqual(c.cS2RC("srk"), "ㄙㄜˋ") + XCTAssertEqual(c.cS2RC("si"), "ㄙㄞ") + XCTAssertEqual(c.cS2RC("sif"), "ㄙㄞˊ") + XCTAssertEqual(c.cS2RC("sij"), "ㄙㄞˇ") + XCTAssertEqual(c.cS2RC("sik"), "ㄙㄞˋ") + XCTAssertEqual(c.cS2RC("sq"), "ㄙㄟ") + XCTAssertEqual(c.cS2RC("sz"), "ㄙㄠ") + XCTAssertEqual(c.cS2RC("szj"), "ㄙㄠˇ") + XCTAssertEqual(c.cS2RC("szk"), "ㄙㄠˋ") + XCTAssertEqual(c.cS2RC("sp"), "ㄙㄡ") + XCTAssertEqual(c.cS2RC("spj"), "ㄙㄡˇ") + XCTAssertEqual(c.cS2RC("spk"), "ㄙㄡˋ") + XCTAssertEqual(c.cS2RC("sm"), "ㄙㄢ") + XCTAssertEqual(c.cS2RC("smj"), "ㄙㄢˇ") + XCTAssertEqual(c.cS2RC("smk"), "ㄙㄢˋ") + XCTAssertEqual(c.cS2RC("sn"), "ㄙㄣ") + XCTAssertEqual(c.cS2RC("snj"), "ㄙㄣˇ") + XCTAssertEqual(c.cS2RC("st"), "ㄙㄤ") + XCTAssertEqual(c.cS2RC("stj"), "ㄙㄤˇ") + XCTAssertEqual(c.cS2RC("stk"), "ㄙㄤˋ") + XCTAssertEqual(c.cS2RC("sl"), "ㄙㄥ") + XCTAssertEqual(c.cS2RC("slk"), "ㄙㄥˋ") + XCTAssertEqual(c.cS2RC("sx"), "ㄙㄨ") + XCTAssertEqual(c.cS2RC("sxf"), "ㄙㄨˊ") + XCTAssertEqual(c.cS2RC("sxj"), "ㄙㄨˇ") + XCTAssertEqual(c.cS2RC("sxk"), "ㄙㄨˋ") + XCTAssertEqual(c.cS2RC("sxo"), "ㄙㄨㄛ") + XCTAssertEqual(c.cS2RC("sxof"), "ㄙㄨㄛˊ") + XCTAssertEqual(c.cS2RC("sxoj"), "ㄙㄨㄛˇ") + XCTAssertEqual(c.cS2RC("sxok"), "ㄙㄨㄛˋ") + XCTAssertEqual(c.cS2RC("sxq"), "ㄙㄨㄟ") + XCTAssertEqual(c.cS2RC("sxqf"), "ㄙㄨㄟˊ") + XCTAssertEqual(c.cS2RC("sxqj"), "ㄙㄨㄟˇ") + XCTAssertEqual(c.cS2RC("sxqk"), "ㄙㄨㄟˋ") + XCTAssertEqual(c.cS2RC("sxm"), "ㄙㄨㄢ") + XCTAssertEqual(c.cS2RC("sxmj"), "ㄙㄨㄢˇ") + XCTAssertEqual(c.cS2RC("sxmk"), "ㄙㄨㄢˋ") + XCTAssertEqual(c.cS2RC("sxn"), "ㄙㄨㄣ") + XCTAssertEqual(c.cS2RC("sxnj"), "ㄙㄨㄣˇ") + XCTAssertEqual(c.cS2RC("sxnk"), "ㄙㄨㄣˋ") + XCTAssertEqual(c.cS2RC("sxl"), "ㄙㄨㄥ") + XCTAssertEqual(c.cS2RC("sxlf"), "ㄙㄨㄥˊ") + XCTAssertEqual(c.cS2RC("sxlj"), "ㄙㄨㄥˇ") + XCTAssertEqual(c.cS2RC("sxlk"), "ㄙㄨㄥˋ") + XCTAssertEqual(c.cS2RC("a"), "ㄚ") + XCTAssertEqual(c.cS2RC("af"), "ㄚˊ") + XCTAssertEqual(c.cS2RC("ak"), "ㄚˋ") + XCTAssertEqual(c.cS2RC("ad"), "ㄚ˙") + XCTAssertEqual(c.cS2RC("o"), "ㄛ") + XCTAssertEqual(c.cS2RC("of"), "ㄛˊ") + XCTAssertEqual(c.cS2RC("oj"), "ㄛˇ") + XCTAssertEqual(c.cS2RC("ok"), "ㄛˋ") + XCTAssertEqual(c.cS2RC("r"), "ㄜ") + XCTAssertEqual(c.cS2RC("rf"), "ㄜˊ") + XCTAssertEqual(c.cS2RC("rj"), "ㄜˇ") + XCTAssertEqual(c.cS2RC("rk"), "ㄜˋ") + // XCTAssertEqual(c.cS2RC("wf"), "ㄝˊ") + // XCTAssertEqual(c.cS2RC("wj"), "ㄝˇ") + // XCTAssertEqual(c.cS2RC("wk"), "ㄝˋ") + // XCTAssertEqual(c.cS2RC("wd"), "ㄝ˙") + XCTAssertEqual(c.cS2RC("i"), "ㄞ") + XCTAssertEqual(c.cS2RC("if"), "ㄞˊ") + XCTAssertEqual(c.cS2RC("ij"), "ㄞˇ") + XCTAssertEqual(c.cS2RC("ik"), "ㄞˋ") + // XCTAssertEqual(c.cS2RC("qk"), "ㄟˋ") + XCTAssertEqual(c.cS2RC("z"), "ㄠ") + XCTAssertEqual(c.cS2RC("zf"), "ㄠˊ") + XCTAssertEqual(c.cS2RC("zj"), "ㄠˇ") + XCTAssertEqual(c.cS2RC("zk"), "ㄠˋ") + XCTAssertEqual(c.cS2RC("p "), "ㄡ ") + XCTAssertEqual(c.cS2RC("pf"), "ㄡˊ") + XCTAssertEqual(c.cS2RC("pj"), "ㄡˇ") + XCTAssertEqual(c.cS2RC("pk"), "ㄡˋ") + XCTAssertEqual(c.cS2RC("pd"), "ㄡ˙") + XCTAssertEqual(c.cS2RC("m "), "ㄢ ") + XCTAssertEqual(c.cS2RC("mf"), "ㄢˊ") + XCTAssertEqual(c.cS2RC("mj"), "ㄢˇ") + XCTAssertEqual(c.cS2RC("mk"), "ㄢˋ") + XCTAssertEqual(c.cS2RC("n "), "ㄣ ") + XCTAssertEqual(c.cS2RC("nf"), "ㄣˊ") + XCTAssertEqual(c.cS2RC("nj"), "ㄣˇ") + XCTAssertEqual(c.cS2RC("nk"), "ㄣˋ") + XCTAssertEqual(c.cS2RC("nd"), "ㄣ˙") + XCTAssertEqual(c.cS2RC("t "), "ㄤ ") + XCTAssertEqual(c.cS2RC("tf"), "ㄤˊ") + XCTAssertEqual(c.cS2RC("tj"), "ㄤˇ") + XCTAssertEqual(c.cS2RC("tk"), "ㄤˋ") + XCTAssertEqual(c.cS2RC("l "), "ㄥ ") + XCTAssertEqual(c.cS2RC("lk"), "ㄥˋ") + XCTAssertEqual(c.cS2RC("h "), "ㄦ ") + XCTAssertEqual(c.cS2RC("hf"), "ㄦˊ") + XCTAssertEqual(c.cS2RC("hj"), "ㄦˇ") + XCTAssertEqual(c.cS2RC("hk"), "ㄦˋ") + XCTAssertEqual(c.cS2RC("hd"), "ㄦ˙") + XCTAssertEqual(c.cS2RC("e"), "ㄧ") + XCTAssertEqual(c.cS2RC("ef"), "ㄧˊ") + XCTAssertEqual(c.cS2RC("ej"), "ㄧˇ") + XCTAssertEqual(c.cS2RC("ek"), "ㄧˋ") + XCTAssertEqual(c.cS2RC("ea"), "ㄧㄚ") + XCTAssertEqual(c.cS2RC("eaf"), "ㄧㄚˊ") + XCTAssertEqual(c.cS2RC("eaj"), "ㄧㄚˇ") + XCTAssertEqual(c.cS2RC("eak"), "ㄧㄚˋ") + XCTAssertEqual(c.cS2RC("ead"), "ㄧㄚ˙") + XCTAssertEqual(c.cS2RC("eo"), "ㄧㄛ") + XCTAssertEqual(c.cS2RC("eod"), "ㄧㄛ˙") + XCTAssertEqual(c.cS2RC("ew"), "ㄧㄝ") + XCTAssertEqual(c.cS2RC("ewf"), "ㄧㄝˊ") + XCTAssertEqual(c.cS2RC("ewj"), "ㄧㄝˇ") + XCTAssertEqual(c.cS2RC("ewk"), "ㄧㄝˋ") + XCTAssertEqual(c.cS2RC("ewd"), "ㄧㄝ˙") + XCTAssertEqual(c.cS2RC("eif"), "ㄧㄞˊ") + XCTAssertEqual(c.cS2RC("ez"), "ㄧㄠ") + XCTAssertEqual(c.cS2RC("ezf"), "ㄧㄠˊ") + XCTAssertEqual(c.cS2RC("ezj"), "ㄧㄠˇ") + XCTAssertEqual(c.cS2RC("ezk"), "ㄧㄠˋ") + XCTAssertEqual(c.cS2RC("ep"), "ㄧㄡ") + XCTAssertEqual(c.cS2RC("epf"), "ㄧㄡˊ") + XCTAssertEqual(c.cS2RC("epj"), "ㄧㄡˇ") + XCTAssertEqual(c.cS2RC("epk"), "ㄧㄡˋ") + XCTAssertEqual(c.cS2RC("em"), "ㄧㄢ") + XCTAssertEqual(c.cS2RC("emf"), "ㄧㄢˊ") + XCTAssertEqual(c.cS2RC("emj"), "ㄧㄢˇ") + XCTAssertEqual(c.cS2RC("emk"), "ㄧㄢˋ") + XCTAssertEqual(c.cS2RC("en"), "ㄧㄣ") + XCTAssertEqual(c.cS2RC("enf"), "ㄧㄣˊ") + XCTAssertEqual(c.cS2RC("enj"), "ㄧㄣˇ") + XCTAssertEqual(c.cS2RC("enk"), "ㄧㄣˋ") + XCTAssertEqual(c.cS2RC("et"), "ㄧㄤ") + XCTAssertEqual(c.cS2RC("etf"), "ㄧㄤˊ") + XCTAssertEqual(c.cS2RC("etj"), "ㄧㄤˇ") + XCTAssertEqual(c.cS2RC("etk"), "ㄧㄤˋ") + XCTAssertEqual(c.cS2RC("el"), "ㄧㄥ") + XCTAssertEqual(c.cS2RC("elf"), "ㄧㄥˊ") + XCTAssertEqual(c.cS2RC("elj"), "ㄧㄥˇ") + XCTAssertEqual(c.cS2RC("elk"), "ㄧㄥˋ") + XCTAssertEqual(c.cS2RC("x"), "ㄨ") + XCTAssertEqual(c.cS2RC("xf"), "ㄨˊ") + XCTAssertEqual(c.cS2RC("xj"), "ㄨˇ") + XCTAssertEqual(c.cS2RC("xk"), "ㄨˋ") + XCTAssertEqual(c.cS2RC("xa"), "ㄨㄚ") + XCTAssertEqual(c.cS2RC("xaf"), "ㄨㄚˊ") + XCTAssertEqual(c.cS2RC("xaj"), "ㄨㄚˇ") + XCTAssertEqual(c.cS2RC("xak"), "ㄨㄚˋ") + XCTAssertEqual(c.cS2RC("xad"), "ㄨㄚ˙") + XCTAssertEqual(c.cS2RC("xo"), "ㄨㄛ") + XCTAssertEqual(c.cS2RC("xoj"), "ㄨㄛˇ") + XCTAssertEqual(c.cS2RC("xok"), "ㄨㄛˋ") + XCTAssertEqual(c.cS2RC("xi"), "ㄨㄞ") + XCTAssertEqual(c.cS2RC("xij"), "ㄨㄞˇ") + XCTAssertEqual(c.cS2RC("xik"), "ㄨㄞˋ") + XCTAssertEqual(c.cS2RC("xq"), "ㄨㄟ") + XCTAssertEqual(c.cS2RC("xqf"), "ㄨㄟˊ") + XCTAssertEqual(c.cS2RC("xqj"), "ㄨㄟˇ") + XCTAssertEqual(c.cS2RC("xqk"), "ㄨㄟˋ") + XCTAssertEqual(c.cS2RC("xm"), "ㄨㄢ") + XCTAssertEqual(c.cS2RC("xmf"), "ㄨㄢˊ") + XCTAssertEqual(c.cS2RC("xmj"), "ㄨㄢˇ") + XCTAssertEqual(c.cS2RC("xmk"), "ㄨㄢˋ") + XCTAssertEqual(c.cS2RC("xn"), "ㄨㄣ") + XCTAssertEqual(c.cS2RC("xnf"), "ㄨㄣˊ") + XCTAssertEqual(c.cS2RC("xnj"), "ㄨㄣˇ") + XCTAssertEqual(c.cS2RC("xnk"), "ㄨㄣˋ") + XCTAssertEqual(c.cS2RC("xt"), "ㄨㄤ") + XCTAssertEqual(c.cS2RC("xtf"), "ㄨㄤˊ") + XCTAssertEqual(c.cS2RC("xtj"), "ㄨㄤˇ") + XCTAssertEqual(c.cS2RC("xtk"), "ㄨㄤˋ") + XCTAssertEqual(c.cS2RC("xl"), "ㄨㄥ") + XCTAssertEqual(c.cS2RC("xlj"), "ㄨㄥˇ") + XCTAssertEqual(c.cS2RC("xlk"), "ㄨㄥˋ") + XCTAssertEqual(c.cS2RC("u"), "ㄩ") + XCTAssertEqual(c.cS2RC("uf"), "ㄩˊ") + XCTAssertEqual(c.cS2RC("uj"), "ㄩˇ") + XCTAssertEqual(c.cS2RC("uk"), "ㄩˋ") + XCTAssertEqual(c.cS2RC("uw"), "ㄩㄝ") + XCTAssertEqual(c.cS2RC("uwj"), "ㄩㄝˇ") + XCTAssertEqual(c.cS2RC("uwk"), "ㄩㄝˋ") + XCTAssertEqual(c.cS2RC("um"), "ㄩㄢ") + XCTAssertEqual(c.cS2RC("umf"), "ㄩㄢˊ") + XCTAssertEqual(c.cS2RC("umj"), "ㄩㄢˇ") + XCTAssertEqual(c.cS2RC("umk"), "ㄩㄢˋ") + XCTAssertEqual(c.cS2RC("un"), "ㄩㄣ") + XCTAssertEqual(c.cS2RC("unf"), "ㄩㄣˊ") + XCTAssertEqual(c.cS2RC("unj"), "ㄩㄣˇ") + XCTAssertEqual(c.cS2RC("unk"), "ㄩㄣˋ") + XCTAssertEqual(c.cS2RC("ul"), "ㄩㄥ") + XCTAssertEqual(c.cS2RC("ulf"), "ㄩㄥˊ") + XCTAssertEqual(c.cS2RC("ulj"), "ㄩㄥˇ") + XCTAssertEqual(c.cS2RC("ulk"), "ㄩㄥˋ") } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_A.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_A.swift index bd65eba0..2823b36c 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_A.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_A.swift @@ -11,490 +11,494 @@ import XCTest @testable import Tekkon extension TekkonTestsKeyboardArrangments { + func testHsuKeysTaigi() throws { + var c = Tekkon.Composer(arrange: .ofHsu) + XCTAssertEqual(c.cS2RC("kek"), "ㄎㄧㄤ") + XCTAssertEqual(c.cS2RC("gewd"), "ㄍㄧㄠˊ") + XCTAssertEqual(c.cS2RC("gen"), "ㄍㄧㄣ") + } + func testHsuKeysA() throws { - var composer = Tekkon.Composer(arrange: .ofHsu) - XCTAssertEqual(composer.convertSequenceToRawComposition("kek"), "ㄎㄧㄤ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("vezf"), "ㄍㄧㄠˊ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("gen"), "ㄍㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bekd"), "ㄅㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bekj"), "ㄅㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxk"), "ㄉㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("by"), "ㄅㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("byd"), "ㄅㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("byf"), "ㄅㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("byj"), "ㄅㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bys"), "ㄅㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("bh"), "ㄅㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bhd"), "ㄅㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bhf"), "ㄅㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bhj"), "ㄅㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bhs"), "ㄅㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("bi"), "ㄅㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bid"), "ㄅㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bif"), "ㄅㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bij"), "ㄅㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bis"), "ㄅㄞ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ba"), "ㄅㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("baf"), "ㄅㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("baj"), "ㄅㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bas"), "ㄅㄟ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("bw"), "ㄅㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bwd"), "ㄅㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bwf"), "ㄅㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bwj"), "ㄅㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bm"), "ㄅㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bmf"), "ㄅㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bmj"), "ㄅㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bn"), "ㄅㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bnf"), "ㄅㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bnj"), "ㄅㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bk"), "ㄅㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bkf"), "ㄅㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bkj"), "ㄅㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bl"), "ㄅㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bld"), "ㄅㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("blf"), "ㄅㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("blj"), "ㄅㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("be"), "ㄅㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bed"), "ㄅㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bef"), "ㄅㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bej"), "ㄅㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bee"), "ㄅㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("beed"), "ㄅㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("beef"), "ㄅㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("beej"), "ㄅㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bew"), "ㄅㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bewf"), "ㄅㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bewj"), "ㄅㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bem"), "ㄅㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bemd"), "ㄅㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bemf"), "ㄅㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bemj"), "ㄅㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ben"), "ㄅㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("benf"), "ㄅㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("benj"), "ㄅㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bel"), "ㄅㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("belf"), "ㄅㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("belj"), "ㄅㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bx"), "ㄅㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bxd"), "ㄅㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bxf"), "ㄅㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bxj"), "ㄅㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("py"), "ㄆㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pyd"), "ㄆㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pyf"), "ㄆㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pyj"), "ㄆㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pys"), "ㄆㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ph"), "ㄆㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("phd"), "ㄆㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("phf"), "ㄆㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("phj"), "ㄆㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pi"), "ㄆㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pid"), "ㄆㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pif"), "ㄆㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pij"), "ㄆㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pa"), "ㄆㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pad"), "ㄆㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("paf"), "ㄆㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("paj"), "ㄆㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pw"), "ㄆㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pwd"), "ㄆㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pwf"), "ㄆㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pwj"), "ㄆㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("po"), "ㄆㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pod"), "ㄆㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pof"), "ㄆㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("poj"), "ㄆㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pm"), "ㄆㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pmd"), "ㄆㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pmf"), "ㄆㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pmj"), "ㄆㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pn"), "ㄆㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pnd"), "ㄆㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pnf"), "ㄆㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pnj"), "ㄆㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pk"), "ㄆㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pkd"), "ㄆㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pkf"), "ㄆㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pkj"), "ㄆㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pl"), "ㄆㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pld"), "ㄆㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("plf"), "ㄆㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("plj"), "ㄆㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pe"), "ㄆㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ped"), "ㄆㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pef"), "ㄆㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pej"), "ㄆㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pey"), "ㄆㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pee"), "ㄆㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("peef"), "ㄆㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("peej"), "ㄆㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pew"), "ㄆㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pewd"), "ㄆㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pewf"), "ㄆㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pewj"), "ㄆㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pem"), "ㄆㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pemd"), "ㄆㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pemf"), "ㄆㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pemj"), "ㄆㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pen"), "ㄆㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pend"), "ㄆㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("penf"), "ㄆㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("penj"), "ㄆㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pel"), "ㄆㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("peld"), "ㄆㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pelf"), "ㄆㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pelj"), "ㄆㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("px"), "ㄆㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pxd"), "ㄆㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pxf"), "ㄆㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pxj"), "ㄆㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("my"), "ㄇㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("myd"), "ㄇㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("myf"), "ㄇㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("myj"), "ㄇㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mys"), "ㄇㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("mh"), "ㄇㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mhd"), "ㄇㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mhf"), "ㄇㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mhj"), "ㄇㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mhs"), "ㄇㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("mg"), "ㄇㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mgj"), "ㄇㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mgs"), "ㄇㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("mi"), "ㄇㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mid"), "ㄇㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mif"), "ㄇㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mij"), "ㄇㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mad"), "ㄇㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("maf"), "ㄇㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("maj"), "ㄇㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mw"), "ㄇㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mwd"), "ㄇㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mwf"), "ㄇㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mwj"), "ㄇㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mod"), "ㄇㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mof"), "ㄇㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("moj"), "ㄇㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mm"), "ㄇㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmd"), "ㄇㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmf"), "ㄇㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mmj"), "ㄇㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mn"), "ㄇㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mnd"), "ㄇㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mnf"), "ㄇㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mnj"), "ㄇㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mns"), "ㄇㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("mk"), "ㄇㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mkd"), "ㄇㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mkf"), "ㄇㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mkj"), "ㄇㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ml"), "ㄇㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mld"), "ㄇㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mlf"), "ㄇㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mlj"), "ㄇㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("me"), "ㄇㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("med"), "ㄇㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mef"), "ㄇㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mej"), "ㄇㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mee"), "ㄇㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("meed"), "ㄇㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("meej"), "ㄇㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mew"), "ㄇㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mewd"), "ㄇㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mewf"), "ㄇㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mewj"), "ㄇㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("meod"), "ㄇㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("meof"), "ㄇㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("meoj"), "ㄇㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mem"), "ㄇㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("memd"), "ㄇㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("memf"), "ㄇㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("memj"), "ㄇㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("men"), "ㄇㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mend"), "ㄇㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("menf"), "ㄇㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("meld"), "ㄇㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("melf"), "ㄇㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("melj"), "ㄇㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mxd"), "ㄇㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mxf"), "ㄇㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mxj"), "ㄇㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fy"), "ㄈㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fyd"), "ㄈㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fyf"), "ㄈㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fyj"), "ㄈㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fhd"), "ㄈㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fa"), "ㄈㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fad"), "ㄈㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("faf"), "ㄈㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("faj"), "ㄈㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fo"), "ㄈㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fod"), "ㄈㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fof"), "ㄈㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("foj"), "ㄈㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fm"), "ㄈㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmd"), "ㄈㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmf"), "ㄈㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fmj"), "ㄈㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fn"), "ㄈㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fnd"), "ㄈㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fnf"), "ㄈㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fnj"), "ㄈㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fns"), "ㄈㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("fk"), "ㄈㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fkd"), "ㄈㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fkf"), "ㄈㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fkj"), "ㄈㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fl"), "ㄈㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fld"), "ㄈㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("flf"), "ㄈㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("flj"), "ㄈㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fewj"), "ㄈㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fx"), "ㄈㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fxd"), "ㄈㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fxf"), "ㄈㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fxj"), "ㄈㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dy"), "ㄉㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dyd"), "ㄉㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dyf"), "ㄉㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dyj"), "ㄉㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dys"), "ㄉㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("dg"), "ㄉㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dgd"), "ㄉㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dgs"), "ㄉㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("di"), "ㄉㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dif"), "ㄉㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dij"), "ㄉㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("daf"), "ㄉㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dw"), "ㄉㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dwd"), "ㄉㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dwf"), "ㄉㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dwj"), "ㄉㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("do"), "ㄉㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dod"), "ㄉㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dof"), "ㄉㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("doj"), "ㄉㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dm"), "ㄉㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dmf"), "ㄉㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dmj"), "ㄉㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dnj"), "ㄉㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dk"), "ㄉㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dkf"), "ㄉㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dkj"), "ㄉㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dl"), "ㄉㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dlf"), "ㄉㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dlj"), "ㄉㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("de"), "ㄉㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ded"), "ㄉㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("def"), "ㄉㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dej"), "ㄉㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("deyf"), "ㄉㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dee"), "ㄉㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("deed"), "ㄉㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("deef"), "ㄉㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("deej"), "ㄉㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dew"), "ㄉㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dewf"), "ㄉㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dewj"), "ㄉㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("deo"), "ㄉㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dem"), "ㄉㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("demd"), "ㄉㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("demf"), "ㄉㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("demj"), "ㄉㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("del"), "ㄉㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("deld"), "ㄉㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("delf"), "ㄉㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("delj"), "ㄉㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dx"), "ㄉㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxd"), "ㄉㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxf"), "ㄉㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxj"), "ㄉㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxh"), "ㄉㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxhd"), "ㄉㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxhf"), "ㄉㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxhj"), "ㄉㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxhs"), "ㄉㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxa"), "ㄉㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxaf"), "ㄉㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxaj"), "ㄉㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxm"), "ㄉㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxmf"), "ㄉㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxmj"), "ㄉㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxn"), "ㄉㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxnf"), "ㄉㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxnj"), "ㄉㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxl"), "ㄉㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxlf"), "ㄉㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dxlj"), "ㄉㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ty"), "ㄊㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tyf"), "ㄊㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tyj"), "ㄊㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tgj"), "ㄊㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ti"), "ㄊㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tid"), "ㄊㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tif"), "ㄊㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tij"), "ㄊㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tis"), "ㄊㄞ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("tw"), "ㄊㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("twd"), "ㄊㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("twf"), "ㄊㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("twj"), "ㄊㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tws"), "ㄊㄠ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("to"), "ㄊㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tod"), "ㄊㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tof"), "ㄊㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("toj"), "ㄊㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tos"), "ㄊㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("tm"), "ㄊㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tmd"), "ㄊㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tmf"), "ㄊㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tmj"), "ㄊㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tk"), "ㄊㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tkd"), "ㄊㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tkf"), "ㄊㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tkj"), "ㄊㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tl"), "ㄊㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tld"), "ㄊㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tlj"), "ㄊㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("te"), "ㄊㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ted"), "ㄊㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tef"), "ㄊㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tej"), "ㄊㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tee"), "ㄊㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("teed"), "ㄊㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("teef"), "ㄊㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("teej"), "ㄊㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tew"), "ㄊㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tewd"), "ㄊㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tewf"), "ㄊㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tewj"), "ㄊㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tem"), "ㄊㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("temd"), "ㄊㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("temf"), "ㄊㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("temj"), "ㄊㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tel"), "ㄊㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("teld"), "ㄊㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("telf"), "ㄊㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("telj"), "ㄊㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tx"), "ㄊㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txd"), "ㄊㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txf"), "ㄊㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txj"), "ㄊㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txh"), "ㄊㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txhd"), "ㄊㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txhf"), "ㄊㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txhj"), "ㄊㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txa"), "ㄊㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txad"), "ㄊㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txaf"), "ㄊㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txaj"), "ㄊㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txm"), "ㄊㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txmd"), "ㄊㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txmf"), "ㄊㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txmj"), "ㄊㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txn"), "ㄊㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txnd"), "ㄊㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txnf"), "ㄊㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txnj"), "ㄊㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txl"), "ㄊㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txld"), "ㄊㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txlf"), "ㄊㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("txlj"), "ㄊㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ny"), "ㄋㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nyd"), "ㄋㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nyf"), "ㄋㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nyj"), "ㄋㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nys"), "ㄋㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ngj"), "ㄋㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ngs"), "ㄋㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("nid"), "ㄋㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nif"), "ㄋㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nij"), "ㄋㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nad"), "ㄋㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("naf"), "ㄋㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("naj"), "ㄋㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nw"), "ㄋㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nwd"), "ㄋㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nwf"), "ㄋㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nwj"), "ㄋㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nod"), "ㄋㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nof"), "ㄋㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("noj"), "ㄋㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nm"), "ㄋㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nmd"), "ㄋㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nmf"), "ㄋㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nmj"), "ㄋㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nnf"), "ㄋㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nnj"), "ㄋㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nk"), "ㄋㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nkd"), "ㄋㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nkf"), "ㄋㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nkj"), "ㄋㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nks"), "ㄋㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("nld"), "ㄋㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nlf"), "ㄋㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ne"), "ㄋㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ned"), "ㄋㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nef"), "ㄋㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nej"), "ㄋㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nee"), "ㄋㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("need"), "ㄋㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("neej"), "ㄋㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("newf"), "ㄋㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("newj"), "ㄋㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("neo"), "ㄋㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("neod"), "ㄋㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("neof"), "ㄋㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("neoj"), "ㄋㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nem"), "ㄋㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nemd"), "ㄋㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nemf"), "ㄋㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nemj"), "ㄋㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nen"), "ㄋㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nend"), "ㄋㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nenf"), "ㄋㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nenj"), "ㄋㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nekd"), "ㄋㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nekf"), "ㄋㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nekj"), "ㄋㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("neld"), "ㄋㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nelf"), "ㄋㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nelj"), "ㄋㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxd"), "ㄋㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxf"), "ㄋㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxj"), "ㄋㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxhd"), "ㄋㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxhf"), "ㄋㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxhj"), "ㄋㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxad"), "ㄋㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxmd"), "ㄋㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxmf"), "ㄋㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxmj"), "ㄋㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxnd"), "ㄋㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxld"), "ㄋㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxlf"), "ㄋㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nxlj"), "ㄋㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nud"), "ㄋㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuf"), "ㄋㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuj"), "ㄋㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuej"), "ㄋㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ly"), "ㄌㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lyd"), "ㄌㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lyf"), "ㄌㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lyj"), "ㄌㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lys"), "ㄌㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lh"), "ㄌㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lhs"), "ㄌㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lg"), "ㄌㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lgd"), "ㄌㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lgj"), "ㄌㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lgs"), "ㄌㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lid"), "ㄌㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lif"), "ㄌㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lij"), "ㄌㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("la"), "ㄌㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lad"), "ㄌㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("laf"), "ㄌㄟˇ") + var c = Tekkon.Composer(arrange: .ofHsu) + XCTAssertEqual(c.cS2RC("bekd"), "ㄅㄧㄤˊ") + XCTAssertEqual(c.cS2RC("bekj"), "ㄅㄧㄤˋ") + XCTAssertEqual(c.cS2RC("dxk"), "ㄉㄨㄤ") + XCTAssertEqual(c.cS2RC("by"), "ㄅㄚ") + XCTAssertEqual(c.cS2RC("byd"), "ㄅㄚˊ") + XCTAssertEqual(c.cS2RC("byf"), "ㄅㄚˇ") + XCTAssertEqual(c.cS2RC("byj"), "ㄅㄚˋ") + XCTAssertEqual(c.cS2RC("bys"), "ㄅㄚ˙") + XCTAssertEqual(c.cS2RC("bh"), "ㄅㄛ") + XCTAssertEqual(c.cS2RC("bhd"), "ㄅㄛˊ") + XCTAssertEqual(c.cS2RC("bhf"), "ㄅㄛˇ") + XCTAssertEqual(c.cS2RC("bhj"), "ㄅㄛˋ") + XCTAssertEqual(c.cS2RC("bhs"), "ㄅㄛ˙") + XCTAssertEqual(c.cS2RC("bi"), "ㄅㄞ") + XCTAssertEqual(c.cS2RC("bid"), "ㄅㄞˊ") + XCTAssertEqual(c.cS2RC("bif"), "ㄅㄞˇ") + XCTAssertEqual(c.cS2RC("bij"), "ㄅㄞˋ") + XCTAssertEqual(c.cS2RC("bis"), "ㄅㄞ˙") + XCTAssertEqual(c.cS2RC("ba"), "ㄅㄟ") + XCTAssertEqual(c.cS2RC("baf"), "ㄅㄟˇ") + XCTAssertEqual(c.cS2RC("baj"), "ㄅㄟˋ") + XCTAssertEqual(c.cS2RC("bas"), "ㄅㄟ˙") + XCTAssertEqual(c.cS2RC("bw"), "ㄅㄠ") + XCTAssertEqual(c.cS2RC("bwd"), "ㄅㄠˊ") + XCTAssertEqual(c.cS2RC("bwf"), "ㄅㄠˇ") + XCTAssertEqual(c.cS2RC("bwj"), "ㄅㄠˋ") + XCTAssertEqual(c.cS2RC("bm"), "ㄅㄢ") + XCTAssertEqual(c.cS2RC("bmf"), "ㄅㄢˇ") + XCTAssertEqual(c.cS2RC("bmj"), "ㄅㄢˋ") + XCTAssertEqual(c.cS2RC("bn"), "ㄅㄣ") + XCTAssertEqual(c.cS2RC("bnf"), "ㄅㄣˇ") + XCTAssertEqual(c.cS2RC("bnj"), "ㄅㄣˋ") + XCTAssertEqual(c.cS2RC("bk"), "ㄅㄤ") + XCTAssertEqual(c.cS2RC("bkf"), "ㄅㄤˇ") + XCTAssertEqual(c.cS2RC("bkj"), "ㄅㄤˋ") + XCTAssertEqual(c.cS2RC("bl"), "ㄅㄥ") + XCTAssertEqual(c.cS2RC("bld"), "ㄅㄥˊ") + XCTAssertEqual(c.cS2RC("blf"), "ㄅㄥˇ") + XCTAssertEqual(c.cS2RC("blj"), "ㄅㄥˋ") + XCTAssertEqual(c.cS2RC("be"), "ㄅㄧ") + XCTAssertEqual(c.cS2RC("bed"), "ㄅㄧˊ") + XCTAssertEqual(c.cS2RC("bef"), "ㄅㄧˇ") + XCTAssertEqual(c.cS2RC("bej"), "ㄅㄧˋ") + XCTAssertEqual(c.cS2RC("bee"), "ㄅㄧㄝ") + XCTAssertEqual(c.cS2RC("beed"), "ㄅㄧㄝˊ") + XCTAssertEqual(c.cS2RC("beef"), "ㄅㄧㄝˇ") + XCTAssertEqual(c.cS2RC("beej"), "ㄅㄧㄝˋ") + XCTAssertEqual(c.cS2RC("bew"), "ㄅㄧㄠ") + XCTAssertEqual(c.cS2RC("bewf"), "ㄅㄧㄠˇ") + XCTAssertEqual(c.cS2RC("bewj"), "ㄅㄧㄠˋ") + XCTAssertEqual(c.cS2RC("bem"), "ㄅㄧㄢ") + XCTAssertEqual(c.cS2RC("bemd"), "ㄅㄧㄢˊ") + XCTAssertEqual(c.cS2RC("bemf"), "ㄅㄧㄢˇ") + XCTAssertEqual(c.cS2RC("bemj"), "ㄅㄧㄢˋ") + XCTAssertEqual(c.cS2RC("ben"), "ㄅㄧㄣ") + XCTAssertEqual(c.cS2RC("benf"), "ㄅㄧㄣˇ") + XCTAssertEqual(c.cS2RC("benj"), "ㄅㄧㄣˋ") + XCTAssertEqual(c.cS2RC("bel"), "ㄅㄧㄥ") + XCTAssertEqual(c.cS2RC("belf"), "ㄅㄧㄥˇ") + XCTAssertEqual(c.cS2RC("belj"), "ㄅㄧㄥˋ") + XCTAssertEqual(c.cS2RC("bx"), "ㄅㄨ") + XCTAssertEqual(c.cS2RC("bxd"), "ㄅㄨˊ") + XCTAssertEqual(c.cS2RC("bxf"), "ㄅㄨˇ") + XCTAssertEqual(c.cS2RC("bxj"), "ㄅㄨˋ") + XCTAssertEqual(c.cS2RC("py"), "ㄆㄚ") + XCTAssertEqual(c.cS2RC("pyd"), "ㄆㄚˊ") + XCTAssertEqual(c.cS2RC("pyf"), "ㄆㄚˇ") + XCTAssertEqual(c.cS2RC("pyj"), "ㄆㄚˋ") + XCTAssertEqual(c.cS2RC("pys"), "ㄆㄚ˙") + XCTAssertEqual(c.cS2RC("ph"), "ㄆㄛ") + XCTAssertEqual(c.cS2RC("phd"), "ㄆㄛˊ") + XCTAssertEqual(c.cS2RC("phf"), "ㄆㄛˇ") + XCTAssertEqual(c.cS2RC("phj"), "ㄆㄛˋ") + XCTAssertEqual(c.cS2RC("pi"), "ㄆㄞ") + XCTAssertEqual(c.cS2RC("pid"), "ㄆㄞˊ") + XCTAssertEqual(c.cS2RC("pif"), "ㄆㄞˇ") + XCTAssertEqual(c.cS2RC("pij"), "ㄆㄞˋ") + XCTAssertEqual(c.cS2RC("pa"), "ㄆㄟ") + XCTAssertEqual(c.cS2RC("pad"), "ㄆㄟˊ") + XCTAssertEqual(c.cS2RC("paf"), "ㄆㄟˇ") + XCTAssertEqual(c.cS2RC("paj"), "ㄆㄟˋ") + XCTAssertEqual(c.cS2RC("pw"), "ㄆㄠ") + XCTAssertEqual(c.cS2RC("pwd"), "ㄆㄠˊ") + XCTAssertEqual(c.cS2RC("pwf"), "ㄆㄠˇ") + XCTAssertEqual(c.cS2RC("pwj"), "ㄆㄠˋ") + XCTAssertEqual(c.cS2RC("po"), "ㄆㄡ") + XCTAssertEqual(c.cS2RC("pod"), "ㄆㄡˊ") + XCTAssertEqual(c.cS2RC("pof"), "ㄆㄡˇ") + XCTAssertEqual(c.cS2RC("poj"), "ㄆㄡˋ") + XCTAssertEqual(c.cS2RC("pm"), "ㄆㄢ") + XCTAssertEqual(c.cS2RC("pmd"), "ㄆㄢˊ") + XCTAssertEqual(c.cS2RC("pmf"), "ㄆㄢˇ") + XCTAssertEqual(c.cS2RC("pmj"), "ㄆㄢˋ") + XCTAssertEqual(c.cS2RC("pn"), "ㄆㄣ") + XCTAssertEqual(c.cS2RC("pnd"), "ㄆㄣˊ") + XCTAssertEqual(c.cS2RC("pnf"), "ㄆㄣˇ") + XCTAssertEqual(c.cS2RC("pnj"), "ㄆㄣˋ") + XCTAssertEqual(c.cS2RC("pk"), "ㄆㄤ") + XCTAssertEqual(c.cS2RC("pkd"), "ㄆㄤˊ") + XCTAssertEqual(c.cS2RC("pkf"), "ㄆㄤˇ") + XCTAssertEqual(c.cS2RC("pkj"), "ㄆㄤˋ") + XCTAssertEqual(c.cS2RC("pl"), "ㄆㄥ") + XCTAssertEqual(c.cS2RC("pld"), "ㄆㄥˊ") + XCTAssertEqual(c.cS2RC("plf"), "ㄆㄥˇ") + XCTAssertEqual(c.cS2RC("plj"), "ㄆㄥˋ") + XCTAssertEqual(c.cS2RC("pe"), "ㄆㄧ") + XCTAssertEqual(c.cS2RC("ped"), "ㄆㄧˊ") + XCTAssertEqual(c.cS2RC("pef"), "ㄆㄧˇ") + XCTAssertEqual(c.cS2RC("pej"), "ㄆㄧˋ") + XCTAssertEqual(c.cS2RC("pey"), "ㄆㄧㄚ") + XCTAssertEqual(c.cS2RC("pee"), "ㄆㄧㄝ") + XCTAssertEqual(c.cS2RC("peef"), "ㄆㄧㄝˇ") + XCTAssertEqual(c.cS2RC("peej"), "ㄆㄧㄝˋ") + XCTAssertEqual(c.cS2RC("pew"), "ㄆㄧㄠ") + XCTAssertEqual(c.cS2RC("pewd"), "ㄆㄧㄠˊ") + XCTAssertEqual(c.cS2RC("pewf"), "ㄆㄧㄠˇ") + XCTAssertEqual(c.cS2RC("pewj"), "ㄆㄧㄠˋ") + XCTAssertEqual(c.cS2RC("pem"), "ㄆㄧㄢ") + XCTAssertEqual(c.cS2RC("pemd"), "ㄆㄧㄢˊ") + XCTAssertEqual(c.cS2RC("pemf"), "ㄆㄧㄢˇ") + XCTAssertEqual(c.cS2RC("pemj"), "ㄆㄧㄢˋ") + XCTAssertEqual(c.cS2RC("pen"), "ㄆㄧㄣ") + XCTAssertEqual(c.cS2RC("pend"), "ㄆㄧㄣˊ") + XCTAssertEqual(c.cS2RC("penf"), "ㄆㄧㄣˇ") + XCTAssertEqual(c.cS2RC("penj"), "ㄆㄧㄣˋ") + XCTAssertEqual(c.cS2RC("pel"), "ㄆㄧㄥ") + XCTAssertEqual(c.cS2RC("peld"), "ㄆㄧㄥˊ") + XCTAssertEqual(c.cS2RC("pelf"), "ㄆㄧㄥˇ") + XCTAssertEqual(c.cS2RC("pelj"), "ㄆㄧㄥˋ") + XCTAssertEqual(c.cS2RC("px"), "ㄆㄨ") + XCTAssertEqual(c.cS2RC("pxd"), "ㄆㄨˊ") + XCTAssertEqual(c.cS2RC("pxf"), "ㄆㄨˇ") + XCTAssertEqual(c.cS2RC("pxj"), "ㄆㄨˋ") + XCTAssertEqual(c.cS2RC("my"), "ㄇㄚ") + XCTAssertEqual(c.cS2RC("myd"), "ㄇㄚˊ") + XCTAssertEqual(c.cS2RC("myf"), "ㄇㄚˇ") + XCTAssertEqual(c.cS2RC("myj"), "ㄇㄚˋ") + XCTAssertEqual(c.cS2RC("mys"), "ㄇㄚ˙") + XCTAssertEqual(c.cS2RC("mh"), "ㄇㄛ") + XCTAssertEqual(c.cS2RC("mhd"), "ㄇㄛˊ") + XCTAssertEqual(c.cS2RC("mhf"), "ㄇㄛˇ") + XCTAssertEqual(c.cS2RC("mhj"), "ㄇㄛˋ") + XCTAssertEqual(c.cS2RC("mhs"), "ㄇㄛ˙") + XCTAssertEqual(c.cS2RC("mg"), "ㄇㄜ") + XCTAssertEqual(c.cS2RC("mgj"), "ㄇㄜˋ") + XCTAssertEqual(c.cS2RC("mgs"), "ㄇㄜ˙") + XCTAssertEqual(c.cS2RC("mi"), "ㄇㄞ") + XCTAssertEqual(c.cS2RC("mid"), "ㄇㄞˊ") + XCTAssertEqual(c.cS2RC("mif"), "ㄇㄞˇ") + XCTAssertEqual(c.cS2RC("mij"), "ㄇㄞˋ") + XCTAssertEqual(c.cS2RC("mad"), "ㄇㄟˊ") + XCTAssertEqual(c.cS2RC("maf"), "ㄇㄟˇ") + XCTAssertEqual(c.cS2RC("maj"), "ㄇㄟˋ") + XCTAssertEqual(c.cS2RC("mw"), "ㄇㄠ") + XCTAssertEqual(c.cS2RC("mwd"), "ㄇㄠˊ") + XCTAssertEqual(c.cS2RC("mwf"), "ㄇㄠˇ") + XCTAssertEqual(c.cS2RC("mwj"), "ㄇㄠˋ") + XCTAssertEqual(c.cS2RC("mod"), "ㄇㄡˊ") + XCTAssertEqual(c.cS2RC("mof"), "ㄇㄡˇ") + XCTAssertEqual(c.cS2RC("moj"), "ㄇㄡˋ") + XCTAssertEqual(c.cS2RC("mm"), "ㄇㄢ") + XCTAssertEqual(c.cS2RC("mmd"), "ㄇㄢˊ") + XCTAssertEqual(c.cS2RC("mmf"), "ㄇㄢˇ") + XCTAssertEqual(c.cS2RC("mmj"), "ㄇㄢˋ") + XCTAssertEqual(c.cS2RC("mn"), "ㄇㄣ") + XCTAssertEqual(c.cS2RC("mnd"), "ㄇㄣˊ") + XCTAssertEqual(c.cS2RC("mnf"), "ㄇㄣˇ") + XCTAssertEqual(c.cS2RC("mnj"), "ㄇㄣˋ") + XCTAssertEqual(c.cS2RC("mns"), "ㄇㄣ˙") + XCTAssertEqual(c.cS2RC("mk"), "ㄇㄤ") + XCTAssertEqual(c.cS2RC("mkd"), "ㄇㄤˊ") + XCTAssertEqual(c.cS2RC("mkf"), "ㄇㄤˇ") + XCTAssertEqual(c.cS2RC("mkj"), "ㄇㄤˋ") + XCTAssertEqual(c.cS2RC("ml"), "ㄇㄥ") + XCTAssertEqual(c.cS2RC("mld"), "ㄇㄥˊ") + XCTAssertEqual(c.cS2RC("mlf"), "ㄇㄥˇ") + XCTAssertEqual(c.cS2RC("mlj"), "ㄇㄥˋ") + XCTAssertEqual(c.cS2RC("me"), "ㄇㄧ") + XCTAssertEqual(c.cS2RC("med"), "ㄇㄧˊ") + XCTAssertEqual(c.cS2RC("mef"), "ㄇㄧˇ") + XCTAssertEqual(c.cS2RC("mej"), "ㄇㄧˋ") + XCTAssertEqual(c.cS2RC("mee"), "ㄇㄧㄝ") + XCTAssertEqual(c.cS2RC("meed"), "ㄇㄧㄝˊ") + XCTAssertEqual(c.cS2RC("meej"), "ㄇㄧㄝˋ") + XCTAssertEqual(c.cS2RC("mew"), "ㄇㄧㄠ") + XCTAssertEqual(c.cS2RC("mewd"), "ㄇㄧㄠˊ") + XCTAssertEqual(c.cS2RC("mewf"), "ㄇㄧㄠˇ") + XCTAssertEqual(c.cS2RC("mewj"), "ㄇㄧㄠˋ") + XCTAssertEqual(c.cS2RC("meod"), "ㄇㄧㄡˊ") + XCTAssertEqual(c.cS2RC("meof"), "ㄇㄧㄡˇ") + XCTAssertEqual(c.cS2RC("meoj"), "ㄇㄧㄡˋ") + XCTAssertEqual(c.cS2RC("mem"), "ㄇㄧㄢ") + XCTAssertEqual(c.cS2RC("memd"), "ㄇㄧㄢˊ") + XCTAssertEqual(c.cS2RC("memf"), "ㄇㄧㄢˇ") + XCTAssertEqual(c.cS2RC("memj"), "ㄇㄧㄢˋ") + XCTAssertEqual(c.cS2RC("men"), "ㄇㄧㄣ") + XCTAssertEqual(c.cS2RC("mend"), "ㄇㄧㄣˊ") + XCTAssertEqual(c.cS2RC("menf"), "ㄇㄧㄣˇ") + XCTAssertEqual(c.cS2RC("meld"), "ㄇㄧㄥˊ") + XCTAssertEqual(c.cS2RC("melf"), "ㄇㄧㄥˇ") + XCTAssertEqual(c.cS2RC("melj"), "ㄇㄧㄥˋ") + XCTAssertEqual(c.cS2RC("mxd"), "ㄇㄨˊ") + XCTAssertEqual(c.cS2RC("mxf"), "ㄇㄨˇ") + XCTAssertEqual(c.cS2RC("mxj"), "ㄇㄨˋ") + XCTAssertEqual(c.cS2RC("fy"), "ㄈㄚ") + XCTAssertEqual(c.cS2RC("fyd"), "ㄈㄚˊ") + XCTAssertEqual(c.cS2RC("fyf"), "ㄈㄚˇ") + XCTAssertEqual(c.cS2RC("fyj"), "ㄈㄚˋ") + XCTAssertEqual(c.cS2RC("fhd"), "ㄈㄛˊ") + XCTAssertEqual(c.cS2RC("fa"), "ㄈㄟ") + XCTAssertEqual(c.cS2RC("fad"), "ㄈㄟˊ") + XCTAssertEqual(c.cS2RC("faf"), "ㄈㄟˇ") + XCTAssertEqual(c.cS2RC("faj"), "ㄈㄟˋ") + XCTAssertEqual(c.cS2RC("fo"), "ㄈㄡ") + XCTAssertEqual(c.cS2RC("fod"), "ㄈㄡˊ") + XCTAssertEqual(c.cS2RC("fof"), "ㄈㄡˇ") + XCTAssertEqual(c.cS2RC("foj"), "ㄈㄡˋ") + XCTAssertEqual(c.cS2RC("fm"), "ㄈㄢ") + XCTAssertEqual(c.cS2RC("fmd"), "ㄈㄢˊ") + XCTAssertEqual(c.cS2RC("fmf"), "ㄈㄢˇ") + XCTAssertEqual(c.cS2RC("fmj"), "ㄈㄢˋ") + XCTAssertEqual(c.cS2RC("fn"), "ㄈㄣ") + XCTAssertEqual(c.cS2RC("fnd"), "ㄈㄣˊ") + XCTAssertEqual(c.cS2RC("fnf"), "ㄈㄣˇ") + XCTAssertEqual(c.cS2RC("fnj"), "ㄈㄣˋ") + XCTAssertEqual(c.cS2RC("fns"), "ㄈㄣ˙") + XCTAssertEqual(c.cS2RC("fk"), "ㄈㄤ") + XCTAssertEqual(c.cS2RC("fkd"), "ㄈㄤˊ") + XCTAssertEqual(c.cS2RC("fkf"), "ㄈㄤˇ") + XCTAssertEqual(c.cS2RC("fkj"), "ㄈㄤˋ") + XCTAssertEqual(c.cS2RC("fl"), "ㄈㄥ") + XCTAssertEqual(c.cS2RC("fld"), "ㄈㄥˊ") + XCTAssertEqual(c.cS2RC("flf"), "ㄈㄥˇ") + XCTAssertEqual(c.cS2RC("flj"), "ㄈㄥˋ") + XCTAssertEqual(c.cS2RC("fewj"), "ㄈㄧㄠˋ") + XCTAssertEqual(c.cS2RC("fx"), "ㄈㄨ") + XCTAssertEqual(c.cS2RC("fxd"), "ㄈㄨˊ") + XCTAssertEqual(c.cS2RC("fxf"), "ㄈㄨˇ") + XCTAssertEqual(c.cS2RC("fxj"), "ㄈㄨˋ") + XCTAssertEqual(c.cS2RC("dy"), "ㄉㄚ") + XCTAssertEqual(c.cS2RC("dyd"), "ㄉㄚˊ") + XCTAssertEqual(c.cS2RC("dyf"), "ㄉㄚˇ") + XCTAssertEqual(c.cS2RC("dyj"), "ㄉㄚˋ") + XCTAssertEqual(c.cS2RC("dys"), "ㄉㄚ˙") + XCTAssertEqual(c.cS2RC("dg"), "ㄉㄜ") + XCTAssertEqual(c.cS2RC("dgd"), "ㄉㄜˊ") + XCTAssertEqual(c.cS2RC("dgs"), "ㄉㄜ˙") + XCTAssertEqual(c.cS2RC("di"), "ㄉㄞ") + XCTAssertEqual(c.cS2RC("dif"), "ㄉㄞˇ") + XCTAssertEqual(c.cS2RC("dij"), "ㄉㄞˋ") + XCTAssertEqual(c.cS2RC("daf"), "ㄉㄟˇ") + XCTAssertEqual(c.cS2RC("dw"), "ㄉㄠ") + XCTAssertEqual(c.cS2RC("dwd"), "ㄉㄠˊ") + XCTAssertEqual(c.cS2RC("dwf"), "ㄉㄠˇ") + XCTAssertEqual(c.cS2RC("dwj"), "ㄉㄠˋ") + XCTAssertEqual(c.cS2RC("do"), "ㄉㄡ") + XCTAssertEqual(c.cS2RC("dod"), "ㄉㄡˊ") + XCTAssertEqual(c.cS2RC("dof"), "ㄉㄡˇ") + XCTAssertEqual(c.cS2RC("doj"), "ㄉㄡˋ") + XCTAssertEqual(c.cS2RC("dm"), "ㄉㄢ") + XCTAssertEqual(c.cS2RC("dmf"), "ㄉㄢˇ") + XCTAssertEqual(c.cS2RC("dmj"), "ㄉㄢˋ") + XCTAssertEqual(c.cS2RC("dnj"), "ㄉㄣˋ") + XCTAssertEqual(c.cS2RC("dk"), "ㄉㄤ") + XCTAssertEqual(c.cS2RC("dkf"), "ㄉㄤˇ") + XCTAssertEqual(c.cS2RC("dkj"), "ㄉㄤˋ") + XCTAssertEqual(c.cS2RC("dl"), "ㄉㄥ") + XCTAssertEqual(c.cS2RC("dlf"), "ㄉㄥˇ") + XCTAssertEqual(c.cS2RC("dlj"), "ㄉㄥˋ") + XCTAssertEqual(c.cS2RC("de"), "ㄉㄧ") + XCTAssertEqual(c.cS2RC("ded"), "ㄉㄧˊ") + XCTAssertEqual(c.cS2RC("def"), "ㄉㄧˇ") + XCTAssertEqual(c.cS2RC("dej"), "ㄉㄧˋ") + XCTAssertEqual(c.cS2RC("deyf"), "ㄉㄧㄚˇ") + XCTAssertEqual(c.cS2RC("dee"), "ㄉㄧㄝ") + XCTAssertEqual(c.cS2RC("deed"), "ㄉㄧㄝˊ") + XCTAssertEqual(c.cS2RC("deef"), "ㄉㄧㄝˇ") + XCTAssertEqual(c.cS2RC("deej"), "ㄉㄧㄝˋ") + XCTAssertEqual(c.cS2RC("dew"), "ㄉㄧㄠ") + XCTAssertEqual(c.cS2RC("dewf"), "ㄉㄧㄠˇ") + XCTAssertEqual(c.cS2RC("dewj"), "ㄉㄧㄠˋ") + XCTAssertEqual(c.cS2RC("deo"), "ㄉㄧㄡ") + XCTAssertEqual(c.cS2RC("dem"), "ㄉㄧㄢ") + XCTAssertEqual(c.cS2RC("demd"), "ㄉㄧㄢˊ") + XCTAssertEqual(c.cS2RC("demf"), "ㄉㄧㄢˇ") + XCTAssertEqual(c.cS2RC("demj"), "ㄉㄧㄢˋ") + XCTAssertEqual(c.cS2RC("del"), "ㄉㄧㄥ") + XCTAssertEqual(c.cS2RC("deld"), "ㄉㄧㄥˊ") + XCTAssertEqual(c.cS2RC("delf"), "ㄉㄧㄥˇ") + XCTAssertEqual(c.cS2RC("delj"), "ㄉㄧㄥˋ") + XCTAssertEqual(c.cS2RC("dx"), "ㄉㄨ") + XCTAssertEqual(c.cS2RC("dxd"), "ㄉㄨˊ") + XCTAssertEqual(c.cS2RC("dxf"), "ㄉㄨˇ") + XCTAssertEqual(c.cS2RC("dxj"), "ㄉㄨˋ") + XCTAssertEqual(c.cS2RC("dxh"), "ㄉㄨㄛ") + XCTAssertEqual(c.cS2RC("dxhd"), "ㄉㄨㄛˊ") + XCTAssertEqual(c.cS2RC("dxhf"), "ㄉㄨㄛˇ") + XCTAssertEqual(c.cS2RC("dxhj"), "ㄉㄨㄛˋ") + XCTAssertEqual(c.cS2RC("dxhs"), "ㄉㄨㄛ˙") + XCTAssertEqual(c.cS2RC("dxa"), "ㄉㄨㄟ") + XCTAssertEqual(c.cS2RC("dxaf"), "ㄉㄨㄟˇ") + XCTAssertEqual(c.cS2RC("dxaj"), "ㄉㄨㄟˋ") + XCTAssertEqual(c.cS2RC("dxm"), "ㄉㄨㄢ") + XCTAssertEqual(c.cS2RC("dxmf"), "ㄉㄨㄢˇ") + XCTAssertEqual(c.cS2RC("dxmj"), "ㄉㄨㄢˋ") + XCTAssertEqual(c.cS2RC("dxn"), "ㄉㄨㄣ") + XCTAssertEqual(c.cS2RC("dxnf"), "ㄉㄨㄣˇ") + XCTAssertEqual(c.cS2RC("dxnj"), "ㄉㄨㄣˋ") + XCTAssertEqual(c.cS2RC("dxl"), "ㄉㄨㄥ") + XCTAssertEqual(c.cS2RC("dxlf"), "ㄉㄨㄥˇ") + XCTAssertEqual(c.cS2RC("dxlj"), "ㄉㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ty"), "ㄊㄚ") + XCTAssertEqual(c.cS2RC("tyf"), "ㄊㄚˇ") + XCTAssertEqual(c.cS2RC("tyj"), "ㄊㄚˋ") + XCTAssertEqual(c.cS2RC("tgj"), "ㄊㄜˋ") + XCTAssertEqual(c.cS2RC("ti"), "ㄊㄞ") + XCTAssertEqual(c.cS2RC("tid"), "ㄊㄞˊ") + XCTAssertEqual(c.cS2RC("tif"), "ㄊㄞˇ") + XCTAssertEqual(c.cS2RC("tij"), "ㄊㄞˋ") + XCTAssertEqual(c.cS2RC("tis"), "ㄊㄞ˙") + XCTAssertEqual(c.cS2RC("tw"), "ㄊㄠ") + XCTAssertEqual(c.cS2RC("twd"), "ㄊㄠˊ") + XCTAssertEqual(c.cS2RC("twf"), "ㄊㄠˇ") + XCTAssertEqual(c.cS2RC("twj"), "ㄊㄠˋ") + XCTAssertEqual(c.cS2RC("tws"), "ㄊㄠ˙") + XCTAssertEqual(c.cS2RC("to"), "ㄊㄡ") + XCTAssertEqual(c.cS2RC("tod"), "ㄊㄡˊ") + XCTAssertEqual(c.cS2RC("tof"), "ㄊㄡˇ") + XCTAssertEqual(c.cS2RC("toj"), "ㄊㄡˋ") + XCTAssertEqual(c.cS2RC("tos"), "ㄊㄡ˙") + XCTAssertEqual(c.cS2RC("tm"), "ㄊㄢ") + XCTAssertEqual(c.cS2RC("tmd"), "ㄊㄢˊ") + XCTAssertEqual(c.cS2RC("tmf"), "ㄊㄢˇ") + XCTAssertEqual(c.cS2RC("tmj"), "ㄊㄢˋ") + XCTAssertEqual(c.cS2RC("tk"), "ㄊㄤ") + XCTAssertEqual(c.cS2RC("tkd"), "ㄊㄤˊ") + XCTAssertEqual(c.cS2RC("tkf"), "ㄊㄤˇ") + XCTAssertEqual(c.cS2RC("tkj"), "ㄊㄤˋ") + XCTAssertEqual(c.cS2RC("tl"), "ㄊㄥ") + XCTAssertEqual(c.cS2RC("tld"), "ㄊㄥˊ") + XCTAssertEqual(c.cS2RC("tlj"), "ㄊㄥˋ") + XCTAssertEqual(c.cS2RC("te"), "ㄊㄧ") + XCTAssertEqual(c.cS2RC("ted"), "ㄊㄧˊ") + XCTAssertEqual(c.cS2RC("tef"), "ㄊㄧˇ") + XCTAssertEqual(c.cS2RC("tej"), "ㄊㄧˋ") + XCTAssertEqual(c.cS2RC("tee"), "ㄊㄧㄝ") + XCTAssertEqual(c.cS2RC("teed"), "ㄊㄧㄝˊ") + XCTAssertEqual(c.cS2RC("teef"), "ㄊㄧㄝˇ") + XCTAssertEqual(c.cS2RC("teej"), "ㄊㄧㄝˋ") + XCTAssertEqual(c.cS2RC("tew"), "ㄊㄧㄠ") + XCTAssertEqual(c.cS2RC("tewd"), "ㄊㄧㄠˊ") + XCTAssertEqual(c.cS2RC("tewf"), "ㄊㄧㄠˇ") + XCTAssertEqual(c.cS2RC("tewj"), "ㄊㄧㄠˋ") + XCTAssertEqual(c.cS2RC("tem"), "ㄊㄧㄢ") + XCTAssertEqual(c.cS2RC("temd"), "ㄊㄧㄢˊ") + XCTAssertEqual(c.cS2RC("temf"), "ㄊㄧㄢˇ") + XCTAssertEqual(c.cS2RC("temj"), "ㄊㄧㄢˋ") + XCTAssertEqual(c.cS2RC("tel"), "ㄊㄧㄥ") + XCTAssertEqual(c.cS2RC("teld"), "ㄊㄧㄥˊ") + XCTAssertEqual(c.cS2RC("telf"), "ㄊㄧㄥˇ") + XCTAssertEqual(c.cS2RC("telj"), "ㄊㄧㄥˋ") + XCTAssertEqual(c.cS2RC("tx"), "ㄊㄨ") + XCTAssertEqual(c.cS2RC("txd"), "ㄊㄨˊ") + XCTAssertEqual(c.cS2RC("txf"), "ㄊㄨˇ") + XCTAssertEqual(c.cS2RC("txj"), "ㄊㄨˋ") + XCTAssertEqual(c.cS2RC("txh"), "ㄊㄨㄛ") + XCTAssertEqual(c.cS2RC("txhd"), "ㄊㄨㄛˊ") + XCTAssertEqual(c.cS2RC("txhf"), "ㄊㄨㄛˇ") + XCTAssertEqual(c.cS2RC("txhj"), "ㄊㄨㄛˋ") + XCTAssertEqual(c.cS2RC("txa"), "ㄊㄨㄟ") + XCTAssertEqual(c.cS2RC("txad"), "ㄊㄨㄟˊ") + XCTAssertEqual(c.cS2RC("txaf"), "ㄊㄨㄟˇ") + XCTAssertEqual(c.cS2RC("txaj"), "ㄊㄨㄟˋ") + XCTAssertEqual(c.cS2RC("txm"), "ㄊㄨㄢ") + XCTAssertEqual(c.cS2RC("txmd"), "ㄊㄨㄢˊ") + XCTAssertEqual(c.cS2RC("txmf"), "ㄊㄨㄢˇ") + XCTAssertEqual(c.cS2RC("txmj"), "ㄊㄨㄢˋ") + XCTAssertEqual(c.cS2RC("txn"), "ㄊㄨㄣ") + XCTAssertEqual(c.cS2RC("txnd"), "ㄊㄨㄣˊ") + XCTAssertEqual(c.cS2RC("txnf"), "ㄊㄨㄣˇ") + XCTAssertEqual(c.cS2RC("txnj"), "ㄊㄨㄣˋ") + XCTAssertEqual(c.cS2RC("txl"), "ㄊㄨㄥ") + XCTAssertEqual(c.cS2RC("txld"), "ㄊㄨㄥˊ") + XCTAssertEqual(c.cS2RC("txlf"), "ㄊㄨㄥˇ") + XCTAssertEqual(c.cS2RC("txlj"), "ㄊㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ny"), "ㄋㄚ") + XCTAssertEqual(c.cS2RC("nyd"), "ㄋㄚˊ") + XCTAssertEqual(c.cS2RC("nyf"), "ㄋㄚˇ") + XCTAssertEqual(c.cS2RC("nyj"), "ㄋㄚˋ") + XCTAssertEqual(c.cS2RC("nys"), "ㄋㄚ˙") + XCTAssertEqual(c.cS2RC("ngj"), "ㄋㄜˋ") + XCTAssertEqual(c.cS2RC("ngs"), "ㄋㄜ˙") + XCTAssertEqual(c.cS2RC("nid"), "ㄋㄞˊ") + XCTAssertEqual(c.cS2RC("nif"), "ㄋㄞˇ") + XCTAssertEqual(c.cS2RC("nij"), "ㄋㄞˋ") + XCTAssertEqual(c.cS2RC("nad"), "ㄋㄟˊ") + XCTAssertEqual(c.cS2RC("naf"), "ㄋㄟˇ") + XCTAssertEqual(c.cS2RC("naj"), "ㄋㄟˋ") + XCTAssertEqual(c.cS2RC("nw"), "ㄋㄠ") + XCTAssertEqual(c.cS2RC("nwd"), "ㄋㄠˊ") + XCTAssertEqual(c.cS2RC("nwf"), "ㄋㄠˇ") + XCTAssertEqual(c.cS2RC("nwj"), "ㄋㄠˋ") + XCTAssertEqual(c.cS2RC("nod"), "ㄋㄡˊ") + XCTAssertEqual(c.cS2RC("nof"), "ㄋㄡˇ") + XCTAssertEqual(c.cS2RC("noj"), "ㄋㄡˋ") + XCTAssertEqual(c.cS2RC("nm"), "ㄋㄢ") + XCTAssertEqual(c.cS2RC("nmd"), "ㄋㄢˊ") + XCTAssertEqual(c.cS2RC("nmf"), "ㄋㄢˇ") + XCTAssertEqual(c.cS2RC("nmj"), "ㄋㄢˋ") + XCTAssertEqual(c.cS2RC("nnf"), "ㄋㄣˇ") + XCTAssertEqual(c.cS2RC("nnj"), "ㄋㄣˋ") + XCTAssertEqual(c.cS2RC("nk"), "ㄋㄤ") + XCTAssertEqual(c.cS2RC("nkd"), "ㄋㄤˊ") + XCTAssertEqual(c.cS2RC("nkf"), "ㄋㄤˇ") + XCTAssertEqual(c.cS2RC("nkj"), "ㄋㄤˋ") + XCTAssertEqual(c.cS2RC("nks"), "ㄋㄤ˙") + XCTAssertEqual(c.cS2RC("nld"), "ㄋㄥˊ") + XCTAssertEqual(c.cS2RC("nlf"), "ㄋㄥˇ") + XCTAssertEqual(c.cS2RC("ne"), "ㄋㄧ") + XCTAssertEqual(c.cS2RC("ned"), "ㄋㄧˊ") + XCTAssertEqual(c.cS2RC("nef"), "ㄋㄧˇ") + XCTAssertEqual(c.cS2RC("nej"), "ㄋㄧˋ") + XCTAssertEqual(c.cS2RC("nee"), "ㄋㄧㄝ") + XCTAssertEqual(c.cS2RC("need"), "ㄋㄧㄝˊ") + XCTAssertEqual(c.cS2RC("neej"), "ㄋㄧㄝˋ") + XCTAssertEqual(c.cS2RC("newf"), "ㄋㄧㄠˇ") + XCTAssertEqual(c.cS2RC("newj"), "ㄋㄧㄠˋ") + XCTAssertEqual(c.cS2RC("neo"), "ㄋㄧㄡ") + XCTAssertEqual(c.cS2RC("neod"), "ㄋㄧㄡˊ") + XCTAssertEqual(c.cS2RC("neof"), "ㄋㄧㄡˇ") + XCTAssertEqual(c.cS2RC("neoj"), "ㄋㄧㄡˋ") + XCTAssertEqual(c.cS2RC("nem"), "ㄋㄧㄢ") + XCTAssertEqual(c.cS2RC("nemd"), "ㄋㄧㄢˊ") + XCTAssertEqual(c.cS2RC("nemf"), "ㄋㄧㄢˇ") + XCTAssertEqual(c.cS2RC("nemj"), "ㄋㄧㄢˋ") + XCTAssertEqual(c.cS2RC("nen"), "ㄋㄧㄣ") + XCTAssertEqual(c.cS2RC("nend"), "ㄋㄧㄣˊ") + XCTAssertEqual(c.cS2RC("nenf"), "ㄋㄧㄣˇ") + XCTAssertEqual(c.cS2RC("nenj"), "ㄋㄧㄣˋ") + XCTAssertEqual(c.cS2RC("nekd"), "ㄋㄧㄤˊ") + XCTAssertEqual(c.cS2RC("nekf"), "ㄋㄧㄤˇ") + XCTAssertEqual(c.cS2RC("nekj"), "ㄋㄧㄤˋ") + XCTAssertEqual(c.cS2RC("neld"), "ㄋㄧㄥˊ") + XCTAssertEqual(c.cS2RC("nelf"), "ㄋㄧㄥˇ") + XCTAssertEqual(c.cS2RC("nelj"), "ㄋㄧㄥˋ") + XCTAssertEqual(c.cS2RC("nxd"), "ㄋㄨˊ") + XCTAssertEqual(c.cS2RC("nxf"), "ㄋㄨˇ") + XCTAssertEqual(c.cS2RC("nxj"), "ㄋㄨˋ") + XCTAssertEqual(c.cS2RC("nxhd"), "ㄋㄨㄛˊ") + XCTAssertEqual(c.cS2RC("nxhf"), "ㄋㄨㄛˇ") + XCTAssertEqual(c.cS2RC("nxhj"), "ㄋㄨㄛˋ") + XCTAssertEqual(c.cS2RC("nxad"), "ㄋㄨㄟˊ") + XCTAssertEqual(c.cS2RC("nxmd"), "ㄋㄨㄢˊ") + XCTAssertEqual(c.cS2RC("nxmf"), "ㄋㄨㄢˇ") + XCTAssertEqual(c.cS2RC("nxmj"), "ㄋㄨㄢˋ") + XCTAssertEqual(c.cS2RC("nxnd"), "ㄋㄨㄣˊ") + XCTAssertEqual(c.cS2RC("nxld"), "ㄋㄨㄥˊ") + XCTAssertEqual(c.cS2RC("nxlf"), "ㄋㄨㄥˇ") + XCTAssertEqual(c.cS2RC("nxlj"), "ㄋㄨㄥˋ") + XCTAssertEqual(c.cS2RC("nud"), "ㄋㄩˊ") + XCTAssertEqual(c.cS2RC("nuf"), "ㄋㄩˇ") + XCTAssertEqual(c.cS2RC("nuj"), "ㄋㄩˋ") + XCTAssertEqual(c.cS2RC("nuej"), "ㄋㄩㄝˋ") + XCTAssertEqual(c.cS2RC("ly"), "ㄌㄚ") + XCTAssertEqual(c.cS2RC("lyd"), "ㄌㄚˊ") + XCTAssertEqual(c.cS2RC("lyf"), "ㄌㄚˇ") + XCTAssertEqual(c.cS2RC("lyj"), "ㄌㄚˋ") + XCTAssertEqual(c.cS2RC("lys"), "ㄌㄚ˙") + XCTAssertEqual(c.cS2RC("lh"), "ㄌㄛ") + XCTAssertEqual(c.cS2RC("lhs"), "ㄌㄛ˙") + XCTAssertEqual(c.cS2RC("lg"), "ㄌㄜ") + XCTAssertEqual(c.cS2RC("lgd"), "ㄌㄜˊ") + XCTAssertEqual(c.cS2RC("lgj"), "ㄌㄜˋ") + XCTAssertEqual(c.cS2RC("lgs"), "ㄌㄜ˙") + XCTAssertEqual(c.cS2RC("lid"), "ㄌㄞˊ") + XCTAssertEqual(c.cS2RC("lif"), "ㄌㄞˇ") + XCTAssertEqual(c.cS2RC("lij"), "ㄌㄞˋ") + XCTAssertEqual(c.cS2RC("la"), "ㄌㄟ") + XCTAssertEqual(c.cS2RC("lad"), "ㄌㄟˊ") + XCTAssertEqual(c.cS2RC("laf"), "ㄌㄟˇ") } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_B.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_B.swift index 0a2c8d67..a7bf36e7 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_B.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_B.swift @@ -12,489 +12,489 @@ import XCTest extension TekkonTestsKeyboardArrangments { func testHsuKeysB() throws { - var composer = Tekkon.Composer(arrange: .ofHsu) - XCTAssertEqual(composer.convertSequenceToRawComposition("laj"), "ㄌㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("las"), "ㄌㄟ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lw"), "ㄌㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lwd"), "ㄌㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lwf"), "ㄌㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lwj"), "ㄌㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lo"), "ㄌㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lod"), "ㄌㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lof"), "ㄌㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("loj"), "ㄌㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("los"), "ㄌㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lmd"), "ㄌㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lmf"), "ㄌㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lmj"), "ㄌㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lk"), "ㄌㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lkd"), "ㄌㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lkf"), "ㄌㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lkj"), "ㄌㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ll"), "ㄌㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lld"), "ㄌㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("llf"), "ㄌㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("llj"), "ㄌㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("le"), "ㄌㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("led"), "ㄌㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lef"), "ㄌㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lej"), "ㄌㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("les"), "ㄌㄧ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("leyf"), "ㄌㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lee"), "ㄌㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("leed"), "ㄌㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("leef"), "ㄌㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("leej"), "ㄌㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lew"), "ㄌㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lewd"), "ㄌㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lewf"), "ㄌㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lewj"), "ㄌㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("leo"), "ㄌㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("leod"), "ㄌㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("leof"), "ㄌㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("leoj"), "ㄌㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lem"), "ㄌㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lemd"), "ㄌㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lemf"), "ㄌㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lemj"), "ㄌㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lend"), "ㄌㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lenf"), "ㄌㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lenj"), "ㄌㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lekd"), "ㄌㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lekf"), "ㄌㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lekj"), "ㄌㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lel"), "ㄌㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("leld"), "ㄌㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lelf"), "ㄌㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lelj"), "ㄌㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lx"), "ㄌㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxd"), "ㄌㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxf"), "ㄌㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxj"), "ㄌㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxh"), "ㄌㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxhd"), "ㄌㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxhf"), "ㄌㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxhj"), "ㄌㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxhs"), "ㄌㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxmd"), "ㄌㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxmf"), "ㄌㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxmj"), "ㄌㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxn"), "ㄌㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxnd"), "ㄌㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxnf"), "ㄌㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxnj"), "ㄌㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxl"), "ㄌㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxld"), "ㄌㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxlf"), "ㄌㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lxlj"), "ㄌㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lu"), "ㄌㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lud"), "ㄌㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luf"), "ㄌㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luj"), "ㄌㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lue"), "ㄌㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luef"), "ㄌㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luej"), "ㄌㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lumd"), "ㄌㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lumf"), "ㄌㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gy"), "ㄍㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gyd"), "ㄍㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gyf"), "ㄍㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gyj"), "ㄍㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gys"), "ㄍㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("gg"), "ㄍㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ggd"), "ㄍㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ggf"), "ㄍㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ggj"), "ㄍㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ggs"), "ㄍㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("gi"), "ㄍㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gif"), "ㄍㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gij"), "ㄍㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gaf"), "ㄍㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gw"), "ㄍㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gwf"), "ㄍㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gwj"), "ㄍㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("go"), "ㄍㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gof"), "ㄍㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("goj"), "ㄍㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gm"), "ㄍㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gmf"), "ㄍㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gmj"), "ㄍㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gn"), "ㄍㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gnd"), "ㄍㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gnf"), "ㄍㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gnj"), "ㄍㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gk"), "ㄍㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gkf"), "ㄍㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gkj"), "ㄍㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gl"), "ㄍㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("glf"), "ㄍㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("glj"), "ㄍㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gx"), "ㄍㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxd"), "ㄍㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxf"), "ㄍㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxj"), "ㄍㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxy"), "ㄍㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxyd"), "ㄍㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxyf"), "ㄍㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxyj"), "ㄍㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxh"), "ㄍㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxhd"), "ㄍㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxhf"), "ㄍㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxhj"), "ㄍㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxi"), "ㄍㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxif"), "ㄍㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxij"), "ㄍㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxa"), "ㄍㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxaf"), "ㄍㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxaj"), "ㄍㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxm"), "ㄍㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxmf"), "ㄍㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxmj"), "ㄍㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxn"), "ㄍㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxnf"), "ㄍㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxnj"), "ㄍㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxk"), "ㄍㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxkf"), "ㄍㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxkj"), "ㄍㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxl"), "ㄍㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxld"), "ㄍㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxlf"), "ㄍㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gxlj"), "ㄍㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ky"), "ㄎㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kyf"), "ㄎㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kyj"), "ㄎㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kg"), "ㄎㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kgd"), "ㄎㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kgf"), "ㄎㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kgj"), "ㄎㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ki"), "ㄎㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kif"), "ㄎㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kij"), "ㄎㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kw"), "ㄎㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kwf"), "ㄎㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kwj"), "ㄎㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ko"), "ㄎㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kof"), "ㄎㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("koj"), "ㄎㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("km"), "ㄎㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kmf"), "ㄎㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kmj"), "ㄎㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kn"), "ㄎㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("knf"), "ㄎㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("knj"), "ㄎㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kk"), "ㄎㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kkd"), "ㄎㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kkf"), "ㄎㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kkj"), "ㄎㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kl"), "ㄎㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("klf"), "ㄎㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kx"), "ㄎㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxd"), "ㄎㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxf"), "ㄎㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxj"), "ㄎㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxy"), "ㄎㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxyf"), "ㄎㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxyj"), "ㄎㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxhj"), "ㄎㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxi"), "ㄎㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxif"), "ㄎㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxij"), "ㄎㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxa"), "ㄎㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxad"), "ㄎㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxaf"), "ㄎㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxaj"), "ㄎㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxm"), "ㄎㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxmf"), "ㄎㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxmj"), "ㄎㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxn"), "ㄎㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxnf"), "ㄎㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxnj"), "ㄎㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxk"), "ㄎㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxkd"), "ㄎㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxkf"), "ㄎㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxkj"), "ㄎㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxl"), "ㄎㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxlf"), "ㄎㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kxlj"), "ㄎㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hy"), "ㄏㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hyd"), "ㄏㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hyf"), "ㄏㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hg"), "ㄏㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hgd"), "ㄏㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hgf"), "ㄏㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hgj"), "ㄏㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hi"), "ㄏㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hid"), "ㄏㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hif"), "ㄏㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hij"), "ㄏㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ha"), "ㄏㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("haf"), "ㄏㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hw"), "ㄏㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hwd"), "ㄏㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hwf"), "ㄏㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hwj"), "ㄏㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ho"), "ㄏㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hod"), "ㄏㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hof"), "ㄏㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hoj"), "ㄏㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hm"), "ㄏㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hmd"), "ㄏㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hmf"), "ㄏㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hmj"), "ㄏㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hn"), "ㄏㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hnd"), "ㄏㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hnf"), "ㄏㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hnj"), "ㄏㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hk"), "ㄏㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hkd"), "ㄏㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hkf"), "ㄏㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hkj"), "ㄏㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hl"), "ㄏㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hld"), "ㄏㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hlj"), "ㄏㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hx"), "ㄏㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxd"), "ㄏㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxf"), "ㄏㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxj"), "ㄏㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxy"), "ㄏㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxyd"), "ㄏㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxyf"), "ㄏㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxyj"), "ㄏㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxh"), "ㄏㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxhd"), "ㄏㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxhf"), "ㄏㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxhj"), "ㄏㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxhs"), "ㄏㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxid"), "ㄏㄨㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxij"), "ㄏㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxa"), "ㄏㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxad"), "ㄏㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxaf"), "ㄏㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxaj"), "ㄏㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxm"), "ㄏㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxmd"), "ㄏㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxmf"), "ㄏㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxmj"), "ㄏㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxn"), "ㄏㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxnd"), "ㄏㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxnf"), "ㄏㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxnj"), "ㄏㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxk"), "ㄏㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxkd"), "ㄏㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxkf"), "ㄏㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxkj"), "ㄏㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxks"), "ㄏㄨㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxl"), "ㄏㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxld"), "ㄏㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxlf"), "ㄏㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hxlj"), "ㄏㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("je"), "ㄐㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jed"), "ㄐㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jef"), "ㄐㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jej"), "ㄐㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jey"), "ㄐㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jeyd"), "ㄐㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jeyf"), "ㄐㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jeyj"), "ㄐㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jee"), "ㄐㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jeed"), "ㄐㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jeef"), "ㄐㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jeej"), "ㄐㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jees"), "ㄐㄧㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("jew"), "ㄐㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jewd"), "ㄐㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jewf"), "ㄐㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jewj"), "ㄐㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jeo"), "ㄐㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jeof"), "ㄐㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jeoj"), "ㄐㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jem"), "ㄐㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jemf"), "ㄐㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jemj"), "ㄐㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jen"), "ㄐㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jenf"), "ㄐㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jenj"), "ㄐㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jek"), "ㄐㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jekd"), "ㄐㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jekf"), "ㄐㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jekj"), "ㄐㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jel"), "ㄐㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jelf"), "ㄐㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jelj"), "ㄐㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ju"), "ㄐㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jud"), "ㄐㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juf"), "ㄐㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juj"), "ㄐㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jue"), "ㄐㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jued"), "ㄐㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juef"), "ㄐㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juej"), "ㄐㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jum"), "ㄐㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jumf"), "ㄐㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jumj"), "ㄐㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jun"), "ㄐㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jund"), "ㄐㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("junf"), "ㄐㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("junj"), "ㄐㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jul"), "ㄐㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("julf"), "ㄐㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("julj"), "ㄐㄩㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vs"), "ㄑ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ve"), "ㄑㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ved"), "ㄑㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vef"), "ㄑㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vej"), "ㄑㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vey"), "ㄑㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veyd"), "ㄑㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veyf"), "ㄑㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veyj"), "ㄑㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vee"), "ㄑㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veed"), "ㄑㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veef"), "ㄑㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veej"), "ㄑㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vew"), "ㄑㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vewd"), "ㄑㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vewf"), "ㄑㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vewj"), "ㄑㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veo"), "ㄑㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veod"), "ㄑㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veof"), "ㄑㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veoj"), "ㄑㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vem"), "ㄑㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vemd"), "ㄑㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vemf"), "ㄑㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vemj"), "ㄑㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ven"), "ㄑㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vend"), "ㄑㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("venf"), "ㄑㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("venj"), "ㄑㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vek"), "ㄑㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vekd"), "ㄑㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vekf"), "ㄑㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vekj"), "ㄑㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vel"), "ㄑㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("veld"), "ㄑㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("velf"), "ㄑㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("velj"), "ㄑㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vu"), "ㄑㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vud"), "ㄑㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuf"), "ㄑㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuj"), "ㄑㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vue"), "ㄑㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vued"), "ㄑㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuej"), "ㄑㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vum"), "ㄑㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vumd"), "ㄑㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vumf"), "ㄑㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vumj"), "ㄑㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vun"), "ㄑㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vund"), "ㄑㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vunf"), "ㄑㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vunj"), "ㄑㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vul"), "ㄑㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vuld"), "ㄑㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vulf"), "ㄑㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vulj"), "ㄑㄩㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ce"), "ㄒㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ced"), "ㄒㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cef"), "ㄒㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cej"), "ㄒㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cey"), "ㄒㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceyd"), "ㄒㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceyf"), "ㄒㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceyj"), "ㄒㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cee"), "ㄒㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceed"), "ㄒㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceef"), "ㄒㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceej"), "ㄒㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cew"), "ㄒㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cewd"), "ㄒㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cewf"), "ㄒㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cewj"), "ㄒㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceo"), "ㄒㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceod"), "ㄒㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceof"), "ㄒㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ceoj"), "ㄒㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cem"), "ㄒㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cemd"), "ㄒㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cemf"), "ㄒㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cemj"), "ㄒㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cen"), "ㄒㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cend"), "ㄒㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cenf"), "ㄒㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cenj"), "ㄒㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cek"), "ㄒㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cekd"), "ㄒㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cekf"), "ㄒㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cekj"), "ㄒㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cel"), "ㄒㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("celd"), "ㄒㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("celf"), "ㄒㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("celj"), "ㄒㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cu"), "ㄒㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cud"), "ㄒㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuf"), "ㄒㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuj"), "ㄒㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cue"), "ㄒㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cued"), "ㄒㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuef"), "ㄒㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuej"), "ㄒㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cum"), "ㄒㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cumd"), "ㄒㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cumf"), "ㄒㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cumj"), "ㄒㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cun"), "ㄒㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cund"), "ㄒㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cunj"), "ㄒㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cul"), "ㄒㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("culd"), "ㄒㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("culf"), "ㄒㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("culj"), "ㄒㄩㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("j"), "ㄓ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jd"), "ㄓˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jf"), "ㄓˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jj"), "ㄓˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jy"), "ㄓㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jyd"), "ㄓㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jyf"), "ㄓㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jyj"), "ㄓㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jg"), "ㄓㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jgd"), "ㄓㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jgf"), "ㄓㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jgj"), "ㄓㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jgs"), "ㄓㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ji"), "ㄓㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jid"), "ㄓㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jif"), "ㄓㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jij"), "ㄓㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jaj"), "ㄓㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jw"), "ㄓㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jwd"), "ㄓㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jwf"), "ㄓㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jwj"), "ㄓㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jo"), "ㄓㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jod"), "ㄓㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jof"), "ㄓㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("joj"), "ㄓㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jm"), "ㄓㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jmf"), "ㄓㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jmj"), "ㄓㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jn"), "ㄓㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jnd"), "ㄓㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jnf"), "ㄓㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jnj"), "ㄓㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jk"), "ㄓㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jkf"), "ㄓㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jkj"), "ㄓㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jl"), "ㄓㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jlf"), "ㄓㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jlj"), "ㄓㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jx"), "ㄓㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxd"), "ㄓㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxf"), "ㄓㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxj"), "ㄓㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxy"), "ㄓㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxyf"), "ㄓㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxh"), "ㄓㄨㄛ") + var c = Tekkon.Composer(arrange: .ofHsu) + XCTAssertEqual(c.cS2RC("laj"), "ㄌㄟˋ") + XCTAssertEqual(c.cS2RC("las"), "ㄌㄟ˙") + XCTAssertEqual(c.cS2RC("lw"), "ㄌㄠ") + XCTAssertEqual(c.cS2RC("lwd"), "ㄌㄠˊ") + XCTAssertEqual(c.cS2RC("lwf"), "ㄌㄠˇ") + XCTAssertEqual(c.cS2RC("lwj"), "ㄌㄠˋ") + XCTAssertEqual(c.cS2RC("lo"), "ㄌㄡ") + XCTAssertEqual(c.cS2RC("lod"), "ㄌㄡˊ") + XCTAssertEqual(c.cS2RC("lof"), "ㄌㄡˇ") + XCTAssertEqual(c.cS2RC("loj"), "ㄌㄡˋ") + XCTAssertEqual(c.cS2RC("los"), "ㄌㄡ˙") + XCTAssertEqual(c.cS2RC("lmd"), "ㄌㄢˊ") + XCTAssertEqual(c.cS2RC("lmf"), "ㄌㄢˇ") + XCTAssertEqual(c.cS2RC("lmj"), "ㄌㄢˋ") + XCTAssertEqual(c.cS2RC("lk"), "ㄌㄤ") + XCTAssertEqual(c.cS2RC("lkd"), "ㄌㄤˊ") + XCTAssertEqual(c.cS2RC("lkf"), "ㄌㄤˇ") + XCTAssertEqual(c.cS2RC("lkj"), "ㄌㄤˋ") + XCTAssertEqual(c.cS2RC("ll"), "ㄌㄥ") + XCTAssertEqual(c.cS2RC("lld"), "ㄌㄥˊ") + XCTAssertEqual(c.cS2RC("llf"), "ㄌㄥˇ") + XCTAssertEqual(c.cS2RC("llj"), "ㄌㄥˋ") + XCTAssertEqual(c.cS2RC("le"), "ㄌㄧ") + XCTAssertEqual(c.cS2RC("led"), "ㄌㄧˊ") + XCTAssertEqual(c.cS2RC("lef"), "ㄌㄧˇ") + XCTAssertEqual(c.cS2RC("lej"), "ㄌㄧˋ") + XCTAssertEqual(c.cS2RC("les"), "ㄌㄧ˙") + XCTAssertEqual(c.cS2RC("leyf"), "ㄌㄧㄚˇ") + XCTAssertEqual(c.cS2RC("lee"), "ㄌㄧㄝ") + XCTAssertEqual(c.cS2RC("leed"), "ㄌㄧㄝˊ") + XCTAssertEqual(c.cS2RC("leef"), "ㄌㄧㄝˇ") + XCTAssertEqual(c.cS2RC("leej"), "ㄌㄧㄝˋ") + XCTAssertEqual(c.cS2RC("lew"), "ㄌㄧㄠ") + XCTAssertEqual(c.cS2RC("lewd"), "ㄌㄧㄠˊ") + XCTAssertEqual(c.cS2RC("lewf"), "ㄌㄧㄠˇ") + XCTAssertEqual(c.cS2RC("lewj"), "ㄌㄧㄠˋ") + XCTAssertEqual(c.cS2RC("leo"), "ㄌㄧㄡ") + XCTAssertEqual(c.cS2RC("leod"), "ㄌㄧㄡˊ") + XCTAssertEqual(c.cS2RC("leof"), "ㄌㄧㄡˇ") + XCTAssertEqual(c.cS2RC("leoj"), "ㄌㄧㄡˋ") + XCTAssertEqual(c.cS2RC("lem"), "ㄌㄧㄢ") + XCTAssertEqual(c.cS2RC("lemd"), "ㄌㄧㄢˊ") + XCTAssertEqual(c.cS2RC("lemf"), "ㄌㄧㄢˇ") + XCTAssertEqual(c.cS2RC("lemj"), "ㄌㄧㄢˋ") + XCTAssertEqual(c.cS2RC("lend"), "ㄌㄧㄣˊ") + XCTAssertEqual(c.cS2RC("lenf"), "ㄌㄧㄣˇ") + XCTAssertEqual(c.cS2RC("lenj"), "ㄌㄧㄣˋ") + XCTAssertEqual(c.cS2RC("lekd"), "ㄌㄧㄤˊ") + XCTAssertEqual(c.cS2RC("lekf"), "ㄌㄧㄤˇ") + XCTAssertEqual(c.cS2RC("lekj"), "ㄌㄧㄤˋ") + XCTAssertEqual(c.cS2RC("lel"), "ㄌㄧㄥ") + XCTAssertEqual(c.cS2RC("leld"), "ㄌㄧㄥˊ") + XCTAssertEqual(c.cS2RC("lelf"), "ㄌㄧㄥˇ") + XCTAssertEqual(c.cS2RC("lelj"), "ㄌㄧㄥˋ") + XCTAssertEqual(c.cS2RC("lx"), "ㄌㄨ") + XCTAssertEqual(c.cS2RC("lxd"), "ㄌㄨˊ") + XCTAssertEqual(c.cS2RC("lxf"), "ㄌㄨˇ") + XCTAssertEqual(c.cS2RC("lxj"), "ㄌㄨˋ") + XCTAssertEqual(c.cS2RC("lxh"), "ㄌㄨㄛ") + XCTAssertEqual(c.cS2RC("lxhd"), "ㄌㄨㄛˊ") + XCTAssertEqual(c.cS2RC("lxhf"), "ㄌㄨㄛˇ") + XCTAssertEqual(c.cS2RC("lxhj"), "ㄌㄨㄛˋ") + XCTAssertEqual(c.cS2RC("lxhs"), "ㄌㄨㄛ˙") + XCTAssertEqual(c.cS2RC("lxmd"), "ㄌㄨㄢˊ") + XCTAssertEqual(c.cS2RC("lxmf"), "ㄌㄨㄢˇ") + XCTAssertEqual(c.cS2RC("lxmj"), "ㄌㄨㄢˋ") + XCTAssertEqual(c.cS2RC("lxn"), "ㄌㄨㄣ") + XCTAssertEqual(c.cS2RC("lxnd"), "ㄌㄨㄣˊ") + XCTAssertEqual(c.cS2RC("lxnf"), "ㄌㄨㄣˇ") + XCTAssertEqual(c.cS2RC("lxnj"), "ㄌㄨㄣˋ") + XCTAssertEqual(c.cS2RC("lxl"), "ㄌㄨㄥ") + XCTAssertEqual(c.cS2RC("lxld"), "ㄌㄨㄥˊ") + XCTAssertEqual(c.cS2RC("lxlf"), "ㄌㄨㄥˇ") + XCTAssertEqual(c.cS2RC("lxlj"), "ㄌㄨㄥˋ") + XCTAssertEqual(c.cS2RC("lu"), "ㄌㄩ") + XCTAssertEqual(c.cS2RC("lud"), "ㄌㄩˊ") + XCTAssertEqual(c.cS2RC("luf"), "ㄌㄩˇ") + XCTAssertEqual(c.cS2RC("luj"), "ㄌㄩˋ") + XCTAssertEqual(c.cS2RC("lue"), "ㄌㄩㄝ") + XCTAssertEqual(c.cS2RC("luef"), "ㄌㄩㄝˇ") + XCTAssertEqual(c.cS2RC("luej"), "ㄌㄩㄝˋ") + XCTAssertEqual(c.cS2RC("lumd"), "ㄌㄩㄢˊ") + XCTAssertEqual(c.cS2RC("lumf"), "ㄌㄩㄢˇ") + XCTAssertEqual(c.cS2RC("gy"), "ㄍㄚ") + XCTAssertEqual(c.cS2RC("gyd"), "ㄍㄚˊ") + XCTAssertEqual(c.cS2RC("gyf"), "ㄍㄚˇ") + XCTAssertEqual(c.cS2RC("gyj"), "ㄍㄚˋ") + XCTAssertEqual(c.cS2RC("gys"), "ㄍㄚ˙") + XCTAssertEqual(c.cS2RC("gg"), "ㄍㄜ") + XCTAssertEqual(c.cS2RC("ggd"), "ㄍㄜˊ") + XCTAssertEqual(c.cS2RC("ggf"), "ㄍㄜˇ") + XCTAssertEqual(c.cS2RC("ggj"), "ㄍㄜˋ") + XCTAssertEqual(c.cS2RC("ggs"), "ㄍㄜ˙") + XCTAssertEqual(c.cS2RC("gi"), "ㄍㄞ") + XCTAssertEqual(c.cS2RC("gif"), "ㄍㄞˇ") + XCTAssertEqual(c.cS2RC("gij"), "ㄍㄞˋ") + XCTAssertEqual(c.cS2RC("gaf"), "ㄍㄟˇ") + XCTAssertEqual(c.cS2RC("gw"), "ㄍㄠ") + XCTAssertEqual(c.cS2RC("gwf"), "ㄍㄠˇ") + XCTAssertEqual(c.cS2RC("gwj"), "ㄍㄠˋ") + XCTAssertEqual(c.cS2RC("go"), "ㄍㄡ") + XCTAssertEqual(c.cS2RC("gof"), "ㄍㄡˇ") + XCTAssertEqual(c.cS2RC("goj"), "ㄍㄡˋ") + XCTAssertEqual(c.cS2RC("gm"), "ㄍㄢ") + XCTAssertEqual(c.cS2RC("gmf"), "ㄍㄢˇ") + XCTAssertEqual(c.cS2RC("gmj"), "ㄍㄢˋ") + XCTAssertEqual(c.cS2RC("gn"), "ㄍㄣ") + XCTAssertEqual(c.cS2RC("gnd"), "ㄍㄣˊ") + XCTAssertEqual(c.cS2RC("gnf"), "ㄍㄣˇ") + XCTAssertEqual(c.cS2RC("gnj"), "ㄍㄣˋ") + XCTAssertEqual(c.cS2RC("gk"), "ㄍㄤ") + XCTAssertEqual(c.cS2RC("gkf"), "ㄍㄤˇ") + XCTAssertEqual(c.cS2RC("gkj"), "ㄍㄤˋ") + XCTAssertEqual(c.cS2RC("gl"), "ㄍㄥ") + XCTAssertEqual(c.cS2RC("glf"), "ㄍㄥˇ") + XCTAssertEqual(c.cS2RC("glj"), "ㄍㄥˋ") + XCTAssertEqual(c.cS2RC("gx"), "ㄍㄨ") + XCTAssertEqual(c.cS2RC("gxd"), "ㄍㄨˊ") + XCTAssertEqual(c.cS2RC("gxf"), "ㄍㄨˇ") + XCTAssertEqual(c.cS2RC("gxj"), "ㄍㄨˋ") + XCTAssertEqual(c.cS2RC("gxy"), "ㄍㄨㄚ") + XCTAssertEqual(c.cS2RC("gxyd"), "ㄍㄨㄚˊ") + XCTAssertEqual(c.cS2RC("gxyf"), "ㄍㄨㄚˇ") + XCTAssertEqual(c.cS2RC("gxyj"), "ㄍㄨㄚˋ") + XCTAssertEqual(c.cS2RC("gxh"), "ㄍㄨㄛ") + XCTAssertEqual(c.cS2RC("gxhd"), "ㄍㄨㄛˊ") + XCTAssertEqual(c.cS2RC("gxhf"), "ㄍㄨㄛˇ") + XCTAssertEqual(c.cS2RC("gxhj"), "ㄍㄨㄛˋ") + XCTAssertEqual(c.cS2RC("gxi"), "ㄍㄨㄞ") + XCTAssertEqual(c.cS2RC("gxif"), "ㄍㄨㄞˇ") + XCTAssertEqual(c.cS2RC("gxij"), "ㄍㄨㄞˋ") + XCTAssertEqual(c.cS2RC("gxa"), "ㄍㄨㄟ") + XCTAssertEqual(c.cS2RC("gxaf"), "ㄍㄨㄟˇ") + XCTAssertEqual(c.cS2RC("gxaj"), "ㄍㄨㄟˋ") + XCTAssertEqual(c.cS2RC("gxm"), "ㄍㄨㄢ") + XCTAssertEqual(c.cS2RC("gxmf"), "ㄍㄨㄢˇ") + XCTAssertEqual(c.cS2RC("gxmj"), "ㄍㄨㄢˋ") + XCTAssertEqual(c.cS2RC("gxn"), "ㄍㄨㄣ") + XCTAssertEqual(c.cS2RC("gxnf"), "ㄍㄨㄣˇ") + XCTAssertEqual(c.cS2RC("gxnj"), "ㄍㄨㄣˋ") + XCTAssertEqual(c.cS2RC("gxk"), "ㄍㄨㄤ") + XCTAssertEqual(c.cS2RC("gxkf"), "ㄍㄨㄤˇ") + XCTAssertEqual(c.cS2RC("gxkj"), "ㄍㄨㄤˋ") + XCTAssertEqual(c.cS2RC("gxl"), "ㄍㄨㄥ") + XCTAssertEqual(c.cS2RC("gxld"), "ㄍㄨㄥˊ") + XCTAssertEqual(c.cS2RC("gxlf"), "ㄍㄨㄥˇ") + XCTAssertEqual(c.cS2RC("gxlj"), "ㄍㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ky"), "ㄎㄚ") + XCTAssertEqual(c.cS2RC("kyf"), "ㄎㄚˇ") + XCTAssertEqual(c.cS2RC("kyj"), "ㄎㄚˋ") + XCTAssertEqual(c.cS2RC("kg"), "ㄎㄜ") + XCTAssertEqual(c.cS2RC("kgd"), "ㄎㄜˊ") + XCTAssertEqual(c.cS2RC("kgf"), "ㄎㄜˇ") + XCTAssertEqual(c.cS2RC("kgj"), "ㄎㄜˋ") + XCTAssertEqual(c.cS2RC("ki"), "ㄎㄞ") + XCTAssertEqual(c.cS2RC("kif"), "ㄎㄞˇ") + XCTAssertEqual(c.cS2RC("kij"), "ㄎㄞˋ") + XCTAssertEqual(c.cS2RC("kw"), "ㄎㄠ") + XCTAssertEqual(c.cS2RC("kwf"), "ㄎㄠˇ") + XCTAssertEqual(c.cS2RC("kwj"), "ㄎㄠˋ") + XCTAssertEqual(c.cS2RC("ko"), "ㄎㄡ") + XCTAssertEqual(c.cS2RC("kof"), "ㄎㄡˇ") + XCTAssertEqual(c.cS2RC("koj"), "ㄎㄡˋ") + XCTAssertEqual(c.cS2RC("km"), "ㄎㄢ") + XCTAssertEqual(c.cS2RC("kmf"), "ㄎㄢˇ") + XCTAssertEqual(c.cS2RC("kmj"), "ㄎㄢˋ") + XCTAssertEqual(c.cS2RC("kn"), "ㄎㄣ") + XCTAssertEqual(c.cS2RC("knf"), "ㄎㄣˇ") + XCTAssertEqual(c.cS2RC("knj"), "ㄎㄣˋ") + XCTAssertEqual(c.cS2RC("kk"), "ㄎㄤ") + XCTAssertEqual(c.cS2RC("kkd"), "ㄎㄤˊ") + XCTAssertEqual(c.cS2RC("kkf"), "ㄎㄤˇ") + XCTAssertEqual(c.cS2RC("kkj"), "ㄎㄤˋ") + XCTAssertEqual(c.cS2RC("kl"), "ㄎㄥ") + XCTAssertEqual(c.cS2RC("klf"), "ㄎㄥˇ") + XCTAssertEqual(c.cS2RC("kx"), "ㄎㄨ") + XCTAssertEqual(c.cS2RC("kxd"), "ㄎㄨˊ") + XCTAssertEqual(c.cS2RC("kxf"), "ㄎㄨˇ") + XCTAssertEqual(c.cS2RC("kxj"), "ㄎㄨˋ") + XCTAssertEqual(c.cS2RC("kxy"), "ㄎㄨㄚ") + XCTAssertEqual(c.cS2RC("kxyf"), "ㄎㄨㄚˇ") + XCTAssertEqual(c.cS2RC("kxyj"), "ㄎㄨㄚˋ") + XCTAssertEqual(c.cS2RC("kxhj"), "ㄎㄨㄛˋ") + XCTAssertEqual(c.cS2RC("kxi"), "ㄎㄨㄞ") + XCTAssertEqual(c.cS2RC("kxif"), "ㄎㄨㄞˇ") + XCTAssertEqual(c.cS2RC("kxij"), "ㄎㄨㄞˋ") + XCTAssertEqual(c.cS2RC("kxa"), "ㄎㄨㄟ") + XCTAssertEqual(c.cS2RC("kxad"), "ㄎㄨㄟˊ") + XCTAssertEqual(c.cS2RC("kxaf"), "ㄎㄨㄟˇ") + XCTAssertEqual(c.cS2RC("kxaj"), "ㄎㄨㄟˋ") + XCTAssertEqual(c.cS2RC("kxm"), "ㄎㄨㄢ") + XCTAssertEqual(c.cS2RC("kxmf"), "ㄎㄨㄢˇ") + XCTAssertEqual(c.cS2RC("kxmj"), "ㄎㄨㄢˋ") + XCTAssertEqual(c.cS2RC("kxn"), "ㄎㄨㄣ") + XCTAssertEqual(c.cS2RC("kxnf"), "ㄎㄨㄣˇ") + XCTAssertEqual(c.cS2RC("kxnj"), "ㄎㄨㄣˋ") + XCTAssertEqual(c.cS2RC("kxk"), "ㄎㄨㄤ") + XCTAssertEqual(c.cS2RC("kxkd"), "ㄎㄨㄤˊ") + XCTAssertEqual(c.cS2RC("kxkf"), "ㄎㄨㄤˇ") + XCTAssertEqual(c.cS2RC("kxkj"), "ㄎㄨㄤˋ") + XCTAssertEqual(c.cS2RC("kxl"), "ㄎㄨㄥ") + XCTAssertEqual(c.cS2RC("kxlf"), "ㄎㄨㄥˇ") + XCTAssertEqual(c.cS2RC("kxlj"), "ㄎㄨㄥˋ") + XCTAssertEqual(c.cS2RC("hy"), "ㄏㄚ") + XCTAssertEqual(c.cS2RC("hyd"), "ㄏㄚˊ") + XCTAssertEqual(c.cS2RC("hyf"), "ㄏㄚˇ") + XCTAssertEqual(c.cS2RC("hg"), "ㄏㄜ") + XCTAssertEqual(c.cS2RC("hgd"), "ㄏㄜˊ") + XCTAssertEqual(c.cS2RC("hgf"), "ㄏㄜˇ") + XCTAssertEqual(c.cS2RC("hgj"), "ㄏㄜˋ") + XCTAssertEqual(c.cS2RC("hi"), "ㄏㄞ") + XCTAssertEqual(c.cS2RC("hid"), "ㄏㄞˊ") + XCTAssertEqual(c.cS2RC("hif"), "ㄏㄞˇ") + XCTAssertEqual(c.cS2RC("hij"), "ㄏㄞˋ") + XCTAssertEqual(c.cS2RC("ha"), "ㄏㄟ") + XCTAssertEqual(c.cS2RC("haf"), "ㄏㄟˇ") + XCTAssertEqual(c.cS2RC("hw"), "ㄏㄠ") + XCTAssertEqual(c.cS2RC("hwd"), "ㄏㄠˊ") + XCTAssertEqual(c.cS2RC("hwf"), "ㄏㄠˇ") + XCTAssertEqual(c.cS2RC("hwj"), "ㄏㄠˋ") + XCTAssertEqual(c.cS2RC("ho"), "ㄏㄡ") + XCTAssertEqual(c.cS2RC("hod"), "ㄏㄡˊ") + XCTAssertEqual(c.cS2RC("hof"), "ㄏㄡˇ") + XCTAssertEqual(c.cS2RC("hoj"), "ㄏㄡˋ") + XCTAssertEqual(c.cS2RC("hm"), "ㄏㄢ") + XCTAssertEqual(c.cS2RC("hmd"), "ㄏㄢˊ") + XCTAssertEqual(c.cS2RC("hmf"), "ㄏㄢˇ") + XCTAssertEqual(c.cS2RC("hmj"), "ㄏㄢˋ") + XCTAssertEqual(c.cS2RC("hn"), "ㄏㄣ") + XCTAssertEqual(c.cS2RC("hnd"), "ㄏㄣˊ") + XCTAssertEqual(c.cS2RC("hnf"), "ㄏㄣˇ") + XCTAssertEqual(c.cS2RC("hnj"), "ㄏㄣˋ") + XCTAssertEqual(c.cS2RC("hk"), "ㄏㄤ") + XCTAssertEqual(c.cS2RC("hkd"), "ㄏㄤˊ") + XCTAssertEqual(c.cS2RC("hkf"), "ㄏㄤˇ") + XCTAssertEqual(c.cS2RC("hkj"), "ㄏㄤˋ") + XCTAssertEqual(c.cS2RC("hl"), "ㄏㄥ") + XCTAssertEqual(c.cS2RC("hld"), "ㄏㄥˊ") + XCTAssertEqual(c.cS2RC("hlj"), "ㄏㄥˋ") + XCTAssertEqual(c.cS2RC("hx"), "ㄏㄨ") + XCTAssertEqual(c.cS2RC("hxd"), "ㄏㄨˊ") + XCTAssertEqual(c.cS2RC("hxf"), "ㄏㄨˇ") + XCTAssertEqual(c.cS2RC("hxj"), "ㄏㄨˋ") + XCTAssertEqual(c.cS2RC("hxy"), "ㄏㄨㄚ") + XCTAssertEqual(c.cS2RC("hxyd"), "ㄏㄨㄚˊ") + XCTAssertEqual(c.cS2RC("hxyf"), "ㄏㄨㄚˇ") + XCTAssertEqual(c.cS2RC("hxyj"), "ㄏㄨㄚˋ") + XCTAssertEqual(c.cS2RC("hxh"), "ㄏㄨㄛ") + XCTAssertEqual(c.cS2RC("hxhd"), "ㄏㄨㄛˊ") + XCTAssertEqual(c.cS2RC("hxhf"), "ㄏㄨㄛˇ") + XCTAssertEqual(c.cS2RC("hxhj"), "ㄏㄨㄛˋ") + XCTAssertEqual(c.cS2RC("hxhs"), "ㄏㄨㄛ˙") + XCTAssertEqual(c.cS2RC("hxid"), "ㄏㄨㄞˊ") + XCTAssertEqual(c.cS2RC("hxij"), "ㄏㄨㄞˋ") + XCTAssertEqual(c.cS2RC("hxa"), "ㄏㄨㄟ") + XCTAssertEqual(c.cS2RC("hxad"), "ㄏㄨㄟˊ") + XCTAssertEqual(c.cS2RC("hxaf"), "ㄏㄨㄟˇ") + XCTAssertEqual(c.cS2RC("hxaj"), "ㄏㄨㄟˋ") + XCTAssertEqual(c.cS2RC("hxm"), "ㄏㄨㄢ") + XCTAssertEqual(c.cS2RC("hxmd"), "ㄏㄨㄢˊ") + XCTAssertEqual(c.cS2RC("hxmf"), "ㄏㄨㄢˇ") + XCTAssertEqual(c.cS2RC("hxmj"), "ㄏㄨㄢˋ") + XCTAssertEqual(c.cS2RC("hxn"), "ㄏㄨㄣ") + XCTAssertEqual(c.cS2RC("hxnd"), "ㄏㄨㄣˊ") + XCTAssertEqual(c.cS2RC("hxnf"), "ㄏㄨㄣˇ") + XCTAssertEqual(c.cS2RC("hxnj"), "ㄏㄨㄣˋ") + XCTAssertEqual(c.cS2RC("hxk"), "ㄏㄨㄤ") + XCTAssertEqual(c.cS2RC("hxkd"), "ㄏㄨㄤˊ") + XCTAssertEqual(c.cS2RC("hxkf"), "ㄏㄨㄤˇ") + XCTAssertEqual(c.cS2RC("hxkj"), "ㄏㄨㄤˋ") + XCTAssertEqual(c.cS2RC("hxks"), "ㄏㄨㄤ˙") + XCTAssertEqual(c.cS2RC("hxl"), "ㄏㄨㄥ") + XCTAssertEqual(c.cS2RC("hxld"), "ㄏㄨㄥˊ") + XCTAssertEqual(c.cS2RC("hxlf"), "ㄏㄨㄥˇ") + XCTAssertEqual(c.cS2RC("hxlj"), "ㄏㄨㄥˋ") + XCTAssertEqual(c.cS2RC("je"), "ㄐㄧ") + XCTAssertEqual(c.cS2RC("jed"), "ㄐㄧˊ") + XCTAssertEqual(c.cS2RC("jef"), "ㄐㄧˇ") + XCTAssertEqual(c.cS2RC("jej"), "ㄐㄧˋ") + XCTAssertEqual(c.cS2RC("jey"), "ㄐㄧㄚ") + XCTAssertEqual(c.cS2RC("jeyd"), "ㄐㄧㄚˊ") + XCTAssertEqual(c.cS2RC("jeyf"), "ㄐㄧㄚˇ") + XCTAssertEqual(c.cS2RC("jeyj"), "ㄐㄧㄚˋ") + XCTAssertEqual(c.cS2RC("jee"), "ㄐㄧㄝ") + XCTAssertEqual(c.cS2RC("jeed"), "ㄐㄧㄝˊ") + XCTAssertEqual(c.cS2RC("jeef"), "ㄐㄧㄝˇ") + XCTAssertEqual(c.cS2RC("jeej"), "ㄐㄧㄝˋ") + XCTAssertEqual(c.cS2RC("jees"), "ㄐㄧㄝ˙") + XCTAssertEqual(c.cS2RC("jew"), "ㄐㄧㄠ") + XCTAssertEqual(c.cS2RC("jewd"), "ㄐㄧㄠˊ") + XCTAssertEqual(c.cS2RC("jewf"), "ㄐㄧㄠˇ") + XCTAssertEqual(c.cS2RC("jewj"), "ㄐㄧㄠˋ") + XCTAssertEqual(c.cS2RC("jeo"), "ㄐㄧㄡ") + XCTAssertEqual(c.cS2RC("jeof"), "ㄐㄧㄡˇ") + XCTAssertEqual(c.cS2RC("jeoj"), "ㄐㄧㄡˋ") + XCTAssertEqual(c.cS2RC("jem"), "ㄐㄧㄢ") + XCTAssertEqual(c.cS2RC("jemf"), "ㄐㄧㄢˇ") + XCTAssertEqual(c.cS2RC("jemj"), "ㄐㄧㄢˋ") + XCTAssertEqual(c.cS2RC("jen"), "ㄐㄧㄣ") + XCTAssertEqual(c.cS2RC("jenf"), "ㄐㄧㄣˇ") + XCTAssertEqual(c.cS2RC("jenj"), "ㄐㄧㄣˋ") + XCTAssertEqual(c.cS2RC("jek"), "ㄐㄧㄤ") + XCTAssertEqual(c.cS2RC("jekd"), "ㄐㄧㄤˊ") + XCTAssertEqual(c.cS2RC("jekf"), "ㄐㄧㄤˇ") + XCTAssertEqual(c.cS2RC("jekj"), "ㄐㄧㄤˋ") + XCTAssertEqual(c.cS2RC("jel"), "ㄐㄧㄥ") + XCTAssertEqual(c.cS2RC("jelf"), "ㄐㄧㄥˇ") + XCTAssertEqual(c.cS2RC("jelj"), "ㄐㄧㄥˋ") + XCTAssertEqual(c.cS2RC("ju"), "ㄐㄩ") + XCTAssertEqual(c.cS2RC("jud"), "ㄐㄩˊ") + XCTAssertEqual(c.cS2RC("juf"), "ㄐㄩˇ") + XCTAssertEqual(c.cS2RC("juj"), "ㄐㄩˋ") + XCTAssertEqual(c.cS2RC("jue"), "ㄐㄩㄝ") + XCTAssertEqual(c.cS2RC("jued"), "ㄐㄩㄝˊ") + XCTAssertEqual(c.cS2RC("juef"), "ㄐㄩㄝˇ") + XCTAssertEqual(c.cS2RC("juej"), "ㄐㄩㄝˋ") + XCTAssertEqual(c.cS2RC("jum"), "ㄐㄩㄢ") + XCTAssertEqual(c.cS2RC("jumf"), "ㄐㄩㄢˇ") + XCTAssertEqual(c.cS2RC("jumj"), "ㄐㄩㄢˋ") + XCTAssertEqual(c.cS2RC("jun"), "ㄐㄩㄣ") + XCTAssertEqual(c.cS2RC("jund"), "ㄐㄩㄣˊ") + XCTAssertEqual(c.cS2RC("junf"), "ㄐㄩㄣˇ") + XCTAssertEqual(c.cS2RC("junj"), "ㄐㄩㄣˋ") + XCTAssertEqual(c.cS2RC("jul"), "ㄐㄩㄥ") + XCTAssertEqual(c.cS2RC("julf"), "ㄐㄩㄥˇ") + XCTAssertEqual(c.cS2RC("julj"), "ㄐㄩㄥˋ") + XCTAssertEqual(c.cS2RC("vs"), "ㄑ˙") + XCTAssertEqual(c.cS2RC("ve"), "ㄑㄧ") + XCTAssertEqual(c.cS2RC("ved"), "ㄑㄧˊ") + XCTAssertEqual(c.cS2RC("vef"), "ㄑㄧˇ") + XCTAssertEqual(c.cS2RC("vej"), "ㄑㄧˋ") + XCTAssertEqual(c.cS2RC("vey"), "ㄑㄧㄚ") + XCTAssertEqual(c.cS2RC("veyd"), "ㄑㄧㄚˊ") + XCTAssertEqual(c.cS2RC("veyf"), "ㄑㄧㄚˇ") + XCTAssertEqual(c.cS2RC("veyj"), "ㄑㄧㄚˋ") + XCTAssertEqual(c.cS2RC("vee"), "ㄑㄧㄝ") + XCTAssertEqual(c.cS2RC("veed"), "ㄑㄧㄝˊ") + XCTAssertEqual(c.cS2RC("veef"), "ㄑㄧㄝˇ") + XCTAssertEqual(c.cS2RC("veej"), "ㄑㄧㄝˋ") + XCTAssertEqual(c.cS2RC("vew"), "ㄑㄧㄠ") + XCTAssertEqual(c.cS2RC("vewd"), "ㄑㄧㄠˊ") + XCTAssertEqual(c.cS2RC("vewf"), "ㄑㄧㄠˇ") + XCTAssertEqual(c.cS2RC("vewj"), "ㄑㄧㄠˋ") + XCTAssertEqual(c.cS2RC("veo"), "ㄑㄧㄡ") + XCTAssertEqual(c.cS2RC("veod"), "ㄑㄧㄡˊ") + XCTAssertEqual(c.cS2RC("veof"), "ㄑㄧㄡˇ") + XCTAssertEqual(c.cS2RC("veoj"), "ㄑㄧㄡˋ") + XCTAssertEqual(c.cS2RC("vem"), "ㄑㄧㄢ") + XCTAssertEqual(c.cS2RC("vemd"), "ㄑㄧㄢˊ") + XCTAssertEqual(c.cS2RC("vemf"), "ㄑㄧㄢˇ") + XCTAssertEqual(c.cS2RC("vemj"), "ㄑㄧㄢˋ") + XCTAssertEqual(c.cS2RC("ven"), "ㄑㄧㄣ") + XCTAssertEqual(c.cS2RC("vend"), "ㄑㄧㄣˊ") + XCTAssertEqual(c.cS2RC("venf"), "ㄑㄧㄣˇ") + XCTAssertEqual(c.cS2RC("venj"), "ㄑㄧㄣˋ") + XCTAssertEqual(c.cS2RC("vek"), "ㄑㄧㄤ") + XCTAssertEqual(c.cS2RC("vekd"), "ㄑㄧㄤˊ") + XCTAssertEqual(c.cS2RC("vekf"), "ㄑㄧㄤˇ") + XCTAssertEqual(c.cS2RC("vekj"), "ㄑㄧㄤˋ") + XCTAssertEqual(c.cS2RC("vel"), "ㄑㄧㄥ") + XCTAssertEqual(c.cS2RC("veld"), "ㄑㄧㄥˊ") + XCTAssertEqual(c.cS2RC("velf"), "ㄑㄧㄥˇ") + XCTAssertEqual(c.cS2RC("velj"), "ㄑㄧㄥˋ") + XCTAssertEqual(c.cS2RC("vu"), "ㄑㄩ") + XCTAssertEqual(c.cS2RC("vud"), "ㄑㄩˊ") + XCTAssertEqual(c.cS2RC("vuf"), "ㄑㄩˇ") + XCTAssertEqual(c.cS2RC("vuj"), "ㄑㄩˋ") + XCTAssertEqual(c.cS2RC("vue"), "ㄑㄩㄝ") + XCTAssertEqual(c.cS2RC("vued"), "ㄑㄩㄝˊ") + XCTAssertEqual(c.cS2RC("vuej"), "ㄑㄩㄝˋ") + XCTAssertEqual(c.cS2RC("vum"), "ㄑㄩㄢ") + XCTAssertEqual(c.cS2RC("vumd"), "ㄑㄩㄢˊ") + XCTAssertEqual(c.cS2RC("vumf"), "ㄑㄩㄢˇ") + XCTAssertEqual(c.cS2RC("vumj"), "ㄑㄩㄢˋ") + XCTAssertEqual(c.cS2RC("vun"), "ㄑㄩㄣ") + XCTAssertEqual(c.cS2RC("vund"), "ㄑㄩㄣˊ") + XCTAssertEqual(c.cS2RC("vunf"), "ㄑㄩㄣˇ") + XCTAssertEqual(c.cS2RC("vunj"), "ㄑㄩㄣˋ") + XCTAssertEqual(c.cS2RC("vul"), "ㄑㄩㄥ") + XCTAssertEqual(c.cS2RC("vuld"), "ㄑㄩㄥˊ") + XCTAssertEqual(c.cS2RC("vulf"), "ㄑㄩㄥˇ") + XCTAssertEqual(c.cS2RC("vulj"), "ㄑㄩㄥˋ") + XCTAssertEqual(c.cS2RC("ce"), "ㄒㄧ") + XCTAssertEqual(c.cS2RC("ced"), "ㄒㄧˊ") + XCTAssertEqual(c.cS2RC("cef"), "ㄒㄧˇ") + XCTAssertEqual(c.cS2RC("cej"), "ㄒㄧˋ") + XCTAssertEqual(c.cS2RC("cey"), "ㄒㄧㄚ") + XCTAssertEqual(c.cS2RC("ceyd"), "ㄒㄧㄚˊ") + XCTAssertEqual(c.cS2RC("ceyf"), "ㄒㄧㄚˇ") + XCTAssertEqual(c.cS2RC("ceyj"), "ㄒㄧㄚˋ") + XCTAssertEqual(c.cS2RC("cee"), "ㄒㄧㄝ") + XCTAssertEqual(c.cS2RC("ceed"), "ㄒㄧㄝˊ") + XCTAssertEqual(c.cS2RC("ceef"), "ㄒㄧㄝˇ") + XCTAssertEqual(c.cS2RC("ceej"), "ㄒㄧㄝˋ") + XCTAssertEqual(c.cS2RC("cew"), "ㄒㄧㄠ") + XCTAssertEqual(c.cS2RC("cewd"), "ㄒㄧㄠˊ") + XCTAssertEqual(c.cS2RC("cewf"), "ㄒㄧㄠˇ") + XCTAssertEqual(c.cS2RC("cewj"), "ㄒㄧㄠˋ") + XCTAssertEqual(c.cS2RC("ceo"), "ㄒㄧㄡ") + XCTAssertEqual(c.cS2RC("ceod"), "ㄒㄧㄡˊ") + XCTAssertEqual(c.cS2RC("ceof"), "ㄒㄧㄡˇ") + XCTAssertEqual(c.cS2RC("ceoj"), "ㄒㄧㄡˋ") + XCTAssertEqual(c.cS2RC("cem"), "ㄒㄧㄢ") + XCTAssertEqual(c.cS2RC("cemd"), "ㄒㄧㄢˊ") + XCTAssertEqual(c.cS2RC("cemf"), "ㄒㄧㄢˇ") + XCTAssertEqual(c.cS2RC("cemj"), "ㄒㄧㄢˋ") + XCTAssertEqual(c.cS2RC("cen"), "ㄒㄧㄣ") + XCTAssertEqual(c.cS2RC("cend"), "ㄒㄧㄣˊ") + XCTAssertEqual(c.cS2RC("cenf"), "ㄒㄧㄣˇ") + XCTAssertEqual(c.cS2RC("cenj"), "ㄒㄧㄣˋ") + XCTAssertEqual(c.cS2RC("cek"), "ㄒㄧㄤ") + XCTAssertEqual(c.cS2RC("cekd"), "ㄒㄧㄤˊ") + XCTAssertEqual(c.cS2RC("cekf"), "ㄒㄧㄤˇ") + XCTAssertEqual(c.cS2RC("cekj"), "ㄒㄧㄤˋ") + XCTAssertEqual(c.cS2RC("cel"), "ㄒㄧㄥ") + XCTAssertEqual(c.cS2RC("celd"), "ㄒㄧㄥˊ") + XCTAssertEqual(c.cS2RC("celf"), "ㄒㄧㄥˇ") + XCTAssertEqual(c.cS2RC("celj"), "ㄒㄧㄥˋ") + XCTAssertEqual(c.cS2RC("cu"), "ㄒㄩ") + XCTAssertEqual(c.cS2RC("cud"), "ㄒㄩˊ") + XCTAssertEqual(c.cS2RC("cuf"), "ㄒㄩˇ") + XCTAssertEqual(c.cS2RC("cuj"), "ㄒㄩˋ") + XCTAssertEqual(c.cS2RC("cue"), "ㄒㄩㄝ") + XCTAssertEqual(c.cS2RC("cued"), "ㄒㄩㄝˊ") + XCTAssertEqual(c.cS2RC("cuef"), "ㄒㄩㄝˇ") + XCTAssertEqual(c.cS2RC("cuej"), "ㄒㄩㄝˋ") + XCTAssertEqual(c.cS2RC("cum"), "ㄒㄩㄢ") + XCTAssertEqual(c.cS2RC("cumd"), "ㄒㄩㄢˊ") + XCTAssertEqual(c.cS2RC("cumf"), "ㄒㄩㄢˇ") + XCTAssertEqual(c.cS2RC("cumj"), "ㄒㄩㄢˋ") + XCTAssertEqual(c.cS2RC("cun"), "ㄒㄩㄣ") + XCTAssertEqual(c.cS2RC("cund"), "ㄒㄩㄣˊ") + XCTAssertEqual(c.cS2RC("cunj"), "ㄒㄩㄣˋ") + XCTAssertEqual(c.cS2RC("cul"), "ㄒㄩㄥ") + XCTAssertEqual(c.cS2RC("culd"), "ㄒㄩㄥˊ") + XCTAssertEqual(c.cS2RC("culf"), "ㄒㄩㄥˇ") + XCTAssertEqual(c.cS2RC("culj"), "ㄒㄩㄥˋ") + XCTAssertEqual(c.cS2RC("j"), "ㄓ") + XCTAssertEqual(c.cS2RC("jd"), "ㄓˊ") + XCTAssertEqual(c.cS2RC("jf"), "ㄓˇ") + XCTAssertEqual(c.cS2RC("jj"), "ㄓˋ") + XCTAssertEqual(c.cS2RC("jy"), "ㄓㄚ") + XCTAssertEqual(c.cS2RC("jyd"), "ㄓㄚˊ") + XCTAssertEqual(c.cS2RC("jyf"), "ㄓㄚˇ") + XCTAssertEqual(c.cS2RC("jyj"), "ㄓㄚˋ") + XCTAssertEqual(c.cS2RC("jg"), "ㄓㄜ") + XCTAssertEqual(c.cS2RC("jgd"), "ㄓㄜˊ") + XCTAssertEqual(c.cS2RC("jgf"), "ㄓㄜˇ") + XCTAssertEqual(c.cS2RC("jgj"), "ㄓㄜˋ") + XCTAssertEqual(c.cS2RC("jgs"), "ㄓㄜ˙") + XCTAssertEqual(c.cS2RC("ji"), "ㄓㄞ") + XCTAssertEqual(c.cS2RC("jid"), "ㄓㄞˊ") + XCTAssertEqual(c.cS2RC("jif"), "ㄓㄞˇ") + XCTAssertEqual(c.cS2RC("jij"), "ㄓㄞˋ") + XCTAssertEqual(c.cS2RC("jaj"), "ㄓㄟˋ") + XCTAssertEqual(c.cS2RC("jw"), "ㄓㄠ") + XCTAssertEqual(c.cS2RC("jwd"), "ㄓㄠˊ") + XCTAssertEqual(c.cS2RC("jwf"), "ㄓㄠˇ") + XCTAssertEqual(c.cS2RC("jwj"), "ㄓㄠˋ") + XCTAssertEqual(c.cS2RC("jo"), "ㄓㄡ") + XCTAssertEqual(c.cS2RC("jod"), "ㄓㄡˊ") + XCTAssertEqual(c.cS2RC("jof"), "ㄓㄡˇ") + XCTAssertEqual(c.cS2RC("joj"), "ㄓㄡˋ") + XCTAssertEqual(c.cS2RC("jm"), "ㄓㄢ") + XCTAssertEqual(c.cS2RC("jmf"), "ㄓㄢˇ") + XCTAssertEqual(c.cS2RC("jmj"), "ㄓㄢˋ") + XCTAssertEqual(c.cS2RC("jn"), "ㄓㄣ") + XCTAssertEqual(c.cS2RC("jnd"), "ㄓㄣˊ") + XCTAssertEqual(c.cS2RC("jnf"), "ㄓㄣˇ") + XCTAssertEqual(c.cS2RC("jnj"), "ㄓㄣˋ") + XCTAssertEqual(c.cS2RC("jk"), "ㄓㄤ") + XCTAssertEqual(c.cS2RC("jkf"), "ㄓㄤˇ") + XCTAssertEqual(c.cS2RC("jkj"), "ㄓㄤˋ") + XCTAssertEqual(c.cS2RC("jl"), "ㄓㄥ") + XCTAssertEqual(c.cS2RC("jlf"), "ㄓㄥˇ") + XCTAssertEqual(c.cS2RC("jlj"), "ㄓㄥˋ") + XCTAssertEqual(c.cS2RC("jx"), "ㄓㄨ") + XCTAssertEqual(c.cS2RC("jxd"), "ㄓㄨˊ") + XCTAssertEqual(c.cS2RC("jxf"), "ㄓㄨˇ") + XCTAssertEqual(c.cS2RC("jxj"), "ㄓㄨˋ") + XCTAssertEqual(c.cS2RC("jxy"), "ㄓㄨㄚ") + XCTAssertEqual(c.cS2RC("jxyf"), "ㄓㄨㄚˇ") + XCTAssertEqual(c.cS2RC("jxh"), "ㄓㄨㄛ") } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_C.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_C.swift index 01a5322b..0d4b2cbc 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_C.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_C.swift @@ -12,513 +12,513 @@ import XCTest extension TekkonTestsKeyboardArrangments { func testHsuKeysC() throws { - var composer = Tekkon.Composer(arrange: .ofHsu) - XCTAssertEqual(composer.convertSequenceToRawComposition("jxhd"), "ㄓㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxhj"), "ㄓㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxi"), "ㄓㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxif"), "ㄓㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxij"), "ㄓㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxa"), "ㄓㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxaf"), "ㄓㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxaj"), "ㄓㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxm"), "ㄓㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxmf"), "ㄓㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxmj"), "ㄓㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxn"), "ㄓㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxnf"), "ㄓㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxnj"), "ㄓㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxk"), "ㄓㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxkf"), "ㄓㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxkj"), "ㄓㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxl"), "ㄓㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxlf"), "ㄓㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jxlj"), "ㄓㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("v "), "ㄔ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vd"), "ㄔˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vf"), "ㄔˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vj"), "ㄔˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vy"), "ㄔㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vyd"), "ㄔㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vyf"), "ㄔㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vyj"), "ㄔㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vg "), "ㄔㄜ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vgf"), "ㄔㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vgj"), "ㄔㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vi"), "ㄔㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vid"), "ㄔㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vif"), "ㄔㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vij"), "ㄔㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vw"), "ㄔㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vwd"), "ㄔㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vwf"), "ㄔㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vwj"), "ㄔㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vo"), "ㄔㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vod"), "ㄔㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vof"), "ㄔㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("voj"), "ㄔㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vm "), "ㄔㄢ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmd"), "ㄔㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmf"), "ㄔㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vmj"), "ㄔㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vn "), "ㄔㄣ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vnd"), "ㄔㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vnf"), "ㄔㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vnj"), "ㄔㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vns"), "ㄔㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("vk "), "ㄔㄤ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vkd"), "ㄔㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vkf"), "ㄔㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vkj"), "ㄔㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vl "), "ㄔㄥ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vld"), "ㄔㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vlf"), "ㄔㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vlj"), "ㄔㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vx"), "ㄔㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxd"), "ㄔㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxf"), "ㄔㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxj"), "ㄔㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxy"), "ㄔㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxyf"), "ㄔㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxyj"), "ㄔㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxh"), "ㄔㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxhj"), "ㄔㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxi"), "ㄔㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxid"), "ㄔㄨㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxif"), "ㄔㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxij"), "ㄔㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxa"), "ㄔㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxad"), "ㄔㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxaf"), "ㄔㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxaj"), "ㄔㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxm"), "ㄔㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxmd"), "ㄔㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxmf"), "ㄔㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxmj"), "ㄔㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxn"), "ㄔㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxnd"), "ㄔㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxnf"), "ㄔㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxk"), "ㄔㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxkd"), "ㄔㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxkf"), "ㄔㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxkj"), "ㄔㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxl"), "ㄔㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxld"), "ㄔㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxlf"), "ㄔㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vxlj"), "ㄔㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("c"), "ㄕ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cd"), "ㄕˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cf"), "ㄕˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cj"), "ㄕˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cs"), "ㄕ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("cy"), "ㄕㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cyd"), "ㄕㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cyf"), "ㄕㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cyj"), "ㄕㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cys"), "ㄕㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("cg"), "ㄕㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cgd"), "ㄕㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cgf"), "ㄕㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cgj"), "ㄕㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ci"), "ㄕㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cif"), "ㄕㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cij"), "ㄕㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cad"), "ㄕㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cw"), "ㄕㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cwd"), "ㄕㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cwf"), "ㄕㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cwj"), "ㄕㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("co"), "ㄕㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cod"), "ㄕㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cof"), "ㄕㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("coj"), "ㄕㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cm"), "ㄕㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cmd"), "ㄕㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cmf"), "ㄕㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cmj"), "ㄕㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cn"), "ㄕㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cnd"), "ㄕㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cnf"), "ㄕㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cnj"), "ㄕㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ck"), "ㄕㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ckf"), "ㄕㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ckj"), "ㄕㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cks"), "ㄕㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("cl"), "ㄕㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cld"), "ㄕㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("clf"), "ㄕㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("clj"), "ㄕㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cx"), "ㄕㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxd"), "ㄕㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxf"), "ㄕㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxj"), "ㄕㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxy"), "ㄕㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxyf"), "ㄕㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxyj"), "ㄕㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxh"), "ㄕㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxhj"), "ㄕㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxi"), "ㄕㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxif"), "ㄕㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxij"), "ㄕㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxa"), "ㄕㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxad"), "ㄕㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxaf"), "ㄕㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxaj"), "ㄕㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxm"), "ㄕㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxmj"), "ㄕㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxnf"), "ㄕㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxnj"), "ㄕㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxk"), "ㄕㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxkd"), "ㄕㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxkf"), "ㄕㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cxkj"), "ㄕㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rj"), "ㄖˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rgf"), "ㄖㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rgj"), "ㄖㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rwd"), "ㄖㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rwf"), "ㄖㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rwj"), "ㄖㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rod"), "ㄖㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rof"), "ㄖㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("roj"), "ㄖㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmd"), "ㄖㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmf"), "ㄖㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rmj"), "ㄖㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rnd"), "ㄖㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rnf"), "ㄖㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rnj"), "ㄖㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rk"), "ㄖㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rkd"), "ㄖㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rkf"), "ㄖㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rkj"), "ㄖㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rl"), "ㄖㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rld"), "ㄖㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rlf"), "ㄖㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rlj"), "ㄖㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxd"), "ㄖㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxf"), "ㄖㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxj"), "ㄖㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxhd"), "ㄖㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxhj"), "ㄖㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxad"), "ㄖㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxaf"), "ㄖㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxaj"), "ㄖㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxmd"), "ㄖㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxmf"), "ㄖㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxmj"), "ㄖㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxnd"), "ㄖㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxnf"), "ㄖㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxnj"), "ㄖㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxld"), "ㄖㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxlf"), "ㄖㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rxlj"), "ㄖㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("z"), "ㄗ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zd"), "ㄗˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zf"), "ㄗˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zj"), "ㄗˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zs"), "ㄗ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("zy"), "ㄗㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zyd"), "ㄗㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zyf"), "ㄗㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zgd"), "ㄗㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zgf"), "ㄗㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zgj"), "ㄗㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zi"), "ㄗㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zif"), "ㄗㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zij"), "ㄗㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zad"), "ㄗㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zw"), "ㄗㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zwd"), "ㄗㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zwf"), "ㄗㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zwj"), "ㄗㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zo"), "ㄗㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zof"), "ㄗㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zoj"), "ㄗㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zm"), "ㄗㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zmd"), "ㄗㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zmf"), "ㄗㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zmj"), "ㄗㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zn"), "ㄗㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("znf"), "ㄗㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("znj"), "ㄗㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zk"), "ㄗㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zkf"), "ㄗㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zkj"), "ㄗㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zl"), "ㄗㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zlf"), "ㄗㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zlj"), "ㄗㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zx"), "ㄗㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxd"), "ㄗㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxf"), "ㄗㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxj"), "ㄗㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxh"), "ㄗㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxhd"), "ㄗㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxhf"), "ㄗㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxhj"), "ㄗㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxhs"), "ㄗㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxa"), "ㄗㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxaf"), "ㄗㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxaj"), "ㄗㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxm"), "ㄗㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxmf"), "ㄗㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxmj"), "ㄗㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxn"), "ㄗㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxnf"), "ㄗㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxnj"), "ㄗㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxl"), "ㄗㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxlf"), "ㄗㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zxlj"), "ㄗㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("a"), "ㄘ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ad"), "ㄘˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("af"), "ㄘˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aj"), "ㄘˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ay"), "ㄘㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ayf"), "ㄘㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ayj"), "ㄘㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("agj"), "ㄘㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ai"), "ㄘㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aid"), "ㄘㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aif"), "ㄘㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aij"), "ㄘㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aw"), "ㄘㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("awd"), "ㄘㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("awf"), "ㄘㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("awj"), "ㄘㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ao"), "ㄘㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aod"), "ㄘㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aof"), "ㄘㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("aoj"), "ㄘㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("am"), "ㄘㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("amd"), "ㄘㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("amf"), "ㄘㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("amj"), "ㄘㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("an"), "ㄘㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("and"), "ㄘㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ak"), "ㄘㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("akd"), "ㄘㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("akf"), "ㄘㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("akj"), "ㄘㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("al"), "ㄘㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ald"), "ㄘㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("alf"), "ㄘㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("alj"), "ㄘㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ax"), "ㄘㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axd"), "ㄘㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axf"), "ㄘㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axj"), "ㄘㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axh"), "ㄘㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axhd"), "ㄘㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axhf"), "ㄘㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axhj"), "ㄘㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axa"), "ㄘㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axaf"), "ㄘㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axaj"), "ㄘㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axm"), "ㄘㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axmd"), "ㄘㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axmf"), "ㄘㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axmj"), "ㄘㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axn"), "ㄘㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axnd"), "ㄘㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axnf"), "ㄘㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axnj"), "ㄘㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axl"), "ㄘㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axld"), "ㄘㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axlf"), "ㄘㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("axlj"), "ㄘㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("s"), "ㄙ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sf"), "ㄙˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sj"), "ㄙˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sy"), "ㄙㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("syf"), "ㄙㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("syj"), "ㄙㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sys"), "ㄙㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("sg"), "ㄙㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sgj"), "ㄙㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("si"), "ㄙㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sid"), "ㄙㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sif"), "ㄙㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sij"), "ㄙㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sa"), "ㄙㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sw"), "ㄙㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("swf"), "ㄙㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("swj"), "ㄙㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("so"), "ㄙㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sof"), "ㄙㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("soj"), "ㄙㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sm"), "ㄙㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("smf"), "ㄙㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("smj"), "ㄙㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sn"), "ㄙㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("snf"), "ㄙㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sk"), "ㄙㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("skf"), "ㄙㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("skj"), "ㄙㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sl"), "ㄙㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("slj"), "ㄙㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sx"), "ㄙㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxd"), "ㄙㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxf"), "ㄙㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxj"), "ㄙㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxh"), "ㄙㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxhd"), "ㄙㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxhf"), "ㄙㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxhj"), "ㄙㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxa"), "ㄙㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxad"), "ㄙㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxaf"), "ㄙㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxaj"), "ㄙㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxm"), "ㄙㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxmf"), "ㄙㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxmj"), "ㄙㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxn"), "ㄙㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxnf"), "ㄙㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxnj"), "ㄙㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxl"), "ㄙㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxld"), "ㄙㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxlf"), "ㄙㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sxlj"), "ㄙㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("y"), "ㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yd"), "ㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("yj"), "ㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ys"), "ㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("h "), "ㄛ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hd"), "ㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hf"), "ㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hj"), "ㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("g "), "ㄜ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gd"), "ㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gf"), "ㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gj"), "ㄜˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("ed"), "ㄝˊ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("ef"), "ㄝˇ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("ej"), "ㄝˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("es"), "ㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("i"), "ㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("id"), "ㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("if"), "ㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ij"), "ㄞˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("aj"), "ㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("w"), "ㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wd"), "ㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wf"), "ㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("wj"), "ㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("o"), "ㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("od"), "ㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("of"), "ㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("oj"), "ㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("os"), "ㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("m "), "ㄢ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("md"), "ㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mf"), "ㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mj"), "ㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("n "), "ㄣ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nd"), "ㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nf"), "ㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nj"), "ㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ns"), "ㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("k "), "ㄤ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kd"), "ㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kf"), "ㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kj"), "ㄤˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("l "), "ㄥ ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("lj"), "ㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("l "), "ㄦ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ld"), "ㄦˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lf"), "ㄦˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lj"), "ㄦˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ls"), "ㄦ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("e"), "ㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ed"), "ㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ef"), "ㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ej"), "ㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ey"), "ㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eyd"), "ㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eyf"), "ㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eyj"), "ㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eys"), "ㄧㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("eh"), "ㄧㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ehs"), "ㄧㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ee"), "ㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eed"), "ㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eef"), "ㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eej"), "ㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ees"), "ㄧㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("eid"), "ㄧㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ew"), "ㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ewd"), "ㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ewf"), "ㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ewj"), "ㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eo"), "ㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eod"), "ㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eof"), "ㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eoj"), "ㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("em"), "ㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("emd"), "ㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("emf"), "ㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("emj"), "ㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("en"), "ㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("end"), "ㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("enf"), "ㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("enj"), "ㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ek"), "ㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ekd"), "ㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ekf"), "ㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ekj"), "ㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("el"), "ㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("eld"), "ㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("elf"), "ㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("elj"), "ㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("x"), "ㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xd"), "ㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xf"), "ㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xj"), "ㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xy"), "ㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xyd"), "ㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xyf"), "ㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xyj"), "ㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xys"), "ㄨㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("xh"), "ㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xhf"), "ㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xhj"), "ㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xi"), "ㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xif"), "ㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xij"), "ㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xa"), "ㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xad"), "ㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xaf"), "ㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xaj"), "ㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xm"), "ㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmd"), "ㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmf"), "ㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xmj"), "ㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xn"), "ㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xnd"), "ㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xnf"), "ㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xnj"), "ㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xk"), "ㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xkd"), "ㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xkf"), "ㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xkj"), "ㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xl"), "ㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xlf"), "ㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xlj"), "ㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("u"), "ㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ud"), "ㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uf"), "ㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uj"), "ㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ue"), "ㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uef"), "ㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uej"), "ㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("um"), "ㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("umd"), "ㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("umf"), "ㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("umj"), "ㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("un"), "ㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("und"), "ㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("unf"), "ㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("unj"), "ㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ul"), "ㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uld"), "ㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ulf"), "ㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ulj"), "ㄩㄥˋ") + var c = Tekkon.Composer(arrange: .ofHsu) + XCTAssertEqual(c.cS2RC("jxhd"), "ㄓㄨㄛˊ") + XCTAssertEqual(c.cS2RC("jxhj"), "ㄓㄨㄛˋ") + XCTAssertEqual(c.cS2RC("jxi"), "ㄓㄨㄞ") + XCTAssertEqual(c.cS2RC("jxif"), "ㄓㄨㄞˇ") + XCTAssertEqual(c.cS2RC("jxij"), "ㄓㄨㄞˋ") + XCTAssertEqual(c.cS2RC("jxa"), "ㄓㄨㄟ") + XCTAssertEqual(c.cS2RC("jxaf"), "ㄓㄨㄟˇ") + XCTAssertEqual(c.cS2RC("jxaj"), "ㄓㄨㄟˋ") + XCTAssertEqual(c.cS2RC("jxm"), "ㄓㄨㄢ") + XCTAssertEqual(c.cS2RC("jxmf"), "ㄓㄨㄢˇ") + XCTAssertEqual(c.cS2RC("jxmj"), "ㄓㄨㄢˋ") + XCTAssertEqual(c.cS2RC("jxn"), "ㄓㄨㄣ") + XCTAssertEqual(c.cS2RC("jxnf"), "ㄓㄨㄣˇ") + XCTAssertEqual(c.cS2RC("jxnj"), "ㄓㄨㄣˋ") + XCTAssertEqual(c.cS2RC("jxk"), "ㄓㄨㄤ") + XCTAssertEqual(c.cS2RC("jxkf"), "ㄓㄨㄤˇ") + XCTAssertEqual(c.cS2RC("jxkj"), "ㄓㄨㄤˋ") + XCTAssertEqual(c.cS2RC("jxl"), "ㄓㄨㄥ") + XCTAssertEqual(c.cS2RC("jxlf"), "ㄓㄨㄥˇ") + XCTAssertEqual(c.cS2RC("jxlj"), "ㄓㄨㄥˋ") + XCTAssertEqual(c.cS2RC("v "), "ㄔ ") + XCTAssertEqual(c.cS2RC("vd"), "ㄔˊ") + XCTAssertEqual(c.cS2RC("vf"), "ㄔˇ") + XCTAssertEqual(c.cS2RC("vj"), "ㄔˋ") + XCTAssertEqual(c.cS2RC("vy"), "ㄔㄚ") + XCTAssertEqual(c.cS2RC("vyd"), "ㄔㄚˊ") + XCTAssertEqual(c.cS2RC("vyf"), "ㄔㄚˇ") + XCTAssertEqual(c.cS2RC("vyj"), "ㄔㄚˋ") + XCTAssertEqual(c.cS2RC("vg "), "ㄔㄜ ") + XCTAssertEqual(c.cS2RC("vgf"), "ㄔㄜˇ") + XCTAssertEqual(c.cS2RC("vgj"), "ㄔㄜˋ") + XCTAssertEqual(c.cS2RC("vi"), "ㄔㄞ") + XCTAssertEqual(c.cS2RC("vid"), "ㄔㄞˊ") + XCTAssertEqual(c.cS2RC("vif"), "ㄔㄞˇ") + XCTAssertEqual(c.cS2RC("vij"), "ㄔㄞˋ") + XCTAssertEqual(c.cS2RC("vw"), "ㄔㄠ") + XCTAssertEqual(c.cS2RC("vwd"), "ㄔㄠˊ") + XCTAssertEqual(c.cS2RC("vwf"), "ㄔㄠˇ") + XCTAssertEqual(c.cS2RC("vwj"), "ㄔㄠˋ") + XCTAssertEqual(c.cS2RC("vo"), "ㄔㄡ") + XCTAssertEqual(c.cS2RC("vod"), "ㄔㄡˊ") + XCTAssertEqual(c.cS2RC("vof"), "ㄔㄡˇ") + XCTAssertEqual(c.cS2RC("voj"), "ㄔㄡˋ") + XCTAssertEqual(c.cS2RC("vm "), "ㄔㄢ ") + XCTAssertEqual(c.cS2RC("vmd"), "ㄔㄢˊ") + XCTAssertEqual(c.cS2RC("vmf"), "ㄔㄢˇ") + XCTAssertEqual(c.cS2RC("vmj"), "ㄔㄢˋ") + XCTAssertEqual(c.cS2RC("vn "), "ㄔㄣ ") + XCTAssertEqual(c.cS2RC("vnd"), "ㄔㄣˊ") + XCTAssertEqual(c.cS2RC("vnf"), "ㄔㄣˇ") + XCTAssertEqual(c.cS2RC("vnj"), "ㄔㄣˋ") + XCTAssertEqual(c.cS2RC("vns"), "ㄔㄣ˙") + XCTAssertEqual(c.cS2RC("vk "), "ㄔㄤ ") + XCTAssertEqual(c.cS2RC("vkd"), "ㄔㄤˊ") + XCTAssertEqual(c.cS2RC("vkf"), "ㄔㄤˇ") + XCTAssertEqual(c.cS2RC("vkj"), "ㄔㄤˋ") + XCTAssertEqual(c.cS2RC("vl "), "ㄔㄥ ") + XCTAssertEqual(c.cS2RC("vld"), "ㄔㄥˊ") + XCTAssertEqual(c.cS2RC("vlf"), "ㄔㄥˇ") + XCTAssertEqual(c.cS2RC("vlj"), "ㄔㄥˋ") + XCTAssertEqual(c.cS2RC("vx"), "ㄔㄨ") + XCTAssertEqual(c.cS2RC("vxd"), "ㄔㄨˊ") + XCTAssertEqual(c.cS2RC("vxf"), "ㄔㄨˇ") + XCTAssertEqual(c.cS2RC("vxj"), "ㄔㄨˋ") + XCTAssertEqual(c.cS2RC("vxy"), "ㄔㄨㄚ") + XCTAssertEqual(c.cS2RC("vxyf"), "ㄔㄨㄚˇ") + XCTAssertEqual(c.cS2RC("vxyj"), "ㄔㄨㄚˋ") + XCTAssertEqual(c.cS2RC("vxh"), "ㄔㄨㄛ") + XCTAssertEqual(c.cS2RC("vxhj"), "ㄔㄨㄛˋ") + XCTAssertEqual(c.cS2RC("vxi"), "ㄔㄨㄞ") + XCTAssertEqual(c.cS2RC("vxid"), "ㄔㄨㄞˊ") + XCTAssertEqual(c.cS2RC("vxif"), "ㄔㄨㄞˇ") + XCTAssertEqual(c.cS2RC("vxij"), "ㄔㄨㄞˋ") + XCTAssertEqual(c.cS2RC("vxa"), "ㄔㄨㄟ") + XCTAssertEqual(c.cS2RC("vxad"), "ㄔㄨㄟˊ") + XCTAssertEqual(c.cS2RC("vxaf"), "ㄔㄨㄟˇ") + XCTAssertEqual(c.cS2RC("vxaj"), "ㄔㄨㄟˋ") + XCTAssertEqual(c.cS2RC("vxm"), "ㄔㄨㄢ") + XCTAssertEqual(c.cS2RC("vxmd"), "ㄔㄨㄢˊ") + XCTAssertEqual(c.cS2RC("vxmf"), "ㄔㄨㄢˇ") + XCTAssertEqual(c.cS2RC("vxmj"), "ㄔㄨㄢˋ") + XCTAssertEqual(c.cS2RC("vxn"), "ㄔㄨㄣ") + XCTAssertEqual(c.cS2RC("vxnd"), "ㄔㄨㄣˊ") + XCTAssertEqual(c.cS2RC("vxnf"), "ㄔㄨㄣˇ") + XCTAssertEqual(c.cS2RC("vxk"), "ㄔㄨㄤ") + XCTAssertEqual(c.cS2RC("vxkd"), "ㄔㄨㄤˊ") + XCTAssertEqual(c.cS2RC("vxkf"), "ㄔㄨㄤˇ") + XCTAssertEqual(c.cS2RC("vxkj"), "ㄔㄨㄤˋ") + XCTAssertEqual(c.cS2RC("vxl"), "ㄔㄨㄥ") + XCTAssertEqual(c.cS2RC("vxld"), "ㄔㄨㄥˊ") + XCTAssertEqual(c.cS2RC("vxlf"), "ㄔㄨㄥˇ") + XCTAssertEqual(c.cS2RC("vxlj"), "ㄔㄨㄥˋ") + XCTAssertEqual(c.cS2RC("c"), "ㄕ") + XCTAssertEqual(c.cS2RC("cd"), "ㄕˊ") + XCTAssertEqual(c.cS2RC("cf"), "ㄕˇ") + XCTAssertEqual(c.cS2RC("cj"), "ㄕˋ") + XCTAssertEqual(c.cS2RC("cs"), "ㄕ˙") + XCTAssertEqual(c.cS2RC("cy"), "ㄕㄚ") + XCTAssertEqual(c.cS2RC("cyd"), "ㄕㄚˊ") + XCTAssertEqual(c.cS2RC("cyf"), "ㄕㄚˇ") + XCTAssertEqual(c.cS2RC("cyj"), "ㄕㄚˋ") + XCTAssertEqual(c.cS2RC("cys"), "ㄕㄚ˙") + XCTAssertEqual(c.cS2RC("cg"), "ㄕㄜ") + XCTAssertEqual(c.cS2RC("cgd"), "ㄕㄜˊ") + XCTAssertEqual(c.cS2RC("cgf"), "ㄕㄜˇ") + XCTAssertEqual(c.cS2RC("cgj"), "ㄕㄜˋ") + XCTAssertEqual(c.cS2RC("ci"), "ㄕㄞ") + XCTAssertEqual(c.cS2RC("cif"), "ㄕㄞˇ") + XCTAssertEqual(c.cS2RC("cij"), "ㄕㄞˋ") + XCTAssertEqual(c.cS2RC("cad"), "ㄕㄟˊ") + XCTAssertEqual(c.cS2RC("cw"), "ㄕㄠ") + XCTAssertEqual(c.cS2RC("cwd"), "ㄕㄠˊ") + XCTAssertEqual(c.cS2RC("cwf"), "ㄕㄠˇ") + XCTAssertEqual(c.cS2RC("cwj"), "ㄕㄠˋ") + XCTAssertEqual(c.cS2RC("co"), "ㄕㄡ") + XCTAssertEqual(c.cS2RC("cod"), "ㄕㄡˊ") + XCTAssertEqual(c.cS2RC("cof"), "ㄕㄡˇ") + XCTAssertEqual(c.cS2RC("coj"), "ㄕㄡˋ") + XCTAssertEqual(c.cS2RC("cm"), "ㄕㄢ") + XCTAssertEqual(c.cS2RC("cmd"), "ㄕㄢˊ") + XCTAssertEqual(c.cS2RC("cmf"), "ㄕㄢˇ") + XCTAssertEqual(c.cS2RC("cmj"), "ㄕㄢˋ") + XCTAssertEqual(c.cS2RC("cn"), "ㄕㄣ") + XCTAssertEqual(c.cS2RC("cnd"), "ㄕㄣˊ") + XCTAssertEqual(c.cS2RC("cnf"), "ㄕㄣˇ") + XCTAssertEqual(c.cS2RC("cnj"), "ㄕㄣˋ") + XCTAssertEqual(c.cS2RC("ck"), "ㄕㄤ") + XCTAssertEqual(c.cS2RC("ckf"), "ㄕㄤˇ") + XCTAssertEqual(c.cS2RC("ckj"), "ㄕㄤˋ") + XCTAssertEqual(c.cS2RC("cks"), "ㄕㄤ˙") + XCTAssertEqual(c.cS2RC("cl"), "ㄕㄥ") + XCTAssertEqual(c.cS2RC("cld"), "ㄕㄥˊ") + XCTAssertEqual(c.cS2RC("clf"), "ㄕㄥˇ") + XCTAssertEqual(c.cS2RC("clj"), "ㄕㄥˋ") + XCTAssertEqual(c.cS2RC("cx"), "ㄕㄨ") + XCTAssertEqual(c.cS2RC("cxd"), "ㄕㄨˊ") + XCTAssertEqual(c.cS2RC("cxf"), "ㄕㄨˇ") + XCTAssertEqual(c.cS2RC("cxj"), "ㄕㄨˋ") + XCTAssertEqual(c.cS2RC("cxy"), "ㄕㄨㄚ") + XCTAssertEqual(c.cS2RC("cxyf"), "ㄕㄨㄚˇ") + XCTAssertEqual(c.cS2RC("cxyj"), "ㄕㄨㄚˋ") + XCTAssertEqual(c.cS2RC("cxh"), "ㄕㄨㄛ") + XCTAssertEqual(c.cS2RC("cxhj"), "ㄕㄨㄛˋ") + XCTAssertEqual(c.cS2RC("cxi"), "ㄕㄨㄞ") + XCTAssertEqual(c.cS2RC("cxif"), "ㄕㄨㄞˇ") + XCTAssertEqual(c.cS2RC("cxij"), "ㄕㄨㄞˋ") + XCTAssertEqual(c.cS2RC("cxa"), "ㄕㄨㄟ") + XCTAssertEqual(c.cS2RC("cxad"), "ㄕㄨㄟˊ") + XCTAssertEqual(c.cS2RC("cxaf"), "ㄕㄨㄟˇ") + XCTAssertEqual(c.cS2RC("cxaj"), "ㄕㄨㄟˋ") + XCTAssertEqual(c.cS2RC("cxm"), "ㄕㄨㄢ") + XCTAssertEqual(c.cS2RC("cxmj"), "ㄕㄨㄢˋ") + XCTAssertEqual(c.cS2RC("cxnf"), "ㄕㄨㄣˇ") + XCTAssertEqual(c.cS2RC("cxnj"), "ㄕㄨㄣˋ") + XCTAssertEqual(c.cS2RC("cxk"), "ㄕㄨㄤ") + XCTAssertEqual(c.cS2RC("cxkd"), "ㄕㄨㄤˊ") + XCTAssertEqual(c.cS2RC("cxkf"), "ㄕㄨㄤˇ") + XCTAssertEqual(c.cS2RC("cxkj"), "ㄕㄨㄤˋ") + XCTAssertEqual(c.cS2RC("rj"), "ㄖˋ") + XCTAssertEqual(c.cS2RC("rgf"), "ㄖㄜˇ") + XCTAssertEqual(c.cS2RC("rgj"), "ㄖㄜˋ") + XCTAssertEqual(c.cS2RC("rwd"), "ㄖㄠˊ") + XCTAssertEqual(c.cS2RC("rwf"), "ㄖㄠˇ") + XCTAssertEqual(c.cS2RC("rwj"), "ㄖㄠˋ") + XCTAssertEqual(c.cS2RC("rod"), "ㄖㄡˊ") + XCTAssertEqual(c.cS2RC("rof"), "ㄖㄡˇ") + XCTAssertEqual(c.cS2RC("roj"), "ㄖㄡˋ") + XCTAssertEqual(c.cS2RC("rmd"), "ㄖㄢˊ") + XCTAssertEqual(c.cS2RC("rmf"), "ㄖㄢˇ") + XCTAssertEqual(c.cS2RC("rmj"), "ㄖㄢˋ") + XCTAssertEqual(c.cS2RC("rnd"), "ㄖㄣˊ") + XCTAssertEqual(c.cS2RC("rnf"), "ㄖㄣˇ") + XCTAssertEqual(c.cS2RC("rnj"), "ㄖㄣˋ") + XCTAssertEqual(c.cS2RC("rk"), "ㄖㄤ") + XCTAssertEqual(c.cS2RC("rkd"), "ㄖㄤˊ") + XCTAssertEqual(c.cS2RC("rkf"), "ㄖㄤˇ") + XCTAssertEqual(c.cS2RC("rkj"), "ㄖㄤˋ") + XCTAssertEqual(c.cS2RC("rl"), "ㄖㄥ") + XCTAssertEqual(c.cS2RC("rld"), "ㄖㄥˊ") + XCTAssertEqual(c.cS2RC("rlf"), "ㄖㄥˇ") + XCTAssertEqual(c.cS2RC("rlj"), "ㄖㄥˋ") + XCTAssertEqual(c.cS2RC("rxd"), "ㄖㄨˊ") + XCTAssertEqual(c.cS2RC("rxf"), "ㄖㄨˇ") + XCTAssertEqual(c.cS2RC("rxj"), "ㄖㄨˋ") + XCTAssertEqual(c.cS2RC("rxhd"), "ㄖㄨㄛˊ") + XCTAssertEqual(c.cS2RC("rxhj"), "ㄖㄨㄛˋ") + XCTAssertEqual(c.cS2RC("rxad"), "ㄖㄨㄟˊ") + XCTAssertEqual(c.cS2RC("rxaf"), "ㄖㄨㄟˇ") + XCTAssertEqual(c.cS2RC("rxaj"), "ㄖㄨㄟˋ") + XCTAssertEqual(c.cS2RC("rxmd"), "ㄖㄨㄢˊ") + XCTAssertEqual(c.cS2RC("rxmf"), "ㄖㄨㄢˇ") + XCTAssertEqual(c.cS2RC("rxmj"), "ㄖㄨㄢˋ") + XCTAssertEqual(c.cS2RC("rxnd"), "ㄖㄨㄣˊ") + XCTAssertEqual(c.cS2RC("rxnf"), "ㄖㄨㄣˇ") + XCTAssertEqual(c.cS2RC("rxnj"), "ㄖㄨㄣˋ") + XCTAssertEqual(c.cS2RC("rxld"), "ㄖㄨㄥˊ") + XCTAssertEqual(c.cS2RC("rxlf"), "ㄖㄨㄥˇ") + XCTAssertEqual(c.cS2RC("rxlj"), "ㄖㄨㄥˋ") + XCTAssertEqual(c.cS2RC("z"), "ㄗ") + XCTAssertEqual(c.cS2RC("zd"), "ㄗˊ") + XCTAssertEqual(c.cS2RC("zf"), "ㄗˇ") + XCTAssertEqual(c.cS2RC("zj"), "ㄗˋ") + XCTAssertEqual(c.cS2RC("zs"), "ㄗ˙") + XCTAssertEqual(c.cS2RC("zy"), "ㄗㄚ") + XCTAssertEqual(c.cS2RC("zyd"), "ㄗㄚˊ") + XCTAssertEqual(c.cS2RC("zyf"), "ㄗㄚˇ") + XCTAssertEqual(c.cS2RC("zgd"), "ㄗㄜˊ") + XCTAssertEqual(c.cS2RC("zgf"), "ㄗㄜˇ") + XCTAssertEqual(c.cS2RC("zgj"), "ㄗㄜˋ") + XCTAssertEqual(c.cS2RC("zi"), "ㄗㄞ") + XCTAssertEqual(c.cS2RC("zif"), "ㄗㄞˇ") + XCTAssertEqual(c.cS2RC("zij"), "ㄗㄞˋ") + XCTAssertEqual(c.cS2RC("zad"), "ㄗㄟˊ") + XCTAssertEqual(c.cS2RC("zw"), "ㄗㄠ") + XCTAssertEqual(c.cS2RC("zwd"), "ㄗㄠˊ") + XCTAssertEqual(c.cS2RC("zwf"), "ㄗㄠˇ") + XCTAssertEqual(c.cS2RC("zwj"), "ㄗㄠˋ") + XCTAssertEqual(c.cS2RC("zo"), "ㄗㄡ") + XCTAssertEqual(c.cS2RC("zof"), "ㄗㄡˇ") + XCTAssertEqual(c.cS2RC("zoj"), "ㄗㄡˋ") + XCTAssertEqual(c.cS2RC("zm"), "ㄗㄢ") + XCTAssertEqual(c.cS2RC("zmd"), "ㄗㄢˊ") + XCTAssertEqual(c.cS2RC("zmf"), "ㄗㄢˇ") + XCTAssertEqual(c.cS2RC("zmj"), "ㄗㄢˋ") + XCTAssertEqual(c.cS2RC("zn"), "ㄗㄣ") + XCTAssertEqual(c.cS2RC("znf"), "ㄗㄣˇ") + XCTAssertEqual(c.cS2RC("znj"), "ㄗㄣˋ") + XCTAssertEqual(c.cS2RC("zk"), "ㄗㄤ") + XCTAssertEqual(c.cS2RC("zkf"), "ㄗㄤˇ") + XCTAssertEqual(c.cS2RC("zkj"), "ㄗㄤˋ") + XCTAssertEqual(c.cS2RC("zl"), "ㄗㄥ") + XCTAssertEqual(c.cS2RC("zlf"), "ㄗㄥˇ") + XCTAssertEqual(c.cS2RC("zlj"), "ㄗㄥˋ") + XCTAssertEqual(c.cS2RC("zx"), "ㄗㄨ") + XCTAssertEqual(c.cS2RC("zxd"), "ㄗㄨˊ") + XCTAssertEqual(c.cS2RC("zxf"), "ㄗㄨˇ") + XCTAssertEqual(c.cS2RC("zxj"), "ㄗㄨˋ") + XCTAssertEqual(c.cS2RC("zxh"), "ㄗㄨㄛ") + XCTAssertEqual(c.cS2RC("zxhd"), "ㄗㄨㄛˊ") + XCTAssertEqual(c.cS2RC("zxhf"), "ㄗㄨㄛˇ") + XCTAssertEqual(c.cS2RC("zxhj"), "ㄗㄨㄛˋ") + XCTAssertEqual(c.cS2RC("zxhs"), "ㄗㄨㄛ˙") + XCTAssertEqual(c.cS2RC("zxa"), "ㄗㄨㄟ") + XCTAssertEqual(c.cS2RC("zxaf"), "ㄗㄨㄟˇ") + XCTAssertEqual(c.cS2RC("zxaj"), "ㄗㄨㄟˋ") + XCTAssertEqual(c.cS2RC("zxm"), "ㄗㄨㄢ") + XCTAssertEqual(c.cS2RC("zxmf"), "ㄗㄨㄢˇ") + XCTAssertEqual(c.cS2RC("zxmj"), "ㄗㄨㄢˋ") + XCTAssertEqual(c.cS2RC("zxn"), "ㄗㄨㄣ") + XCTAssertEqual(c.cS2RC("zxnf"), "ㄗㄨㄣˇ") + XCTAssertEqual(c.cS2RC("zxnj"), "ㄗㄨㄣˋ") + XCTAssertEqual(c.cS2RC("zxl"), "ㄗㄨㄥ") + XCTAssertEqual(c.cS2RC("zxlf"), "ㄗㄨㄥˇ") + XCTAssertEqual(c.cS2RC("zxlj"), "ㄗㄨㄥˋ") + XCTAssertEqual(c.cS2RC("a"), "ㄘ") + XCTAssertEqual(c.cS2RC("ad"), "ㄘˊ") + XCTAssertEqual(c.cS2RC("af"), "ㄘˇ") + XCTAssertEqual(c.cS2RC("aj"), "ㄘˋ") + XCTAssertEqual(c.cS2RC("ay"), "ㄘㄚ") + XCTAssertEqual(c.cS2RC("ayf"), "ㄘㄚˇ") + XCTAssertEqual(c.cS2RC("ayj"), "ㄘㄚˋ") + XCTAssertEqual(c.cS2RC("agj"), "ㄘㄜˋ") + XCTAssertEqual(c.cS2RC("ai"), "ㄘㄞ") + XCTAssertEqual(c.cS2RC("aid"), "ㄘㄞˊ") + XCTAssertEqual(c.cS2RC("aif"), "ㄘㄞˇ") + XCTAssertEqual(c.cS2RC("aij"), "ㄘㄞˋ") + XCTAssertEqual(c.cS2RC("aw"), "ㄘㄠ") + XCTAssertEqual(c.cS2RC("awd"), "ㄘㄠˊ") + XCTAssertEqual(c.cS2RC("awf"), "ㄘㄠˇ") + XCTAssertEqual(c.cS2RC("awj"), "ㄘㄠˋ") + XCTAssertEqual(c.cS2RC("ao"), "ㄘㄡ") + XCTAssertEqual(c.cS2RC("aod"), "ㄘㄡˊ") + XCTAssertEqual(c.cS2RC("aof"), "ㄘㄡˇ") + XCTAssertEqual(c.cS2RC("aoj"), "ㄘㄡˋ") + XCTAssertEqual(c.cS2RC("am"), "ㄘㄢ") + XCTAssertEqual(c.cS2RC("amd"), "ㄘㄢˊ") + XCTAssertEqual(c.cS2RC("amf"), "ㄘㄢˇ") + XCTAssertEqual(c.cS2RC("amj"), "ㄘㄢˋ") + XCTAssertEqual(c.cS2RC("an"), "ㄘㄣ") + XCTAssertEqual(c.cS2RC("and"), "ㄘㄣˊ") + XCTAssertEqual(c.cS2RC("ak"), "ㄘㄤ") + XCTAssertEqual(c.cS2RC("akd"), "ㄘㄤˊ") + XCTAssertEqual(c.cS2RC("akf"), "ㄘㄤˇ") + XCTAssertEqual(c.cS2RC("akj"), "ㄘㄤˋ") + XCTAssertEqual(c.cS2RC("al"), "ㄘㄥ") + XCTAssertEqual(c.cS2RC("ald"), "ㄘㄥˊ") + XCTAssertEqual(c.cS2RC("alf"), "ㄘㄥˇ") + XCTAssertEqual(c.cS2RC("alj"), "ㄘㄥˋ") + XCTAssertEqual(c.cS2RC("ax"), "ㄘㄨ") + XCTAssertEqual(c.cS2RC("axd"), "ㄘㄨˊ") + XCTAssertEqual(c.cS2RC("axf"), "ㄘㄨˇ") + XCTAssertEqual(c.cS2RC("axj"), "ㄘㄨˋ") + XCTAssertEqual(c.cS2RC("axh"), "ㄘㄨㄛ") + XCTAssertEqual(c.cS2RC("axhd"), "ㄘㄨㄛˊ") + XCTAssertEqual(c.cS2RC("axhf"), "ㄘㄨㄛˇ") + XCTAssertEqual(c.cS2RC("axhj"), "ㄘㄨㄛˋ") + XCTAssertEqual(c.cS2RC("axa"), "ㄘㄨㄟ") + XCTAssertEqual(c.cS2RC("axaf"), "ㄘㄨㄟˇ") + XCTAssertEqual(c.cS2RC("axaj"), "ㄘㄨㄟˋ") + XCTAssertEqual(c.cS2RC("axm"), "ㄘㄨㄢ") + XCTAssertEqual(c.cS2RC("axmd"), "ㄘㄨㄢˊ") + XCTAssertEqual(c.cS2RC("axmf"), "ㄘㄨㄢˇ") + XCTAssertEqual(c.cS2RC("axmj"), "ㄘㄨㄢˋ") + XCTAssertEqual(c.cS2RC("axn"), "ㄘㄨㄣ") + XCTAssertEqual(c.cS2RC("axnd"), "ㄘㄨㄣˊ") + XCTAssertEqual(c.cS2RC("axnf"), "ㄘㄨㄣˇ") + XCTAssertEqual(c.cS2RC("axnj"), "ㄘㄨㄣˋ") + XCTAssertEqual(c.cS2RC("axl"), "ㄘㄨㄥ") + XCTAssertEqual(c.cS2RC("axld"), "ㄘㄨㄥˊ") + XCTAssertEqual(c.cS2RC("axlf"), "ㄘㄨㄥˇ") + XCTAssertEqual(c.cS2RC("axlj"), "ㄘㄨㄥˋ") + XCTAssertEqual(c.cS2RC("s"), "ㄙ") + XCTAssertEqual(c.cS2RC("sf"), "ㄙˇ") + XCTAssertEqual(c.cS2RC("sj"), "ㄙˋ") + XCTAssertEqual(c.cS2RC("sy"), "ㄙㄚ") + XCTAssertEqual(c.cS2RC("syf"), "ㄙㄚˇ") + XCTAssertEqual(c.cS2RC("syj"), "ㄙㄚˋ") + XCTAssertEqual(c.cS2RC("sys"), "ㄙㄚ˙") + XCTAssertEqual(c.cS2RC("sg"), "ㄙㄜ") + XCTAssertEqual(c.cS2RC("sgj"), "ㄙㄜˋ") + XCTAssertEqual(c.cS2RC("si"), "ㄙㄞ") + XCTAssertEqual(c.cS2RC("sid"), "ㄙㄞˊ") + XCTAssertEqual(c.cS2RC("sif"), "ㄙㄞˇ") + XCTAssertEqual(c.cS2RC("sij"), "ㄙㄞˋ") + XCTAssertEqual(c.cS2RC("sa"), "ㄙㄟ") + XCTAssertEqual(c.cS2RC("sw"), "ㄙㄠ") + XCTAssertEqual(c.cS2RC("swf"), "ㄙㄠˇ") + XCTAssertEqual(c.cS2RC("swj"), "ㄙㄠˋ") + XCTAssertEqual(c.cS2RC("so"), "ㄙㄡ") + XCTAssertEqual(c.cS2RC("sof"), "ㄙㄡˇ") + XCTAssertEqual(c.cS2RC("soj"), "ㄙㄡˋ") + XCTAssertEqual(c.cS2RC("sm"), "ㄙㄢ") + XCTAssertEqual(c.cS2RC("smf"), "ㄙㄢˇ") + XCTAssertEqual(c.cS2RC("smj"), "ㄙㄢˋ") + XCTAssertEqual(c.cS2RC("sn"), "ㄙㄣ") + XCTAssertEqual(c.cS2RC("snf"), "ㄙㄣˇ") + XCTAssertEqual(c.cS2RC("sk"), "ㄙㄤ") + XCTAssertEqual(c.cS2RC("skf"), "ㄙㄤˇ") + XCTAssertEqual(c.cS2RC("skj"), "ㄙㄤˋ") + XCTAssertEqual(c.cS2RC("sl"), "ㄙㄥ") + XCTAssertEqual(c.cS2RC("slj"), "ㄙㄥˋ") + XCTAssertEqual(c.cS2RC("sx"), "ㄙㄨ") + XCTAssertEqual(c.cS2RC("sxd"), "ㄙㄨˊ") + XCTAssertEqual(c.cS2RC("sxf"), "ㄙㄨˇ") + XCTAssertEqual(c.cS2RC("sxj"), "ㄙㄨˋ") + XCTAssertEqual(c.cS2RC("sxh"), "ㄙㄨㄛ") + XCTAssertEqual(c.cS2RC("sxhd"), "ㄙㄨㄛˊ") + XCTAssertEqual(c.cS2RC("sxhf"), "ㄙㄨㄛˇ") + XCTAssertEqual(c.cS2RC("sxhj"), "ㄙㄨㄛˋ") + XCTAssertEqual(c.cS2RC("sxa"), "ㄙㄨㄟ") + XCTAssertEqual(c.cS2RC("sxad"), "ㄙㄨㄟˊ") + XCTAssertEqual(c.cS2RC("sxaf"), "ㄙㄨㄟˇ") + XCTAssertEqual(c.cS2RC("sxaj"), "ㄙㄨㄟˋ") + XCTAssertEqual(c.cS2RC("sxm"), "ㄙㄨㄢ") + XCTAssertEqual(c.cS2RC("sxmf"), "ㄙㄨㄢˇ") + XCTAssertEqual(c.cS2RC("sxmj"), "ㄙㄨㄢˋ") + XCTAssertEqual(c.cS2RC("sxn"), "ㄙㄨㄣ") + XCTAssertEqual(c.cS2RC("sxnf"), "ㄙㄨㄣˇ") + XCTAssertEqual(c.cS2RC("sxnj"), "ㄙㄨㄣˋ") + XCTAssertEqual(c.cS2RC("sxl"), "ㄙㄨㄥ") + XCTAssertEqual(c.cS2RC("sxld"), "ㄙㄨㄥˊ") + XCTAssertEqual(c.cS2RC("sxlf"), "ㄙㄨㄥˇ") + XCTAssertEqual(c.cS2RC("sxlj"), "ㄙㄨㄥˋ") + XCTAssertEqual(c.cS2RC("y"), "ㄚ") + XCTAssertEqual(c.cS2RC("yd"), "ㄚˊ") + XCTAssertEqual(c.cS2RC("yj"), "ㄚˋ") + XCTAssertEqual(c.cS2RC("ys"), "ㄚ˙") + XCTAssertEqual(c.cS2RC("h "), "ㄛ ") + XCTAssertEqual(c.cS2RC("hd"), "ㄛˊ") + XCTAssertEqual(c.cS2RC("hf"), "ㄛˇ") + XCTAssertEqual(c.cS2RC("hj"), "ㄛˋ") + XCTAssertEqual(c.cS2RC("g "), "ㄜ ") + XCTAssertEqual(c.cS2RC("gd"), "ㄜˊ") + XCTAssertEqual(c.cS2RC("gf"), "ㄜˇ") + XCTAssertEqual(c.cS2RC("gj"), "ㄜˋ") + // XCTAssertEqual(c.cS2RC("ed"), "ㄝˊ") + // XCTAssertEqual(c.cS2RC("ef"), "ㄝˇ") + // XCTAssertEqual(c.cS2RC("ej"), "ㄝˋ") + // XCTAssertEqual(c.cS2RC("es"), "ㄝ˙") + XCTAssertEqual(c.cS2RC("i"), "ㄞ") + XCTAssertEqual(c.cS2RC("id"), "ㄞˊ") + XCTAssertEqual(c.cS2RC("if"), "ㄞˇ") + XCTAssertEqual(c.cS2RC("ij"), "ㄞˋ") + // XCTAssertEqual(c.cS2RC("aj"), "ㄟˋ") + XCTAssertEqual(c.cS2RC("w"), "ㄠ") + XCTAssertEqual(c.cS2RC("wd"), "ㄠˊ") + XCTAssertEqual(c.cS2RC("wf"), "ㄠˇ") + XCTAssertEqual(c.cS2RC("wj"), "ㄠˋ") + XCTAssertEqual(c.cS2RC("o"), "ㄡ") + XCTAssertEqual(c.cS2RC("od"), "ㄡˊ") + XCTAssertEqual(c.cS2RC("of"), "ㄡˇ") + XCTAssertEqual(c.cS2RC("oj"), "ㄡˋ") + XCTAssertEqual(c.cS2RC("os"), "ㄡ˙") + XCTAssertEqual(c.cS2RC("m "), "ㄢ ") + XCTAssertEqual(c.cS2RC("md"), "ㄢˊ") + XCTAssertEqual(c.cS2RC("mf"), "ㄢˇ") + XCTAssertEqual(c.cS2RC("mj"), "ㄢˋ") + XCTAssertEqual(c.cS2RC("n "), "ㄣ ") + XCTAssertEqual(c.cS2RC("nd"), "ㄣˊ") + XCTAssertEqual(c.cS2RC("nf"), "ㄣˇ") + XCTAssertEqual(c.cS2RC("nj"), "ㄣˋ") + XCTAssertEqual(c.cS2RC("ns"), "ㄣ˙") + XCTAssertEqual(c.cS2RC("k "), "ㄤ ") + XCTAssertEqual(c.cS2RC("kd"), "ㄤˊ") + XCTAssertEqual(c.cS2RC("kf"), "ㄤˇ") + XCTAssertEqual(c.cS2RC("kj"), "ㄤˋ") + // XCTAssertEqual(c.cS2RC("l "), "ㄥ ") + // XCTAssertEqual(c.cS2RC("lj"), "ㄥˋ") + XCTAssertEqual(c.cS2RC("l "), "ㄦ ") + XCTAssertEqual(c.cS2RC("ld"), "ㄦˊ") + XCTAssertEqual(c.cS2RC("lf"), "ㄦˇ") + XCTAssertEqual(c.cS2RC("lj"), "ㄦˋ") + XCTAssertEqual(c.cS2RC("ls"), "ㄦ˙") + XCTAssertEqual(c.cS2RC("e"), "ㄧ") + XCTAssertEqual(c.cS2RC("ed"), "ㄧˊ") + XCTAssertEqual(c.cS2RC("ef"), "ㄧˇ") + XCTAssertEqual(c.cS2RC("ej"), "ㄧˋ") + XCTAssertEqual(c.cS2RC("ey"), "ㄧㄚ") + XCTAssertEqual(c.cS2RC("eyd"), "ㄧㄚˊ") + XCTAssertEqual(c.cS2RC("eyf"), "ㄧㄚˇ") + XCTAssertEqual(c.cS2RC("eyj"), "ㄧㄚˋ") + XCTAssertEqual(c.cS2RC("eys"), "ㄧㄚ˙") + XCTAssertEqual(c.cS2RC("eh"), "ㄧㄛ") + XCTAssertEqual(c.cS2RC("ehs"), "ㄧㄛ˙") + XCTAssertEqual(c.cS2RC("ee"), "ㄧㄝ") + XCTAssertEqual(c.cS2RC("eed"), "ㄧㄝˊ") + XCTAssertEqual(c.cS2RC("eef"), "ㄧㄝˇ") + XCTAssertEqual(c.cS2RC("eej"), "ㄧㄝˋ") + XCTAssertEqual(c.cS2RC("ees"), "ㄧㄝ˙") + XCTAssertEqual(c.cS2RC("eid"), "ㄧㄞˊ") + XCTAssertEqual(c.cS2RC("ew"), "ㄧㄠ") + XCTAssertEqual(c.cS2RC("ewd"), "ㄧㄠˊ") + XCTAssertEqual(c.cS2RC("ewf"), "ㄧㄠˇ") + XCTAssertEqual(c.cS2RC("ewj"), "ㄧㄠˋ") + XCTAssertEqual(c.cS2RC("eo"), "ㄧㄡ") + XCTAssertEqual(c.cS2RC("eod"), "ㄧㄡˊ") + XCTAssertEqual(c.cS2RC("eof"), "ㄧㄡˇ") + XCTAssertEqual(c.cS2RC("eoj"), "ㄧㄡˋ") + XCTAssertEqual(c.cS2RC("em"), "ㄧㄢ") + XCTAssertEqual(c.cS2RC("emd"), "ㄧㄢˊ") + XCTAssertEqual(c.cS2RC("emf"), "ㄧㄢˇ") + XCTAssertEqual(c.cS2RC("emj"), "ㄧㄢˋ") + XCTAssertEqual(c.cS2RC("en"), "ㄧㄣ") + XCTAssertEqual(c.cS2RC("end"), "ㄧㄣˊ") + XCTAssertEqual(c.cS2RC("enf"), "ㄧㄣˇ") + XCTAssertEqual(c.cS2RC("enj"), "ㄧㄣˋ") + XCTAssertEqual(c.cS2RC("ek"), "ㄧㄤ") + XCTAssertEqual(c.cS2RC("ekd"), "ㄧㄤˊ") + XCTAssertEqual(c.cS2RC("ekf"), "ㄧㄤˇ") + XCTAssertEqual(c.cS2RC("ekj"), "ㄧㄤˋ") + XCTAssertEqual(c.cS2RC("el"), "ㄧㄥ") + XCTAssertEqual(c.cS2RC("eld"), "ㄧㄥˊ") + XCTAssertEqual(c.cS2RC("elf"), "ㄧㄥˇ") + XCTAssertEqual(c.cS2RC("elj"), "ㄧㄥˋ") + XCTAssertEqual(c.cS2RC("x"), "ㄨ") + XCTAssertEqual(c.cS2RC("xd"), "ㄨˊ") + XCTAssertEqual(c.cS2RC("xf"), "ㄨˇ") + XCTAssertEqual(c.cS2RC("xj"), "ㄨˋ") + XCTAssertEqual(c.cS2RC("xy"), "ㄨㄚ") + XCTAssertEqual(c.cS2RC("xyd"), "ㄨㄚˊ") + XCTAssertEqual(c.cS2RC("xyf"), "ㄨㄚˇ") + XCTAssertEqual(c.cS2RC("xyj"), "ㄨㄚˋ") + XCTAssertEqual(c.cS2RC("xys"), "ㄨㄚ˙") + XCTAssertEqual(c.cS2RC("xh"), "ㄨㄛ") + XCTAssertEqual(c.cS2RC("xhf"), "ㄨㄛˇ") + XCTAssertEqual(c.cS2RC("xhj"), "ㄨㄛˋ") + XCTAssertEqual(c.cS2RC("xi"), "ㄨㄞ") + XCTAssertEqual(c.cS2RC("xif"), "ㄨㄞˇ") + XCTAssertEqual(c.cS2RC("xij"), "ㄨㄞˋ") + XCTAssertEqual(c.cS2RC("xa"), "ㄨㄟ") + XCTAssertEqual(c.cS2RC("xad"), "ㄨㄟˊ") + XCTAssertEqual(c.cS2RC("xaf"), "ㄨㄟˇ") + XCTAssertEqual(c.cS2RC("xaj"), "ㄨㄟˋ") + XCTAssertEqual(c.cS2RC("xm"), "ㄨㄢ") + XCTAssertEqual(c.cS2RC("xmd"), "ㄨㄢˊ") + XCTAssertEqual(c.cS2RC("xmf"), "ㄨㄢˇ") + XCTAssertEqual(c.cS2RC("xmj"), "ㄨㄢˋ") + XCTAssertEqual(c.cS2RC("xn"), "ㄨㄣ") + XCTAssertEqual(c.cS2RC("xnd"), "ㄨㄣˊ") + XCTAssertEqual(c.cS2RC("xnf"), "ㄨㄣˇ") + XCTAssertEqual(c.cS2RC("xnj"), "ㄨㄣˋ") + XCTAssertEqual(c.cS2RC("xk"), "ㄨㄤ") + XCTAssertEqual(c.cS2RC("xkd"), "ㄨㄤˊ") + XCTAssertEqual(c.cS2RC("xkf"), "ㄨㄤˇ") + XCTAssertEqual(c.cS2RC("xkj"), "ㄨㄤˋ") + XCTAssertEqual(c.cS2RC("xl"), "ㄨㄥ") + XCTAssertEqual(c.cS2RC("xlf"), "ㄨㄥˇ") + XCTAssertEqual(c.cS2RC("xlj"), "ㄨㄥˋ") + XCTAssertEqual(c.cS2RC("u"), "ㄩ") + XCTAssertEqual(c.cS2RC("ud"), "ㄩˊ") + XCTAssertEqual(c.cS2RC("uf"), "ㄩˇ") + XCTAssertEqual(c.cS2RC("uj"), "ㄩˋ") + XCTAssertEqual(c.cS2RC("ue"), "ㄩㄝ") + XCTAssertEqual(c.cS2RC("uef"), "ㄩㄝˇ") + XCTAssertEqual(c.cS2RC("uej"), "ㄩㄝˋ") + XCTAssertEqual(c.cS2RC("um"), "ㄩㄢ") + XCTAssertEqual(c.cS2RC("umd"), "ㄩㄢˊ") + XCTAssertEqual(c.cS2RC("umf"), "ㄩㄢˇ") + XCTAssertEqual(c.cS2RC("umj"), "ㄩㄢˋ") + XCTAssertEqual(c.cS2RC("un"), "ㄩㄣ") + XCTAssertEqual(c.cS2RC("und"), "ㄩㄣˊ") + XCTAssertEqual(c.cS2RC("unf"), "ㄩㄣˇ") + XCTAssertEqual(c.cS2RC("unj"), "ㄩㄣˋ") + XCTAssertEqual(c.cS2RC("ul"), "ㄩㄥ") + XCTAssertEqual(c.cS2RC("uld"), "ㄩㄥˊ") + XCTAssertEqual(c.cS2RC("ulf"), "ㄩㄥˇ") + XCTAssertEqual(c.cS2RC("ulj"), "ㄩㄥˋ") } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_A.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_A.swift index 2a983f91..c432d354 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_A.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_A.swift @@ -11,491 +11,495 @@ import XCTest @testable import Tekkon extension TekkonTestsKeyboardArrangments { + func testStarlightKeysTaigi() throws { + var c = Tekkon.Composer(arrange: .ofStarlight) + XCTAssertEqual(c.cS2RC("kik"), "ㄎㄧㄤ") + XCTAssertEqual(c.cS2RC("gif7"), "ㄍㄧㄠˊ") + XCTAssertEqual(c.cS2RC("gin"), "ㄍㄧㄣ") + } + func testStarlightKeysA() throws { - var composer = Tekkon.Composer(arrange: .ofStarlight) - XCTAssertEqual(composer.convertSequenceToRawComposition("kik"), "ㄎㄧㄤ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("gif7"), "ㄍㄧㄠˊ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("gin"), "ㄍㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bik7"), "ㄅㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bik9"), "ㄅㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("duk"), "ㄉㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ba"), "ㄅㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ba7"), "ㄅㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ba8"), "ㄅㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ba9"), "ㄅㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ba0"), "ㄅㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("bo"), "ㄅㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bo7"), "ㄅㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bo8"), "ㄅㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bo9"), "ㄅㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bo0"), "ㄅㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("by"), "ㄅㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("by7"), "ㄅㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("by8"), "ㄅㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("by9"), "ㄅㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("by0"), "ㄅㄞ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("bt"), "ㄅㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bt8"), "ㄅㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bt9"), "ㄅㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bt0"), "ㄅㄟ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("bf"), "ㄅㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bf7"), "ㄅㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bf8"), "ㄅㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bf9"), "ㄅㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bm"), "ㄅㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bm8"), "ㄅㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bm9"), "ㄅㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bn"), "ㄅㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bn8"), "ㄅㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bn9"), "ㄅㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bk"), "ㄅㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bk8"), "ㄅㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bk9"), "ㄅㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bg"), "ㄅㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bg7"), "ㄅㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bg8"), "ㄅㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bg9"), "ㄅㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bi"), "ㄅㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bi7"), "ㄅㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bi8"), "ㄅㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bi9"), "ㄅㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bie"), "ㄅㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bie7"), "ㄅㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bie8"), "ㄅㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bie9"), "ㄅㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bif"), "ㄅㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bif8"), "ㄅㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bif9"), "ㄅㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bim"), "ㄅㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bim7"), "ㄅㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bim8"), "ㄅㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bim9"), "ㄅㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bin"), "ㄅㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bin8"), "ㄅㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bin9"), "ㄅㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("big"), "ㄅㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("big8"), "ㄅㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("big9"), "ㄅㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bu"), "ㄅㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bu7"), "ㄅㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bu8"), "ㄅㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("bu9"), "ㄅㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pa"), "ㄆㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pa7"), "ㄆㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pa8"), "ㄆㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pa9"), "ㄆㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pa0"), "ㄆㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("po"), "ㄆㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("po7"), "ㄆㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("po8"), "ㄆㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("po9"), "ㄆㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("py"), "ㄆㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("py7"), "ㄆㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("py8"), "ㄆㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("py9"), "ㄆㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pt"), "ㄆㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pt7"), "ㄆㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pt8"), "ㄆㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pt9"), "ㄆㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pf"), "ㄆㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pf7"), "ㄆㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pf8"), "ㄆㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pf9"), "ㄆㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pw"), "ㄆㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pw7"), "ㄆㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pw8"), "ㄆㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pw9"), "ㄆㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pm"), "ㄆㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pm7"), "ㄆㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pm8"), "ㄆㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pm9"), "ㄆㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pn"), "ㄆㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pn7"), "ㄆㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pn8"), "ㄆㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pn9"), "ㄆㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pk"), "ㄆㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pk7"), "ㄆㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pk8"), "ㄆㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pk9"), "ㄆㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pg"), "ㄆㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pg7"), "ㄆㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pg8"), "ㄆㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pg9"), "ㄆㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pi"), "ㄆㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pi7"), "ㄆㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pi8"), "ㄆㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pi9"), "ㄆㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pia"), "ㄆㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pie"), "ㄆㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pie8"), "ㄆㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pie9"), "ㄆㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pif"), "ㄆㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pif7"), "ㄆㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pif8"), "ㄆㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pif9"), "ㄆㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pim"), "ㄆㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pim7"), "ㄆㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pim8"), "ㄆㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pim9"), "ㄆㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pin"), "ㄆㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pin7"), "ㄆㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pin8"), "ㄆㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pin9"), "ㄆㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pig"), "ㄆㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pig7"), "ㄆㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pig8"), "ㄆㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pig9"), "ㄆㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pu"), "ㄆㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pu7"), "ㄆㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pu8"), "ㄆㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("pu9"), "ㄆㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ma"), "ㄇㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ma7"), "ㄇㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ma8"), "ㄇㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ma9"), "ㄇㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ma0"), "ㄇㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("mo"), "ㄇㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mo7"), "ㄇㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mo8"), "ㄇㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mo9"), "ㄇㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mo0"), "ㄇㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("me"), "ㄇㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("me9"), "ㄇㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("me0"), "ㄇㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("my"), "ㄇㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("my7"), "ㄇㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("my8"), "ㄇㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("my9"), "ㄇㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mt7"), "ㄇㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mt8"), "ㄇㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mt9"), "ㄇㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mf"), "ㄇㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mf7"), "ㄇㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mf8"), "ㄇㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mf9"), "ㄇㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mw7"), "ㄇㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mw8"), "ㄇㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mw9"), "ㄇㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mm"), "ㄇㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mm7"), "ㄇㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mm8"), "ㄇㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mm9"), "ㄇㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mn"), "ㄇㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mn7"), "ㄇㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mn8"), "ㄇㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mn9"), "ㄇㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mn0"), "ㄇㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("mk"), "ㄇㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mk7"), "ㄇㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mk8"), "ㄇㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mk9"), "ㄇㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mg"), "ㄇㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mg7"), "ㄇㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mg8"), "ㄇㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mg9"), "ㄇㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mi"), "ㄇㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mi7"), "ㄇㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mi8"), "ㄇㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mi9"), "ㄇㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mie"), "ㄇㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mie7"), "ㄇㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mie9"), "ㄇㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mif"), "ㄇㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mif7"), "ㄇㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mif8"), "ㄇㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mif9"), "ㄇㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("miw7"), "ㄇㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("miw8"), "ㄇㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("miw9"), "ㄇㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mim"), "ㄇㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mim7"), "ㄇㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mim8"), "ㄇㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mim9"), "ㄇㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("min"), "ㄇㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("min7"), "ㄇㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("min8"), "ㄇㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mig7"), "ㄇㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mig8"), "ㄇㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mig9"), "ㄇㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mu7"), "ㄇㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mu8"), "ㄇㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("mu9"), "ㄇㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fa"), "ㄈㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fa7"), "ㄈㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fa8"), "ㄈㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fa9"), "ㄈㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fo7"), "ㄈㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ft"), "ㄈㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ft7"), "ㄈㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ft8"), "ㄈㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ft9"), "ㄈㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fw"), "ㄈㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fw7"), "ㄈㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fw8"), "ㄈㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fw9"), "ㄈㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fm"), "ㄈㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fm7"), "ㄈㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fm8"), "ㄈㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fm9"), "ㄈㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fn"), "ㄈㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fn7"), "ㄈㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fn8"), "ㄈㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fn9"), "ㄈㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fn0"), "ㄈㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("fk"), "ㄈㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fk7"), "ㄈㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fk8"), "ㄈㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fk9"), "ㄈㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fg"), "ㄈㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fg7"), "ㄈㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fg8"), "ㄈㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fg9"), "ㄈㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fif9"), "ㄈㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fu"), "ㄈㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fu7"), "ㄈㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fu8"), "ㄈㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("fu9"), "ㄈㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("da"), "ㄉㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("da7"), "ㄉㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("da8"), "ㄉㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("da9"), "ㄉㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("da0"), "ㄉㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("de"), "ㄉㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("de7"), "ㄉㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("de0"), "ㄉㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("dy"), "ㄉㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dy8"), "ㄉㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dy9"), "ㄉㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dt8"), "ㄉㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("df"), "ㄉㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("df7"), "ㄉㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("df8"), "ㄉㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("df9"), "ㄉㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dw"), "ㄉㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dw7"), "ㄉㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dw8"), "ㄉㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dw9"), "ㄉㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dm"), "ㄉㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dm8"), "ㄉㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dm9"), "ㄉㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dn9"), "ㄉㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dk"), "ㄉㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dk8"), "ㄉㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dk9"), "ㄉㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dg"), "ㄉㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dg8"), "ㄉㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dg9"), "ㄉㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("di"), "ㄉㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("di7"), "ㄉㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("di8"), "ㄉㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("di9"), "ㄉㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dia8"), "ㄉㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("die"), "ㄉㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("die7"), "ㄉㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("die8"), "ㄉㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("die9"), "ㄉㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dif"), "ㄉㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dif8"), "ㄉㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dif9"), "ㄉㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("diw"), "ㄉㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dim"), "ㄉㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dim7"), "ㄉㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dim8"), "ㄉㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dim9"), "ㄉㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dig"), "ㄉㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dig7"), "ㄉㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dig8"), "ㄉㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dig9"), "ㄉㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("du"), "ㄉㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("du7"), "ㄉㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("du8"), "ㄉㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("du9"), "ㄉㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("duo"), "ㄉㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("duo7"), "ㄉㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("duo8"), "ㄉㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("duo9"), "ㄉㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("duo0"), "ㄉㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("dut"), "ㄉㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dut8"), "ㄉㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dut9"), "ㄉㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dum"), "ㄉㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dum8"), "ㄉㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dum9"), "ㄉㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dun"), "ㄉㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dun8"), "ㄉㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dun9"), "ㄉㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dug"), "ㄉㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dug8"), "ㄉㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("dug9"), "ㄉㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ta"), "ㄊㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ta8"), "ㄊㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ta9"), "ㄊㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("te9"), "ㄊㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ty"), "ㄊㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ty7"), "ㄊㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ty8"), "ㄊㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ty9"), "ㄊㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ty0"), "ㄊㄞ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("tf"), "ㄊㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tf7"), "ㄊㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tf8"), "ㄊㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tf9"), "ㄊㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tf0"), "ㄊㄠ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("tw"), "ㄊㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tw7"), "ㄊㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tw8"), "ㄊㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tw9"), "ㄊㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tw0"), "ㄊㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("tm"), "ㄊㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tm7"), "ㄊㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tm8"), "ㄊㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tm9"), "ㄊㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tk"), "ㄊㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tk7"), "ㄊㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tk8"), "ㄊㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tk9"), "ㄊㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tg"), "ㄊㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tg7"), "ㄊㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tg9"), "ㄊㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ti"), "ㄊㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ti7"), "ㄊㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ti8"), "ㄊㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ti9"), "ㄊㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tie"), "ㄊㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tie7"), "ㄊㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tie8"), "ㄊㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tie9"), "ㄊㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tif"), "ㄊㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tif7"), "ㄊㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tif8"), "ㄊㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tif9"), "ㄊㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tim"), "ㄊㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tim7"), "ㄊㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tim8"), "ㄊㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tim9"), "ㄊㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tig"), "ㄊㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tig7"), "ㄊㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tig8"), "ㄊㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tig9"), "ㄊㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tu"), "ㄊㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tu7"), "ㄊㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tu8"), "ㄊㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tu9"), "ㄊㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tuo"), "ㄊㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tuo7"), "ㄊㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tuo8"), "ㄊㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tuo9"), "ㄊㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tut"), "ㄊㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tut7"), "ㄊㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tut8"), "ㄊㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tut9"), "ㄊㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tum"), "ㄊㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tum7"), "ㄊㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tum8"), "ㄊㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tum9"), "ㄊㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tun"), "ㄊㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tun7"), "ㄊㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tun8"), "ㄊㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tun9"), "ㄊㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tug"), "ㄊㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tug7"), "ㄊㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tug8"), "ㄊㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("tug9"), "ㄊㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("na"), "ㄋㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("na7"), "ㄋㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("na8"), "ㄋㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("na9"), "ㄋㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("na0"), "ㄋㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ne9"), "ㄋㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ne0"), "ㄋㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ny7"), "ㄋㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ny8"), "ㄋㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ny9"), "ㄋㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nt7"), "ㄋㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nt8"), "ㄋㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nt9"), "ㄋㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nf"), "ㄋㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nf7"), "ㄋㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nf8"), "ㄋㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nf9"), "ㄋㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nw7"), "ㄋㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nw8"), "ㄋㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nw9"), "ㄋㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nm"), "ㄋㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nm7"), "ㄋㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nm8"), "ㄋㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nm9"), "ㄋㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nn8"), "ㄋㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nn9"), "ㄋㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nk"), "ㄋㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nk7"), "ㄋㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nk8"), "ㄋㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nk9"), "ㄋㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nk0"), "ㄋㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ng7"), "ㄋㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ng8"), "ㄋㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ni"), "ㄋㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ni7"), "ㄋㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ni8"), "ㄋㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ni9"), "ㄋㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nie"), "ㄋㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nie7"), "ㄋㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nie9"), "ㄋㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nif8"), "ㄋㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nif9"), "ㄋㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("niw"), "ㄋㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("niw7"), "ㄋㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("niw8"), "ㄋㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("niw9"), "ㄋㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nim"), "ㄋㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nim7"), "ㄋㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nim8"), "ㄋㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nim9"), "ㄋㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nin"), "ㄋㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nin7"), "ㄋㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nin8"), "ㄋㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nin9"), "ㄋㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nik7"), "ㄋㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nik8"), "ㄋㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nik9"), "ㄋㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nig7"), "ㄋㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nig8"), "ㄋㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nig9"), "ㄋㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nu7"), "ㄋㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nu8"), "ㄋㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nu9"), "ㄋㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuo7"), "ㄋㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuo8"), "ㄋㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nuo9"), "ㄋㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nut7"), "ㄋㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("num7"), "ㄋㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("num8"), "ㄋㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("num9"), "ㄋㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nun7"), "ㄋㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nug7"), "ㄋㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nug8"), "ㄋㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nug9"), "ㄋㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nv7"), "ㄋㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nv8"), "ㄋㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nv9"), "ㄋㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("nve9"), "ㄋㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("la"), "ㄌㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("la7"), "ㄌㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("la8"), "ㄌㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("la9"), "ㄌㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("la0"), "ㄌㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lo"), "ㄌㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lo0"), "ㄌㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("le"), "ㄌㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("le7"), "ㄌㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("le9"), "ㄌㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("le0"), "ㄌㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ly7"), "ㄌㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ly8"), "ㄌㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ly9"), "ㄌㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lt"), "ㄌㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lt7"), "ㄌㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lt8"), "ㄌㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lt9"), "ㄌㄟˋ") + var c = Tekkon.Composer(arrange: .ofStarlight) + XCTAssertEqual(c.cS2RC("bik7"), "ㄅㄧㄤˊ") + XCTAssertEqual(c.cS2RC("bik9"), "ㄅㄧㄤˋ") + XCTAssertEqual(c.cS2RC("duk"), "ㄉㄨㄤ") + XCTAssertEqual(c.cS2RC("ba"), "ㄅㄚ") + XCTAssertEqual(c.cS2RC("ba7"), "ㄅㄚˊ") + XCTAssertEqual(c.cS2RC("ba8"), "ㄅㄚˇ") + XCTAssertEqual(c.cS2RC("ba9"), "ㄅㄚˋ") + XCTAssertEqual(c.cS2RC("ba0"), "ㄅㄚ˙") + XCTAssertEqual(c.cS2RC("bo"), "ㄅㄛ") + XCTAssertEqual(c.cS2RC("bo7"), "ㄅㄛˊ") + XCTAssertEqual(c.cS2RC("bo8"), "ㄅㄛˇ") + XCTAssertEqual(c.cS2RC("bo9"), "ㄅㄛˋ") + XCTAssertEqual(c.cS2RC("bo0"), "ㄅㄛ˙") + XCTAssertEqual(c.cS2RC("by"), "ㄅㄞ") + XCTAssertEqual(c.cS2RC("by7"), "ㄅㄞˊ") + XCTAssertEqual(c.cS2RC("by8"), "ㄅㄞˇ") + XCTAssertEqual(c.cS2RC("by9"), "ㄅㄞˋ") + XCTAssertEqual(c.cS2RC("by0"), "ㄅㄞ˙") + XCTAssertEqual(c.cS2RC("bt"), "ㄅㄟ") + XCTAssertEqual(c.cS2RC("bt8"), "ㄅㄟˇ") + XCTAssertEqual(c.cS2RC("bt9"), "ㄅㄟˋ") + XCTAssertEqual(c.cS2RC("bt0"), "ㄅㄟ˙") + XCTAssertEqual(c.cS2RC("bf"), "ㄅㄠ") + XCTAssertEqual(c.cS2RC("bf7"), "ㄅㄠˊ") + XCTAssertEqual(c.cS2RC("bf8"), "ㄅㄠˇ") + XCTAssertEqual(c.cS2RC("bf9"), "ㄅㄠˋ") + XCTAssertEqual(c.cS2RC("bm"), "ㄅㄢ") + XCTAssertEqual(c.cS2RC("bm8"), "ㄅㄢˇ") + XCTAssertEqual(c.cS2RC("bm9"), "ㄅㄢˋ") + XCTAssertEqual(c.cS2RC("bn"), "ㄅㄣ") + XCTAssertEqual(c.cS2RC("bn8"), "ㄅㄣˇ") + XCTAssertEqual(c.cS2RC("bn9"), "ㄅㄣˋ") + XCTAssertEqual(c.cS2RC("bk"), "ㄅㄤ") + XCTAssertEqual(c.cS2RC("bk8"), "ㄅㄤˇ") + XCTAssertEqual(c.cS2RC("bk9"), "ㄅㄤˋ") + XCTAssertEqual(c.cS2RC("bg"), "ㄅㄥ") + XCTAssertEqual(c.cS2RC("bg7"), "ㄅㄥˊ") + XCTAssertEqual(c.cS2RC("bg8"), "ㄅㄥˇ") + XCTAssertEqual(c.cS2RC("bg9"), "ㄅㄥˋ") + XCTAssertEqual(c.cS2RC("bi"), "ㄅㄧ") + XCTAssertEqual(c.cS2RC("bi7"), "ㄅㄧˊ") + XCTAssertEqual(c.cS2RC("bi8"), "ㄅㄧˇ") + XCTAssertEqual(c.cS2RC("bi9"), "ㄅㄧˋ") + XCTAssertEqual(c.cS2RC("bie"), "ㄅㄧㄝ") + XCTAssertEqual(c.cS2RC("bie7"), "ㄅㄧㄝˊ") + XCTAssertEqual(c.cS2RC("bie8"), "ㄅㄧㄝˇ") + XCTAssertEqual(c.cS2RC("bie9"), "ㄅㄧㄝˋ") + XCTAssertEqual(c.cS2RC("bif"), "ㄅㄧㄠ") + XCTAssertEqual(c.cS2RC("bif8"), "ㄅㄧㄠˇ") + XCTAssertEqual(c.cS2RC("bif9"), "ㄅㄧㄠˋ") + XCTAssertEqual(c.cS2RC("bim"), "ㄅㄧㄢ") + XCTAssertEqual(c.cS2RC("bim7"), "ㄅㄧㄢˊ") + XCTAssertEqual(c.cS2RC("bim8"), "ㄅㄧㄢˇ") + XCTAssertEqual(c.cS2RC("bim9"), "ㄅㄧㄢˋ") + XCTAssertEqual(c.cS2RC("bin"), "ㄅㄧㄣ") + XCTAssertEqual(c.cS2RC("bin8"), "ㄅㄧㄣˇ") + XCTAssertEqual(c.cS2RC("bin9"), "ㄅㄧㄣˋ") + XCTAssertEqual(c.cS2RC("big"), "ㄅㄧㄥ") + XCTAssertEqual(c.cS2RC("big8"), "ㄅㄧㄥˇ") + XCTAssertEqual(c.cS2RC("big9"), "ㄅㄧㄥˋ") + XCTAssertEqual(c.cS2RC("bu"), "ㄅㄨ") + XCTAssertEqual(c.cS2RC("bu7"), "ㄅㄨˊ") + XCTAssertEqual(c.cS2RC("bu8"), "ㄅㄨˇ") + XCTAssertEqual(c.cS2RC("bu9"), "ㄅㄨˋ") + XCTAssertEqual(c.cS2RC("pa"), "ㄆㄚ") + XCTAssertEqual(c.cS2RC("pa7"), "ㄆㄚˊ") + XCTAssertEqual(c.cS2RC("pa8"), "ㄆㄚˇ") + XCTAssertEqual(c.cS2RC("pa9"), "ㄆㄚˋ") + XCTAssertEqual(c.cS2RC("pa0"), "ㄆㄚ˙") + XCTAssertEqual(c.cS2RC("po"), "ㄆㄛ") + XCTAssertEqual(c.cS2RC("po7"), "ㄆㄛˊ") + XCTAssertEqual(c.cS2RC("po8"), "ㄆㄛˇ") + XCTAssertEqual(c.cS2RC("po9"), "ㄆㄛˋ") + XCTAssertEqual(c.cS2RC("py"), "ㄆㄞ") + XCTAssertEqual(c.cS2RC("py7"), "ㄆㄞˊ") + XCTAssertEqual(c.cS2RC("py8"), "ㄆㄞˇ") + XCTAssertEqual(c.cS2RC("py9"), "ㄆㄞˋ") + XCTAssertEqual(c.cS2RC("pt"), "ㄆㄟ") + XCTAssertEqual(c.cS2RC("pt7"), "ㄆㄟˊ") + XCTAssertEqual(c.cS2RC("pt8"), "ㄆㄟˇ") + XCTAssertEqual(c.cS2RC("pt9"), "ㄆㄟˋ") + XCTAssertEqual(c.cS2RC("pf"), "ㄆㄠ") + XCTAssertEqual(c.cS2RC("pf7"), "ㄆㄠˊ") + XCTAssertEqual(c.cS2RC("pf8"), "ㄆㄠˇ") + XCTAssertEqual(c.cS2RC("pf9"), "ㄆㄠˋ") + XCTAssertEqual(c.cS2RC("pw"), "ㄆㄡ") + XCTAssertEqual(c.cS2RC("pw7"), "ㄆㄡˊ") + XCTAssertEqual(c.cS2RC("pw8"), "ㄆㄡˇ") + XCTAssertEqual(c.cS2RC("pw9"), "ㄆㄡˋ") + XCTAssertEqual(c.cS2RC("pm"), "ㄆㄢ") + XCTAssertEqual(c.cS2RC("pm7"), "ㄆㄢˊ") + XCTAssertEqual(c.cS2RC("pm8"), "ㄆㄢˇ") + XCTAssertEqual(c.cS2RC("pm9"), "ㄆㄢˋ") + XCTAssertEqual(c.cS2RC("pn"), "ㄆㄣ") + XCTAssertEqual(c.cS2RC("pn7"), "ㄆㄣˊ") + XCTAssertEqual(c.cS2RC("pn8"), "ㄆㄣˇ") + XCTAssertEqual(c.cS2RC("pn9"), "ㄆㄣˋ") + XCTAssertEqual(c.cS2RC("pk"), "ㄆㄤ") + XCTAssertEqual(c.cS2RC("pk7"), "ㄆㄤˊ") + XCTAssertEqual(c.cS2RC("pk8"), "ㄆㄤˇ") + XCTAssertEqual(c.cS2RC("pk9"), "ㄆㄤˋ") + XCTAssertEqual(c.cS2RC("pg"), "ㄆㄥ") + XCTAssertEqual(c.cS2RC("pg7"), "ㄆㄥˊ") + XCTAssertEqual(c.cS2RC("pg8"), "ㄆㄥˇ") + XCTAssertEqual(c.cS2RC("pg9"), "ㄆㄥˋ") + XCTAssertEqual(c.cS2RC("pi"), "ㄆㄧ") + XCTAssertEqual(c.cS2RC("pi7"), "ㄆㄧˊ") + XCTAssertEqual(c.cS2RC("pi8"), "ㄆㄧˇ") + XCTAssertEqual(c.cS2RC("pi9"), "ㄆㄧˋ") + XCTAssertEqual(c.cS2RC("pia"), "ㄆㄧㄚ") + XCTAssertEqual(c.cS2RC("pie"), "ㄆㄧㄝ") + XCTAssertEqual(c.cS2RC("pie8"), "ㄆㄧㄝˇ") + XCTAssertEqual(c.cS2RC("pie9"), "ㄆㄧㄝˋ") + XCTAssertEqual(c.cS2RC("pif"), "ㄆㄧㄠ") + XCTAssertEqual(c.cS2RC("pif7"), "ㄆㄧㄠˊ") + XCTAssertEqual(c.cS2RC("pif8"), "ㄆㄧㄠˇ") + XCTAssertEqual(c.cS2RC("pif9"), "ㄆㄧㄠˋ") + XCTAssertEqual(c.cS2RC("pim"), "ㄆㄧㄢ") + XCTAssertEqual(c.cS2RC("pim7"), "ㄆㄧㄢˊ") + XCTAssertEqual(c.cS2RC("pim8"), "ㄆㄧㄢˇ") + XCTAssertEqual(c.cS2RC("pim9"), "ㄆㄧㄢˋ") + XCTAssertEqual(c.cS2RC("pin"), "ㄆㄧㄣ") + XCTAssertEqual(c.cS2RC("pin7"), "ㄆㄧㄣˊ") + XCTAssertEqual(c.cS2RC("pin8"), "ㄆㄧㄣˇ") + XCTAssertEqual(c.cS2RC("pin9"), "ㄆㄧㄣˋ") + XCTAssertEqual(c.cS2RC("pig"), "ㄆㄧㄥ") + XCTAssertEqual(c.cS2RC("pig7"), "ㄆㄧㄥˊ") + XCTAssertEqual(c.cS2RC("pig8"), "ㄆㄧㄥˇ") + XCTAssertEqual(c.cS2RC("pig9"), "ㄆㄧㄥˋ") + XCTAssertEqual(c.cS2RC("pu"), "ㄆㄨ") + XCTAssertEqual(c.cS2RC("pu7"), "ㄆㄨˊ") + XCTAssertEqual(c.cS2RC("pu8"), "ㄆㄨˇ") + XCTAssertEqual(c.cS2RC("pu9"), "ㄆㄨˋ") + XCTAssertEqual(c.cS2RC("ma"), "ㄇㄚ") + XCTAssertEqual(c.cS2RC("ma7"), "ㄇㄚˊ") + XCTAssertEqual(c.cS2RC("ma8"), "ㄇㄚˇ") + XCTAssertEqual(c.cS2RC("ma9"), "ㄇㄚˋ") + XCTAssertEqual(c.cS2RC("ma0"), "ㄇㄚ˙") + XCTAssertEqual(c.cS2RC("mo"), "ㄇㄛ") + XCTAssertEqual(c.cS2RC("mo7"), "ㄇㄛˊ") + XCTAssertEqual(c.cS2RC("mo8"), "ㄇㄛˇ") + XCTAssertEqual(c.cS2RC("mo9"), "ㄇㄛˋ") + XCTAssertEqual(c.cS2RC("mo0"), "ㄇㄛ˙") + XCTAssertEqual(c.cS2RC("me"), "ㄇㄜ") + XCTAssertEqual(c.cS2RC("me9"), "ㄇㄜˋ") + XCTAssertEqual(c.cS2RC("me0"), "ㄇㄜ˙") + XCTAssertEqual(c.cS2RC("my"), "ㄇㄞ") + XCTAssertEqual(c.cS2RC("my7"), "ㄇㄞˊ") + XCTAssertEqual(c.cS2RC("my8"), "ㄇㄞˇ") + XCTAssertEqual(c.cS2RC("my9"), "ㄇㄞˋ") + XCTAssertEqual(c.cS2RC("mt7"), "ㄇㄟˊ") + XCTAssertEqual(c.cS2RC("mt8"), "ㄇㄟˇ") + XCTAssertEqual(c.cS2RC("mt9"), "ㄇㄟˋ") + XCTAssertEqual(c.cS2RC("mf"), "ㄇㄠ") + XCTAssertEqual(c.cS2RC("mf7"), "ㄇㄠˊ") + XCTAssertEqual(c.cS2RC("mf8"), "ㄇㄠˇ") + XCTAssertEqual(c.cS2RC("mf9"), "ㄇㄠˋ") + XCTAssertEqual(c.cS2RC("mw7"), "ㄇㄡˊ") + XCTAssertEqual(c.cS2RC("mw8"), "ㄇㄡˇ") + XCTAssertEqual(c.cS2RC("mw9"), "ㄇㄡˋ") + XCTAssertEqual(c.cS2RC("mm"), "ㄇㄢ") + XCTAssertEqual(c.cS2RC("mm7"), "ㄇㄢˊ") + XCTAssertEqual(c.cS2RC("mm8"), "ㄇㄢˇ") + XCTAssertEqual(c.cS2RC("mm9"), "ㄇㄢˋ") + XCTAssertEqual(c.cS2RC("mn"), "ㄇㄣ") + XCTAssertEqual(c.cS2RC("mn7"), "ㄇㄣˊ") + XCTAssertEqual(c.cS2RC("mn8"), "ㄇㄣˇ") + XCTAssertEqual(c.cS2RC("mn9"), "ㄇㄣˋ") + XCTAssertEqual(c.cS2RC("mn0"), "ㄇㄣ˙") + XCTAssertEqual(c.cS2RC("mk"), "ㄇㄤ") + XCTAssertEqual(c.cS2RC("mk7"), "ㄇㄤˊ") + XCTAssertEqual(c.cS2RC("mk8"), "ㄇㄤˇ") + XCTAssertEqual(c.cS2RC("mk9"), "ㄇㄤˋ") + XCTAssertEqual(c.cS2RC("mg"), "ㄇㄥ") + XCTAssertEqual(c.cS2RC("mg7"), "ㄇㄥˊ") + XCTAssertEqual(c.cS2RC("mg8"), "ㄇㄥˇ") + XCTAssertEqual(c.cS2RC("mg9"), "ㄇㄥˋ") + XCTAssertEqual(c.cS2RC("mi"), "ㄇㄧ") + XCTAssertEqual(c.cS2RC("mi7"), "ㄇㄧˊ") + XCTAssertEqual(c.cS2RC("mi8"), "ㄇㄧˇ") + XCTAssertEqual(c.cS2RC("mi9"), "ㄇㄧˋ") + XCTAssertEqual(c.cS2RC("mie"), "ㄇㄧㄝ") + XCTAssertEqual(c.cS2RC("mie7"), "ㄇㄧㄝˊ") + XCTAssertEqual(c.cS2RC("mie9"), "ㄇㄧㄝˋ") + XCTAssertEqual(c.cS2RC("mif"), "ㄇㄧㄠ") + XCTAssertEqual(c.cS2RC("mif7"), "ㄇㄧㄠˊ") + XCTAssertEqual(c.cS2RC("mif8"), "ㄇㄧㄠˇ") + XCTAssertEqual(c.cS2RC("mif9"), "ㄇㄧㄠˋ") + XCTAssertEqual(c.cS2RC("miw7"), "ㄇㄧㄡˊ") + XCTAssertEqual(c.cS2RC("miw8"), "ㄇㄧㄡˇ") + XCTAssertEqual(c.cS2RC("miw9"), "ㄇㄧㄡˋ") + XCTAssertEqual(c.cS2RC("mim"), "ㄇㄧㄢ") + XCTAssertEqual(c.cS2RC("mim7"), "ㄇㄧㄢˊ") + XCTAssertEqual(c.cS2RC("mim8"), "ㄇㄧㄢˇ") + XCTAssertEqual(c.cS2RC("mim9"), "ㄇㄧㄢˋ") + XCTAssertEqual(c.cS2RC("min"), "ㄇㄧㄣ") + XCTAssertEqual(c.cS2RC("min7"), "ㄇㄧㄣˊ") + XCTAssertEqual(c.cS2RC("min8"), "ㄇㄧㄣˇ") + XCTAssertEqual(c.cS2RC("mig7"), "ㄇㄧㄥˊ") + XCTAssertEqual(c.cS2RC("mig8"), "ㄇㄧㄥˇ") + XCTAssertEqual(c.cS2RC("mig9"), "ㄇㄧㄥˋ") + XCTAssertEqual(c.cS2RC("mu7"), "ㄇㄨˊ") + XCTAssertEqual(c.cS2RC("mu8"), "ㄇㄨˇ") + XCTAssertEqual(c.cS2RC("mu9"), "ㄇㄨˋ") + XCTAssertEqual(c.cS2RC("fa"), "ㄈㄚ") + XCTAssertEqual(c.cS2RC("fa7"), "ㄈㄚˊ") + XCTAssertEqual(c.cS2RC("fa8"), "ㄈㄚˇ") + XCTAssertEqual(c.cS2RC("fa9"), "ㄈㄚˋ") + XCTAssertEqual(c.cS2RC("fo7"), "ㄈㄛˊ") + XCTAssertEqual(c.cS2RC("ft"), "ㄈㄟ") + XCTAssertEqual(c.cS2RC("ft7"), "ㄈㄟˊ") + XCTAssertEqual(c.cS2RC("ft8"), "ㄈㄟˇ") + XCTAssertEqual(c.cS2RC("ft9"), "ㄈㄟˋ") + XCTAssertEqual(c.cS2RC("fw"), "ㄈㄡ") + XCTAssertEqual(c.cS2RC("fw7"), "ㄈㄡˊ") + XCTAssertEqual(c.cS2RC("fw8"), "ㄈㄡˇ") + XCTAssertEqual(c.cS2RC("fw9"), "ㄈㄡˋ") + XCTAssertEqual(c.cS2RC("fm"), "ㄈㄢ") + XCTAssertEqual(c.cS2RC("fm7"), "ㄈㄢˊ") + XCTAssertEqual(c.cS2RC("fm8"), "ㄈㄢˇ") + XCTAssertEqual(c.cS2RC("fm9"), "ㄈㄢˋ") + XCTAssertEqual(c.cS2RC("fn"), "ㄈㄣ") + XCTAssertEqual(c.cS2RC("fn7"), "ㄈㄣˊ") + XCTAssertEqual(c.cS2RC("fn8"), "ㄈㄣˇ") + XCTAssertEqual(c.cS2RC("fn9"), "ㄈㄣˋ") + XCTAssertEqual(c.cS2RC("fn0"), "ㄈㄣ˙") + XCTAssertEqual(c.cS2RC("fk"), "ㄈㄤ") + XCTAssertEqual(c.cS2RC("fk7"), "ㄈㄤˊ") + XCTAssertEqual(c.cS2RC("fk8"), "ㄈㄤˇ") + XCTAssertEqual(c.cS2RC("fk9"), "ㄈㄤˋ") + XCTAssertEqual(c.cS2RC("fg"), "ㄈㄥ") + XCTAssertEqual(c.cS2RC("fg7"), "ㄈㄥˊ") + XCTAssertEqual(c.cS2RC("fg8"), "ㄈㄥˇ") + XCTAssertEqual(c.cS2RC("fg9"), "ㄈㄥˋ") + XCTAssertEqual(c.cS2RC("fif9"), "ㄈㄧㄠˋ") + XCTAssertEqual(c.cS2RC("fu"), "ㄈㄨ") + XCTAssertEqual(c.cS2RC("fu7"), "ㄈㄨˊ") + XCTAssertEqual(c.cS2RC("fu8"), "ㄈㄨˇ") + XCTAssertEqual(c.cS2RC("fu9"), "ㄈㄨˋ") + XCTAssertEqual(c.cS2RC("da"), "ㄉㄚ") + XCTAssertEqual(c.cS2RC("da7"), "ㄉㄚˊ") + XCTAssertEqual(c.cS2RC("da8"), "ㄉㄚˇ") + XCTAssertEqual(c.cS2RC("da9"), "ㄉㄚˋ") + XCTAssertEqual(c.cS2RC("da0"), "ㄉㄚ˙") + XCTAssertEqual(c.cS2RC("de"), "ㄉㄜ") + XCTAssertEqual(c.cS2RC("de7"), "ㄉㄜˊ") + XCTAssertEqual(c.cS2RC("de0"), "ㄉㄜ˙") + XCTAssertEqual(c.cS2RC("dy"), "ㄉㄞ") + XCTAssertEqual(c.cS2RC("dy8"), "ㄉㄞˇ") + XCTAssertEqual(c.cS2RC("dy9"), "ㄉㄞˋ") + XCTAssertEqual(c.cS2RC("dt8"), "ㄉㄟˇ") + XCTAssertEqual(c.cS2RC("df"), "ㄉㄠ") + XCTAssertEqual(c.cS2RC("df7"), "ㄉㄠˊ") + XCTAssertEqual(c.cS2RC("df8"), "ㄉㄠˇ") + XCTAssertEqual(c.cS2RC("df9"), "ㄉㄠˋ") + XCTAssertEqual(c.cS2RC("dw"), "ㄉㄡ") + XCTAssertEqual(c.cS2RC("dw7"), "ㄉㄡˊ") + XCTAssertEqual(c.cS2RC("dw8"), "ㄉㄡˇ") + XCTAssertEqual(c.cS2RC("dw9"), "ㄉㄡˋ") + XCTAssertEqual(c.cS2RC("dm"), "ㄉㄢ") + XCTAssertEqual(c.cS2RC("dm8"), "ㄉㄢˇ") + XCTAssertEqual(c.cS2RC("dm9"), "ㄉㄢˋ") + XCTAssertEqual(c.cS2RC("dn9"), "ㄉㄣˋ") + XCTAssertEqual(c.cS2RC("dk"), "ㄉㄤ") + XCTAssertEqual(c.cS2RC("dk8"), "ㄉㄤˇ") + XCTAssertEqual(c.cS2RC("dk9"), "ㄉㄤˋ") + XCTAssertEqual(c.cS2RC("dg"), "ㄉㄥ") + XCTAssertEqual(c.cS2RC("dg8"), "ㄉㄥˇ") + XCTAssertEqual(c.cS2RC("dg9"), "ㄉㄥˋ") + XCTAssertEqual(c.cS2RC("di"), "ㄉㄧ") + XCTAssertEqual(c.cS2RC("di7"), "ㄉㄧˊ") + XCTAssertEqual(c.cS2RC("di8"), "ㄉㄧˇ") + XCTAssertEqual(c.cS2RC("di9"), "ㄉㄧˋ") + XCTAssertEqual(c.cS2RC("dia8"), "ㄉㄧㄚˇ") + XCTAssertEqual(c.cS2RC("die"), "ㄉㄧㄝ") + XCTAssertEqual(c.cS2RC("die7"), "ㄉㄧㄝˊ") + XCTAssertEqual(c.cS2RC("die8"), "ㄉㄧㄝˇ") + XCTAssertEqual(c.cS2RC("die9"), "ㄉㄧㄝˋ") + XCTAssertEqual(c.cS2RC("dif"), "ㄉㄧㄠ") + XCTAssertEqual(c.cS2RC("dif8"), "ㄉㄧㄠˇ") + XCTAssertEqual(c.cS2RC("dif9"), "ㄉㄧㄠˋ") + XCTAssertEqual(c.cS2RC("diw"), "ㄉㄧㄡ") + XCTAssertEqual(c.cS2RC("dim"), "ㄉㄧㄢ") + XCTAssertEqual(c.cS2RC("dim7"), "ㄉㄧㄢˊ") + XCTAssertEqual(c.cS2RC("dim8"), "ㄉㄧㄢˇ") + XCTAssertEqual(c.cS2RC("dim9"), "ㄉㄧㄢˋ") + XCTAssertEqual(c.cS2RC("dig"), "ㄉㄧㄥ") + XCTAssertEqual(c.cS2RC("dig7"), "ㄉㄧㄥˊ") + XCTAssertEqual(c.cS2RC("dig8"), "ㄉㄧㄥˇ") + XCTAssertEqual(c.cS2RC("dig9"), "ㄉㄧㄥˋ") + XCTAssertEqual(c.cS2RC("du"), "ㄉㄨ") + XCTAssertEqual(c.cS2RC("du7"), "ㄉㄨˊ") + XCTAssertEqual(c.cS2RC("du8"), "ㄉㄨˇ") + XCTAssertEqual(c.cS2RC("du9"), "ㄉㄨˋ") + XCTAssertEqual(c.cS2RC("duo"), "ㄉㄨㄛ") + XCTAssertEqual(c.cS2RC("duo7"), "ㄉㄨㄛˊ") + XCTAssertEqual(c.cS2RC("duo8"), "ㄉㄨㄛˇ") + XCTAssertEqual(c.cS2RC("duo9"), "ㄉㄨㄛˋ") + XCTAssertEqual(c.cS2RC("duo0"), "ㄉㄨㄛ˙") + XCTAssertEqual(c.cS2RC("dut"), "ㄉㄨㄟ") + XCTAssertEqual(c.cS2RC("dut8"), "ㄉㄨㄟˇ") + XCTAssertEqual(c.cS2RC("dut9"), "ㄉㄨㄟˋ") + XCTAssertEqual(c.cS2RC("dum"), "ㄉㄨㄢ") + XCTAssertEqual(c.cS2RC("dum8"), "ㄉㄨㄢˇ") + XCTAssertEqual(c.cS2RC("dum9"), "ㄉㄨㄢˋ") + XCTAssertEqual(c.cS2RC("dun"), "ㄉㄨㄣ") + XCTAssertEqual(c.cS2RC("dun8"), "ㄉㄨㄣˇ") + XCTAssertEqual(c.cS2RC("dun9"), "ㄉㄨㄣˋ") + XCTAssertEqual(c.cS2RC("dug"), "ㄉㄨㄥ") + XCTAssertEqual(c.cS2RC("dug8"), "ㄉㄨㄥˇ") + XCTAssertEqual(c.cS2RC("dug9"), "ㄉㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ta"), "ㄊㄚ") + XCTAssertEqual(c.cS2RC("ta8"), "ㄊㄚˇ") + XCTAssertEqual(c.cS2RC("ta9"), "ㄊㄚˋ") + XCTAssertEqual(c.cS2RC("te9"), "ㄊㄜˋ") + XCTAssertEqual(c.cS2RC("ty"), "ㄊㄞ") + XCTAssertEqual(c.cS2RC("ty7"), "ㄊㄞˊ") + XCTAssertEqual(c.cS2RC("ty8"), "ㄊㄞˇ") + XCTAssertEqual(c.cS2RC("ty9"), "ㄊㄞˋ") + XCTAssertEqual(c.cS2RC("ty0"), "ㄊㄞ˙") + XCTAssertEqual(c.cS2RC("tf"), "ㄊㄠ") + XCTAssertEqual(c.cS2RC("tf7"), "ㄊㄠˊ") + XCTAssertEqual(c.cS2RC("tf8"), "ㄊㄠˇ") + XCTAssertEqual(c.cS2RC("tf9"), "ㄊㄠˋ") + XCTAssertEqual(c.cS2RC("tf0"), "ㄊㄠ˙") + XCTAssertEqual(c.cS2RC("tw"), "ㄊㄡ") + XCTAssertEqual(c.cS2RC("tw7"), "ㄊㄡˊ") + XCTAssertEqual(c.cS2RC("tw8"), "ㄊㄡˇ") + XCTAssertEqual(c.cS2RC("tw9"), "ㄊㄡˋ") + XCTAssertEqual(c.cS2RC("tw0"), "ㄊㄡ˙") + XCTAssertEqual(c.cS2RC("tm"), "ㄊㄢ") + XCTAssertEqual(c.cS2RC("tm7"), "ㄊㄢˊ") + XCTAssertEqual(c.cS2RC("tm8"), "ㄊㄢˇ") + XCTAssertEqual(c.cS2RC("tm9"), "ㄊㄢˋ") + XCTAssertEqual(c.cS2RC("tk"), "ㄊㄤ") + XCTAssertEqual(c.cS2RC("tk7"), "ㄊㄤˊ") + XCTAssertEqual(c.cS2RC("tk8"), "ㄊㄤˇ") + XCTAssertEqual(c.cS2RC("tk9"), "ㄊㄤˋ") + XCTAssertEqual(c.cS2RC("tg"), "ㄊㄥ") + XCTAssertEqual(c.cS2RC("tg7"), "ㄊㄥˊ") + XCTAssertEqual(c.cS2RC("tg9"), "ㄊㄥˋ") + XCTAssertEqual(c.cS2RC("ti"), "ㄊㄧ") + XCTAssertEqual(c.cS2RC("ti7"), "ㄊㄧˊ") + XCTAssertEqual(c.cS2RC("ti8"), "ㄊㄧˇ") + XCTAssertEqual(c.cS2RC("ti9"), "ㄊㄧˋ") + XCTAssertEqual(c.cS2RC("tie"), "ㄊㄧㄝ") + XCTAssertEqual(c.cS2RC("tie7"), "ㄊㄧㄝˊ") + XCTAssertEqual(c.cS2RC("tie8"), "ㄊㄧㄝˇ") + XCTAssertEqual(c.cS2RC("tie9"), "ㄊㄧㄝˋ") + XCTAssertEqual(c.cS2RC("tif"), "ㄊㄧㄠ") + XCTAssertEqual(c.cS2RC("tif7"), "ㄊㄧㄠˊ") + XCTAssertEqual(c.cS2RC("tif8"), "ㄊㄧㄠˇ") + XCTAssertEqual(c.cS2RC("tif9"), "ㄊㄧㄠˋ") + XCTAssertEqual(c.cS2RC("tim"), "ㄊㄧㄢ") + XCTAssertEqual(c.cS2RC("tim7"), "ㄊㄧㄢˊ") + XCTAssertEqual(c.cS2RC("tim8"), "ㄊㄧㄢˇ") + XCTAssertEqual(c.cS2RC("tim9"), "ㄊㄧㄢˋ") + XCTAssertEqual(c.cS2RC("tig"), "ㄊㄧㄥ") + XCTAssertEqual(c.cS2RC("tig7"), "ㄊㄧㄥˊ") + XCTAssertEqual(c.cS2RC("tig8"), "ㄊㄧㄥˇ") + XCTAssertEqual(c.cS2RC("tig9"), "ㄊㄧㄥˋ") + XCTAssertEqual(c.cS2RC("tu"), "ㄊㄨ") + XCTAssertEqual(c.cS2RC("tu7"), "ㄊㄨˊ") + XCTAssertEqual(c.cS2RC("tu8"), "ㄊㄨˇ") + XCTAssertEqual(c.cS2RC("tu9"), "ㄊㄨˋ") + XCTAssertEqual(c.cS2RC("tuo"), "ㄊㄨㄛ") + XCTAssertEqual(c.cS2RC("tuo7"), "ㄊㄨㄛˊ") + XCTAssertEqual(c.cS2RC("tuo8"), "ㄊㄨㄛˇ") + XCTAssertEqual(c.cS2RC("tuo9"), "ㄊㄨㄛˋ") + XCTAssertEqual(c.cS2RC("tut"), "ㄊㄨㄟ") + XCTAssertEqual(c.cS2RC("tut7"), "ㄊㄨㄟˊ") + XCTAssertEqual(c.cS2RC("tut8"), "ㄊㄨㄟˇ") + XCTAssertEqual(c.cS2RC("tut9"), "ㄊㄨㄟˋ") + XCTAssertEqual(c.cS2RC("tum"), "ㄊㄨㄢ") + XCTAssertEqual(c.cS2RC("tum7"), "ㄊㄨㄢˊ") + XCTAssertEqual(c.cS2RC("tum8"), "ㄊㄨㄢˇ") + XCTAssertEqual(c.cS2RC("tum9"), "ㄊㄨㄢˋ") + XCTAssertEqual(c.cS2RC("tun"), "ㄊㄨㄣ") + XCTAssertEqual(c.cS2RC("tun7"), "ㄊㄨㄣˊ") + XCTAssertEqual(c.cS2RC("tun8"), "ㄊㄨㄣˇ") + XCTAssertEqual(c.cS2RC("tun9"), "ㄊㄨㄣˋ") + XCTAssertEqual(c.cS2RC("tug"), "ㄊㄨㄥ") + XCTAssertEqual(c.cS2RC("tug7"), "ㄊㄨㄥˊ") + XCTAssertEqual(c.cS2RC("tug8"), "ㄊㄨㄥˇ") + XCTAssertEqual(c.cS2RC("tug9"), "ㄊㄨㄥˋ") + XCTAssertEqual(c.cS2RC("na"), "ㄋㄚ") + XCTAssertEqual(c.cS2RC("na7"), "ㄋㄚˊ") + XCTAssertEqual(c.cS2RC("na8"), "ㄋㄚˇ") + XCTAssertEqual(c.cS2RC("na9"), "ㄋㄚˋ") + XCTAssertEqual(c.cS2RC("na0"), "ㄋㄚ˙") + XCTAssertEqual(c.cS2RC("ne9"), "ㄋㄜˋ") + XCTAssertEqual(c.cS2RC("ne0"), "ㄋㄜ˙") + XCTAssertEqual(c.cS2RC("ny7"), "ㄋㄞˊ") + XCTAssertEqual(c.cS2RC("ny8"), "ㄋㄞˇ") + XCTAssertEqual(c.cS2RC("ny9"), "ㄋㄞˋ") + XCTAssertEqual(c.cS2RC("nt7"), "ㄋㄟˊ") + XCTAssertEqual(c.cS2RC("nt8"), "ㄋㄟˇ") + XCTAssertEqual(c.cS2RC("nt9"), "ㄋㄟˋ") + XCTAssertEqual(c.cS2RC("nf"), "ㄋㄠ") + XCTAssertEqual(c.cS2RC("nf7"), "ㄋㄠˊ") + XCTAssertEqual(c.cS2RC("nf8"), "ㄋㄠˇ") + XCTAssertEqual(c.cS2RC("nf9"), "ㄋㄠˋ") + XCTAssertEqual(c.cS2RC("nw7"), "ㄋㄡˊ") + XCTAssertEqual(c.cS2RC("nw8"), "ㄋㄡˇ") + XCTAssertEqual(c.cS2RC("nw9"), "ㄋㄡˋ") + XCTAssertEqual(c.cS2RC("nm"), "ㄋㄢ") + XCTAssertEqual(c.cS2RC("nm7"), "ㄋㄢˊ") + XCTAssertEqual(c.cS2RC("nm8"), "ㄋㄢˇ") + XCTAssertEqual(c.cS2RC("nm9"), "ㄋㄢˋ") + XCTAssertEqual(c.cS2RC("nn8"), "ㄋㄣˇ") + XCTAssertEqual(c.cS2RC("nn9"), "ㄋㄣˋ") + XCTAssertEqual(c.cS2RC("nk"), "ㄋㄤ") + XCTAssertEqual(c.cS2RC("nk7"), "ㄋㄤˊ") + XCTAssertEqual(c.cS2RC("nk8"), "ㄋㄤˇ") + XCTAssertEqual(c.cS2RC("nk9"), "ㄋㄤˋ") + XCTAssertEqual(c.cS2RC("nk0"), "ㄋㄤ˙") + XCTAssertEqual(c.cS2RC("ng7"), "ㄋㄥˊ") + XCTAssertEqual(c.cS2RC("ng8"), "ㄋㄥˇ") + XCTAssertEqual(c.cS2RC("ni"), "ㄋㄧ") + XCTAssertEqual(c.cS2RC("ni7"), "ㄋㄧˊ") + XCTAssertEqual(c.cS2RC("ni8"), "ㄋㄧˇ") + XCTAssertEqual(c.cS2RC("ni9"), "ㄋㄧˋ") + XCTAssertEqual(c.cS2RC("nie"), "ㄋㄧㄝ") + XCTAssertEqual(c.cS2RC("nie7"), "ㄋㄧㄝˊ") + XCTAssertEqual(c.cS2RC("nie9"), "ㄋㄧㄝˋ") + XCTAssertEqual(c.cS2RC("nif8"), "ㄋㄧㄠˇ") + XCTAssertEqual(c.cS2RC("nif9"), "ㄋㄧㄠˋ") + XCTAssertEqual(c.cS2RC("niw"), "ㄋㄧㄡ") + XCTAssertEqual(c.cS2RC("niw7"), "ㄋㄧㄡˊ") + XCTAssertEqual(c.cS2RC("niw8"), "ㄋㄧㄡˇ") + XCTAssertEqual(c.cS2RC("niw9"), "ㄋㄧㄡˋ") + XCTAssertEqual(c.cS2RC("nim"), "ㄋㄧㄢ") + XCTAssertEqual(c.cS2RC("nim7"), "ㄋㄧㄢˊ") + XCTAssertEqual(c.cS2RC("nim8"), "ㄋㄧㄢˇ") + XCTAssertEqual(c.cS2RC("nim9"), "ㄋㄧㄢˋ") + XCTAssertEqual(c.cS2RC("nin"), "ㄋㄧㄣ") + XCTAssertEqual(c.cS2RC("nin7"), "ㄋㄧㄣˊ") + XCTAssertEqual(c.cS2RC("nin8"), "ㄋㄧㄣˇ") + XCTAssertEqual(c.cS2RC("nin9"), "ㄋㄧㄣˋ") + XCTAssertEqual(c.cS2RC("nik7"), "ㄋㄧㄤˊ") + XCTAssertEqual(c.cS2RC("nik8"), "ㄋㄧㄤˇ") + XCTAssertEqual(c.cS2RC("nik9"), "ㄋㄧㄤˋ") + XCTAssertEqual(c.cS2RC("nig7"), "ㄋㄧㄥˊ") + XCTAssertEqual(c.cS2RC("nig8"), "ㄋㄧㄥˇ") + XCTAssertEqual(c.cS2RC("nig9"), "ㄋㄧㄥˋ") + XCTAssertEqual(c.cS2RC("nu7"), "ㄋㄨˊ") + XCTAssertEqual(c.cS2RC("nu8"), "ㄋㄨˇ") + XCTAssertEqual(c.cS2RC("nu9"), "ㄋㄨˋ") + XCTAssertEqual(c.cS2RC("nuo7"), "ㄋㄨㄛˊ") + XCTAssertEqual(c.cS2RC("nuo8"), "ㄋㄨㄛˇ") + XCTAssertEqual(c.cS2RC("nuo9"), "ㄋㄨㄛˋ") + XCTAssertEqual(c.cS2RC("nut7"), "ㄋㄨㄟˊ") + XCTAssertEqual(c.cS2RC("num7"), "ㄋㄨㄢˊ") + XCTAssertEqual(c.cS2RC("num8"), "ㄋㄨㄢˇ") + XCTAssertEqual(c.cS2RC("num9"), "ㄋㄨㄢˋ") + XCTAssertEqual(c.cS2RC("nun7"), "ㄋㄨㄣˊ") + XCTAssertEqual(c.cS2RC("nug7"), "ㄋㄨㄥˊ") + XCTAssertEqual(c.cS2RC("nug8"), "ㄋㄨㄥˇ") + XCTAssertEqual(c.cS2RC("nug9"), "ㄋㄨㄥˋ") + XCTAssertEqual(c.cS2RC("nv7"), "ㄋㄩˊ") + XCTAssertEqual(c.cS2RC("nv8"), "ㄋㄩˇ") + XCTAssertEqual(c.cS2RC("nv9"), "ㄋㄩˋ") + XCTAssertEqual(c.cS2RC("nve9"), "ㄋㄩㄝˋ") + XCTAssertEqual(c.cS2RC("la"), "ㄌㄚ") + XCTAssertEqual(c.cS2RC("la7"), "ㄌㄚˊ") + XCTAssertEqual(c.cS2RC("la8"), "ㄌㄚˇ") + XCTAssertEqual(c.cS2RC("la9"), "ㄌㄚˋ") + XCTAssertEqual(c.cS2RC("la0"), "ㄌㄚ˙") + XCTAssertEqual(c.cS2RC("lo"), "ㄌㄛ") + XCTAssertEqual(c.cS2RC("lo0"), "ㄌㄛ˙") + XCTAssertEqual(c.cS2RC("le"), "ㄌㄜ") + XCTAssertEqual(c.cS2RC("le7"), "ㄌㄜˊ") + XCTAssertEqual(c.cS2RC("le9"), "ㄌㄜˋ") + XCTAssertEqual(c.cS2RC("le0"), "ㄌㄜ˙") + XCTAssertEqual(c.cS2RC("ly7"), "ㄌㄞˊ") + XCTAssertEqual(c.cS2RC("ly8"), "ㄌㄞˇ") + XCTAssertEqual(c.cS2RC("ly9"), "ㄌㄞˋ") + XCTAssertEqual(c.cS2RC("lt"), "ㄌㄟ") + XCTAssertEqual(c.cS2RC("lt7"), "ㄌㄟˊ") + XCTAssertEqual(c.cS2RC("lt8"), "ㄌㄟˇ") + XCTAssertEqual(c.cS2RC("lt9"), "ㄌㄟˋ") } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_B.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_B.swift index 35f48d60..8ea43868 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_B.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_B.swift @@ -12,490 +12,490 @@ import XCTest extension TekkonTestsKeyboardArrangments { func testStarlightKeysB() throws { - var composer = Tekkon.Composer(arrange: .ofStarlight) - XCTAssertEqual(composer.convertSequenceToRawComposition("lt0"), "ㄌㄟ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lf"), "ㄌㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lf7"), "ㄌㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lf8"), "ㄌㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lf9"), "ㄌㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lw"), "ㄌㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lw7"), "ㄌㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lw8"), "ㄌㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lw9"), "ㄌㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lw0"), "ㄌㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lm7"), "ㄌㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lm8"), "ㄌㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lm9"), "ㄌㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lk"), "ㄌㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lk7"), "ㄌㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lk8"), "ㄌㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lk9"), "ㄌㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lg"), "ㄌㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lg7"), "ㄌㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lg8"), "ㄌㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lg9"), "ㄌㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("li"), "ㄌㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("li7"), "ㄌㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("li8"), "ㄌㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("li9"), "ㄌㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("li0"), "ㄌㄧ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lia8"), "ㄌㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lie"), "ㄌㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lie7"), "ㄌㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lie8"), "ㄌㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lie9"), "ㄌㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lif"), "ㄌㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lif7"), "ㄌㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lif8"), "ㄌㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lif9"), "ㄌㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("liw"), "ㄌㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("liw7"), "ㄌㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("liw8"), "ㄌㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("liw9"), "ㄌㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lim"), "ㄌㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lim7"), "ㄌㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lim8"), "ㄌㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lim9"), "ㄌㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lin7"), "ㄌㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lin8"), "ㄌㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lin9"), "ㄌㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lik7"), "ㄌㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lik8"), "ㄌㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lik9"), "ㄌㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lig"), "ㄌㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lig7"), "ㄌㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lig8"), "ㄌㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lig9"), "ㄌㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lu"), "ㄌㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lu7"), "ㄌㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lu8"), "ㄌㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lu9"), "ㄌㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luo"), "ㄌㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luo7"), "ㄌㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luo8"), "ㄌㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luo9"), "ㄌㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("luo0"), "ㄌㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("lum7"), "ㄌㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lum8"), "ㄌㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lum9"), "ㄌㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lun"), "ㄌㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lun7"), "ㄌㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lun8"), "ㄌㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lun9"), "ㄌㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lug"), "ㄌㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lug7"), "ㄌㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lug8"), "ㄌㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lug9"), "ㄌㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lv"), "ㄌㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lv7"), "ㄌㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lv8"), "ㄌㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lv9"), "ㄌㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lve"), "ㄌㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lve8"), "ㄌㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lve9"), "ㄌㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lvm7"), "ㄌㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("lvm8"), "ㄌㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ga"), "ㄍㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ga7"), "ㄍㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ga8"), "ㄍㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ga9"), "ㄍㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ga0"), "ㄍㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ge"), "ㄍㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ge7"), "ㄍㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ge8"), "ㄍㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ge9"), "ㄍㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ge0"), "ㄍㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("gy"), "ㄍㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gy8"), "ㄍㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gy9"), "ㄍㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gt8"), "ㄍㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gf"), "ㄍㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gf8"), "ㄍㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gf9"), "ㄍㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gw"), "ㄍㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gw8"), "ㄍㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gw9"), "ㄍㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gm"), "ㄍㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gm8"), "ㄍㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gm9"), "ㄍㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gn"), "ㄍㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gn7"), "ㄍㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gn8"), "ㄍㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gn9"), "ㄍㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gk"), "ㄍㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gk8"), "ㄍㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gk9"), "ㄍㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gg"), "ㄍㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gg8"), "ㄍㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gg9"), "ㄍㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gu"), "ㄍㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gu7"), "ㄍㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gu8"), "ㄍㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gu9"), "ㄍㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gua"), "ㄍㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gua7"), "ㄍㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gua8"), "ㄍㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gua9"), "ㄍㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guo"), "ㄍㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guo7"), "ㄍㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guo8"), "ㄍㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guo9"), "ㄍㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guy"), "ㄍㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guy8"), "ㄍㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guy9"), "ㄍㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gut"), "ㄍㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gut8"), "ㄍㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gut9"), "ㄍㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gum"), "ㄍㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gum8"), "ㄍㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gum9"), "ㄍㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gun"), "ㄍㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gun8"), "ㄍㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gun9"), "ㄍㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guk"), "ㄍㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guk8"), "ㄍㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("guk9"), "ㄍㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gug"), "ㄍㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gug7"), "ㄍㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gug8"), "ㄍㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("gug9"), "ㄍㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ka"), "ㄎㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ka8"), "ㄎㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ka9"), "ㄎㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ke"), "ㄎㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ke7"), "ㄎㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ke8"), "ㄎㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ke9"), "ㄎㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ky"), "ㄎㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ky8"), "ㄎㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ky9"), "ㄎㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kf"), "ㄎㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kf8"), "ㄎㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kf9"), "ㄎㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kw"), "ㄎㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kw8"), "ㄎㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kw9"), "ㄎㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("km"), "ㄎㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("km8"), "ㄎㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("km9"), "ㄎㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kn"), "ㄎㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kn8"), "ㄎㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kn9"), "ㄎㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kk"), "ㄎㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kk7"), "ㄎㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kk8"), "ㄎㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kk9"), "ㄎㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kg"), "ㄎㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kg8"), "ㄎㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ku"), "ㄎㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ku7"), "ㄎㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ku8"), "ㄎㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ku9"), "ㄎㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kua"), "ㄎㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kua8"), "ㄎㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kua9"), "ㄎㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kuo9"), "ㄎㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kuy"), "ㄎㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kuy8"), "ㄎㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kuy9"), "ㄎㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kut"), "ㄎㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kut7"), "ㄎㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kut8"), "ㄎㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kut9"), "ㄎㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kum"), "ㄎㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kum8"), "ㄎㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kum9"), "ㄎㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kun"), "ㄎㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kun8"), "ㄎㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kun9"), "ㄎㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kuk"), "ㄎㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kuk7"), "ㄎㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kuk8"), "ㄎㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kuk9"), "ㄎㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kug"), "ㄎㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kug8"), "ㄎㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("kug9"), "ㄎㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ha"), "ㄏㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ha7"), "ㄏㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ha8"), "ㄏㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("he"), "ㄏㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("he7"), "ㄏㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("he8"), "ㄏㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("he9"), "ㄏㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hy"), "ㄏㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hy7"), "ㄏㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hy8"), "ㄏㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hy9"), "ㄏㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ht"), "ㄏㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ht8"), "ㄏㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hf"), "ㄏㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hf7"), "ㄏㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hf8"), "ㄏㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hf9"), "ㄏㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hw"), "ㄏㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hw7"), "ㄏㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hw8"), "ㄏㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hw9"), "ㄏㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hm"), "ㄏㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hm7"), "ㄏㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hm8"), "ㄏㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hm9"), "ㄏㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hn"), "ㄏㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hn7"), "ㄏㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hn8"), "ㄏㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hn9"), "ㄏㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hk"), "ㄏㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hk7"), "ㄏㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hk8"), "ㄏㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hk9"), "ㄏㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hg"), "ㄏㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hg7"), "ㄏㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hg9"), "ㄏㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hu"), "ㄏㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hu7"), "ㄏㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hu8"), "ㄏㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hu9"), "ㄏㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hua"), "ㄏㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hua7"), "ㄏㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hua8"), "ㄏㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hua9"), "ㄏㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huo"), "ㄏㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huo7"), "ㄏㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huo8"), "ㄏㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huo9"), "ㄏㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huo0"), "ㄏㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("huy7"), "ㄏㄨㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huy9"), "ㄏㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hut"), "ㄏㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hut7"), "ㄏㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hut8"), "ㄏㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hut9"), "ㄏㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hum"), "ㄏㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hum7"), "ㄏㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hum8"), "ㄏㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hum9"), "ㄏㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hun"), "ㄏㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hun7"), "ㄏㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hun8"), "ㄏㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hun9"), "ㄏㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huk"), "ㄏㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huk7"), "ㄏㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huk8"), "ㄏㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huk9"), "ㄏㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("huk0"), "ㄏㄨㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("hug"), "ㄏㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hug7"), "ㄏㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hug8"), "ㄏㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("hug9"), "ㄏㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ji"), "ㄐㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ji7"), "ㄐㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ji8"), "ㄐㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ji9"), "ㄐㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jia"), "ㄐㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jia7"), "ㄐㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jia8"), "ㄐㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jia9"), "ㄐㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jie"), "ㄐㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jie7"), "ㄐㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jie8"), "ㄐㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jie9"), "ㄐㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jie0"), "ㄐㄧㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("jif"), "ㄐㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jif7"), "ㄐㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jif8"), "ㄐㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jif9"), "ㄐㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jiw"), "ㄐㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jiw8"), "ㄐㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jiw9"), "ㄐㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jim"), "ㄐㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jim8"), "ㄐㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jim9"), "ㄐㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jin"), "ㄐㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jin8"), "ㄐㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jin9"), "ㄐㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jik"), "ㄐㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jik7"), "ㄐㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jik8"), "ㄐㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jik9"), "ㄐㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jig"), "ㄐㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jig8"), "ㄐㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jig9"), "ㄐㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jv"), "ㄐㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jv7"), "ㄐㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jv8"), "ㄐㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jv9"), "ㄐㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jve"), "ㄐㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jve7"), "ㄐㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jve8"), "ㄐㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jve9"), "ㄐㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jvm"), "ㄐㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jvm8"), "ㄐㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jvm9"), "ㄐㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jvn"), "ㄐㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jvn7"), "ㄐㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jvn8"), "ㄐㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jvn9"), "ㄐㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jvg"), "ㄐㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jvg8"), "ㄐㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jvg9"), "ㄐㄩㄥˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("q0"), "ㄑ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("qi"), "ㄑㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qi7"), "ㄑㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qi8"), "ㄑㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qi9"), "ㄑㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qia"), "ㄑㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qia7"), "ㄑㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qia8"), "ㄑㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qia9"), "ㄑㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qie"), "ㄑㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qie7"), "ㄑㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qie8"), "ㄑㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qie9"), "ㄑㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qif"), "ㄑㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qif7"), "ㄑㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qif8"), "ㄑㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qif9"), "ㄑㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qiw"), "ㄑㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qiw7"), "ㄑㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qiw8"), "ㄑㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qiw9"), "ㄑㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qim"), "ㄑㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qim7"), "ㄑㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qim8"), "ㄑㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qim9"), "ㄑㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qin"), "ㄑㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qin7"), "ㄑㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qin8"), "ㄑㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qin9"), "ㄑㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qik"), "ㄑㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qik7"), "ㄑㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qik8"), "ㄑㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qik9"), "ㄑㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qig"), "ㄑㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qig7"), "ㄑㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qig8"), "ㄑㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qig9"), "ㄑㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qv"), "ㄑㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qv7"), "ㄑㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qv8"), "ㄑㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qv9"), "ㄑㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qve"), "ㄑㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qve7"), "ㄑㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qve9"), "ㄑㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvm"), "ㄑㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvm7"), "ㄑㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvm8"), "ㄑㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvm9"), "ㄑㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvn"), "ㄑㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvn7"), "ㄑㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvn8"), "ㄑㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvn9"), "ㄑㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvg"), "ㄑㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvg7"), "ㄑㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvg8"), "ㄑㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qvg9"), "ㄑㄩㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xi"), "ㄒㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xi7"), "ㄒㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xi8"), "ㄒㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xi9"), "ㄒㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xia"), "ㄒㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xia7"), "ㄒㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xia8"), "ㄒㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xia9"), "ㄒㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xie"), "ㄒㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xie7"), "ㄒㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xie8"), "ㄒㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xie9"), "ㄒㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xif"), "ㄒㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xif7"), "ㄒㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xif8"), "ㄒㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xif9"), "ㄒㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xiw"), "ㄒㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xiw7"), "ㄒㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xiw8"), "ㄒㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xiw9"), "ㄒㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xim"), "ㄒㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xim7"), "ㄒㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xim8"), "ㄒㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xim9"), "ㄒㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xin"), "ㄒㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xin7"), "ㄒㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xin8"), "ㄒㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xin9"), "ㄒㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xik"), "ㄒㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xik7"), "ㄒㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xik8"), "ㄒㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xik9"), "ㄒㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xig"), "ㄒㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xig7"), "ㄒㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xig8"), "ㄒㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xig9"), "ㄒㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xv"), "ㄒㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xv7"), "ㄒㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xv8"), "ㄒㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xv9"), "ㄒㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xve"), "ㄒㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xve7"), "ㄒㄩㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xve8"), "ㄒㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xve9"), "ㄒㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xvm"), "ㄒㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xvm7"), "ㄒㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xvm8"), "ㄒㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xvm9"), "ㄒㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xvn"), "ㄒㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xvn7"), "ㄒㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xvn9"), "ㄒㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xvg"), "ㄒㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xvg7"), "ㄒㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xvg8"), "ㄒㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xvg9"), "ㄒㄩㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("j"), "ㄓ") - XCTAssertEqual(composer.convertSequenceToRawComposition("j7"), "ㄓˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("j8"), "ㄓˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("j9"), "ㄓˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ja"), "ㄓㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ja7"), "ㄓㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ja8"), "ㄓㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ja9"), "ㄓㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("je"), "ㄓㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("je7"), "ㄓㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("je8"), "ㄓㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("je9"), "ㄓㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("je0"), "ㄓㄜ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("jy"), "ㄓㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jy7"), "ㄓㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jy8"), "ㄓㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jy9"), "ㄓㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jt9"), "ㄓㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jf"), "ㄓㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jf7"), "ㄓㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jf8"), "ㄓㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jf9"), "ㄓㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jw"), "ㄓㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jw7"), "ㄓㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jw8"), "ㄓㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jw9"), "ㄓㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jm"), "ㄓㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jm8"), "ㄓㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jm9"), "ㄓㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jn"), "ㄓㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jn7"), "ㄓㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jn8"), "ㄓㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jn9"), "ㄓㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jk"), "ㄓㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jk8"), "ㄓㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jk9"), "ㄓㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jg"), "ㄓㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jg8"), "ㄓㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jg9"), "ㄓㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ju"), "ㄓㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ju7"), "ㄓㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ju8"), "ㄓㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ju9"), "ㄓㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jua"), "ㄓㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jua8"), "ㄓㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juo"), "ㄓㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juo7"), "ㄓㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juo9"), "ㄓㄨㄛˋ") + var c = Tekkon.Composer(arrange: .ofStarlight) + XCTAssertEqual(c.cS2RC("lt0"), "ㄌㄟ˙") + XCTAssertEqual(c.cS2RC("lf"), "ㄌㄠ") + XCTAssertEqual(c.cS2RC("lf7"), "ㄌㄠˊ") + XCTAssertEqual(c.cS2RC("lf8"), "ㄌㄠˇ") + XCTAssertEqual(c.cS2RC("lf9"), "ㄌㄠˋ") + XCTAssertEqual(c.cS2RC("lw"), "ㄌㄡ") + XCTAssertEqual(c.cS2RC("lw7"), "ㄌㄡˊ") + XCTAssertEqual(c.cS2RC("lw8"), "ㄌㄡˇ") + XCTAssertEqual(c.cS2RC("lw9"), "ㄌㄡˋ") + XCTAssertEqual(c.cS2RC("lw0"), "ㄌㄡ˙") + XCTAssertEqual(c.cS2RC("lm7"), "ㄌㄢˊ") + XCTAssertEqual(c.cS2RC("lm8"), "ㄌㄢˇ") + XCTAssertEqual(c.cS2RC("lm9"), "ㄌㄢˋ") + XCTAssertEqual(c.cS2RC("lk"), "ㄌㄤ") + XCTAssertEqual(c.cS2RC("lk7"), "ㄌㄤˊ") + XCTAssertEqual(c.cS2RC("lk8"), "ㄌㄤˇ") + XCTAssertEqual(c.cS2RC("lk9"), "ㄌㄤˋ") + XCTAssertEqual(c.cS2RC("lg"), "ㄌㄥ") + XCTAssertEqual(c.cS2RC("lg7"), "ㄌㄥˊ") + XCTAssertEqual(c.cS2RC("lg8"), "ㄌㄥˇ") + XCTAssertEqual(c.cS2RC("lg9"), "ㄌㄥˋ") + XCTAssertEqual(c.cS2RC("li"), "ㄌㄧ") + XCTAssertEqual(c.cS2RC("li7"), "ㄌㄧˊ") + XCTAssertEqual(c.cS2RC("li8"), "ㄌㄧˇ") + XCTAssertEqual(c.cS2RC("li9"), "ㄌㄧˋ") + XCTAssertEqual(c.cS2RC("li0"), "ㄌㄧ˙") + XCTAssertEqual(c.cS2RC("lia8"), "ㄌㄧㄚˇ") + XCTAssertEqual(c.cS2RC("lie"), "ㄌㄧㄝ") + XCTAssertEqual(c.cS2RC("lie7"), "ㄌㄧㄝˊ") + XCTAssertEqual(c.cS2RC("lie8"), "ㄌㄧㄝˇ") + XCTAssertEqual(c.cS2RC("lie9"), "ㄌㄧㄝˋ") + XCTAssertEqual(c.cS2RC("lif"), "ㄌㄧㄠ") + XCTAssertEqual(c.cS2RC("lif7"), "ㄌㄧㄠˊ") + XCTAssertEqual(c.cS2RC("lif8"), "ㄌㄧㄠˇ") + XCTAssertEqual(c.cS2RC("lif9"), "ㄌㄧㄠˋ") + XCTAssertEqual(c.cS2RC("liw"), "ㄌㄧㄡ") + XCTAssertEqual(c.cS2RC("liw7"), "ㄌㄧㄡˊ") + XCTAssertEqual(c.cS2RC("liw8"), "ㄌㄧㄡˇ") + XCTAssertEqual(c.cS2RC("liw9"), "ㄌㄧㄡˋ") + XCTAssertEqual(c.cS2RC("lim"), "ㄌㄧㄢ") + XCTAssertEqual(c.cS2RC("lim7"), "ㄌㄧㄢˊ") + XCTAssertEqual(c.cS2RC("lim8"), "ㄌㄧㄢˇ") + XCTAssertEqual(c.cS2RC("lim9"), "ㄌㄧㄢˋ") + XCTAssertEqual(c.cS2RC("lin7"), "ㄌㄧㄣˊ") + XCTAssertEqual(c.cS2RC("lin8"), "ㄌㄧㄣˇ") + XCTAssertEqual(c.cS2RC("lin9"), "ㄌㄧㄣˋ") + XCTAssertEqual(c.cS2RC("lik7"), "ㄌㄧㄤˊ") + XCTAssertEqual(c.cS2RC("lik8"), "ㄌㄧㄤˇ") + XCTAssertEqual(c.cS2RC("lik9"), "ㄌㄧㄤˋ") + XCTAssertEqual(c.cS2RC("lig"), "ㄌㄧㄥ") + XCTAssertEqual(c.cS2RC("lig7"), "ㄌㄧㄥˊ") + XCTAssertEqual(c.cS2RC("lig8"), "ㄌㄧㄥˇ") + XCTAssertEqual(c.cS2RC("lig9"), "ㄌㄧㄥˋ") + XCTAssertEqual(c.cS2RC("lu"), "ㄌㄨ") + XCTAssertEqual(c.cS2RC("lu7"), "ㄌㄨˊ") + XCTAssertEqual(c.cS2RC("lu8"), "ㄌㄨˇ") + XCTAssertEqual(c.cS2RC("lu9"), "ㄌㄨˋ") + XCTAssertEqual(c.cS2RC("luo"), "ㄌㄨㄛ") + XCTAssertEqual(c.cS2RC("luo7"), "ㄌㄨㄛˊ") + XCTAssertEqual(c.cS2RC("luo8"), "ㄌㄨㄛˇ") + XCTAssertEqual(c.cS2RC("luo9"), "ㄌㄨㄛˋ") + XCTAssertEqual(c.cS2RC("luo0"), "ㄌㄨㄛ˙") + XCTAssertEqual(c.cS2RC("lum7"), "ㄌㄨㄢˊ") + XCTAssertEqual(c.cS2RC("lum8"), "ㄌㄨㄢˇ") + XCTAssertEqual(c.cS2RC("lum9"), "ㄌㄨㄢˋ") + XCTAssertEqual(c.cS2RC("lun"), "ㄌㄨㄣ") + XCTAssertEqual(c.cS2RC("lun7"), "ㄌㄨㄣˊ") + XCTAssertEqual(c.cS2RC("lun8"), "ㄌㄨㄣˇ") + XCTAssertEqual(c.cS2RC("lun9"), "ㄌㄨㄣˋ") + XCTAssertEqual(c.cS2RC("lug"), "ㄌㄨㄥ") + XCTAssertEqual(c.cS2RC("lug7"), "ㄌㄨㄥˊ") + XCTAssertEqual(c.cS2RC("lug8"), "ㄌㄨㄥˇ") + XCTAssertEqual(c.cS2RC("lug9"), "ㄌㄨㄥˋ") + XCTAssertEqual(c.cS2RC("lv"), "ㄌㄩ") + XCTAssertEqual(c.cS2RC("lv7"), "ㄌㄩˊ") + XCTAssertEqual(c.cS2RC("lv8"), "ㄌㄩˇ") + XCTAssertEqual(c.cS2RC("lv9"), "ㄌㄩˋ") + XCTAssertEqual(c.cS2RC("lve"), "ㄌㄩㄝ") + XCTAssertEqual(c.cS2RC("lve8"), "ㄌㄩㄝˇ") + XCTAssertEqual(c.cS2RC("lve9"), "ㄌㄩㄝˋ") + XCTAssertEqual(c.cS2RC("lvm7"), "ㄌㄩㄢˊ") + XCTAssertEqual(c.cS2RC("lvm8"), "ㄌㄩㄢˇ") + XCTAssertEqual(c.cS2RC("ga"), "ㄍㄚ") + XCTAssertEqual(c.cS2RC("ga7"), "ㄍㄚˊ") + XCTAssertEqual(c.cS2RC("ga8"), "ㄍㄚˇ") + XCTAssertEqual(c.cS2RC("ga9"), "ㄍㄚˋ") + XCTAssertEqual(c.cS2RC("ga0"), "ㄍㄚ˙") + XCTAssertEqual(c.cS2RC("ge"), "ㄍㄜ") + XCTAssertEqual(c.cS2RC("ge7"), "ㄍㄜˊ") + XCTAssertEqual(c.cS2RC("ge8"), "ㄍㄜˇ") + XCTAssertEqual(c.cS2RC("ge9"), "ㄍㄜˋ") + XCTAssertEqual(c.cS2RC("ge0"), "ㄍㄜ˙") + XCTAssertEqual(c.cS2RC("gy"), "ㄍㄞ") + XCTAssertEqual(c.cS2RC("gy8"), "ㄍㄞˇ") + XCTAssertEqual(c.cS2RC("gy9"), "ㄍㄞˋ") + XCTAssertEqual(c.cS2RC("gt8"), "ㄍㄟˇ") + XCTAssertEqual(c.cS2RC("gf"), "ㄍㄠ") + XCTAssertEqual(c.cS2RC("gf8"), "ㄍㄠˇ") + XCTAssertEqual(c.cS2RC("gf9"), "ㄍㄠˋ") + XCTAssertEqual(c.cS2RC("gw"), "ㄍㄡ") + XCTAssertEqual(c.cS2RC("gw8"), "ㄍㄡˇ") + XCTAssertEqual(c.cS2RC("gw9"), "ㄍㄡˋ") + XCTAssertEqual(c.cS2RC("gm"), "ㄍㄢ") + XCTAssertEqual(c.cS2RC("gm8"), "ㄍㄢˇ") + XCTAssertEqual(c.cS2RC("gm9"), "ㄍㄢˋ") + XCTAssertEqual(c.cS2RC("gn"), "ㄍㄣ") + XCTAssertEqual(c.cS2RC("gn7"), "ㄍㄣˊ") + XCTAssertEqual(c.cS2RC("gn8"), "ㄍㄣˇ") + XCTAssertEqual(c.cS2RC("gn9"), "ㄍㄣˋ") + XCTAssertEqual(c.cS2RC("gk"), "ㄍㄤ") + XCTAssertEqual(c.cS2RC("gk8"), "ㄍㄤˇ") + XCTAssertEqual(c.cS2RC("gk9"), "ㄍㄤˋ") + XCTAssertEqual(c.cS2RC("gg"), "ㄍㄥ") + XCTAssertEqual(c.cS2RC("gg8"), "ㄍㄥˇ") + XCTAssertEqual(c.cS2RC("gg9"), "ㄍㄥˋ") + XCTAssertEqual(c.cS2RC("gu"), "ㄍㄨ") + XCTAssertEqual(c.cS2RC("gu7"), "ㄍㄨˊ") + XCTAssertEqual(c.cS2RC("gu8"), "ㄍㄨˇ") + XCTAssertEqual(c.cS2RC("gu9"), "ㄍㄨˋ") + XCTAssertEqual(c.cS2RC("gua"), "ㄍㄨㄚ") + XCTAssertEqual(c.cS2RC("gua7"), "ㄍㄨㄚˊ") + XCTAssertEqual(c.cS2RC("gua8"), "ㄍㄨㄚˇ") + XCTAssertEqual(c.cS2RC("gua9"), "ㄍㄨㄚˋ") + XCTAssertEqual(c.cS2RC("guo"), "ㄍㄨㄛ") + XCTAssertEqual(c.cS2RC("guo7"), "ㄍㄨㄛˊ") + XCTAssertEqual(c.cS2RC("guo8"), "ㄍㄨㄛˇ") + XCTAssertEqual(c.cS2RC("guo9"), "ㄍㄨㄛˋ") + XCTAssertEqual(c.cS2RC("guy"), "ㄍㄨㄞ") + XCTAssertEqual(c.cS2RC("guy8"), "ㄍㄨㄞˇ") + XCTAssertEqual(c.cS2RC("guy9"), "ㄍㄨㄞˋ") + XCTAssertEqual(c.cS2RC("gut"), "ㄍㄨㄟ") + XCTAssertEqual(c.cS2RC("gut8"), "ㄍㄨㄟˇ") + XCTAssertEqual(c.cS2RC("gut9"), "ㄍㄨㄟˋ") + XCTAssertEqual(c.cS2RC("gum"), "ㄍㄨㄢ") + XCTAssertEqual(c.cS2RC("gum8"), "ㄍㄨㄢˇ") + XCTAssertEqual(c.cS2RC("gum9"), "ㄍㄨㄢˋ") + XCTAssertEqual(c.cS2RC("gun"), "ㄍㄨㄣ") + XCTAssertEqual(c.cS2RC("gun8"), "ㄍㄨㄣˇ") + XCTAssertEqual(c.cS2RC("gun9"), "ㄍㄨㄣˋ") + XCTAssertEqual(c.cS2RC("guk"), "ㄍㄨㄤ") + XCTAssertEqual(c.cS2RC("guk8"), "ㄍㄨㄤˇ") + XCTAssertEqual(c.cS2RC("guk9"), "ㄍㄨㄤˋ") + XCTAssertEqual(c.cS2RC("gug"), "ㄍㄨㄥ") + XCTAssertEqual(c.cS2RC("gug7"), "ㄍㄨㄥˊ") + XCTAssertEqual(c.cS2RC("gug8"), "ㄍㄨㄥˇ") + XCTAssertEqual(c.cS2RC("gug9"), "ㄍㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ka"), "ㄎㄚ") + XCTAssertEqual(c.cS2RC("ka8"), "ㄎㄚˇ") + XCTAssertEqual(c.cS2RC("ka9"), "ㄎㄚˋ") + XCTAssertEqual(c.cS2RC("ke"), "ㄎㄜ") + XCTAssertEqual(c.cS2RC("ke7"), "ㄎㄜˊ") + XCTAssertEqual(c.cS2RC("ke8"), "ㄎㄜˇ") + XCTAssertEqual(c.cS2RC("ke9"), "ㄎㄜˋ") + XCTAssertEqual(c.cS2RC("ky"), "ㄎㄞ") + XCTAssertEqual(c.cS2RC("ky8"), "ㄎㄞˇ") + XCTAssertEqual(c.cS2RC("ky9"), "ㄎㄞˋ") + XCTAssertEqual(c.cS2RC("kf"), "ㄎㄠ") + XCTAssertEqual(c.cS2RC("kf8"), "ㄎㄠˇ") + XCTAssertEqual(c.cS2RC("kf9"), "ㄎㄠˋ") + XCTAssertEqual(c.cS2RC("kw"), "ㄎㄡ") + XCTAssertEqual(c.cS2RC("kw8"), "ㄎㄡˇ") + XCTAssertEqual(c.cS2RC("kw9"), "ㄎㄡˋ") + XCTAssertEqual(c.cS2RC("km"), "ㄎㄢ") + XCTAssertEqual(c.cS2RC("km8"), "ㄎㄢˇ") + XCTAssertEqual(c.cS2RC("km9"), "ㄎㄢˋ") + XCTAssertEqual(c.cS2RC("kn"), "ㄎㄣ") + XCTAssertEqual(c.cS2RC("kn8"), "ㄎㄣˇ") + XCTAssertEqual(c.cS2RC("kn9"), "ㄎㄣˋ") + XCTAssertEqual(c.cS2RC("kk"), "ㄎㄤ") + XCTAssertEqual(c.cS2RC("kk7"), "ㄎㄤˊ") + XCTAssertEqual(c.cS2RC("kk8"), "ㄎㄤˇ") + XCTAssertEqual(c.cS2RC("kk9"), "ㄎㄤˋ") + XCTAssertEqual(c.cS2RC("kg"), "ㄎㄥ") + XCTAssertEqual(c.cS2RC("kg8"), "ㄎㄥˇ") + XCTAssertEqual(c.cS2RC("ku"), "ㄎㄨ") + XCTAssertEqual(c.cS2RC("ku7"), "ㄎㄨˊ") + XCTAssertEqual(c.cS2RC("ku8"), "ㄎㄨˇ") + XCTAssertEqual(c.cS2RC("ku9"), "ㄎㄨˋ") + XCTAssertEqual(c.cS2RC("kua"), "ㄎㄨㄚ") + XCTAssertEqual(c.cS2RC("kua8"), "ㄎㄨㄚˇ") + XCTAssertEqual(c.cS2RC("kua9"), "ㄎㄨㄚˋ") + XCTAssertEqual(c.cS2RC("kuo9"), "ㄎㄨㄛˋ") + XCTAssertEqual(c.cS2RC("kuy"), "ㄎㄨㄞ") + XCTAssertEqual(c.cS2RC("kuy8"), "ㄎㄨㄞˇ") + XCTAssertEqual(c.cS2RC("kuy9"), "ㄎㄨㄞˋ") + XCTAssertEqual(c.cS2RC("kut"), "ㄎㄨㄟ") + XCTAssertEqual(c.cS2RC("kut7"), "ㄎㄨㄟˊ") + XCTAssertEqual(c.cS2RC("kut8"), "ㄎㄨㄟˇ") + XCTAssertEqual(c.cS2RC("kut9"), "ㄎㄨㄟˋ") + XCTAssertEqual(c.cS2RC("kum"), "ㄎㄨㄢ") + XCTAssertEqual(c.cS2RC("kum8"), "ㄎㄨㄢˇ") + XCTAssertEqual(c.cS2RC("kum9"), "ㄎㄨㄢˋ") + XCTAssertEqual(c.cS2RC("kun"), "ㄎㄨㄣ") + XCTAssertEqual(c.cS2RC("kun8"), "ㄎㄨㄣˇ") + XCTAssertEqual(c.cS2RC("kun9"), "ㄎㄨㄣˋ") + XCTAssertEqual(c.cS2RC("kuk"), "ㄎㄨㄤ") + XCTAssertEqual(c.cS2RC("kuk7"), "ㄎㄨㄤˊ") + XCTAssertEqual(c.cS2RC("kuk8"), "ㄎㄨㄤˇ") + XCTAssertEqual(c.cS2RC("kuk9"), "ㄎㄨㄤˋ") + XCTAssertEqual(c.cS2RC("kug"), "ㄎㄨㄥ") + XCTAssertEqual(c.cS2RC("kug8"), "ㄎㄨㄥˇ") + XCTAssertEqual(c.cS2RC("kug9"), "ㄎㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ha"), "ㄏㄚ") + XCTAssertEqual(c.cS2RC("ha7"), "ㄏㄚˊ") + XCTAssertEqual(c.cS2RC("ha8"), "ㄏㄚˇ") + XCTAssertEqual(c.cS2RC("he"), "ㄏㄜ") + XCTAssertEqual(c.cS2RC("he7"), "ㄏㄜˊ") + XCTAssertEqual(c.cS2RC("he8"), "ㄏㄜˇ") + XCTAssertEqual(c.cS2RC("he9"), "ㄏㄜˋ") + XCTAssertEqual(c.cS2RC("hy"), "ㄏㄞ") + XCTAssertEqual(c.cS2RC("hy7"), "ㄏㄞˊ") + XCTAssertEqual(c.cS2RC("hy8"), "ㄏㄞˇ") + XCTAssertEqual(c.cS2RC("hy9"), "ㄏㄞˋ") + XCTAssertEqual(c.cS2RC("ht"), "ㄏㄟ") + XCTAssertEqual(c.cS2RC("ht8"), "ㄏㄟˇ") + XCTAssertEqual(c.cS2RC("hf"), "ㄏㄠ") + XCTAssertEqual(c.cS2RC("hf7"), "ㄏㄠˊ") + XCTAssertEqual(c.cS2RC("hf8"), "ㄏㄠˇ") + XCTAssertEqual(c.cS2RC("hf9"), "ㄏㄠˋ") + XCTAssertEqual(c.cS2RC("hw"), "ㄏㄡ") + XCTAssertEqual(c.cS2RC("hw7"), "ㄏㄡˊ") + XCTAssertEqual(c.cS2RC("hw8"), "ㄏㄡˇ") + XCTAssertEqual(c.cS2RC("hw9"), "ㄏㄡˋ") + XCTAssertEqual(c.cS2RC("hm"), "ㄏㄢ") + XCTAssertEqual(c.cS2RC("hm7"), "ㄏㄢˊ") + XCTAssertEqual(c.cS2RC("hm8"), "ㄏㄢˇ") + XCTAssertEqual(c.cS2RC("hm9"), "ㄏㄢˋ") + XCTAssertEqual(c.cS2RC("hn"), "ㄏㄣ") + XCTAssertEqual(c.cS2RC("hn7"), "ㄏㄣˊ") + XCTAssertEqual(c.cS2RC("hn8"), "ㄏㄣˇ") + XCTAssertEqual(c.cS2RC("hn9"), "ㄏㄣˋ") + XCTAssertEqual(c.cS2RC("hk"), "ㄏㄤ") + XCTAssertEqual(c.cS2RC("hk7"), "ㄏㄤˊ") + XCTAssertEqual(c.cS2RC("hk8"), "ㄏㄤˇ") + XCTAssertEqual(c.cS2RC("hk9"), "ㄏㄤˋ") + XCTAssertEqual(c.cS2RC("hg"), "ㄏㄥ") + XCTAssertEqual(c.cS2RC("hg7"), "ㄏㄥˊ") + XCTAssertEqual(c.cS2RC("hg9"), "ㄏㄥˋ") + XCTAssertEqual(c.cS2RC("hu"), "ㄏㄨ") + XCTAssertEqual(c.cS2RC("hu7"), "ㄏㄨˊ") + XCTAssertEqual(c.cS2RC("hu8"), "ㄏㄨˇ") + XCTAssertEqual(c.cS2RC("hu9"), "ㄏㄨˋ") + XCTAssertEqual(c.cS2RC("hua"), "ㄏㄨㄚ") + XCTAssertEqual(c.cS2RC("hua7"), "ㄏㄨㄚˊ") + XCTAssertEqual(c.cS2RC("hua8"), "ㄏㄨㄚˇ") + XCTAssertEqual(c.cS2RC("hua9"), "ㄏㄨㄚˋ") + XCTAssertEqual(c.cS2RC("huo"), "ㄏㄨㄛ") + XCTAssertEqual(c.cS2RC("huo7"), "ㄏㄨㄛˊ") + XCTAssertEqual(c.cS2RC("huo8"), "ㄏㄨㄛˇ") + XCTAssertEqual(c.cS2RC("huo9"), "ㄏㄨㄛˋ") + XCTAssertEqual(c.cS2RC("huo0"), "ㄏㄨㄛ˙") + XCTAssertEqual(c.cS2RC("huy7"), "ㄏㄨㄞˊ") + XCTAssertEqual(c.cS2RC("huy9"), "ㄏㄨㄞˋ") + XCTAssertEqual(c.cS2RC("hut"), "ㄏㄨㄟ") + XCTAssertEqual(c.cS2RC("hut7"), "ㄏㄨㄟˊ") + XCTAssertEqual(c.cS2RC("hut8"), "ㄏㄨㄟˇ") + XCTAssertEqual(c.cS2RC("hut9"), "ㄏㄨㄟˋ") + XCTAssertEqual(c.cS2RC("hum"), "ㄏㄨㄢ") + XCTAssertEqual(c.cS2RC("hum7"), "ㄏㄨㄢˊ") + XCTAssertEqual(c.cS2RC("hum8"), "ㄏㄨㄢˇ") + XCTAssertEqual(c.cS2RC("hum9"), "ㄏㄨㄢˋ") + XCTAssertEqual(c.cS2RC("hun"), "ㄏㄨㄣ") + XCTAssertEqual(c.cS2RC("hun7"), "ㄏㄨㄣˊ") + XCTAssertEqual(c.cS2RC("hun8"), "ㄏㄨㄣˇ") + XCTAssertEqual(c.cS2RC("hun9"), "ㄏㄨㄣˋ") + XCTAssertEqual(c.cS2RC("huk"), "ㄏㄨㄤ") + XCTAssertEqual(c.cS2RC("huk7"), "ㄏㄨㄤˊ") + XCTAssertEqual(c.cS2RC("huk8"), "ㄏㄨㄤˇ") + XCTAssertEqual(c.cS2RC("huk9"), "ㄏㄨㄤˋ") + XCTAssertEqual(c.cS2RC("huk0"), "ㄏㄨㄤ˙") + XCTAssertEqual(c.cS2RC("hug"), "ㄏㄨㄥ") + XCTAssertEqual(c.cS2RC("hug7"), "ㄏㄨㄥˊ") + XCTAssertEqual(c.cS2RC("hug8"), "ㄏㄨㄥˇ") + XCTAssertEqual(c.cS2RC("hug9"), "ㄏㄨㄥˋ") + XCTAssertEqual(c.cS2RC("ji"), "ㄐㄧ") + XCTAssertEqual(c.cS2RC("ji7"), "ㄐㄧˊ") + XCTAssertEqual(c.cS2RC("ji8"), "ㄐㄧˇ") + XCTAssertEqual(c.cS2RC("ji9"), "ㄐㄧˋ") + XCTAssertEqual(c.cS2RC("jia"), "ㄐㄧㄚ") + XCTAssertEqual(c.cS2RC("jia7"), "ㄐㄧㄚˊ") + XCTAssertEqual(c.cS2RC("jia8"), "ㄐㄧㄚˇ") + XCTAssertEqual(c.cS2RC("jia9"), "ㄐㄧㄚˋ") + XCTAssertEqual(c.cS2RC("jie"), "ㄐㄧㄝ") + XCTAssertEqual(c.cS2RC("jie7"), "ㄐㄧㄝˊ") + XCTAssertEqual(c.cS2RC("jie8"), "ㄐㄧㄝˇ") + XCTAssertEqual(c.cS2RC("jie9"), "ㄐㄧㄝˋ") + XCTAssertEqual(c.cS2RC("jie0"), "ㄐㄧㄝ˙") + XCTAssertEqual(c.cS2RC("jif"), "ㄐㄧㄠ") + XCTAssertEqual(c.cS2RC("jif7"), "ㄐㄧㄠˊ") + XCTAssertEqual(c.cS2RC("jif8"), "ㄐㄧㄠˇ") + XCTAssertEqual(c.cS2RC("jif9"), "ㄐㄧㄠˋ") + XCTAssertEqual(c.cS2RC("jiw"), "ㄐㄧㄡ") + XCTAssertEqual(c.cS2RC("jiw8"), "ㄐㄧㄡˇ") + XCTAssertEqual(c.cS2RC("jiw9"), "ㄐㄧㄡˋ") + XCTAssertEqual(c.cS2RC("jim"), "ㄐㄧㄢ") + XCTAssertEqual(c.cS2RC("jim8"), "ㄐㄧㄢˇ") + XCTAssertEqual(c.cS2RC("jim9"), "ㄐㄧㄢˋ") + XCTAssertEqual(c.cS2RC("jin"), "ㄐㄧㄣ") + XCTAssertEqual(c.cS2RC("jin8"), "ㄐㄧㄣˇ") + XCTAssertEqual(c.cS2RC("jin9"), "ㄐㄧㄣˋ") + XCTAssertEqual(c.cS2RC("jik"), "ㄐㄧㄤ") + XCTAssertEqual(c.cS2RC("jik7"), "ㄐㄧㄤˊ") + XCTAssertEqual(c.cS2RC("jik8"), "ㄐㄧㄤˇ") + XCTAssertEqual(c.cS2RC("jik9"), "ㄐㄧㄤˋ") + XCTAssertEqual(c.cS2RC("jig"), "ㄐㄧㄥ") + XCTAssertEqual(c.cS2RC("jig8"), "ㄐㄧㄥˇ") + XCTAssertEqual(c.cS2RC("jig9"), "ㄐㄧㄥˋ") + XCTAssertEqual(c.cS2RC("jv"), "ㄐㄩ") + XCTAssertEqual(c.cS2RC("jv7"), "ㄐㄩˊ") + XCTAssertEqual(c.cS2RC("jv8"), "ㄐㄩˇ") + XCTAssertEqual(c.cS2RC("jv9"), "ㄐㄩˋ") + XCTAssertEqual(c.cS2RC("jve"), "ㄐㄩㄝ") + XCTAssertEqual(c.cS2RC("jve7"), "ㄐㄩㄝˊ") + XCTAssertEqual(c.cS2RC("jve8"), "ㄐㄩㄝˇ") + XCTAssertEqual(c.cS2RC("jve9"), "ㄐㄩㄝˋ") + XCTAssertEqual(c.cS2RC("jvm"), "ㄐㄩㄢ") + XCTAssertEqual(c.cS2RC("jvm8"), "ㄐㄩㄢˇ") + XCTAssertEqual(c.cS2RC("jvm9"), "ㄐㄩㄢˋ") + XCTAssertEqual(c.cS2RC("jvn"), "ㄐㄩㄣ") + XCTAssertEqual(c.cS2RC("jvn7"), "ㄐㄩㄣˊ") + XCTAssertEqual(c.cS2RC("jvn8"), "ㄐㄩㄣˇ") + XCTAssertEqual(c.cS2RC("jvn9"), "ㄐㄩㄣˋ") + XCTAssertEqual(c.cS2RC("jvg"), "ㄐㄩㄥ") + XCTAssertEqual(c.cS2RC("jvg8"), "ㄐㄩㄥˇ") + XCTAssertEqual(c.cS2RC("jvg9"), "ㄐㄩㄥˋ") + // XCTAssertEqual(c.cS2RC("q0"), "ㄑ˙") + XCTAssertEqual(c.cS2RC("qi"), "ㄑㄧ") + XCTAssertEqual(c.cS2RC("qi7"), "ㄑㄧˊ") + XCTAssertEqual(c.cS2RC("qi8"), "ㄑㄧˇ") + XCTAssertEqual(c.cS2RC("qi9"), "ㄑㄧˋ") + XCTAssertEqual(c.cS2RC("qia"), "ㄑㄧㄚ") + XCTAssertEqual(c.cS2RC("qia7"), "ㄑㄧㄚˊ") + XCTAssertEqual(c.cS2RC("qia8"), "ㄑㄧㄚˇ") + XCTAssertEqual(c.cS2RC("qia9"), "ㄑㄧㄚˋ") + XCTAssertEqual(c.cS2RC("qie"), "ㄑㄧㄝ") + XCTAssertEqual(c.cS2RC("qie7"), "ㄑㄧㄝˊ") + XCTAssertEqual(c.cS2RC("qie8"), "ㄑㄧㄝˇ") + XCTAssertEqual(c.cS2RC("qie9"), "ㄑㄧㄝˋ") + XCTAssertEqual(c.cS2RC("qif"), "ㄑㄧㄠ") + XCTAssertEqual(c.cS2RC("qif7"), "ㄑㄧㄠˊ") + XCTAssertEqual(c.cS2RC("qif8"), "ㄑㄧㄠˇ") + XCTAssertEqual(c.cS2RC("qif9"), "ㄑㄧㄠˋ") + XCTAssertEqual(c.cS2RC("qiw"), "ㄑㄧㄡ") + XCTAssertEqual(c.cS2RC("qiw7"), "ㄑㄧㄡˊ") + XCTAssertEqual(c.cS2RC("qiw8"), "ㄑㄧㄡˇ") + XCTAssertEqual(c.cS2RC("qiw9"), "ㄑㄧㄡˋ") + XCTAssertEqual(c.cS2RC("qim"), "ㄑㄧㄢ") + XCTAssertEqual(c.cS2RC("qim7"), "ㄑㄧㄢˊ") + XCTAssertEqual(c.cS2RC("qim8"), "ㄑㄧㄢˇ") + XCTAssertEqual(c.cS2RC("qim9"), "ㄑㄧㄢˋ") + XCTAssertEqual(c.cS2RC("qin"), "ㄑㄧㄣ") + XCTAssertEqual(c.cS2RC("qin7"), "ㄑㄧㄣˊ") + XCTAssertEqual(c.cS2RC("qin8"), "ㄑㄧㄣˇ") + XCTAssertEqual(c.cS2RC("qin9"), "ㄑㄧㄣˋ") + XCTAssertEqual(c.cS2RC("qik"), "ㄑㄧㄤ") + XCTAssertEqual(c.cS2RC("qik7"), "ㄑㄧㄤˊ") + XCTAssertEqual(c.cS2RC("qik8"), "ㄑㄧㄤˇ") + XCTAssertEqual(c.cS2RC("qik9"), "ㄑㄧㄤˋ") + XCTAssertEqual(c.cS2RC("qig"), "ㄑㄧㄥ") + XCTAssertEqual(c.cS2RC("qig7"), "ㄑㄧㄥˊ") + XCTAssertEqual(c.cS2RC("qig8"), "ㄑㄧㄥˇ") + XCTAssertEqual(c.cS2RC("qig9"), "ㄑㄧㄥˋ") + XCTAssertEqual(c.cS2RC("qv"), "ㄑㄩ") + XCTAssertEqual(c.cS2RC("qv7"), "ㄑㄩˊ") + XCTAssertEqual(c.cS2RC("qv8"), "ㄑㄩˇ") + XCTAssertEqual(c.cS2RC("qv9"), "ㄑㄩˋ") + XCTAssertEqual(c.cS2RC("qve"), "ㄑㄩㄝ") + XCTAssertEqual(c.cS2RC("qve7"), "ㄑㄩㄝˊ") + XCTAssertEqual(c.cS2RC("qve9"), "ㄑㄩㄝˋ") + XCTAssertEqual(c.cS2RC("qvm"), "ㄑㄩㄢ") + XCTAssertEqual(c.cS2RC("qvm7"), "ㄑㄩㄢˊ") + XCTAssertEqual(c.cS2RC("qvm8"), "ㄑㄩㄢˇ") + XCTAssertEqual(c.cS2RC("qvm9"), "ㄑㄩㄢˋ") + XCTAssertEqual(c.cS2RC("qvn"), "ㄑㄩㄣ") + XCTAssertEqual(c.cS2RC("qvn7"), "ㄑㄩㄣˊ") + XCTAssertEqual(c.cS2RC("qvn8"), "ㄑㄩㄣˇ") + XCTAssertEqual(c.cS2RC("qvn9"), "ㄑㄩㄣˋ") + XCTAssertEqual(c.cS2RC("qvg"), "ㄑㄩㄥ") + XCTAssertEqual(c.cS2RC("qvg7"), "ㄑㄩㄥˊ") + XCTAssertEqual(c.cS2RC("qvg8"), "ㄑㄩㄥˇ") + XCTAssertEqual(c.cS2RC("qvg9"), "ㄑㄩㄥˋ") + XCTAssertEqual(c.cS2RC("xi"), "ㄒㄧ") + XCTAssertEqual(c.cS2RC("xi7"), "ㄒㄧˊ") + XCTAssertEqual(c.cS2RC("xi8"), "ㄒㄧˇ") + XCTAssertEqual(c.cS2RC("xi9"), "ㄒㄧˋ") + XCTAssertEqual(c.cS2RC("xia"), "ㄒㄧㄚ") + XCTAssertEqual(c.cS2RC("xia7"), "ㄒㄧㄚˊ") + XCTAssertEqual(c.cS2RC("xia8"), "ㄒㄧㄚˇ") + XCTAssertEqual(c.cS2RC("xia9"), "ㄒㄧㄚˋ") + XCTAssertEqual(c.cS2RC("xie"), "ㄒㄧㄝ") + XCTAssertEqual(c.cS2RC("xie7"), "ㄒㄧㄝˊ") + XCTAssertEqual(c.cS2RC("xie8"), "ㄒㄧㄝˇ") + XCTAssertEqual(c.cS2RC("xie9"), "ㄒㄧㄝˋ") + XCTAssertEqual(c.cS2RC("xif"), "ㄒㄧㄠ") + XCTAssertEqual(c.cS2RC("xif7"), "ㄒㄧㄠˊ") + XCTAssertEqual(c.cS2RC("xif8"), "ㄒㄧㄠˇ") + XCTAssertEqual(c.cS2RC("xif9"), "ㄒㄧㄠˋ") + XCTAssertEqual(c.cS2RC("xiw"), "ㄒㄧㄡ") + XCTAssertEqual(c.cS2RC("xiw7"), "ㄒㄧㄡˊ") + XCTAssertEqual(c.cS2RC("xiw8"), "ㄒㄧㄡˇ") + XCTAssertEqual(c.cS2RC("xiw9"), "ㄒㄧㄡˋ") + XCTAssertEqual(c.cS2RC("xim"), "ㄒㄧㄢ") + XCTAssertEqual(c.cS2RC("xim7"), "ㄒㄧㄢˊ") + XCTAssertEqual(c.cS2RC("xim8"), "ㄒㄧㄢˇ") + XCTAssertEqual(c.cS2RC("xim9"), "ㄒㄧㄢˋ") + XCTAssertEqual(c.cS2RC("xin"), "ㄒㄧㄣ") + XCTAssertEqual(c.cS2RC("xin7"), "ㄒㄧㄣˊ") + XCTAssertEqual(c.cS2RC("xin8"), "ㄒㄧㄣˇ") + XCTAssertEqual(c.cS2RC("xin9"), "ㄒㄧㄣˋ") + XCTAssertEqual(c.cS2RC("xik"), "ㄒㄧㄤ") + XCTAssertEqual(c.cS2RC("xik7"), "ㄒㄧㄤˊ") + XCTAssertEqual(c.cS2RC("xik8"), "ㄒㄧㄤˇ") + XCTAssertEqual(c.cS2RC("xik9"), "ㄒㄧㄤˋ") + XCTAssertEqual(c.cS2RC("xig"), "ㄒㄧㄥ") + XCTAssertEqual(c.cS2RC("xig7"), "ㄒㄧㄥˊ") + XCTAssertEqual(c.cS2RC("xig8"), "ㄒㄧㄥˇ") + XCTAssertEqual(c.cS2RC("xig9"), "ㄒㄧㄥˋ") + XCTAssertEqual(c.cS2RC("xv"), "ㄒㄩ") + XCTAssertEqual(c.cS2RC("xv7"), "ㄒㄩˊ") + XCTAssertEqual(c.cS2RC("xv8"), "ㄒㄩˇ") + XCTAssertEqual(c.cS2RC("xv9"), "ㄒㄩˋ") + XCTAssertEqual(c.cS2RC("xve"), "ㄒㄩㄝ") + XCTAssertEqual(c.cS2RC("xve7"), "ㄒㄩㄝˊ") + XCTAssertEqual(c.cS2RC("xve8"), "ㄒㄩㄝˇ") + XCTAssertEqual(c.cS2RC("xve9"), "ㄒㄩㄝˋ") + XCTAssertEqual(c.cS2RC("xvm"), "ㄒㄩㄢ") + XCTAssertEqual(c.cS2RC("xvm7"), "ㄒㄩㄢˊ") + XCTAssertEqual(c.cS2RC("xvm8"), "ㄒㄩㄢˇ") + XCTAssertEqual(c.cS2RC("xvm9"), "ㄒㄩㄢˋ") + XCTAssertEqual(c.cS2RC("xvn"), "ㄒㄩㄣ") + XCTAssertEqual(c.cS2RC("xvn7"), "ㄒㄩㄣˊ") + XCTAssertEqual(c.cS2RC("xvn9"), "ㄒㄩㄣˋ") + XCTAssertEqual(c.cS2RC("xvg"), "ㄒㄩㄥ") + XCTAssertEqual(c.cS2RC("xvg7"), "ㄒㄩㄥˊ") + XCTAssertEqual(c.cS2RC("xvg8"), "ㄒㄩㄥˇ") + XCTAssertEqual(c.cS2RC("xvg9"), "ㄒㄩㄥˋ") + XCTAssertEqual(c.cS2RC("j"), "ㄓ") + XCTAssertEqual(c.cS2RC("j7"), "ㄓˊ") + XCTAssertEqual(c.cS2RC("j8"), "ㄓˇ") + XCTAssertEqual(c.cS2RC("j9"), "ㄓˋ") + XCTAssertEqual(c.cS2RC("ja"), "ㄓㄚ") + XCTAssertEqual(c.cS2RC("ja7"), "ㄓㄚˊ") + XCTAssertEqual(c.cS2RC("ja8"), "ㄓㄚˇ") + XCTAssertEqual(c.cS2RC("ja9"), "ㄓㄚˋ") + XCTAssertEqual(c.cS2RC("je"), "ㄓㄜ") + XCTAssertEqual(c.cS2RC("je7"), "ㄓㄜˊ") + XCTAssertEqual(c.cS2RC("je8"), "ㄓㄜˇ") + XCTAssertEqual(c.cS2RC("je9"), "ㄓㄜˋ") + XCTAssertEqual(c.cS2RC("je0"), "ㄓㄜ˙") + XCTAssertEqual(c.cS2RC("jy"), "ㄓㄞ") + XCTAssertEqual(c.cS2RC("jy7"), "ㄓㄞˊ") + XCTAssertEqual(c.cS2RC("jy8"), "ㄓㄞˇ") + XCTAssertEqual(c.cS2RC("jy9"), "ㄓㄞˋ") + XCTAssertEqual(c.cS2RC("jt9"), "ㄓㄟˋ") + XCTAssertEqual(c.cS2RC("jf"), "ㄓㄠ") + XCTAssertEqual(c.cS2RC("jf7"), "ㄓㄠˊ") + XCTAssertEqual(c.cS2RC("jf8"), "ㄓㄠˇ") + XCTAssertEqual(c.cS2RC("jf9"), "ㄓㄠˋ") + XCTAssertEqual(c.cS2RC("jw"), "ㄓㄡ") + XCTAssertEqual(c.cS2RC("jw7"), "ㄓㄡˊ") + XCTAssertEqual(c.cS2RC("jw8"), "ㄓㄡˇ") + XCTAssertEqual(c.cS2RC("jw9"), "ㄓㄡˋ") + XCTAssertEqual(c.cS2RC("jm"), "ㄓㄢ") + XCTAssertEqual(c.cS2RC("jm8"), "ㄓㄢˇ") + XCTAssertEqual(c.cS2RC("jm9"), "ㄓㄢˋ") + XCTAssertEqual(c.cS2RC("jn"), "ㄓㄣ") + XCTAssertEqual(c.cS2RC("jn7"), "ㄓㄣˊ") + XCTAssertEqual(c.cS2RC("jn8"), "ㄓㄣˇ") + XCTAssertEqual(c.cS2RC("jn9"), "ㄓㄣˋ") + XCTAssertEqual(c.cS2RC("jk"), "ㄓㄤ") + XCTAssertEqual(c.cS2RC("jk8"), "ㄓㄤˇ") + XCTAssertEqual(c.cS2RC("jk9"), "ㄓㄤˋ") + XCTAssertEqual(c.cS2RC("jg"), "ㄓㄥ") + XCTAssertEqual(c.cS2RC("jg8"), "ㄓㄥˇ") + XCTAssertEqual(c.cS2RC("jg9"), "ㄓㄥˋ") + XCTAssertEqual(c.cS2RC("ju"), "ㄓㄨ") + XCTAssertEqual(c.cS2RC("ju7"), "ㄓㄨˊ") + XCTAssertEqual(c.cS2RC("ju8"), "ㄓㄨˇ") + XCTAssertEqual(c.cS2RC("ju9"), "ㄓㄨˋ") + XCTAssertEqual(c.cS2RC("jua"), "ㄓㄨㄚ") + XCTAssertEqual(c.cS2RC("jua8"), "ㄓㄨㄚˇ") + XCTAssertEqual(c.cS2RC("juo"), "ㄓㄨㄛ") + XCTAssertEqual(c.cS2RC("juo7"), "ㄓㄨㄛˊ") + XCTAssertEqual(c.cS2RC("juo9"), "ㄓㄨㄛˋ") } } diff --git a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_C.swift b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_C.swift index 624cedaa..1014ffaa 100644 --- a/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_C.swift +++ b/Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_C.swift @@ -12,511 +12,511 @@ import XCTest extension TekkonTestsKeyboardArrangments { func testStarlightKeysC() throws { - var composer = Tekkon.Composer(arrange: .ofStarlight) - XCTAssertEqual(composer.convertSequenceToRawComposition("juy"), "ㄓㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juy8"), "ㄓㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juy9"), "ㄓㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jut"), "ㄓㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jut8"), "ㄓㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jut9"), "ㄓㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jum"), "ㄓㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jum8"), "ㄓㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jum9"), "ㄓㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jun"), "ㄓㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jun8"), "ㄓㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jun9"), "ㄓㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juk"), "ㄓㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juk8"), "ㄓㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("juk9"), "ㄓㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jug"), "ㄓㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jug8"), "ㄓㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("jug9"), "ㄓㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("q"), "ㄔ") - XCTAssertEqual(composer.convertSequenceToRawComposition("q7"), "ㄔˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("q8"), "ㄔˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("q9"), "ㄔˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qa"), "ㄔㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qa7"), "ㄔㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qa8"), "ㄔㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qa9"), "ㄔㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qe"), "ㄔㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qe8"), "ㄔㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qe9"), "ㄔㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qy"), "ㄔㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qy7"), "ㄔㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qy8"), "ㄔㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qy9"), "ㄔㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qf"), "ㄔㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qf7"), "ㄔㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qf8"), "ㄔㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qf9"), "ㄔㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qw"), "ㄔㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qw7"), "ㄔㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qw8"), "ㄔㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qw9"), "ㄔㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qm"), "ㄔㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qm7"), "ㄔㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qm8"), "ㄔㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qm9"), "ㄔㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qn"), "ㄔㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qn7"), "ㄔㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qn8"), "ㄔㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qn9"), "ㄔㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qn0"), "ㄔㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("qk"), "ㄔㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qk7"), "ㄔㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qk8"), "ㄔㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qk9"), "ㄔㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qg"), "ㄔㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qg7"), "ㄔㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qg8"), "ㄔㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qg9"), "ㄔㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qu"), "ㄔㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qu7"), "ㄔㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qu8"), "ㄔㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qu9"), "ㄔㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qua"), "ㄔㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qua8"), "ㄔㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qua9"), "ㄔㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quo"), "ㄔㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quo9"), "ㄔㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quy"), "ㄔㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quy7"), "ㄔㄨㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quy8"), "ㄔㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quy9"), "ㄔㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qut"), "ㄔㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qut7"), "ㄔㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qut8"), "ㄔㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qut9"), "ㄔㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qum"), "ㄔㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qum7"), "ㄔㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qum8"), "ㄔㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qum9"), "ㄔㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qun"), "ㄔㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qun7"), "ㄔㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qun8"), "ㄔㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quk"), "ㄔㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quk7"), "ㄔㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quk8"), "ㄔㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("quk9"), "ㄔㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qug"), "ㄔㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qug7"), "ㄔㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qug8"), "ㄔㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("qug9"), "ㄔㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("x"), "ㄕ") - XCTAssertEqual(composer.convertSequenceToRawComposition("x7"), "ㄕˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("x8"), "ㄕˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("x9"), "ㄕˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("x0"), "ㄕ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("xa"), "ㄕㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xa7"), "ㄕㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xa8"), "ㄕㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xa9"), "ㄕㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xa0"), "ㄕㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("xe"), "ㄕㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xe7"), "ㄕㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xe8"), "ㄕㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xe9"), "ㄕㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xy"), "ㄕㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xy8"), "ㄕㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xy9"), "ㄕㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xt7"), "ㄕㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xf"), "ㄕㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xf7"), "ㄕㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xf8"), "ㄕㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xf9"), "ㄕㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xw"), "ㄕㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xw7"), "ㄕㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xw8"), "ㄕㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xw9"), "ㄕㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xm"), "ㄕㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xm7"), "ㄕㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xm8"), "ㄕㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xm9"), "ㄕㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xn"), "ㄕㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xn7"), "ㄕㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xn8"), "ㄕㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xn9"), "ㄕㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xk"), "ㄕㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xk8"), "ㄕㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xk9"), "ㄕㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xk0"), "ㄕㄤ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("xg"), "ㄕㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xg7"), "ㄕㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xg8"), "ㄕㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xg9"), "ㄕㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xu"), "ㄕㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xu7"), "ㄕㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xu8"), "ㄕㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xu9"), "ㄕㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xua"), "ㄕㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xua8"), "ㄕㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xua9"), "ㄕㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuo"), "ㄕㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuo9"), "ㄕㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuy"), "ㄕㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuy8"), "ㄕㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuy9"), "ㄕㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xut"), "ㄕㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xut7"), "ㄕㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xut8"), "ㄕㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xut9"), "ㄕㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xum"), "ㄕㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xum9"), "ㄕㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xun8"), "ㄕㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xun9"), "ㄕㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuk"), "ㄕㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuk7"), "ㄕㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuk8"), "ㄕㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("xuk9"), "ㄕㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("r9"), "ㄖˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("re8"), "ㄖㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("re9"), "ㄖㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rf7"), "ㄖㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rf8"), "ㄖㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rf9"), "ㄖㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rw7"), "ㄖㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rw8"), "ㄖㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rw9"), "ㄖㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rm7"), "ㄖㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rm8"), "ㄖㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rm9"), "ㄖㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rn7"), "ㄖㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rn8"), "ㄖㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rn9"), "ㄖㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rk"), "ㄖㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rk7"), "ㄖㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rk8"), "ㄖㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rk9"), "ㄖㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rg"), "ㄖㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rg7"), "ㄖㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rg8"), "ㄖㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rg9"), "ㄖㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ru7"), "ㄖㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ru8"), "ㄖㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ru9"), "ㄖㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ruo7"), "ㄖㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ruo9"), "ㄖㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rut7"), "ㄖㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rut8"), "ㄖㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rut9"), "ㄖㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rum7"), "ㄖㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rum8"), "ㄖㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rum9"), "ㄖㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("run7"), "ㄖㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("run8"), "ㄖㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("run9"), "ㄖㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rug7"), "ㄖㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rug8"), "ㄖㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("rug9"), "ㄖㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("z"), "ㄗ") - XCTAssertEqual(composer.convertSequenceToRawComposition("z7"), "ㄗˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("z8"), "ㄗˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("z9"), "ㄗˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("z0"), "ㄗ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("za"), "ㄗㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("za7"), "ㄗㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("za8"), "ㄗㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ze7"), "ㄗㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ze8"), "ㄗㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ze9"), "ㄗㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zy"), "ㄗㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zy8"), "ㄗㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zy9"), "ㄗㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zt7"), "ㄗㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zf"), "ㄗㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zf7"), "ㄗㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zf8"), "ㄗㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zf9"), "ㄗㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zw"), "ㄗㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zw8"), "ㄗㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zw9"), "ㄗㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zm"), "ㄗㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zm7"), "ㄗㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zm8"), "ㄗㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zm9"), "ㄗㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zn"), "ㄗㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zn8"), "ㄗㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zn9"), "ㄗㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zk"), "ㄗㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zk8"), "ㄗㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zk9"), "ㄗㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zg"), "ㄗㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zg8"), "ㄗㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zg9"), "ㄗㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zu"), "ㄗㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zu7"), "ㄗㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zu8"), "ㄗㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zu9"), "ㄗㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zuo"), "ㄗㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zuo7"), "ㄗㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zuo8"), "ㄗㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zuo9"), "ㄗㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zuo0"), "ㄗㄨㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("zut"), "ㄗㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zut8"), "ㄗㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zut9"), "ㄗㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zum"), "ㄗㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zum8"), "ㄗㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zum9"), "ㄗㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zun"), "ㄗㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zun8"), "ㄗㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zun9"), "ㄗㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zug"), "ㄗㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zug8"), "ㄗㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("zug9"), "ㄗㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("c"), "ㄘ") - XCTAssertEqual(composer.convertSequenceToRawComposition("c7"), "ㄘˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("c8"), "ㄘˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("c9"), "ㄘˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ca"), "ㄘㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ca8"), "ㄘㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ca9"), "ㄘㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ce9"), "ㄘㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cy"), "ㄘㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cy7"), "ㄘㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cy8"), "ㄘㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cy9"), "ㄘㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cf"), "ㄘㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cf7"), "ㄘㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cf8"), "ㄘㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cf9"), "ㄘㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cw"), "ㄘㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cw7"), "ㄘㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cw8"), "ㄘㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cw9"), "ㄘㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cm"), "ㄘㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cm7"), "ㄘㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cm8"), "ㄘㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cm9"), "ㄘㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cn"), "ㄘㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cn7"), "ㄘㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ck"), "ㄘㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ck7"), "ㄘㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ck8"), "ㄘㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ck9"), "ㄘㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cg"), "ㄘㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cg7"), "ㄘㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cg8"), "ㄘㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cg9"), "ㄘㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cu"), "ㄘㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cu7"), "ㄘㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cu8"), "ㄘㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cu9"), "ㄘㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuo"), "ㄘㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuo7"), "ㄘㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuo8"), "ㄘㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cuo9"), "ㄘㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cut"), "ㄘㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cut8"), "ㄘㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cut9"), "ㄘㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cum"), "ㄘㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cum7"), "ㄘㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cum8"), "ㄘㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cum9"), "ㄘㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cun"), "ㄘㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cun7"), "ㄘㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cun8"), "ㄘㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cun9"), "ㄘㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cug"), "ㄘㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cug7"), "ㄘㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cug8"), "ㄘㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("cug9"), "ㄘㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("s"), "ㄙ") - XCTAssertEqual(composer.convertSequenceToRawComposition("s8"), "ㄙˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("s9"), "ㄙˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sa"), "ㄙㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sa8"), "ㄙㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sa9"), "ㄙㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sa0"), "ㄙㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("se"), "ㄙㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("se9"), "ㄙㄜˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sy"), "ㄙㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sy7"), "ㄙㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sy8"), "ㄙㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sy9"), "ㄙㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("st"), "ㄙㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sf"), "ㄙㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sf8"), "ㄙㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sf9"), "ㄙㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sw"), "ㄙㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sw8"), "ㄙㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sw9"), "ㄙㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sm"), "ㄙㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sm8"), "ㄙㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sm9"), "ㄙㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sn"), "ㄙㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sn8"), "ㄙㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sk"), "ㄙㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sk8"), "ㄙㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sk9"), "ㄙㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sg"), "ㄙㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sg9"), "ㄙㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("su"), "ㄙㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("su7"), "ㄙㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("su8"), "ㄙㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("su9"), "ㄙㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suo"), "ㄙㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suo7"), "ㄙㄨㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suo8"), "ㄙㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("suo9"), "ㄙㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sut"), "ㄙㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sut7"), "ㄙㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sut8"), "ㄙㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sut9"), "ㄙㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sum"), "ㄙㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sum8"), "ㄙㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sum9"), "ㄙㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sun"), "ㄙㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sun8"), "ㄙㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sun9"), "ㄙㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sug"), "ㄙㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sug7"), "ㄙㄨㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sug8"), "ㄙㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("sug9"), "ㄙㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("a"), "ㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("a7"), "ㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("a9"), "ㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("a0"), "ㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("o"), "ㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("o7"), "ㄛˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("o8"), "ㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("o9"), "ㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("e"), "ㄜ") - XCTAssertEqual(composer.convertSequenceToRawComposition("e7"), "ㄜˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("e8"), "ㄜˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("e9"), "ㄜˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("e7"), "ㄝˊ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("e8"), "ㄝˇ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("e9"), "ㄝˋ") - // XCTAssertEqual(composer.convertSequenceToRawComposition("e0"), "ㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("y"), "ㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("y7"), "ㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("y8"), "ㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("y9"), "ㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("t9"), "ㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("f "), "ㄠ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("f7"), "ㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("f8"), "ㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("f9"), "ㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("w"), "ㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("w7"), "ㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("w8"), "ㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("w9"), "ㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("w0"), "ㄡ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("m "), "ㄢ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("m7"), "ㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("m8"), "ㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("m9"), "ㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("n "), "ㄣ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("n7"), "ㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("n8"), "ㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("n9"), "ㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("n0"), "ㄣ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("k "), "ㄤ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("k7"), "ㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("k8"), "ㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("k9"), "ㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("g "), "ㄥ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("g9"), "ㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("l "), "ㄦ ") - XCTAssertEqual(composer.convertSequenceToRawComposition("l7"), "ㄦˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("l8"), "ㄦˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("l9"), "ㄦˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("l0"), "ㄦ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("i"), "ㄧ") - XCTAssertEqual(composer.convertSequenceToRawComposition("i7"), "ㄧˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("i8"), "ㄧˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("i9"), "ㄧˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ia"), "ㄧㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ia7"), "ㄧㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ia8"), "ㄧㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ia9"), "ㄧㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ia0"), "ㄧㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("io"), "ㄧㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("io0"), "ㄧㄛ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("ie"), "ㄧㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ie7"), "ㄧㄝˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ie8"), "ㄧㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ie9"), "ㄧㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ie0"), "ㄧㄝ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("iy7"), "ㄧㄞˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("if"), "ㄧㄠ") - XCTAssertEqual(composer.convertSequenceToRawComposition("if7"), "ㄧㄠˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("if8"), "ㄧㄠˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("if9"), "ㄧㄠˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("iw"), "ㄧㄡ") - XCTAssertEqual(composer.convertSequenceToRawComposition("iw7"), "ㄧㄡˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("iw8"), "ㄧㄡˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("iw9"), "ㄧㄡˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("im"), "ㄧㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("im7"), "ㄧㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("im8"), "ㄧㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("im9"), "ㄧㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("in"), "ㄧㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("in7"), "ㄧㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("in8"), "ㄧㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("in9"), "ㄧㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ik"), "ㄧㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ik7"), "ㄧㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ik8"), "ㄧㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ik9"), "ㄧㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ig"), "ㄧㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ig7"), "ㄧㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ig8"), "ㄧㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ig9"), "ㄧㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("u"), "ㄨ") - XCTAssertEqual(composer.convertSequenceToRawComposition("u7"), "ㄨˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("u8"), "ㄨˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("u9"), "ㄨˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ua"), "ㄨㄚ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ua7"), "ㄨㄚˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ua8"), "ㄨㄚˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ua9"), "ㄨㄚˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ua0"), "ㄨㄚ˙") - XCTAssertEqual(composer.convertSequenceToRawComposition("uo"), "ㄨㄛ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uo8"), "ㄨㄛˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uo9"), "ㄨㄛˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uy"), "ㄨㄞ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uy8"), "ㄨㄞˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uy9"), "ㄨㄞˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ut"), "ㄨㄟ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ut7"), "ㄨㄟˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ut8"), "ㄨㄟˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ut9"), "ㄨㄟˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("um"), "ㄨㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("um7"), "ㄨㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("um8"), "ㄨㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("um9"), "ㄨㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("un"), "ㄨㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("un7"), "ㄨㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("un8"), "ㄨㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("un9"), "ㄨㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uk"), "ㄨㄤ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uk7"), "ㄨㄤˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uk8"), "ㄨㄤˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("uk9"), "ㄨㄤˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ug"), "ㄨㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ug8"), "ㄨㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ug9"), "ㄨㄥˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("v"), "ㄩ") - XCTAssertEqual(composer.convertSequenceToRawComposition("v7"), "ㄩˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("v8"), "ㄩˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("v9"), "ㄩˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ve"), "ㄩㄝ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ve8"), "ㄩㄝˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("ve9"), "ㄩㄝˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vm"), "ㄩㄢ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vm7"), "ㄩㄢˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vm8"), "ㄩㄢˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vm9"), "ㄩㄢˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vn"), "ㄩㄣ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vn7"), "ㄩㄣˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vn8"), "ㄩㄣˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vn9"), "ㄩㄣˋ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vg"), "ㄩㄥ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vg7"), "ㄩㄥˊ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vg8"), "ㄩㄥˇ") - XCTAssertEqual(composer.convertSequenceToRawComposition("vg9"), "ㄩㄥˋ") + var c = Tekkon.Composer(arrange: .ofStarlight) + XCTAssertEqual(c.cS2RC("juy"), "ㄓㄨㄞ") + XCTAssertEqual(c.cS2RC("juy8"), "ㄓㄨㄞˇ") + XCTAssertEqual(c.cS2RC("juy9"), "ㄓㄨㄞˋ") + XCTAssertEqual(c.cS2RC("jut"), "ㄓㄨㄟ") + XCTAssertEqual(c.cS2RC("jut8"), "ㄓㄨㄟˇ") + XCTAssertEqual(c.cS2RC("jut9"), "ㄓㄨㄟˋ") + XCTAssertEqual(c.cS2RC("jum"), "ㄓㄨㄢ") + XCTAssertEqual(c.cS2RC("jum8"), "ㄓㄨㄢˇ") + XCTAssertEqual(c.cS2RC("jum9"), "ㄓㄨㄢˋ") + XCTAssertEqual(c.cS2RC("jun"), "ㄓㄨㄣ") + XCTAssertEqual(c.cS2RC("jun8"), "ㄓㄨㄣˇ") + XCTAssertEqual(c.cS2RC("jun9"), "ㄓㄨㄣˋ") + XCTAssertEqual(c.cS2RC("juk"), "ㄓㄨㄤ") + XCTAssertEqual(c.cS2RC("juk8"), "ㄓㄨㄤˇ") + XCTAssertEqual(c.cS2RC("juk9"), "ㄓㄨㄤˋ") + XCTAssertEqual(c.cS2RC("jug"), "ㄓㄨㄥ") + XCTAssertEqual(c.cS2RC("jug8"), "ㄓㄨㄥˇ") + XCTAssertEqual(c.cS2RC("jug9"), "ㄓㄨㄥˋ") + XCTAssertEqual(c.cS2RC("q"), "ㄔ") + XCTAssertEqual(c.cS2RC("q7"), "ㄔˊ") + XCTAssertEqual(c.cS2RC("q8"), "ㄔˇ") + XCTAssertEqual(c.cS2RC("q9"), "ㄔˋ") + XCTAssertEqual(c.cS2RC("qa"), "ㄔㄚ") + XCTAssertEqual(c.cS2RC("qa7"), "ㄔㄚˊ") + XCTAssertEqual(c.cS2RC("qa8"), "ㄔㄚˇ") + XCTAssertEqual(c.cS2RC("qa9"), "ㄔㄚˋ") + XCTAssertEqual(c.cS2RC("qe"), "ㄔㄜ") + XCTAssertEqual(c.cS2RC("qe8"), "ㄔㄜˇ") + XCTAssertEqual(c.cS2RC("qe9"), "ㄔㄜˋ") + XCTAssertEqual(c.cS2RC("qy"), "ㄔㄞ") + XCTAssertEqual(c.cS2RC("qy7"), "ㄔㄞˊ") + XCTAssertEqual(c.cS2RC("qy8"), "ㄔㄞˇ") + XCTAssertEqual(c.cS2RC("qy9"), "ㄔㄞˋ") + XCTAssertEqual(c.cS2RC("qf"), "ㄔㄠ") + XCTAssertEqual(c.cS2RC("qf7"), "ㄔㄠˊ") + XCTAssertEqual(c.cS2RC("qf8"), "ㄔㄠˇ") + XCTAssertEqual(c.cS2RC("qf9"), "ㄔㄠˋ") + XCTAssertEqual(c.cS2RC("qw"), "ㄔㄡ") + XCTAssertEqual(c.cS2RC("qw7"), "ㄔㄡˊ") + XCTAssertEqual(c.cS2RC("qw8"), "ㄔㄡˇ") + XCTAssertEqual(c.cS2RC("qw9"), "ㄔㄡˋ") + XCTAssertEqual(c.cS2RC("qm"), "ㄔㄢ") + XCTAssertEqual(c.cS2RC("qm7"), "ㄔㄢˊ") + XCTAssertEqual(c.cS2RC("qm8"), "ㄔㄢˇ") + XCTAssertEqual(c.cS2RC("qm9"), "ㄔㄢˋ") + XCTAssertEqual(c.cS2RC("qn"), "ㄔㄣ") + XCTAssertEqual(c.cS2RC("qn7"), "ㄔㄣˊ") + XCTAssertEqual(c.cS2RC("qn8"), "ㄔㄣˇ") + XCTAssertEqual(c.cS2RC("qn9"), "ㄔㄣˋ") + XCTAssertEqual(c.cS2RC("qn0"), "ㄔㄣ˙") + XCTAssertEqual(c.cS2RC("qk"), "ㄔㄤ") + XCTAssertEqual(c.cS2RC("qk7"), "ㄔㄤˊ") + XCTAssertEqual(c.cS2RC("qk8"), "ㄔㄤˇ") + XCTAssertEqual(c.cS2RC("qk9"), "ㄔㄤˋ") + XCTAssertEqual(c.cS2RC("qg"), "ㄔㄥ") + XCTAssertEqual(c.cS2RC("qg7"), "ㄔㄥˊ") + XCTAssertEqual(c.cS2RC("qg8"), "ㄔㄥˇ") + XCTAssertEqual(c.cS2RC("qg9"), "ㄔㄥˋ") + XCTAssertEqual(c.cS2RC("qu"), "ㄔㄨ") + XCTAssertEqual(c.cS2RC("qu7"), "ㄔㄨˊ") + XCTAssertEqual(c.cS2RC("qu8"), "ㄔㄨˇ") + XCTAssertEqual(c.cS2RC("qu9"), "ㄔㄨˋ") + XCTAssertEqual(c.cS2RC("qua"), "ㄔㄨㄚ") + XCTAssertEqual(c.cS2RC("qua8"), "ㄔㄨㄚˇ") + XCTAssertEqual(c.cS2RC("qua9"), "ㄔㄨㄚˋ") + XCTAssertEqual(c.cS2RC("quo"), "ㄔㄨㄛ") + XCTAssertEqual(c.cS2RC("quo9"), "ㄔㄨㄛˋ") + XCTAssertEqual(c.cS2RC("quy"), "ㄔㄨㄞ") + XCTAssertEqual(c.cS2RC("quy7"), "ㄔㄨㄞˊ") + XCTAssertEqual(c.cS2RC("quy8"), "ㄔㄨㄞˇ") + XCTAssertEqual(c.cS2RC("quy9"), "ㄔㄨㄞˋ") + XCTAssertEqual(c.cS2RC("qut"), "ㄔㄨㄟ") + XCTAssertEqual(c.cS2RC("qut7"), "ㄔㄨㄟˊ") + XCTAssertEqual(c.cS2RC("qut8"), "ㄔㄨㄟˇ") + XCTAssertEqual(c.cS2RC("qut9"), "ㄔㄨㄟˋ") + XCTAssertEqual(c.cS2RC("qum"), "ㄔㄨㄢ") + XCTAssertEqual(c.cS2RC("qum7"), "ㄔㄨㄢˊ") + XCTAssertEqual(c.cS2RC("qum8"), "ㄔㄨㄢˇ") + XCTAssertEqual(c.cS2RC("qum9"), "ㄔㄨㄢˋ") + XCTAssertEqual(c.cS2RC("qun"), "ㄔㄨㄣ") + XCTAssertEqual(c.cS2RC("qun7"), "ㄔㄨㄣˊ") + XCTAssertEqual(c.cS2RC("qun8"), "ㄔㄨㄣˇ") + XCTAssertEqual(c.cS2RC("quk"), "ㄔㄨㄤ") + XCTAssertEqual(c.cS2RC("quk7"), "ㄔㄨㄤˊ") + XCTAssertEqual(c.cS2RC("quk8"), "ㄔㄨㄤˇ") + XCTAssertEqual(c.cS2RC("quk9"), "ㄔㄨㄤˋ") + XCTAssertEqual(c.cS2RC("qug"), "ㄔㄨㄥ") + XCTAssertEqual(c.cS2RC("qug7"), "ㄔㄨㄥˊ") + XCTAssertEqual(c.cS2RC("qug8"), "ㄔㄨㄥˇ") + XCTAssertEqual(c.cS2RC("qug9"), "ㄔㄨㄥˋ") + XCTAssertEqual(c.cS2RC("x"), "ㄕ") + XCTAssertEqual(c.cS2RC("x7"), "ㄕˊ") + XCTAssertEqual(c.cS2RC("x8"), "ㄕˇ") + XCTAssertEqual(c.cS2RC("x9"), "ㄕˋ") + XCTAssertEqual(c.cS2RC("x0"), "ㄕ˙") + XCTAssertEqual(c.cS2RC("xa"), "ㄕㄚ") + XCTAssertEqual(c.cS2RC("xa7"), "ㄕㄚˊ") + XCTAssertEqual(c.cS2RC("xa8"), "ㄕㄚˇ") + XCTAssertEqual(c.cS2RC("xa9"), "ㄕㄚˋ") + XCTAssertEqual(c.cS2RC("xa0"), "ㄕㄚ˙") + XCTAssertEqual(c.cS2RC("xe"), "ㄕㄜ") + XCTAssertEqual(c.cS2RC("xe7"), "ㄕㄜˊ") + XCTAssertEqual(c.cS2RC("xe8"), "ㄕㄜˇ") + XCTAssertEqual(c.cS2RC("xe9"), "ㄕㄜˋ") + XCTAssertEqual(c.cS2RC("xy"), "ㄕㄞ") + XCTAssertEqual(c.cS2RC("xy8"), "ㄕㄞˇ") + XCTAssertEqual(c.cS2RC("xy9"), "ㄕㄞˋ") + XCTAssertEqual(c.cS2RC("xt7"), "ㄕㄟˊ") + XCTAssertEqual(c.cS2RC("xf"), "ㄕㄠ") + XCTAssertEqual(c.cS2RC("xf7"), "ㄕㄠˊ") + XCTAssertEqual(c.cS2RC("xf8"), "ㄕㄠˇ") + XCTAssertEqual(c.cS2RC("xf9"), "ㄕㄠˋ") + XCTAssertEqual(c.cS2RC("xw"), "ㄕㄡ") + XCTAssertEqual(c.cS2RC("xw7"), "ㄕㄡˊ") + XCTAssertEqual(c.cS2RC("xw8"), "ㄕㄡˇ") + XCTAssertEqual(c.cS2RC("xw9"), "ㄕㄡˋ") + XCTAssertEqual(c.cS2RC("xm"), "ㄕㄢ") + XCTAssertEqual(c.cS2RC("xm7"), "ㄕㄢˊ") + XCTAssertEqual(c.cS2RC("xm8"), "ㄕㄢˇ") + XCTAssertEqual(c.cS2RC("xm9"), "ㄕㄢˋ") + XCTAssertEqual(c.cS2RC("xn"), "ㄕㄣ") + XCTAssertEqual(c.cS2RC("xn7"), "ㄕㄣˊ") + XCTAssertEqual(c.cS2RC("xn8"), "ㄕㄣˇ") + XCTAssertEqual(c.cS2RC("xn9"), "ㄕㄣˋ") + XCTAssertEqual(c.cS2RC("xk"), "ㄕㄤ") + XCTAssertEqual(c.cS2RC("xk8"), "ㄕㄤˇ") + XCTAssertEqual(c.cS2RC("xk9"), "ㄕㄤˋ") + XCTAssertEqual(c.cS2RC("xk0"), "ㄕㄤ˙") + XCTAssertEqual(c.cS2RC("xg"), "ㄕㄥ") + XCTAssertEqual(c.cS2RC("xg7"), "ㄕㄥˊ") + XCTAssertEqual(c.cS2RC("xg8"), "ㄕㄥˇ") + XCTAssertEqual(c.cS2RC("xg9"), "ㄕㄥˋ") + XCTAssertEqual(c.cS2RC("xu"), "ㄕㄨ") + XCTAssertEqual(c.cS2RC("xu7"), "ㄕㄨˊ") + XCTAssertEqual(c.cS2RC("xu8"), "ㄕㄨˇ") + XCTAssertEqual(c.cS2RC("xu9"), "ㄕㄨˋ") + XCTAssertEqual(c.cS2RC("xua"), "ㄕㄨㄚ") + XCTAssertEqual(c.cS2RC("xua8"), "ㄕㄨㄚˇ") + XCTAssertEqual(c.cS2RC("xua9"), "ㄕㄨㄚˋ") + XCTAssertEqual(c.cS2RC("xuo"), "ㄕㄨㄛ") + XCTAssertEqual(c.cS2RC("xuo9"), "ㄕㄨㄛˋ") + XCTAssertEqual(c.cS2RC("xuy"), "ㄕㄨㄞ") + XCTAssertEqual(c.cS2RC("xuy8"), "ㄕㄨㄞˇ") + XCTAssertEqual(c.cS2RC("xuy9"), "ㄕㄨㄞˋ") + XCTAssertEqual(c.cS2RC("xut"), "ㄕㄨㄟ") + XCTAssertEqual(c.cS2RC("xut7"), "ㄕㄨㄟˊ") + XCTAssertEqual(c.cS2RC("xut8"), "ㄕㄨㄟˇ") + XCTAssertEqual(c.cS2RC("xut9"), "ㄕㄨㄟˋ") + XCTAssertEqual(c.cS2RC("xum"), "ㄕㄨㄢ") + XCTAssertEqual(c.cS2RC("xum9"), "ㄕㄨㄢˋ") + XCTAssertEqual(c.cS2RC("xun8"), "ㄕㄨㄣˇ") + XCTAssertEqual(c.cS2RC("xun9"), "ㄕㄨㄣˋ") + XCTAssertEqual(c.cS2RC("xuk"), "ㄕㄨㄤ") + XCTAssertEqual(c.cS2RC("xuk7"), "ㄕㄨㄤˊ") + XCTAssertEqual(c.cS2RC("xuk8"), "ㄕㄨㄤˇ") + XCTAssertEqual(c.cS2RC("xuk9"), "ㄕㄨㄤˋ") + XCTAssertEqual(c.cS2RC("r9"), "ㄖˋ") + XCTAssertEqual(c.cS2RC("re8"), "ㄖㄜˇ") + XCTAssertEqual(c.cS2RC("re9"), "ㄖㄜˋ") + XCTAssertEqual(c.cS2RC("rf7"), "ㄖㄠˊ") + XCTAssertEqual(c.cS2RC("rf8"), "ㄖㄠˇ") + XCTAssertEqual(c.cS2RC("rf9"), "ㄖㄠˋ") + XCTAssertEqual(c.cS2RC("rw7"), "ㄖㄡˊ") + XCTAssertEqual(c.cS2RC("rw8"), "ㄖㄡˇ") + XCTAssertEqual(c.cS2RC("rw9"), "ㄖㄡˋ") + XCTAssertEqual(c.cS2RC("rm7"), "ㄖㄢˊ") + XCTAssertEqual(c.cS2RC("rm8"), "ㄖㄢˇ") + XCTAssertEqual(c.cS2RC("rm9"), "ㄖㄢˋ") + XCTAssertEqual(c.cS2RC("rn7"), "ㄖㄣˊ") + XCTAssertEqual(c.cS2RC("rn8"), "ㄖㄣˇ") + XCTAssertEqual(c.cS2RC("rn9"), "ㄖㄣˋ") + XCTAssertEqual(c.cS2RC("rk"), "ㄖㄤ") + XCTAssertEqual(c.cS2RC("rk7"), "ㄖㄤˊ") + XCTAssertEqual(c.cS2RC("rk8"), "ㄖㄤˇ") + XCTAssertEqual(c.cS2RC("rk9"), "ㄖㄤˋ") + XCTAssertEqual(c.cS2RC("rg"), "ㄖㄥ") + XCTAssertEqual(c.cS2RC("rg7"), "ㄖㄥˊ") + XCTAssertEqual(c.cS2RC("rg8"), "ㄖㄥˇ") + XCTAssertEqual(c.cS2RC("rg9"), "ㄖㄥˋ") + XCTAssertEqual(c.cS2RC("ru7"), "ㄖㄨˊ") + XCTAssertEqual(c.cS2RC("ru8"), "ㄖㄨˇ") + XCTAssertEqual(c.cS2RC("ru9"), "ㄖㄨˋ") + XCTAssertEqual(c.cS2RC("ruo7"), "ㄖㄨㄛˊ") + XCTAssertEqual(c.cS2RC("ruo9"), "ㄖㄨㄛˋ") + XCTAssertEqual(c.cS2RC("rut7"), "ㄖㄨㄟˊ") + XCTAssertEqual(c.cS2RC("rut8"), "ㄖㄨㄟˇ") + XCTAssertEqual(c.cS2RC("rut9"), "ㄖㄨㄟˋ") + XCTAssertEqual(c.cS2RC("rum7"), "ㄖㄨㄢˊ") + XCTAssertEqual(c.cS2RC("rum8"), "ㄖㄨㄢˇ") + XCTAssertEqual(c.cS2RC("rum9"), "ㄖㄨㄢˋ") + XCTAssertEqual(c.cS2RC("run7"), "ㄖㄨㄣˊ") + XCTAssertEqual(c.cS2RC("run8"), "ㄖㄨㄣˇ") + XCTAssertEqual(c.cS2RC("run9"), "ㄖㄨㄣˋ") + XCTAssertEqual(c.cS2RC("rug7"), "ㄖㄨㄥˊ") + XCTAssertEqual(c.cS2RC("rug8"), "ㄖㄨㄥˇ") + XCTAssertEqual(c.cS2RC("rug9"), "ㄖㄨㄥˋ") + XCTAssertEqual(c.cS2RC("z"), "ㄗ") + XCTAssertEqual(c.cS2RC("z7"), "ㄗˊ") + XCTAssertEqual(c.cS2RC("z8"), "ㄗˇ") + XCTAssertEqual(c.cS2RC("z9"), "ㄗˋ") + XCTAssertEqual(c.cS2RC("z0"), "ㄗ˙") + XCTAssertEqual(c.cS2RC("za"), "ㄗㄚ") + XCTAssertEqual(c.cS2RC("za7"), "ㄗㄚˊ") + XCTAssertEqual(c.cS2RC("za8"), "ㄗㄚˇ") + XCTAssertEqual(c.cS2RC("ze7"), "ㄗㄜˊ") + XCTAssertEqual(c.cS2RC("ze8"), "ㄗㄜˇ") + XCTAssertEqual(c.cS2RC("ze9"), "ㄗㄜˋ") + XCTAssertEqual(c.cS2RC("zy"), "ㄗㄞ") + XCTAssertEqual(c.cS2RC("zy8"), "ㄗㄞˇ") + XCTAssertEqual(c.cS2RC("zy9"), "ㄗㄞˋ") + XCTAssertEqual(c.cS2RC("zt7"), "ㄗㄟˊ") + XCTAssertEqual(c.cS2RC("zf"), "ㄗㄠ") + XCTAssertEqual(c.cS2RC("zf7"), "ㄗㄠˊ") + XCTAssertEqual(c.cS2RC("zf8"), "ㄗㄠˇ") + XCTAssertEqual(c.cS2RC("zf9"), "ㄗㄠˋ") + XCTAssertEqual(c.cS2RC("zw"), "ㄗㄡ") + XCTAssertEqual(c.cS2RC("zw8"), "ㄗㄡˇ") + XCTAssertEqual(c.cS2RC("zw9"), "ㄗㄡˋ") + XCTAssertEqual(c.cS2RC("zm"), "ㄗㄢ") + XCTAssertEqual(c.cS2RC("zm7"), "ㄗㄢˊ") + XCTAssertEqual(c.cS2RC("zm8"), "ㄗㄢˇ") + XCTAssertEqual(c.cS2RC("zm9"), "ㄗㄢˋ") + XCTAssertEqual(c.cS2RC("zn"), "ㄗㄣ") + XCTAssertEqual(c.cS2RC("zn8"), "ㄗㄣˇ") + XCTAssertEqual(c.cS2RC("zn9"), "ㄗㄣˋ") + XCTAssertEqual(c.cS2RC("zk"), "ㄗㄤ") + XCTAssertEqual(c.cS2RC("zk8"), "ㄗㄤˇ") + XCTAssertEqual(c.cS2RC("zk9"), "ㄗㄤˋ") + XCTAssertEqual(c.cS2RC("zg"), "ㄗㄥ") + XCTAssertEqual(c.cS2RC("zg8"), "ㄗㄥˇ") + XCTAssertEqual(c.cS2RC("zg9"), "ㄗㄥˋ") + XCTAssertEqual(c.cS2RC("zu"), "ㄗㄨ") + XCTAssertEqual(c.cS2RC("zu7"), "ㄗㄨˊ") + XCTAssertEqual(c.cS2RC("zu8"), "ㄗㄨˇ") + XCTAssertEqual(c.cS2RC("zu9"), "ㄗㄨˋ") + XCTAssertEqual(c.cS2RC("zuo"), "ㄗㄨㄛ") + XCTAssertEqual(c.cS2RC("zuo7"), "ㄗㄨㄛˊ") + XCTAssertEqual(c.cS2RC("zuo8"), "ㄗㄨㄛˇ") + XCTAssertEqual(c.cS2RC("zuo9"), "ㄗㄨㄛˋ") + XCTAssertEqual(c.cS2RC("zuo0"), "ㄗㄨㄛ˙") + XCTAssertEqual(c.cS2RC("zut"), "ㄗㄨㄟ") + XCTAssertEqual(c.cS2RC("zut8"), "ㄗㄨㄟˇ") + XCTAssertEqual(c.cS2RC("zut9"), "ㄗㄨㄟˋ") + XCTAssertEqual(c.cS2RC("zum"), "ㄗㄨㄢ") + XCTAssertEqual(c.cS2RC("zum8"), "ㄗㄨㄢˇ") + XCTAssertEqual(c.cS2RC("zum9"), "ㄗㄨㄢˋ") + XCTAssertEqual(c.cS2RC("zun"), "ㄗㄨㄣ") + XCTAssertEqual(c.cS2RC("zun8"), "ㄗㄨㄣˇ") + XCTAssertEqual(c.cS2RC("zun9"), "ㄗㄨㄣˋ") + XCTAssertEqual(c.cS2RC("zug"), "ㄗㄨㄥ") + XCTAssertEqual(c.cS2RC("zug8"), "ㄗㄨㄥˇ") + XCTAssertEqual(c.cS2RC("zug9"), "ㄗㄨㄥˋ") + XCTAssertEqual(c.cS2RC("c"), "ㄘ") + XCTAssertEqual(c.cS2RC("c7"), "ㄘˊ") + XCTAssertEqual(c.cS2RC("c8"), "ㄘˇ") + XCTAssertEqual(c.cS2RC("c9"), "ㄘˋ") + XCTAssertEqual(c.cS2RC("ca"), "ㄘㄚ") + XCTAssertEqual(c.cS2RC("ca8"), "ㄘㄚˇ") + XCTAssertEqual(c.cS2RC("ca9"), "ㄘㄚˋ") + XCTAssertEqual(c.cS2RC("ce9"), "ㄘㄜˋ") + XCTAssertEqual(c.cS2RC("cy"), "ㄘㄞ") + XCTAssertEqual(c.cS2RC("cy7"), "ㄘㄞˊ") + XCTAssertEqual(c.cS2RC("cy8"), "ㄘㄞˇ") + XCTAssertEqual(c.cS2RC("cy9"), "ㄘㄞˋ") + XCTAssertEqual(c.cS2RC("cf"), "ㄘㄠ") + XCTAssertEqual(c.cS2RC("cf7"), "ㄘㄠˊ") + XCTAssertEqual(c.cS2RC("cf8"), "ㄘㄠˇ") + XCTAssertEqual(c.cS2RC("cf9"), "ㄘㄠˋ") + XCTAssertEqual(c.cS2RC("cw"), "ㄘㄡ") + XCTAssertEqual(c.cS2RC("cw7"), "ㄘㄡˊ") + XCTAssertEqual(c.cS2RC("cw8"), "ㄘㄡˇ") + XCTAssertEqual(c.cS2RC("cw9"), "ㄘㄡˋ") + XCTAssertEqual(c.cS2RC("cm"), "ㄘㄢ") + XCTAssertEqual(c.cS2RC("cm7"), "ㄘㄢˊ") + XCTAssertEqual(c.cS2RC("cm8"), "ㄘㄢˇ") + XCTAssertEqual(c.cS2RC("cm9"), "ㄘㄢˋ") + XCTAssertEqual(c.cS2RC("cn"), "ㄘㄣ") + XCTAssertEqual(c.cS2RC("cn7"), "ㄘㄣˊ") + XCTAssertEqual(c.cS2RC("ck"), "ㄘㄤ") + XCTAssertEqual(c.cS2RC("ck7"), "ㄘㄤˊ") + XCTAssertEqual(c.cS2RC("ck8"), "ㄘㄤˇ") + XCTAssertEqual(c.cS2RC("ck9"), "ㄘㄤˋ") + XCTAssertEqual(c.cS2RC("cg"), "ㄘㄥ") + XCTAssertEqual(c.cS2RC("cg7"), "ㄘㄥˊ") + XCTAssertEqual(c.cS2RC("cg8"), "ㄘㄥˇ") + XCTAssertEqual(c.cS2RC("cg9"), "ㄘㄥˋ") + XCTAssertEqual(c.cS2RC("cu"), "ㄘㄨ") + XCTAssertEqual(c.cS2RC("cu7"), "ㄘㄨˊ") + XCTAssertEqual(c.cS2RC("cu8"), "ㄘㄨˇ") + XCTAssertEqual(c.cS2RC("cu9"), "ㄘㄨˋ") + XCTAssertEqual(c.cS2RC("cuo"), "ㄘㄨㄛ") + XCTAssertEqual(c.cS2RC("cuo7"), "ㄘㄨㄛˊ") + XCTAssertEqual(c.cS2RC("cuo8"), "ㄘㄨㄛˇ") + XCTAssertEqual(c.cS2RC("cuo9"), "ㄘㄨㄛˋ") + XCTAssertEqual(c.cS2RC("cut"), "ㄘㄨㄟ") + XCTAssertEqual(c.cS2RC("cut8"), "ㄘㄨㄟˇ") + XCTAssertEqual(c.cS2RC("cut9"), "ㄘㄨㄟˋ") + XCTAssertEqual(c.cS2RC("cum"), "ㄘㄨㄢ") + XCTAssertEqual(c.cS2RC("cum7"), "ㄘㄨㄢˊ") + XCTAssertEqual(c.cS2RC("cum8"), "ㄘㄨㄢˇ") + XCTAssertEqual(c.cS2RC("cum9"), "ㄘㄨㄢˋ") + XCTAssertEqual(c.cS2RC("cun"), "ㄘㄨㄣ") + XCTAssertEqual(c.cS2RC("cun7"), "ㄘㄨㄣˊ") + XCTAssertEqual(c.cS2RC("cun8"), "ㄘㄨㄣˇ") + XCTAssertEqual(c.cS2RC("cun9"), "ㄘㄨㄣˋ") + XCTAssertEqual(c.cS2RC("cug"), "ㄘㄨㄥ") + XCTAssertEqual(c.cS2RC("cug7"), "ㄘㄨㄥˊ") + XCTAssertEqual(c.cS2RC("cug8"), "ㄘㄨㄥˇ") + XCTAssertEqual(c.cS2RC("cug9"), "ㄘㄨㄥˋ") + XCTAssertEqual(c.cS2RC("s"), "ㄙ") + XCTAssertEqual(c.cS2RC("s8"), "ㄙˇ") + XCTAssertEqual(c.cS2RC("s9"), "ㄙˋ") + XCTAssertEqual(c.cS2RC("sa"), "ㄙㄚ") + XCTAssertEqual(c.cS2RC("sa8"), "ㄙㄚˇ") + XCTAssertEqual(c.cS2RC("sa9"), "ㄙㄚˋ") + XCTAssertEqual(c.cS2RC("sa0"), "ㄙㄚ˙") + XCTAssertEqual(c.cS2RC("se"), "ㄙㄜ") + XCTAssertEqual(c.cS2RC("se9"), "ㄙㄜˋ") + XCTAssertEqual(c.cS2RC("sy"), "ㄙㄞ") + XCTAssertEqual(c.cS2RC("sy7"), "ㄙㄞˊ") + XCTAssertEqual(c.cS2RC("sy8"), "ㄙㄞˇ") + XCTAssertEqual(c.cS2RC("sy9"), "ㄙㄞˋ") + XCTAssertEqual(c.cS2RC("st"), "ㄙㄟ") + XCTAssertEqual(c.cS2RC("sf"), "ㄙㄠ") + XCTAssertEqual(c.cS2RC("sf8"), "ㄙㄠˇ") + XCTAssertEqual(c.cS2RC("sf9"), "ㄙㄠˋ") + XCTAssertEqual(c.cS2RC("sw"), "ㄙㄡ") + XCTAssertEqual(c.cS2RC("sw8"), "ㄙㄡˇ") + XCTAssertEqual(c.cS2RC("sw9"), "ㄙㄡˋ") + XCTAssertEqual(c.cS2RC("sm"), "ㄙㄢ") + XCTAssertEqual(c.cS2RC("sm8"), "ㄙㄢˇ") + XCTAssertEqual(c.cS2RC("sm9"), "ㄙㄢˋ") + XCTAssertEqual(c.cS2RC("sn"), "ㄙㄣ") + XCTAssertEqual(c.cS2RC("sn8"), "ㄙㄣˇ") + XCTAssertEqual(c.cS2RC("sk"), "ㄙㄤ") + XCTAssertEqual(c.cS2RC("sk8"), "ㄙㄤˇ") + XCTAssertEqual(c.cS2RC("sk9"), "ㄙㄤˋ") + XCTAssertEqual(c.cS2RC("sg"), "ㄙㄥ") + XCTAssertEqual(c.cS2RC("sg9"), "ㄙㄥˋ") + XCTAssertEqual(c.cS2RC("su"), "ㄙㄨ") + XCTAssertEqual(c.cS2RC("su7"), "ㄙㄨˊ") + XCTAssertEqual(c.cS2RC("su8"), "ㄙㄨˇ") + XCTAssertEqual(c.cS2RC("su9"), "ㄙㄨˋ") + XCTAssertEqual(c.cS2RC("suo"), "ㄙㄨㄛ") + XCTAssertEqual(c.cS2RC("suo7"), "ㄙㄨㄛˊ") + XCTAssertEqual(c.cS2RC("suo8"), "ㄙㄨㄛˇ") + XCTAssertEqual(c.cS2RC("suo9"), "ㄙㄨㄛˋ") + XCTAssertEqual(c.cS2RC("sut"), "ㄙㄨㄟ") + XCTAssertEqual(c.cS2RC("sut7"), "ㄙㄨㄟˊ") + XCTAssertEqual(c.cS2RC("sut8"), "ㄙㄨㄟˇ") + XCTAssertEqual(c.cS2RC("sut9"), "ㄙㄨㄟˋ") + XCTAssertEqual(c.cS2RC("sum"), "ㄙㄨㄢ") + XCTAssertEqual(c.cS2RC("sum8"), "ㄙㄨㄢˇ") + XCTAssertEqual(c.cS2RC("sum9"), "ㄙㄨㄢˋ") + XCTAssertEqual(c.cS2RC("sun"), "ㄙㄨㄣ") + XCTAssertEqual(c.cS2RC("sun8"), "ㄙㄨㄣˇ") + XCTAssertEqual(c.cS2RC("sun9"), "ㄙㄨㄣˋ") + XCTAssertEqual(c.cS2RC("sug"), "ㄙㄨㄥ") + XCTAssertEqual(c.cS2RC("sug7"), "ㄙㄨㄥˊ") + XCTAssertEqual(c.cS2RC("sug8"), "ㄙㄨㄥˇ") + XCTAssertEqual(c.cS2RC("sug9"), "ㄙㄨㄥˋ") + XCTAssertEqual(c.cS2RC("a"), "ㄚ") + XCTAssertEqual(c.cS2RC("a7"), "ㄚˊ") + XCTAssertEqual(c.cS2RC("a9"), "ㄚˋ") + XCTAssertEqual(c.cS2RC("a0"), "ㄚ˙") + XCTAssertEqual(c.cS2RC("o"), "ㄛ") + XCTAssertEqual(c.cS2RC("o7"), "ㄛˊ") + XCTAssertEqual(c.cS2RC("o8"), "ㄛˇ") + XCTAssertEqual(c.cS2RC("o9"), "ㄛˋ") + XCTAssertEqual(c.cS2RC("e"), "ㄜ") + XCTAssertEqual(c.cS2RC("e7"), "ㄜˊ") + XCTAssertEqual(c.cS2RC("e8"), "ㄜˇ") + XCTAssertEqual(c.cS2RC("e9"), "ㄜˋ") + // XCTAssertEqual(c.cS2RC("e7"), "ㄝˊ") + // XCTAssertEqual(c.cS2RC("e8"), "ㄝˇ") + // XCTAssertEqual(c.cS2RC("e9"), "ㄝˋ") + // XCTAssertEqual(c.cS2RC("e0"), "ㄝ˙") + XCTAssertEqual(c.cS2RC("y"), "ㄞ") + XCTAssertEqual(c.cS2RC("y7"), "ㄞˊ") + XCTAssertEqual(c.cS2RC("y8"), "ㄞˇ") + XCTAssertEqual(c.cS2RC("y9"), "ㄞˋ") + XCTAssertEqual(c.cS2RC("t9"), "ㄟˋ") + XCTAssertEqual(c.cS2RC("f "), "ㄠ ") + XCTAssertEqual(c.cS2RC("f7"), "ㄠˊ") + XCTAssertEqual(c.cS2RC("f8"), "ㄠˇ") + XCTAssertEqual(c.cS2RC("f9"), "ㄠˋ") + XCTAssertEqual(c.cS2RC("w"), "ㄡ") + XCTAssertEqual(c.cS2RC("w7"), "ㄡˊ") + XCTAssertEqual(c.cS2RC("w8"), "ㄡˇ") + XCTAssertEqual(c.cS2RC("w9"), "ㄡˋ") + XCTAssertEqual(c.cS2RC("w0"), "ㄡ˙") + XCTAssertEqual(c.cS2RC("m "), "ㄢ ") + XCTAssertEqual(c.cS2RC("m7"), "ㄢˊ") + XCTAssertEqual(c.cS2RC("m8"), "ㄢˇ") + XCTAssertEqual(c.cS2RC("m9"), "ㄢˋ") + XCTAssertEqual(c.cS2RC("n "), "ㄣ ") + XCTAssertEqual(c.cS2RC("n7"), "ㄣˊ") + XCTAssertEqual(c.cS2RC("n8"), "ㄣˇ") + XCTAssertEqual(c.cS2RC("n9"), "ㄣˋ") + XCTAssertEqual(c.cS2RC("n0"), "ㄣ˙") + XCTAssertEqual(c.cS2RC("k "), "ㄤ ") + XCTAssertEqual(c.cS2RC("k7"), "ㄤˊ") + XCTAssertEqual(c.cS2RC("k8"), "ㄤˇ") + XCTAssertEqual(c.cS2RC("k9"), "ㄤˋ") + XCTAssertEqual(c.cS2RC("g "), "ㄥ ") + XCTAssertEqual(c.cS2RC("g9"), "ㄥˋ") + XCTAssertEqual(c.cS2RC("l "), "ㄦ ") + XCTAssertEqual(c.cS2RC("l7"), "ㄦˊ") + XCTAssertEqual(c.cS2RC("l8"), "ㄦˇ") + XCTAssertEqual(c.cS2RC("l9"), "ㄦˋ") + XCTAssertEqual(c.cS2RC("l0"), "ㄦ˙") + XCTAssertEqual(c.cS2RC("i"), "ㄧ") + XCTAssertEqual(c.cS2RC("i7"), "ㄧˊ") + XCTAssertEqual(c.cS2RC("i8"), "ㄧˇ") + XCTAssertEqual(c.cS2RC("i9"), "ㄧˋ") + XCTAssertEqual(c.cS2RC("ia"), "ㄧㄚ") + XCTAssertEqual(c.cS2RC("ia7"), "ㄧㄚˊ") + XCTAssertEqual(c.cS2RC("ia8"), "ㄧㄚˇ") + XCTAssertEqual(c.cS2RC("ia9"), "ㄧㄚˋ") + XCTAssertEqual(c.cS2RC("ia0"), "ㄧㄚ˙") + XCTAssertEqual(c.cS2RC("io"), "ㄧㄛ") + XCTAssertEqual(c.cS2RC("io0"), "ㄧㄛ˙") + XCTAssertEqual(c.cS2RC("ie"), "ㄧㄝ") + XCTAssertEqual(c.cS2RC("ie7"), "ㄧㄝˊ") + XCTAssertEqual(c.cS2RC("ie8"), "ㄧㄝˇ") + XCTAssertEqual(c.cS2RC("ie9"), "ㄧㄝˋ") + XCTAssertEqual(c.cS2RC("ie0"), "ㄧㄝ˙") + XCTAssertEqual(c.cS2RC("iy7"), "ㄧㄞˊ") + XCTAssertEqual(c.cS2RC("if"), "ㄧㄠ") + XCTAssertEqual(c.cS2RC("if7"), "ㄧㄠˊ") + XCTAssertEqual(c.cS2RC("if8"), "ㄧㄠˇ") + XCTAssertEqual(c.cS2RC("if9"), "ㄧㄠˋ") + XCTAssertEqual(c.cS2RC("iw"), "ㄧㄡ") + XCTAssertEqual(c.cS2RC("iw7"), "ㄧㄡˊ") + XCTAssertEqual(c.cS2RC("iw8"), "ㄧㄡˇ") + XCTAssertEqual(c.cS2RC("iw9"), "ㄧㄡˋ") + XCTAssertEqual(c.cS2RC("im"), "ㄧㄢ") + XCTAssertEqual(c.cS2RC("im7"), "ㄧㄢˊ") + XCTAssertEqual(c.cS2RC("im8"), "ㄧㄢˇ") + XCTAssertEqual(c.cS2RC("im9"), "ㄧㄢˋ") + XCTAssertEqual(c.cS2RC("in"), "ㄧㄣ") + XCTAssertEqual(c.cS2RC("in7"), "ㄧㄣˊ") + XCTAssertEqual(c.cS2RC("in8"), "ㄧㄣˇ") + XCTAssertEqual(c.cS2RC("in9"), "ㄧㄣˋ") + XCTAssertEqual(c.cS2RC("ik"), "ㄧㄤ") + XCTAssertEqual(c.cS2RC("ik7"), "ㄧㄤˊ") + XCTAssertEqual(c.cS2RC("ik8"), "ㄧㄤˇ") + XCTAssertEqual(c.cS2RC("ik9"), "ㄧㄤˋ") + XCTAssertEqual(c.cS2RC("ig"), "ㄧㄥ") + XCTAssertEqual(c.cS2RC("ig7"), "ㄧㄥˊ") + XCTAssertEqual(c.cS2RC("ig8"), "ㄧㄥˇ") + XCTAssertEqual(c.cS2RC("ig9"), "ㄧㄥˋ") + XCTAssertEqual(c.cS2RC("u"), "ㄨ") + XCTAssertEqual(c.cS2RC("u7"), "ㄨˊ") + XCTAssertEqual(c.cS2RC("u8"), "ㄨˇ") + XCTAssertEqual(c.cS2RC("u9"), "ㄨˋ") + XCTAssertEqual(c.cS2RC("ua"), "ㄨㄚ") + XCTAssertEqual(c.cS2RC("ua7"), "ㄨㄚˊ") + XCTAssertEqual(c.cS2RC("ua8"), "ㄨㄚˇ") + XCTAssertEqual(c.cS2RC("ua9"), "ㄨㄚˋ") + XCTAssertEqual(c.cS2RC("ua0"), "ㄨㄚ˙") + XCTAssertEqual(c.cS2RC("uo"), "ㄨㄛ") + XCTAssertEqual(c.cS2RC("uo8"), "ㄨㄛˇ") + XCTAssertEqual(c.cS2RC("uo9"), "ㄨㄛˋ") + XCTAssertEqual(c.cS2RC("uy"), "ㄨㄞ") + XCTAssertEqual(c.cS2RC("uy8"), "ㄨㄞˇ") + XCTAssertEqual(c.cS2RC("uy9"), "ㄨㄞˋ") + XCTAssertEqual(c.cS2RC("ut"), "ㄨㄟ") + XCTAssertEqual(c.cS2RC("ut7"), "ㄨㄟˊ") + XCTAssertEqual(c.cS2RC("ut8"), "ㄨㄟˇ") + XCTAssertEqual(c.cS2RC("ut9"), "ㄨㄟˋ") + XCTAssertEqual(c.cS2RC("um"), "ㄨㄢ") + XCTAssertEqual(c.cS2RC("um7"), "ㄨㄢˊ") + XCTAssertEqual(c.cS2RC("um8"), "ㄨㄢˇ") + XCTAssertEqual(c.cS2RC("um9"), "ㄨㄢˋ") + XCTAssertEqual(c.cS2RC("un"), "ㄨㄣ") + XCTAssertEqual(c.cS2RC("un7"), "ㄨㄣˊ") + XCTAssertEqual(c.cS2RC("un8"), "ㄨㄣˇ") + XCTAssertEqual(c.cS2RC("un9"), "ㄨㄣˋ") + XCTAssertEqual(c.cS2RC("uk"), "ㄨㄤ") + XCTAssertEqual(c.cS2RC("uk7"), "ㄨㄤˊ") + XCTAssertEqual(c.cS2RC("uk8"), "ㄨㄤˇ") + XCTAssertEqual(c.cS2RC("uk9"), "ㄨㄤˋ") + XCTAssertEqual(c.cS2RC("ug"), "ㄨㄥ") + XCTAssertEqual(c.cS2RC("ug8"), "ㄨㄥˇ") + XCTAssertEqual(c.cS2RC("ug9"), "ㄨㄥˋ") + XCTAssertEqual(c.cS2RC("v"), "ㄩ") + XCTAssertEqual(c.cS2RC("v7"), "ㄩˊ") + XCTAssertEqual(c.cS2RC("v8"), "ㄩˇ") + XCTAssertEqual(c.cS2RC("v9"), "ㄩˋ") + XCTAssertEqual(c.cS2RC("ve"), "ㄩㄝ") + XCTAssertEqual(c.cS2RC("ve8"), "ㄩㄝˇ") + XCTAssertEqual(c.cS2RC("ve9"), "ㄩㄝˋ") + XCTAssertEqual(c.cS2RC("vm"), "ㄩㄢ") + XCTAssertEqual(c.cS2RC("vm7"), "ㄩㄢˊ") + XCTAssertEqual(c.cS2RC("vm8"), "ㄩㄢˇ") + XCTAssertEqual(c.cS2RC("vm9"), "ㄩㄢˋ") + XCTAssertEqual(c.cS2RC("vn"), "ㄩㄣ") + XCTAssertEqual(c.cS2RC("vn7"), "ㄩㄣˊ") + XCTAssertEqual(c.cS2RC("vn8"), "ㄩㄣˇ") + XCTAssertEqual(c.cS2RC("vn9"), "ㄩㄣˋ") + XCTAssertEqual(c.cS2RC("vg"), "ㄩㄥ") + XCTAssertEqual(c.cS2RC("vg7"), "ㄩㄥˊ") + XCTAssertEqual(c.cS2RC("vg8"), "ㄩㄥˇ") + XCTAssertEqual(c.cS2RC("vg9"), "ㄩㄥˋ") } }