[go: nahoru, domu]
Google Git
Sign in
android / platform / frameworks / support / 01f7b52dc1d470dbf7d1c4e6496e7cd3334e5f89 / . / ui / ui-text / src / androidTest / java / androidx / ui / text / platform / AndroidParagraphTest.kt
blob: 174eb7e3e6bcbd525ecec0edfed4e75e456c4acb [file] [log] [blame]
Siyamed Sinirff51df92019-07-02 15:35:20 -0700[diff] [blame]1package androidx.ui.text.platform
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]2
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]3import android.graphics.Paint
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]4import android.text.TextPaint
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]5import android.text.style.AbsoluteSizeSpan
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]6import android.text.style.BackgroundColorSpan
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]7import android.text.style.ForegroundColorSpan
Haoyu Zhang7fc59172019-03-01 17:03:31 -0800[diff] [blame]8import android.text.style.LeadingMarginSpan
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]9import android.text.style.LocaleSpan
Haoyu Zhang24eb32f2019-05-21 16:16:37 -0700[diff] [blame]10import android.text.style.RelativeSizeSpan
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]11import android.text.style.ScaleXSpan
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]12import android.text.style.StrikethroughSpan
13import android.text.style.UnderlineSpan
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]14import androidx.test.filters.SmallTest
15import androidx.test.platform.app.InstrumentationRegistry
Siyamed Sinir97d0ccf2019-11-02 02:51:24 -0700[diff] [blame]16import androidx.text.TextLayout
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]17import androidx.text.style.BaselineShiftSpan
Haoyu Zhang588aaef2019-02-20 14:47:39 -0800[diff] [blame]18import androidx.text.style.FontFeatureSpan
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]19import androidx.text.style.LetterSpacingSpan
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]20import androidx.text.style.ShadowSpan
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]21import androidx.text.style.SkewXSpan
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]22import androidx.text.style.TypefaceSpan
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]23import androidx.ui.core.Density
Haoyu Zhangf2e9e032019-10-16 15:23:39 -0700[diff] [blame]24import androidx.ui.core.em
Haoyu Zhang7fc59172019-03-01 17:03:31 -0800[diff] [blame]25import androidx.ui.core.px
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]26import androidx.ui.core.sp
27import androidx.ui.core.withDensity
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]28import androidx.ui.engine.geometry.Offset
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]29import androidx.ui.graphics.Color
Nader Jawadad983532019-08-29 16:27:37 -0700[diff] [blame]30import androidx.ui.graphics.Shadow
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]31import androidx.ui.graphics.toArgb
32import androidx.ui.text.AnnotatedString
33import androidx.ui.text.FontTestData.Companion.BASIC_MEASURE_FONT
Seigo Nonaka8de69792019-09-04 14:55:15 -0700[diff] [blame]34import androidx.ui.text.LocaleList
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]35import androidx.ui.text.ParagraphConstraints
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]36import androidx.ui.text.SpanStyle
Siyamed Sinirc4c308e2019-07-03 16:14:22 -0700[diff] [blame]37import androidx.ui.text.TestFontResourceLoader
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]38import androidx.ui.text.TextStyle
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]39import androidx.ui.text.font.FontFamily
40import androidx.ui.text.font.FontStyle
41import androidx.ui.text.font.FontSynthesis
42import androidx.ui.text.font.FontWeight
43import androidx.ui.text.font.asFontFamily
44import androidx.ui.text.matchers.assertThat
45import androidx.ui.text.style.BaselineShift
46import androidx.ui.text.style.TextAlign
47import androidx.ui.text.style.TextDecoration
Seigo Nonakac4f136a2019-08-16 16:48:44 -0700[diff] [blame]48import androidx.ui.text.style.TextDirectionAlgorithm
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]49import androidx.ui.text.style.TextGeometricTransform
50import androidx.ui.text.style.TextIndent
51import com.google.common.truth.Truth.assertThat
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]52import com.nhaarman.mockitokotlin2.any
53import com.nhaarman.mockitokotlin2.eq
54import com.nhaarman.mockitokotlin2.mock
55import com.nhaarman.mockitokotlin2.never
56import com.nhaarman.mockitokotlin2.spy
57import com.nhaarman.mockitokotlin2.times
58import com.nhaarman.mockitokotlin2.verify
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]59import org.junit.Test
60import org.junit.runner.RunWith
61import org.junit.runners.JUnit4
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]62import kotlin.math.ceil
63
64@RunWith(JUnit4::class)
65@SmallTest
Siyamed Sinire75976f2019-07-03 09:24:30 -0700[diff] [blame]66class AndroidParagraphTest {
Siyamed Sinir472ed132019-07-03 15:43:43 -0700[diff] [blame]67 // This sample font provides the following features:
68 // 1. The width of most of visible characters equals to font size.
69 // 2. The LTR/RTL characters are rendered as â–¶/â—€.
70 // 3. The fontMetrics passed to TextPaint has descend - ascend equal to 1.2 * fontSize.
71 private val fontFamily = BASIC_MEASURE_FONT.asFontFamily()
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]72 private val defaultDensity = Density(density = 1f)
Siyamed Sinir472ed132019-07-03 15:43:43 -0700[diff] [blame]73 private val context = InstrumentationRegistry.getInstrumentation().context
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]74
75 @Test
76 fun draw_with_newline_and_line_break_default_values() {
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]77 withDensity(defaultDensity) {
78 val fontSize = 50.sp
79 for (text in arrayOf("abc\ndef", "\u05D0\u05D1\u05D2\n\u05D3\u05D4\u05D5")) {
80 val paragraphAndroid = simpleParagraph(
81 text = text,
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]82 style = TextStyle(
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]83 fontSize = fontSize,
84 fontFamily = fontFamily
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]85 ),
86 // 2 chars width
87 constraints = ParagraphConstraints(width = 2 * fontSize.toPx().value)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]88 )
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]89
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]90 val textPaint = TextPaint(Paint.ANTI_ALIAS_FLAG)
91 textPaint.textSize = fontSize.toPx().value
92 textPaint.typeface = TypefaceAdapter().create(fontFamily)
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]93
Siyamed Sinir97d0ccf2019-11-02 02:51:24 -0700[diff] [blame]94 val layout = TextLayout(
95 charSequence = text,
96 width = ceil(paragraphAndroid.width),
97 textPaint = textPaint
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]98 )
Siyamed Sinir97d0ccf2019-11-02 02:51:24 -0700[diff] [blame]99
100 assertThat(paragraphAndroid.bitmap()).isEqualToBitmap(layout.bitmap())
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]101 }
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]102 }
103 }
104
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]105 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]106 fun testAnnotatedString_setColorOnWholeText() {
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]107 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]108 val spanStyle = SpanStyle(color = Color(0xFF0000FF))
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]109
110 val paragraph = simpleParagraph(
111 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]112 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]113 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]114 )
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]115
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]116 assertThat(paragraph.charSequence).hasSpan(ForegroundColorSpan::class, 0, text.length)
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]117 }
118
119 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]120 fun testAnnotatedString_setColorOnPartOfText() {
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]121 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]122 val spanStyle = SpanStyle(color = Color(0xFF0000FF))
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]123
124 val paragraph = simpleParagraph(
125 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]126 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, "abc".length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]127 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]128 )
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]129
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]130 assertThat(paragraph.charSequence).hasSpan(ForegroundColorSpan::class, 0, "abc".length)
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]131 }
132
133 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]134 fun testAnnotatedString_setColorTwice_lastOneOverwrite() {
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]135 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]136 val spanStyle = SpanStyle(color = Color(0xFF0000FF))
137 val spanStyleOverwrite = SpanStyle(color = Color(0xFF00FF00))
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]138
139 val paragraph = simpleParagraph(
140 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]141 spanStyles = listOf(
142 AnnotatedString.Item(spanStyle, 0, text.length),
143 AnnotatedString.Item(spanStyleOverwrite, 0, "abc".length)
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]144 ),
145 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]146 )
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]147
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]148 assertThat(paragraph.charSequence).hasSpan(ForegroundColorSpan::class, 0, text.length)
149 assertThat(paragraph.charSequence).hasSpan(ForegroundColorSpan::class, 0, "abc".length)
150 assertThat(paragraph.charSequence).hasSpanOnTop(ForegroundColorSpan::class, 0, "abc".length)
Haoyu Zhang47f57a22018-12-12 13:16:40 -0800[diff] [blame]151 }
152
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]153 @Test
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]154 fun testStyle_setTextDecorationOnWholeText_withLineThrough() {
155 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]156 val spanStyle = SpanStyle(decoration = TextDecoration.LineThrough)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]157
158 val paragraph = simpleParagraph(
159 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]160 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]161 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]162 )
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]163
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]164 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
165 assertThat(paragraph.charSequence).hasSpan(StrikethroughSpan::class, 0, text.length)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]166 }
167
168 @Test
169 fun testStyle_setTextDecorationOnWholeText_withUnderline() {
170 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]171 val spanStyle = SpanStyle(decoration = TextDecoration.Underline)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]172
173 val paragraph = simpleParagraph(
174 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]175 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]176 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]177 )
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]178
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]179 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
180 assertThat(paragraph.charSequence).hasSpan(UnderlineSpan::class, 0, text.length)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]181 }
182
183 @Test
184 fun testStyle_setTextDecorationOnPartText_withLineThrough() {
185 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]186 val spanStyle = SpanStyle(decoration = TextDecoration.LineThrough)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]187
188 val paragraph = simpleParagraph(
189 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]190 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, "abc".length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]191 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]192 )
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]193
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]194 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
195 assertThat(paragraph.charSequence).hasSpan(StrikethroughSpan::class, 0, "abc".length)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]196 }
197
198 @Test
199 fun testStyle_setTextDecorationOnPartText_withUnderline() {
200 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]201 val spanStyle = SpanStyle(decoration = TextDecoration.Underline)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]202
203 val paragraph = simpleParagraph(
204 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]205 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, "abc".length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]206 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]207 )
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]208
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]209 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
210 assertThat(paragraph.charSequence).hasSpan(UnderlineSpan::class, 0, "abc".length)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]211 }
212
213 @Test
214 fun testStyle_setTextDecoration_withLineThroughAndUnderline() {
215 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]216 val spanStyle = SpanStyle(
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]217 decoration = TextDecoration.combine(
Siyamed Sinir9fd89f42019-05-20 18:04:29 -0700[diff] [blame]218 listOf(TextDecoration.LineThrough, TextDecoration.Underline)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]219 )
220 )
221
222 val paragraph = simpleParagraph(
223 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]224 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, "abc".length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]225 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]226 )
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]227
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]228 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
229 assertThat(paragraph.charSequence).hasSpan(UnderlineSpan::class, 0, "abc".length)
230 assertThat(paragraph.charSequence).hasSpan(StrikethroughSpan::class, 0, "abc".length)
Haoyu Zhangb5677202018-12-19 14:22:18 -0800[diff] [blame]231 }
232
233 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]234 fun testAnnotatedString_setFontSizeOnWholeText() {
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]235 withDensity(defaultDensity) {
236 val text = "abcde"
237 val fontSize = 20.sp
238 val paragraphWidth = text.length * fontSize.toPx().value
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]239 val spanStyle = SpanStyle(fontSize = fontSize)
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]240
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]241 val paragraph = simpleParagraph(
242 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]243 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]244 constraints = ParagraphConstraints(width = paragraphWidth)
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]245 )
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]246
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]247 assertThat(paragraph.charSequence).hasSpan(AbsoluteSizeSpan::class, 0, text.length)
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]248 }
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]249 }
250
251 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]252 fun testAnnotatedString_setFontSizeOnPartText() {
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]253 withDensity(defaultDensity) {
254 val text = "abcde"
255 val fontSize = 20.sp
256 val paragraphWidth = text.length * fontSize.toPx().value
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]257 val spanStyle = SpanStyle(fontSize = fontSize)
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]258
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]259 val paragraph = simpleParagraph(
260 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]261 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, "abc".length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]262 constraints = ParagraphConstraints(width = paragraphWidth)
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]263 )
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]264
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]265 assertThat(paragraph.charSequence).hasSpan(AbsoluteSizeSpan::class, 0, "abc".length)
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]266 }
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]267 }
268
269 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]270 fun testAnnotatedString_setFontSizeTwice_lastOneOverwrite() {
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]271 withDensity(defaultDensity) {
272 val text = "abcde"
273 val fontSize = 20.sp
274 val fontSizeOverwrite = 30.sp
275 val paragraphWidth = text.length * fontSizeOverwrite.toPx().value
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]276 val spanStyle = SpanStyle(fontSize = fontSize)
277 val spanStyleOverwrite = SpanStyle(fontSize = fontSizeOverwrite)
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]278
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]279 val paragraph = simpleParagraph(
280 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]281 spanStyles = listOf(
282 AnnotatedString.Item(spanStyle, 0, text.length),
283 AnnotatedString.Item(spanStyleOverwrite, 0, "abc".length)
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]284 ),
285 constraints = ParagraphConstraints(width = paragraphWidth)
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]286 )
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]287
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]288 assertThat(paragraph.charSequence).hasSpan(AbsoluteSizeSpan::class, 0, text.length)
289 assertThat(paragraph.charSequence).hasSpan(AbsoluteSizeSpan::class, 0, "abc".length)
290 assertThat(paragraph.charSequence)
291 .hasSpanOnTop(AbsoluteSizeSpan::class, 0, "abc".length)
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]292 }
Haoyu Zhangbb51ccf2018-12-17 15:07:43 -0800[diff] [blame]293 }
294
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]295 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]296 fun testAnnotatedString_setFontSizeScaleOnWholeText() {
Haoyu Zhang24eb32f2019-05-21 16:16:37 -0700[diff] [blame]297 val text = "abcde"
Seigo Nonakad9638202019-11-19 16:37:07 -0800[diff] [blame]298 val fontSizeScale = 2.0.em
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]299 val spanStyle = SpanStyle(fontSize = fontSizeScale)
Haoyu Zhang24eb32f2019-05-21 16:16:37 -0700[diff] [blame]300
301 val paragraph = simpleParagraph(
302 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]303 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]304 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang24eb32f2019-05-21 16:16:37 -0700[diff] [blame]305 )
Haoyu Zhang24eb32f2019-05-21 16:16:37 -0700[diff] [blame]306
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]307 assertThat(paragraph.charSequence).hasSpan(RelativeSizeSpan::class, 0, text.length) {
Seigo Nonakad9638202019-11-19 16:37:07 -0800[diff] [blame]308 it.sizeChange == fontSizeScale.value
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]309 }
Haoyu Zhang24eb32f2019-05-21 16:16:37 -0700[diff] [blame]310 }
311
312 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]313 fun testAnnotatedString_setFontSizeScaleOnPartText() {
Haoyu Zhang24eb32f2019-05-21 16:16:37 -0700[diff] [blame]314 val text = "abcde"
Seigo Nonakad9638202019-11-19 16:37:07 -0800[diff] [blame]315 val fontSizeScale = 2.0f.em
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]316 val spanStyle = SpanStyle(fontSize = fontSizeScale)
Haoyu Zhang24eb32f2019-05-21 16:16:37 -0700[diff] [blame]317
318 val paragraph = simpleParagraph(
319 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]320 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, "abc".length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]321 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang24eb32f2019-05-21 16:16:37 -0700[diff] [blame]322 )
Haoyu Zhang24eb32f2019-05-21 16:16:37 -0700[diff] [blame]323
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]324 assertThat(paragraph.charSequence).hasSpan(RelativeSizeSpan::class, 0, "abc".length) {
Seigo Nonakad9638202019-11-19 16:37:07 -0800[diff] [blame]325 it.sizeChange == fontSizeScale.value
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]326 }
Haoyu Zhang24eb32f2019-05-21 16:16:37 -0700[diff] [blame]327 }
328
329 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]330 fun testAnnotatedString_setLetterSpacingOnWholeText() {
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]331 val text = "abcde"
George Mountb1cdd862018-12-21 10:54:42 -0800[diff] [blame]332 val letterSpacing = 2.0f
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]333 val spanStyle = SpanStyle(letterSpacing = letterSpacing.em)
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]334
335 val paragraph = simpleParagraph(
336 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]337 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]338 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]339 )
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]340
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]341 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
342 assertThat(paragraph.charSequence).hasSpan(LetterSpacingSpan::class, 0, text.length)
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]343 }
344
345 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]346 fun testAnnotatedString_setLetterSpacingOnPartText() {
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]347 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]348 val spanStyle = SpanStyle(letterSpacing = 2.em)
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]349
350 val paragraph = simpleParagraph(
351 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]352 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, "abc".length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]353 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]354 )
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]355
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]356 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
357 assertThat(paragraph.charSequence).hasSpan(LetterSpacingSpan::class, 0, "abc".length)
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]358 }
359
360 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]361 fun testAnnotatedString_setLetterSpacingTwice_lastOneOverwrite() {
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]362 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]363 val spanStyle = SpanStyle(letterSpacing = 2.em)
364 val spanStyleOverwrite = SpanStyle(letterSpacing = 3.em)
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]365
366 val paragraph = simpleParagraph(
367 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]368 spanStyles = listOf(
369 AnnotatedString.Item(spanStyle, 0, text.length),
370 AnnotatedString.Item(spanStyleOverwrite, 0, "abc".length)
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]371 ),
372 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]373 )
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]374
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]375 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
376 assertThat(paragraph.charSequence).hasSpan(LetterSpacingSpan::class, 0, text.length)
377 assertThat(paragraph.charSequence).hasSpan(LetterSpacingSpan::class, 0, "abc".length)
378 assertThat(paragraph.charSequence).hasSpanOnTop(LetterSpacingSpan::class, 0, "abc".length)
Haoyu Zhang1588ba0f2018-12-19 16:47:10 -0800[diff] [blame]379 }
380
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]381 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]382 fun testAnnotatedString_setBackgroundOnWholeText() {
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]383 val text = "abcde"
George Mountaa12c482019-08-14 14:51:38 -0700[diff] [blame]384 val color = Color(0xFF0000FF)
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]385 val spanStyle = SpanStyle(background = color)
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]386
387 val paragraph = simpleParagraph(
388 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]389 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]390 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]391 )
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]392
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]393 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
394 assertThat(paragraph.charSequence)
395 .hasSpan(BackgroundColorSpan::class, 0, text.length) { span ->
George Mounta3145782019-05-02 10:08:03 -0700[diff] [blame]396 span.backgroundColor == color.toArgb()
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]397 }
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]398 }
399
400 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]401 fun testAnnotatedString_setBackgroundOnPartText() {
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]402 val text = "abcde"
George Mountaa12c482019-08-14 14:51:38 -0700[diff] [blame]403 val color = Color(0xFF0000FF)
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]404 val spanStyle = SpanStyle(background = color)
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]405
406 val paragraph = simpleParagraph(
407 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]408 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, "abc".length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]409 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]410 )
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]411
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]412 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
413 assertThat(paragraph.charSequence)
414 .hasSpan(BackgroundColorSpan::class, 0, "abc".length) { span ->
George Mounta3145782019-05-02 10:08:03 -0700[diff] [blame]415 span.backgroundColor == color.toArgb()
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]416 }
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]417 }
418
419 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]420 fun testAnnotatedString_setBackgroundTwice_lastOneOverwrite() {
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]421 val text = "abcde"
George Mountaa12c482019-08-14 14:51:38 -0700[diff] [blame]422 val color = Color(0xFF0000FF)
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]423 val spanStyle = SpanStyle(background = color)
George Mountaa12c482019-08-14 14:51:38 -0700[diff] [blame]424 val colorOverwrite = Color(0xFF00FF00)
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]425 val spanStyleOverwrite = SpanStyle(background = colorOverwrite)
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]426
427 val paragraph = simpleParagraph(
428 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]429 spanStyles = listOf(
430 AnnotatedString.Item(spanStyle, 0, text.length),
431 AnnotatedString.Item(spanStyleOverwrite, 0, "abc".length)
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]432 ),
433 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]434 )
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]435
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]436 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
437 assertThat(paragraph.charSequence)
438 .hasSpan(BackgroundColorSpan::class, 0, text.length) { span ->
George Mounta3145782019-05-02 10:08:03 -0700[diff] [blame]439 span.backgroundColor == color.toArgb()
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]440 }
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]441 assertThat(paragraph.charSequence)
442 .hasSpan(BackgroundColorSpan::class, 0, "abc".length) { span ->
George Mounta3145782019-05-02 10:08:03 -0700[diff] [blame]443 span.backgroundColor == colorOverwrite.toArgb()
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]444 }
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]445 assertThat(paragraph.charSequence)
446 .hasSpanOnTop(BackgroundColorSpan::class, 0, "abc".length) { span ->
George Mounta3145782019-05-02 10:08:03 -0700[diff] [blame]447 span.backgroundColor == colorOverwrite.toArgb()
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]448 }
Haoyu Zhang0c4fd022019-01-02 13:53:10 -0800[diff] [blame]449 }
450
451 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]452 fun testAnnotatedString_setLocaleOnWholeText() {
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]453 val text = "abcde"
Seigo Nonaka8de69792019-09-04 14:55:15 -0700[diff] [blame]454 val localeList = LocaleList("en-US")
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]455 val spanStyle = SpanStyle(localeList = localeList)
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]456
457 val paragraph = simpleParagraph(
458 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]459 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]460 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]461 )
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]462
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]463 assertThat(paragraph.charSequence).hasSpan(LocaleSpan::class, 0, text.length)
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]464 }
465
466 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]467 fun testAnnotatedString_setLocaleOnPartText() {
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]468 val text = "abcde"
Seigo Nonaka8de69792019-09-04 14:55:15 -0700[diff] [blame]469 val localeList = LocaleList("en-US")
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]470 val spanStyle = SpanStyle(localeList = localeList)
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]471
472 val paragraph = simpleParagraph(
473 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]474 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, "abc".length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]475 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]476 )
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]477
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]478 assertThat(paragraph.charSequence).hasSpan(LocaleSpan::class, 0, "abc".length)
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]479 }
480
481 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]482 fun testAnnotatedString_setLocaleTwice_lastOneOverwrite() {
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]483 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]484 val spanStyle = SpanStyle(localeList = LocaleList("en-US"))
485 val spanStyleOverwrite = SpanStyle(localeList = LocaleList("ja-JP"))
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]486
487 val paragraph = simpleParagraph(
488 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]489 spanStyles = listOf(
490 AnnotatedString.Item(spanStyle, 0, text.length),
491 AnnotatedString.Item(spanStyleOverwrite, 0, "abc".length)
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]492 ),
493 constraints = ParagraphConstraints(width = 100.0f)
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]494 )
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]495
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]496 assertThat(paragraph.charSequence).hasSpan(LocaleSpan::class, 0, text.length)
497 assertThat(paragraph.charSequence).hasSpan(LocaleSpan::class, 0, "abc".length)
498 assertThat(paragraph.charSequence).hasSpanOnTop(LocaleSpan::class, 0, "abc".length)
Haoyu Zhang4b201d22018-12-18 14:27:38 -0800[diff] [blame]499 }
500
501 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]502 fun testAnnotatedString_setBaselineShiftOnWholeText() {
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]503 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]504 val spanStyle = SpanStyle(baselineShift = BaselineShift.Subscript)
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]505
506 val paragraph = simpleParagraph(
507 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]508 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]509 constraints = ParagraphConstraints(width = 100.0f) // width is not important
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]510 )
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]511
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]512 assertThat(paragraph.charSequence).hasSpan(BaselineShiftSpan::class, 0, text.length)
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]513 }
514
515 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]516 fun testAnnotatedString_setBaselineShiftOnPartText() {
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]517 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]518 val spanStyle = SpanStyle(baselineShift = BaselineShift.Superscript)
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]519
520 val paragraph = simpleParagraph(
521 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]522 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, "abc".length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]523 constraints = ParagraphConstraints(width = 100.0f) // width is not important
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]524 )
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]525
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]526 assertThat(paragraph.charSequence).hasSpan(BaselineShiftSpan::class, 0, "abc".length)
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]527 }
528
529 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]530 fun testAnnotatedString_setBaselineShiftTwice_LastOneOnTop() {
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]531 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]532 val spanStyle = SpanStyle(baselineShift = BaselineShift.Subscript)
533 val spanStyleOverwrite =
534 SpanStyle(baselineShift = BaselineShift.Superscript)
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]535
536 val paragraph = simpleParagraph(
537 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]538 spanStyles = listOf(
539 AnnotatedString.Item(spanStyle, 0, text.length),
540 AnnotatedString.Item(spanStyleOverwrite, 0, "abc".length)
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]541 ),
542 constraints = ParagraphConstraints(width = 100.0f) // width is not important
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]543 )
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]544
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]545 assertThat(paragraph.charSequence).hasSpan(BaselineShiftSpan::class, 0, text.length)
546 assertThat(paragraph.charSequence).hasSpan(BaselineShiftSpan::class, 0, "abc".length)
547 assertThat(paragraph.charSequence).hasSpanOnTop(BaselineShiftSpan::class, 0, "abc".length)
Haoyu Zhang40ce6bf2019-01-28 15:58:20 -0800[diff] [blame]548 }
549
550 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]551 fun testAnnotatedString_setTextGeometricTransformWithNull_noSpanSet() {
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]552 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]553 val spanStyle = SpanStyle(textGeometricTransform = TextGeometricTransform())
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]554
555 val paragraph = simpleParagraph(
556 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]557 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]558 constraints = ParagraphConstraints(width = 100.0f) // width is not important
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]559 )
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]560
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]561 assertThat(paragraph.charSequence).spans(ScaleXSpan::class).isEmpty()
562 assertThat(paragraph.charSequence).spans(SkewXSpan::class).isEmpty()
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]563 }
564
565 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]566 fun testAnnotatedString_setTextGeometricTransformWithScaleX() {
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]567 val text = "abcde"
568 val scaleX = 0.5f
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]569 val spanStyle = SpanStyle(
Siyamed Sinirff51df92019-07-02 15:35:20 -0700[diff] [blame]570 textGeometricTransform = TextGeometricTransform(
Seigo Nonaka9b62cc92019-12-03 14:32:17 -0800[diff] [blame]571 scaleX = scaleX
Siyamed Sinirff51df92019-07-02 15:35:20 -0700[diff] [blame]572 )
573 )
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]574
575 val paragraph = simpleParagraph(
576 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]577 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]578 constraints = ParagraphConstraints(width = 100.0f) // width is not important
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]579 )
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]580
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]581 assertThat(paragraph.charSequence).hasSpan(ScaleXSpan::class, 0, text.length) {
582 it.scaleX == scaleX
583 }
584 assertThat(paragraph.charSequence).spans(SkewXSpan::class).isEmpty()
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]585 }
586
587 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]588 fun testAnnotatedString_setTextGeometricTransformWithSkewX() {
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]589 val text = "aa"
590 val skewX = 1f
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]591 val spanStyle = SpanStyle(textGeometricTransform = TextGeometricTransform(skewX = skewX))
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]592
593 val paragraph = simpleParagraph(
594 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]595 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, text.length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]596 constraints = ParagraphConstraints(width = 100.0f) // width is not important
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]597 )
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]598
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]599 assertThat(paragraph.charSequence).hasSpan(SkewXSpan::class, 0, text.length) {
600 it.skewX == skewX
601 }
602 assertThat(paragraph.charSequence).spans(ScaleXSpan::class).isEmpty()
Haoyu Zhang15750922019-02-19 13:44:17 -0800[diff] [blame]603 }
604
605 @Test
Siyamed Sinir2690d532019-06-21 13:16:00 -0700[diff] [blame]606 fun textIndent_onWholeParagraph() {
Haoyu Zhang7fc59172019-03-01 17:03:31 -0800[diff] [blame]607 val text = "abc\ndef"
608 val firstLine = 40
609 val restLine = 20
Haoyu Zhang7fc59172019-03-01 17:03:31 -0800[diff] [blame]610
611 val paragraph = simpleParagraph(
612 text = text,
Haoyu Zhangb0e43c12019-10-15 16:37:51 -0700[diff] [blame]613 textIndent = TextIndent(firstLine.sp, restLine.sp),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]614 constraints = ParagraphConstraints(width = 100.0f) // width is not important
Haoyu Zhang7fc59172019-03-01 17:03:31 -0800[diff] [blame]615 )
Haoyu Zhang7fc59172019-03-01 17:03:31 -0800[diff] [blame]616
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]617 assertThat(paragraph.charSequence)
618 .hasSpan(LeadingMarginSpan.Standard::class, 0, text.length) {
Haoyu Zhang7fc59172019-03-01 17:03:31 -0800[diff] [blame]619 it.getLeadingMargin(true) == firstLine && it.getLeadingMargin(false) == restLine
620 }
Haoyu Zhang7fc59172019-03-01 17:03:31 -0800[diff] [blame]621 }
622
623 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]624 fun testAnnotatedString_setShadow() {
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]625 val text = "abcde"
George Mountaa12c482019-08-14 14:51:38 -0700[diff] [blame]626 val color = Color(0xFF00FF00)
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]627 val offset = Offset(1f, 2f)
628 val radius = 3.px
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]629 val spanStyle = SpanStyle(shadow = Shadow(color, offset, radius))
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]630
631 val paragraph = simpleParagraph(
632 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]633 spanStyles = listOf(
634 AnnotatedString.Item(spanStyle, start = 0, end = text.length)
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]635 ),
636 constraints = ParagraphConstraints(width = 100.0f) // width is not important
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]637 )
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]638
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]639 assertThat(paragraph.charSequence)
640 .hasSpan(ShadowSpan::class, start = 0, end = text.length) {
George Mounta3145782019-05-02 10:08:03 -0700[diff] [blame]641 return@hasSpan it.color == color.toArgb() &&
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]642 it.offsetX == offset.dx &&
643 it.offsetY == offset.dy &&
644 it.radius == radius.value
645 }
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]646 }
647
648 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]649 fun testAnnotatedString_setShadowTwice_lastOnTop() {
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]650 val text = "abcde"
George Mountaa12c482019-08-14 14:51:38 -0700[diff] [blame]651 val color = Color(0xFF00FF00)
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]652 val offset = Offset(1f, 2f)
653 val radius = 3.px
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]654 val spanStyle = SpanStyle(shadow = Shadow(color, offset, radius))
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]655
George Mountaa12c482019-08-14 14:51:38 -0700[diff] [blame]656 val colorOverwrite = Color(0xFF0000FF)
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]657 val offsetOverwrite = Offset(3f, 2f)
658 val radiusOverwrite = 1.px
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]659 val spanStyleOverwrite = SpanStyle(
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]660 shadow = Shadow(colorOverwrite, offsetOverwrite, radiusOverwrite)
661 )
662
663 val paragraph = simpleParagraph(
664 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]665 spanStyles = listOf(
666 AnnotatedString.Item(spanStyle, start = 0, end = text.length),
667 AnnotatedString.Item(spanStyleOverwrite, start = 0, end = "abc".length)
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]668 ),
669 constraints = ParagraphConstraints(width = 100.0f) // width is not important
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]670 )
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]671
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]672 assertThat(paragraph.charSequence)
673 .hasSpan(ShadowSpan::class, start = 0, end = text.length) {
George Mounta3145782019-05-02 10:08:03 -0700[diff] [blame]674 return@hasSpan it.color == color.toArgb() &&
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]675 it.offsetX == offset.dx &&
676 it.offsetY == offset.dy &&
677 it.radius == radius.value
678 }
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]679 assertThat(paragraph.charSequence)
680 .hasSpanOnTop(ShadowSpan::class, start = 0, end = "abc".length) {
George Mounta3145782019-05-02 10:08:03 -0700[diff] [blame]681 return@hasSpanOnTop it.color == colorOverwrite.toArgb() &&
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]682 it.offsetX == offsetOverwrite.dx &&
683 it.offsetY == offsetOverwrite.dy &&
684 it.radius == radiusOverwrite.value
685 }
Haoyu Zhang2a036c832019-03-08 11:57:13 -0800[diff] [blame]686 }
687
688 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]689 fun testAnnotatedString_fontFamily_addsTypefaceSpanWithCorrectTypeface() {
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]690 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]691 val spanStyle = SpanStyle(
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]692 fontFamily = fontFamily,
Siyamed Siniradf982d2019-05-20 17:35:13 -0700[diff] [blame]693 fontStyle = FontStyle.Italic,
Siyamed Sinirdc8f5742019-10-04 21:03:28 -0700[diff] [blame]694 fontWeight = FontWeight.Bold
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]695 )
696 val expectedTypeface = TypefaceAdapter().create(
697 fontFamily = fontFamily,
Siyamed Siniradf982d2019-05-20 17:35:13 -0700[diff] [blame]698 fontStyle = FontStyle.Italic,
Siyamed Sinirdc8f5742019-10-04 21:03:28 -0700[diff] [blame]699 fontWeight = FontWeight.Bold
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]700 )
Siyamed Sinir37298412018-12-27 19:47:15 -0800[diff] [blame]701 val expectedStart = 0
702 val expectedEnd = "abc".length
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]703
704 val paragraph = simpleParagraph(
705 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]706 spanStyles = listOf(
Haoyu Zhang27429892019-06-11 13:19:57 -0700[diff] [blame]707 AnnotatedString.Item(
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]708 spanStyle,
Siyamed Sinir37298412018-12-27 19:47:15 -0800[diff] [blame]709 expectedStart,
710 expectedEnd
711 )
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]712 ),
713 constraints = ParagraphConstraints(width = 100.0f)
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]714 )
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]715
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]716 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
717 assertThat(paragraph.charSequence)
718 .hasSpan(TypefaceSpan::class, expectedStart, expectedEnd) { span ->
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]719 span.typeface == expectedTypeface
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]720 }
Siyamed Sinir37298412018-12-27 19:47:15 -0800[diff] [blame]721 }
722
723 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]724 fun testAnnotatedString_fontFamily_whenFontSynthesizeTurnedOff() {
Siyamed Sinir37298412018-12-27 19:47:15 -0800[diff] [blame]725 val text = "abcde"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]726 val spanStyle = SpanStyle(
Siyamed Sinir37298412018-12-27 19:47:15 -0800[diff] [blame]727 fontFamily = fontFamily,
Siyamed Siniradf982d2019-05-20 17:35:13 -0700[diff] [blame]728 fontStyle = FontStyle.Italic,
Siyamed Sinirdc8f5742019-10-04 21:03:28 -0700[diff] [blame]729 fontWeight = FontWeight.Bold,
Siyamed Sinir934a3442019-06-18 12:57:13 -0700[diff] [blame]730 fontSynthesis = FontSynthesis.None
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]731 )
Siyamed Sinir37298412018-12-27 19:47:15 -0800[diff] [blame]732 val expectedTypeface = TypefaceAdapter().create(
733 fontFamily = fontFamily,
Siyamed Siniradf982d2019-05-20 17:35:13 -0700[diff] [blame]734 fontStyle = FontStyle.Italic,
Siyamed Sinirdc8f5742019-10-04 21:03:28 -0700[diff] [blame]735 fontWeight = FontWeight.Bold,
Siyamed Sinir934a3442019-06-18 12:57:13 -0700[diff] [blame]736 fontSynthesis = FontSynthesis.None
Siyamed Sinir37298412018-12-27 19:47:15 -0800[diff] [blame]737 )
738 val expectedStart = 0
739 val expectedEnd = "abc".length
740
741 val paragraph = simpleParagraph(
742 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]743 spanStyles = listOf(
Haoyu Zhang27429892019-06-11 13:19:57 -0700[diff] [blame]744 AnnotatedString.Item(
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]745 spanStyle,
Siyamed Sinir37298412018-12-27 19:47:15 -0800[diff] [blame]746 expectedStart,
747 expectedEnd
748 )
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]749 ),
750 constraints = ParagraphConstraints(width = 100.0f)
Siyamed Sinir37298412018-12-27 19:47:15 -0800[diff] [blame]751 )
Siyamed Sinir37298412018-12-27 19:47:15 -0800[diff] [blame]752
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]753 assertThat(paragraph.charSequence.toString()).isEqualTo(text)
754 assertThat(paragraph.charSequence)
755 .hasSpan(TypefaceSpan::class, expectedStart, expectedEnd) { span ->
Siyamed Sinir37298412018-12-27 19:47:15 -0800[diff] [blame]756 span.typeface == expectedTypeface
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]757 }
Siyamed Sinir70f336a2018-12-27 10:37:09 -0800[diff] [blame]758 }
759
760 @Test
haoyua8e48a52019-06-25 12:23:27 -0700[diff] [blame]761 fun testAnnotatedString_fontFeatureSetting_setSpanOnText() {
Haoyu Zhang588aaef2019-02-20 14:47:39 -0800[diff] [blame]762 val text = "abc"
763 val fontFeatureSettings = "\"kern\" 0"
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]764 val spanStyle = SpanStyle(fontFeatureSettings = fontFeatureSettings)
Haoyu Zhang588aaef2019-02-20 14:47:39 -0800[diff] [blame]765
766 val paragraph = simpleParagraph(
767 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]768 spanStyles = listOf(AnnotatedString.Item(spanStyle, 0, "abc".length)),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]769 constraints = ParagraphConstraints(width = 100.0f) // width is not important
Haoyu Zhang588aaef2019-02-20 14:47:39 -0800[diff] [blame]770 )
Haoyu Zhang588aaef2019-02-20 14:47:39 -0800[diff] [blame]771
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]772 assertThat(paragraph.charSequence).hasSpan(FontFeatureSpan::class, 0, "abc".length) {
773 it.fontFeatureSettings == fontFeatureSettings
774 }
Haoyu Zhang588aaef2019-02-20 14:47:39 -0800[diff] [blame]775 }
776
777 @Test
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]778 fun testEmptyFontFamily() {
779 val typefaceAdapter = mock<TypefaceAdapter>()
780 val paragraph = simpleParagraph(
781 text = "abc",
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]782 typefaceAdapter = typefaceAdapter,
783 constraints = ParagraphConstraints(width = Float.MAX_VALUE)
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]784 )
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]785
786 verify(typefaceAdapter, never()).create(
787 fontFamily = any(),
788 fontWeight = any(),
Siyamed Sinir21796012018-12-26 13:51:17 -0800[diff] [blame]789 fontStyle = any(),
790 fontSynthesis = any()
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]791 )
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]792 assertThat(paragraph.textPaint.typeface).isNull()
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]793 }
794
795 @Test
796 fun testEmptyFontFamily_withBoldFontWeightSelection() {
797 val typefaceAdapter = spy(TypefaceAdapter())
798
799 val paragraph = simpleParagraph(
800 text = "abc",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]801 style = TextStyle(
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]802 fontFamily = null,
Siyamed Sinirdc8f5742019-10-04 21:03:28 -0700[diff] [blame]803 fontWeight = FontWeight.Bold
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]804 ),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]805 typefaceAdapter = typefaceAdapter,
806 constraints = ParagraphConstraints(width = Float.MAX_VALUE)
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]807 )
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]808
809 verify(typefaceAdapter, times(1)).create(
810 fontFamily = eq(null),
Siyamed Sinirdc8f5742019-10-04 21:03:28 -0700[diff] [blame]811 fontWeight = eq(FontWeight.Bold),
Siyamed Siniradf982d2019-05-20 17:35:13 -0700[diff] [blame]812 fontStyle = eq(FontStyle.Normal),
Siyamed Sinir934a3442019-06-18 12:57:13 -0700[diff] [blame]813 fontSynthesis = eq(FontSynthesis.All)
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]814 )
815
816 val typeface = paragraph.textPaint.typeface
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]817 assertThat(typeface).isNotNull()
818 assertThat(typeface.isBold).isTrue()
819 assertThat(typeface.isItalic).isFalse()
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]820 }
821
822 @Test
823 fun testEmptyFontFamily_withFontStyleSelection() {
824 val typefaceAdapter = spy(TypefaceAdapter())
825 val paragraph = simpleParagraph(
826 text = "abc",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]827 style = TextStyle(
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]828 fontFamily = null,
829 fontStyle = FontStyle.Italic
830 ),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]831 typefaceAdapter = typefaceAdapter,
832 constraints = ParagraphConstraints(width = Float.MAX_VALUE)
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]833 )
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]834
835 verify(typefaceAdapter, times(1)).create(
836 fontFamily = eq(null),
Siyamed Sinirdc8f5742019-10-04 21:03:28 -0700[diff] [blame]837 fontWeight = eq(FontWeight.Normal),
Siyamed Siniradf982d2019-05-20 17:35:13 -0700[diff] [blame]838 fontStyle = eq(FontStyle.Italic),
Siyamed Sinir934a3442019-06-18 12:57:13 -0700[diff] [blame]839 fontSynthesis = eq(FontSynthesis.All)
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]840 )
841
842 val typeface = paragraph.textPaint.typeface
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]843 assertThat(typeface).isNotNull()
844 assertThat(typeface.isBold).isFalse()
845 assertThat(typeface.isItalic).isTrue()
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]846 }
847
848 @Test
849 fun testFontFamily_withGenericFamilyName() {
850 val typefaceAdapter = spy(TypefaceAdapter())
851 val fontFamily = FontFamily("sans-serif")
852
853 val paragraph = simpleParagraph(
854 text = "abc",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]855 style = TextStyle(
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]856 fontFamily = fontFamily
857 ),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]858 typefaceAdapter = typefaceAdapter,
859 constraints = ParagraphConstraints(width = Float.MAX_VALUE)
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]860 )
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]861
862 verify(typefaceAdapter, times(1)).create(
863 fontFamily = eq(fontFamily),
Siyamed Sinirdc8f5742019-10-04 21:03:28 -0700[diff] [blame]864 fontWeight = eq(FontWeight.Normal),
Siyamed Siniradf982d2019-05-20 17:35:13 -0700[diff] [blame]865 fontStyle = eq(FontStyle.Normal),
Siyamed Sinir934a3442019-06-18 12:57:13 -0700[diff] [blame]866 fontSynthesis = eq(FontSynthesis.All)
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]867 )
868
869 val typeface = paragraph.textPaint.typeface
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]870 assertThat(typeface).isNotNull()
871 assertThat(typeface.isBold).isFalse()
872 assertThat(typeface.isItalic).isFalse()
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]873 }
874
875 @Test
876 fun testFontFamily_withCustomFont() {
877 val typefaceAdapter = spy(TypefaceAdapter())
878 val paragraph = simpleParagraph(
879 text = "abc",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]880 style = TextStyle(
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]881 fontFamily = fontFamily
882 ),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]883 typefaceAdapter = typefaceAdapter,
884 constraints = ParagraphConstraints(width = Float.MAX_VALUE)
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]885 )
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]886
887 verify(typefaceAdapter, times(1)).create(
888 fontFamily = eq(fontFamily),
Siyamed Sinirdc8f5742019-10-04 21:03:28 -0700[diff] [blame]889 fontWeight = eq(FontWeight.Normal),
Siyamed Siniradf982d2019-05-20 17:35:13 -0700[diff] [blame]890 fontStyle = eq(FontStyle.Normal),
Siyamed Sinir934a3442019-06-18 12:57:13 -0700[diff] [blame]891 fontSynthesis = eq(FontSynthesis.All)
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]892 )
893 val typeface = paragraph.textPaint.typeface
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]894 assertThat(typeface.isBold).isFalse()
895 assertThat(typeface.isItalic).isFalse()
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]896 }
897
Haoyu Zhangc11ef5a2019-01-14 16:35:05 -0800[diff] [blame]898 @Test
899 fun testEllipsis_withMaxLineEqualsNull_doesNotEllipsis() {
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]900 withDensity(defaultDensity) {
901 val text = "abc"
902 val fontSize = 20.sp
903 val paragraphWidth = (text.length - 1) * fontSize.toPx().value
904 val paragraph = simpleParagraph(
905 text = text,
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]906 style = TextStyle(
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]907 fontFamily = fontFamily,
908 fontSize = fontSize
909 ),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]910 ellipsis = true,
911 constraints = ParagraphConstraints(width = paragraphWidth)
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]912 )
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]913
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]914 for (i in 0 until paragraph.lineCount) {
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]915 assertThat(paragraph.isEllipsisApplied(i)).isFalse()
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]916 }
Haoyu Zhangc11ef5a2019-01-14 16:35:05 -0800[diff] [blame]917 }
918 }
919
920 @Test
921 fun testEllipsis_withMaxLinesLessThanTextLines_doesEllipsis() {
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]922 withDensity(defaultDensity) {
923 val text = "abcde"
924 val fontSize = 100.sp
925 // Note that on API 21, if the next line only contains 1 character, ellipsis won't work
926 val paragraphWidth = (text.length - 1.5f) * fontSize.toPx().value
927 val paragraph = simpleParagraph(
928 text = text,
929 ellipsis = true,
930 maxLines = 1,
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]931 style = TextStyle(
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]932 fontFamily = fontFamily,
933 fontSize = fontSize
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]934 ),
935 constraints = ParagraphConstraints(width = paragraphWidth)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]936 )
Haoyu Zhangc11ef5a2019-01-14 16:35:05 -0800[diff] [blame]937
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]938 assertThat(paragraph.isEllipsisApplied(0)).isTrue()
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]939 }
Haoyu Zhangc11ef5a2019-01-14 16:35:05 -0800[diff] [blame]940 }
941
942 @Test
943 fun testEllipsis_withMaxLinesMoreThanTextLines_doesNotEllipsis() {
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]944 withDensity(defaultDensity) {
945 val text = "abc"
946 val fontSize = 100.sp
947 val paragraphWidth = (text.length - 1) * fontSize.toPx().value
948 val maxLines = ceil(text.length * fontSize.toPx().value / paragraphWidth).toInt()
949 val paragraph = simpleParagraph(
950 text = text,
951 ellipsis = true,
952 maxLines = maxLines,
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]953 style = TextStyle(
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]954 fontFamily = fontFamily,
955 fontSize = fontSize
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]956 ),
957 constraints = ParagraphConstraints(width = paragraphWidth)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]958 )
Haoyu Zhangc11ef5a2019-01-14 16:35:05 -0800[diff] [blame]959
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]960 for (i in 0 until paragraph.lineCount) {
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]961 assertThat(paragraph.isEllipsisApplied(i)).isFalse()
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]962 }
Haoyu Zhangc11ef5a2019-01-14 16:35:05 -0800[diff] [blame]963 }
964 }
965
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]966 @Test
Siyamed Sinir0b691752019-12-05 11:27:58 -0800[diff] [blame]967 fun testSpanStyle_fontSize_appliedOnTextPaint() {
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]968 withDensity(defaultDensity) {
969 val fontSize = 100.sp
970 val paragraph = simpleParagraph(
971 text = "",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]972 style = TextStyle(fontSize = fontSize),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]973 constraints = ParagraphConstraints(width = 0.0f)
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]974 )
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]975
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]976 assertThat(paragraph.textPaint.textSize).isEqualTo(fontSize.toPx().value)
Siyamed Sinir7d4c98f2019-06-27 16:23:31 -0700[diff] [blame]977 }
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]978 }
979
980 @Test
Siyamed Sinir0b691752019-12-05 11:27:58 -0800[diff] [blame]981 fun testSpanStyle_locale_appliedOnTextPaint() {
Seigo Nonaka8de69792019-09-04 14:55:15 -0700[diff] [blame]982 val platformLocale = java.util.Locale.JAPANESE
983 val localeList = LocaleList(platformLocale.toLanguageTag())
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]984
985 val paragraph = simpleParagraph(
986 text = "",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]987 style = TextStyle(localeList = localeList),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]988 constraints = ParagraphConstraints(width = 0.0f)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]989 )
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]990
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]991 assertThat(paragraph.textPaint.textLocale.language).isEqualTo(platformLocale.language)
992 assertThat(paragraph.textPaint.textLocale.country).isEqualTo(platformLocale.country)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]993 }
994
995 @Test
Siyamed Sinir0b691752019-12-05 11:27:58 -0800[diff] [blame]996 fun testSpanStyle_color_appliedOnTextPaint() {
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]997 val color = Color(0x12345678)
998 val paragraph = simpleParagraph(
999 text = "",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1000 style = TextStyle(color = color),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1001 constraints = ParagraphConstraints(width = 0.0f)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1002 )
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1003
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1004 assertThat(paragraph.textPaint.color).isEqualTo(color.toArgb())
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1005 }
1006
1007 @Test
Siyamed Sinir0b691752019-12-05 11:27:58 -0800[diff] [blame]1008 fun testSpanStyle_letterSpacing_appliedOnTextPaint() {
Haoyu Zhangf2e9e032019-10-16 15:23:39 -0700[diff] [blame]1009 val letterSpacing = 2
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1010 val paragraph = simpleParagraph(
1011 text = "",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1012 style = TextStyle(letterSpacing = letterSpacing.em),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1013 constraints = ParagraphConstraints(width = 0.0f)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1014 )
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1015
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1016 assertThat(paragraph.textPaint.letterSpacing).isEqualTo((letterSpacing))
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1017 }
1018
1019 @Test
Siyamed Sinir0b691752019-12-05 11:27:58 -0800[diff] [blame]1020 fun testSpanStyle_fontFeatureSettings_appliedOnTextPaint() {
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1021 val fontFeatureSettings = "\"kern\" 0"
1022 val paragraph = simpleParagraph(
1023 text = "",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1024 style = TextStyle(fontFeatureSettings = fontFeatureSettings),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1025 constraints = ParagraphConstraints(width = 0.0f)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1026 )
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1027
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1028 assertThat(paragraph.textPaint.fontFeatureSettings).isEqualTo(fontFeatureSettings)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1029 }
1030
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1031 @Test
Siyamed Sinir0b691752019-12-05 11:27:58 -0800[diff] [blame]1032 fun testSpanStyle_scaleX_appliedOnTextPaint() {
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1033 val scaleX = 0.5f
1034 val paragraph = simpleParagraph(
1035 text = "",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1036 style = TextStyle(
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1037 textGeometricTransform = TextGeometricTransform(
1038 scaleX = scaleX
1039 )
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1040 ),
1041 constraints = ParagraphConstraints(width = 0.0f)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1042 )
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1043
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1044 assertThat(paragraph.textPaint.textScaleX).isEqualTo(scaleX)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1045 }
1046
1047 @Test
Siyamed Sinir0b691752019-12-05 11:27:58 -0800[diff] [blame]1048 fun testSpanStyle_skewX_appliedOnTextPaint() {
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1049 val skewX = 0.5f
1050 val paragraph = simpleParagraph(
1051 text = "",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1052 style = TextStyle(
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1053 textGeometricTransform = TextGeometricTransform(
1054 skewX = skewX
1055 )
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1056 ),
1057 constraints = ParagraphConstraints(width = 0.0f)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1058 )
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1059
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1060 assertThat(paragraph.textPaint.textSkewX).isEqualTo(skewX)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1061 }
1062
1063 @Test
Siyamed Sinir0b691752019-12-05 11:27:58 -0800[diff] [blame]1064 fun testSpanStyle_decoration_underline_appliedOnTextPaint() {
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1065 val paragraph = simpleParagraph(
1066 text = "",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1067 style = TextStyle(decoration = TextDecoration.Underline),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1068 constraints = ParagraphConstraints(width = 0.0f)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1069 )
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1070
Siyamed Sinir18914522019-09-25 15:41:44 -0700[diff] [blame]1071 assertThat(paragraph.textPaint.isUnderlineText).isTrue()
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1072 }
1073
1074 @Test
Siyamed Sinir0b691752019-12-05 11:27:58 -0800[diff] [blame]1075 fun testSpanStyle_decoration_lineThrough_appliedOnTextPaint() {
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1076 val paragraph = simpleParagraph(
1077 text = "",
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1078 style = TextStyle(decoration = TextDecoration.LineThrough),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1079 constraints = ParagraphConstraints(width = 0.0f)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1080 )
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1081
Siyamed Sinir18914522019-09-25 15:41:44 -0700[diff] [blame]1082 assertThat(paragraph.textPaint.isStrikeThruText).isTrue()
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1083 }
1084
1085 @Test
Siyamed Sinir0b691752019-12-05 11:27:58 -0800[diff] [blame]1086 fun testSpanStyle_background_appliedAsSpan() {
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1087 // bgColor is reset in the Android Layout constructor.
1088 // therefore we cannot apply them on paint, have to use spans.
1089 val text = "abc"
1090 val color = Color(0x12345678)
1091 val paragraph = simpleParagraph(
1092 text = text,
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1093 style = TextStyle(background = color),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1094 constraints = ParagraphConstraints(width = 0.0f)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1095 )
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1096
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1097 assertThat(paragraph.charSequence)
1098 .hasSpan(BackgroundColorSpan::class, 0, text.length) { span ->
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1099 span.backgroundColor == color.toArgb()
1100 }
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1101 }
1102
1103 @Test
Siyamed Sinir0b691752019-12-05 11:27:58 -0800[diff] [blame]1104 fun testSpanStyle_baselineShift_appliedAsSpan() {
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1105 // baselineShift is reset in the Android Layout constructor.
1106 // therefore we cannot apply them on paint, have to use spans.
1107 val text = "abc"
1108 val baselineShift = BaselineShift.Subscript
1109 val paragraph = simpleParagraph(
1110 text = text,
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1111 style = TextStyle(baselineShift = baselineShift),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1112 constraints = ParagraphConstraints(width = 0.0f)
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1113 )
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1114
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1115 assertThat(paragraph.charSequence)
1116 .hasSpan(BaselineShiftSpan::class, 0, text.length) { span ->
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1117 span.multiplier == BaselineShift.Subscript.multiplier
1118 }
Siyamed Sinirbf9f3ba2019-06-25 22:40:56 -0700[diff] [blame]1119 }
1120
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1121 @Test
1122 fun locale_isDefaultLocaleIfNotProvided() {
1123 val text = "abc"
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1124 val paragraph = simpleParagraph(
1125 text = text,
1126 constraints = ParagraphConstraints(width = Float.MAX_VALUE)
1127 )
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1128
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1129 assertThat(paragraph.textLocale.toLanguageTag())
1130 .isEqualTo(java.util.Locale.getDefault().toLanguageTag())
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1131 }
1132
1133 @Test
1134 fun locale_isSetOnParagraphImpl_enUS() {
Seigo Nonaka8de69792019-09-04 14:55:15 -0700[diff] [blame]1135 val localeList = LocaleList("en-US")
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1136 val text = "abc"
1137 val paragraph = simpleParagraph(
1138 text = text,
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1139 style = TextStyle(localeList = localeList),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1140 constraints = ParagraphConstraints(width = Float.MAX_VALUE)
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1141 )
1142
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1143 assertThat(paragraph.textLocale.toLanguageTag()).isEqualTo("en-US")
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1144 }
1145
1146 @Test
1147 fun locale_isSetOnParagraphImpl_jpJP() {
Seigo Nonaka8de69792019-09-04 14:55:15 -0700[diff] [blame]1148 val localeList = LocaleList("ja-JP")
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1149 val text = "abc"
1150 val paragraph = simpleParagraph(
1151 text = text,
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1152 style = TextStyle(localeList = localeList),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1153 constraints = ParagraphConstraints(width = Float.MAX_VALUE)
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1154 )
1155
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1156 assertThat(paragraph.textLocale.toLanguageTag()).isEqualTo("ja-JP")
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1157 }
1158
1159 @Test
1160 fun locale_noCountryCode_isSetOnParagraphImpl() {
Seigo Nonaka8de69792019-09-04 14:55:15 -0700[diff] [blame]1161 val localeList = LocaleList("ja")
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1162 val text = "abc"
1163 val paragraph = simpleParagraph(
1164 text = text,
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1165 style = TextStyle(localeList = localeList),
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1166 constraints = ParagraphConstraints(width = Float.MAX_VALUE)
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1167 )
1168
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1169 assertThat(paragraph.textLocale.toLanguageTag()).isEqualTo("ja")
Siyamed Sinir031e5bf2019-07-02 11:49:05 -0700[diff] [blame]1170 }
1171
Seigo Nonakac4f136a2019-08-16 16:48:44 -0700[diff] [blame]1172 @Test
Seigo Nonakaad4a3772019-08-26 12:06:58 -0700[diff] [blame]1173 fun floatingWidth() {
1174 val floatWidth = 1.3f
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1175 val paragraph = simpleParagraph(
1176 text = "Hello, World",
1177 constraints = ParagraphConstraints(floatWidth)
1178 )
1179
Siyamed Sinir63789c92019-09-25 10:44:11 -0700[diff] [blame]1180 assertThat(floatWidth).isEqualTo(paragraph.width)
Seigo Nonakaad4a3772019-08-26 12:06:58 -0700[diff] [blame]1181 }
1182
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]1183 private fun simpleParagraph(
Haoyu Zhang27429892019-06-11 13:19:57 -0700[diff] [blame]1184 text: String = "",
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]1185 spanStyles: List<AnnotatedString.Item<SpanStyle>> = listOf(),
Siyamed Sinir2690d532019-06-21 13:16:00 -0700[diff] [blame]1186 textIndent: TextIndent? = null,
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]1187 textAlign: TextAlign? = null,
Siyamed Sinir504d5b02019-09-24 13:39:43 -0700[diff] [blame]1188 textDirectionAlgorithm: TextDirectionAlgorithm? = TextDirectionAlgorithm.ContentOrLtr,
Seigo Nonaka51664792019-12-04 10:59:29 -0800[diff] [blame]1189 ellipsis: Boolean = false,
1190 maxLines: Int = Int.MAX_VALUE,
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1191 constraints: ParagraphConstraints,
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1192 style: TextStyle? = null,
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]1193 typefaceAdapter: TypefaceAdapter = TypefaceAdapter()
Siyamed Sinire75976f2019-07-03 09:24:30 -0700[diff] [blame]1194 ): AndroidParagraph {
1195 return AndroidParagraph(
Haoyu Zhang27429892019-06-11 13:19:57 -0700[diff] [blame]1196 text = text,
Siyamed Sinirfaa4ac42019-12-04 09:02:31 -0800[diff] [blame]1197 spanStyles = spanStyles,
Siyamed Sinirf18dcca2018-12-20 18:25:10 -0800[diff] [blame]1198 typefaceAdapter = typefaceAdapter,
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1199 style = TextStyle(
Siyamed Sinir883e0232019-06-25 12:38:12 -0700[diff] [blame]1200 textAlign = textAlign,
Siyamed Sinir504d5b02019-09-24 13:39:43 -0700[diff] [blame]1201 textIndent = textIndent,
1202 textDirectionAlgorithm = textDirectionAlgorithm
Siyamed Sinir01f7b522019-12-06 00:14:02 -0800[diff] [blame^]1203 ).merge(style),
Siyamed Sinir6a1f0362019-07-08 15:58:32 -0700[diff] [blame]1204 maxLines = maxLines,
1205 ellipsis = ellipsis,
Siyamed Sinir3f44b9a2019-09-21 13:13:38 -0700[diff] [blame]1206 constraints = constraints,
Siyamed Sinir504d5b02019-09-24 13:39:43 -0700[diff] [blame]1207 density = Density(density = 1f)
Haoyu Zhang10fc6502018-11-09 15:50:11 -0800[diff] [blame]1208 )
1209 }
Siyamed Sinir472ed132019-07-03 15:43:43 -0700[diff] [blame]1210
1211 private fun TypefaceAdapter() = TypefaceAdapter(
Siyamed Sinirc4c308e2019-07-03 16:14:22 -0700[diff] [blame]1212 resourceLoader = TestFontResourceLoader(context)
Siyamed Sinir472ed132019-07-03 15:43:43 -0700[diff] [blame]1213 )
Siyamed Sinir2690d532019-06-21 13:16:00 -0700[diff] [blame]1214}