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