SpannableStringBuilderTest.kt revision 3091829d6e5cf1c5e5af33614657bfeb4f2320ab 
1/*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *       http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package androidx.core.text
18
19import android.graphics.Color.RED
20import android.graphics.Color.YELLOW
21import android.graphics.Typeface.BOLD
22import android.graphics.Typeface.ITALIC
23import android.text.SpannedString
24import android.text.style.BackgroundColorSpan
25import android.text.style.BulletSpan
26import android.text.style.ForegroundColorSpan
27import android.text.style.RelativeSizeSpan
28import android.text.style.StrikethroughSpan
29import android.text.style.StyleSpan
30import android.text.style.SubscriptSpan
31import android.text.style.SuperscriptSpan
32import android.text.style.UnderlineSpan
33import org.junit.Assert.assertEquals
34import org.junit.Assert.assertSame
35import org.junit.Test
36
37class SpannableStringBuilderTest {
38    @Test fun builder() {
39        val result: SpannedString = buildSpannedString {
40            append("Hello,")
41            append(" World")
42        }
43        assertEquals("Hello, World", result.toString())
44    }
45
46    @Test fun builderInSpan() {
47        val bold = StyleSpan(BOLD)
48        val result: SpannedString = buildSpannedString {
49            append("Hello, ")
50            inSpans(bold) {
51                append("World")
52            }
53        }
54        assertEquals("Hello, World", result.toString())
55
56        val spans = result.getSpans<Any>()
57        assertEquals(1, spans.size)
58
59        val boldSpan = spans.filterIsInstance<StyleSpan>().single()
60        assertSame(bold, boldSpan)
61        assertEquals(7, result.getSpanStart(bold))
62        assertEquals(12, result.getSpanEnd(bold))
63    }
64
65    @Test fun builderBold() {
66        val result: SpannedString = buildSpannedString {
67            append("Hello, ")
68            bold {
69                append("World")
70            }
71        }
72        assertEquals("Hello, World", result.toString())
73
74        val spans = result.getSpans<Any>()
75        assertEquals(1, spans.size)
76
77        val bold = spans.filterIsInstance<StyleSpan>().single()
78        assertEquals(BOLD, bold.style)
79        assertEquals(7, result.getSpanStart(bold))
80        assertEquals(12, result.getSpanEnd(bold))
81    }
82
83    @Test fun builderItalic() {
84        val result: SpannedString = buildSpannedString {
85            append("Hello, ")
86            italic {
87                append("World")
88            }
89        }
90        assertEquals("Hello, World", result.toString())
91
92        val spans = result.getSpans<Any>()
93        assertEquals(1, spans.size)
94
95        val italic = spans.filterIsInstance<StyleSpan>().single()
96        assertEquals(ITALIC, italic.style)
97        assertEquals(7, result.getSpanStart(italic))
98        assertEquals(12, result.getSpanEnd(italic))
99    }
100
101    @Test fun builderUnderline() {
102        val result: SpannedString = buildSpannedString {
103            append("Hello, ")
104            underline {
105                append("World")
106            }
107        }
108        assertEquals("Hello, World", result.toString())
109
110        val spans = result.getSpans<Any>()
111        assertEquals(1, spans.size)
112
113        val underline = spans.filterIsInstance<UnderlineSpan>().single()
114        assertEquals(7, result.getSpanStart(underline))
115        assertEquals(12, result.getSpanEnd(underline))
116    }
117
118    @Test fun builderColor() {
119        val result: SpannedString = buildSpannedString {
120            append("Hello, ")
121            color(RED) {
122                append("World")
123            }
124        }
125        assertEquals("Hello, World", result.toString())
126
127        val spans = result.getSpans<Any>()
128        assertEquals(1, spans.size)
129
130        val color = spans.filterIsInstance<ForegroundColorSpan>().single()
131        assertEquals(RED, color.foregroundColor)
132        assertEquals(7, result.getSpanStart(color))
133        assertEquals(12, result.getSpanEnd(color))
134    }
135
136    @Test fun builderBackgroundColor() {
137        val result: SpannedString = buildSpannedString {
138            append("Hello, ")
139            backgroundColor(RED) {
140                append("World")
141            }
142        }
143        assertEquals("Hello, World", result.toString())
144
145        val spans = result.getSpans<Any>()
146        assertEquals(1, spans.size)
147
148        val color = spans.filterIsInstance<BackgroundColorSpan>().single()
149        assertEquals(RED, color.backgroundColor)
150        assertEquals(7, result.getSpanStart(color))
151        assertEquals(12, result.getSpanEnd(color))
152    }
153
154    @Test fun builderStrikeThrough() {
155        val result: SpannedString = buildSpannedString {
156            append("Hello, ")
157            strikeThrough {
158                append("World")
159            }
160        }
161        assertEquals("Hello, World", result.toString())
162
163        val spans = result.getSpans<Any>()
164        assertEquals(1, spans.size)
165
166        val strikeThrough = spans.filterIsInstance<StrikethroughSpan>().single()
167        assertEquals(7, result.getSpanStart(strikeThrough))
168        assertEquals(12, result.getSpanEnd(strikeThrough))
169    }
170
171    @Test fun builderScale() {
172        val result: SpannedString = buildSpannedString {
173            append("Hello, ")
174            scale(2f) {
175                append("World")
176            }
177        }
178        assertEquals("Hello, World", result.toString())
179
180        val spans = result.getSpans<Any>()
181        assertEquals(1, spans.size)
182
183        val scale = spans.filterIsInstance<RelativeSizeSpan>().single()
184        assertEquals(2f, scale.sizeChange)
185        assertEquals(7, result.getSpanStart(scale))
186        assertEquals(12, result.getSpanEnd(scale))
187    }
188
189    @Test fun builderSuperscript() {
190        val result: SpannedString = buildSpannedString {
191            append("Hello, ")
192            superscript {
193                append("World")
194            }
195        }
196        assertEquals("Hello, World", result.toString())
197
198        val spans = result.getSpans<Any>()
199        assertEquals(1, spans.size)
200
201        val superscript = spans.filterIsInstance<SuperscriptSpan>().single()
202        assertEquals(7, result.getSpanStart(superscript))
203        assertEquals(12, result.getSpanEnd(superscript))
204    }
205
206    @Test fun builderSubscript() {
207        val result: SpannedString = buildSpannedString {
208            append("Hello, ")
209            subscript {
210                append("World")
211            }
212        }
213        assertEquals("Hello, World", result.toString())
214
215        val spans = result.getSpans<Any>()
216        assertEquals(1, spans.size)
217
218        val subscript = spans.filterIsInstance<SubscriptSpan>().single()
219        assertEquals(7, result.getSpanStart(subscript))
220        assertEquals(12, result.getSpanEnd(subscript))
221    }
222
223    @Test fun nested() {
224        val result: SpannedString = buildSpannedString {
225            color(RED) {
226                append('H')
227                subscript {
228                    append('e')
229                }
230                append('l')
231                superscript {
232                    append('l')
233                }
234                append('o')
235            }
236            append(", ")
237            backgroundColor(YELLOW) {
238                append('W')
239                underline {
240                    append('o')
241                    bold {
242                        append('r')
243                    }
244                    append('l')
245                }
246                append('d')
247            }
248        }
249        assertEquals("Hello, World", result.toString())
250
251        val spans = result.getSpans<Any>()
252        assertEquals(6, spans.size)
253
254        val color = spans.filterIsInstance<ForegroundColorSpan>().single()
255        assertEquals(RED, color.foregroundColor)
256        assertEquals(0, result.getSpanStart(color))
257        assertEquals(5, result.getSpanEnd(color))
258
259        val subscript = spans.filterIsInstance<SubscriptSpan>().single()
260        assertEquals(1, result.getSpanStart(subscript))
261        assertEquals(2, result.getSpanEnd(subscript))
262
263        val superscript = spans.filterIsInstance<SuperscriptSpan>().single()
264        assertEquals(3, result.getSpanStart(superscript))
265        assertEquals(4, result.getSpanEnd(superscript))
266
267        val backgroundColor = spans.filterIsInstance<BackgroundColorSpan>().single()
268        assertEquals(YELLOW, backgroundColor.backgroundColor)
269        assertEquals(7, result.getSpanStart(backgroundColor))
270        assertEquals(12, result.getSpanEnd(backgroundColor))
271
272        val underline = spans.filterIsInstance<UnderlineSpan>().single()
273        assertEquals(8, result.getSpanStart(underline))
274        assertEquals(11, result.getSpanEnd(underline))
275
276        val bold = spans.filterIsInstance<StyleSpan>().single()
277        assertEquals(BOLD, bold.style)
278        assertEquals(9, result.getSpanStart(bold))
279        assertEquals(10, result.getSpanEnd(bold))
280    }
281
282    @Test fun multipleSpans() {
283        val result: SpannedString = buildSpannedString {
284            append("Hello, ")
285            inSpans(BulletSpan(), UnderlineSpan()) {
286                append("World")
287            }
288        }
289        assertEquals("Hello, World", result.toString())
290
291        val spans = result.getSpans<Any>()
292        assertEquals(2, spans.size)
293
294        val bullet = spans.filterIsInstance<BulletSpan>().single()
295        assertEquals(7, result.getSpanStart(bullet))
296        assertEquals(12, result.getSpanEnd(bullet))
297        val underline = spans.filterIsInstance<UnderlineSpan>().single()
298        assertEquals(7, result.getSpanStart(underline))
299        assertEquals(12, result.getSpanEnd(underline))
300    }
301}
302