← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/src/test/org/apache/lucene/analysis/WordBreakTestUnicode_6_0_0.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/src/test/org/apache/lucene/analysis/WordBreakTestUnicode_6_0_0.java
1
 
package org.apache.lucene.analysis;
2
 
 
3
 
/**
4
 
 * Licensed to the Apache Software Foundation (ASF) under one or more
5
 
 * contributor license agreements.  See the NOTICE file distributed with
6
 
 * this work for additional information regarding copyright ownership.
7
 
 * The ASF licenses this file to You under the Apache License, Version 2.0
8
 
 * (the "License"); you may not use this file except in compliance with
9
 
 * the License.  You may obtain a copy of the License at
10
 
 *
11
 
 *     http://www.apache.org/licenses/LICENSE-2.0
12
 
 *
13
 
 * Unless required by applicable law or agreed to in writing, software
14
 
 * distributed under the License is distributed on an "AS IS" BASIS,
15
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16
 
 * See the License for the specific language governing permissions and
17
 
 * limitations under the License.
18
 
 */
19
 
 
20
 
import org.junit.Ignore;
21
 
 
22
 
/**
23
 
 * This class was automatically generated by generateJavaUnicodeWordBreakTest.pl
24
 
 * from: http://www.unicode.org/Public/6.0.0/ucd/auxiliary/WordBreakTest.txt
25
 
 *
26
 
 * WordBreakTest.txt indicates the points in the provided character sequences
27
 
 * at which conforming implementations must and must not break words.  This
28
 
 * class tests for expected token extraction from each of the test sequences
29
 
 * in WordBreakTest.txt, where the expected tokens are those character
30
 
 * sequences bounded by word breaks and containing at least one character
31
 
 * from one of the following character sets:
32
 
 *
33
 
 *    \p{Script = Han}                (From http://www.unicode.org/Public/6.0.0/ucd/Scripts.txt)
34
 
 *    \p{Script = Hiragana}
35
 
 *    \p{LineBreak = Complex_Context} (From http://www.unicode.org/Public/6.0.0/ucd/LineBreak.txt)
36
 
 *    \p{WordBreak = ALetter}         (From http://www.unicode.org/Public/6.0.0/ucd/auxiliary/WordBreakProperty.txt)
37
 
 *    \p{WordBreak = Katakana}
38
 
 *    \p{WordBreak = Numeric}         (Excludes full-width Arabic digits)
39
 
 *    [\uFF10-\uFF19]                 (Full-width Arabic digits)
40
 
 */
41
 
@Ignore
42
 
public class WordBreakTestUnicode_6_0_0 extends BaseTokenStreamTestCase {
43
 
 
44
 
  public void test(Analyzer analyzer) throws Exception {
45
 
    // ÷ 0001 ÷ 0001 ÷  #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
46
 
    assertAnalyzesTo(analyzer, "\u0001\u0001",
47
 
                     new String[] {  });
48
 
 
49
 
    // ÷ 0001 × 0308 ÷ 0001 ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
50
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0001",
51
 
                     new String[] {  });
52
 
 
53
 
    // ÷ 0001 ÷ 000D ÷  #  ÷ [0.2] <START OF HEADING> (Other) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
54
 
    assertAnalyzesTo(analyzer, "\u0001\r",
55
 
                     new String[] {  });
56
 
 
57
 
    // ÷ 0001 × 0308 ÷ 000D ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
58
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\r",
59
 
                     new String[] {  });
60
 
 
61
 
    // ÷ 0001 ÷ 000A ÷  #  ÷ [0.2] <START OF HEADING> (Other) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
62
 
    assertAnalyzesTo(analyzer, "\u0001\n",
63
 
                     new String[] {  });
64
 
 
65
 
    // ÷ 0001 × 0308 ÷ 000A ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
66
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\n",
67
 
                     new String[] {  });
68
 
 
69
 
    // ÷ 0001 ÷ 000B ÷  #  ÷ [0.2] <START OF HEADING> (Other) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
70
 
    assertAnalyzesTo(analyzer, "\u0001\u000B",
71
 
                     new String[] {  });
72
 
 
73
 
    // ÷ 0001 × 0308 ÷ 000B ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
74
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u000B",
75
 
                     new String[] {  });
76
 
 
77
 
    // ÷ 0001 ÷ 3031 ÷  #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
78
 
    assertAnalyzesTo(analyzer, "\u0001\u3031",
79
 
                     new String[] { "\u3031" });
80
 
 
81
 
    // ÷ 0001 × 0308 ÷ 3031 ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
82
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u3031",
83
 
                     new String[] { "\u3031" });
84
 
 
85
 
    // ÷ 0001 ÷ 0041 ÷  #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
86
 
    assertAnalyzesTo(analyzer, "\u0001\u0041",
87
 
                     new String[] { "\u0041" });
88
 
 
89
 
    // ÷ 0001 × 0308 ÷ 0041 ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
90
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0041",
91
 
                     new String[] { "\u0041" });
92
 
 
93
 
    // ÷ 0001 ÷ 003A ÷  #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
94
 
    assertAnalyzesTo(analyzer, "\u0001\u003A",
95
 
                     new String[] {  });
96
 
 
97
 
    // ÷ 0001 × 0308 ÷ 003A ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
98
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u003A",
99
 
                     new String[] {  });
100
 
 
101
 
    // ÷ 0001 ÷ 002C ÷  #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
102
 
    assertAnalyzesTo(analyzer, "\u0001\u002C",
103
 
                     new String[] {  });
104
 
 
105
 
    // ÷ 0001 × 0308 ÷ 002C ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
106
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u002C",
107
 
                     new String[] {  });
108
 
 
109
 
    // ÷ 0001 ÷ 0027 ÷  #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
110
 
    assertAnalyzesTo(analyzer, "\u0001\u0027",
111
 
                     new String[] {  });
112
 
 
113
 
    // ÷ 0001 × 0308 ÷ 0027 ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
114
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0027",
115
 
                     new String[] {  });
116
 
 
117
 
    // ÷ 0001 ÷ 0030 ÷  #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
118
 
    assertAnalyzesTo(analyzer, "\u0001\u0030",
119
 
                     new String[] { "\u0030" });
120
 
 
121
 
    // ÷ 0001 × 0308 ÷ 0030 ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
122
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0030",
123
 
                     new String[] { "\u0030" });
124
 
 
125
 
    // ÷ 0001 ÷ 005F ÷  #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
126
 
    assertAnalyzesTo(analyzer, "\u0001\u005F",
127
 
                     new String[] {  });
128
 
 
129
 
    // ÷ 0001 × 0308 ÷ 005F ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
130
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u005F",
131
 
                     new String[] {  });
132
 
 
133
 
    // ÷ 0001 × 00AD ÷  #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
134
 
    assertAnalyzesTo(analyzer, "\u0001\u00AD",
135
 
                     new String[] {  });
136
 
 
137
 
    // ÷ 0001 × 0308 × 00AD ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
138
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u00AD",
139
 
                     new String[] {  });
140
 
 
141
 
    // ÷ 0001 × 0300 ÷  #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
142
 
    assertAnalyzesTo(analyzer, "\u0001\u0300",
143
 
                     new String[] {  });
144
 
 
145
 
    // ÷ 0001 × 0308 × 0300 ÷   #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
146
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0300",
147
 
                     new String[] {  });
148
 
 
149
 
    // ÷ 0001 ÷ 0061 × 2060 ÷   #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
150
 
    assertAnalyzesTo(analyzer, "\u0001\u0061\u2060",
151
 
                     new String[] { "\u0061\u2060" });
152
 
 
153
 
    // ÷ 0001 × 0308 ÷ 0061 × 2060 ÷    #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
154
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0061\u2060",
155
 
                     new String[] { "\u0061\u2060" });
156
 
 
157
 
    // ÷ 0001 ÷ 0061 ÷ 003A ÷   #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
158
 
    assertAnalyzesTo(analyzer, "\u0001\u0061\u003A",
159
 
                     new String[] { "\u0061" });
160
 
 
161
 
    // ÷ 0001 × 0308 ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
162
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0061\u003A",
163
 
                     new String[] { "\u0061" });
164
 
 
165
 
    // ÷ 0001 ÷ 0061 ÷ 0027 ÷   #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
166
 
    assertAnalyzesTo(analyzer, "\u0001\u0061\u0027",
167
 
                     new String[] { "\u0061" });
168
 
 
169
 
    // ÷ 0001 × 0308 ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
170
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0061\u0027",
171
 
                     new String[] { "\u0061" });
172
 
 
173
 
    // ÷ 0001 ÷ 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
174
 
    assertAnalyzesTo(analyzer, "\u0001\u0061\u0027\u2060",
175
 
                     new String[] { "\u0061" });
176
 
 
177
 
    // ÷ 0001 × 0308 ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
178
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0061\u0027\u2060",
179
 
                     new String[] { "\u0061" });
180
 
 
181
 
    // ÷ 0001 ÷ 0061 ÷ 002C ÷   #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
182
 
    assertAnalyzesTo(analyzer, "\u0001\u0061\u002C",
183
 
                     new String[] { "\u0061" });
184
 
 
185
 
    // ÷ 0001 × 0308 ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
186
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0061\u002C",
187
 
                     new String[] { "\u0061" });
188
 
 
189
 
    // ÷ 0001 ÷ 0031 ÷ 003A ÷   #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
190
 
    assertAnalyzesTo(analyzer, "\u0001\u0031\u003A",
191
 
                     new String[] { "\u0031" });
192
 
 
193
 
    // ÷ 0001 × 0308 ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
194
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0031\u003A",
195
 
                     new String[] { "\u0031" });
196
 
 
197
 
    // ÷ 0001 ÷ 0031 ÷ 0027 ÷   #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
198
 
    assertAnalyzesTo(analyzer, "\u0001\u0031\u0027",
199
 
                     new String[] { "\u0031" });
200
 
 
201
 
    // ÷ 0001 × 0308 ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
202
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0031\u0027",
203
 
                     new String[] { "\u0031" });
204
 
 
205
 
    // ÷ 0001 ÷ 0031 ÷ 002C ÷   #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
206
 
    assertAnalyzesTo(analyzer, "\u0001\u0031\u002C",
207
 
                     new String[] { "\u0031" });
208
 
 
209
 
    // ÷ 0001 × 0308 ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
210
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0031\u002C",
211
 
                     new String[] { "\u0031" });
212
 
 
213
 
    // ÷ 0001 ÷ 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] <START OF HEADING> (Other) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
214
 
    assertAnalyzesTo(analyzer, "\u0001\u0031\u002E\u2060",
215
 
                     new String[] { "\u0031" });
216
 
 
217
 
    // ÷ 0001 × 0308 ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] <START OF HEADING> (Other) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
218
 
    assertAnalyzesTo(analyzer, "\u0001\u0308\u0031\u002E\u2060",
219
 
                     new String[] { "\u0031" });
220
 
 
221
 
    // ÷ 000D ÷ 0001 ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] <START OF HEADING> (Other) ÷ [0.3]
222
 
    assertAnalyzesTo(analyzer, "\r\u0001",
223
 
                     new String[] {  });
224
 
 
225
 
    // ÷ 000D ÷ 0308 ÷ 0001 ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
226
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0001",
227
 
                     new String[] {  });
228
 
 
229
 
    // ÷ 000D ÷ 000D ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
230
 
    assertAnalyzesTo(analyzer, "\r\r",
231
 
                     new String[] {  });
232
 
 
233
 
    // ÷ 000D ÷ 0308 ÷ 000D ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
234
 
    assertAnalyzesTo(analyzer, "\r\u0308\r",
235
 
                     new String[] {  });
236
 
 
237
 
    // ÷ 000D × 000A ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) × [3.0] <LINE FEED (LF)> (LF) ÷ [0.3]
238
 
    assertAnalyzesTo(analyzer, "\r\n",
239
 
                     new String[] {  });
240
 
 
241
 
    // ÷ 000D ÷ 0308 ÷ 000A ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
242
 
    assertAnalyzesTo(analyzer, "\r\u0308\n",
243
 
                     new String[] {  });
244
 
 
245
 
    // ÷ 000D ÷ 000B ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] <LINE TABULATION> (Newline) ÷ [0.3]
246
 
    assertAnalyzesTo(analyzer, "\r\u000B",
247
 
                     new String[] {  });
248
 
 
249
 
    // ÷ 000D ÷ 0308 ÷ 000B ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
250
 
    assertAnalyzesTo(analyzer, "\r\u0308\u000B",
251
 
                     new String[] {  });
252
 
 
253
 
    // ÷ 000D ÷ 3031 ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
254
 
    assertAnalyzesTo(analyzer, "\r\u3031",
255
 
                     new String[] { "\u3031" });
256
 
 
257
 
    // ÷ 000D ÷ 0308 ÷ 3031 ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
258
 
    assertAnalyzesTo(analyzer, "\r\u0308\u3031",
259
 
                     new String[] { "\u3031" });
260
 
 
261
 
    // ÷ 000D ÷ 0041 ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
262
 
    assertAnalyzesTo(analyzer, "\r\u0041",
263
 
                     new String[] { "\u0041" });
264
 
 
265
 
    // ÷ 000D ÷ 0308 ÷ 0041 ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
266
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0041",
267
 
                     new String[] { "\u0041" });
268
 
 
269
 
    // ÷ 000D ÷ 003A ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COLON (MidLetter) ÷ [0.3]
270
 
    assertAnalyzesTo(analyzer, "\r\u003A",
271
 
                     new String[] {  });
272
 
 
273
 
    // ÷ 000D ÷ 0308 ÷ 003A ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
274
 
    assertAnalyzesTo(analyzer, "\r\u0308\u003A",
275
 
                     new String[] {  });
276
 
 
277
 
    // ÷ 000D ÷ 002C ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMMA (MidNum) ÷ [0.3]
278
 
    assertAnalyzesTo(analyzer, "\r\u002C",
279
 
                     new String[] {  });
280
 
 
281
 
    // ÷ 000D ÷ 0308 ÷ 002C ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
282
 
    assertAnalyzesTo(analyzer, "\r\u0308\u002C",
283
 
                     new String[] {  });
284
 
 
285
 
    // ÷ 000D ÷ 0027 ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] APOSTROPHE (MidNumLet) ÷ [0.3]
286
 
    assertAnalyzesTo(analyzer, "\r\u0027",
287
 
                     new String[] {  });
288
 
 
289
 
    // ÷ 000D ÷ 0308 ÷ 0027 ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
290
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0027",
291
 
                     new String[] {  });
292
 
 
293
 
    // ÷ 000D ÷ 0030 ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] DIGIT ZERO (Numeric) ÷ [0.3]
294
 
    assertAnalyzesTo(analyzer, "\r\u0030",
295
 
                     new String[] { "\u0030" });
296
 
 
297
 
    // ÷ 000D ÷ 0308 ÷ 0030 ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
298
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0030",
299
 
                     new String[] { "\u0030" });
300
 
 
301
 
    // ÷ 000D ÷ 005F ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] LOW LINE (ExtendNumLet) ÷ [0.3]
302
 
    assertAnalyzesTo(analyzer, "\r\u005F",
303
 
                     new String[] {  });
304
 
 
305
 
    // ÷ 000D ÷ 0308 ÷ 005F ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
306
 
    assertAnalyzesTo(analyzer, "\r\u0308\u005F",
307
 
                     new String[] {  });
308
 
 
309
 
    // ÷ 000D ÷ 00AD ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] SOFT HYPHEN (Format_FE) ÷ [0.3]
310
 
    assertAnalyzesTo(analyzer, "\r\u00AD",
311
 
                     new String[] {  });
312
 
 
313
 
    // ÷ 000D ÷ 0308 × 00AD ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
314
 
    assertAnalyzesTo(analyzer, "\r\u0308\u00AD",
315
 
                     new String[] {  });
316
 
 
317
 
    // ÷ 000D ÷ 0300 ÷  #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
318
 
    assertAnalyzesTo(analyzer, "\r\u0300",
319
 
                     new String[] {  });
320
 
 
321
 
    // ÷ 000D ÷ 0308 × 0300 ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
322
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0300",
323
 
                     new String[] {  });
324
 
 
325
 
    // ÷ 000D ÷ 0061 × 2060 ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
326
 
    assertAnalyzesTo(analyzer, "\r\u0061\u2060",
327
 
                     new String[] { "\u0061\u2060" });
328
 
 
329
 
    // ÷ 000D ÷ 0308 ÷ 0061 × 2060 ÷    #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
330
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0061\u2060",
331
 
                     new String[] { "\u0061\u2060" });
332
 
 
333
 
    // ÷ 000D ÷ 0061 ÷ 003A ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
334
 
    assertAnalyzesTo(analyzer, "\r\u0061\u003A",
335
 
                     new String[] { "\u0061" });
336
 
 
337
 
    // ÷ 000D ÷ 0308 ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
338
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0061\u003A",
339
 
                     new String[] { "\u0061" });
340
 
 
341
 
    // ÷ 000D ÷ 0061 ÷ 0027 ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
342
 
    assertAnalyzesTo(analyzer, "\r\u0061\u0027",
343
 
                     new String[] { "\u0061" });
344
 
 
345
 
    // ÷ 000D ÷ 0308 ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
346
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0061\u0027",
347
 
                     new String[] { "\u0061" });
348
 
 
349
 
    // ÷ 000D ÷ 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
350
 
    assertAnalyzesTo(analyzer, "\r\u0061\u0027\u2060",
351
 
                     new String[] { "\u0061" });
352
 
 
353
 
    // ÷ 000D ÷ 0308 ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
354
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0061\u0027\u2060",
355
 
                     new String[] { "\u0061" });
356
 
 
357
 
    // ÷ 000D ÷ 0061 ÷ 002C ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
358
 
    assertAnalyzesTo(analyzer, "\r\u0061\u002C",
359
 
                     new String[] { "\u0061" });
360
 
 
361
 
    // ÷ 000D ÷ 0308 ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
362
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0061\u002C",
363
 
                     new String[] { "\u0061" });
364
 
 
365
 
    // ÷ 000D ÷ 0031 ÷ 003A ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
366
 
    assertAnalyzesTo(analyzer, "\r\u0031\u003A",
367
 
                     new String[] { "\u0031" });
368
 
 
369
 
    // ÷ 000D ÷ 0308 ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
370
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0031\u003A",
371
 
                     new String[] { "\u0031" });
372
 
 
373
 
    // ÷ 000D ÷ 0031 ÷ 0027 ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
374
 
    assertAnalyzesTo(analyzer, "\r\u0031\u0027",
375
 
                     new String[] { "\u0031" });
376
 
 
377
 
    // ÷ 000D ÷ 0308 ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
378
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0031\u0027",
379
 
                     new String[] { "\u0031" });
380
 
 
381
 
    // ÷ 000D ÷ 0031 ÷ 002C ÷   #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
382
 
    assertAnalyzesTo(analyzer, "\r\u0031\u002C",
383
 
                     new String[] { "\u0031" });
384
 
 
385
 
    // ÷ 000D ÷ 0308 ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
386
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0031\u002C",
387
 
                     new String[] { "\u0031" });
388
 
 
389
 
    // ÷ 000D ÷ 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
390
 
    assertAnalyzesTo(analyzer, "\r\u0031\u002E\u2060",
391
 
                     new String[] { "\u0031" });
392
 
 
393
 
    // ÷ 000D ÷ 0308 ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] <CARRIAGE RETURN (CR)> (CR) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
394
 
    assertAnalyzesTo(analyzer, "\r\u0308\u0031\u002E\u2060",
395
 
                     new String[] { "\u0031" });
396
 
 
397
 
    // ÷ 000A ÷ 0001 ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] <START OF HEADING> (Other) ÷ [0.3]
398
 
    assertAnalyzesTo(analyzer, "\n\u0001",
399
 
                     new String[] {  });
400
 
 
401
 
    // ÷ 000A ÷ 0308 ÷ 0001 ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
402
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0001",
403
 
                     new String[] {  });
404
 
 
405
 
    // ÷ 000A ÷ 000D ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
406
 
    assertAnalyzesTo(analyzer, "\n\r",
407
 
                     new String[] {  });
408
 
 
409
 
    // ÷ 000A ÷ 0308 ÷ 000D ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
410
 
    assertAnalyzesTo(analyzer, "\n\u0308\r",
411
 
                     new String[] {  });
412
 
 
413
 
    // ÷ 000A ÷ 000A ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] <LINE FEED (LF)> (LF) ÷ [0.3]
414
 
    assertAnalyzesTo(analyzer, "\n\n",
415
 
                     new String[] {  });
416
 
 
417
 
    // ÷ 000A ÷ 0308 ÷ 000A ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
418
 
    assertAnalyzesTo(analyzer, "\n\u0308\n",
419
 
                     new String[] {  });
420
 
 
421
 
    // ÷ 000A ÷ 000B ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] <LINE TABULATION> (Newline) ÷ [0.3]
422
 
    assertAnalyzesTo(analyzer, "\n\u000B",
423
 
                     new String[] {  });
424
 
 
425
 
    // ÷ 000A ÷ 0308 ÷ 000B ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
426
 
    assertAnalyzesTo(analyzer, "\n\u0308\u000B",
427
 
                     new String[] {  });
428
 
 
429
 
    // ÷ 000A ÷ 3031 ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
430
 
    assertAnalyzesTo(analyzer, "\n\u3031",
431
 
                     new String[] { "\u3031" });
432
 
 
433
 
    // ÷ 000A ÷ 0308 ÷ 3031 ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
434
 
    assertAnalyzesTo(analyzer, "\n\u0308\u3031",
435
 
                     new String[] { "\u3031" });
436
 
 
437
 
    // ÷ 000A ÷ 0041 ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
438
 
    assertAnalyzesTo(analyzer, "\n\u0041",
439
 
                     new String[] { "\u0041" });
440
 
 
441
 
    // ÷ 000A ÷ 0308 ÷ 0041 ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
442
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0041",
443
 
                     new String[] { "\u0041" });
444
 
 
445
 
    // ÷ 000A ÷ 003A ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COLON (MidLetter) ÷ [0.3]
446
 
    assertAnalyzesTo(analyzer, "\n\u003A",
447
 
                     new String[] {  });
448
 
 
449
 
    // ÷ 000A ÷ 0308 ÷ 003A ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
450
 
    assertAnalyzesTo(analyzer, "\n\u0308\u003A",
451
 
                     new String[] {  });
452
 
 
453
 
    // ÷ 000A ÷ 002C ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMMA (MidNum) ÷ [0.3]
454
 
    assertAnalyzesTo(analyzer, "\n\u002C",
455
 
                     new String[] {  });
456
 
 
457
 
    // ÷ 000A ÷ 0308 ÷ 002C ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
458
 
    assertAnalyzesTo(analyzer, "\n\u0308\u002C",
459
 
                     new String[] {  });
460
 
 
461
 
    // ÷ 000A ÷ 0027 ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] APOSTROPHE (MidNumLet) ÷ [0.3]
462
 
    assertAnalyzesTo(analyzer, "\n\u0027",
463
 
                     new String[] {  });
464
 
 
465
 
    // ÷ 000A ÷ 0308 ÷ 0027 ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
466
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0027",
467
 
                     new String[] {  });
468
 
 
469
 
    // ÷ 000A ÷ 0030 ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] DIGIT ZERO (Numeric) ÷ [0.3]
470
 
    assertAnalyzesTo(analyzer, "\n\u0030",
471
 
                     new String[] { "\u0030" });
472
 
 
473
 
    // ÷ 000A ÷ 0308 ÷ 0030 ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
474
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0030",
475
 
                     new String[] { "\u0030" });
476
 
 
477
 
    // ÷ 000A ÷ 005F ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] LOW LINE (ExtendNumLet) ÷ [0.3]
478
 
    assertAnalyzesTo(analyzer, "\n\u005F",
479
 
                     new String[] {  });
480
 
 
481
 
    // ÷ 000A ÷ 0308 ÷ 005F ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
482
 
    assertAnalyzesTo(analyzer, "\n\u0308\u005F",
483
 
                     new String[] {  });
484
 
 
485
 
    // ÷ 000A ÷ 00AD ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] SOFT HYPHEN (Format_FE) ÷ [0.3]
486
 
    assertAnalyzesTo(analyzer, "\n\u00AD",
487
 
                     new String[] {  });
488
 
 
489
 
    // ÷ 000A ÷ 0308 × 00AD ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
490
 
    assertAnalyzesTo(analyzer, "\n\u0308\u00AD",
491
 
                     new String[] {  });
492
 
 
493
 
    // ÷ 000A ÷ 0300 ÷  #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
494
 
    assertAnalyzesTo(analyzer, "\n\u0300",
495
 
                     new String[] {  });
496
 
 
497
 
    // ÷ 000A ÷ 0308 × 0300 ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
498
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0300",
499
 
                     new String[] {  });
500
 
 
501
 
    // ÷ 000A ÷ 0061 × 2060 ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
502
 
    assertAnalyzesTo(analyzer, "\n\u0061\u2060",
503
 
                     new String[] { "\u0061\u2060" });
504
 
 
505
 
    // ÷ 000A ÷ 0308 ÷ 0061 × 2060 ÷    #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
506
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0061\u2060",
507
 
                     new String[] { "\u0061\u2060" });
508
 
 
509
 
    // ÷ 000A ÷ 0061 ÷ 003A ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
510
 
    assertAnalyzesTo(analyzer, "\n\u0061\u003A",
511
 
                     new String[] { "\u0061" });
512
 
 
513
 
    // ÷ 000A ÷ 0308 ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
514
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0061\u003A",
515
 
                     new String[] { "\u0061" });
516
 
 
517
 
    // ÷ 000A ÷ 0061 ÷ 0027 ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
518
 
    assertAnalyzesTo(analyzer, "\n\u0061\u0027",
519
 
                     new String[] { "\u0061" });
520
 
 
521
 
    // ÷ 000A ÷ 0308 ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
522
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0061\u0027",
523
 
                     new String[] { "\u0061" });
524
 
 
525
 
    // ÷ 000A ÷ 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
526
 
    assertAnalyzesTo(analyzer, "\n\u0061\u0027\u2060",
527
 
                     new String[] { "\u0061" });
528
 
 
529
 
    // ÷ 000A ÷ 0308 ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
530
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0061\u0027\u2060",
531
 
                     new String[] { "\u0061" });
532
 
 
533
 
    // ÷ 000A ÷ 0061 ÷ 002C ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
534
 
    assertAnalyzesTo(analyzer, "\n\u0061\u002C",
535
 
                     new String[] { "\u0061" });
536
 
 
537
 
    // ÷ 000A ÷ 0308 ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
538
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0061\u002C",
539
 
                     new String[] { "\u0061" });
540
 
 
541
 
    // ÷ 000A ÷ 0031 ÷ 003A ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
542
 
    assertAnalyzesTo(analyzer, "\n\u0031\u003A",
543
 
                     new String[] { "\u0031" });
544
 
 
545
 
    // ÷ 000A ÷ 0308 ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
546
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0031\u003A",
547
 
                     new String[] { "\u0031" });
548
 
 
549
 
    // ÷ 000A ÷ 0031 ÷ 0027 ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
550
 
    assertAnalyzesTo(analyzer, "\n\u0031\u0027",
551
 
                     new String[] { "\u0031" });
552
 
 
553
 
    // ÷ 000A ÷ 0308 ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
554
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0031\u0027",
555
 
                     new String[] { "\u0031" });
556
 
 
557
 
    // ÷ 000A ÷ 0031 ÷ 002C ÷   #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
558
 
    assertAnalyzesTo(analyzer, "\n\u0031\u002C",
559
 
                     new String[] { "\u0031" });
560
 
 
561
 
    // ÷ 000A ÷ 0308 ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
562
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0031\u002C",
563
 
                     new String[] { "\u0031" });
564
 
 
565
 
    // ÷ 000A ÷ 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
566
 
    assertAnalyzesTo(analyzer, "\n\u0031\u002E\u2060",
567
 
                     new String[] { "\u0031" });
568
 
 
569
 
    // ÷ 000A ÷ 0308 ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] <LINE FEED (LF)> (LF) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
570
 
    assertAnalyzesTo(analyzer, "\n\u0308\u0031\u002E\u2060",
571
 
                     new String[] { "\u0031" });
572
 
 
573
 
    // ÷ 000B ÷ 0001 ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] <START OF HEADING> (Other) ÷ [0.3]
574
 
    assertAnalyzesTo(analyzer, "\u000B\u0001",
575
 
                     new String[] {  });
576
 
 
577
 
    // ÷ 000B ÷ 0308 ÷ 0001 ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
578
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0001",
579
 
                     new String[] {  });
580
 
 
581
 
    // ÷ 000B ÷ 000D ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
582
 
    assertAnalyzesTo(analyzer, "\u000B\r",
583
 
                     new String[] {  });
584
 
 
585
 
    // ÷ 000B ÷ 0308 ÷ 000D ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
586
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\r",
587
 
                     new String[] {  });
588
 
 
589
 
    // ÷ 000B ÷ 000A ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] <LINE FEED (LF)> (LF) ÷ [0.3]
590
 
    assertAnalyzesTo(analyzer, "\u000B\n",
591
 
                     new String[] {  });
592
 
 
593
 
    // ÷ 000B ÷ 0308 ÷ 000A ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
594
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\n",
595
 
                     new String[] {  });
596
 
 
597
 
    // ÷ 000B ÷ 000B ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] <LINE TABULATION> (Newline) ÷ [0.3]
598
 
    assertAnalyzesTo(analyzer, "\u000B\u000B",
599
 
                     new String[] {  });
600
 
 
601
 
    // ÷ 000B ÷ 0308 ÷ 000B ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
602
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u000B",
603
 
                     new String[] {  });
604
 
 
605
 
    // ÷ 000B ÷ 3031 ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
606
 
    assertAnalyzesTo(analyzer, "\u000B\u3031",
607
 
                     new String[] { "\u3031" });
608
 
 
609
 
    // ÷ 000B ÷ 0308 ÷ 3031 ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
610
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u3031",
611
 
                     new String[] { "\u3031" });
612
 
 
613
 
    // ÷ 000B ÷ 0041 ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
614
 
    assertAnalyzesTo(analyzer, "\u000B\u0041",
615
 
                     new String[] { "\u0041" });
616
 
 
617
 
    // ÷ 000B ÷ 0308 ÷ 0041 ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
618
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0041",
619
 
                     new String[] { "\u0041" });
620
 
 
621
 
    // ÷ 000B ÷ 003A ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COLON (MidLetter) ÷ [0.3]
622
 
    assertAnalyzesTo(analyzer, "\u000B\u003A",
623
 
                     new String[] {  });
624
 
 
625
 
    // ÷ 000B ÷ 0308 ÷ 003A ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
626
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u003A",
627
 
                     new String[] {  });
628
 
 
629
 
    // ÷ 000B ÷ 002C ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMMA (MidNum) ÷ [0.3]
630
 
    assertAnalyzesTo(analyzer, "\u000B\u002C",
631
 
                     new String[] {  });
632
 
 
633
 
    // ÷ 000B ÷ 0308 ÷ 002C ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
634
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u002C",
635
 
                     new String[] {  });
636
 
 
637
 
    // ÷ 000B ÷ 0027 ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] APOSTROPHE (MidNumLet) ÷ [0.3]
638
 
    assertAnalyzesTo(analyzer, "\u000B\u0027",
639
 
                     new String[] {  });
640
 
 
641
 
    // ÷ 000B ÷ 0308 ÷ 0027 ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
642
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0027",
643
 
                     new String[] {  });
644
 
 
645
 
    // ÷ 000B ÷ 0030 ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] DIGIT ZERO (Numeric) ÷ [0.3]
646
 
    assertAnalyzesTo(analyzer, "\u000B\u0030",
647
 
                     new String[] { "\u0030" });
648
 
 
649
 
    // ÷ 000B ÷ 0308 ÷ 0030 ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
650
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0030",
651
 
                     new String[] { "\u0030" });
652
 
 
653
 
    // ÷ 000B ÷ 005F ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] LOW LINE (ExtendNumLet) ÷ [0.3]
654
 
    assertAnalyzesTo(analyzer, "\u000B\u005F",
655
 
                     new String[] {  });
656
 
 
657
 
    // ÷ 000B ÷ 0308 ÷ 005F ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
658
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u005F",
659
 
                     new String[] {  });
660
 
 
661
 
    // ÷ 000B ÷ 00AD ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] SOFT HYPHEN (Format_FE) ÷ [0.3]
662
 
    assertAnalyzesTo(analyzer, "\u000B\u00AD",
663
 
                     new String[] {  });
664
 
 
665
 
    // ÷ 000B ÷ 0308 × 00AD ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
666
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u00AD",
667
 
                     new String[] {  });
668
 
 
669
 
    // ÷ 000B ÷ 0300 ÷  #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
670
 
    assertAnalyzesTo(analyzer, "\u000B\u0300",
671
 
                     new String[] {  });
672
 
 
673
 
    // ÷ 000B ÷ 0308 × 0300 ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
674
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0300",
675
 
                     new String[] {  });
676
 
 
677
 
    // ÷ 000B ÷ 0061 × 2060 ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
678
 
    assertAnalyzesTo(analyzer, "\u000B\u0061\u2060",
679
 
                     new String[] { "\u0061\u2060" });
680
 
 
681
 
    // ÷ 000B ÷ 0308 ÷ 0061 × 2060 ÷    #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
682
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0061\u2060",
683
 
                     new String[] { "\u0061\u2060" });
684
 
 
685
 
    // ÷ 000B ÷ 0061 ÷ 003A ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
686
 
    assertAnalyzesTo(analyzer, "\u000B\u0061\u003A",
687
 
                     new String[] { "\u0061" });
688
 
 
689
 
    // ÷ 000B ÷ 0308 ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
690
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0061\u003A",
691
 
                     new String[] { "\u0061" });
692
 
 
693
 
    // ÷ 000B ÷ 0061 ÷ 0027 ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
694
 
    assertAnalyzesTo(analyzer, "\u000B\u0061\u0027",
695
 
                     new String[] { "\u0061" });
696
 
 
697
 
    // ÷ 000B ÷ 0308 ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
698
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0061\u0027",
699
 
                     new String[] { "\u0061" });
700
 
 
701
 
    // ÷ 000B ÷ 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
702
 
    assertAnalyzesTo(analyzer, "\u000B\u0061\u0027\u2060",
703
 
                     new String[] { "\u0061" });
704
 
 
705
 
    // ÷ 000B ÷ 0308 ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
706
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0061\u0027\u2060",
707
 
                     new String[] { "\u0061" });
708
 
 
709
 
    // ÷ 000B ÷ 0061 ÷ 002C ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
710
 
    assertAnalyzesTo(analyzer, "\u000B\u0061\u002C",
711
 
                     new String[] { "\u0061" });
712
 
 
713
 
    // ÷ 000B ÷ 0308 ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
714
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0061\u002C",
715
 
                     new String[] { "\u0061" });
716
 
 
717
 
    // ÷ 000B ÷ 0031 ÷ 003A ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
718
 
    assertAnalyzesTo(analyzer, "\u000B\u0031\u003A",
719
 
                     new String[] { "\u0031" });
720
 
 
721
 
    // ÷ 000B ÷ 0308 ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
722
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0031\u003A",
723
 
                     new String[] { "\u0031" });
724
 
 
725
 
    // ÷ 000B ÷ 0031 ÷ 0027 ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
726
 
    assertAnalyzesTo(analyzer, "\u000B\u0031\u0027",
727
 
                     new String[] { "\u0031" });
728
 
 
729
 
    // ÷ 000B ÷ 0308 ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
730
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0031\u0027",
731
 
                     new String[] { "\u0031" });
732
 
 
733
 
    // ÷ 000B ÷ 0031 ÷ 002C ÷   #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
734
 
    assertAnalyzesTo(analyzer, "\u000B\u0031\u002C",
735
 
                     new String[] { "\u0031" });
736
 
 
737
 
    // ÷ 000B ÷ 0308 ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
738
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0031\u002C",
739
 
                     new String[] { "\u0031" });
740
 
 
741
 
    // ÷ 000B ÷ 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
742
 
    assertAnalyzesTo(analyzer, "\u000B\u0031\u002E\u2060",
743
 
                     new String[] { "\u0031" });
744
 
 
745
 
    // ÷ 000B ÷ 0308 ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] <LINE TABULATION> (Newline) ÷ [3.1] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
746
 
    assertAnalyzesTo(analyzer, "\u000B\u0308\u0031\u002E\u2060",
747
 
                     new String[] { "\u0031" });
748
 
 
749
 
    // ÷ 3031 ÷ 0001 ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
750
 
    assertAnalyzesTo(analyzer, "\u3031\u0001",
751
 
                     new String[] { "\u3031" });
752
 
 
753
 
    // ÷ 3031 × 0308 ÷ 0001 ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
754
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0001",
755
 
                     new String[] { "\u3031\u0308" });
756
 
 
757
 
    // ÷ 3031 ÷ 000D ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
758
 
    assertAnalyzesTo(analyzer, "\u3031\r",
759
 
                     new String[] { "\u3031" });
760
 
 
761
 
    // ÷ 3031 × 0308 ÷ 000D ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
762
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\r",
763
 
                     new String[] { "\u3031\u0308" });
764
 
 
765
 
    // ÷ 3031 ÷ 000A ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
766
 
    assertAnalyzesTo(analyzer, "\u3031\n",
767
 
                     new String[] { "\u3031" });
768
 
 
769
 
    // ÷ 3031 × 0308 ÷ 000A ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
770
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\n",
771
 
                     new String[] { "\u3031\u0308" });
772
 
 
773
 
    // ÷ 3031 ÷ 000B ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
774
 
    assertAnalyzesTo(analyzer, "\u3031\u000B",
775
 
                     new String[] { "\u3031" });
776
 
 
777
 
    // ÷ 3031 × 0308 ÷ 000B ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
778
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u000B",
779
 
                     new String[] { "\u3031\u0308" });
780
 
 
781
 
    // ÷ 3031 × 3031 ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [13.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
782
 
    assertAnalyzesTo(analyzer, "\u3031\u3031",
783
 
                     new String[] { "\u3031\u3031" });
784
 
 
785
 
    // ÷ 3031 × 0308 × 3031 ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
786
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u3031",
787
 
                     new String[] { "\u3031\u0308\u3031" });
788
 
 
789
 
    // ÷ 3031 ÷ 0041 ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
790
 
    assertAnalyzesTo(analyzer, "\u3031\u0041",
791
 
                     new String[] { "\u3031", "\u0041" });
792
 
 
793
 
    // ÷ 3031 × 0308 ÷ 0041 ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
794
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0041",
795
 
                     new String[] { "\u3031\u0308", "\u0041" });
796
 
 
797
 
    // ÷ 3031 ÷ 003A ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
798
 
    assertAnalyzesTo(analyzer, "\u3031\u003A",
799
 
                     new String[] { "\u3031" });
800
 
 
801
 
    // ÷ 3031 × 0308 ÷ 003A ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
802
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u003A",
803
 
                     new String[] { "\u3031\u0308" });
804
 
 
805
 
    // ÷ 3031 ÷ 002C ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
806
 
    assertAnalyzesTo(analyzer, "\u3031\u002C",
807
 
                     new String[] { "\u3031" });
808
 
 
809
 
    // ÷ 3031 × 0308 ÷ 002C ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
810
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u002C",
811
 
                     new String[] { "\u3031\u0308" });
812
 
 
813
 
    // ÷ 3031 ÷ 0027 ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
814
 
    assertAnalyzesTo(analyzer, "\u3031\u0027",
815
 
                     new String[] { "\u3031" });
816
 
 
817
 
    // ÷ 3031 × 0308 ÷ 0027 ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
818
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0027",
819
 
                     new String[] { "\u3031\u0308" });
820
 
 
821
 
    // ÷ 3031 ÷ 0030 ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
822
 
    assertAnalyzesTo(analyzer, "\u3031\u0030",
823
 
                     new String[] { "\u3031", "\u0030" });
824
 
 
825
 
    // ÷ 3031 × 0308 ÷ 0030 ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
826
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0030",
827
 
                     new String[] { "\u3031\u0308", "\u0030" });
828
 
 
829
 
    // ÷ 3031 × 005F ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]
830
 
    assertAnalyzesTo(analyzer, "\u3031\u005F",
831
 
                     new String[] { "\u3031\u005F" });
832
 
 
833
 
    // ÷ 3031 × 0308 × 005F ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]
834
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u005F",
835
 
                     new String[] { "\u3031\u0308\u005F" });
836
 
 
837
 
    // ÷ 3031 × 00AD ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
838
 
    assertAnalyzesTo(analyzer, "\u3031\u00AD",
839
 
                     new String[] { "\u3031\u00AD" });
840
 
 
841
 
    // ÷ 3031 × 0308 × 00AD ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
842
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u00AD",
843
 
                     new String[] { "\u3031\u0308\u00AD" });
844
 
 
845
 
    // ÷ 3031 × 0300 ÷  #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
846
 
    assertAnalyzesTo(analyzer, "\u3031\u0300",
847
 
                     new String[] { "\u3031\u0300" });
848
 
 
849
 
    // ÷ 3031 × 0308 × 0300 ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
850
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0300",
851
 
                     new String[] { "\u3031\u0308\u0300" });
852
 
 
853
 
    // ÷ 3031 ÷ 0061 × 2060 ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
854
 
    assertAnalyzesTo(analyzer, "\u3031\u0061\u2060",
855
 
                     new String[] { "\u3031", "\u0061\u2060" });
856
 
 
857
 
    // ÷ 3031 × 0308 ÷ 0061 × 2060 ÷    #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
858
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0061\u2060",
859
 
                     new String[] { "\u3031\u0308", "\u0061\u2060" });
860
 
 
861
 
    // ÷ 3031 ÷ 0061 ÷ 003A ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
862
 
    assertAnalyzesTo(analyzer, "\u3031\u0061\u003A",
863
 
                     new String[] { "\u3031", "\u0061" });
864
 
 
865
 
    // ÷ 3031 × 0308 ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
866
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0061\u003A",
867
 
                     new String[] { "\u3031\u0308", "\u0061" });
868
 
 
869
 
    // ÷ 3031 ÷ 0061 ÷ 0027 ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
870
 
    assertAnalyzesTo(analyzer, "\u3031\u0061\u0027",
871
 
                     new String[] { "\u3031", "\u0061" });
872
 
 
873
 
    // ÷ 3031 × 0308 ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
874
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0061\u0027",
875
 
                     new String[] { "\u3031\u0308", "\u0061" });
876
 
 
877
 
    // ÷ 3031 ÷ 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
878
 
    assertAnalyzesTo(analyzer, "\u3031\u0061\u0027\u2060",
879
 
                     new String[] { "\u3031", "\u0061" });
880
 
 
881
 
    // ÷ 3031 × 0308 ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
882
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0061\u0027\u2060",
883
 
                     new String[] { "\u3031\u0308", "\u0061" });
884
 
 
885
 
    // ÷ 3031 ÷ 0061 ÷ 002C ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
886
 
    assertAnalyzesTo(analyzer, "\u3031\u0061\u002C",
887
 
                     new String[] { "\u3031", "\u0061" });
888
 
 
889
 
    // ÷ 3031 × 0308 ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
890
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0061\u002C",
891
 
                     new String[] { "\u3031\u0308", "\u0061" });
892
 
 
893
 
    // ÷ 3031 ÷ 0031 ÷ 003A ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
894
 
    assertAnalyzesTo(analyzer, "\u3031\u0031\u003A",
895
 
                     new String[] { "\u3031", "\u0031" });
896
 
 
897
 
    // ÷ 3031 × 0308 ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
898
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0031\u003A",
899
 
                     new String[] { "\u3031\u0308", "\u0031" });
900
 
 
901
 
    // ÷ 3031 ÷ 0031 ÷ 0027 ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
902
 
    assertAnalyzesTo(analyzer, "\u3031\u0031\u0027",
903
 
                     new String[] { "\u3031", "\u0031" });
904
 
 
905
 
    // ÷ 3031 × 0308 ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
906
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0031\u0027",
907
 
                     new String[] { "\u3031\u0308", "\u0031" });
908
 
 
909
 
    // ÷ 3031 ÷ 0031 ÷ 002C ÷   #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
910
 
    assertAnalyzesTo(analyzer, "\u3031\u0031\u002C",
911
 
                     new String[] { "\u3031", "\u0031" });
912
 
 
913
 
    // ÷ 3031 × 0308 ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
914
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0031\u002C",
915
 
                     new String[] { "\u3031\u0308", "\u0031" });
916
 
 
917
 
    // ÷ 3031 ÷ 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
918
 
    assertAnalyzesTo(analyzer, "\u3031\u0031\u002E\u2060",
919
 
                     new String[] { "\u3031", "\u0031" });
920
 
 
921
 
    // ÷ 3031 × 0308 ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] VERTICAL KANA REPEAT MARK (Katakana) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
922
 
    assertAnalyzesTo(analyzer, "\u3031\u0308\u0031\u002E\u2060",
923
 
                     new String[] { "\u3031\u0308", "\u0031" });
924
 
 
925
 
    // ÷ 0041 ÷ 0001 ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
926
 
    assertAnalyzesTo(analyzer, "\u0041\u0001",
927
 
                     new String[] { "\u0041" });
928
 
 
929
 
    // ÷ 0041 × 0308 ÷ 0001 ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
930
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0001",
931
 
                     new String[] { "\u0041\u0308" });
932
 
 
933
 
    // ÷ 0041 ÷ 000D ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
934
 
    assertAnalyzesTo(analyzer, "\u0041\r",
935
 
                     new String[] { "\u0041" });
936
 
 
937
 
    // ÷ 0041 × 0308 ÷ 000D ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
938
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\r",
939
 
                     new String[] { "\u0041\u0308" });
940
 
 
941
 
    // ÷ 0041 ÷ 000A ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
942
 
    assertAnalyzesTo(analyzer, "\u0041\n",
943
 
                     new String[] { "\u0041" });
944
 
 
945
 
    // ÷ 0041 × 0308 ÷ 000A ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
946
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\n",
947
 
                     new String[] { "\u0041\u0308" });
948
 
 
949
 
    // ÷ 0041 ÷ 000B ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
950
 
    assertAnalyzesTo(analyzer, "\u0041\u000B",
951
 
                     new String[] { "\u0041" });
952
 
 
953
 
    // ÷ 0041 × 0308 ÷ 000B ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
954
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u000B",
955
 
                     new String[] { "\u0041\u0308" });
956
 
 
957
 
    // ÷ 0041 ÷ 3031 ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
958
 
    assertAnalyzesTo(analyzer, "\u0041\u3031",
959
 
                     new String[] { "\u0041", "\u3031" });
960
 
 
961
 
    // ÷ 0041 × 0308 ÷ 3031 ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
962
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u3031",
963
 
                     new String[] { "\u0041\u0308", "\u3031" });
964
 
 
965
 
    // ÷ 0041 × 0041 ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [5.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
966
 
    assertAnalyzesTo(analyzer, "\u0041\u0041",
967
 
                     new String[] { "\u0041\u0041" });
968
 
 
969
 
    // ÷ 0041 × 0308 × 0041 ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
970
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0041",
971
 
                     new String[] { "\u0041\u0308\u0041" });
972
 
 
973
 
    // ÷ 0041 ÷ 003A ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
974
 
    assertAnalyzesTo(analyzer, "\u0041\u003A",
975
 
                     new String[] { "\u0041" });
976
 
 
977
 
    // ÷ 0041 × 0308 ÷ 003A ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
978
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u003A",
979
 
                     new String[] { "\u0041\u0308" });
980
 
 
981
 
    // ÷ 0041 ÷ 002C ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
982
 
    assertAnalyzesTo(analyzer, "\u0041\u002C",
983
 
                     new String[] { "\u0041" });
984
 
 
985
 
    // ÷ 0041 × 0308 ÷ 002C ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
986
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u002C",
987
 
                     new String[] { "\u0041\u0308" });
988
 
 
989
 
    // ÷ 0041 ÷ 0027 ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
990
 
    assertAnalyzesTo(analyzer, "\u0041\u0027",
991
 
                     new String[] { "\u0041" });
992
 
 
993
 
    // ÷ 0041 × 0308 ÷ 0027 ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
994
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0027",
995
 
                     new String[] { "\u0041\u0308" });
996
 
 
997
 
    // ÷ 0041 × 0030 ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]
998
 
    assertAnalyzesTo(analyzer, "\u0041\u0030",
999
 
                     new String[] { "\u0041\u0030" });
1000
 
 
1001
 
    // ÷ 0041 × 0308 × 0030 ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]
1002
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0030",
1003
 
                     new String[] { "\u0041\u0308\u0030" });
1004
 
 
1005
 
    // ÷ 0041 × 005F ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]
1006
 
    assertAnalyzesTo(analyzer, "\u0041\u005F",
1007
 
                     new String[] { "\u0041\u005F" });
1008
 
 
1009
 
    // ÷ 0041 × 0308 × 005F ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]
1010
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u005F",
1011
 
                     new String[] { "\u0041\u0308\u005F" });
1012
 
 
1013
 
    // ÷ 0041 × 00AD ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1014
 
    assertAnalyzesTo(analyzer, "\u0041\u00AD",
1015
 
                     new String[] { "\u0041\u00AD" });
1016
 
 
1017
 
    // ÷ 0041 × 0308 × 00AD ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1018
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u00AD",
1019
 
                     new String[] { "\u0041\u0308\u00AD" });
1020
 
 
1021
 
    // ÷ 0041 × 0300 ÷  #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1022
 
    assertAnalyzesTo(analyzer, "\u0041\u0300",
1023
 
                     new String[] { "\u0041\u0300" });
1024
 
 
1025
 
    // ÷ 0041 × 0308 × 0300 ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1026
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0300",
1027
 
                     new String[] { "\u0041\u0308\u0300" });
1028
 
 
1029
 
    // ÷ 0041 × 0061 × 2060 ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [5.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1030
 
    assertAnalyzesTo(analyzer, "\u0041\u0061\u2060",
1031
 
                     new String[] { "\u0041\u0061\u2060" });
1032
 
 
1033
 
    // ÷ 0041 × 0308 × 0061 × 2060 ÷    #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1034
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0061\u2060",
1035
 
                     new String[] { "\u0041\u0308\u0061\u2060" });
1036
 
 
1037
 
    // ÷ 0041 × 0061 ÷ 003A ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1038
 
    assertAnalyzesTo(analyzer, "\u0041\u0061\u003A",
1039
 
                     new String[] { "\u0041\u0061" });
1040
 
 
1041
 
    // ÷ 0041 × 0308 × 0061 ÷ 003A ÷    #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1042
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0061\u003A",
1043
 
                     new String[] { "\u0041\u0308\u0061" });
1044
 
 
1045
 
    // ÷ 0041 × 0061 ÷ 0027 ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1046
 
    assertAnalyzesTo(analyzer, "\u0041\u0061\u0027",
1047
 
                     new String[] { "\u0041\u0061" });
1048
 
 
1049
 
    // ÷ 0041 × 0308 × 0061 ÷ 0027 ÷    #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1050
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0061\u0027",
1051
 
                     new String[] { "\u0041\u0308\u0061" });
1052
 
 
1053
 
    // ÷ 0041 × 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1054
 
    assertAnalyzesTo(analyzer, "\u0041\u0061\u0027\u2060",
1055
 
                     new String[] { "\u0041\u0061" });
1056
 
 
1057
 
    // ÷ 0041 × 0308 × 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1058
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0061\u0027\u2060",
1059
 
                     new String[] { "\u0041\u0308\u0061" });
1060
 
 
1061
 
    // ÷ 0041 × 0061 ÷ 002C ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1062
 
    assertAnalyzesTo(analyzer, "\u0041\u0061\u002C",
1063
 
                     new String[] { "\u0041\u0061" });
1064
 
 
1065
 
    // ÷ 0041 × 0308 × 0061 ÷ 002C ÷    #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1066
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0061\u002C",
1067
 
                     new String[] { "\u0041\u0308\u0061" });
1068
 
 
1069
 
    // ÷ 0041 × 0031 ÷ 003A ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1070
 
    assertAnalyzesTo(analyzer, "\u0041\u0031\u003A",
1071
 
                     new String[] { "\u0041\u0031" });
1072
 
 
1073
 
    // ÷ 0041 × 0308 × 0031 ÷ 003A ÷    #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1074
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0031\u003A",
1075
 
                     new String[] { "\u0041\u0308\u0031" });
1076
 
 
1077
 
    // ÷ 0041 × 0031 ÷ 0027 ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1078
 
    assertAnalyzesTo(analyzer, "\u0041\u0031\u0027",
1079
 
                     new String[] { "\u0041\u0031" });
1080
 
 
1081
 
    // ÷ 0041 × 0308 × 0031 ÷ 0027 ÷    #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1082
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0031\u0027",
1083
 
                     new String[] { "\u0041\u0308\u0031" });
1084
 
 
1085
 
    // ÷ 0041 × 0031 ÷ 002C ÷   #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1086
 
    assertAnalyzesTo(analyzer, "\u0041\u0031\u002C",
1087
 
                     new String[] { "\u0041\u0031" });
1088
 
 
1089
 
    // ÷ 0041 × 0308 × 0031 ÷ 002C ÷    #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1090
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0031\u002C",
1091
 
                     new String[] { "\u0041\u0308\u0031" });
1092
 
 
1093
 
    // ÷ 0041 × 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1094
 
    assertAnalyzesTo(analyzer, "\u0041\u0031\u002E\u2060",
1095
 
                     new String[] { "\u0041\u0031" });
1096
 
 
1097
 
    // ÷ 0041 × 0308 × 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] LATIN CAPITAL LETTER A (ALetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1098
 
    assertAnalyzesTo(analyzer, "\u0041\u0308\u0031\u002E\u2060",
1099
 
                     new String[] { "\u0041\u0308\u0031" });
1100
 
 
1101
 
    // ÷ 003A ÷ 0001 ÷  #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1102
 
    assertAnalyzesTo(analyzer, "\u003A\u0001",
1103
 
                     new String[] {  });
1104
 
 
1105
 
    // ÷ 003A × 0308 ÷ 0001 ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1106
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0001",
1107
 
                     new String[] {  });
1108
 
 
1109
 
    // ÷ 003A ÷ 000D ÷  #  ÷ [0.2] COLON (MidLetter) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1110
 
    assertAnalyzesTo(analyzer, "\u003A\r",
1111
 
                     new String[] {  });
1112
 
 
1113
 
    // ÷ 003A × 0308 ÷ 000D ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1114
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\r",
1115
 
                     new String[] {  });
1116
 
 
1117
 
    // ÷ 003A ÷ 000A ÷  #  ÷ [0.2] COLON (MidLetter) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
1118
 
    assertAnalyzesTo(analyzer, "\u003A\n",
1119
 
                     new String[] {  });
1120
 
 
1121
 
    // ÷ 003A × 0308 ÷ 000A ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
1122
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\n",
1123
 
                     new String[] {  });
1124
 
 
1125
 
    // ÷ 003A ÷ 000B ÷  #  ÷ [0.2] COLON (MidLetter) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
1126
 
    assertAnalyzesTo(analyzer, "\u003A\u000B",
1127
 
                     new String[] {  });
1128
 
 
1129
 
    // ÷ 003A × 0308 ÷ 000B ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
1130
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u000B",
1131
 
                     new String[] {  });
1132
 
 
1133
 
    // ÷ 003A ÷ 3031 ÷  #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
1134
 
    assertAnalyzesTo(analyzer, "\u003A\u3031",
1135
 
                     new String[] { "\u3031" });
1136
 
 
1137
 
    // ÷ 003A × 0308 ÷ 3031 ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
1138
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u3031",
1139
 
                     new String[] { "\u3031" });
1140
 
 
1141
 
    // ÷ 003A ÷ 0041 ÷  #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
1142
 
    assertAnalyzesTo(analyzer, "\u003A\u0041",
1143
 
                     new String[] { "\u0041" });
1144
 
 
1145
 
    // ÷ 003A × 0308 ÷ 0041 ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
1146
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0041",
1147
 
                     new String[] { "\u0041" });
1148
 
 
1149
 
    // ÷ 003A ÷ 003A ÷  #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1150
 
    assertAnalyzesTo(analyzer, "\u003A\u003A",
1151
 
                     new String[] {  });
1152
 
 
1153
 
    // ÷ 003A × 0308 ÷ 003A ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1154
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u003A",
1155
 
                     new String[] {  });
1156
 
 
1157
 
    // ÷ 003A ÷ 002C ÷  #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1158
 
    assertAnalyzesTo(analyzer, "\u003A\u002C",
1159
 
                     new String[] {  });
1160
 
 
1161
 
    // ÷ 003A × 0308 ÷ 002C ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1162
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u002C",
1163
 
                     new String[] {  });
1164
 
 
1165
 
    // ÷ 003A ÷ 0027 ÷  #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1166
 
    assertAnalyzesTo(analyzer, "\u003A\u0027",
1167
 
                     new String[] {  });
1168
 
 
1169
 
    // ÷ 003A × 0308 ÷ 0027 ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1170
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0027",
1171
 
                     new String[] {  });
1172
 
 
1173
 
    // ÷ 003A ÷ 0030 ÷  #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
1174
 
    assertAnalyzesTo(analyzer, "\u003A\u0030",
1175
 
                     new String[] { "\u0030" });
1176
 
 
1177
 
    // ÷ 003A × 0308 ÷ 0030 ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
1178
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0030",
1179
 
                     new String[] { "\u0030" });
1180
 
 
1181
 
    // ÷ 003A ÷ 005F ÷  #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
1182
 
    assertAnalyzesTo(analyzer, "\u003A\u005F",
1183
 
                     new String[] {  });
1184
 
 
1185
 
    // ÷ 003A × 0308 ÷ 005F ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
1186
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u005F",
1187
 
                     new String[] {  });
1188
 
 
1189
 
    // ÷ 003A × 00AD ÷  #  ÷ [0.2] COLON (MidLetter) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1190
 
    assertAnalyzesTo(analyzer, "\u003A\u00AD",
1191
 
                     new String[] {  });
1192
 
 
1193
 
    // ÷ 003A × 0308 × 00AD ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1194
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u00AD",
1195
 
                     new String[] {  });
1196
 
 
1197
 
    // ÷ 003A × 0300 ÷  #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1198
 
    assertAnalyzesTo(analyzer, "\u003A\u0300",
1199
 
                     new String[] {  });
1200
 
 
1201
 
    // ÷ 003A × 0308 × 0300 ÷   #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1202
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0300",
1203
 
                     new String[] {  });
1204
 
 
1205
 
    // ÷ 003A ÷ 0061 × 2060 ÷   #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1206
 
    assertAnalyzesTo(analyzer, "\u003A\u0061\u2060",
1207
 
                     new String[] { "\u0061\u2060" });
1208
 
 
1209
 
    // ÷ 003A × 0308 ÷ 0061 × 2060 ÷    #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1210
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0061\u2060",
1211
 
                     new String[] { "\u0061\u2060" });
1212
 
 
1213
 
    // ÷ 003A ÷ 0061 ÷ 003A ÷   #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1214
 
    assertAnalyzesTo(analyzer, "\u003A\u0061\u003A",
1215
 
                     new String[] { "\u0061" });
1216
 
 
1217
 
    // ÷ 003A × 0308 ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1218
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0061\u003A",
1219
 
                     new String[] { "\u0061" });
1220
 
 
1221
 
    // ÷ 003A ÷ 0061 ÷ 0027 ÷   #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1222
 
    assertAnalyzesTo(analyzer, "\u003A\u0061\u0027",
1223
 
                     new String[] { "\u0061" });
1224
 
 
1225
 
    // ÷ 003A × 0308 ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1226
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0061\u0027",
1227
 
                     new String[] { "\u0061" });
1228
 
 
1229
 
    // ÷ 003A ÷ 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1230
 
    assertAnalyzesTo(analyzer, "\u003A\u0061\u0027\u2060",
1231
 
                     new String[] { "\u0061" });
1232
 
 
1233
 
    // ÷ 003A × 0308 ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1234
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0061\u0027\u2060",
1235
 
                     new String[] { "\u0061" });
1236
 
 
1237
 
    // ÷ 003A ÷ 0061 ÷ 002C ÷   #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1238
 
    assertAnalyzesTo(analyzer, "\u003A\u0061\u002C",
1239
 
                     new String[] { "\u0061" });
1240
 
 
1241
 
    // ÷ 003A × 0308 ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1242
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0061\u002C",
1243
 
                     new String[] { "\u0061" });
1244
 
 
1245
 
    // ÷ 003A ÷ 0031 ÷ 003A ÷   #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1246
 
    assertAnalyzesTo(analyzer, "\u003A\u0031\u003A",
1247
 
                     new String[] { "\u0031" });
1248
 
 
1249
 
    // ÷ 003A × 0308 ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1250
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0031\u003A",
1251
 
                     new String[] { "\u0031" });
1252
 
 
1253
 
    // ÷ 003A ÷ 0031 ÷ 0027 ÷   #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1254
 
    assertAnalyzesTo(analyzer, "\u003A\u0031\u0027",
1255
 
                     new String[] { "\u0031" });
1256
 
 
1257
 
    // ÷ 003A × 0308 ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1258
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0031\u0027",
1259
 
                     new String[] { "\u0031" });
1260
 
 
1261
 
    // ÷ 003A ÷ 0031 ÷ 002C ÷   #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1262
 
    assertAnalyzesTo(analyzer, "\u003A\u0031\u002C",
1263
 
                     new String[] { "\u0031" });
1264
 
 
1265
 
    // ÷ 003A × 0308 ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1266
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0031\u002C",
1267
 
                     new String[] { "\u0031" });
1268
 
 
1269
 
    // ÷ 003A ÷ 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1270
 
    assertAnalyzesTo(analyzer, "\u003A\u0031\u002E\u2060",
1271
 
                     new String[] { "\u0031" });
1272
 
 
1273
 
    // ÷ 003A × 0308 ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1274
 
    assertAnalyzesTo(analyzer, "\u003A\u0308\u0031\u002E\u2060",
1275
 
                     new String[] { "\u0031" });
1276
 
 
1277
 
    // ÷ 002C ÷ 0001 ÷  #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1278
 
    assertAnalyzesTo(analyzer, "\u002C\u0001",
1279
 
                     new String[] {  });
1280
 
 
1281
 
    // ÷ 002C × 0308 ÷ 0001 ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1282
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0001",
1283
 
                     new String[] {  });
1284
 
 
1285
 
    // ÷ 002C ÷ 000D ÷  #  ÷ [0.2] COMMA (MidNum) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1286
 
    assertAnalyzesTo(analyzer, "\u002C\r",
1287
 
                     new String[] {  });
1288
 
 
1289
 
    // ÷ 002C × 0308 ÷ 000D ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1290
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\r",
1291
 
                     new String[] {  });
1292
 
 
1293
 
    // ÷ 002C ÷ 000A ÷  #  ÷ [0.2] COMMA (MidNum) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
1294
 
    assertAnalyzesTo(analyzer, "\u002C\n",
1295
 
                     new String[] {  });
1296
 
 
1297
 
    // ÷ 002C × 0308 ÷ 000A ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
1298
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\n",
1299
 
                     new String[] {  });
1300
 
 
1301
 
    // ÷ 002C ÷ 000B ÷  #  ÷ [0.2] COMMA (MidNum) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
1302
 
    assertAnalyzesTo(analyzer, "\u002C\u000B",
1303
 
                     new String[] {  });
1304
 
 
1305
 
    // ÷ 002C × 0308 ÷ 000B ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
1306
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u000B",
1307
 
                     new String[] {  });
1308
 
 
1309
 
    // ÷ 002C ÷ 3031 ÷  #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
1310
 
    assertAnalyzesTo(analyzer, "\u002C\u3031",
1311
 
                     new String[] { "\u3031" });
1312
 
 
1313
 
    // ÷ 002C × 0308 ÷ 3031 ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
1314
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u3031",
1315
 
                     new String[] { "\u3031" });
1316
 
 
1317
 
    // ÷ 002C ÷ 0041 ÷  #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
1318
 
    assertAnalyzesTo(analyzer, "\u002C\u0041",
1319
 
                     new String[] { "\u0041" });
1320
 
 
1321
 
    // ÷ 002C × 0308 ÷ 0041 ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
1322
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0041",
1323
 
                     new String[] { "\u0041" });
1324
 
 
1325
 
    // ÷ 002C ÷ 003A ÷  #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1326
 
    assertAnalyzesTo(analyzer, "\u002C\u003A",
1327
 
                     new String[] {  });
1328
 
 
1329
 
    // ÷ 002C × 0308 ÷ 003A ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1330
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u003A",
1331
 
                     new String[] {  });
1332
 
 
1333
 
    // ÷ 002C ÷ 002C ÷  #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1334
 
    assertAnalyzesTo(analyzer, "\u002C\u002C",
1335
 
                     new String[] {  });
1336
 
 
1337
 
    // ÷ 002C × 0308 ÷ 002C ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1338
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u002C",
1339
 
                     new String[] {  });
1340
 
 
1341
 
    // ÷ 002C ÷ 0027 ÷  #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1342
 
    assertAnalyzesTo(analyzer, "\u002C\u0027",
1343
 
                     new String[] {  });
1344
 
 
1345
 
    // ÷ 002C × 0308 ÷ 0027 ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1346
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0027",
1347
 
                     new String[] {  });
1348
 
 
1349
 
    // ÷ 002C ÷ 0030 ÷  #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
1350
 
    assertAnalyzesTo(analyzer, "\u002C\u0030",
1351
 
                     new String[] { "\u0030" });
1352
 
 
1353
 
    // ÷ 002C × 0308 ÷ 0030 ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
1354
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0030",
1355
 
                     new String[] { "\u0030" });
1356
 
 
1357
 
    // ÷ 002C ÷ 005F ÷  #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
1358
 
    assertAnalyzesTo(analyzer, "\u002C\u005F",
1359
 
                     new String[] {  });
1360
 
 
1361
 
    // ÷ 002C × 0308 ÷ 005F ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
1362
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u005F",
1363
 
                     new String[] {  });
1364
 
 
1365
 
    // ÷ 002C × 00AD ÷  #  ÷ [0.2] COMMA (MidNum) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1366
 
    assertAnalyzesTo(analyzer, "\u002C\u00AD",
1367
 
                     new String[] {  });
1368
 
 
1369
 
    // ÷ 002C × 0308 × 00AD ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1370
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u00AD",
1371
 
                     new String[] {  });
1372
 
 
1373
 
    // ÷ 002C × 0300 ÷  #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1374
 
    assertAnalyzesTo(analyzer, "\u002C\u0300",
1375
 
                     new String[] {  });
1376
 
 
1377
 
    // ÷ 002C × 0308 × 0300 ÷   #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1378
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0300",
1379
 
                     new String[] {  });
1380
 
 
1381
 
    // ÷ 002C ÷ 0061 × 2060 ÷   #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1382
 
    assertAnalyzesTo(analyzer, "\u002C\u0061\u2060",
1383
 
                     new String[] { "\u0061\u2060" });
1384
 
 
1385
 
    // ÷ 002C × 0308 ÷ 0061 × 2060 ÷    #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1386
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0061\u2060",
1387
 
                     new String[] { "\u0061\u2060" });
1388
 
 
1389
 
    // ÷ 002C ÷ 0061 ÷ 003A ÷   #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1390
 
    assertAnalyzesTo(analyzer, "\u002C\u0061\u003A",
1391
 
                     new String[] { "\u0061" });
1392
 
 
1393
 
    // ÷ 002C × 0308 ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1394
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0061\u003A",
1395
 
                     new String[] { "\u0061" });
1396
 
 
1397
 
    // ÷ 002C ÷ 0061 ÷ 0027 ÷   #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1398
 
    assertAnalyzesTo(analyzer, "\u002C\u0061\u0027",
1399
 
                     new String[] { "\u0061" });
1400
 
 
1401
 
    // ÷ 002C × 0308 ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1402
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0061\u0027",
1403
 
                     new String[] { "\u0061" });
1404
 
 
1405
 
    // ÷ 002C ÷ 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1406
 
    assertAnalyzesTo(analyzer, "\u002C\u0061\u0027\u2060",
1407
 
                     new String[] { "\u0061" });
1408
 
 
1409
 
    // ÷ 002C × 0308 ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1410
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0061\u0027\u2060",
1411
 
                     new String[] { "\u0061" });
1412
 
 
1413
 
    // ÷ 002C ÷ 0061 ÷ 002C ÷   #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1414
 
    assertAnalyzesTo(analyzer, "\u002C\u0061\u002C",
1415
 
                     new String[] { "\u0061" });
1416
 
 
1417
 
    // ÷ 002C × 0308 ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1418
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0061\u002C",
1419
 
                     new String[] { "\u0061" });
1420
 
 
1421
 
    // ÷ 002C ÷ 0031 ÷ 003A ÷   #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1422
 
    assertAnalyzesTo(analyzer, "\u002C\u0031\u003A",
1423
 
                     new String[] { "\u0031" });
1424
 
 
1425
 
    // ÷ 002C × 0308 ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1426
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0031\u003A",
1427
 
                     new String[] { "\u0031" });
1428
 
 
1429
 
    // ÷ 002C ÷ 0031 ÷ 0027 ÷   #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1430
 
    assertAnalyzesTo(analyzer, "\u002C\u0031\u0027",
1431
 
                     new String[] { "\u0031" });
1432
 
 
1433
 
    // ÷ 002C × 0308 ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1434
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0031\u0027",
1435
 
                     new String[] { "\u0031" });
1436
 
 
1437
 
    // ÷ 002C ÷ 0031 ÷ 002C ÷   #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1438
 
    assertAnalyzesTo(analyzer, "\u002C\u0031\u002C",
1439
 
                     new String[] { "\u0031" });
1440
 
 
1441
 
    // ÷ 002C × 0308 ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1442
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0031\u002C",
1443
 
                     new String[] { "\u0031" });
1444
 
 
1445
 
    // ÷ 002C ÷ 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1446
 
    assertAnalyzesTo(analyzer, "\u002C\u0031\u002E\u2060",
1447
 
                     new String[] { "\u0031" });
1448
 
 
1449
 
    // ÷ 002C × 0308 ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1450
 
    assertAnalyzesTo(analyzer, "\u002C\u0308\u0031\u002E\u2060",
1451
 
                     new String[] { "\u0031" });
1452
 
 
1453
 
    // ÷ 0027 ÷ 0001 ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1454
 
    assertAnalyzesTo(analyzer, "\u0027\u0001",
1455
 
                     new String[] {  });
1456
 
 
1457
 
    // ÷ 0027 × 0308 ÷ 0001 ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1458
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0001",
1459
 
                     new String[] {  });
1460
 
 
1461
 
    // ÷ 0027 ÷ 000D ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1462
 
    assertAnalyzesTo(analyzer, "\u0027\r",
1463
 
                     new String[] {  });
1464
 
 
1465
 
    // ÷ 0027 × 0308 ÷ 000D ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1466
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\r",
1467
 
                     new String[] {  });
1468
 
 
1469
 
    // ÷ 0027 ÷ 000A ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
1470
 
    assertAnalyzesTo(analyzer, "\u0027\n",
1471
 
                     new String[] {  });
1472
 
 
1473
 
    // ÷ 0027 × 0308 ÷ 000A ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
1474
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\n",
1475
 
                     new String[] {  });
1476
 
 
1477
 
    // ÷ 0027 ÷ 000B ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
1478
 
    assertAnalyzesTo(analyzer, "\u0027\u000B",
1479
 
                     new String[] {  });
1480
 
 
1481
 
    // ÷ 0027 × 0308 ÷ 000B ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
1482
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u000B",
1483
 
                     new String[] {  });
1484
 
 
1485
 
    // ÷ 0027 ÷ 3031 ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
1486
 
    assertAnalyzesTo(analyzer, "\u0027\u3031",
1487
 
                     new String[] { "\u3031" });
1488
 
 
1489
 
    // ÷ 0027 × 0308 ÷ 3031 ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
1490
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u3031",
1491
 
                     new String[] { "\u3031" });
1492
 
 
1493
 
    // ÷ 0027 ÷ 0041 ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
1494
 
    assertAnalyzesTo(analyzer, "\u0027\u0041",
1495
 
                     new String[] { "\u0041" });
1496
 
 
1497
 
    // ÷ 0027 × 0308 ÷ 0041 ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
1498
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0041",
1499
 
                     new String[] { "\u0041" });
1500
 
 
1501
 
    // ÷ 0027 ÷ 003A ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1502
 
    assertAnalyzesTo(analyzer, "\u0027\u003A",
1503
 
                     new String[] {  });
1504
 
 
1505
 
    // ÷ 0027 × 0308 ÷ 003A ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1506
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u003A",
1507
 
                     new String[] {  });
1508
 
 
1509
 
    // ÷ 0027 ÷ 002C ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1510
 
    assertAnalyzesTo(analyzer, "\u0027\u002C",
1511
 
                     new String[] {  });
1512
 
 
1513
 
    // ÷ 0027 × 0308 ÷ 002C ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1514
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u002C",
1515
 
                     new String[] {  });
1516
 
 
1517
 
    // ÷ 0027 ÷ 0027 ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1518
 
    assertAnalyzesTo(analyzer, "\u0027\u0027",
1519
 
                     new String[] {  });
1520
 
 
1521
 
    // ÷ 0027 × 0308 ÷ 0027 ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1522
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0027",
1523
 
                     new String[] {  });
1524
 
 
1525
 
    // ÷ 0027 ÷ 0030 ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
1526
 
    assertAnalyzesTo(analyzer, "\u0027\u0030",
1527
 
                     new String[] { "\u0030" });
1528
 
 
1529
 
    // ÷ 0027 × 0308 ÷ 0030 ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
1530
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0030",
1531
 
                     new String[] { "\u0030" });
1532
 
 
1533
 
    // ÷ 0027 ÷ 005F ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
1534
 
    assertAnalyzesTo(analyzer, "\u0027\u005F",
1535
 
                     new String[] {  });
1536
 
 
1537
 
    // ÷ 0027 × 0308 ÷ 005F ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
1538
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u005F",
1539
 
                     new String[] {  });
1540
 
 
1541
 
    // ÷ 0027 × 00AD ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1542
 
    assertAnalyzesTo(analyzer, "\u0027\u00AD",
1543
 
                     new String[] {  });
1544
 
 
1545
 
    // ÷ 0027 × 0308 × 00AD ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1546
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u00AD",
1547
 
                     new String[] {  });
1548
 
 
1549
 
    // ÷ 0027 × 0300 ÷  #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1550
 
    assertAnalyzesTo(analyzer, "\u0027\u0300",
1551
 
                     new String[] {  });
1552
 
 
1553
 
    // ÷ 0027 × 0308 × 0300 ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1554
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0300",
1555
 
                     new String[] {  });
1556
 
 
1557
 
    // ÷ 0027 ÷ 0061 × 2060 ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1558
 
    assertAnalyzesTo(analyzer, "\u0027\u0061\u2060",
1559
 
                     new String[] { "\u0061\u2060" });
1560
 
 
1561
 
    // ÷ 0027 × 0308 ÷ 0061 × 2060 ÷    #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1562
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0061\u2060",
1563
 
                     new String[] { "\u0061\u2060" });
1564
 
 
1565
 
    // ÷ 0027 ÷ 0061 ÷ 003A ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1566
 
    assertAnalyzesTo(analyzer, "\u0027\u0061\u003A",
1567
 
                     new String[] { "\u0061" });
1568
 
 
1569
 
    // ÷ 0027 × 0308 ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1570
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0061\u003A",
1571
 
                     new String[] { "\u0061" });
1572
 
 
1573
 
    // ÷ 0027 ÷ 0061 ÷ 0027 ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1574
 
    assertAnalyzesTo(analyzer, "\u0027\u0061\u0027",
1575
 
                     new String[] { "\u0061" });
1576
 
 
1577
 
    // ÷ 0027 × 0308 ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1578
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0061\u0027",
1579
 
                     new String[] { "\u0061" });
1580
 
 
1581
 
    // ÷ 0027 ÷ 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1582
 
    assertAnalyzesTo(analyzer, "\u0027\u0061\u0027\u2060",
1583
 
                     new String[] { "\u0061" });
1584
 
 
1585
 
    // ÷ 0027 × 0308 ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1586
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0061\u0027\u2060",
1587
 
                     new String[] { "\u0061" });
1588
 
 
1589
 
    // ÷ 0027 ÷ 0061 ÷ 002C ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1590
 
    assertAnalyzesTo(analyzer, "\u0027\u0061\u002C",
1591
 
                     new String[] { "\u0061" });
1592
 
 
1593
 
    // ÷ 0027 × 0308 ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1594
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0061\u002C",
1595
 
                     new String[] { "\u0061" });
1596
 
 
1597
 
    // ÷ 0027 ÷ 0031 ÷ 003A ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1598
 
    assertAnalyzesTo(analyzer, "\u0027\u0031\u003A",
1599
 
                     new String[] { "\u0031" });
1600
 
 
1601
 
    // ÷ 0027 × 0308 ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1602
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0031\u003A",
1603
 
                     new String[] { "\u0031" });
1604
 
 
1605
 
    // ÷ 0027 ÷ 0031 ÷ 0027 ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1606
 
    assertAnalyzesTo(analyzer, "\u0027\u0031\u0027",
1607
 
                     new String[] { "\u0031" });
1608
 
 
1609
 
    // ÷ 0027 × 0308 ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1610
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0031\u0027",
1611
 
                     new String[] { "\u0031" });
1612
 
 
1613
 
    // ÷ 0027 ÷ 0031 ÷ 002C ÷   #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1614
 
    assertAnalyzesTo(analyzer, "\u0027\u0031\u002C",
1615
 
                     new String[] { "\u0031" });
1616
 
 
1617
 
    // ÷ 0027 × 0308 ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1618
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0031\u002C",
1619
 
                     new String[] { "\u0031" });
1620
 
 
1621
 
    // ÷ 0027 ÷ 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] APOSTROPHE (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1622
 
    assertAnalyzesTo(analyzer, "\u0027\u0031\u002E\u2060",
1623
 
                     new String[] { "\u0031" });
1624
 
 
1625
 
    // ÷ 0027 × 0308 ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1626
 
    assertAnalyzesTo(analyzer, "\u0027\u0308\u0031\u002E\u2060",
1627
 
                     new String[] { "\u0031" });
1628
 
 
1629
 
    // ÷ 0030 ÷ 0001 ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1630
 
    assertAnalyzesTo(analyzer, "\u0030\u0001",
1631
 
                     new String[] { "\u0030" });
1632
 
 
1633
 
    // ÷ 0030 × 0308 ÷ 0001 ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1634
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0001",
1635
 
                     new String[] { "\u0030\u0308" });
1636
 
 
1637
 
    // ÷ 0030 ÷ 000D ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1638
 
    assertAnalyzesTo(analyzer, "\u0030\r",
1639
 
                     new String[] { "\u0030" });
1640
 
 
1641
 
    // ÷ 0030 × 0308 ÷ 000D ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1642
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\r",
1643
 
                     new String[] { "\u0030\u0308" });
1644
 
 
1645
 
    // ÷ 0030 ÷ 000A ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
1646
 
    assertAnalyzesTo(analyzer, "\u0030\n",
1647
 
                     new String[] { "\u0030" });
1648
 
 
1649
 
    // ÷ 0030 × 0308 ÷ 000A ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
1650
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\n",
1651
 
                     new String[] { "\u0030\u0308" });
1652
 
 
1653
 
    // ÷ 0030 ÷ 000B ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
1654
 
    assertAnalyzesTo(analyzer, "\u0030\u000B",
1655
 
                     new String[] { "\u0030" });
1656
 
 
1657
 
    // ÷ 0030 × 0308 ÷ 000B ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
1658
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u000B",
1659
 
                     new String[] { "\u0030\u0308" });
1660
 
 
1661
 
    // ÷ 0030 ÷ 3031 ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
1662
 
    assertAnalyzesTo(analyzer, "\u0030\u3031",
1663
 
                     new String[] { "\u0030", "\u3031" });
1664
 
 
1665
 
    // ÷ 0030 × 0308 ÷ 3031 ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
1666
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u3031",
1667
 
                     new String[] { "\u0030\u0308", "\u3031" });
1668
 
 
1669
 
    // ÷ 0030 × 0041 ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
1670
 
    assertAnalyzesTo(analyzer, "\u0030\u0041",
1671
 
                     new String[] { "\u0030\u0041" });
1672
 
 
1673
 
    // ÷ 0030 × 0308 × 0041 ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [10.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
1674
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0041",
1675
 
                     new String[] { "\u0030\u0308\u0041" });
1676
 
 
1677
 
    // ÷ 0030 ÷ 003A ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1678
 
    assertAnalyzesTo(analyzer, "\u0030\u003A",
1679
 
                     new String[] { "\u0030" });
1680
 
 
1681
 
    // ÷ 0030 × 0308 ÷ 003A ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1682
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u003A",
1683
 
                     new String[] { "\u0030\u0308" });
1684
 
 
1685
 
    // ÷ 0030 ÷ 002C ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1686
 
    assertAnalyzesTo(analyzer, "\u0030\u002C",
1687
 
                     new String[] { "\u0030" });
1688
 
 
1689
 
    // ÷ 0030 × 0308 ÷ 002C ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1690
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u002C",
1691
 
                     new String[] { "\u0030\u0308" });
1692
 
 
1693
 
    // ÷ 0030 ÷ 0027 ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1694
 
    assertAnalyzesTo(analyzer, "\u0030\u0027",
1695
 
                     new String[] { "\u0030" });
1696
 
 
1697
 
    // ÷ 0030 × 0308 ÷ 0027 ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1698
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0027",
1699
 
                     new String[] { "\u0030\u0308" });
1700
 
 
1701
 
    // ÷ 0030 × 0030 ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) × [8.0] DIGIT ZERO (Numeric) ÷ [0.3]
1702
 
    assertAnalyzesTo(analyzer, "\u0030\u0030",
1703
 
                     new String[] { "\u0030\u0030" });
1704
 
 
1705
 
    // ÷ 0030 × 0308 × 0030 ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [8.0] DIGIT ZERO (Numeric) ÷ [0.3]
1706
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0030",
1707
 
                     new String[] { "\u0030\u0308\u0030" });
1708
 
 
1709
 
    // ÷ 0030 × 005F ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]
1710
 
    assertAnalyzesTo(analyzer, "\u0030\u005F",
1711
 
                     new String[] { "\u0030\u005F" });
1712
 
 
1713
 
    // ÷ 0030 × 0308 × 005F ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]
1714
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u005F",
1715
 
                     new String[] { "\u0030\u0308\u005F" });
1716
 
 
1717
 
    // ÷ 0030 × 00AD ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1718
 
    assertAnalyzesTo(analyzer, "\u0030\u00AD",
1719
 
                     new String[] { "\u0030\u00AD" });
1720
 
 
1721
 
    // ÷ 0030 × 0308 × 00AD ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1722
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u00AD",
1723
 
                     new String[] { "\u0030\u0308\u00AD" });
1724
 
 
1725
 
    // ÷ 0030 × 0300 ÷  #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1726
 
    assertAnalyzesTo(analyzer, "\u0030\u0300",
1727
 
                     new String[] { "\u0030\u0300" });
1728
 
 
1729
 
    // ÷ 0030 × 0308 × 0300 ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1730
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0300",
1731
 
                     new String[] { "\u0030\u0308\u0300" });
1732
 
 
1733
 
    // ÷ 0030 × 0061 × 2060 ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1734
 
    assertAnalyzesTo(analyzer, "\u0030\u0061\u2060",
1735
 
                     new String[] { "\u0030\u0061\u2060" });
1736
 
 
1737
 
    // ÷ 0030 × 0308 × 0061 × 2060 ÷    #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [10.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1738
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0061\u2060",
1739
 
                     new String[] { "\u0030\u0308\u0061\u2060" });
1740
 
 
1741
 
    // ÷ 0030 × 0061 ÷ 003A ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1742
 
    assertAnalyzesTo(analyzer, "\u0030\u0061\u003A",
1743
 
                     new String[] { "\u0030\u0061" });
1744
 
 
1745
 
    // ÷ 0030 × 0308 × 0061 ÷ 003A ÷    #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [10.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1746
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0061\u003A",
1747
 
                     new String[] { "\u0030\u0308\u0061" });
1748
 
 
1749
 
    // ÷ 0030 × 0061 ÷ 0027 ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1750
 
    assertAnalyzesTo(analyzer, "\u0030\u0061\u0027",
1751
 
                     new String[] { "\u0030\u0061" });
1752
 
 
1753
 
    // ÷ 0030 × 0308 × 0061 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [10.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1754
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0061\u0027",
1755
 
                     new String[] { "\u0030\u0308\u0061" });
1756
 
 
1757
 
    // ÷ 0030 × 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1758
 
    assertAnalyzesTo(analyzer, "\u0030\u0061\u0027\u2060",
1759
 
                     new String[] { "\u0030\u0061" });
1760
 
 
1761
 
    // ÷ 0030 × 0308 × 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [10.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1762
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0061\u0027\u2060",
1763
 
                     new String[] { "\u0030\u0308\u0061" });
1764
 
 
1765
 
    // ÷ 0030 × 0061 ÷ 002C ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [10.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1766
 
    assertAnalyzesTo(analyzer, "\u0030\u0061\u002C",
1767
 
                     new String[] { "\u0030\u0061" });
1768
 
 
1769
 
    // ÷ 0030 × 0308 × 0061 ÷ 002C ÷    #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [10.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1770
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0061\u002C",
1771
 
                     new String[] { "\u0030\u0308\u0061" });
1772
 
 
1773
 
    // ÷ 0030 × 0031 ÷ 003A ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1774
 
    assertAnalyzesTo(analyzer, "\u0030\u0031\u003A",
1775
 
                     new String[] { "\u0030\u0031" });
1776
 
 
1777
 
    // ÷ 0030 × 0308 × 0031 ÷ 003A ÷    #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1778
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0031\u003A",
1779
 
                     new String[] { "\u0030\u0308\u0031" });
1780
 
 
1781
 
    // ÷ 0030 × 0031 ÷ 0027 ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1782
 
    assertAnalyzesTo(analyzer, "\u0030\u0031\u0027",
1783
 
                     new String[] { "\u0030\u0031" });
1784
 
 
1785
 
    // ÷ 0030 × 0308 × 0031 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1786
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0031\u0027",
1787
 
                     new String[] { "\u0030\u0308\u0031" });
1788
 
 
1789
 
    // ÷ 0030 × 0031 ÷ 002C ÷   #  ÷ [0.2] DIGIT ZERO (Numeric) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1790
 
    assertAnalyzesTo(analyzer, "\u0030\u0031\u002C",
1791
 
                     new String[] { "\u0030\u0031" });
1792
 
 
1793
 
    // ÷ 0030 × 0308 × 0031 ÷ 002C ÷    #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1794
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0031\u002C",
1795
 
                     new String[] { "\u0030\u0308\u0031" });
1796
 
 
1797
 
    // ÷ 0030 × 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] DIGIT ZERO (Numeric) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1798
 
    assertAnalyzesTo(analyzer, "\u0030\u0031\u002E\u2060",
1799
 
                     new String[] { "\u0030\u0031" });
1800
 
 
1801
 
    // ÷ 0030 × 0308 × 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] DIGIT ZERO (Numeric) × [4.0] COMBINING DIAERESIS (Extend_FE) × [8.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1802
 
    assertAnalyzesTo(analyzer, "\u0030\u0308\u0031\u002E\u2060",
1803
 
                     new String[] { "\u0030\u0308\u0031" });
1804
 
 
1805
 
    // ÷ 005F ÷ 0001 ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1806
 
    assertAnalyzesTo(analyzer, "\u005F\u0001",
1807
 
                     new String[] {  });
1808
 
 
1809
 
    // ÷ 005F × 0308 ÷ 0001 ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1810
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0001",
1811
 
                     new String[] {  });
1812
 
 
1813
 
    // ÷ 005F ÷ 000D ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1814
 
    assertAnalyzesTo(analyzer, "\u005F\r",
1815
 
                     new String[] {  });
1816
 
 
1817
 
    // ÷ 005F × 0308 ÷ 000D ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1818
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\r",
1819
 
                     new String[] {  });
1820
 
 
1821
 
    // ÷ 005F ÷ 000A ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
1822
 
    assertAnalyzesTo(analyzer, "\u005F\n",
1823
 
                     new String[] {  });
1824
 
 
1825
 
    // ÷ 005F × 0308 ÷ 000A ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
1826
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\n",
1827
 
                     new String[] {  });
1828
 
 
1829
 
    // ÷ 005F ÷ 000B ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
1830
 
    assertAnalyzesTo(analyzer, "\u005F\u000B",
1831
 
                     new String[] {  });
1832
 
 
1833
 
    // ÷ 005F × 0308 ÷ 000B ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
1834
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u000B",
1835
 
                     new String[] {  });
1836
 
 
1837
 
    // ÷ 005F × 3031 ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
1838
 
    assertAnalyzesTo(analyzer, "\u005F\u3031",
1839
 
                     new String[] { "\u005F\u3031" });
1840
 
 
1841
 
    // ÷ 005F × 0308 × 3031 ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
1842
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u3031",
1843
 
                     new String[] { "\u005F\u0308\u3031" });
1844
 
 
1845
 
    // ÷ 005F × 0041 ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
1846
 
    assertAnalyzesTo(analyzer, "\u005F\u0041",
1847
 
                     new String[] { "\u005F\u0041" });
1848
 
 
1849
 
    // ÷ 005F × 0308 × 0041 ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
1850
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0041",
1851
 
                     new String[] { "\u005F\u0308\u0041" });
1852
 
 
1853
 
    // ÷ 005F ÷ 003A ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1854
 
    assertAnalyzesTo(analyzer, "\u005F\u003A",
1855
 
                     new String[] {  });
1856
 
 
1857
 
    // ÷ 005F × 0308 ÷ 003A ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1858
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u003A",
1859
 
                     new String[] {  });
1860
 
 
1861
 
    // ÷ 005F ÷ 002C ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1862
 
    assertAnalyzesTo(analyzer, "\u005F\u002C",
1863
 
                     new String[] {  });
1864
 
 
1865
 
    // ÷ 005F × 0308 ÷ 002C ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1866
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u002C",
1867
 
                     new String[] {  });
1868
 
 
1869
 
    // ÷ 005F ÷ 0027 ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1870
 
    assertAnalyzesTo(analyzer, "\u005F\u0027",
1871
 
                     new String[] {  });
1872
 
 
1873
 
    // ÷ 005F × 0308 ÷ 0027 ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1874
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0027",
1875
 
                     new String[] {  });
1876
 
 
1877
 
    // ÷ 005F × 0030 ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] DIGIT ZERO (Numeric) ÷ [0.3]
1878
 
    assertAnalyzesTo(analyzer, "\u005F\u0030",
1879
 
                     new String[] { "\u005F\u0030" });
1880
 
 
1881
 
    // ÷ 005F × 0308 × 0030 ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] DIGIT ZERO (Numeric) ÷ [0.3]
1882
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0030",
1883
 
                     new String[] { "\u005F\u0308\u0030" });
1884
 
 
1885
 
    // ÷ 005F × 005F ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]
1886
 
    assertAnalyzesTo(analyzer, "\u005F\u005F",
1887
 
                     new String[] {  });
1888
 
 
1889
 
    // ÷ 005F × 0308 × 005F ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]
1890
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u005F",
1891
 
                     new String[] {  });
1892
 
 
1893
 
    // ÷ 005F × 00AD ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1894
 
    assertAnalyzesTo(analyzer, "\u005F\u00AD",
1895
 
                     new String[] {  });
1896
 
 
1897
 
    // ÷ 005F × 0308 × 00AD ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
1898
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u00AD",
1899
 
                     new String[] {  });
1900
 
 
1901
 
    // ÷ 005F × 0300 ÷  #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1902
 
    assertAnalyzesTo(analyzer, "\u005F\u0300",
1903
 
                     new String[] {  });
1904
 
 
1905
 
    // ÷ 005F × 0308 × 0300 ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
1906
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0300",
1907
 
                     new String[] {  });
1908
 
 
1909
 
    // ÷ 005F × 0061 × 2060 ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1910
 
    assertAnalyzesTo(analyzer, "\u005F\u0061\u2060",
1911
 
                     new String[] { "\u005F\u0061\u2060" });
1912
 
 
1913
 
    // ÷ 005F × 0308 × 0061 × 2060 ÷    #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1914
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0061\u2060",
1915
 
                     new String[] { "\u005F\u0308\u0061\u2060" });
1916
 
 
1917
 
    // ÷ 005F × 0061 ÷ 003A ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1918
 
    assertAnalyzesTo(analyzer, "\u005F\u0061\u003A",
1919
 
                     new String[] { "\u005F\u0061" });
1920
 
 
1921
 
    // ÷ 005F × 0308 × 0061 ÷ 003A ÷    #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1922
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0061\u003A",
1923
 
                     new String[] { "\u005F\u0308\u0061" });
1924
 
 
1925
 
    // ÷ 005F × 0061 ÷ 0027 ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1926
 
    assertAnalyzesTo(analyzer, "\u005F\u0061\u0027",
1927
 
                     new String[] { "\u005F\u0061" });
1928
 
 
1929
 
    // ÷ 005F × 0308 × 0061 ÷ 0027 ÷    #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1930
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0061\u0027",
1931
 
                     new String[] { "\u005F\u0308\u0061" });
1932
 
 
1933
 
    // ÷ 005F × 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1934
 
    assertAnalyzesTo(analyzer, "\u005F\u0061\u0027\u2060",
1935
 
                     new String[] { "\u005F\u0061" });
1936
 
 
1937
 
    // ÷ 005F × 0308 × 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1938
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0061\u0027\u2060",
1939
 
                     new String[] { "\u005F\u0308\u0061" });
1940
 
 
1941
 
    // ÷ 005F × 0061 ÷ 002C ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1942
 
    assertAnalyzesTo(analyzer, "\u005F\u0061\u002C",
1943
 
                     new String[] { "\u005F\u0061" });
1944
 
 
1945
 
    // ÷ 005F × 0308 × 0061 ÷ 002C ÷    #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1946
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0061\u002C",
1947
 
                     new String[] { "\u005F\u0308\u0061" });
1948
 
 
1949
 
    // ÷ 005F × 0031 ÷ 003A ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1950
 
    assertAnalyzesTo(analyzer, "\u005F\u0031\u003A",
1951
 
                     new String[] { "\u005F\u0031" });
1952
 
 
1953
 
    // ÷ 005F × 0308 × 0031 ÷ 003A ÷    #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
1954
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0031\u003A",
1955
 
                     new String[] { "\u005F\u0308\u0031" });
1956
 
 
1957
 
    // ÷ 005F × 0031 ÷ 0027 ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1958
 
    assertAnalyzesTo(analyzer, "\u005F\u0031\u0027",
1959
 
                     new String[] { "\u005F\u0031" });
1960
 
 
1961
 
    // ÷ 005F × 0308 × 0031 ÷ 0027 ÷    #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
1962
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0031\u0027",
1963
 
                     new String[] { "\u005F\u0308\u0031" });
1964
 
 
1965
 
    // ÷ 005F × 0031 ÷ 002C ÷   #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1966
 
    assertAnalyzesTo(analyzer, "\u005F\u0031\u002C",
1967
 
                     new String[] { "\u005F\u0031" });
1968
 
 
1969
 
    // ÷ 005F × 0308 × 0031 ÷ 002C ÷    #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
1970
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0031\u002C",
1971
 
                     new String[] { "\u005F\u0308\u0031" });
1972
 
 
1973
 
    // ÷ 005F × 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] LOW LINE (ExtendNumLet) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1974
 
    assertAnalyzesTo(analyzer, "\u005F\u0031\u002E\u2060",
1975
 
                     new String[] { "\u005F\u0031" });
1976
 
 
1977
 
    // ÷ 005F × 0308 × 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] LOW LINE (ExtendNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
1978
 
    assertAnalyzesTo(analyzer, "\u005F\u0308\u0031\u002E\u2060",
1979
 
                     new String[] { "\u005F\u0308\u0031" });
1980
 
 
1981
 
    // ÷ 00AD ÷ 0001 ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1982
 
    assertAnalyzesTo(analyzer, "\u00AD\u0001",
1983
 
                     new String[] {  });
1984
 
 
1985
 
    // ÷ 00AD × 0308 ÷ 0001 ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
1986
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0001",
1987
 
                     new String[] {  });
1988
 
 
1989
 
    // ÷ 00AD ÷ 000D ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1990
 
    assertAnalyzesTo(analyzer, "\u00AD\r",
1991
 
                     new String[] {  });
1992
 
 
1993
 
    // ÷ 00AD × 0308 ÷ 000D ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
1994
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\r",
1995
 
                     new String[] {  });
1996
 
 
1997
 
    // ÷ 00AD ÷ 000A ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
1998
 
    assertAnalyzesTo(analyzer, "\u00AD\n",
1999
 
                     new String[] {  });
2000
 
 
2001
 
    // ÷ 00AD × 0308 ÷ 000A ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
2002
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\n",
2003
 
                     new String[] {  });
2004
 
 
2005
 
    // ÷ 00AD ÷ 000B ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2006
 
    assertAnalyzesTo(analyzer, "\u00AD\u000B",
2007
 
                     new String[] {  });
2008
 
 
2009
 
    // ÷ 00AD × 0308 ÷ 000B ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2010
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u000B",
2011
 
                     new String[] {  });
2012
 
 
2013
 
    // ÷ 00AD ÷ 3031 ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2014
 
    assertAnalyzesTo(analyzer, "\u00AD\u3031",
2015
 
                     new String[] { "\u3031" });
2016
 
 
2017
 
    // ÷ 00AD × 0308 ÷ 3031 ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2018
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u3031",
2019
 
                     new String[] { "\u3031" });
2020
 
 
2021
 
    // ÷ 00AD ÷ 0041 ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2022
 
    assertAnalyzesTo(analyzer, "\u00AD\u0041",
2023
 
                     new String[] { "\u0041" });
2024
 
 
2025
 
    // ÷ 00AD × 0308 ÷ 0041 ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2026
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0041",
2027
 
                     new String[] { "\u0041" });
2028
 
 
2029
 
    // ÷ 00AD ÷ 003A ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2030
 
    assertAnalyzesTo(analyzer, "\u00AD\u003A",
2031
 
                     new String[] {  });
2032
 
 
2033
 
    // ÷ 00AD × 0308 ÷ 003A ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2034
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u003A",
2035
 
                     new String[] {  });
2036
 
 
2037
 
    // ÷ 00AD ÷ 002C ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2038
 
    assertAnalyzesTo(analyzer, "\u00AD\u002C",
2039
 
                     new String[] {  });
2040
 
 
2041
 
    // ÷ 00AD × 0308 ÷ 002C ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2042
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u002C",
2043
 
                     new String[] {  });
2044
 
 
2045
 
    // ÷ 00AD ÷ 0027 ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2046
 
    assertAnalyzesTo(analyzer, "\u00AD\u0027",
2047
 
                     new String[] {  });
2048
 
 
2049
 
    // ÷ 00AD × 0308 ÷ 0027 ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2050
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0027",
2051
 
                     new String[] {  });
2052
 
 
2053
 
    // ÷ 00AD ÷ 0030 ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
2054
 
    assertAnalyzesTo(analyzer, "\u00AD\u0030",
2055
 
                     new String[] { "\u0030" });
2056
 
 
2057
 
    // ÷ 00AD × 0308 ÷ 0030 ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
2058
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0030",
2059
 
                     new String[] { "\u0030" });
2060
 
 
2061
 
    // ÷ 00AD ÷ 005F ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
2062
 
    assertAnalyzesTo(analyzer, "\u00AD\u005F",
2063
 
                     new String[] {  });
2064
 
 
2065
 
    // ÷ 00AD × 0308 ÷ 005F ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
2066
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u005F",
2067
 
                     new String[] {  });
2068
 
 
2069
 
    // ÷ 00AD × 00AD ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2070
 
    assertAnalyzesTo(analyzer, "\u00AD\u00AD",
2071
 
                     new String[] {  });
2072
 
 
2073
 
    // ÷ 00AD × 0308 × 00AD ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2074
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u00AD",
2075
 
                     new String[] {  });
2076
 
 
2077
 
    // ÷ 00AD × 0300 ÷  #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2078
 
    assertAnalyzesTo(analyzer, "\u00AD\u0300",
2079
 
                     new String[] {  });
2080
 
 
2081
 
    // ÷ 00AD × 0308 × 0300 ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2082
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0300",
2083
 
                     new String[] {  });
2084
 
 
2085
 
    // ÷ 00AD ÷ 0061 × 2060 ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2086
 
    assertAnalyzesTo(analyzer, "\u00AD\u0061\u2060",
2087
 
                     new String[] { "\u0061\u2060" });
2088
 
 
2089
 
    // ÷ 00AD × 0308 ÷ 0061 × 2060 ÷    #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2090
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0061\u2060",
2091
 
                     new String[] { "\u0061\u2060" });
2092
 
 
2093
 
    // ÷ 00AD ÷ 0061 ÷ 003A ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2094
 
    assertAnalyzesTo(analyzer, "\u00AD\u0061\u003A",
2095
 
                     new String[] { "\u0061" });
2096
 
 
2097
 
    // ÷ 00AD × 0308 ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2098
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0061\u003A",
2099
 
                     new String[] { "\u0061" });
2100
 
 
2101
 
    // ÷ 00AD ÷ 0061 ÷ 0027 ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2102
 
    assertAnalyzesTo(analyzer, "\u00AD\u0061\u0027",
2103
 
                     new String[] { "\u0061" });
2104
 
 
2105
 
    // ÷ 00AD × 0308 ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2106
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0061\u0027",
2107
 
                     new String[] { "\u0061" });
2108
 
 
2109
 
    // ÷ 00AD ÷ 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2110
 
    assertAnalyzesTo(analyzer, "\u00AD\u0061\u0027\u2060",
2111
 
                     new String[] { "\u0061" });
2112
 
 
2113
 
    // ÷ 00AD × 0308 ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2114
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0061\u0027\u2060",
2115
 
                     new String[] { "\u0061" });
2116
 
 
2117
 
    // ÷ 00AD ÷ 0061 ÷ 002C ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2118
 
    assertAnalyzesTo(analyzer, "\u00AD\u0061\u002C",
2119
 
                     new String[] { "\u0061" });
2120
 
 
2121
 
    // ÷ 00AD × 0308 ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2122
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0061\u002C",
2123
 
                     new String[] { "\u0061" });
2124
 
 
2125
 
    // ÷ 00AD ÷ 0031 ÷ 003A ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2126
 
    assertAnalyzesTo(analyzer, "\u00AD\u0031\u003A",
2127
 
                     new String[] { "\u0031" });
2128
 
 
2129
 
    // ÷ 00AD × 0308 ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2130
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0031\u003A",
2131
 
                     new String[] { "\u0031" });
2132
 
 
2133
 
    // ÷ 00AD ÷ 0031 ÷ 0027 ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2134
 
    assertAnalyzesTo(analyzer, "\u00AD\u0031\u0027",
2135
 
                     new String[] { "\u0031" });
2136
 
 
2137
 
    // ÷ 00AD × 0308 ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2138
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0031\u0027",
2139
 
                     new String[] { "\u0031" });
2140
 
 
2141
 
    // ÷ 00AD ÷ 0031 ÷ 002C ÷   #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2142
 
    assertAnalyzesTo(analyzer, "\u00AD\u0031\u002C",
2143
 
                     new String[] { "\u0031" });
2144
 
 
2145
 
    // ÷ 00AD × 0308 ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2146
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0031\u002C",
2147
 
                     new String[] { "\u0031" });
2148
 
 
2149
 
    // ÷ 00AD ÷ 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2150
 
    assertAnalyzesTo(analyzer, "\u00AD\u0031\u002E\u2060",
2151
 
                     new String[] { "\u0031" });
2152
 
 
2153
 
    // ÷ 00AD × 0308 ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2154
 
    assertAnalyzesTo(analyzer, "\u00AD\u0308\u0031\u002E\u2060",
2155
 
                     new String[] { "\u0031" });
2156
 
 
2157
 
    // ÷ 0300 ÷ 0001 ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
2158
 
    assertAnalyzesTo(analyzer, "\u0300\u0001",
2159
 
                     new String[] {  });
2160
 
 
2161
 
    // ÷ 0300 × 0308 ÷ 0001 ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
2162
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0001",
2163
 
                     new String[] {  });
2164
 
 
2165
 
    // ÷ 0300 ÷ 000D ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
2166
 
    assertAnalyzesTo(analyzer, "\u0300\r",
2167
 
                     new String[] {  });
2168
 
 
2169
 
    // ÷ 0300 × 0308 ÷ 000D ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
2170
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\r",
2171
 
                     new String[] {  });
2172
 
 
2173
 
    // ÷ 0300 ÷ 000A ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
2174
 
    assertAnalyzesTo(analyzer, "\u0300\n",
2175
 
                     new String[] {  });
2176
 
 
2177
 
    // ÷ 0300 × 0308 ÷ 000A ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
2178
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\n",
2179
 
                     new String[] {  });
2180
 
 
2181
 
    // ÷ 0300 ÷ 000B ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2182
 
    assertAnalyzesTo(analyzer, "\u0300\u000B",
2183
 
                     new String[] {  });
2184
 
 
2185
 
    // ÷ 0300 × 0308 ÷ 000B ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2186
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u000B",
2187
 
                     new String[] {  });
2188
 
 
2189
 
    // ÷ 0300 ÷ 3031 ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2190
 
    assertAnalyzesTo(analyzer, "\u0300\u3031",
2191
 
                     new String[] { "\u3031" });
2192
 
 
2193
 
    // ÷ 0300 × 0308 ÷ 3031 ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2194
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u3031",
2195
 
                     new String[] { "\u3031" });
2196
 
 
2197
 
    // ÷ 0300 ÷ 0041 ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2198
 
    assertAnalyzesTo(analyzer, "\u0300\u0041",
2199
 
                     new String[] { "\u0041" });
2200
 
 
2201
 
    // ÷ 0300 × 0308 ÷ 0041 ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2202
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0041",
2203
 
                     new String[] { "\u0041" });
2204
 
 
2205
 
    // ÷ 0300 ÷ 003A ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2206
 
    assertAnalyzesTo(analyzer, "\u0300\u003A",
2207
 
                     new String[] {  });
2208
 
 
2209
 
    // ÷ 0300 × 0308 ÷ 003A ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2210
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u003A",
2211
 
                     new String[] {  });
2212
 
 
2213
 
    // ÷ 0300 ÷ 002C ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2214
 
    assertAnalyzesTo(analyzer, "\u0300\u002C",
2215
 
                     new String[] {  });
2216
 
 
2217
 
    // ÷ 0300 × 0308 ÷ 002C ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2218
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u002C",
2219
 
                     new String[] {  });
2220
 
 
2221
 
    // ÷ 0300 ÷ 0027 ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2222
 
    assertAnalyzesTo(analyzer, "\u0300\u0027",
2223
 
                     new String[] {  });
2224
 
 
2225
 
    // ÷ 0300 × 0308 ÷ 0027 ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2226
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0027",
2227
 
                     new String[] {  });
2228
 
 
2229
 
    // ÷ 0300 ÷ 0030 ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
2230
 
    assertAnalyzesTo(analyzer, "\u0300\u0030",
2231
 
                     new String[] { "\u0030" });
2232
 
 
2233
 
    // ÷ 0300 × 0308 ÷ 0030 ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
2234
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0030",
2235
 
                     new String[] { "\u0030" });
2236
 
 
2237
 
    // ÷ 0300 ÷ 005F ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
2238
 
    assertAnalyzesTo(analyzer, "\u0300\u005F",
2239
 
                     new String[] {  });
2240
 
 
2241
 
    // ÷ 0300 × 0308 ÷ 005F ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
2242
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u005F",
2243
 
                     new String[] {  });
2244
 
 
2245
 
    // ÷ 0300 × 00AD ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2246
 
    assertAnalyzesTo(analyzer, "\u0300\u00AD",
2247
 
                     new String[] {  });
2248
 
 
2249
 
    // ÷ 0300 × 0308 × 00AD ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2250
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u00AD",
2251
 
                     new String[] {  });
2252
 
 
2253
 
    // ÷ 0300 × 0300 ÷  #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2254
 
    assertAnalyzesTo(analyzer, "\u0300\u0300",
2255
 
                     new String[] {  });
2256
 
 
2257
 
    // ÷ 0300 × 0308 × 0300 ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2258
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0300",
2259
 
                     new String[] {  });
2260
 
 
2261
 
    // ÷ 0300 ÷ 0061 × 2060 ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2262
 
    assertAnalyzesTo(analyzer, "\u0300\u0061\u2060",
2263
 
                     new String[] { "\u0061\u2060" });
2264
 
 
2265
 
    // ÷ 0300 × 0308 ÷ 0061 × 2060 ÷    #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2266
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0061\u2060",
2267
 
                     new String[] { "\u0061\u2060" });
2268
 
 
2269
 
    // ÷ 0300 ÷ 0061 ÷ 003A ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2270
 
    assertAnalyzesTo(analyzer, "\u0300\u0061\u003A",
2271
 
                     new String[] { "\u0061" });
2272
 
 
2273
 
    // ÷ 0300 × 0308 ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2274
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0061\u003A",
2275
 
                     new String[] { "\u0061" });
2276
 
 
2277
 
    // ÷ 0300 ÷ 0061 ÷ 0027 ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2278
 
    assertAnalyzesTo(analyzer, "\u0300\u0061\u0027",
2279
 
                     new String[] { "\u0061" });
2280
 
 
2281
 
    // ÷ 0300 × 0308 ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2282
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0061\u0027",
2283
 
                     new String[] { "\u0061" });
2284
 
 
2285
 
    // ÷ 0300 ÷ 0061 ÷ 0027 × 2060 ÷    #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2286
 
    assertAnalyzesTo(analyzer, "\u0300\u0061\u0027\u2060",
2287
 
                     new String[] { "\u0061" });
2288
 
 
2289
 
    // ÷ 0300 × 0308 ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2290
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0061\u0027\u2060",
2291
 
                     new String[] { "\u0061" });
2292
 
 
2293
 
    // ÷ 0300 ÷ 0061 ÷ 002C ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2294
 
    assertAnalyzesTo(analyzer, "\u0300\u0061\u002C",
2295
 
                     new String[] { "\u0061" });
2296
 
 
2297
 
    // ÷ 0300 × 0308 ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2298
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0061\u002C",
2299
 
                     new String[] { "\u0061" });
2300
 
 
2301
 
    // ÷ 0300 ÷ 0031 ÷ 003A ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2302
 
    assertAnalyzesTo(analyzer, "\u0300\u0031\u003A",
2303
 
                     new String[] { "\u0031" });
2304
 
 
2305
 
    // ÷ 0300 × 0308 ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2306
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0031\u003A",
2307
 
                     new String[] { "\u0031" });
2308
 
 
2309
 
    // ÷ 0300 ÷ 0031 ÷ 0027 ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2310
 
    assertAnalyzesTo(analyzer, "\u0300\u0031\u0027",
2311
 
                     new String[] { "\u0031" });
2312
 
 
2313
 
    // ÷ 0300 × 0308 ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2314
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0031\u0027",
2315
 
                     new String[] { "\u0031" });
2316
 
 
2317
 
    // ÷ 0300 ÷ 0031 ÷ 002C ÷   #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2318
 
    assertAnalyzesTo(analyzer, "\u0300\u0031\u002C",
2319
 
                     new String[] { "\u0031" });
2320
 
 
2321
 
    // ÷ 0300 × 0308 ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2322
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0031\u002C",
2323
 
                     new String[] { "\u0031" });
2324
 
 
2325
 
    // ÷ 0300 ÷ 0031 ÷ 002E × 2060 ÷    #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2326
 
    assertAnalyzesTo(analyzer, "\u0300\u0031\u002E\u2060",
2327
 
                     new String[] { "\u0031" });
2328
 
 
2329
 
    // ÷ 0300 × 0308 ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] COMBINING GRAVE ACCENT (Extend_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2330
 
    assertAnalyzesTo(analyzer, "\u0300\u0308\u0031\u002E\u2060",
2331
 
                     new String[] { "\u0031" });
2332
 
 
2333
 
    // ÷ 0061 × 2060 ÷ 0001 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
2334
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0001",
2335
 
                     new String[] { "\u0061\u2060" });
2336
 
 
2337
 
    // ÷ 0061 × 2060 × 0308 ÷ 0001 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
2338
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0001",
2339
 
                     new String[] { "\u0061\u2060\u0308" });
2340
 
 
2341
 
    // ÷ 0061 × 2060 ÷ 000D ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
2342
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\r",
2343
 
                     new String[] { "\u0061\u2060" });
2344
 
 
2345
 
    // ÷ 0061 × 2060 × 0308 ÷ 000D ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
2346
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\r",
2347
 
                     new String[] { "\u0061\u2060\u0308" });
2348
 
 
2349
 
    // ÷ 0061 × 2060 ÷ 000A ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
2350
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\n",
2351
 
                     new String[] { "\u0061\u2060" });
2352
 
 
2353
 
    // ÷ 0061 × 2060 × 0308 ÷ 000A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
2354
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\n",
2355
 
                     new String[] { "\u0061\u2060\u0308" });
2356
 
 
2357
 
    // ÷ 0061 × 2060 ÷ 000B ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2358
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u000B",
2359
 
                     new String[] { "\u0061\u2060" });
2360
 
 
2361
 
    // ÷ 0061 × 2060 × 0308 ÷ 000B ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2362
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u000B",
2363
 
                     new String[] { "\u0061\u2060\u0308" });
2364
 
 
2365
 
    // ÷ 0061 × 2060 ÷ 3031 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2366
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u3031",
2367
 
                     new String[] { "\u0061\u2060", "\u3031" });
2368
 
 
2369
 
    // ÷ 0061 × 2060 × 0308 ÷ 3031 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2370
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u3031",
2371
 
                     new String[] { "\u0061\u2060\u0308", "\u3031" });
2372
 
 
2373
 
    // ÷ 0061 × 2060 × 0041 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2374
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0041",
2375
 
                     new String[] { "\u0061\u2060\u0041" });
2376
 
 
2377
 
    // ÷ 0061 × 2060 × 0308 × 0041 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2378
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0041",
2379
 
                     new String[] { "\u0061\u2060\u0308\u0041" });
2380
 
 
2381
 
    // ÷ 0061 × 2060 ÷ 003A ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2382
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u003A",
2383
 
                     new String[] { "\u0061\u2060" });
2384
 
 
2385
 
    // ÷ 0061 × 2060 × 0308 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2386
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u003A",
2387
 
                     new String[] { "\u0061\u2060\u0308" });
2388
 
 
2389
 
    // ÷ 0061 × 2060 ÷ 002C ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2390
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u002C",
2391
 
                     new String[] { "\u0061\u2060" });
2392
 
 
2393
 
    // ÷ 0061 × 2060 × 0308 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2394
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u002C",
2395
 
                     new String[] { "\u0061\u2060\u0308" });
2396
 
 
2397
 
    // ÷ 0061 × 2060 ÷ 0027 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2398
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0027",
2399
 
                     new String[] { "\u0061\u2060" });
2400
 
 
2401
 
    // ÷ 0061 × 2060 × 0308 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2402
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0027",
2403
 
                     new String[] { "\u0061\u2060\u0308" });
2404
 
 
2405
 
    // ÷ 0061 × 2060 × 0030 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]
2406
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0030",
2407
 
                     new String[] { "\u0061\u2060\u0030" });
2408
 
 
2409
 
    // ÷ 0061 × 2060 × 0308 × 0030 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [9.0] DIGIT ZERO (Numeric) ÷ [0.3]
2410
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0030",
2411
 
                     new String[] { "\u0061\u2060\u0308\u0030" });
2412
 
 
2413
 
    // ÷ 0061 × 2060 × 005F ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]
2414
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u005F",
2415
 
                     new String[] { "\u0061\u2060\u005F" });
2416
 
 
2417
 
    // ÷ 0061 × 2060 × 0308 × 005F ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [13.1] LOW LINE (ExtendNumLet) ÷ [0.3]
2418
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u005F",
2419
 
                     new String[] { "\u0061\u2060\u0308\u005F" });
2420
 
 
2421
 
    // ÷ 0061 × 2060 × 00AD ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2422
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u00AD",
2423
 
                     new String[] { "\u0061\u2060\u00AD" });
2424
 
 
2425
 
    // ÷ 0061 × 2060 × 0308 × 00AD ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2426
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u00AD",
2427
 
                     new String[] { "\u0061\u2060\u0308\u00AD" });
2428
 
 
2429
 
    // ÷ 0061 × 2060 × 0300 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2430
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0300",
2431
 
                     new String[] { "\u0061\u2060\u0300" });
2432
 
 
2433
 
    // ÷ 0061 × 2060 × 0308 × 0300 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2434
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0300",
2435
 
                     new String[] { "\u0061\u2060\u0308\u0300" });
2436
 
 
2437
 
    // ÷ 0061 × 2060 × 0061 × 2060 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2438
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0061\u2060",
2439
 
                     new String[] { "\u0061\u2060\u0061\u2060" });
2440
 
 
2441
 
    // ÷ 0061 × 2060 × 0308 × 0061 × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2442
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0061\u2060",
2443
 
                     new String[] { "\u0061\u2060\u0308\u0061\u2060" });
2444
 
 
2445
 
    // ÷ 0061 × 2060 × 0061 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2446
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0061\u003A",
2447
 
                     new String[] { "\u0061\u2060\u0061" });
2448
 
 
2449
 
    // ÷ 0061 × 2060 × 0308 × 0061 ÷ 003A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2450
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0061\u003A",
2451
 
                     new String[] { "\u0061\u2060\u0308\u0061" });
2452
 
 
2453
 
    // ÷ 0061 × 2060 × 0061 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2454
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0061\u0027",
2455
 
                     new String[] { "\u0061\u2060\u0061" });
2456
 
 
2457
 
    // ÷ 0061 × 2060 × 0308 × 0061 ÷ 0027 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2458
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0061\u0027",
2459
 
                     new String[] { "\u0061\u2060\u0308\u0061" });
2460
 
 
2461
 
    // ÷ 0061 × 2060 × 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2462
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0061\u0027\u2060",
2463
 
                     new String[] { "\u0061\u2060\u0061" });
2464
 
 
2465
 
    // ÷ 0061 × 2060 × 0308 × 0061 ÷ 0027 × 2060 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2466
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0061\u0027\u2060",
2467
 
                     new String[] { "\u0061\u2060\u0308\u0061" });
2468
 
 
2469
 
    // ÷ 0061 × 2060 × 0061 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2470
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0061\u002C",
2471
 
                     new String[] { "\u0061\u2060\u0061" });
2472
 
 
2473
 
    // ÷ 0061 × 2060 × 0308 × 0061 ÷ 002C ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [5.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2474
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0061\u002C",
2475
 
                     new String[] { "\u0061\u2060\u0308\u0061" });
2476
 
 
2477
 
    // ÷ 0061 × 2060 × 0031 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2478
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0031\u003A",
2479
 
                     new String[] { "\u0061\u2060\u0031" });
2480
 
 
2481
 
    // ÷ 0061 × 2060 × 0308 × 0031 ÷ 003A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2482
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0031\u003A",
2483
 
                     new String[] { "\u0061\u2060\u0308\u0031" });
2484
 
 
2485
 
    // ÷ 0061 × 2060 × 0031 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2486
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0031\u0027",
2487
 
                     new String[] { "\u0061\u2060\u0031" });
2488
 
 
2489
 
    // ÷ 0061 × 2060 × 0308 × 0031 ÷ 0027 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2490
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0031\u0027",
2491
 
                     new String[] { "\u0061\u2060\u0308\u0031" });
2492
 
 
2493
 
    // ÷ 0061 × 2060 × 0031 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2494
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0031\u002C",
2495
 
                     new String[] { "\u0061\u2060\u0031" });
2496
 
 
2497
 
    // ÷ 0061 × 2060 × 0308 × 0031 ÷ 002C ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2498
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0031\u002C",
2499
 
                     new String[] { "\u0061\u2060\u0308\u0031" });
2500
 
 
2501
 
    // ÷ 0061 × 2060 × 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2502
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0031\u002E\u2060",
2503
 
                     new String[] { "\u0061\u2060\u0031" });
2504
 
 
2505
 
    // ÷ 0061 × 2060 × 0308 × 0031 ÷ 002E × 2060 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [9.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2506
 
    assertAnalyzesTo(analyzer, "\u0061\u2060\u0308\u0031\u002E\u2060",
2507
 
                     new String[] { "\u0061\u2060\u0308\u0031" });
2508
 
 
2509
 
    // ÷ 0061 ÷ 003A ÷ 0001 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
2510
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0001",
2511
 
                     new String[] { "\u0061" });
2512
 
 
2513
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 0001 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
2514
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0001",
2515
 
                     new String[] { "\u0061" });
2516
 
 
2517
 
    // ÷ 0061 ÷ 003A ÷ 000D ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
2518
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\r",
2519
 
                     new String[] { "\u0061" });
2520
 
 
2521
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 000D ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
2522
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\r",
2523
 
                     new String[] { "\u0061" });
2524
 
 
2525
 
    // ÷ 0061 ÷ 003A ÷ 000A ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
2526
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\n",
2527
 
                     new String[] { "\u0061" });
2528
 
 
2529
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 000A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
2530
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\n",
2531
 
                     new String[] { "\u0061" });
2532
 
 
2533
 
    // ÷ 0061 ÷ 003A ÷ 000B ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2534
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u000B",
2535
 
                     new String[] { "\u0061" });
2536
 
 
2537
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 000B ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2538
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u000B",
2539
 
                     new String[] { "\u0061" });
2540
 
 
2541
 
    // ÷ 0061 ÷ 003A ÷ 3031 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2542
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u3031",
2543
 
                     new String[] { "\u0061", "\u3031" });
2544
 
 
2545
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 3031 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2546
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u3031",
2547
 
                     new String[] { "\u0061", "\u3031" });
2548
 
 
2549
 
    // ÷ 0061 × 003A × 0041 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [7.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2550
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0041",
2551
 
                     new String[] { "\u0061\u003A\u0041" });
2552
 
 
2553
 
    // ÷ 0061 × 003A × 0308 × 0041 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2554
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0041",
2555
 
                     new String[] { "\u0061\u003A\u0308\u0041" });
2556
 
 
2557
 
    // ÷ 0061 ÷ 003A ÷ 003A ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2558
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u003A",
2559
 
                     new String[] { "\u0061" });
2560
 
 
2561
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2562
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u003A",
2563
 
                     new String[] { "\u0061" });
2564
 
 
2565
 
    // ÷ 0061 ÷ 003A ÷ 002C ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2566
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u002C",
2567
 
                     new String[] { "\u0061" });
2568
 
 
2569
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2570
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u002C",
2571
 
                     new String[] { "\u0061" });
2572
 
 
2573
 
    // ÷ 0061 ÷ 003A ÷ 0027 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2574
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0027",
2575
 
                     new String[] { "\u0061" });
2576
 
 
2577
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2578
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0027",
2579
 
                     new String[] { "\u0061" });
2580
 
 
2581
 
    // ÷ 0061 ÷ 003A ÷ 0030 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
2582
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0030",
2583
 
                     new String[] { "\u0061", "\u0030" });
2584
 
 
2585
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 0030 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
2586
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0030",
2587
 
                     new String[] { "\u0061", "\u0030" });
2588
 
 
2589
 
    // ÷ 0061 ÷ 003A ÷ 005F ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
2590
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u005F",
2591
 
                     new String[] { "\u0061" });
2592
 
 
2593
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 005F ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
2594
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u005F",
2595
 
                     new String[] { "\u0061" });
2596
 
 
2597
 
    // ÷ 0061 ÷ 003A × 00AD ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2598
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u00AD",
2599
 
                     new String[] { "\u0061" });
2600
 
 
2601
 
    // ÷ 0061 ÷ 003A × 0308 × 00AD ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2602
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u00AD",
2603
 
                     new String[] { "\u0061" });
2604
 
 
2605
 
    // ÷ 0061 ÷ 003A × 0300 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2606
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0300",
2607
 
                     new String[] { "\u0061" });
2608
 
 
2609
 
    // ÷ 0061 ÷ 003A × 0308 × 0300 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2610
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0300",
2611
 
                     new String[] { "\u0061" });
2612
 
 
2613
 
    // ÷ 0061 × 003A × 0061 × 2060 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [7.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2614
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0061\u2060",
2615
 
                     new String[] { "\u0061\u003A\u0061\u2060" });
2616
 
 
2617
 
    // ÷ 0061 × 003A × 0308 × 0061 × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2618
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0061\u2060",
2619
 
                     new String[] { "\u0061\u003A\u0308\u0061\u2060" });
2620
 
 
2621
 
    // ÷ 0061 × 003A × 0061 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2622
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0061\u003A",
2623
 
                     new String[] { "\u0061\u003A\u0061" });
2624
 
 
2625
 
    // ÷ 0061 × 003A × 0308 × 0061 ÷ 003A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2626
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0061\u003A",
2627
 
                     new String[] { "\u0061\u003A\u0308\u0061" });
2628
 
 
2629
 
    // ÷ 0061 × 003A × 0061 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2630
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0061\u0027",
2631
 
                     new String[] { "\u0061\u003A\u0061" });
2632
 
 
2633
 
    // ÷ 0061 × 003A × 0308 × 0061 ÷ 0027 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2634
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0061\u0027",
2635
 
                     new String[] { "\u0061\u003A\u0308\u0061" });
2636
 
 
2637
 
    // ÷ 0061 × 003A × 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2638
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0061\u0027\u2060",
2639
 
                     new String[] { "\u0061\u003A\u0061" });
2640
 
 
2641
 
    // ÷ 0061 × 003A × 0308 × 0061 ÷ 0027 × 2060 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2642
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0061\u0027\u2060",
2643
 
                     new String[] { "\u0061\u003A\u0308\u0061" });
2644
 
 
2645
 
    // ÷ 0061 × 003A × 0061 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2646
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0061\u002C",
2647
 
                     new String[] { "\u0061\u003A\u0061" });
2648
 
 
2649
 
    // ÷ 0061 × 003A × 0308 × 0061 ÷ 002C ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2650
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0061\u002C",
2651
 
                     new String[] { "\u0061\u003A\u0308\u0061" });
2652
 
 
2653
 
    // ÷ 0061 ÷ 003A ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2654
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0031\u003A",
2655
 
                     new String[] { "\u0061", "\u0031" });
2656
 
 
2657
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 0031 ÷ 003A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2658
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0031\u003A",
2659
 
                     new String[] { "\u0061", "\u0031" });
2660
 
 
2661
 
    // ÷ 0061 ÷ 003A ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2662
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0031\u0027",
2663
 
                     new String[] { "\u0061", "\u0031" });
2664
 
 
2665
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 0031 ÷ 0027 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2666
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0031\u0027",
2667
 
                     new String[] { "\u0061", "\u0031" });
2668
 
 
2669
 
    // ÷ 0061 ÷ 003A ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2670
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0031\u002C",
2671
 
                     new String[] { "\u0061", "\u0031" });
2672
 
 
2673
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 0031 ÷ 002C ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2674
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0031\u002C",
2675
 
                     new String[] { "\u0061", "\u0031" });
2676
 
 
2677
 
    // ÷ 0061 ÷ 003A ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2678
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0031\u002E\u2060",
2679
 
                     new String[] { "\u0061", "\u0031" });
2680
 
 
2681
 
    // ÷ 0061 ÷ 003A × 0308 ÷ 0031 ÷ 002E × 2060 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2682
 
    assertAnalyzesTo(analyzer, "\u0061\u003A\u0308\u0031\u002E\u2060",
2683
 
                     new String[] { "\u0061", "\u0031" });
2684
 
 
2685
 
    // ÷ 0061 ÷ 0027 ÷ 0001 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
2686
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0001",
2687
 
                     new String[] { "\u0061" });
2688
 
 
2689
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 0001 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
2690
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0001",
2691
 
                     new String[] { "\u0061" });
2692
 
 
2693
 
    // ÷ 0061 ÷ 0027 ÷ 000D ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
2694
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\r",
2695
 
                     new String[] { "\u0061" });
2696
 
 
2697
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 000D ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
2698
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\r",
2699
 
                     new String[] { "\u0061" });
2700
 
 
2701
 
    // ÷ 0061 ÷ 0027 ÷ 000A ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
2702
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\n",
2703
 
                     new String[] { "\u0061" });
2704
 
 
2705
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 000A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
2706
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\n",
2707
 
                     new String[] { "\u0061" });
2708
 
 
2709
 
    // ÷ 0061 ÷ 0027 ÷ 000B ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2710
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u000B",
2711
 
                     new String[] { "\u0061" });
2712
 
 
2713
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 000B ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2714
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u000B",
2715
 
                     new String[] { "\u0061" });
2716
 
 
2717
 
    // ÷ 0061 ÷ 0027 ÷ 3031 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2718
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u3031",
2719
 
                     new String[] { "\u0061", "\u3031" });
2720
 
 
2721
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 3031 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2722
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u3031",
2723
 
                     new String[] { "\u0061", "\u3031" });
2724
 
 
2725
 
    // ÷ 0061 × 0027 × 0041 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [7.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2726
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0041",
2727
 
                     new String[] { "\u0061\u0027\u0041" });
2728
 
 
2729
 
    // ÷ 0061 × 0027 × 0308 × 0041 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2730
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0041",
2731
 
                     new String[] { "\u0061\u0027\u0308\u0041" });
2732
 
 
2733
 
    // ÷ 0061 ÷ 0027 ÷ 003A ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2734
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u003A",
2735
 
                     new String[] { "\u0061" });
2736
 
 
2737
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2738
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u003A",
2739
 
                     new String[] { "\u0061" });
2740
 
 
2741
 
    // ÷ 0061 ÷ 0027 ÷ 002C ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2742
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u002C",
2743
 
                     new String[] { "\u0061" });
2744
 
 
2745
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2746
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u002C",
2747
 
                     new String[] { "\u0061" });
2748
 
 
2749
 
    // ÷ 0061 ÷ 0027 ÷ 0027 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2750
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0027",
2751
 
                     new String[] { "\u0061" });
2752
 
 
2753
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2754
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0027",
2755
 
                     new String[] { "\u0061" });
2756
 
 
2757
 
    // ÷ 0061 ÷ 0027 ÷ 0030 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
2758
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0030",
2759
 
                     new String[] { "\u0061", "\u0030" });
2760
 
 
2761
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 0030 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
2762
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0030",
2763
 
                     new String[] { "\u0061", "\u0030" });
2764
 
 
2765
 
    // ÷ 0061 ÷ 0027 ÷ 005F ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
2766
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u005F",
2767
 
                     new String[] { "\u0061" });
2768
 
 
2769
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 005F ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
2770
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u005F",
2771
 
                     new String[] { "\u0061" });
2772
 
 
2773
 
    // ÷ 0061 ÷ 0027 × 00AD ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2774
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u00AD",
2775
 
                     new String[] { "\u0061" });
2776
 
 
2777
 
    // ÷ 0061 ÷ 0027 × 0308 × 00AD ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2778
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u00AD",
2779
 
                     new String[] { "\u0061" });
2780
 
 
2781
 
    // ÷ 0061 ÷ 0027 × 0300 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2782
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0300",
2783
 
                     new String[] { "\u0061" });
2784
 
 
2785
 
    // ÷ 0061 ÷ 0027 × 0308 × 0300 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2786
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0300",
2787
 
                     new String[] { "\u0061" });
2788
 
 
2789
 
    // ÷ 0061 × 0027 × 0061 × 2060 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [7.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2790
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0061\u2060",
2791
 
                     new String[] { "\u0061\u0027\u0061\u2060" });
2792
 
 
2793
 
    // ÷ 0061 × 0027 × 0308 × 0061 × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2794
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0061\u2060",
2795
 
                     new String[] { "\u0061\u0027\u0308\u0061\u2060" });
2796
 
 
2797
 
    // ÷ 0061 × 0027 × 0061 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2798
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0061\u003A",
2799
 
                     new String[] { "\u0061\u0027\u0061" });
2800
 
 
2801
 
    // ÷ 0061 × 0027 × 0308 × 0061 ÷ 003A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2802
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0061\u003A",
2803
 
                     new String[] { "\u0061\u0027\u0308\u0061" });
2804
 
 
2805
 
    // ÷ 0061 × 0027 × 0061 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2806
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0061\u0027",
2807
 
                     new String[] { "\u0061\u0027\u0061" });
2808
 
 
2809
 
    // ÷ 0061 × 0027 × 0308 × 0061 ÷ 0027 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2810
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0061\u0027",
2811
 
                     new String[] { "\u0061\u0027\u0308\u0061" });
2812
 
 
2813
 
    // ÷ 0061 × 0027 × 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2814
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0061\u0027\u2060",
2815
 
                     new String[] { "\u0061\u0027\u0061" });
2816
 
 
2817
 
    // ÷ 0061 × 0027 × 0308 × 0061 ÷ 0027 × 2060 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2818
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0061\u0027\u2060",
2819
 
                     new String[] { "\u0061\u0027\u0308\u0061" });
2820
 
 
2821
 
    // ÷ 0061 × 0027 × 0061 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2822
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0061\u002C",
2823
 
                     new String[] { "\u0061\u0027\u0061" });
2824
 
 
2825
 
    // ÷ 0061 × 0027 × 0308 × 0061 ÷ 002C ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2826
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0061\u002C",
2827
 
                     new String[] { "\u0061\u0027\u0308\u0061" });
2828
 
 
2829
 
    // ÷ 0061 ÷ 0027 ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2830
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0031\u003A",
2831
 
                     new String[] { "\u0061", "\u0031" });
2832
 
 
2833
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 0031 ÷ 003A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2834
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0031\u003A",
2835
 
                     new String[] { "\u0061", "\u0031" });
2836
 
 
2837
 
    // ÷ 0061 ÷ 0027 ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2838
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0031\u0027",
2839
 
                     new String[] { "\u0061", "\u0031" });
2840
 
 
2841
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 0031 ÷ 0027 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2842
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0031\u0027",
2843
 
                     new String[] { "\u0061", "\u0031" });
2844
 
 
2845
 
    // ÷ 0061 ÷ 0027 ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2846
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0031\u002C",
2847
 
                     new String[] { "\u0061", "\u0031" });
2848
 
 
2849
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 0031 ÷ 002C ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2850
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0031\u002C",
2851
 
                     new String[] { "\u0061", "\u0031" });
2852
 
 
2853
 
    // ÷ 0061 ÷ 0027 ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2854
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0031\u002E\u2060",
2855
 
                     new String[] { "\u0061", "\u0031" });
2856
 
 
2857
 
    // ÷ 0061 ÷ 0027 × 0308 ÷ 0031 ÷ 002E × 2060 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2858
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u0308\u0031\u002E\u2060",
2859
 
                     new String[] { "\u0061", "\u0031" });
2860
 
 
2861
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 0001 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
2862
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0001",
2863
 
                     new String[] { "\u0061" });
2864
 
 
2865
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 0001 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
2866
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0001",
2867
 
                     new String[] { "\u0061" });
2868
 
 
2869
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 000D ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
2870
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\r",
2871
 
                     new String[] { "\u0061" });
2872
 
 
2873
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 000D ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
2874
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\r",
2875
 
                     new String[] { "\u0061" });
2876
 
 
2877
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 000A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
2878
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\n",
2879
 
                     new String[] { "\u0061" });
2880
 
 
2881
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 000A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
2882
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\n",
2883
 
                     new String[] { "\u0061" });
2884
 
 
2885
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 000B ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2886
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u000B",
2887
 
                     new String[] { "\u0061" });
2888
 
 
2889
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 000B ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
2890
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u000B",
2891
 
                     new String[] { "\u0061" });
2892
 
 
2893
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 3031 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2894
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u3031",
2895
 
                     new String[] { "\u0061", "\u3031" });
2896
 
 
2897
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 3031 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
2898
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u3031",
2899
 
                     new String[] { "\u0061", "\u3031" });
2900
 
 
2901
 
    // ÷ 0061 × 0027 × 2060 × 0041 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [7.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2902
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0041",
2903
 
                     new String[] { "\u0061\u0027\u2060\u0041" });
2904
 
 
2905
 
    // ÷ 0061 × 0027 × 2060 × 0308 × 0041 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
2906
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0041",
2907
 
                     new String[] { "\u0061\u0027\u2060\u0308\u0041" });
2908
 
 
2909
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2910
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u003A",
2911
 
                     new String[] { "\u0061" });
2912
 
 
2913
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 003A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2914
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u003A",
2915
 
                     new String[] { "\u0061" });
2916
 
 
2917
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2918
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u002C",
2919
 
                     new String[] { "\u0061" });
2920
 
 
2921
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 002C ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2922
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u002C",
2923
 
                     new String[] { "\u0061" });
2924
 
 
2925
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2926
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0027",
2927
 
                     new String[] { "\u0061" });
2928
 
 
2929
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 0027 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2930
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0027",
2931
 
                     new String[] { "\u0061" });
2932
 
 
2933
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 0030 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
2934
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0030",
2935
 
                     new String[] { "\u0061", "\u0030" });
2936
 
 
2937
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 0030 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
2938
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0030",
2939
 
                     new String[] { "\u0061", "\u0030" });
2940
 
 
2941
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 005F ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
2942
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u005F",
2943
 
                     new String[] { "\u0061" });
2944
 
 
2945
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 005F ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
2946
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u005F",
2947
 
                     new String[] { "\u0061" });
2948
 
 
2949
 
    // ÷ 0061 ÷ 0027 × 2060 × 00AD ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2950
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u00AD",
2951
 
                     new String[] { "\u0061" });
2952
 
 
2953
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 × 00AD ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
2954
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u00AD",
2955
 
                     new String[] { "\u0061" });
2956
 
 
2957
 
    // ÷ 0061 ÷ 0027 × 2060 × 0300 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2958
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0300",
2959
 
                     new String[] { "\u0061" });
2960
 
 
2961
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 × 0300 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
2962
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0300",
2963
 
                     new String[] { "\u0061" });
2964
 
 
2965
 
    // ÷ 0061 × 0027 × 2060 × 0061 × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [7.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2966
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0061\u2060",
2967
 
                     new String[] { "\u0061\u0027\u2060\u0061\u2060" });
2968
 
 
2969
 
    // ÷ 0061 × 0027 × 2060 × 0308 × 0061 × 2060 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2970
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0061\u2060",
2971
 
                     new String[] { "\u0061\u0027\u2060\u0308\u0061\u2060" });
2972
 
 
2973
 
    // ÷ 0061 × 0027 × 2060 × 0061 ÷ 003A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2974
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0061\u003A",
2975
 
                     new String[] { "\u0061\u0027\u2060\u0061" });
2976
 
 
2977
 
    // ÷ 0061 × 0027 × 2060 × 0308 × 0061 ÷ 003A ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
2978
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0061\u003A",
2979
 
                     new String[] { "\u0061\u0027\u2060\u0308\u0061" });
2980
 
 
2981
 
    // ÷ 0061 × 0027 × 2060 × 0061 ÷ 0027 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2982
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0061\u0027",
2983
 
                     new String[] { "\u0061\u0027\u2060\u0061" });
2984
 
 
2985
 
    // ÷ 0061 × 0027 × 2060 × 0308 × 0061 ÷ 0027 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
2986
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0061\u0027",
2987
 
                     new String[] { "\u0061\u0027\u2060\u0308\u0061" });
2988
 
 
2989
 
    // ÷ 0061 × 0027 × 2060 × 0061 ÷ 0027 × 2060 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2990
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0061\u0027\u2060",
2991
 
                     new String[] { "\u0061\u0027\u2060\u0061" });
2992
 
 
2993
 
    // ÷ 0061 × 0027 × 2060 × 0308 × 0061 ÷ 0027 × 2060 ÷       #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
2994
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0061\u0027\u2060",
2995
 
                     new String[] { "\u0061\u0027\u2060\u0308\u0061" });
2996
 
 
2997
 
    // ÷ 0061 × 0027 × 2060 × 0061 ÷ 002C ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
2998
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0061\u002C",
2999
 
                     new String[] { "\u0061\u0027\u2060\u0061" });
3000
 
 
3001
 
    // ÷ 0061 × 0027 × 2060 × 0308 × 0061 ÷ 002C ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [7.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3002
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0061\u002C",
3003
 
                     new String[] { "\u0061\u0027\u2060\u0308\u0061" });
3004
 
 
3005
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 0031 ÷ 003A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3006
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0031\u003A",
3007
 
                     new String[] { "\u0061", "\u0031" });
3008
 
 
3009
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 0031 ÷ 003A ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3010
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0031\u003A",
3011
 
                     new String[] { "\u0061", "\u0031" });
3012
 
 
3013
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 0031 ÷ 0027 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3014
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0031\u0027",
3015
 
                     new String[] { "\u0061", "\u0031" });
3016
 
 
3017
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 0031 ÷ 0027 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3018
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0031\u0027",
3019
 
                     new String[] { "\u0061", "\u0031" });
3020
 
 
3021
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 0031 ÷ 002C ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3022
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0031\u002C",
3023
 
                     new String[] { "\u0061", "\u0031" });
3024
 
 
3025
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 0031 ÷ 002C ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3026
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0031\u002C",
3027
 
                     new String[] { "\u0061", "\u0031" });
3028
 
 
3029
 
    // ÷ 0061 ÷ 0027 × 2060 ÷ 0031 ÷ 002E × 2060 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3030
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0031\u002E\u2060",
3031
 
                     new String[] { "\u0061", "\u0031" });
3032
 
 
3033
 
    // ÷ 0061 ÷ 0027 × 2060 × 0308 ÷ 0031 ÷ 002E × 2060 ÷       #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3034
 
    assertAnalyzesTo(analyzer, "\u0061\u0027\u2060\u0308\u0031\u002E\u2060",
3035
 
                     new String[] { "\u0061", "\u0031" });
3036
 
 
3037
 
    // ÷ 0061 ÷ 002C ÷ 0001 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
3038
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0001",
3039
 
                     new String[] { "\u0061" });
3040
 
 
3041
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0001 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
3042
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0001",
3043
 
                     new String[] { "\u0061" });
3044
 
 
3045
 
    // ÷ 0061 ÷ 002C ÷ 000D ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
3046
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\r",
3047
 
                     new String[] { "\u0061" });
3048
 
 
3049
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 000D ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
3050
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\r",
3051
 
                     new String[] { "\u0061" });
3052
 
 
3053
 
    // ÷ 0061 ÷ 002C ÷ 000A ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
3054
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\n",
3055
 
                     new String[] { "\u0061" });
3056
 
 
3057
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 000A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
3058
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\n",
3059
 
                     new String[] { "\u0061" });
3060
 
 
3061
 
    // ÷ 0061 ÷ 002C ÷ 000B ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
3062
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u000B",
3063
 
                     new String[] { "\u0061" });
3064
 
 
3065
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 000B ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
3066
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u000B",
3067
 
                     new String[] { "\u0061" });
3068
 
 
3069
 
    // ÷ 0061 ÷ 002C ÷ 3031 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
3070
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u3031",
3071
 
                     new String[] { "\u0061", "\u3031" });
3072
 
 
3073
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 3031 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
3074
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u3031",
3075
 
                     new String[] { "\u0061", "\u3031" });
3076
 
 
3077
 
    // ÷ 0061 ÷ 002C ÷ 0041 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
3078
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0041",
3079
 
                     new String[] { "\u0061", "\u0041" });
3080
 
 
3081
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0041 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
3082
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0041",
3083
 
                     new String[] { "\u0061", "\u0041" });
3084
 
 
3085
 
    // ÷ 0061 ÷ 002C ÷ 003A ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3086
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u003A",
3087
 
                     new String[] { "\u0061" });
3088
 
 
3089
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3090
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u003A",
3091
 
                     new String[] { "\u0061" });
3092
 
 
3093
 
    // ÷ 0061 ÷ 002C ÷ 002C ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3094
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u002C",
3095
 
                     new String[] { "\u0061" });
3096
 
 
3097
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3098
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u002C",
3099
 
                     new String[] { "\u0061" });
3100
 
 
3101
 
    // ÷ 0061 ÷ 002C ÷ 0027 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3102
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0027",
3103
 
                     new String[] { "\u0061" });
3104
 
 
3105
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3106
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0027",
3107
 
                     new String[] { "\u0061" });
3108
 
 
3109
 
    // ÷ 0061 ÷ 002C ÷ 0030 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
3110
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0030",
3111
 
                     new String[] { "\u0061", "\u0030" });
3112
 
 
3113
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0030 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
3114
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0030",
3115
 
                     new String[] { "\u0061", "\u0030" });
3116
 
 
3117
 
    // ÷ 0061 ÷ 002C ÷ 005F ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
3118
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u005F",
3119
 
                     new String[] { "\u0061" });
3120
 
 
3121
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 005F ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
3122
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u005F",
3123
 
                     new String[] { "\u0061" });
3124
 
 
3125
 
    // ÷ 0061 ÷ 002C × 00AD ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
3126
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u00AD",
3127
 
                     new String[] { "\u0061" });
3128
 
 
3129
 
    // ÷ 0061 ÷ 002C × 0308 × 00AD ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
3130
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u00AD",
3131
 
                     new String[] { "\u0061" });
3132
 
 
3133
 
    // ÷ 0061 ÷ 002C × 0300 ÷   #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
3134
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0300",
3135
 
                     new String[] { "\u0061" });
3136
 
 
3137
 
    // ÷ 0061 ÷ 002C × 0308 × 0300 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
3138
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0300",
3139
 
                     new String[] { "\u0061" });
3140
 
 
3141
 
    // ÷ 0061 ÷ 002C ÷ 0061 × 2060 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3142
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0061\u2060",
3143
 
                     new String[] { "\u0061", "\u0061\u2060" });
3144
 
 
3145
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0061 × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3146
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0061\u2060",
3147
 
                     new String[] { "\u0061", "\u0061\u2060" });
3148
 
 
3149
 
    // ÷ 0061 ÷ 002C ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3150
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0061\u003A",
3151
 
                     new String[] { "\u0061", "\u0061" });
3152
 
 
3153
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0061 ÷ 003A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3154
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0061\u003A",
3155
 
                     new String[] { "\u0061", "\u0061" });
3156
 
 
3157
 
    // ÷ 0061 ÷ 002C ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3158
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0061\u0027",
3159
 
                     new String[] { "\u0061", "\u0061" });
3160
 
 
3161
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0061 ÷ 0027 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3162
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0061\u0027",
3163
 
                     new String[] { "\u0061", "\u0061" });
3164
 
 
3165
 
    // ÷ 0061 ÷ 002C ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3166
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0061\u0027\u2060",
3167
 
                     new String[] { "\u0061", "\u0061" });
3168
 
 
3169
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0061 ÷ 0027 × 2060 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3170
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0061\u0027\u2060",
3171
 
                     new String[] { "\u0061", "\u0061" });
3172
 
 
3173
 
    // ÷ 0061 ÷ 002C ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3174
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0061\u002C",
3175
 
                     new String[] { "\u0061", "\u0061" });
3176
 
 
3177
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0061 ÷ 002C ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3178
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0061\u002C",
3179
 
                     new String[] { "\u0061", "\u0061" });
3180
 
 
3181
 
    // ÷ 0061 ÷ 002C ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3182
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0031\u003A",
3183
 
                     new String[] { "\u0061", "\u0031" });
3184
 
 
3185
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0031 ÷ 003A ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3186
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0031\u003A",
3187
 
                     new String[] { "\u0061", "\u0031" });
3188
 
 
3189
 
    // ÷ 0061 ÷ 002C ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3190
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0031\u0027",
3191
 
                     new String[] { "\u0061", "\u0031" });
3192
 
 
3193
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0031 ÷ 0027 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3194
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0031\u0027",
3195
 
                     new String[] { "\u0061", "\u0031" });
3196
 
 
3197
 
    // ÷ 0061 ÷ 002C ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3198
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0031\u002C",
3199
 
                     new String[] { "\u0061", "\u0031" });
3200
 
 
3201
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0031 ÷ 002C ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3202
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0031\u002C",
3203
 
                     new String[] { "\u0061", "\u0031" });
3204
 
 
3205
 
    // ÷ 0061 ÷ 002C ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3206
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0031\u002E\u2060",
3207
 
                     new String[] { "\u0061", "\u0031" });
3208
 
 
3209
 
    // ÷ 0061 ÷ 002C × 0308 ÷ 0031 ÷ 002E × 2060 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3210
 
    assertAnalyzesTo(analyzer, "\u0061\u002C\u0308\u0031\u002E\u2060",
3211
 
                     new String[] { "\u0061", "\u0031" });
3212
 
 
3213
 
    // ÷ 0031 ÷ 003A ÷ 0001 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
3214
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0001",
3215
 
                     new String[] { "\u0031" });
3216
 
 
3217
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0001 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
3218
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0001",
3219
 
                     new String[] { "\u0031" });
3220
 
 
3221
 
    // ÷ 0031 ÷ 003A ÷ 000D ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
3222
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\r",
3223
 
                     new String[] { "\u0031" });
3224
 
 
3225
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 000D ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
3226
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\r",
3227
 
                     new String[] { "\u0031" });
3228
 
 
3229
 
    // ÷ 0031 ÷ 003A ÷ 000A ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
3230
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\n",
3231
 
                     new String[] { "\u0031" });
3232
 
 
3233
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 000A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
3234
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\n",
3235
 
                     new String[] { "\u0031" });
3236
 
 
3237
 
    // ÷ 0031 ÷ 003A ÷ 000B ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
3238
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u000B",
3239
 
                     new String[] { "\u0031" });
3240
 
 
3241
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 000B ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
3242
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u000B",
3243
 
                     new String[] { "\u0031" });
3244
 
 
3245
 
    // ÷ 0031 ÷ 003A ÷ 3031 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
3246
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u3031",
3247
 
                     new String[] { "\u0031", "\u3031" });
3248
 
 
3249
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 3031 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
3250
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u3031",
3251
 
                     new String[] { "\u0031", "\u3031" });
3252
 
 
3253
 
    // ÷ 0031 ÷ 003A ÷ 0041 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
3254
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0041",
3255
 
                     new String[] { "\u0031", "\u0041" });
3256
 
 
3257
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0041 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
3258
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0041",
3259
 
                     new String[] { "\u0031", "\u0041" });
3260
 
 
3261
 
    // ÷ 0031 ÷ 003A ÷ 003A ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3262
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u003A",
3263
 
                     new String[] { "\u0031" });
3264
 
 
3265
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 003A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3266
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u003A",
3267
 
                     new String[] { "\u0031" });
3268
 
 
3269
 
    // ÷ 0031 ÷ 003A ÷ 002C ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3270
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u002C",
3271
 
                     new String[] { "\u0031" });
3272
 
 
3273
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 002C ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3274
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u002C",
3275
 
                     new String[] { "\u0031" });
3276
 
 
3277
 
    // ÷ 0031 ÷ 003A ÷ 0027 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3278
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0027",
3279
 
                     new String[] { "\u0031" });
3280
 
 
3281
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3282
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0027",
3283
 
                     new String[] { "\u0031" });
3284
 
 
3285
 
    // ÷ 0031 ÷ 003A ÷ 0030 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
3286
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0030",
3287
 
                     new String[] { "\u0031", "\u0030" });
3288
 
 
3289
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0030 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
3290
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0030",
3291
 
                     new String[] { "\u0031", "\u0030" });
3292
 
 
3293
 
    // ÷ 0031 ÷ 003A ÷ 005F ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
3294
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u005F",
3295
 
                     new String[] { "\u0031" });
3296
 
 
3297
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 005F ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
3298
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u005F",
3299
 
                     new String[] { "\u0031" });
3300
 
 
3301
 
    // ÷ 0031 ÷ 003A × 00AD ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
3302
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u00AD",
3303
 
                     new String[] { "\u0031" });
3304
 
 
3305
 
    // ÷ 0031 ÷ 003A × 0308 × 00AD ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
3306
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u00AD",
3307
 
                     new String[] { "\u0031" });
3308
 
 
3309
 
    // ÷ 0031 ÷ 003A × 0300 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
3310
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0300",
3311
 
                     new String[] { "\u0031" });
3312
 
 
3313
 
    // ÷ 0031 ÷ 003A × 0308 × 0300 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
3314
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0300",
3315
 
                     new String[] { "\u0031" });
3316
 
 
3317
 
    // ÷ 0031 ÷ 003A ÷ 0061 × 2060 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3318
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0061\u2060",
3319
 
                     new String[] { "\u0031", "\u0061\u2060" });
3320
 
 
3321
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0061 × 2060 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3322
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0061\u2060",
3323
 
                     new String[] { "\u0031", "\u0061\u2060" });
3324
 
 
3325
 
    // ÷ 0031 ÷ 003A ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3326
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0061\u003A",
3327
 
                     new String[] { "\u0031", "\u0061" });
3328
 
 
3329
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0061 ÷ 003A ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3330
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0061\u003A",
3331
 
                     new String[] { "\u0031", "\u0061" });
3332
 
 
3333
 
    // ÷ 0031 ÷ 003A ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3334
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0061\u0027",
3335
 
                     new String[] { "\u0031", "\u0061" });
3336
 
 
3337
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0061 ÷ 0027 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3338
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0061\u0027",
3339
 
                     new String[] { "\u0031", "\u0061" });
3340
 
 
3341
 
    // ÷ 0031 ÷ 003A ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3342
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0061\u0027\u2060",
3343
 
                     new String[] { "\u0031", "\u0061" });
3344
 
 
3345
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0061 ÷ 0027 × 2060 ÷      #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3346
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0061\u0027\u2060",
3347
 
                     new String[] { "\u0031", "\u0061" });
3348
 
 
3349
 
    // ÷ 0031 ÷ 003A ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3350
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0061\u002C",
3351
 
                     new String[] { "\u0031", "\u0061" });
3352
 
 
3353
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0061 ÷ 002C ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3354
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0061\u002C",
3355
 
                     new String[] { "\u0031", "\u0061" });
3356
 
 
3357
 
    // ÷ 0031 ÷ 003A ÷ 0031 ÷ 003A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3358
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0031\u003A",
3359
 
                     new String[] { "\u0031", "\u0031" });
3360
 
 
3361
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0031 ÷ 003A ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3362
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0031\u003A",
3363
 
                     new String[] { "\u0031", "\u0031" });
3364
 
 
3365
 
    // ÷ 0031 ÷ 003A ÷ 0031 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3366
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0031\u0027",
3367
 
                     new String[] { "\u0031", "\u0031" });
3368
 
 
3369
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0031 ÷ 0027 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3370
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0031\u0027",
3371
 
                     new String[] { "\u0031", "\u0031" });
3372
 
 
3373
 
    // ÷ 0031 ÷ 003A ÷ 0031 ÷ 002C ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3374
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0031\u002C",
3375
 
                     new String[] { "\u0031", "\u0031" });
3376
 
 
3377
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0031 ÷ 002C ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3378
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0031\u002C",
3379
 
                     new String[] { "\u0031", "\u0031" });
3380
 
 
3381
 
    // ÷ 0031 ÷ 003A ÷ 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3382
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0031\u002E\u2060",
3383
 
                     new String[] { "\u0031", "\u0031" });
3384
 
 
3385
 
    // ÷ 0031 ÷ 003A × 0308 ÷ 0031 ÷ 002E × 2060 ÷      #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3386
 
    assertAnalyzesTo(analyzer, "\u0031\u003A\u0308\u0031\u002E\u2060",
3387
 
                     new String[] { "\u0031", "\u0031" });
3388
 
 
3389
 
    // ÷ 0031 ÷ 0027 ÷ 0001 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
3390
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0001",
3391
 
                     new String[] { "\u0031" });
3392
 
 
3393
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 0001 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
3394
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0001",
3395
 
                     new String[] { "\u0031" });
3396
 
 
3397
 
    // ÷ 0031 ÷ 0027 ÷ 000D ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
3398
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\r",
3399
 
                     new String[] { "\u0031" });
3400
 
 
3401
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 000D ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
3402
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\r",
3403
 
                     new String[] { "\u0031" });
3404
 
 
3405
 
    // ÷ 0031 ÷ 0027 ÷ 000A ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
3406
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\n",
3407
 
                     new String[] { "\u0031" });
3408
 
 
3409
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 000A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
3410
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\n",
3411
 
                     new String[] { "\u0031" });
3412
 
 
3413
 
    // ÷ 0031 ÷ 0027 ÷ 000B ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
3414
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u000B",
3415
 
                     new String[] { "\u0031" });
3416
 
 
3417
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 000B ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
3418
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u000B",
3419
 
                     new String[] { "\u0031" });
3420
 
 
3421
 
    // ÷ 0031 ÷ 0027 ÷ 3031 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
3422
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u3031",
3423
 
                     new String[] { "\u0031", "\u3031" });
3424
 
 
3425
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 3031 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
3426
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u3031",
3427
 
                     new String[] { "\u0031", "\u3031" });
3428
 
 
3429
 
    // ÷ 0031 ÷ 0027 ÷ 0041 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
3430
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0041",
3431
 
                     new String[] { "\u0031", "\u0041" });
3432
 
 
3433
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 0041 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
3434
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0041",
3435
 
                     new String[] { "\u0031", "\u0041" });
3436
 
 
3437
 
    // ÷ 0031 ÷ 0027 ÷ 003A ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3438
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u003A",
3439
 
                     new String[] { "\u0031" });
3440
 
 
3441
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 003A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3442
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u003A",
3443
 
                     new String[] { "\u0031" });
3444
 
 
3445
 
    // ÷ 0031 ÷ 0027 ÷ 002C ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3446
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u002C",
3447
 
                     new String[] { "\u0031" });
3448
 
 
3449
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 002C ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3450
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u002C",
3451
 
                     new String[] { "\u0031" });
3452
 
 
3453
 
    // ÷ 0031 ÷ 0027 ÷ 0027 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3454
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0027",
3455
 
                     new String[] { "\u0031" });
3456
 
 
3457
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3458
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0027",
3459
 
                     new String[] { "\u0031" });
3460
 
 
3461
 
    // ÷ 0031 × 0027 × 0030 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (MidNumLet) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]
3462
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0030",
3463
 
                     new String[] { "\u0031\u0027\u0030" });
3464
 
 
3465
 
    // ÷ 0031 × 0027 × 0308 × 0030 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]
3466
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0030",
3467
 
                     new String[] { "\u0031\u0027\u0308\u0030" });
3468
 
 
3469
 
    // ÷ 0031 ÷ 0027 ÷ 005F ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
3470
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u005F",
3471
 
                     new String[] { "\u0031" });
3472
 
 
3473
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 005F ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
3474
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u005F",
3475
 
                     new String[] { "\u0031" });
3476
 
 
3477
 
    // ÷ 0031 ÷ 0027 × 00AD ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
3478
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u00AD",
3479
 
                     new String[] { "\u0031" });
3480
 
 
3481
 
    // ÷ 0031 ÷ 0027 × 0308 × 00AD ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
3482
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u00AD",
3483
 
                     new String[] { "\u0031" });
3484
 
 
3485
 
    // ÷ 0031 ÷ 0027 × 0300 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
3486
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0300",
3487
 
                     new String[] { "\u0031" });
3488
 
 
3489
 
    // ÷ 0031 ÷ 0027 × 0308 × 0300 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
3490
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0300",
3491
 
                     new String[] { "\u0031" });
3492
 
 
3493
 
    // ÷ 0031 ÷ 0027 ÷ 0061 × 2060 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3494
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0061\u2060",
3495
 
                     new String[] { "\u0031", "\u0061\u2060" });
3496
 
 
3497
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 0061 × 2060 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3498
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0061\u2060",
3499
 
                     new String[] { "\u0031", "\u0061\u2060" });
3500
 
 
3501
 
    // ÷ 0031 ÷ 0027 ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3502
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0061\u003A",
3503
 
                     new String[] { "\u0031", "\u0061" });
3504
 
 
3505
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 0061 ÷ 003A ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3506
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0061\u003A",
3507
 
                     new String[] { "\u0031", "\u0061" });
3508
 
 
3509
 
    // ÷ 0031 ÷ 0027 ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3510
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0061\u0027",
3511
 
                     new String[] { "\u0031", "\u0061" });
3512
 
 
3513
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 0061 ÷ 0027 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3514
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0061\u0027",
3515
 
                     new String[] { "\u0031", "\u0061" });
3516
 
 
3517
 
    // ÷ 0031 ÷ 0027 ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3518
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0061\u0027\u2060",
3519
 
                     new String[] { "\u0031", "\u0061" });
3520
 
 
3521
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 0061 ÷ 0027 × 2060 ÷      #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3522
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0061\u0027\u2060",
3523
 
                     new String[] { "\u0031", "\u0061" });
3524
 
 
3525
 
    // ÷ 0031 ÷ 0027 ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3526
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0061\u002C",
3527
 
                     new String[] { "\u0031", "\u0061" });
3528
 
 
3529
 
    // ÷ 0031 ÷ 0027 × 0308 ÷ 0061 ÷ 002C ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3530
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0061\u002C",
3531
 
                     new String[] { "\u0031", "\u0061" });
3532
 
 
3533
 
    // ÷ 0031 × 0027 × 0031 ÷ 003A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (MidNumLet) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3534
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0031\u003A",
3535
 
                     new String[] { "\u0031\u0027\u0031" });
3536
 
 
3537
 
    // ÷ 0031 × 0027 × 0308 × 0031 ÷ 003A ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3538
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0031\u003A",
3539
 
                     new String[] { "\u0031\u0027\u0308\u0031" });
3540
 
 
3541
 
    // ÷ 0031 × 0027 × 0031 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (MidNumLet) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3542
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0031\u0027",
3543
 
                     new String[] { "\u0031\u0027\u0031" });
3544
 
 
3545
 
    // ÷ 0031 × 0027 × 0308 × 0031 ÷ 0027 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3546
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0031\u0027",
3547
 
                     new String[] { "\u0031\u0027\u0308\u0031" });
3548
 
 
3549
 
    // ÷ 0031 × 0027 × 0031 ÷ 002C ÷    #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (MidNumLet) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3550
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0031\u002C",
3551
 
                     new String[] { "\u0031\u0027\u0031" });
3552
 
 
3553
 
    // ÷ 0031 × 0027 × 0308 × 0031 ÷ 002C ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3554
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0031\u002C",
3555
 
                     new String[] { "\u0031\u0027\u0308\u0031" });
3556
 
 
3557
 
    // ÷ 0031 × 0027 × 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (MidNumLet) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3558
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0031\u002E\u2060",
3559
 
                     new String[] { "\u0031\u0027\u0031" });
3560
 
 
3561
 
    // ÷ 0031 × 0027 × 0308 × 0031 ÷ 002E × 2060 ÷      #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] APOSTROPHE (MidNumLet) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3562
 
    assertAnalyzesTo(analyzer, "\u0031\u0027\u0308\u0031\u002E\u2060",
3563
 
                     new String[] { "\u0031\u0027\u0308\u0031" });
3564
 
 
3565
 
    // ÷ 0031 ÷ 002C ÷ 0001 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
3566
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0001",
3567
 
                     new String[] { "\u0031" });
3568
 
 
3569
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 0001 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
3570
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0001",
3571
 
                     new String[] { "\u0031" });
3572
 
 
3573
 
    // ÷ 0031 ÷ 002C ÷ 000D ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
3574
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\r",
3575
 
                     new String[] { "\u0031" });
3576
 
 
3577
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 000D ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
3578
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\r",
3579
 
                     new String[] { "\u0031" });
3580
 
 
3581
 
    // ÷ 0031 ÷ 002C ÷ 000A ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
3582
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\n",
3583
 
                     new String[] { "\u0031" });
3584
 
 
3585
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 000A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
3586
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\n",
3587
 
                     new String[] { "\u0031" });
3588
 
 
3589
 
    // ÷ 0031 ÷ 002C ÷ 000B ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
3590
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u000B",
3591
 
                     new String[] { "\u0031" });
3592
 
 
3593
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 000B ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
3594
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u000B",
3595
 
                     new String[] { "\u0031" });
3596
 
 
3597
 
    // ÷ 0031 ÷ 002C ÷ 3031 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
3598
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u3031",
3599
 
                     new String[] { "\u0031", "\u3031" });
3600
 
 
3601
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 3031 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
3602
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u3031",
3603
 
                     new String[] { "\u0031", "\u3031" });
3604
 
 
3605
 
    // ÷ 0031 ÷ 002C ÷ 0041 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
3606
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0041",
3607
 
                     new String[] { "\u0031", "\u0041" });
3608
 
 
3609
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 0041 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
3610
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0041",
3611
 
                     new String[] { "\u0031", "\u0041" });
3612
 
 
3613
 
    // ÷ 0031 ÷ 002C ÷ 003A ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3614
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u003A",
3615
 
                     new String[] { "\u0031" });
3616
 
 
3617
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 003A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3618
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u003A",
3619
 
                     new String[] { "\u0031" });
3620
 
 
3621
 
    // ÷ 0031 ÷ 002C ÷ 002C ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3622
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u002C",
3623
 
                     new String[] { "\u0031" });
3624
 
 
3625
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 002C ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3626
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u002C",
3627
 
                     new String[] { "\u0031" });
3628
 
 
3629
 
    // ÷ 0031 ÷ 002C ÷ 0027 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3630
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0027",
3631
 
                     new String[] { "\u0031" });
3632
 
 
3633
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3634
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0027",
3635
 
                     new String[] { "\u0031" });
3636
 
 
3637
 
    // ÷ 0031 × 002C × 0030 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]
3638
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0030",
3639
 
                     new String[] { "\u0031\u002C\u0030" });
3640
 
 
3641
 
    // ÷ 0031 × 002C × 0308 × 0030 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]
3642
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0030",
3643
 
                     new String[] { "\u0031\u002C\u0308\u0030" });
3644
 
 
3645
 
    // ÷ 0031 ÷ 002C ÷ 005F ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
3646
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u005F",
3647
 
                     new String[] { "\u0031" });
3648
 
 
3649
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 005F ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
3650
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u005F",
3651
 
                     new String[] { "\u0031" });
3652
 
 
3653
 
    // ÷ 0031 ÷ 002C × 00AD ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
3654
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u00AD",
3655
 
                     new String[] { "\u0031" });
3656
 
 
3657
 
    // ÷ 0031 ÷ 002C × 0308 × 00AD ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
3658
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u00AD",
3659
 
                     new String[] { "\u0031" });
3660
 
 
3661
 
    // ÷ 0031 ÷ 002C × 0300 ÷   #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
3662
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0300",
3663
 
                     new String[] { "\u0031" });
3664
 
 
3665
 
    // ÷ 0031 ÷ 002C × 0308 × 0300 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
3666
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0300",
3667
 
                     new String[] { "\u0031" });
3668
 
 
3669
 
    // ÷ 0031 ÷ 002C ÷ 0061 × 2060 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3670
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0061\u2060",
3671
 
                     new String[] { "\u0031", "\u0061\u2060" });
3672
 
 
3673
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 0061 × 2060 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3674
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0061\u2060",
3675
 
                     new String[] { "\u0031", "\u0061\u2060" });
3676
 
 
3677
 
    // ÷ 0031 ÷ 002C ÷ 0061 ÷ 003A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3678
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0061\u003A",
3679
 
                     new String[] { "\u0031", "\u0061" });
3680
 
 
3681
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 0061 ÷ 003A ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3682
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0061\u003A",
3683
 
                     new String[] { "\u0031", "\u0061" });
3684
 
 
3685
 
    // ÷ 0031 ÷ 002C ÷ 0061 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3686
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0061\u0027",
3687
 
                     new String[] { "\u0031", "\u0061" });
3688
 
 
3689
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 0061 ÷ 0027 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3690
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0061\u0027",
3691
 
                     new String[] { "\u0031", "\u0061" });
3692
 
 
3693
 
    // ÷ 0031 ÷ 002C ÷ 0061 ÷ 0027 × 2060 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3694
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0061\u0027\u2060",
3695
 
                     new String[] { "\u0031", "\u0061" });
3696
 
 
3697
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 0061 ÷ 0027 × 2060 ÷      #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3698
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0061\u0027\u2060",
3699
 
                     new String[] { "\u0031", "\u0061" });
3700
 
 
3701
 
    // ÷ 0031 ÷ 002C ÷ 0061 ÷ 002C ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3702
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0061\u002C",
3703
 
                     new String[] { "\u0031", "\u0061" });
3704
 
 
3705
 
    // ÷ 0031 ÷ 002C × 0308 ÷ 0061 ÷ 002C ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3706
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0061\u002C",
3707
 
                     new String[] { "\u0031", "\u0061" });
3708
 
 
3709
 
    // ÷ 0031 × 002C × 0031 ÷ 003A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3710
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0031\u003A",
3711
 
                     new String[] { "\u0031\u002C\u0031" });
3712
 
 
3713
 
    // ÷ 0031 × 002C × 0308 × 0031 ÷ 003A ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3714
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0031\u003A",
3715
 
                     new String[] { "\u0031\u002C\u0308\u0031" });
3716
 
 
3717
 
    // ÷ 0031 × 002C × 0031 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3718
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0031\u0027",
3719
 
                     new String[] { "\u0031\u002C\u0031" });
3720
 
 
3721
 
    // ÷ 0031 × 002C × 0308 × 0031 ÷ 0027 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3722
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0031\u0027",
3723
 
                     new String[] { "\u0031\u002C\u0308\u0031" });
3724
 
 
3725
 
    // ÷ 0031 × 002C × 0031 ÷ 002C ÷    #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3726
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0031\u002C",
3727
 
                     new String[] { "\u0031\u002C\u0031" });
3728
 
 
3729
 
    // ÷ 0031 × 002C × 0308 × 0031 ÷ 002C ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3730
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0031\u002C",
3731
 
                     new String[] { "\u0031\u002C\u0308\u0031" });
3732
 
 
3733
 
    // ÷ 0031 × 002C × 0031 ÷ 002E × 2060 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3734
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0031\u002E\u2060",
3735
 
                     new String[] { "\u0031\u002C\u0031" });
3736
 
 
3737
 
    // ÷ 0031 × 002C × 0308 × 0031 ÷ 002E × 2060 ÷      #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] COMMA (MidNum) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3738
 
    assertAnalyzesTo(analyzer, "\u0031\u002C\u0308\u0031\u002E\u2060",
3739
 
                     new String[] { "\u0031\u002C\u0308\u0031" });
3740
 
 
3741
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 0001 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
3742
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0001",
3743
 
                     new String[] { "\u0031" });
3744
 
 
3745
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 0001 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
3746
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0001",
3747
 
                     new String[] { "\u0031" });
3748
 
 
3749
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 000D ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
3750
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\r",
3751
 
                     new String[] { "\u0031" });
3752
 
 
3753
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 000D ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
3754
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\r",
3755
 
                     new String[] { "\u0031" });
3756
 
 
3757
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 000A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
3758
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\n",
3759
 
                     new String[] { "\u0031" });
3760
 
 
3761
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 000A ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE FEED (LF)> (LF) ÷ [0.3]
3762
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\n",
3763
 
                     new String[] { "\u0031" });
3764
 
 
3765
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 000B ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
3766
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u000B",
3767
 
                     new String[] { "\u0031" });
3768
 
 
3769
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 000B ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.11] <LINE TABULATION> (Newline) ÷ [0.3]
3770
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u000B",
3771
 
                     new String[] { "\u0031" });
3772
 
 
3773
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 3031 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
3774
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u3031",
3775
 
                     new String[] { "\u0031", "\u3031" });
3776
 
 
3777
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 3031 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
3778
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u3031",
3779
 
                     new String[] { "\u0031", "\u3031" });
3780
 
 
3781
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 0041 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
3782
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0041",
3783
 
                     new String[] { "\u0031", "\u0041" });
3784
 
 
3785
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 0041 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
3786
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0041",
3787
 
                     new String[] { "\u0031", "\u0041" });
3788
 
 
3789
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 003A ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3790
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u003A",
3791
 
                     new String[] { "\u0031" });
3792
 
 
3793
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 003A ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3794
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u003A",
3795
 
                     new String[] { "\u0031" });
3796
 
 
3797
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 002C ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3798
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u002C",
3799
 
                     new String[] { "\u0031" });
3800
 
 
3801
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 002C ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3802
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u002C",
3803
 
                     new String[] { "\u0031" });
3804
 
 
3805
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 0027 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3806
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0027",
3807
 
                     new String[] { "\u0031" });
3808
 
 
3809
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 0027 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3810
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0027",
3811
 
                     new String[] { "\u0031" });
3812
 
 
3813
 
    // ÷ 0031 × 002E × 2060 × 0030 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]
3814
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0030",
3815
 
                     new String[] { "\u0031\u002E\u2060\u0030" });
3816
 
 
3817
 
    // ÷ 0031 × 002E × 2060 × 0308 × 0030 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ZERO (Numeric) ÷ [0.3]
3818
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0030",
3819
 
                     new String[] { "\u0031\u002E\u2060\u0308\u0030" });
3820
 
 
3821
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 005F ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
3822
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u005F",
3823
 
                     new String[] { "\u0031" });
3824
 
 
3825
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 005F ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
3826
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u005F",
3827
 
                     new String[] { "\u0031" });
3828
 
 
3829
 
    // ÷ 0031 ÷ 002E × 2060 × 00AD ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
3830
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u00AD",
3831
 
                     new String[] { "\u0031" });
3832
 
 
3833
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 × 00AD ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
3834
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u00AD",
3835
 
                     new String[] { "\u0031" });
3836
 
 
3837
 
    // ÷ 0031 ÷ 002E × 2060 × 0300 ÷    #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
3838
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0300",
3839
 
                     new String[] { "\u0031" });
3840
 
 
3841
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 × 0300 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
3842
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0300",
3843
 
                     new String[] { "\u0031" });
3844
 
 
3845
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 0061 × 2060 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3846
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0061\u2060",
3847
 
                     new String[] { "\u0031", "\u0061\u2060" });
3848
 
 
3849
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 0061 × 2060 ÷      #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3850
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0061\u2060",
3851
 
                     new String[] { "\u0031", "\u0061\u2060" });
3852
 
 
3853
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 0061 ÷ 003A ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3854
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0061\u003A",
3855
 
                     new String[] { "\u0031", "\u0061" });
3856
 
 
3857
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 0061 ÷ 003A ÷      #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3858
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0061\u003A",
3859
 
                     new String[] { "\u0031", "\u0061" });
3860
 
 
3861
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 0061 ÷ 0027 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3862
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0061\u0027",
3863
 
                     new String[] { "\u0031", "\u0061" });
3864
 
 
3865
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 0061 ÷ 0027 ÷      #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3866
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0061\u0027",
3867
 
                     new String[] { "\u0031", "\u0061" });
3868
 
 
3869
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 0061 ÷ 0027 × 2060 ÷      #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3870
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0061\u0027\u2060",
3871
 
                     new String[] { "\u0031", "\u0061" });
3872
 
 
3873
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 0061 ÷ 0027 × 2060 ÷       #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3874
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0061\u0027\u2060",
3875
 
                     new String[] { "\u0031", "\u0061" });
3876
 
 
3877
 
    // ÷ 0031 ÷ 002E × 2060 ÷ 0061 ÷ 002C ÷     #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3878
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0061\u002C",
3879
 
                     new String[] { "\u0031", "\u0061" });
3880
 
 
3881
 
    // ÷ 0031 ÷ 002E × 2060 × 0308 ÷ 0061 ÷ 002C ÷      #  ÷ [0.2] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3882
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0061\u002C",
3883
 
                     new String[] { "\u0031", "\u0061" });
3884
 
 
3885
 
    // ÷ 0031 × 002E × 2060 × 0031 ÷ 003A ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3886
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0031\u003A",
3887
 
                     new String[] { "\u0031\u002E\u2060\u0031" });
3888
 
 
3889
 
    // ÷ 0031 × 002E × 2060 × 0308 × 0031 ÷ 003A ÷      #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
3890
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0031\u003A",
3891
 
                     new String[] { "\u0031\u002E\u2060\u0308\u0031" });
3892
 
 
3893
 
    // ÷ 0031 × 002E × 2060 × 0031 ÷ 0027 ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3894
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0031\u0027",
3895
 
                     new String[] { "\u0031\u002E\u2060\u0031" });
3896
 
 
3897
 
    // ÷ 0031 × 002E × 2060 × 0308 × 0031 ÷ 0027 ÷      #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (MidNumLet) ÷ [0.3]
3898
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0031\u0027",
3899
 
                     new String[] { "\u0031\u002E\u2060\u0308\u0031" });
3900
 
 
3901
 
    // ÷ 0031 × 002E × 2060 × 0031 ÷ 002C ÷     #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3902
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0031\u002C",
3903
 
                     new String[] { "\u0031\u002E\u2060\u0031" });
3904
 
 
3905
 
    // ÷ 0031 × 002E × 2060 × 0308 × 0031 ÷ 002C ÷      #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
3906
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0031\u002C",
3907
 
                     new String[] { "\u0031\u002E\u2060\u0308\u0031" });
3908
 
 
3909
 
    // ÷ 0031 × 002E × 2060 × 0031 ÷ 002E × 2060 ÷      #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3910
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0031\u002E\u2060",
3911
 
                     new String[] { "\u0031\u002E\u2060\u0031" });
3912
 
 
3913
 
    // ÷ 0031 × 002E × 2060 × 0308 × 0031 ÷ 002E × 2060 ÷       #  ÷ [0.2] DIGIT ONE (Numeric) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [11.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3914
 
    assertAnalyzesTo(analyzer, "\u0031\u002E\u2060\u0308\u0031\u002E\u2060",
3915
 
                     new String[] { "\u0031\u002E\u2060\u0308\u0031" });
3916
 
 
3917
 
    // ÷ 0063 × 0061 × 006E × 0027 × 0074 ÷     #  ÷ [0.2] LATIN SMALL LETTER C (ALetter) × [5.0] LATIN SMALL LETTER A (ALetter) × [5.0] LATIN SMALL LETTER N (ALetter) × [6.0] APOSTROPHE (MidNumLet) × [7.0] LATIN SMALL LETTER T (ALetter) ÷ [0.3]
3918
 
    assertAnalyzesTo(analyzer, "\u0063\u0061\u006E\u0027\u0074",
3919
 
                     new String[] { "\u0063\u0061\u006E\u0027\u0074" });
3920
 
 
3921
 
    // ÷ 0063 × 0061 × 006E × 2019 × 0074 ÷     #  ÷ [0.2] LATIN SMALL LETTER C (ALetter) × [5.0] LATIN SMALL LETTER A (ALetter) × [5.0] LATIN SMALL LETTER N (ALetter) × [6.0] RIGHT SINGLE QUOTATION MARK (MidNumLet) × [7.0] LATIN SMALL LETTER T (ALetter) ÷ [0.3]
3922
 
    assertAnalyzesTo(analyzer, "\u0063\u0061\u006E\u2019\u0074",
3923
 
                     new String[] { "\u0063\u0061\u006E\u2019\u0074" });
3924
 
 
3925
 
    // ÷ 0061 × 0062 × 00AD × 0062 × 0079 ÷     #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) × [5.0] LATIN SMALL LETTER B (ALetter) × [4.0] SOFT HYPHEN (Format_FE) × [5.0] LATIN SMALL LETTER B (ALetter) × [5.0] LATIN SMALL LETTER Y (ALetter) ÷ [0.3]
3926
 
    assertAnalyzesTo(analyzer, "\u0061\u0062\u00AD\u0062\u0079",
3927
 
                     new String[] { "\u0061\u0062\u00AD\u0062\u0079" });
3928
 
 
3929
 
    // ÷ 0061 ÷ 0024 ÷ 002D ÷ 0033 × 0034 × 002C × 0035 × 0036 × 0037 × 002E × 0031 × 0034 ÷ 0025 ÷ 0062 ÷      #  ÷ [0.2] LATIN SMALL LETTER A (ALetter) ÷ [999.0] DOLLAR SIGN (Other) ÷ [999.0] HYPHEN-MINUS (Other) ÷ [999.0] DIGIT THREE (Numeric) × [8.0] DIGIT FOUR (Numeric) × [12.0] COMMA (MidNum) × [11.0] DIGIT FIVE (Numeric) × [8.0] DIGIT SIX (Numeric) × [8.0] DIGIT SEVEN (Numeric) × [12.0] FULL STOP (MidNumLet) × [11.0] DIGIT ONE (Numeric) × [8.0] DIGIT FOUR (Numeric) ÷ [999.0] PERCENT SIGN (Other) ÷ [999.0] LATIN SMALL LETTER B (ALetter) ÷ [0.3]
3930
 
    assertAnalyzesTo(analyzer, "\u0061\u0024\u002D\u0033\u0034\u002C\u0035\u0036\u0037\u002E\u0031\u0034\u0025\u0062",
3931
 
                     new String[] { "\u0061", "\u0033\u0034\u002C\u0035\u0036\u0037\u002E\u0031\u0034", "\u0062" });
3932
 
 
3933
 
    // ÷ 0033 × 0061 ÷  #  ÷ [0.2] DIGIT THREE (Numeric) × [10.0] LATIN SMALL LETTER A (ALetter) ÷ [0.3]
3934
 
    assertAnalyzesTo(analyzer, "\u0033\u0061",
3935
 
                     new String[] { "\u0033\u0061" });
3936
 
 
3937
 
    // ÷ 2060 ÷ 0063 × 2060 × 0061 × 2060 × 006E × 2060 × 0027 × 2060 × 0074 × 2060 × 2060 ÷    #  ÷ [0.2] WORD JOINER (Format_FE) ÷ [999.0] LATIN SMALL LETTER C (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER N (ALetter) × [4.0] WORD JOINER (Format_FE) × [6.0] APOSTROPHE (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [7.0] LATIN SMALL LETTER T (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3938
 
    assertAnalyzesTo(analyzer, "\u2060\u0063\u2060\u0061\u2060\u006E\u2060\u0027\u2060\u0074\u2060\u2060",
3939
 
                     new String[] { "\u0063\u2060\u0061\u2060\u006E\u2060\u0027\u2060\u0074\u2060\u2060" });
3940
 
 
3941
 
    // ÷ 2060 ÷ 0063 × 2060 × 0061 × 2060 × 006E × 2060 × 2019 × 2060 × 0074 × 2060 × 2060 ÷    #  ÷ [0.2] WORD JOINER (Format_FE) ÷ [999.0] LATIN SMALL LETTER C (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER N (ALetter) × [4.0] WORD JOINER (Format_FE) × [6.0] RIGHT SINGLE QUOTATION MARK (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [7.0] LATIN SMALL LETTER T (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3942
 
    assertAnalyzesTo(analyzer, "\u2060\u0063\u2060\u0061\u2060\u006E\u2060\u2019\u2060\u0074\u2060\u2060",
3943
 
                     new String[] { "\u0063\u2060\u0061\u2060\u006E\u2060\u2019\u2060\u0074\u2060\u2060" });
3944
 
 
3945
 
    // ÷ 2060 ÷ 0061 × 2060 × 0062 × 2060 × 00AD × 2060 × 0062 × 2060 × 0079 × 2060 × 2060 ÷    #  ÷ [0.2] WORD JOINER (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER B (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] SOFT HYPHEN (Format_FE) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER B (ALetter) × [4.0] WORD JOINER (Format_FE) × [5.0] LATIN SMALL LETTER Y (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3946
 
    assertAnalyzesTo(analyzer, "\u2060\u0061\u2060\u0062\u2060\u00AD\u2060\u0062\u2060\u0079\u2060\u2060",
3947
 
                     new String[] { "\u0061\u2060\u0062\u2060\u00AD\u2060\u0062\u2060\u0079\u2060\u2060" });
3948
 
 
3949
 
    // ÷ 2060 ÷ 0061 × 2060 ÷ 0024 × 2060 ÷ 002D × 2060 ÷ 0033 × 2060 × 0034 × 2060 × 002C × 2060 × 0035 × 2060 × 0036 × 2060 × 0037 × 2060 × 002E × 2060 × 0031 × 2060 × 0034 × 2060 ÷ 0025 × 2060 ÷ 0062 × 2060 × 2060 ÷      #  ÷ [0.2] WORD JOINER (Format_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] DOLLAR SIGN (Other) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] HYPHEN-MINUS (Other) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] DIGIT THREE (Numeric) × [4.0] WORD JOINER (Format_FE) × [8.0] DIGIT FOUR (Numeric) × [4.0] WORD JOINER (Format_FE) × [12.0] COMMA (MidNum) × [4.0] WORD JOINER (Format_FE) × [11.0] DIGIT FIVE (Numeric) × [4.0] WORD JOINER (Format_FE) × [8.0] DIGIT SIX (Numeric) × [4.0] WORD JOINER (Format_FE) × [8.0] DIGIT SEVEN (Numeric) × [4.0] WORD JOINER (Format_FE) × [12.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) × [11.0] DIGIT ONE (Numeric) × [4.0] WORD JOINER (Format_FE) × [8.0] DIGIT FOUR (Numeric) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] PERCENT SIGN (Other) × [4.0] WORD JOINER (Format_FE) ÷ [999.0] LATIN SMALL LETTER B (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3950
 
    assertAnalyzesTo(analyzer, "\u2060\u0061\u2060\u0024\u2060\u002D\u2060\u0033\u2060\u0034\u2060\u002C\u2060\u0035\u2060\u0036\u2060\u0037\u2060\u002E\u2060\u0031\u2060\u0034\u2060\u0025\u2060\u0062\u2060\u2060",
3951
 
                     new String[] { "\u0061\u2060", "\u0033\u2060\u0034\u2060\u002C\u2060\u0035\u2060\u0036\u2060\u0037\u2060\u002E\u2060\u0031\u2060\u0034\u2060", "\u0062\u2060\u2060" });
3952
 
 
3953
 
    // ÷ 2060 ÷ 0033 × 2060 × 0061 × 2060 × 2060 ÷      #  ÷ [0.2] WORD JOINER (Format_FE) ÷ [999.0] DIGIT THREE (Numeric) × [4.0] WORD JOINER (Format_FE) × [10.0] LATIN SMALL LETTER A (ALetter) × [4.0] WORD JOINER (Format_FE) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
3954
 
    assertAnalyzesTo(analyzer, "\u2060\u0033\u2060\u0061\u2060\u2060",
3955
 
                     new String[] { "\u0033\u2060\u0061\u2060\u2060" });
3956
 
 
3957
 
  }
3958
 
}