From 72cb3456e25806fb85c3db2c56a2f48962aee0d7 Mon Sep 17 00:00:00 2001 From: ShikiSuen Date: Wed, 5 Oct 2022 14:05:08 +0800 Subject: [PATCH] Repo // Split files to boost build speed. --- Package.swift | 4 +- README.md | 28 +- ...eComposer.swift => Tekkon_Constants.swift} | 925 +-- Sources/Tekkon/Tekkon_Phonabets.swift | 158 + Sources/Tekkon/Tekkon_SyllableComposer.swift | 688 ++ Sources/Tekkon/Tekkon_Utilities.swift | 99 + Tests/TekkonTests/BasicTests.swift | 417 ++ .../KeyTest_Basic_DachenTrad.swift | 32 + Tests/TekkonTests/KeyTest_Dachen26_A.swift | 502 ++ Tests/TekkonTests/KeyTest_Dachen26_B.swift | 502 ++ Tests/TekkonTests/KeyTest_Dachen26_C.swift | 520 ++ Tests/TekkonTests/KeyTest_Eten26_A.swift | 502 ++ Tests/TekkonTests/KeyTest_Eten26_B.swift | 501 ++ Tests/TekkonTests/KeyTest_Eten26_C.swift | 521 ++ Tests/TekkonTests/KeyTest_Hsu_A.swift | 500 ++ Tests/TekkonTests/KeyTest_Hsu_B.swift | 500 ++ Tests/TekkonTests/KeyTest_Hsu_C.swift | 524 ++ Tests/TekkonTests/KeyTest_Starlight_A.swift | 501 ++ Tests/TekkonTests/KeyTest_Starlight_B.swift | 501 ++ Tests/TekkonTests/KeyTest_Starlight_C.swift | 522 ++ Tests/TekkonTests/TekkonTests.swift | 6346 ----------------- 21 files changed, 7515 insertions(+), 7278 deletions(-) rename Sources/Tekkon/{TekkonSyllableComposer.swift => Tekkon_Constants.swift} (62%) create mode 100644 Sources/Tekkon/Tekkon_Phonabets.swift create mode 100644 Sources/Tekkon/Tekkon_SyllableComposer.swift create mode 100644 Sources/Tekkon/Tekkon_Utilities.swift create mode 100644 Tests/TekkonTests/BasicTests.swift create mode 100644 Tests/TekkonTests/KeyTest_Basic_DachenTrad.swift create mode 100644 Tests/TekkonTests/KeyTest_Dachen26_A.swift create mode 100644 Tests/TekkonTests/KeyTest_Dachen26_B.swift create mode 100644 Tests/TekkonTests/KeyTest_Dachen26_C.swift create mode 100644 Tests/TekkonTests/KeyTest_Eten26_A.swift create mode 100644 Tests/TekkonTests/KeyTest_Eten26_B.swift create mode 100644 Tests/TekkonTests/KeyTest_Eten26_C.swift create mode 100644 Tests/TekkonTests/KeyTest_Hsu_A.swift create mode 100644 Tests/TekkonTests/KeyTest_Hsu_B.swift create mode 100644 Tests/TekkonTests/KeyTest_Hsu_C.swift create mode 100644 Tests/TekkonTests/KeyTest_Starlight_A.swift create mode 100644 Tests/TekkonTests/KeyTest_Starlight_B.swift create mode 100644 Tests/TekkonTests/KeyTest_Starlight_C.swift delete mode 100644 Tests/TekkonTests/TekkonTests.swift diff --git a/Package.swift b/Package.swift index 82cd248..1965234 100644 --- a/Package.swift +++ b/Package.swift @@ -1,9 +1,11 @@ // swift-tools-version:5.3 - import PackageDescription let package = Package( name: "Tekkon", + platforms: [ + .macOS(.v10_11) + ], products: [ .library( name: "Tekkon", diff --git a/README.md b/README.md index 4fc914d..30c0509 100644 --- a/README.md +++ b/README.md @@ -23,7 +23,7 @@ Regarding pinyin input support, we only support: Hanyu Pinyin, Secondary Pinyin, ### §1. 初期化 -在你的 ctlInputMethod (InputMethodController) 或者 KeyHandler 內初期化一份 Tekkon.Composer 注拼槽副本（這裡將該副本命名為「`_composer`」）。由於 Tekkon.Composer 的型別是 Struct 型別，所以其副本必須為變數（var），否則無法自我 mutate。 +在你的 IMKInputController (InputMethodController) 或者 KeyHandler 內初期化一份 Tekkon.Composer 注拼槽副本（這裡將該副本命名為「`_composer`」）。由於 Tekkon.Composer 的型別是 Struct 型別，所以其副本必須為變數（var），否則無法自我 mutate。 以 KeyHandler 為例： ```swift @@ -34,10 +34,10 @@ class KeyHandler: NSObject { } ``` -以 ctlInputMethod 為例： +以 IMKInputController 為例： ```swift -@objc(ctlInputMethod) // 根據 info.plist 內的情況來確定型別的命名 -class ctlInputMethod: IMKInputController { +@objc(IMKMyInputController) // 根據 info.plist 內的情況來確定型別的命名 +class IMKMyInputController: IMKInputController { // 先設定好變數 var _composer: Tekkon.Composer = .init() ... @@ -45,17 +45,17 @@ class ctlInputMethod: IMKInputController { ``` -由於 Swift 會在某個大副本（KeyHandler 或者 ctlInputMethod 副本）被銷毀的時候自動銷毀其中的全部副本，所以 Tekkon.Composer 的副本初期化沒必要寫在 init() 當中。但你很可能會想在 init() 時指定 Tekkon.Composer 所使用的注音排列（是大千？還是倚天傳統？還是神通？等）。 +由於 Swift 會在某個大副本（KeyHandler 或者 IMKInputController 副本）被銷毀的時候自動銷毀其中的全部副本，所以 Tekkon.Composer 的副本初期化沒必要寫在 init() 當中。但你很可能會想在 init() 時指定 Tekkon.Composer 所使用的注音排列（是大千？還是倚天傳統？還是神通？等）。 這裡就需要在 _composer 這個副本所在的型別當中額外寫一個過程函式。 -下文範例 `ensureParser()` 是這樣：假設 mgrPrefs 用來管理 UserDefaults 資料，那麼就從裡面取資料來判定 _composer 的注音排列分析器究竟該選哪個。 +下文範例 `ensureParser()` 是這樣：假設 PrefMgr 用來管理 UserDefaults 資料，那麼就從裡面取資料來判定 _composer 的注音排列分析器究竟該選哪個。 ```swift // MARK: - Extracted methods and functions (Tekkon). func ensureParser() { - switch mgrPrefs.mandarinParser { + switch PrefMgr.shared.mandarinParser { case MandarinParser.ofStandard.rawValue: _composer.ensureParser(arrange: .ofDachen) // 大千 case MandarinParser.ofETen.rawValue: @@ -81,8 +81,8 @@ class ctlInputMethod: IMKInputController { case MandarinParser.ofUniversalPinyin.rawValue: _composer.ensureParser(arrange: .ofUniversalPinyin) // 通用拼音 default: - _composer.ensureParser(arrange: .ofDachen) // 預設情況下按照 mgrPrefs 內定義預設值來處理 - mgrPrefs.mandarinParser = MandarinParser.ofStandard.rawValue + _composer.ensureParser(arrange: .ofDachen) // 預設情況下按照 PrefMgr 內定義預設值來處理 + PrefMgr.shared.mandarinParser = MandarinParser.ofStandard.rawValue } _composer.clear() } @@ -159,9 +159,9 @@ final class TekkonTests: XCTestCase { #### // 2. 訊號處理 -無論是 KeyHandler 還是 ctlInputMethod 都得要處理被傳入的 NSEvent 當中的 charCode 訊號。 +無論是 KeyHandler 還是 IMKInputController 都得要處理被傳入的 NSEvent 當中的 charCode 訊號。 -比如 ctlInputMethod 內： +比如 IMKInputController 內： ```swift func handleInputText(_ inputText: String?, key keyCode: Int, modifiers flags: Int, client: Any?) -> Bool { ... @@ -175,7 +175,7 @@ extension KeyHandler { input: InputHandler, state: InputState, stateCallback: @escaping (InputState) -> Void, - errorCallback: @escaping () -> Void + errorCallback: @escaping (String) -> Void ) -> Bool { let charCode: UniChar = input.charCode ... @@ -244,8 +244,8 @@ if composeReading { // 符合按鍵組合條件 // See whether we have a unigram for this... // 向語言模型詢問是否有對應的記錄 if !ifLangModelHasUnigrams(forKey: reading) { // 如果沒有的話 - IME.prtDebugIntel("B49C0979：語彙庫內無「\(reading)」的匹配記錄。") - errorCallback() // 向狀態管理引擎回呼一個錯誤狀態 + vCLog("B49C0979：語彙庫內無「\(reading)」的匹配記錄。") + errorCallback("114514") // 向狀態管理引擎回呼一個錯誤狀態 _composer.clear() // 清空注拼槽的內容 // 根據「天權星引擎 (威注音) 或 Gramambular (小麥) 的組字器是否為空」來判定回呼哪一種狀態 stateCallback( diff --git a/Sources/Tekkon/TekkonSyllableComposer.swift b/Sources/Tekkon/Tekkon_Constants.swift similarity index 62% rename from Sources/Tekkon/TekkonSyllableComposer.swift rename to Sources/Tekkon/Tekkon_Constants.swift index 5e8fa2d..fa67c37 100644 --- a/Sources/Tekkon/TekkonSyllableComposer.swift +++ b/Sources/Tekkon/Tekkon_Constants.swift @@ -9,935 +9,35 @@ import Foundation /// The namespace for this package. -public struct Tekkon { - // MARK: - Static Constants and Basic Enums - - /// 定義注音符號的種類 - public enum PhoneType: Int { - case null = 0 // 假 - case consonant = 1 // 聲 - case semivowel = 2 // 介 - case vowel = 3 // 韻 - case intonation = 4 // 調 - } - - /// 定義注音排列的類型 - public enum MandarinParser: Int { - case ofDachen = 0 - case ofDachen26 = 1 - case ofETen = 2 - case ofETen26 = 3 - case ofHsu = 4 - case ofIBM = 5 - case ofMiTAC = 6 - case ofSeigyou = 7 - case ofFakeSeigyou = 8 - case ofStarlight = 9 - case ofHanyuPinyin = 100 - case ofSecondaryPinyin = 101 - case ofYalePinyin = 102 - case ofHualuoPinyin = 103 - case ofUniversalPinyin = 104 - - var name: String { - switch self { - case .ofDachen: - return "Dachen" - case .ofDachen26: - return "Dachen26" - case .ofETen: - return "ETen" - case .ofHsu: - return "Hsu" - case .ofETen26: - return "ETen26" - case .ofIBM: - return "IBM" - case .ofMiTAC: - return "MiTAC" - case .ofFakeSeigyou: - return "FakeSeigyou" - case .ofSeigyou: - return "Seigyou" - case .ofStarlight: - return "Starlight" - case .ofHanyuPinyin: - return "HanyuPinyin" - case .ofSecondaryPinyin: - return "SecondaryPinyin" - case .ofYalePinyin: - return "YalePinyin" - case .ofHualuoPinyin: - return "HualuoPinyin" - case .ofUniversalPinyin: - return "UniversalPinyin" - } - } - } +public enum Tekkon { + // MARK: - Static Constants /// 引擎僅接受這些記號作為聲母 - public static let allowedConsonants = [ + public static let allowedConsonants: [String] = [ "ㄅ", "ㄆ", "ㄇ", "ㄈ", "ㄉ", "ㄊ", "ㄋ", "ㄌ", "ㄍ", "ㄎ", "ㄏ", "ㄐ", "ㄑ", "ㄒ", "ㄓ", "ㄔ", "ㄕ", "ㄖ", "ㄗ", "ㄘ", "ㄙ", ] /// 引擎僅接受這些記號作為介母 - public static let allowedSemivowels = ["ㄧ", "ㄨ", "ㄩ"] + public static let allowedSemivowels: [String] = ["ㄧ", "ㄨ", "ㄩ"] /// 引擎僅接受這些記號作為韻母 - public static let allowedVowels = [ + public static let allowedVowels: [String] = [ "ㄚ", "ㄛ", "ㄜ", "ㄝ", "ㄞ", "ㄟ", "ㄠ", "ㄡ", "ㄢ", "ㄣ", "ㄤ", "ㄥ", "ㄦ", ] /// 引擎僅接受這些記號作為聲調 - public static let allowedIntonations = [" ", "ˊ", "ˇ", "ˋ", "˙"] + public static let allowedIntonations: [String] = [" ", "ˊ", "ˇ", "ˋ", "˙"] /// 引擎僅接受這些記號作為注音（聲介韻調四個集合加起來） public static var allowedPhonabets: [String] { allowedConsonants + allowedSemivowels + allowedVowels + allowedIntonations } - // MARK: - Phonabet Structure - - /// 注音符號型別。本身與字串差不多，但卻只能被設定成一個注音符號字符。 - /// 然後會根據自身的 value 的內容值自動計算自身的 PhoneType 類型（聲介韻調假）。 - /// 如果遇到被設為多個字符、或者字符不對的情況的話，value 會被清空、PhoneType 會變成 null。 - /// 賦值時最好直接重新 init 且一直用 let 來初期化 Phonabet。 - /// 其實 value 對外只讀，對內的話另有 valueStorage 代為存儲內容。這樣比較安全一些。 - @frozen public struct Phonabet: Equatable, Hashable, ExpressibleByStringLiteral { - public var type: PhoneType = .null - private var valueStorage = "" - public var value: String { valueStorage } - public var isEmpty: Bool { - value.isEmpty - } - - /// 初期化，會根據傳入的 input 字串參數來自動判定自身的 PhoneType 類型屬性值。 - public init(_ input: String = "") { - if !input.isEmpty { - if allowedPhonabets.contains(String(input.reversed()[0])) { - valueStorage = String(input.reversed()[0]) - ensureType() - } - } - } - - /// 自我清空內容。 - public mutating func clear() { - valueStorage = "" - type = .null - } - - /// 自我變換資料值。 - /// - Parameters: - /// - strOf: 要取代的內容。 - /// - strWith: 要取代成的內容。 - mutating func selfReplace(_ strOf: String, _ strWith: String = "") { - valueStorage = valueStorage.replacingOccurrences(of: strOf, with: strWith) - ensureType() - } - - /// 用來自動更新自身的屬性值的函式。 - mutating func ensureType() { - if Tekkon.allowedConsonants.contains(value) { - type = .consonant - } else if Tekkon.allowedSemivowels.contains(value) { - type = .semivowel - } else if Tekkon.allowedVowels.contains(value) { - type = .vowel - } else if Tekkon.allowedIntonations.contains(value) { - type = .intonation - } else { - type = .null - valueStorage = "" - } - } - - // MARK: - Misc Definitions - - /// 這些內容用來滿足 "Equatable, Hashable, ExpressibleByStringLiteral" 需求。 - - public static func == (lhs: Phonabet, rhs: Phonabet) -> Bool { - lhs.value == rhs.value - } - - public func hash(into hasher: inout Hasher) { - hasher.combine(value) - hasher.combine(type) - } - - public init(stringLiteral value: String) { - self.init(value) - } - - public init(unicodeScalarLiteral value: String) { - self.init(stringLiteral: value) - } - - public init(extendedGraphemeClusterLiteral value: String) { - self.init(stringLiteral: value) - } - } - - // MARK: - Syllable Composer - - /// 注音並擊處理的對外介面以注拼槽（Syllable Composer）的形式存在。 - /// 使用時需要單獨初期化為一個副本變數（因為是 Struct 所以必須得是變數）。 - /// 注拼槽只有四格：聲、介、韻、調。 - /// - /// 因為是 String Literal，所以初期化時可以藉由 @input 參數指定初期已經傳入的按鍵訊號。 - /// 還可以在初期化時藉由 @arrange 參數來指定注音排列（預設為「.ofDachen」大千佈局）。 - @frozen public struct Composer: Equatable, Hashable, ExpressibleByStringLiteral { - /// 聲母。 - public var consonant: Phonabet = "" - - /// 介母。 - public var semivowel: Phonabet = "" - - /// 韻母。 - public var vowel: Phonabet = "" - - /// 聲調。 - public var intonation: Phonabet = "" - - /// 為拉丁字母專用的組音區。 - public var romajiBuffer: String = "" - - /// 注音排列種類。預設情況下是大千排列（Windows / macOS 預設注音排列）。 - public var parser: MandarinParser = .ofDachen - - /// 是否對錯誤的注音讀音組合做出自動糾正處理。 - public var phonabetCombinationCorrectionEnabled = false - - /// 內容值，會直接按照正確的順序拼裝自己的聲介韻調內容、再回傳。 - /// 注意：直接取這個參數的內容的話，陰平聲調會成為一個空格。 - /// 如果是要取不帶空格的注音的話，請使用「.getComposition()」而非「.value」。 - public var value: String { - consonant.value + semivowel.value + vowel.value + intonation.value - } - - /// 與 value 類似，這個函式就是用來決定輸入法組字區內顯示的注音/拼音內容， - /// 但可以指定是否輸出教科書格式（拼音的調號在字母上方、注音的輕聲寫在左側）。 - /// - Parameters: - /// - isHanyuPinyin: 是否將輸出結果轉成漢語拼音。 - /// - isTextBookStyle: 是否將輸出的注音/拼音結果轉成教科書排版格式。 - public func getComposition(isHanyuPinyin: Bool = false, isTextBookStyle: Bool = false) -> String { - switch isHanyuPinyin { - case false: // 注音輸出的場合 - let valReturnZhuyin = value.replacingOccurrences(of: " ", with: "") - return isTextBookStyle ? cnvZhuyinChainToTextbookReading(target: valReturnZhuyin) : valReturnZhuyin - case true: // 拼音輸出的場合 - let valReturnPinyin = Tekkon.cnvPhonaToHanyuPinyin(target: value) - return isTextBookStyle ? Tekkon.cnvHanyuPinyinToTextbookStyle(target: valReturnPinyin) : valReturnPinyin - } - } - - // 該函式僅用來獲取給 macOS InputMethod Kit 的內文組字區使用的顯示字串。 - /// - Parameters: - /// - isHanyuPinyin: 是否將輸出結果轉成漢語拼音。 - public func getInlineCompositionForDisplay(isHanyuPinyin: Bool = false) -> String { - switch parser { - case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin: - var toneReturned = "" - switch intonation.value { - case " ": toneReturned = "1" - case "ˊ": toneReturned = "2" - case "ˇ": toneReturned = "3" - case "ˋ": toneReturned = "4" - case "˙": toneReturned = "5" - default: break - } - return romajiBuffer + toneReturned - default: return getComposition(isHanyuPinyin: isHanyuPinyin) - } - } - - /// 注拼槽內容是否為空。 - public var isEmpty: Bool { - switch parser { - case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin: - return intonation.isEmpty && romajiBuffer.isEmpty - default: return intonation.isEmpty && vowel.isEmpty && semivowel.isEmpty && consonant.isEmpty - } - } - - /// 注拼槽內容是否可唸。 - public var isPronouncable: Bool { - !vowel.isEmpty || !semivowel.isEmpty || !consonant.isEmpty - } - - // MARK: 注拼槽對外處理函式 - - /// 初期化一個新的注拼槽。可以藉由 @input 參數指定初期已經傳入的按鍵訊號。 - /// 還可以在初期化時藉由 @arrange 參數來指定注音排列（預設為「.ofDachen」大千佈局）。 - /// - Parameters: - /// - input: 傳入的 String 內容，用以處理單個字符。 - /// - arrange: 要使用的注音排列。 - /// - correction: 是否對錯誤的注音讀音組合做出自動糾正處理。 - public init(_ input: String = "", arrange parser: MandarinParser = .ofDachen, correction: Bool = false) { - phonabetCombinationCorrectionEnabled = correction - ensureParser(arrange: parser) - receiveKey(fromString: input) - } - - /// 清除自身的內容，就是將聲介韻調全部清空。 - /// 嚴格而言，「注音排列」這個屬性沒有需要清空的概念，只能用 ensureParser 參數變更之。 - public mutating func clear() { - consonant.clear() - semivowel.clear() - vowel.clear() - intonation.clear() - romajiBuffer = "" - } - - // MARK: - Public Functions - - /// 用於檢測「某個輸入字符訊號的合規性」的函式。 - /// - /// 注意：回傳結果會受到當前注音排列 parser 屬性的影響。 - /// - Parameters: - /// - key: 傳入的 UniChar 內容。 - public func inputValidityCheck(key inputKey: UniChar = 0) -> Bool { - if let scalar = UnicodeScalar(inputKey) { - let input = String(scalar) - switch parser { - case .ofDachen: - return Tekkon.mapQwertyDachen[input] != nil - case .ofDachen26: - return Tekkon.mapDachenCP26StaticKeys[input] != nil - case .ofETen: - return Tekkon.mapQwertyETenTraditional[input] != nil - case .ofHsu: - return Tekkon.mapHsuStaticKeys[input] != nil - case .ofETen26: - return Tekkon.mapETen26StaticKeys[input] != nil - case .ofIBM: - return Tekkon.mapQwertyIBM[input] != nil - case .ofMiTAC: - return Tekkon.mapQwertyMiTAC[input] != nil - case .ofSeigyou: - return Tekkon.mapSeigyou[input] != nil - case .ofFakeSeigyou: - return Tekkon.mapFakeSeigyou[input] != nil - case .ofStarlight: - return Tekkon.mapStarlightStaticKeys[input] != nil - case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin: - return Tekkon.mapArayuruPinyin.contains(input) - } - } - return false - } - - /// 接受傳入的按鍵訊號時的處理，處理對象為 String。 - /// 另有同名函式可處理 UniChar 訊號。 - /// - /// 如果是諸如複合型注音排列的話，翻譯結果有可能為空，但翻譯過程已經處理好聲介韻調分配了。 - /// - Parameters: - /// - fromString: 傳入的 String 內容。 - public mutating func receiveKey(fromString input: String = "") { - switch parser { - case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin: - if mapArayuruPinyinIntonation.keys.contains(input) { - if let theTone = mapArayuruPinyinIntonation[input] { - intonation = Phonabet(theTone) - } - } else { - // 為了防止 romajiBuffer 越敲越長帶來算力負擔，這裡讓它在要溢出時自動丟掉最早輸入的音頭。 - if romajiBuffer.count > 5 { - romajiBuffer = String(romajiBuffer.dropFirst()) - } - let romajiBufferBackup = romajiBuffer + input - receiveSequence(romajiBufferBackup, isRomaji: true) - romajiBuffer = romajiBufferBackup - } - default: receiveKey(fromPhonabet: translate(key: input)) - } - } - - /// 接受傳入的按鍵訊號時的處理，處理對象為 UniChar。 - /// 其實也就是先將 UniChar 轉為 String 再交給某個同名異參的函式來處理而已。 - /// - /// 如果是諸如複合型注音排列的話，翻譯結果有可能為空，但翻譯過程已經處理好聲介韻調分配了。 - /// - Parameters: - /// - fromCharCode: 傳入的 UniChar 內容。 - public mutating func receiveKey(fromCharCode inputCharCode: UniChar = 0) { - if let scalar = UnicodeScalar(inputCharCode) { - receiveKey(fromString: String(scalar)) - } - } - - /// 接受傳入的按鍵訊號時的處理，處理對象為單個注音符號。 - /// 主要就是將注音符號拆分辨識且分配到正確的貯存位置而已。 - /// - Parameters: - /// - fromPhonabet: 傳入的單個注音符號字串。 - public mutating func receiveKey(fromPhonabet phonabet: String = "") { - var thePhone: Phonabet = .init(phonabet) - if phonabetCombinationCorrectionEnabled { - switch phonabet { - case "ㄧ", "ㄩ": - if vowel.value == "ㄜ" { vowel = "ㄝ" } - case "ㄜ": - if "ㄨ".contains(semivowel.value) { semivowel = "ㄩ" } - if "ㄧㄩ".contains(semivowel.value) { thePhone = "ㄝ" } - case "ㄝ": - if "ㄨ".contains(semivowel.value) { semivowel = "ㄩ" } - case "ㄛ", "ㄥ": - if "ㄅㄆㄇㄈ".contains(consonant.value), semivowel.value == "ㄨ" { semivowel.clear() } - case "ㄟ": - if "ㄋㄌ".contains(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 = "ㄩ" } - case "ㄅ", "ㄆ", "ㄇ", "ㄈ": - if ["ㄨㄛ", "ㄨㄥ"].contains(semivowel.value + vowel.value) { semivowel.clear() } - default: break - } - } - switch thePhone.type { - case .consonant: consonant = thePhone - case .semivowel: semivowel = thePhone - case .vowel: vowel = thePhone - case .intonation: intonation = thePhone - default: break - } - } - - /// 處理一連串的按鍵輸入。 - /// - Parameters: - /// - givenSequence: 傳入的 String 內容，用以處理一整串擊鍵輸入。 - /// - isRomaji: 如果輸入的字串是諸如漢語拼音這樣的西文字母拼音的話，請啟用此選項。 - public mutating func receiveSequence(_ givenSequence: String = "", isRomaji: Bool = false) { - clear() - if isRomaji { - switch parser { - case .ofHanyuPinyin: - if let dictResult = mapHanyuPinyin[givenSequence] { - for phonabet in dictResult { - receiveKey(fromPhonabet: String(phonabet)) - } - } - case .ofSecondaryPinyin: - if let dictResult = mapSecondaryPinyin[givenSequence] { - for phonabet in dictResult { - receiveKey(fromPhonabet: String(phonabet)) - } - } - case .ofYalePinyin: - if let dictResult = mapYalePinyin[givenSequence] { - for phonabet in dictResult { - receiveKey(fromPhonabet: String(phonabet)) - } - } - case .ofHualuoPinyin: - if let dictResult = mapHualuoPinyin[givenSequence] { - for phonabet in dictResult { - receiveKey(fromPhonabet: String(phonabet)) - } - } - case .ofUniversalPinyin: - if let dictResult = mapUniversalPinyin[givenSequence] { - for phonabet in dictResult { - receiveKey(fromPhonabet: String(phonabet)) - } - } - default: break - } - } else { - for key in givenSequence { - receiveKey(fromString: String(key)) - } - } - } - - /// 處理一連串的按鍵輸入、且返回被處理之後的注音（陰平為空格）。 - /// - Parameters: - /// - givenSequence: 傳入的 String 內容，用以處理一整串擊鍵輸入。 - public mutating func convertSequenceToRawComposition(_ givenSequence: String = "") -> String { - receiveSequence(givenSequence) - return value - } - - /// 專門用來響應使用者摁下 BackSpace 按鍵時的行為。 - /// 刪除順序：調、韻、介、聲。 - /// - /// 基本上就是按順序從游標前方開始往後刪。 - public mutating func doBackSpace() { - if [.ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin].contains(parser), - !romajiBuffer.isEmpty - { - if !intonation.isEmpty { - intonation.clear() - } else { - romajiBuffer = String(romajiBuffer.dropLast()) - } - } else if !intonation.isEmpty { - intonation.clear() - } else if !vowel.isEmpty { - vowel.clear() - } else if !semivowel.isEmpty { - semivowel.clear() - } else if !consonant.isEmpty { - consonant.clear() - } - } - - /// 用來檢測是否有調號的函式，預設情況下不判定聲調以外的內容的存無。 - /// - Parameters: - /// - withNothingElse: 追加判定「槽內是否僅有調號」。 - public func hasToneMarker(withNothingElse: Bool = false) -> Bool { - if !withNothingElse { - return !intonation.isEmpty - } - return !intonation.isEmpty && vowel.isEmpty && semivowel.isEmpty && consonant.isEmpty - } - - // 設定該 Composer 處於何種鍵盤排列分析模式。 - /// - Parameters: - /// - arrange: 給該注拼槽指定注音排列。 - public mutating func ensureParser(arrange: MandarinParser = .ofDachen) { - parser = arrange - } - - // MARK: - Parser Processings - - // 注拼槽對內處理用函式都在這一小節。 - - /// 根據目前的注音排列設定來翻譯傳入的 String 訊號。 - /// - /// 倚天或許氏鍵盤的處理函式會將分配過程代為處理過，此時回傳結果為空字串。 - /// - Parameters: - /// - key: 傳入的 String 訊號。 - mutating func translate(key: String = "") -> String { - switch parser { - case .ofDachen: - return Tekkon.mapQwertyDachen[key] ?? "" - case .ofDachen26: - return handleDachen26(key: key) - case .ofETen: - return Tekkon.mapQwertyETenTraditional[key] ?? "" - case .ofHsu: - return handleHsu(key: key) - case .ofETen26: - return handleETen26(key: key) - case .ofIBM: - return Tekkon.mapQwertyIBM[key] ?? "" - case .ofMiTAC: - return Tekkon.mapQwertyMiTAC[key] ?? "" - case .ofSeigyou: - return Tekkon.mapSeigyou[key] ?? "" - case .ofFakeSeigyou: - return Tekkon.mapFakeSeigyou[key] ?? "" - case .ofStarlight: - return handleStarlight(key: key) - case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin: - break // 漢語拼音單獨用另外的函式處理 - } - return "" - } - - /// 所有動態注音鍵盤佈局都會用到的共用糾錯處理步驟。 - /// - Parameter incomingPhonabet: 傳入的注音 Phonabet。 - mutating func commonFixWhenHandlingDynamicArrangeInputs(target incomingPhonabet: Phonabet) { - // 處理特殊情形。 - switch incomingPhonabet.type { - case .semivowel: - switch consonant { - case "ㄍ": - switch incomingPhonabet { - case "ㄧ": consonant = "ㄑ" // ㄑㄧ - case "ㄨ": consonant = "ㄍ" // ㄍㄨ - case "ㄩ": consonant = "ㄑ" // ㄑㄩ - default: break - } - case "ㄓ": - switch incomingPhonabet { - case "ㄧ": consonant = "ㄐ" // ㄐㄧ - case "ㄨ": consonant = "ㄓ" // ㄓㄨ - case "ㄩ": consonant = "ㄐ" // ㄐㄩ - default: break - } - case "ㄔ": - switch incomingPhonabet { - case "ㄧ": consonant = "ㄑ" // ㄐㄧ - case "ㄨ": consonant = "ㄔ" // ㄓㄨ - case "ㄩ": consonant = "ㄑ" // ㄐㄩ - default: break - } - case "ㄕ": - switch incomingPhonabet { - case "ㄧ": consonant = "ㄒ" // ㄒㄧ - case "ㄨ": consonant = "ㄕ" // ㄕㄨ - case "ㄩ": consonant = "ㄒ" // ㄒㄩ - default: break - } - default: break - } - case .vowel: - if semivowel.isEmpty { - consonant.selfReplace("ㄐ", "ㄓ") - consonant.selfReplace("ㄑ", "ㄔ") - consonant.selfReplace("ㄒ", "ㄕ") - } - default: break - } - } - - /// 倚天忘形注音排列比較麻煩，需要單獨處理。 - /// - /// 回傳結果是空字串的話，不要緊，因為該函式內部已經處理過分配過程了。 - /// - Parameters: - /// - key: 傳入的 String 訊號。 - mutating func handleETen26(key: String = "") -> String { - var strReturn = Tekkon.mapETen26StaticKeys[key] ?? "" - let incomingPhonabet = Phonabet(strReturn) - - 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 { - vowel = "ㄆ" - } else { - vowel = "ㄡ" - } - default: break - } - - // 處理特殊情形。 - commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet) - - if "dfjk ".contains(key), - !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty - { - consonant.selfReplace("ㄆ", "ㄡ") - consonant.selfReplace("ㄇ", "ㄢ") - consonant.selfReplace("ㄊ", "ㄤ") - consonant.selfReplace("ㄋ", "ㄣ") - consonant.selfReplace("ㄌ", "ㄥ") - consonant.selfReplace("ㄏ", "ㄦ") - } - - // 後置修正 - if value == "ㄍ˙" { consonant = "ㄑ" } - - // 這些按鍵在上文處理過了，就不要再回傳了。 - if "dfhjklmnpqtw".contains(key) { strReturn = "" } - - // 回傳結果是空字串的話，不要緊，因為上文已經代處理過分配過程了。 - return strReturn - } - - /// 許氏鍵盤與倚天忘形一樣同樣也比較麻煩，需要單獨處理。 - /// - /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。 - /// - Parameters: - /// - key: 傳入的 String 訊號。 - mutating func handleHsu(key: String = "") -> String { - var strReturn = Tekkon.mapHsuStaticKeys[key] ?? "" - let incomingPhonabet = Phonabet(strReturn) - - if key == " ", value == "ㄋ" { - consonant.clear() - vowel = "ㄣ" - } - - 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 "l": - if value.isEmpty, !consonant.isEmpty, !semivowel.isEmpty { - vowel = "ㄦ" - } else if consonant.isEmpty, semivowel.isEmpty { - consonant = "ㄌ" - } else { - vowel = "ㄥ" - } - default: break - } - - // 處理特殊情形。 - commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet) - - if "dfjs ".contains(key) { - if !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty { - consonant.selfReplace("ㄍ", "ㄜ") - consonant.selfReplace("ㄋ", "ㄣ") - consonant.selfReplace("ㄌ", "ㄦ") - consonant.selfReplace("ㄎ", "ㄤ") - consonant.selfReplace("ㄇ", "ㄢ") - } - if !consonant.isEmpty, vowel.isEmpty { - consonant.selfReplace("ㄧ", "ㄝ") - } - if "ㄢㄣㄤㄥ".contains(vowel.value), semivowel.isEmpty { - consonant.selfReplace("ㄐ", "ㄓ") - consonant.selfReplace("ㄑ", "ㄔ") - consonant.selfReplace("ㄒ", "ㄕ") - } - if "ㄐㄑㄒ".contains(consonant.value), semivowel.isEmpty { - consonant.selfReplace("ㄐ", "ㄓ") - consonant.selfReplace("ㄑ", "ㄔ") - consonant.selfReplace("ㄒ", "ㄕ") - } - if consonant == "ㄏ", semivowel.isEmpty, vowel.isEmpty { - consonant.clear() - vowel = "ㄛ" - } - } - - // 後置修正 - if value == "ㄔ˙" { consonant = "ㄑ" } - - // 這些按鍵在上文處理過了，就不要再回傳了。 - if "acdefghjklmns".contains(key) { strReturn = "" } - - // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。 - return strReturn - } - - /// 星光排列一樣同樣也比較麻煩，需要單獨處理。 - /// - /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。 - /// - Parameters: - /// - key: 傳入的 String 訊號。 - mutating func handleStarlight(key: String) -> String { - var strReturn = Tekkon.mapStarlightStaticKeys[key] ?? "" - let incomingPhonabet = Phonabet(strReturn) - 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 ? "ㄊ" : "ㄟ" - default: break - } - - // 處理特殊情形。 - commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet) - - if "67890 ".contains(key) { - if !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty { - consonant.selfReplace("ㄈ", "ㄠ") - consonant.selfReplace("ㄍ", "ㄥ") - consonant.selfReplace("ㄎ", "ㄤ") - consonant.selfReplace("ㄌ", "ㄦ") - consonant.selfReplace("ㄇ", "ㄢ") - consonant.selfReplace("ㄋ", "ㄣ") - consonant.selfReplace("ㄊ", "ㄟ") - } - } - - // 這些按鍵在上文處理過了，就不要再回傳了。 - if "efgklmn".contains(key) { strReturn = "" } - - // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。 - return strReturn - } - - /// 大千忘形一樣同樣也比較麻煩，需要單獨處理。 - /// - /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。 - /// - Parameters: - /// - key: 傳入的 String 訊號。 - mutating func handleDachen26(key: String = "") -> String { - 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 "m": - if semivowel == "ㄩ", vowel != "ㄡ" { - semivowel.clear() - vowel = "ㄡ" - } else if semivowel != "ㄩ", vowel == "ㄡ" { - semivowel = "ㄩ" - vowel.clear() - } else if !semivowel.isEmpty { - vowel = "ㄡ" - } else { - receiveKey(fromPhonabet: "ㄐㄑㄒ".contains(consonant.value) ? "ㄩ" : "ㄡ") - } - case "u": - if semivowel == "ㄧ", vowel != "ㄚ" { - semivowel.clear() - vowel = "ㄚ" - } else if semivowel != "ㄧ", vowel == "ㄚ" { - semivowel = "ㄧ" - } else if semivowel == "ㄧ", vowel == "ㄚ" { - semivowel.clear() - vowel.clear() - } else if !semivowel.isEmpty { - vowel = "ㄚ" - } else { - semivowel = "ㄧ" - } - default: break - } - - // 這些按鍵在上文處理過了，就不要再回傳了。 - if "qwtilopnbmuerdy".contains(key) { strReturn = "" } - - // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。 - return strReturn - } - - // MARK: - Misc Definitions - - /// 這些內容用來滿足 "Equatable, Hashable, ExpressibleByStringLiteral" 需求。 - - public static func == (lhs: Composer, rhs: Composer) -> Bool { - lhs.value == rhs.value - } - - public func hash(into hasher: inout Hasher) { - hasher.combine(consonant) - hasher.combine(semivowel) - hasher.combine(vowel) - hasher.combine(intonation) - } - - public init(stringLiteral value: String) { - self.init(value) - } - - public init(unicodeScalarLiteral value: String) { - self.init(stringLiteral: value) - } - - public init(extendedGraphemeClusterLiteral value: String) { - self.init(stringLiteral: value) - } - } - - // MARK: - Phonabet to Hanyu-Pinyin Conversion Processing - - /// 注音轉拼音，要求陰平必須是空格。 - /// - Parameters: - /// - target: 傳入的 String 對象物件。 - static func cnvPhonaToHanyuPinyin(target: String) -> String { - var targetConverted = target - for pair in arrPhonaToHanyuPinyin { - targetConverted = targetConverted.replacingOccurrences(of: pair[0], with: pair[1]) - } - return targetConverted - } - - /// 漢語拼音數字標調式轉漢語拼音教科書格式，要求陰平必須是數字 1。 - /// - Parameters: - /// - target: 傳入的 String 對象物件。 - static func cnvHanyuPinyinToTextbookStyle(target: String) -> String { - var targetConverted = target - for pair in arrHanyuPinyinTextbookStyleConversionTable { - targetConverted = targetConverted.replacingOccurrences(of: pair[0], with: pair[1]) - } - return targetConverted - } - - /// 該函式負責將注音轉為教科書印刷的方式（先寫輕聲）。 - /// - Parameters: - /// - target: 要拿來做轉換處理的讀音鏈，以英文減號來分隔每個讀音。 - /// - newSeparator: 新的讀音分隔符。 - /// - Returns: 經過轉換處理的讀音鏈。 - static func cnvZhuyinChainToTextbookReading(target: String, newSeparator: String = "-") -> String { - var arrReturn: [String] = [] - for neta in target.split(separator: "-") { - var newString = String(neta) - if String(neta.reversed()[0]) == "˙" { - newString = String(neta.dropLast()) - newString.insert("˙", at: newString.startIndex) - } - arrReturn.append(newString) - } - return arrReturn.joined(separator: newSeparator) - } - - /// 該函式用來恢復注音當中的陰平聲調，恢復之後會以「1」表示陰平。 - /// - Parameters: - /// - target: 要拿來做轉換處理的讀音鏈，以英文減號來分隔每個讀音。 - /// - newSeparator: 新的讀音分隔符。 - /// - Returns: 經過轉換處理的讀音鏈。 - static func restoreToneOneInZhuyinKey(target: String, newSeparator: String = "-") -> String { - var arrReturn: [String] = [] - for neta in target.split(separator: "-") { - var newNeta = String(neta) - if !"ˊˇˋ˙".contains(String(neta.reversed()[0])), !neta.contains("_") { - newNeta += "1" - } - arrReturn.append(newNeta) - } - return arrReturn.joined(separator: newSeparator) - } - - /// 該函式用來將漢語拼音轉為注音。 - /// - Parameters: - /// - target: 要轉換的漢語拼音內容，要求必須帶有 12345 數字標調。 - /// - newToneOne: 對陰平指定新的標記。預設情況下該標記為空字串。 - /// - Returns: 轉換結果。 - static func cnvHanyuPinyinToPhona(target: String, newToneOne: String = "") -> String { - /// 如果當前內容有任何除了半形英數內容以外的內容的話，就直接放棄轉換。 - if target.contains("_") || !target.isNotPureAlphanumerical { return target } - var result = target - for key in Tekkon.mapHanyuPinyin.keys.sorted(by: { $0.count > $1.count }) { - guard let value = Tekkon.mapHanyuPinyin[key] else { continue } - result = result.replacingOccurrences(of: key, with: value) - } - for key in Tekkon.mapArayuruPinyinIntonation.keys.sorted(by: { $0.count > $1.count }) { - guard let value = Tekkon.mapArayuruPinyinIntonation[key] else { continue } - result = result.replacingOccurrences(of: key, with: (key == "1") ? newToneOne : value) - } - return result - } - /// 原始轉換對照表資料貯存專用佇列（數字標調格式） - static let arrPhonaToHanyuPinyin = [ // 排序很重要。先處理最長的，再處理短的。不然會出亂子。 + static let arrPhonaToHanyuPinyin: [[String]] = [ // 排序很重要。先處理最長的，再處理短的。不然會出亂子。 [" ", "1"], ["ˊ", "2"], ["ˇ", "3"], ["ˋ", "4"], ["˙", "5"], ["ㄅㄧㄝ", "bie"], ["ㄅㄧㄠ", "biao"], ["ㄅㄧㄢ", "bian"], ["ㄅㄧㄣ", "bin"], ["ㄅㄧㄥ", "bing"], ["ㄆㄧㄚ", "pia"], ["ㄆㄧㄝ", "pie"], @@ -1010,7 +110,7 @@ public struct Tekkon { ] /// 漢語拼音韻母轉換對照表資料貯存專用佇列 - static let arrHanyuPinyinTextbookStyleConversionTable = [ // 排序很重要。先處理最長的，再處理短的。不然會出亂子。 + static let arrHanyuPinyinTextbookStyleConversionTable: [[String]] = [ // 排序很重要。先處理最長的，再處理短的。不然會出亂子。 ["iang1", "iāng"], ["iang2", "iáng"], ["iang3", "iǎng"], ["iang4", "iàng"], ["iong1", "iōng"], ["iong2", "ióng"], ["iong3", "iǒng"], ["iong4", "iòng"], ["uang1", "uāng"], ["uang2", "uáng"], ["uang3", "uǎng"], ["uang4", "uàng"], ["uang5", "uang"], @@ -1447,12 +547,3 @@ public struct Tekkon { "s": "ㄙ", "t": "ㄊ", "u": "ㄡ", "v": "ㄩ", "w": "ㄨ", "x": "ㄒ", "y": "ㄧ", "z": "ㄗ", " ": " ", ] } - -/// 檢測字串是否包含半形英數內容 -extension String { - fileprivate var isNotPureAlphanumerical: Bool { - let regex = ".*[^A-Za-z0-9].*" - let testString = NSPredicate(format: "SELF MATCHES %@", regex) - return testString.evaluate(with: self) - } -} diff --git a/Sources/Tekkon/Tekkon_Phonabets.swift b/Sources/Tekkon/Tekkon_Phonabets.swift new file mode 100644 index 0000000..7943e91 --- /dev/null +++ b/Sources/Tekkon/Tekkon_Phonabets.swift @@ -0,0 +1,158 @@ +// (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 Foundation + +extension Tekkon { + // MARK: - Dynamic Constants and Basic Enums + + /// 定義注音符號的種類 + public enum PhoneType: Int { + case null = 0 // 假 + case consonant = 1 // 聲 + case semivowel = 2 // 介 + case vowel = 3 // 韻 + case intonation = 4 // 調 + } + + /// 定義注音排列的類型 + public enum MandarinParser: Int { + case ofDachen = 0 + case ofDachen26 = 1 + case ofETen = 2 + case ofETen26 = 3 + case ofHsu = 4 + case ofIBM = 5 + case ofMiTAC = 6 + case ofSeigyou = 7 + case ofFakeSeigyou = 8 + case ofStarlight = 9 + case ofHanyuPinyin = 100 + case ofSecondaryPinyin = 101 + case ofYalePinyin = 102 + case ofHualuoPinyin = 103 + case ofUniversalPinyin = 104 + + var name: String { + switch self { + case .ofDachen: + return "Dachen" + case .ofDachen26: + return "Dachen26" + case .ofETen: + return "ETen" + case .ofHsu: + return "Hsu" + case .ofETen26: + return "ETen26" + case .ofIBM: + return "IBM" + case .ofMiTAC: + return "MiTAC" + case .ofFakeSeigyou: + return "FakeSeigyou" + case .ofSeigyou: + return "Seigyou" + case .ofStarlight: + return "Starlight" + case .ofHanyuPinyin: + return "HanyuPinyin" + case .ofSecondaryPinyin: + return "SecondaryPinyin" + case .ofYalePinyin: + return "YalePinyin" + case .ofHualuoPinyin: + return "HualuoPinyin" + case .ofUniversalPinyin: + return "UniversalPinyin" + } + } + } + + // MARK: - Phonabet Structure + + /// 注音符號型別。本身與字串差不多，但卻只能被設定成一個注音符號字符。 + /// 然後會根據自身的 value 的內容值自動計算自身的 PhoneType 類型（聲介韻調假）。 + /// 如果遇到被設為多個字符、或者字符不對的情況的話，value 會被清空、PhoneType 會變成 null。 + /// 賦值時最好直接重新 init 且一直用 let 來初期化 Phonabet。 + /// 其實 value 對外只讀，對內的話另有 valueStorage 代為存儲內容。這樣比較安全一些。 + @frozen public struct Phonabet: Equatable, Hashable, ExpressibleByStringLiteral { + public var type: PhoneType = .null + private var valueStorage = "" + public var value: String { valueStorage } + public var isEmpty: Bool { + value.isEmpty + } + + /// 初期化，會根據傳入的 input 字串參數來自動判定自身的 PhoneType 類型屬性值。 + public init(_ input: String = "") { + if !input.isEmpty { + if allowedPhonabets.contains(String(input.reversed()[0])) { + valueStorage = String(input.reversed()[0]) + ensureType() + } + } + } + + /// 自我清空內容。 + public mutating func clear() { + valueStorage = "" + type = .null + } + + /// 自我變換資料值。 + /// - Parameters: + /// - strOf: 要取代的內容。 + /// - strWith: 要取代成的內容。 + public mutating func selfReplace(_ strOf: String, _ strWith: String = "") { + valueStorage = valueStorage.replacingOccurrences(of: strOf, with: strWith) + ensureType() + } + + /// 用來自動更新自身的屬性值的函式。 + public mutating func ensureType() { + if Tekkon.allowedConsonants.contains(value) { + type = .consonant + } else if Tekkon.allowedSemivowels.contains(value) { + type = .semivowel + } else if Tekkon.allowedVowels.contains(value) { + type = .vowel + } else if Tekkon.allowedIntonations.contains(value) { + type = .intonation + } else { + type = .null + valueStorage = "" + } + } + + // MARK: - Misc Definitions + + /// 這些內容用來滿足 "Equatable, Hashable, ExpressibleByStringLiteral" 需求。 + + public static func == (lhs: Phonabet, rhs: Phonabet) -> Bool { + lhs.value == rhs.value + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(value) + hasher.combine(type) + } + + public init(stringLiteral value: String) { + self.init(value) + } + + public init(unicodeScalarLiteral value: String) { + self.init(stringLiteral: value) + } + + public init(extendedGraphemeClusterLiteral value: String) { + self.init(stringLiteral: value) + } + } +} diff --git a/Sources/Tekkon/Tekkon_SyllableComposer.swift b/Sources/Tekkon/Tekkon_SyllableComposer.swift new file mode 100644 index 0000000..993d8dd --- /dev/null +++ b/Sources/Tekkon/Tekkon_SyllableComposer.swift @@ -0,0 +1,688 @@ +// (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 Foundation + +extension Tekkon { + // MARK: - Syllable Composer + + /// 注音並擊處理的對外介面以注拼槽（Syllable Composer）的形式存在。 + /// 使用時需要單獨初期化為一個副本變數（因為是 Struct 所以必須得是變數）。 + /// 注拼槽只有四格：聲、介、韻、調。 + /// + /// 因為是 String Literal，所以初期化時可以藉由 @input 參數指定初期已經傳入的按鍵訊號。 + /// 還可以在初期化時藉由 @arrange 參數來指定注音排列（預設為「.ofDachen」大千佈局）。 + @frozen public struct Composer: Equatable, Hashable, ExpressibleByStringLiteral { + /// 聲母。 + public var consonant: Phonabet = "" + + /// 介母。 + public var semivowel: Phonabet = "" + + /// 韻母。 + public var vowel: Phonabet = "" + + /// 聲調。 + public var intonation: Phonabet = "" + + /// 為拉丁字母專用的組音區。 + public var romajiBuffer: String = "" + + /// 注音排列種類。預設情況下是大千排列（Windows / macOS 預設注音排列）。 + public var parser: MandarinParser = .ofDachen + + /// 是否對錯誤的注音讀音組合做出自動糾正處理。 + public var phonabetCombinationCorrectionEnabled = false + + /// 內容值，會直接按照正確的順序拼裝自己的聲介韻調內容、再回傳。 + /// 注意：直接取這個參數的內容的話，陰平聲調會成為一個空格。 + /// 如果是要取不帶空格的注音的話，請使用「.getComposition()」而非「.value」。 + public var value: String { + consonant.value + semivowel.value + vowel.value + intonation.value + } + + /// 與 value 類似，這個函式就是用來決定輸入法組字區內顯示的注音/拼音內容， + /// 但可以指定是否輸出教科書格式（拼音的調號在字母上方、注音的輕聲寫在左側）。 + /// - Parameters: + /// - isHanyuPinyin: 是否將輸出結果轉成漢語拼音。 + /// - isTextBookStyle: 是否將輸出的注音/拼音結果轉成教科書排版格式。 + public func getComposition(isHanyuPinyin: Bool = false, isTextBookStyle: Bool = false) -> String { + switch isHanyuPinyin { + case false: // 注音輸出的場合 + let valReturnZhuyin = value.replacingOccurrences(of: " ", with: "") + return isTextBookStyle ? cnvZhuyinChainToTextbookReading(target: valReturnZhuyin) : valReturnZhuyin + case true: // 拼音輸出的場合 + let valReturnPinyin = Tekkon.cnvPhonaToHanyuPinyin(target: value) + return isTextBookStyle ? Tekkon.cnvHanyuPinyinToTextbookStyle(target: valReturnPinyin) : valReturnPinyin + } + } + + // 該函式僅用來獲取給 macOS InputMethod Kit 的內文組字區使用的顯示字串。 + /// - Parameters: + /// - isHanyuPinyin: 是否將輸出結果轉成漢語拼音。 + public func getInlineCompositionForDisplay(isHanyuPinyin: Bool = false) -> String { + switch parser { + case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin: + var toneReturned = "" + switch intonation.value { + case " ": toneReturned = "1" + case "ˊ": toneReturned = "2" + case "ˇ": toneReturned = "3" + case "ˋ": toneReturned = "4" + case "˙": toneReturned = "5" + default: break + } + return romajiBuffer + toneReturned + default: return getComposition(isHanyuPinyin: isHanyuPinyin) + } + } + + /// 注拼槽內容是否為空。 + public var isEmpty: Bool { + switch parser { + case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin: + return intonation.isEmpty && romajiBuffer.isEmpty + default: return intonation.isEmpty && vowel.isEmpty && semivowel.isEmpty && consonant.isEmpty + } + } + + /// 注拼槽內容是否可唸。 + public var isPronouncable: Bool { + !vowel.isEmpty || !semivowel.isEmpty || !consonant.isEmpty + } + + // MARK: 注拼槽對外處理函式 + + /// 初期化一個新的注拼槽。可以藉由 @input 參數指定初期已經傳入的按鍵訊號。 + /// 還可以在初期化時藉由 @arrange 參數來指定注音排列（預設為「.ofDachen」大千佈局）。 + /// - Parameters: + /// - input: 傳入的 String 內容，用以處理單個字符。 + /// - arrange: 要使用的注音排列。 + /// - correction: 是否對錯誤的注音讀音組合做出自動糾正處理。 + public init(_ input: String = "", arrange parser: MandarinParser = .ofDachen, correction: Bool = false) { + phonabetCombinationCorrectionEnabled = correction + ensureParser(arrange: parser) + receiveKey(fromString: input) + } + + /// 清除自身的內容，就是將聲介韻調全部清空。 + /// 嚴格而言，「注音排列」這個屬性沒有需要清空的概念，只能用 ensureParser 參數變更之。 + public mutating func clear() { + consonant.clear() + semivowel.clear() + vowel.clear() + intonation.clear() + romajiBuffer = "" + } + + // MARK: - Public Functions + + /// 用於檢測「某個輸入字符訊號的合規性」的函式。 + /// + /// 注意：回傳結果會受到當前注音排列 parser 屬性的影響。 + /// - Parameters: + /// - key: 傳入的 UniChar 內容。 + public func inputValidityCheck(key inputKey: UniChar = 0) -> Bool { + if let scalar = UnicodeScalar(inputKey) { + let input = String(scalar) + switch parser { + case .ofDachen: + return Tekkon.mapQwertyDachen[input] != nil + case .ofDachen26: + return Tekkon.mapDachenCP26StaticKeys[input] != nil + case .ofETen: + return Tekkon.mapQwertyETenTraditional[input] != nil + case .ofHsu: + return Tekkon.mapHsuStaticKeys[input] != nil + case .ofETen26: + return Tekkon.mapETen26StaticKeys[input] != nil + case .ofIBM: + return Tekkon.mapQwertyIBM[input] != nil + case .ofMiTAC: + return Tekkon.mapQwertyMiTAC[input] != nil + case .ofSeigyou: + return Tekkon.mapSeigyou[input] != nil + case .ofFakeSeigyou: + return Tekkon.mapFakeSeigyou[input] != nil + case .ofStarlight: + return Tekkon.mapStarlightStaticKeys[input] != nil + case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin: + return Tekkon.mapArayuruPinyin.contains(input) + } + } + return false + } + + /// 接受傳入的按鍵訊號時的處理，處理對象為 String。 + /// 另有同名函式可處理 UniChar 訊號。 + /// + /// 如果是諸如複合型注音排列的話，翻譯結果有可能為空，但翻譯過程已經處理好聲介韻調分配了。 + /// - Parameters: + /// - fromString: 傳入的 String 內容。 + public mutating func receiveKey(fromString input: String = "") { + switch parser { + case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin: + if mapArayuruPinyinIntonation.keys.contains(input) { + if let theTone = mapArayuruPinyinIntonation[input] { + intonation = Phonabet(theTone) + } + } else { + // 為了防止 romajiBuffer 越敲越長帶來算力負擔，這裡讓它在要溢出時自動丟掉最早輸入的音頭。 + if romajiBuffer.count > 5 { + romajiBuffer = String(romajiBuffer.dropFirst()) + } + let romajiBufferBackup = romajiBuffer + input + receiveSequence(romajiBufferBackup, isRomaji: true) + romajiBuffer = romajiBufferBackup + } + default: receiveKey(fromPhonabet: translate(key: input)) + } + } + + /// 接受傳入的按鍵訊號時的處理，處理對象為 UniChar。 + /// 其實也就是先將 UniChar 轉為 String 再交給某個同名異參的函式來處理而已。 + /// + /// 如果是諸如複合型注音排列的話，翻譯結果有可能為空，但翻譯過程已經處理好聲介韻調分配了。 + /// - Parameters: + /// - fromCharCode: 傳入的 UniChar 內容。 + public mutating func receiveKey(fromCharCode inputCharCode: UniChar = 0) { + if let scalar = UnicodeScalar(inputCharCode) { + receiveKey(fromString: String(scalar)) + } + } + + /// 接受傳入的按鍵訊號時的處理，處理對象為單個注音符號。 + /// 主要就是將注音符號拆分辨識且分配到正確的貯存位置而已。 + /// - Parameters: + /// - fromPhonabet: 傳入的單個注音符號字串。 + public mutating func receiveKey(fromPhonabet phonabet: String = "") { + var thePhone: Phonabet = .init(phonabet) + if phonabetCombinationCorrectionEnabled { + switch phonabet { + case "ㄧ", "ㄩ": + if vowel.value == "ㄜ" { vowel = "ㄝ" } + case "ㄜ": + if "ㄨ".contains(semivowel.value) { semivowel = "ㄩ" } + if "ㄧㄩ".contains(semivowel.value) { thePhone = "ㄝ" } + case "ㄝ": + if "ㄨ".contains(semivowel.value) { semivowel = "ㄩ" } + case "ㄛ", "ㄥ": + if "ㄅㄆㄇㄈ".contains(consonant.value), semivowel.value == "ㄨ" { semivowel.clear() } + case "ㄟ": + if "ㄋㄌ".contains(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 = "ㄩ" } + case "ㄅ", "ㄆ", "ㄇ", "ㄈ": + if ["ㄨㄛ", "ㄨㄥ"].contains(semivowel.value + vowel.value) { semivowel.clear() } + default: break + } + } + switch thePhone.type { + case .consonant: consonant = thePhone + case .semivowel: semivowel = thePhone + case .vowel: vowel = thePhone + case .intonation: intonation = thePhone + default: break + } + } + + /// 處理一連串的按鍵輸入。 + /// - Remark: 注意：對各種拼音而言，該函式無法處理聲調。 + /// - Parameters: + /// - givenSequence: 傳入的 String 內容，用以處理一整串擊鍵輸入。 + /// - isRomaji: 如果輸入的字串是諸如漢語拼音這樣的西文字母拼音的話，請啟用此選項。 + public mutating func receiveSequence(_ givenSequence: String = "", isRomaji: Bool = false) { + clear() + if isRomaji { + switch parser { + case .ofHanyuPinyin: + if let dictResult = mapHanyuPinyin[givenSequence] { + for phonabet in dictResult { + receiveKey(fromPhonabet: String(phonabet)) + } + } + case .ofSecondaryPinyin: + if let dictResult = mapSecondaryPinyin[givenSequence] { + for phonabet in dictResult { + receiveKey(fromPhonabet: String(phonabet)) + } + } + case .ofYalePinyin: + if let dictResult = mapYalePinyin[givenSequence] { + for phonabet in dictResult { + receiveKey(fromPhonabet: String(phonabet)) + } + } + case .ofHualuoPinyin: + if let dictResult = mapHualuoPinyin[givenSequence] { + for phonabet in dictResult { + receiveKey(fromPhonabet: String(phonabet)) + } + } + case .ofUniversalPinyin: + if let dictResult = mapUniversalPinyin[givenSequence] { + for phonabet in dictResult { + receiveKey(fromPhonabet: String(phonabet)) + } + } + default: break + } + } else { + for key in givenSequence { + receiveKey(fromString: String(key)) + } + } + } + + /// 處理一連串的按鍵輸入、且返回被處理之後的注音（陰平為空格）。 + /// - Parameters: + /// - givenSequence: 傳入的 String 內容，用以處理一整串擊鍵輸入。 + public mutating func convertSequenceToRawComposition(_ givenSequence: String = "") -> String { + receiveSequence(givenSequence) + return value + } + + /// 專門用來響應使用者摁下 BackSpace 按鍵時的行為。 + /// 刪除順序：調、韻、介、聲。 + /// + /// 基本上就是按順序從游標前方開始往後刪。 + public mutating func doBackSpace() { + if [.ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin].contains(parser), + !romajiBuffer.isEmpty + { + if !intonation.isEmpty { + intonation.clear() + } else { + romajiBuffer = String(romajiBuffer.dropLast()) + } + } else if !intonation.isEmpty { + intonation.clear() + } else if !vowel.isEmpty { + vowel.clear() + } else if !semivowel.isEmpty { + semivowel.clear() + } else if !consonant.isEmpty { + consonant.clear() + } + } + + /// 用來檢測是否有調號的函式，預設情況下不判定聲調以外的內容的存無。 + /// - Parameters: + /// - withNothingElse: 追加判定「槽內是否僅有調號」。 + public func hasToneMarker(withNothingElse: Bool = false) -> Bool { + if !withNothingElse { + return !intonation.isEmpty + } + return !intonation.isEmpty && vowel.isEmpty && semivowel.isEmpty && consonant.isEmpty + } + + // 設定該 Composer 處於何種鍵盤排列分析模式。 + /// - Parameters: + /// - arrange: 給該注拼槽指定注音排列。 + public mutating func ensureParser(arrange: MandarinParser = .ofDachen) { + parser = arrange + } + + // MARK: - Parser Processings + + // 注拼槽對內處理用函式都在這一小節。 + + /// 根據目前的注音排列設定來翻譯傳入的 String 訊號。 + /// + /// 倚天或許氏鍵盤的處理函式會將分配過程代為處理過，此時回傳結果為空字串。 + /// - Parameters: + /// - key: 傳入的 String 訊號。 + public mutating func translate(key: String = "") -> String { + switch parser { + case .ofDachen: + return Tekkon.mapQwertyDachen[key] ?? "" + case .ofDachen26: + return handleDachen26(key: key) + case .ofETen: + return Tekkon.mapQwertyETenTraditional[key] ?? "" + case .ofHsu: + return handleHsu(key: key) + case .ofETen26: + return handleETen26(key: key) + case .ofIBM: + return Tekkon.mapQwertyIBM[key] ?? "" + case .ofMiTAC: + return Tekkon.mapQwertyMiTAC[key] ?? "" + case .ofSeigyou: + return Tekkon.mapSeigyou[key] ?? "" + case .ofFakeSeigyou: + return Tekkon.mapFakeSeigyou[key] ?? "" + case .ofStarlight: + return handleStarlight(key: key) + case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin: + break // 漢語拼音單獨用另外的函式處理 + } + return "" + } + + /// 所有動態注音鍵盤佈局都會用到的共用糾錯處理步驟。 + /// - Parameter incomingPhonabet: 傳入的注音 Phonabet。 + public mutating func commonFixWhenHandlingDynamicArrangeInputs(target incomingPhonabet: Phonabet) { + // 處理特殊情形。 + switch incomingPhonabet.type { + case .semivowel: + switch consonant { + case "ㄍ": + switch incomingPhonabet { + case "ㄧ": consonant = "ㄑ" // ㄑㄧ + case "ㄨ": consonant = "ㄍ" // ㄍㄨ + case "ㄩ": consonant = "ㄑ" // ㄑㄩ + default: break + } + case "ㄓ": + switch incomingPhonabet { + case "ㄧ": consonant = "ㄐ" // ㄐㄧ + case "ㄨ": consonant = "ㄓ" // ㄓㄨ + case "ㄩ": consonant = "ㄐ" // ㄐㄩ + default: break + } + case "ㄔ": + switch incomingPhonabet { + case "ㄧ": consonant = "ㄑ" // ㄐㄧ + case "ㄨ": consonant = "ㄔ" // ㄓㄨ + case "ㄩ": consonant = "ㄑ" // ㄐㄩ + default: break + } + case "ㄕ": + switch incomingPhonabet { + case "ㄧ": consonant = "ㄒ" // ㄒㄧ + case "ㄨ": consonant = "ㄕ" // ㄕㄨ + case "ㄩ": consonant = "ㄒ" // ㄒㄩ + default: break + } + default: break + } + case .vowel: + if semivowel.isEmpty { + consonant.selfReplace("ㄐ", "ㄓ") + consonant.selfReplace("ㄑ", "ㄔ") + consonant.selfReplace("ㄒ", "ㄕ") + } + default: break + } + } + + /// 倚天忘形注音排列比較麻煩，需要單獨處理。 + /// + /// 回傳結果是空字串的話，不要緊，因為該函式內部已經處理過分配過程了。 + /// - Parameters: + /// - key: 傳入的 String 訊號。 + public mutating func handleETen26(key: String = "") -> String { + var strReturn = Tekkon.mapETen26StaticKeys[key] ?? "" + let incomingPhonabet = Phonabet(strReturn) + + 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 { + vowel = "ㄆ" + } else { + vowel = "ㄡ" + } + default: break + } + + // 處理特殊情形。 + commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet) + + if "dfjk ".contains(key), + !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty + { + consonant.selfReplace("ㄆ", "ㄡ") + consonant.selfReplace("ㄇ", "ㄢ") + consonant.selfReplace("ㄊ", "ㄤ") + consonant.selfReplace("ㄋ", "ㄣ") + consonant.selfReplace("ㄌ", "ㄥ") + consonant.selfReplace("ㄏ", "ㄦ") + } + + // 後置修正 + if value == "ㄍ˙" { consonant = "ㄑ" } + + // 這些按鍵在上文處理過了，就不要再回傳了。 + if "dfhjklmnpqtw".contains(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 = "ㄣ" + } + + 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 "l": + if value.isEmpty, !consonant.isEmpty, !semivowel.isEmpty { + vowel = "ㄦ" + } else if consonant.isEmpty, semivowel.isEmpty { + consonant = "ㄌ" + } else { + vowel = "ㄥ" + } + default: break + } + + // 處理特殊情形。 + commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet) + + if "dfjs ".contains(key) { + if !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty { + consonant.selfReplace("ㄍ", "ㄜ") + consonant.selfReplace("ㄋ", "ㄣ") + consonant.selfReplace("ㄌ", "ㄦ") + consonant.selfReplace("ㄎ", "ㄤ") + consonant.selfReplace("ㄇ", "ㄢ") + } + if !consonant.isEmpty, vowel.isEmpty { + consonant.selfReplace("ㄧ", "ㄝ") + } + if "ㄢㄣㄤㄥ".contains(vowel.value), semivowel.isEmpty { + consonant.selfReplace("ㄐ", "ㄓ") + consonant.selfReplace("ㄑ", "ㄔ") + consonant.selfReplace("ㄒ", "ㄕ") + } + if "ㄐㄑㄒ".contains(consonant.value), semivowel.isEmpty { + consonant.selfReplace("ㄐ", "ㄓ") + consonant.selfReplace("ㄑ", "ㄔ") + consonant.selfReplace("ㄒ", "ㄕ") + } + if consonant == "ㄏ", semivowel.isEmpty, vowel.isEmpty { + consonant.clear() + vowel = "ㄛ" + } + } + + // 後置修正 + if value == "ㄔ˙" { consonant = "ㄑ" } + + // 這些按鍵在上文處理過了，就不要再回傳了。 + if "acdefghjklmns".contains(key) { strReturn = "" } + + // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。 + return strReturn + } + + /// 星光排列一樣同樣也比較麻煩，需要單獨處理。 + /// + /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。 + /// - Parameters: + /// - key: 傳入的 String 訊號。 + public mutating func handleStarlight(key: String) -> String { + var strReturn = Tekkon.mapStarlightStaticKeys[key] ?? "" + let incomingPhonabet = Phonabet(strReturn) + 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 ? "ㄊ" : "ㄟ" + default: break + } + + // 處理特殊情形。 + commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet) + + if "67890 ".contains(key) { + if !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty { + consonant.selfReplace("ㄈ", "ㄠ") + consonant.selfReplace("ㄍ", "ㄥ") + consonant.selfReplace("ㄎ", "ㄤ") + consonant.selfReplace("ㄌ", "ㄦ") + consonant.selfReplace("ㄇ", "ㄢ") + consonant.selfReplace("ㄋ", "ㄣ") + consonant.selfReplace("ㄊ", "ㄟ") + } + } + + // 這些按鍵在上文處理過了，就不要再回傳了。 + if "efgklmn".contains(key) { strReturn = "" } + + // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。 + return strReturn + } + + /// 大千忘形一樣同樣也比較麻煩，需要單獨處理。 + /// + /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。 + /// - Parameters: + /// - key: 傳入的 String 訊號。 + public mutating func handleDachen26(key: String = "") -> String { + 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 "m": + if semivowel == "ㄩ", vowel != "ㄡ" { + semivowel.clear() + vowel = "ㄡ" + } else if semivowel != "ㄩ", vowel == "ㄡ" { + semivowel = "ㄩ" + vowel.clear() + } else if !semivowel.isEmpty { + vowel = "ㄡ" + } else { + receiveKey(fromPhonabet: "ㄐㄑㄒ".contains(consonant.value) ? "ㄩ" : "ㄡ") + } + case "u": + if semivowel == "ㄧ", vowel != "ㄚ" { + semivowel.clear() + vowel = "ㄚ" + } else if semivowel != "ㄧ", vowel == "ㄚ" { + semivowel = "ㄧ" + } else if semivowel == "ㄧ", vowel == "ㄚ" { + semivowel.clear() + vowel.clear() + } else if !semivowel.isEmpty { + vowel = "ㄚ" + } else { + semivowel = "ㄧ" + } + default: break + } + + // 這些按鍵在上文處理過了，就不要再回傳了。 + if "qwtilopnbmuerdy".contains(key) { strReturn = "" } + + // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。 + return strReturn + } + + // MARK: - Misc Definitions + + /// 這些內容用來滿足 "Equatable, Hashable, ExpressibleByStringLiteral" 需求。 + + public static func == (lhs: Composer, rhs: Composer) -> Bool { + lhs.value == rhs.value + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(consonant) + hasher.combine(semivowel) + hasher.combine(vowel) + hasher.combine(intonation) + } + + public init(stringLiteral value: String) { + self.init(value) + } + + public init(unicodeScalarLiteral value: String) { + self.init(stringLiteral: value) + } + + public init(extendedGraphemeClusterLiteral value: String) { + self.init(stringLiteral: value) + } + } +} diff --git a/Sources/Tekkon/Tekkon_Utilities.swift b/Sources/Tekkon/Tekkon_Utilities.swift new file mode 100644 index 0000000..6cca133 --- /dev/null +++ b/Sources/Tekkon/Tekkon_Utilities.swift @@ -0,0 +1,99 @@ +// (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 Foundation + +extension Tekkon { + // MARK: - Phonabet to Hanyu-Pinyin Conversion Processing + + /// 注音轉拼音，要求陰平必須是空格。 + /// - Parameters: + /// - target: 傳入的 String 對象物件。 + public static func cnvPhonaToHanyuPinyin(target: String) -> String { + var targetConverted = target + for pair in arrPhonaToHanyuPinyin { + targetConverted = targetConverted.replacingOccurrences(of: pair[0], with: pair[1]) + } + return targetConverted + } + + /// 漢語拼音數字標調式轉漢語拼音教科書格式，要求陰平必須是數字 1。 + /// - Parameters: + /// - target: 傳入的 String 對象物件。 + public static func cnvHanyuPinyinToTextbookStyle(target: String) -> String { + var targetConverted = target + for pair in arrHanyuPinyinTextbookStyleConversionTable { + targetConverted = targetConverted.replacingOccurrences(of: pair[0], with: pair[1]) + } + return targetConverted + } + + /// 該函式負責將注音轉為教科書印刷的方式（先寫輕聲）。 + /// - Parameters: + /// - target: 要拿來做轉換處理的讀音鏈，以英文減號來分隔每個讀音。 + /// - newSeparator: 新的讀音分隔符。 + /// - Returns: 經過轉換處理的讀音鏈。 + public static func cnvZhuyinChainToTextbookReading(target: String, newSeparator: String = "-") -> String { + var arrReturn: [String] = [] + for neta in target.split(separator: "-") { + var newString = String(neta) + if String(neta.reversed()[0]) == "˙" { + newString = String(neta.dropLast()) + newString.insert("˙", at: newString.startIndex) + } + arrReturn.append(newString) + } + return arrReturn.joined(separator: newSeparator) + } + + /// 該函式用來恢復注音當中的陰平聲調，恢復之後會以「1」表示陰平。 + /// - Parameters: + /// - target: 要拿來做轉換處理的讀音鏈，以英文減號來分隔每個讀音。 + /// - newSeparator: 新的讀音分隔符。 + /// - Returns: 經過轉換處理的讀音鏈。 + public static func restoreToneOneInZhuyinKey(target: String, newSeparator: String = "-") -> String { + var arrReturn: [String] = [] + for neta in target.split(separator: "-") { + var newNeta = String(neta) + if !"ˊˇˋ˙".contains(String(neta.reversed()[0])), !neta.contains("_") { + newNeta += "1" + } + arrReturn.append(newNeta) + } + return arrReturn.joined(separator: newSeparator) + } + + /// 該函式用來將漢語拼音轉為注音。 + /// - Parameters: + /// - target: 要轉換的漢語拼音內容，要求必須帶有 12345 數字標調。 + /// - newToneOne: 對陰平指定新的標記。預設情況下該標記為空字串。 + /// - Returns: 轉換結果。 + public static func cnvHanyuPinyinToPhona(target: String, newToneOne: String = "") -> String { + /// 如果當前內容有任何除了半形英數內容以外的內容的話，就直接放棄轉換。 + if target.contains("_") || !target.isNotPureAlphanumerical { return target } + var result = target + for key in Tekkon.mapHanyuPinyin.keys.sorted(by: { $0.count > $1.count }) { + guard let value = Tekkon.mapHanyuPinyin[key] else { continue } + result = result.replacingOccurrences(of: key, with: value) + } + for key in Tekkon.mapArayuruPinyinIntonation.keys.sorted(by: { $0.count > $1.count }) { + guard let value = Tekkon.mapArayuruPinyinIntonation[key] else { continue } + result = result.replacingOccurrences(of: key, with: (key == "1") ? newToneOne : value) + } + return result + } +} + +/// 檢測字串是否包含半形英數內容 +extension String { + fileprivate var isNotPureAlphanumerical: Bool { + let regex = ".*[^A-Za-z0-9].*" + let testString = NSPredicate(format: "SELF MATCHES %@", regex) + return testString.evaluate(with: self) + } +} diff --git a/Tests/TekkonTests/BasicTests.swift b/Tests/TekkonTests/BasicTests.swift new file mode 100644 index 0000000..d578f1b --- /dev/null +++ b/Tests/TekkonTests/BasicTests.swift @@ -0,0 +1,417 @@ +// (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 + +final class TekkonTestsBasic: XCTestCase { + func testInitializingPhonabet() throws { + let thePhonabetNull = Tekkon.Phonabet("0") + let thePhonabetA = Tekkon.Phonabet("ㄉ") + let thePhonabetB = Tekkon.Phonabet("ㄧ") + let thePhonabetC = Tekkon.Phonabet("ㄠ") + let thePhonabetD = Tekkon.Phonabet("ˇ") + XCTAssert( + thePhonabetNull.type.rawValue == 0 + && thePhonabetA.type.rawValue == 1 + && thePhonabetB.type.rawValue == 2 + && thePhonabetC.type.rawValue == 3 + && thePhonabetD.type.rawValue == 4 + ) + } + + func testIsValidKeyWithKeys() throws { + var result = true + var composer = Tekkon.Composer(arrange: .ofDachen) + + /// Testing Failed Key + result = composer.inputValidityCheck(key: 0x0024) + XCTAssert(result == false) + + // Testing Correct Qwerty Dachen Key + composer.ensureParser(arrange: .ofDachen) + result = composer.inputValidityCheck(key: 0x002F) + XCTAssert(result == true) + + // Testing Correct ETen26 Key + composer.ensureParser(arrange: .ofETen26) + result = composer.inputValidityCheck(key: 0x0062) + XCTAssert(result == true) + + // Testing Correct Hanyu-Pinyin Key + composer.ensureParser(arrange: .ofHanyuPinyin) + result = composer.inputValidityCheck(key: 0x0062) + XCTAssert(result == true) + } + + func testPhonabetKeyReceivingAndCompositions() throws { + var composer = Tekkon.Composer(arrange: .ofDachen) + var toneMarkerIndicator = true + + // Test Key Receiving + composer.receiveKey(fromCharCode: 0x0032) // 2, ㄉ + composer.receiveKey(fromString: "j") // ㄨ + composer.receiveKey(fromString: "u") // ㄧ + composer.receiveKey(fromString: "l") // ㄠ + + // Testing missing tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(!toneMarkerIndicator) + + composer.receiveKey(fromString: "3") // 上聲 + XCTAssertEqual(composer.value, "ㄉㄧㄠˇ") + composer.doBackSpace() + composer.receiveKey(fromString: " ") // 陰平 + XCTAssertEqual(composer.value, "ㄉㄧㄠ ") // 這裡回傳的結果的陰平是空格 + + // Test Getting Displayed Composition + XCTAssertEqual(composer.getComposition(), "ㄉㄧㄠ") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "diao1") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "diāo") + XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "diao1") + + // Test Tone 5 + composer.receiveKey(fromString: "7") // 輕聲 + XCTAssertEqual(composer.getComposition(), "ㄉㄧㄠ˙") + XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄉㄧㄠ") + + // Testing having tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(toneMarkerIndicator) + + // Testing having not-only tone markers + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(!toneMarkerIndicator) + + // Testing having only tone markers + composer.clear() + composer.receiveKey(fromString: "3") // 上聲 + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(toneMarkerIndicator) + + // Testing auto phonabet combination fixing process. + composer.phonabetCombinationCorrectionEnabled = true + + // Testing exceptions of handling "ㄅㄨㄛ ㄆㄨㄛ ㄇㄨㄛ ㄈㄨㄛ" + composer.clear() + composer.receiveKey(fromString: "1") + composer.receiveKey(fromString: "j") + composer.receiveKey(fromString: "i") + XCTAssertEqual(composer.getComposition(), "ㄅㄛ") + composer.receiveKey(fromString: "q") + XCTAssertEqual(composer.getComposition(), "ㄆㄛ") + composer.receiveKey(fromString: "a") + XCTAssertEqual(composer.getComposition(), "ㄇㄛ") + composer.receiveKey(fromString: "z") + XCTAssertEqual(composer.getComposition(), "ㄈㄛ") + + // Testing exceptions of handling "ㄅㄨㄥ ㄆㄨㄥ ㄇㄨㄥ ㄈㄨㄥ" + composer.clear() + composer.receiveKey(fromString: "1") + composer.receiveKey(fromString: "j") + composer.receiveKey(fromString: "/") + XCTAssertEqual(composer.getComposition(), "ㄅㄥ") + composer.receiveKey(fromString: "q") + XCTAssertEqual(composer.getComposition(), "ㄆㄥ") + composer.receiveKey(fromString: "a") + XCTAssertEqual(composer.getComposition(), "ㄇㄥ") + composer.receiveKey(fromString: "z") + XCTAssertEqual(composer.getComposition(), "ㄈㄥ") + + // Testing exceptions of handling "ㄋㄨㄟ ㄌㄨㄟ" + composer.clear() + composer.receiveKey(fromString: "s") + composer.receiveKey(fromString: "j") + composer.receiveKey(fromString: "o") + XCTAssertEqual(composer.getComposition(), "ㄋㄟ") + composer.receiveKey(fromString: "x") + XCTAssertEqual(composer.getComposition(), "ㄌㄟ") + + // Testing exceptions of handling "ㄧㄜ ㄩㄜ" + composer.clear() + composer.receiveKey(fromString: "s") + composer.receiveKey(fromString: "k") + composer.receiveKey(fromString: "u") + XCTAssertEqual(composer.getComposition(), "ㄋㄧㄝ") + composer.receiveKey(fromString: "s") + composer.receiveKey(fromString: "m") + composer.receiveKey(fromString: "k") + XCTAssertEqual(composer.getComposition(), "ㄋㄩㄝ") + composer.receiveKey(fromString: "s") + composer.receiveKey(fromString: "u") + composer.receiveKey(fromString: "k") + XCTAssertEqual(composer.getComposition(), "ㄋㄧㄝ") + + // Testing exceptions of handling "ㄨㄜ ㄨㄝ" + composer.clear() + composer.receiveKey(fromString: "j") + composer.receiveKey(fromString: "k") + XCTAssertEqual(composer.getComposition(), "ㄩㄝ") + composer.clear() + composer.receiveKey(fromString: "j") + composer.receiveKey(fromString: ",") + XCTAssertEqual(composer.getComposition(), "ㄩㄝ") + composer.clear() + composer.receiveKey(fromString: ",") + composer.receiveKey(fromString: "j") + XCTAssertEqual(composer.getComposition(), "ㄩㄝ") + composer.clear() + composer.receiveKey(fromString: "k") + composer.receiveKey(fromString: "j") + XCTAssertEqual(composer.getComposition(), "ㄩㄝ") + + // Testing tool functions + XCTAssertEqual(Tekkon.restoreToneOneInZhuyinKey(target: "ㄉㄧㄠ"), "ㄉㄧㄠ1") + XCTAssertEqual(Tekkon.cnvZhuyinChainToTextbookReading(target: "ㄊㄧㄥ-ㄓㄜ˙"), "ㄊㄧㄥ-˙ㄓㄜ") + XCTAssertEqual(Tekkon.cnvHanyuPinyinToPhona(target: "bian4-le5-tian1"), "ㄅㄧㄢˋ-ㄌㄜ˙-ㄊㄧㄢ") + // 測試這種情形：「如果傳入的字串不包含任何半形英數內容的話，那麼應該直接將傳入的字串原樣返回」。 + XCTAssertEqual(Tekkon.cnvHanyuPinyinToPhona(target: "ㄅㄧㄢˋ-˙ㄌㄜ-ㄊㄧㄢ"), "ㄅㄧㄢˋ-˙ㄌㄜ-ㄊㄧㄢ") + } +} + +// MARK: Testing Pinyin Arrangements + +final class TekkonTestsPinyin: XCTestCase { + func testHanyuPinyinKeyReceivingAndCompositions() throws { + var composer = Tekkon.Composer(arrange: .ofHanyuPinyin) + var toneMarkerIndicator = true + + // Test Key Receiving + composer.receiveKey(fromCharCode: 100) // d + composer.receiveKey(fromString: "i") + composer.receiveKey(fromString: "a") + composer.receiveKey(fromString: "o") + + // Testing missing tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(!toneMarkerIndicator) + + composer.receiveKey(fromString: "3") // 上聲 + XCTAssertEqual(composer.value, "ㄉㄧㄠˇ") + composer.doBackSpace() + composer.receiveKey(fromString: " ") // 陰平 + XCTAssertEqual(composer.value, "ㄉㄧㄠ ") // 這裡回傳的結果的陰平是空格 + + // Test Getting Displayed Composition + XCTAssertEqual(composer.getComposition(), "ㄉㄧㄠ") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "diao1") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "diāo") + XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "diao1") + + // Test Tone 5 + composer.receiveKey(fromString: "7") // 輕聲 + XCTAssertEqual(composer.getComposition(), "ㄉㄧㄠ˙") + XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄉㄧㄠ") + + // Testing having tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(toneMarkerIndicator) + + // Testing having not-only tone markers + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(!toneMarkerIndicator) + + // Testing having only tone markers + composer.clear() + composer.receiveKey(fromString: "3") // 上聲 + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(toneMarkerIndicator) + } + + func testSecondaryPinyinKeyReceivingAndCompositions() throws { + var composer = Tekkon.Composer(arrange: .ofSecondaryPinyin) + var toneMarkerIndicator = true + + // Test Key Receiving + composer.receiveKey(fromCharCode: 99) // c + composer.receiveKey(fromString: "h") + composer.receiveKey(fromString: "i") + composer.receiveKey(fromString: "u") + composer.receiveKey(fromString: "n") + composer.receiveKey(fromString: "g") + + // Testing missing tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(!toneMarkerIndicator) + + composer.receiveKey(fromString: "2") // 陽平 + XCTAssertEqual(composer.value, "ㄑㄩㄥˊ") + composer.doBackSpace() + composer.receiveKey(fromString: " ") // 陰平 + XCTAssertEqual(composer.value, "ㄑㄩㄥ ") // 這裡回傳的結果的陰平是空格 + + // Test Getting Displayed Composition + XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "qiong1") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "qiōng") + XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "chiung1") + + // Test Tone 5 + composer.receiveKey(fromString: "7") // 輕聲 + XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ˙") + XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄑㄩㄥ") + + // Testing having tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(toneMarkerIndicator) + + // Testing having not-only tone markers + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(!toneMarkerIndicator) + + // Testing having only tone markers + composer.clear() + composer.receiveKey(fromString: "3") // 上聲 + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(toneMarkerIndicator) + } + + func testYalePinyinKeyReceivingAndCompositions() throws { + var composer = Tekkon.Composer(arrange: .ofYalePinyin) + var toneMarkerIndicator = true + + // Test Key Receiving + composer.receiveKey(fromCharCode: 99) // c + composer.receiveKey(fromString: "h") + composer.receiveKey(fromString: "y") + composer.receiveKey(fromString: "u") + composer.receiveKey(fromString: "n") + composer.receiveKey(fromString: "g") + + // Testing missing tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(!toneMarkerIndicator) + + composer.receiveKey(fromString: "2") // 陽平 + XCTAssertEqual(composer.value, "ㄑㄩㄥˊ") + composer.doBackSpace() + composer.receiveKey(fromString: " ") // 陰平 + XCTAssertEqual(composer.value, "ㄑㄩㄥ ") // 這裡回傳的結果的陰平是空格 + + // Test Getting Displayed Composition + XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "qiong1") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "qiōng") + XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "chyung1") + + // Test Tone 5 + composer.receiveKey(fromString: "7") // 輕聲 + XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ˙") + XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄑㄩㄥ") + + // Testing having tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(toneMarkerIndicator) + + // Testing having not-only tone markers + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(!toneMarkerIndicator) + + // Testing having only tone markers + composer.clear() + composer.receiveKey(fromString: "3") // 上聲 + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(toneMarkerIndicator) + } + + func testHualuoPinyinKeyReceivingAndCompositions() throws { + var composer = Tekkon.Composer(arrange: .ofHualuoPinyin) + var toneMarkerIndicator = true + + // Test Key Receiving + composer.receiveKey(fromCharCode: 99) // c + composer.receiveKey(fromString: "h") + composer.receiveKey(fromString: "y") + composer.receiveKey(fromString: "o") + composer.receiveKey(fromString: "n") + composer.receiveKey(fromString: "g") + + // Testing missing tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(!toneMarkerIndicator) + + composer.receiveKey(fromString: "2") // 陽平 + XCTAssertEqual(composer.value, "ㄑㄩㄥˊ") + composer.doBackSpace() + composer.receiveKey(fromString: " ") // 陰平 + XCTAssertEqual(composer.value, "ㄑㄩㄥ ") // 這裡回傳的結果的陰平是空格 + + // Test Getting Displayed Composition + XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "qiong1") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "qiōng") + XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "chyong1") + + // Test Tone 5 + composer.receiveKey(fromString: "7") // 輕聲 + XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ˙") + XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄑㄩㄥ") + + // Testing having tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(toneMarkerIndicator) + + // Testing having not-only tone markers + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(!toneMarkerIndicator) + + // Testing having only tone markers + composer.clear() + composer.receiveKey(fromString: "3") // 上聲 + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(toneMarkerIndicator) + } + + func testUniversalPinyinKeyReceivingAndCompositions() throws { + var composer = Tekkon.Composer(arrange: .ofUniversalPinyin) + var toneMarkerIndicator = true + + // Test Key Receiving + composer.receiveKey(fromCharCode: 99) // c + composer.receiveKey(fromString: "y") + composer.receiveKey(fromString: "o") + composer.receiveKey(fromString: "n") + composer.receiveKey(fromString: "g") + + // Testing missing tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(!toneMarkerIndicator) + + composer.receiveKey(fromString: "2") // 陽平 + XCTAssertEqual(composer.value, "ㄑㄩㄥˊ") + composer.doBackSpace() + composer.receiveKey(fromString: " ") // 陰平 + XCTAssertEqual(composer.value, "ㄑㄩㄥ ") // 這裡回傳的結果的陰平是空格 + + // Test Getting Displayed Composition + XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "qiong1") + XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "qiōng") + XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "cyong1") + + // Test Tone 5 + composer.receiveKey(fromString: "7") // 輕聲 + XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ˙") + XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄑㄩㄥ") + + // Testing having tone markers + toneMarkerIndicator = composer.hasToneMarker() + XCTAssert(toneMarkerIndicator) + + // Testing having not-only tone markers + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(!toneMarkerIndicator) + + // Testing having only tone markers + composer.clear() + composer.receiveKey(fromString: "3") // 上聲 + toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) + XCTAssert(toneMarkerIndicator) + } +} diff --git a/Tests/TekkonTests/KeyTest_Basic_DachenTrad.swift b/Tests/TekkonTests/KeyTest_Basic_DachenTrad.swift new file mode 100644 index 0000000..9e8cf7a --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Basic_DachenTrad.swift @@ -0,0 +1,32 @@ +// (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 + +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"), "ㄅㄞˇ") + } +} diff --git a/Tests/TekkonTests/KeyTest_Dachen26_A.swift b/Tests/TekkonTests/KeyTest_Dachen26_A.swift new file mode 100644 index 0000000..111236a --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Dachen26_A.swift @@ -0,0 +1,502 @@ +// (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 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"), "ㄌㄟ˙") + } +} diff --git a/Tests/TekkonTests/KeyTest_Dachen26_B.swift b/Tests/TekkonTests/KeyTest_Dachen26_B.swift new file mode 100644 index 0000000..ed42c69 --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Dachen26_B.swift @@ -0,0 +1,502 @@ +// (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 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"), "ㄓㄨㄞˇ") + } +} diff --git a/Tests/TekkonTests/KeyTest_Dachen26_C.swift b/Tests/TekkonTests/KeyTest_Dachen26_C.swift new file mode 100644 index 0000000..b7798e1 --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Dachen26_C.swift @@ -0,0 +1,520 @@ +// (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 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"), "ㄩㄥˋ") + } +} diff --git a/Tests/TekkonTests/KeyTest_Eten26_A.swift b/Tests/TekkonTests/KeyTest_Eten26_A.swift new file mode 100644 index 0000000..a6d87e1 --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Eten26_A.swift @@ -0,0 +1,502 @@ +// (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 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"), "ㄌㄟ˙") + } +} diff --git a/Tests/TekkonTests/KeyTest_Eten26_B.swift b/Tests/TekkonTests/KeyTest_Eten26_B.swift new file mode 100644 index 0000000..8219f00 --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Eten26_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 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"), "ㄓㄨㄞ") + } +} diff --git a/Tests/TekkonTests/KeyTest_Eten26_C.swift b/Tests/TekkonTests/KeyTest_Eten26_C.swift new file mode 100644 index 0000000..5da4b12 --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Eten26_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 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"), "ㄩㄥˋ") + } +} diff --git a/Tests/TekkonTests/KeyTest_Hsu_A.swift b/Tests/TekkonTests/KeyTest_Hsu_A.swift new file mode 100644 index 0000000..bd65eba --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Hsu_A.swift @@ -0,0 +1,500 @@ +// (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 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"), "ㄌㄟˇ") + } +} diff --git a/Tests/TekkonTests/KeyTest_Hsu_B.swift b/Tests/TekkonTests/KeyTest_Hsu_B.swift new file mode 100644 index 0000000..0a2c8d6 --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Hsu_B.swift @@ -0,0 +1,500 @@ +// (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 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"), "ㄓㄨㄛ") + } +} diff --git a/Tests/TekkonTests/KeyTest_Hsu_C.swift b/Tests/TekkonTests/KeyTest_Hsu_C.swift new file mode 100644 index 0000000..01a5322 --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Hsu_C.swift @@ -0,0 +1,524 @@ +// (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 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"), "ㄩㄥˋ") + } +} diff --git a/Tests/TekkonTests/KeyTest_Starlight_A.swift b/Tests/TekkonTests/KeyTest_Starlight_A.swift new file mode 100644 index 0000000..2a983f9 --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Starlight_A.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 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"), "ㄌㄟˋ") + } +} diff --git a/Tests/TekkonTests/KeyTest_Starlight_B.swift b/Tests/TekkonTests/KeyTest_Starlight_B.swift new file mode 100644 index 0000000..35f48d6 --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Starlight_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 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"), "ㄓㄨㄛˋ") + } +} diff --git a/Tests/TekkonTests/KeyTest_Starlight_C.swift b/Tests/TekkonTests/KeyTest_Starlight_C.swift new file mode 100644 index 0000000..624ceda --- /dev/null +++ b/Tests/TekkonTests/KeyTest_Starlight_C.swift @@ -0,0 +1,522 @@ +// (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 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"), "ㄩㄥˋ") + } +} diff --git a/Tests/TekkonTests/TekkonTests.swift b/Tests/TekkonTests/TekkonTests.swift deleted file mode 100644 index f6bd6f6..0000000 --- a/Tests/TekkonTests/TekkonTests.swift +++ /dev/null @@ -1,6346 +0,0 @@ -// (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 - -final class TekkonTests: XCTestCase { - func testInitializingPhonabet() throws { - let thePhonabetNull = Tekkon.Phonabet("0") - let thePhonabetA = Tekkon.Phonabet("ㄉ") - let thePhonabetB = Tekkon.Phonabet("ㄧ") - let thePhonabetC = Tekkon.Phonabet("ㄠ") - let thePhonabetD = Tekkon.Phonabet("ˇ") - XCTAssert( - thePhonabetNull.type.rawValue == 0 - && thePhonabetA.type.rawValue == 1 - && thePhonabetB.type.rawValue == 2 - && thePhonabetC.type.rawValue == 3 - && thePhonabetD.type.rawValue == 4 - ) - } - - func testIsValidKeyWithKeys() throws { - var result = true - var composer = Tekkon.Composer(arrange: .ofDachen) - - /// Testing Failed Key - result = composer.inputValidityCheck(key: 0x0024) - XCTAssert(result == false) - - // Testing Correct Qwerty Dachen Key - composer.ensureParser(arrange: .ofDachen) - result = composer.inputValidityCheck(key: 0x002F) - XCTAssert(result == true) - - // Testing Correct ETen26 Key - composer.ensureParser(arrange: .ofETen26) - result = composer.inputValidityCheck(key: 0x0062) - XCTAssert(result == true) - - // Testing Correct Hanyu-Pinyin Key - composer.ensureParser(arrange: .ofHanyuPinyin) - result = composer.inputValidityCheck(key: 0x0062) - XCTAssert(result == true) - } - - func testPhonabetKeyReceivingAndCompositions() throws { - var composer = Tekkon.Composer(arrange: .ofDachen) - var toneMarkerIndicator = true - - // Test Key Receiving - composer.receiveKey(fromCharCode: 0x0032) // 2, ㄉ - composer.receiveKey(fromString: "j") // ㄨ - composer.receiveKey(fromString: "u") // ㄧ - composer.receiveKey(fromString: "l") // ㄠ - - // Testing missing tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(!toneMarkerIndicator) - - composer.receiveKey(fromString: "3") // 上聲 - XCTAssertEqual(composer.value, "ㄉㄧㄠˇ") - composer.doBackSpace() - composer.receiveKey(fromString: " ") // 陰平 - XCTAssertEqual(composer.value, "ㄉㄧㄠ ") // 這裡回傳的結果的陰平是空格 - - // Test Getting Displayed Composition - XCTAssertEqual(composer.getComposition(), "ㄉㄧㄠ") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "diao1") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "diāo") - XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "diao1") - - // Test Tone 5 - composer.receiveKey(fromString: "7") // 輕聲 - XCTAssertEqual(composer.getComposition(), "ㄉㄧㄠ˙") - XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄉㄧㄠ") - - // Testing having tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(toneMarkerIndicator) - - // Testing having not-only tone markers - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(!toneMarkerIndicator) - - // Testing having only tone markers - composer.clear() - composer.receiveKey(fromString: "3") // 上聲 - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(toneMarkerIndicator) - - // Testing auto phonabet combination fixing process. - composer.phonabetCombinationCorrectionEnabled = true - - // Testing exceptions of handling "ㄅㄨㄛ ㄆㄨㄛ ㄇㄨㄛ ㄈㄨㄛ" - composer.clear() - composer.receiveKey(fromString: "1") - composer.receiveKey(fromString: "j") - composer.receiveKey(fromString: "i") - XCTAssertEqual(composer.getComposition(), "ㄅㄛ") - composer.receiveKey(fromString: "q") - XCTAssertEqual(composer.getComposition(), "ㄆㄛ") - composer.receiveKey(fromString: "a") - XCTAssertEqual(composer.getComposition(), "ㄇㄛ") - composer.receiveKey(fromString: "z") - XCTAssertEqual(composer.getComposition(), "ㄈㄛ") - - // Testing exceptions of handling "ㄅㄨㄥ ㄆㄨㄥ ㄇㄨㄥ ㄈㄨㄥ" - composer.clear() - composer.receiveKey(fromString: "1") - composer.receiveKey(fromString: "j") - composer.receiveKey(fromString: "/") - XCTAssertEqual(composer.getComposition(), "ㄅㄥ") - composer.receiveKey(fromString: "q") - XCTAssertEqual(composer.getComposition(), "ㄆㄥ") - composer.receiveKey(fromString: "a") - XCTAssertEqual(composer.getComposition(), "ㄇㄥ") - composer.receiveKey(fromString: "z") - XCTAssertEqual(composer.getComposition(), "ㄈㄥ") - - // Testing exceptions of handling "ㄋㄨㄟ ㄌㄨㄟ" - composer.clear() - composer.receiveKey(fromString: "s") - composer.receiveKey(fromString: "j") - composer.receiveKey(fromString: "o") - XCTAssertEqual(composer.getComposition(), "ㄋㄟ") - composer.receiveKey(fromString: "x") - XCTAssertEqual(composer.getComposition(), "ㄌㄟ") - - // Testing exceptions of handling "ㄧㄜ ㄩㄜ" - composer.clear() - composer.receiveKey(fromString: "s") - composer.receiveKey(fromString: "k") - composer.receiveKey(fromString: "u") - XCTAssertEqual(composer.getComposition(), "ㄋㄧㄝ") - composer.receiveKey(fromString: "s") - composer.receiveKey(fromString: "m") - composer.receiveKey(fromString: "k") - XCTAssertEqual(composer.getComposition(), "ㄋㄩㄝ") - composer.receiveKey(fromString: "s") - composer.receiveKey(fromString: "u") - composer.receiveKey(fromString: "k") - XCTAssertEqual(composer.getComposition(), "ㄋㄧㄝ") - - // Testing exceptions of handling "ㄨㄜ ㄨㄝ" - composer.clear() - composer.receiveKey(fromString: "j") - composer.receiveKey(fromString: "k") - XCTAssertEqual(composer.getComposition(), "ㄩㄝ") - composer.clear() - composer.receiveKey(fromString: "j") - composer.receiveKey(fromString: ",") - XCTAssertEqual(composer.getComposition(), "ㄩㄝ") - composer.clear() - composer.receiveKey(fromString: ",") - composer.receiveKey(fromString: "j") - XCTAssertEqual(composer.getComposition(), "ㄩㄝ") - composer.clear() - composer.receiveKey(fromString: "k") - composer.receiveKey(fromString: "j") - XCTAssertEqual(composer.getComposition(), "ㄩㄝ") - - // Testing tool functions - XCTAssertEqual(Tekkon.restoreToneOneInZhuyinKey(target: "ㄉㄧㄠ"), "ㄉㄧㄠ1") - XCTAssertEqual(Tekkon.cnvZhuyinChainToTextbookReading(target: "ㄊㄧㄥ-ㄓㄜ˙"), "ㄊㄧㄥ-˙ㄓㄜ") - XCTAssertEqual(Tekkon.cnvHanyuPinyinToPhona(target: "bian4-le5-tian1"), "ㄅㄧㄢˋ-ㄌㄜ˙-ㄊㄧㄢ") - // 測試這種情形：「如果傳入的字串不包含任何半形英數內容的話，那麼應該直接將傳入的字串原樣返回」。 - XCTAssertEqual(Tekkon.cnvHanyuPinyinToPhona(target: "ㄅㄧㄢˋ-˙ㄌㄜ-ㄊㄧㄢ"), "ㄅㄧㄢˋ-˙ㄌㄜ-ㄊㄧㄢ") - } - - func testHanyuinyinKeyReceivingAndCompositions() throws { - var composer = Tekkon.Composer(arrange: .ofHanyuPinyin) - var toneMarkerIndicator = true - - // Test Key Receiving - composer.receiveKey(fromCharCode: 100) // d - composer.receiveKey(fromString: "i") - composer.receiveKey(fromString: "a") - composer.receiveKey(fromString: "o") - - // Testing missing tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(!toneMarkerIndicator) - - composer.receiveKey(fromString: "3") // 上聲 - XCTAssertEqual(composer.value, "ㄉㄧㄠˇ") - composer.doBackSpace() - composer.receiveKey(fromString: " ") // 陰平 - XCTAssertEqual(composer.value, "ㄉㄧㄠ ") // 這裡回傳的結果的陰平是空格 - - // Test Getting Displayed Composition - XCTAssertEqual(composer.getComposition(), "ㄉㄧㄠ") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "diao1") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "diāo") - XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "diao1") - - // Test Tone 5 - composer.receiveKey(fromString: "7") // 輕聲 - XCTAssertEqual(composer.getComposition(), "ㄉㄧㄠ˙") - XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄉㄧㄠ") - - // Testing having tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(toneMarkerIndicator) - - // Testing having not-only tone markers - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(!toneMarkerIndicator) - - // Testing having only tone markers - composer.clear() - composer.receiveKey(fromString: "3") // 上聲 - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(toneMarkerIndicator) - } - - func testSecondaryPinyinKeyReceivingAndCompositions() throws { - var composer = Tekkon.Composer(arrange: .ofSecondaryPinyin) - var toneMarkerIndicator = true - - // Test Key Receiving - composer.receiveKey(fromCharCode: 99) // c - composer.receiveKey(fromString: "h") - composer.receiveKey(fromString: "i") - composer.receiveKey(fromString: "u") - composer.receiveKey(fromString: "n") - composer.receiveKey(fromString: "g") - - // Testing missing tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(!toneMarkerIndicator) - - composer.receiveKey(fromString: "2") // 陽平 - XCTAssertEqual(composer.value, "ㄑㄩㄥˊ") - composer.doBackSpace() - composer.receiveKey(fromString: " ") // 陰平 - XCTAssertEqual(composer.value, "ㄑㄩㄥ ") // 這裡回傳的結果的陰平是空格 - - // Test Getting Displayed Composition - XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "qiong1") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "qiōng") - XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "chiung1") - - // Test Tone 5 - composer.receiveKey(fromString: "7") // 輕聲 - XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ˙") - XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄑㄩㄥ") - - // Testing having tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(toneMarkerIndicator) - - // Testing having not-only tone markers - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(!toneMarkerIndicator) - - // Testing having only tone markers - composer.clear() - composer.receiveKey(fromString: "3") // 上聲 - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(toneMarkerIndicator) - } - - func testYalePinyinKeyReceivingAndCompositions() throws { - var composer = Tekkon.Composer(arrange: .ofYalePinyin) - var toneMarkerIndicator = true - - // Test Key Receiving - composer.receiveKey(fromCharCode: 99) // c - composer.receiveKey(fromString: "h") - composer.receiveKey(fromString: "y") - composer.receiveKey(fromString: "u") - composer.receiveKey(fromString: "n") - composer.receiveKey(fromString: "g") - - // Testing missing tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(!toneMarkerIndicator) - - composer.receiveKey(fromString: "2") // 陽平 - XCTAssertEqual(composer.value, "ㄑㄩㄥˊ") - composer.doBackSpace() - composer.receiveKey(fromString: " ") // 陰平 - XCTAssertEqual(composer.value, "ㄑㄩㄥ ") // 這裡回傳的結果的陰平是空格 - - // Test Getting Displayed Composition - XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "qiong1") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "qiōng") - XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "chyung1") - - // Test Tone 5 - composer.receiveKey(fromString: "7") // 輕聲 - XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ˙") - XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄑㄩㄥ") - - // Testing having tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(toneMarkerIndicator) - - // Testing having not-only tone markers - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(!toneMarkerIndicator) - - // Testing having only tone markers - composer.clear() - composer.receiveKey(fromString: "3") // 上聲 - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(toneMarkerIndicator) - } - - func testHualuoPinyinKeyReceivingAndCompositions() throws { - var composer = Tekkon.Composer(arrange: .ofHualuoPinyin) - var toneMarkerIndicator = true - - // Test Key Receiving - composer.receiveKey(fromCharCode: 99) // c - composer.receiveKey(fromString: "h") - composer.receiveKey(fromString: "y") - composer.receiveKey(fromString: "o") - composer.receiveKey(fromString: "n") - composer.receiveKey(fromString: "g") - - // Testing missing tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(!toneMarkerIndicator) - - composer.receiveKey(fromString: "2") // 陽平 - XCTAssertEqual(composer.value, "ㄑㄩㄥˊ") - composer.doBackSpace() - composer.receiveKey(fromString: " ") // 陰平 - XCTAssertEqual(composer.value, "ㄑㄩㄥ ") // 這裡回傳的結果的陰平是空格 - - // Test Getting Displayed Composition - XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "qiong1") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "qiōng") - XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "chyong1") - - // Test Tone 5 - composer.receiveKey(fromString: "7") // 輕聲 - XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ˙") - XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄑㄩㄥ") - - // Testing having tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(toneMarkerIndicator) - - // Testing having not-only tone markers - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(!toneMarkerIndicator) - - // Testing having only tone markers - composer.clear() - composer.receiveKey(fromString: "3") // 上聲 - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(toneMarkerIndicator) - } - - func testUniversalPinyinKeyReceivingAndCompositions() throws { - var composer = Tekkon.Composer(arrange: .ofUniversalPinyin) - var toneMarkerIndicator = true - - // Test Key Receiving - composer.receiveKey(fromCharCode: 99) // c - composer.receiveKey(fromString: "y") - composer.receiveKey(fromString: "o") - composer.receiveKey(fromString: "n") - composer.receiveKey(fromString: "g") - - // Testing missing tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(!toneMarkerIndicator) - - composer.receiveKey(fromString: "2") // 陽平 - XCTAssertEqual(composer.value, "ㄑㄩㄥˊ") - composer.doBackSpace() - composer.receiveKey(fromString: " ") // 陰平 - XCTAssertEqual(composer.value, "ㄑㄩㄥ ") // 這裡回傳的結果的陰平是空格 - - // Test Getting Displayed Composition - XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true), "qiong1") - XCTAssertEqual(composer.getComposition(isHanyuPinyin: true, isTextBookStyle: true), "qiōng") - XCTAssertEqual(composer.getInlineCompositionForDisplay(isHanyuPinyin: true), "cyong1") - - // Test Tone 5 - composer.receiveKey(fromString: "7") // 輕聲 - XCTAssertEqual(composer.getComposition(), "ㄑㄩㄥ˙") - XCTAssertEqual(composer.getComposition(isTextBookStyle: true), "˙ㄑㄩㄥ") - - // Testing having tone markers - toneMarkerIndicator = composer.hasToneMarker() - XCTAssert(toneMarkerIndicator) - - // Testing having not-only tone markers - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(!toneMarkerIndicator) - - // Testing having only tone markers - composer.clear() - composer.receiveKey(fromString: "3") // 上聲 - toneMarkerIndicator = composer.hasToneMarker(withNothingElse: true) - XCTAssert(toneMarkerIndicator) - } - - // MARK: - Keyboard Arrangement Tests - - 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"), "ㄅㄞˇ") - } - - func testDachen26Keys() throws { - // Testing handleDachen26() - 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"), "ㄌㄟ˙") - 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"), "ㄓㄨㄞˇ") - 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"), "ㄩㄥˋ") - } - - func testETen26Keys() throws { - // Testing handleETen26() - 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"), "ㄌㄟ˙") - 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"), "ㄓㄨㄞ") - 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"), "ㄩㄥˋ") - } - - func testHsuKeys() throws { - // Testing handleHsu() - 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"), "ㄌㄟˇ") - 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"), "ㄓㄨㄛ") - 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"), "ㄩㄥˋ") - } - - func testStarlightKeys() throws { - // Testing handleHsu() - 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"), "ㄌㄟˋ") - 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"), "ㄓㄨㄛˋ") - 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"), "ㄩㄥˋ") - } -}