ui/ui-text-core/src/test/java/androidx/ui/text/SpanStyleTest.kt - platform/frameworks/support - Git at Google

 /*
  * Copyright 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package androidx.ui.text

 import androidx.ui.intl.LocaleList
 import androidx.ui.graphics.Color
 import androidx.ui.graphics.lerp
 import androidx.ui.text.font.FontFamily
 import androidx.ui.text.font.FontStyle
 import androidx.ui.text.font.FontSynthesis
 import androidx.ui.text.font.FontWeight
 import androidx.ui.text.font.lerp
 import androidx.ui.text.style.BaselineShift
 import androidx.ui.text.style.TextDecoration
 import androidx.ui.text.style.TextGeometricTransform
 import androidx.ui.text.style.lerp
 import androidx.ui.unit.TextUnit
 import androidx.ui.unit.em
 import androidx.ui.unit.sp
 import com.google.common.truth.Truth.assertThat
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4

 @RunWith(JUnit4::class)
 class SpanStyleTest {
     @Test
     fun `constructor with default values`() {
         val style = SpanStyle()

         assertThat(style.color).isEqualTo(Color.Unset)
         assertThat(style.fontSize.isInherit).isTrue()
         assertThat(style.fontWeight).isNull()
         assertThat(style.fontStyle).isNull()
         assertThat(style.letterSpacing.isInherit).isTrue()
         assertThat(style.localeList).isNull()
         assertThat(style.background).isEqualTo(Color.Unset)
         assertThat(style.textDecoration).isNull()
         assertThat(style.fontFamily).isNull()
     }

     @Test
     fun `constructor with customized color`() {
         val color = Color.Red

         val style = SpanStyle(color = color)

         assertThat(style.color).isEqualTo(color)
     }

     @Test
     fun `constructor with customized fontSize`() {
         val fontSize = 18.sp

         val style = SpanStyle(fontSize = fontSize)

         assertThat(style.fontSize).isEqualTo(fontSize)
     }

     @Test
     fun `constructor with customized fontWeight`() {
         val fontWeight = FontWeight.W500

         val style = SpanStyle(fontWeight = fontWeight)

         assertThat(style.fontWeight).isEqualTo(fontWeight)
     }

     @Test
     fun `constructor with customized fontStyle`() {
         val fontStyle = FontStyle.Italic

         val style = SpanStyle(fontStyle = fontStyle)

         assertThat(style.fontStyle).isEqualTo(fontStyle)
     }

     @Test
     fun `constructor with customized letterSpacing`() {
         val letterSpacing = 1.em

         val style = SpanStyle(letterSpacing = letterSpacing)

         assertThat(style.letterSpacing).isEqualTo(letterSpacing)
     }

     @Test
     fun `constructor with customized baselineShift`() {
         val baselineShift = BaselineShift.Superscript

         val style = SpanStyle(baselineShift = baselineShift)

         assertThat(style.baselineShift).isEqualTo(baselineShift)
     }

     @Test
     fun `constructor with customized locale`() {
         val localeList = LocaleList("en-US")

         val style = SpanStyle(localeList = localeList)

         assertThat(style.localeList).isEqualTo(localeList)
     }

     @Test
     fun `constructor with customized background`() {
         val color = Color.Red

         val style = SpanStyle(background = color)

         assertThat(style.background).isEqualTo(color)
     }

     @Test
     fun `constructor with customized textDecoration`() {
         val decoration = TextDecoration.Underline

         val style = SpanStyle(textDecoration = decoration)

         assertThat(style.textDecoration).isEqualTo(decoration)
     }

     @Test
     fun `constructor with customized fontFamily`() {
         val fontFamily = FontFamily.SansSerif

         val style = SpanStyle(fontFamily = fontFamily)

         assertThat(style.fontFamily).isEqualTo(fontFamily)
     }

     @Test
     fun `merge with empty other should return this`() {
         val style = SpanStyle()

         val newSpanStyle = style.merge()

         assertThat(newSpanStyle).isEqualTo(style)
     }

     @Test
     fun `merge with other's color is null should use this' color`() {
         val style = SpanStyle(color = Color.Red)

         val newSpanStyle = style.merge(SpanStyle(color = Color.Unset))

         assertThat(newSpanStyle.color).isEqualTo(style.color)
     }

     @Test
     fun `merge with other's color is set should use other's color`() {
         val style = SpanStyle(color = Color.Red)
         val otherStyle = SpanStyle(color = Color.Green)

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.color).isEqualTo(otherStyle.color)
     }

     @Test
     fun `merge with other's fontFamily is null should use this' fontFamily`() {
         val style = SpanStyle(fontFamily = FontFamily.SansSerif)

         val newSpanStyle = style.merge(SpanStyle(fontFamily = null))

         assertThat(newSpanStyle.fontFamily).isEqualTo(style.fontFamily)
     }

     @Test
     fun `merge with other's fontFamily is set should use other's fontFamily`() {
         val style = SpanStyle(fontFamily = FontFamily.SansSerif)
         val otherStyle = SpanStyle(fontFamily = FontFamily.Serif)

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.fontFamily).isEqualTo(otherStyle.fontFamily)
     }

     @Test
     fun `merge with other's fontSize is null should use this' fontSize`() {
         val style = SpanStyle(fontSize = 3.5.sp)

         val newSpanStyle = style.merge(SpanStyle(fontSize = TextUnit.Inherit))

         assertThat(newSpanStyle.fontSize).isEqualTo(style.fontSize)
     }

     @Test
     fun `merge with other's fontSize is set should use other's fontSize`() {
         val style = SpanStyle(fontSize = 3.5.sp)
         val otherStyle = SpanStyle(fontSize = 8.7.sp)

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.fontSize).isEqualTo(otherStyle.fontSize)
     }

     @Test
     fun `merge with other's fontWeight is null should use this' fontWeight`() {
         val style = SpanStyle(fontWeight = FontWeight.W300)

         val newSpanStyle = style.merge(SpanStyle(fontWeight = null))

         assertThat(newSpanStyle.fontWeight).isEqualTo(style.fontWeight)
     }

     @Test
     fun `merge with other's fontWeight is set should use other's fontWeight`() {
         val style = SpanStyle(fontWeight = FontWeight.W300)
         val otherStyle = SpanStyle(fontWeight = FontWeight.W500)

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.fontWeight).isEqualTo(otherStyle.fontWeight)
     }

     @Test
     fun `merge with other's fontStyle is null should use this' fontStyle`() {
         val style = SpanStyle(fontStyle = FontStyle.Italic)

         val newSpanStyle = style.merge(SpanStyle(fontStyle = null))

         assertThat(newSpanStyle.fontStyle).isEqualTo(style.fontStyle)
     }

     @Test
     fun `merge with other's fontStyle is set should use other's fontStyle`() {
         val style = SpanStyle(fontStyle = FontStyle.Normal)
         val otherStyle = SpanStyle(fontStyle = FontStyle.Italic)

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.fontStyle).isEqualTo(otherStyle.fontStyle)
     }

     @Test
     fun `merge with other's fontSynthesis is null should use this' fontSynthesis`() {
         val style = SpanStyle(fontSynthesis = FontSynthesis.Style)

         val newSpanStyle = style.merge(SpanStyle(fontSynthesis = null))

         assertThat(newSpanStyle.fontSynthesis).isEqualTo(style.fontSynthesis)
     }

     @Test
     fun `merge with other's fontSynthesis is set should use other's fontSynthesis`() {
         val style = SpanStyle(fontSynthesis = FontSynthesis.Style)
         val otherStyle = SpanStyle(fontSynthesis = FontSynthesis.Weight)

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.fontSynthesis).isEqualTo(otherStyle.fontSynthesis)
     }

     @Test
     fun `merge with other's fontFeature is null should use this' fontSynthesis`() {
         val style = SpanStyle(fontFeatureSettings = "\"kern\" 0")

         val newSpanStyle = style.merge(SpanStyle(fontFeatureSettings = null))

         assertThat(newSpanStyle.fontFeatureSettings).isEqualTo(style.fontFeatureSettings)
     }

     @Test
     fun `merge with other's fontFeature is set should use other's fontSynthesis`() {
         val style = SpanStyle(fontFeatureSettings = "\"kern\" 0")
         val otherStyle = SpanStyle(fontFeatureSettings = "\"kern\" 1")

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.fontFeatureSettings).isEqualTo(otherStyle.fontFeatureSettings)
     }

     @Test
     fun `merge with other's letterSpacing is null should use this' letterSpacing`() {
         val style = SpanStyle(letterSpacing = 1.2.em)

         val newSpanStyle = style.merge(SpanStyle(letterSpacing = TextUnit.Inherit))

         assertThat(newSpanStyle.letterSpacing).isEqualTo(style.letterSpacing)
     }

     @Test
     fun `merge with other's letterSpacing is set should use other's letterSpacing`() {
         val style = SpanStyle(letterSpacing = 1.2.em)
         val otherStyle = SpanStyle(letterSpacing = 1.5.em)

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.letterSpacing).isEqualTo(otherStyle.letterSpacing)
     }

     @Test
     fun `merge with other's baselineShift is null should use this' baselineShift`() {
         val style = SpanStyle(baselineShift = BaselineShift.Superscript)

         val newSpanStyle = style.merge(SpanStyle(baselineShift = null))

         assertThat(newSpanStyle.baselineShift).isEqualTo(style.baselineShift)
     }

     @Test
     fun `merge with other's baselineShift is set should use other's baselineShift`() {
         val style = SpanStyle(baselineShift = BaselineShift.Superscript)
         val otherStyle = SpanStyle(baselineShift = BaselineShift.Subscript)

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.baselineShift).isEqualTo(otherStyle.baselineShift)
     }

     @Test
     fun `merge with other's background is null should use this' background`() {
         val style = SpanStyle(background = Color.Red)

         val newSpanStyle = style.merge(SpanStyle(background = Color.Unset))

         assertThat(newSpanStyle.background).isEqualTo(style.background)
     }

     @Test
     fun `merge with other's background is set should use other's background`() {
         val style = SpanStyle(background = Color.Red)
         val otherStyle = SpanStyle(background = Color.Green)

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.background).isEqualTo(otherStyle.background)
     }

     @Test
     fun `merge with other's textDecoration is null should use this' textDecoration`() {
         val style = SpanStyle(textDecoration = TextDecoration.LineThrough)

         val newSpanStyle = style.merge(SpanStyle(textDecoration = null))

         assertThat(newSpanStyle.textDecoration).isEqualTo(style.textDecoration)
     }

     @Test
     fun `merge with other's textDecoration is set should use other's textDecoration`() {
         val style = SpanStyle(textDecoration = TextDecoration.LineThrough)
         val otherStyle = SpanStyle(textDecoration = TextDecoration.Underline)

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.textDecoration).isEqualTo(otherStyle.textDecoration)
     }

     @Test
     fun `merge with other's locale is null should use this' locale`() {
         val style = SpanStyle(localeList = LocaleList("en-US"))

         val newSpanStyle = style.merge(SpanStyle(localeList = null))

         assertThat(newSpanStyle.localeList).isEqualTo(style.localeList)
     }

     @Test
     fun `merge with other's locale is set should use other's locale`() {
         val style = SpanStyle(localeList = LocaleList("en-US"))
         val otherStyle = SpanStyle(localeList = LocaleList("ja-JP"))

         val newSpanStyle = style.merge(otherStyle)

         assertThat(newSpanStyle.localeList).isEqualTo(otherStyle.localeList)
     }

     @Test
     fun `plus operator merges`() {
         val style = SpanStyle(
             color = Color.Red,
             fontWeight = FontWeight.Bold
         ) + SpanStyle(
             color = Color.Green,
             fontFamily = FontFamily.Cursive
         )

         assertThat(style).isEqualTo(
             SpanStyle(
                 color = Color.Green, // overridden by RHS
                 fontWeight = FontWeight.Bold, // from LHS,
                 fontFamily = FontFamily.Cursive // from RHS
             )
         )
     }

     @Test
     fun `lerp color with a and b are not Null`() {
         val color1 = Color.Red
         val color2 = Color.Green
         val t = 0.3f
         val style1 = SpanStyle(color = color1)
         val style2 = SpanStyle(color = color2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.color).isEqualTo(lerp(start = color1, stop = color2, fraction = t))
     }

     @Test
     fun `lerp color with a and b are Unset`() {
         val style1 = SpanStyle(color = Color.Unset)
         val style2 = SpanStyle(color = Color.Unset)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = 0.3f)

         assertThat(newSpanStyle.color).isEqualTo(Color.Unset)
     }

     @Test
     fun `lerp color with a is set, and b is Unset`() {
         val t = 0.3f
         val color1 = Color.Red
         val color2 = Color.Unset
         val style1 = SpanStyle(color = color1)
         val style2 = SpanStyle(color = color2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.color).isEqualTo(lerp(start = color1, stop = color2, fraction = t))
     }

     @Test
     fun `lerp fontFamily with a and b are not Null and t is smaller than half`() {
         val fontFamily1 = FontFamily.SansSerif
         val fontFamily2 = FontFamily.Serif
         val t = 0.3f
         val style1 = SpanStyle(fontFamily = fontFamily1)
         val style2 = SpanStyle(fontFamily = fontFamily2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.fontFamily).isEqualTo(fontFamily1)
     }

     @Test
     fun `lerp fontFamily with a and b are not Null and t is larger than half`() {
         val fontFamily1 = FontFamily.SansSerif
         val fontFamily2 = FontFamily.Serif
         val t = 0.8f
         val style1 = SpanStyle(fontFamily = fontFamily1)
         val style2 = SpanStyle(fontFamily = fontFamily2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.fontFamily).isEqualTo(fontFamily2)
     }

     @Test
     fun `lerp fontSize with a and b are not Null`() {
         val fontSize1 = 8.sp
         val fontSize2 = 16.sp
         val t = 0.8f
         val style1 = SpanStyle(fontSize = fontSize1)
         val style2 = SpanStyle(fontSize = fontSize2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         // a + (b - a) * t = 8.0f + (16.0f  - 8.0f) * 0.8f = 14.4f
         assertThat(newSpanStyle.fontSize).isEqualTo(14.4.sp)
     }

     @Test
     fun `lerp fontWeight with a and b are not Null`() {
         val fontWeight1 = FontWeight.W200
         val fontWeight2 = FontWeight.W500
         val t = 0.8f
         val style1 = SpanStyle(fontWeight = fontWeight1)
         val style2 = SpanStyle(fontWeight = fontWeight2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.fontWeight).isEqualTo(lerp(fontWeight1, fontWeight2, t))
     }

     @Test
     fun `lerp fontStyle with a and b are not Null and t is smaller than half`() {
         val fontStyle1 = FontStyle.Italic
         val fontStyle2 = FontStyle.Normal
         // attributes other than fontStyle are required for lerp not to throw an exception
         val t = 0.3f
         val style1 = SpanStyle(fontStyle = fontStyle1)
         val style2 = SpanStyle(fontStyle = fontStyle2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.fontStyle).isEqualTo(fontStyle1)
     }

     @Test
     fun `lerp fontStyle with a and b are not Null and t is larger than half`() {
         val fontStyle1 = FontStyle.Italic
         val fontStyle2 = FontStyle.Normal
         // attributes other than fontStyle are required for lerp not to throw an exception
         val t = 0.8f
         val style1 = SpanStyle(fontStyle = fontStyle1)
         val style2 = SpanStyle(fontStyle = fontStyle2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.fontStyle).isEqualTo(fontStyle2)
     }

     @Test
     fun `lerp fontSynthesis with a and b are not Null and t is smaller than half`() {
         val fontSynthesis1 = FontSynthesis.Style
         val fontSynthesis2 = FontSynthesis.Weight

         val t = 0.3f
         // attributes other than fontSynthesis are required for lerp not to throw an exception
         val style1 = SpanStyle(fontSynthesis = fontSynthesis1)
         val style2 = SpanStyle(fontSynthesis = fontSynthesis2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.fontSynthesis).isEqualTo(fontSynthesis1)
     }

     @Test
     fun `lerp fontSynthesis with a and b are not Null and t is larger than half`() {
         val fontSynthesis1 = FontSynthesis.Style
         val fontSynthesis2 = FontSynthesis.Weight

         val t = 0.8f
         // attributes other than fontSynthesis are required for lerp not to throw an exception
         val style1 = SpanStyle(fontSynthesis = fontSynthesis1)
         val style2 = SpanStyle(fontSynthesis = fontSynthesis2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.fontSynthesis).isEqualTo(fontSynthesis2)
     }

     @Test
     fun `lerp fontFeatureSettings with a and b are not Null and t is smaller than half`() {
         val fontFeatureSettings1 = "\"kern\" 0"
         val fontFeatureSettings2 = "\"kern\" 1"

         val t = 0.3f
         // attributes other than fontSynthesis are required for lerp not to throw an exception
         val style1 = SpanStyle(fontFeatureSettings = fontFeatureSettings1)
         val style2 = SpanStyle(fontFeatureSettings = fontFeatureSettings2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.fontFeatureSettings).isEqualTo(fontFeatureSettings1)
     }

     @Test
     fun `lerp fontFeatureSettings with a and b are not Null and t is larger than half`() {
         val fontFeatureSettings1 = "\"kern\" 0"
         val fontFeatureSettings2 = "\"kern\" 1"

         val t = 0.8f
         // attributes other than fontSynthesis are required for lerp not to throw an exception
         val style1 = SpanStyle(fontFeatureSettings = fontFeatureSettings1)
         val style2 = SpanStyle(fontFeatureSettings = fontFeatureSettings2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.fontFeatureSettings).isEqualTo(fontFeatureSettings2)
     }

     @Test
     fun `lerp baselineShift with a and b are not Null`() {
         val baselineShift1 = BaselineShift(1.0f)
         val baselineShift2 = BaselineShift(2.0f)
         val t = 0.3f
         val style1 = SpanStyle(baselineShift = baselineShift1)
         val style2 = SpanStyle(baselineShift = baselineShift2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.baselineShift)
             .isEqualTo(lerp(baselineShift1, baselineShift2, t))
     }

     @Test
     fun `lerp textGeometricTransform with a and b are not Null`() {
         val textTransform1 = TextGeometricTransform(scaleX = 1.5f, skewX = 0.1f)
         val textTransform2 = TextGeometricTransform(scaleX = 1.0f, skewX = 0.3f)
         val t = 0.3f
         val style1 = SpanStyle(textGeometricTransform = textTransform1)
         val style2 = SpanStyle(textGeometricTransform = textTransform2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.textGeometricTransform)
             .isEqualTo(lerp(textTransform1, textTransform2, t))
     }

     @Test
     fun `lerp locale with a and b are not Null and t is smaller than half`() {
         val localeList1 = LocaleList("en-US")
         val localeList2 = LocaleList("ja-JP")
         val t = 0.3f
         val style1 = SpanStyle(localeList = localeList1)
         val style2 = SpanStyle(localeList = localeList2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.localeList).isEqualTo(localeList1)
     }

     @Test
     fun `lerp locale with a and b are not Null and t is larger than half`() {
         val localeList1 = LocaleList("en-US")
         val localeList2 = LocaleList("ja-JP")
         val t = 0.8f
         val style1 = SpanStyle(localeList = localeList1)
         val style2 = SpanStyle(localeList = localeList2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.localeList).isEqualTo(localeList2)
     }

     @Test
     fun `lerp background with a and b are Null and t is smaller than half`() {
         val style1 = SpanStyle(background = Color.Unset)
         val style2 = SpanStyle(background = Color.Unset)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = 0.1f)

         assertThat(newSpanStyle.background).isEqualTo(Color.Unset)
     }

     @Test
     fun `lerp background with a is Null and b is not Null`() {
         val t = 0.1f
         val color1 = Color.Unset
         val style1 = SpanStyle(background = color1)
         val color2 = Color.Red
         val style2 = SpanStyle(background = color2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.background).isEqualTo(lerp(color1, color2, t))
     }

     @Test
     fun `lerp background with a is Not Null and b is Null`() {
         val t = 0.1f
         val color1 = Color.Red
         val style1 = SpanStyle(background = color1)
         val style2 = SpanStyle(background = Color.Unset)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.background).isEqualTo(lerp(color1, Color.Unset, t))
     }

     @Test
     fun `lerp background with a and b are not Null and t is smaller than half`() {
         val color1 = Color.Red
         val color2 = Color.Green
         val t = 0.2f
         val style1 = SpanStyle(background = color1)
         val style2 = SpanStyle(background = color2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.background).isEqualTo(lerp(color1, color2, t))
     }

     @Test
     fun `lerp background with a and b are not Null and t is larger than half`() {
         val color1 = Color.Red
         val color2 = Color.Green
         val t = 0.8f
         val style1 = SpanStyle(background = color1)
         val style2 = SpanStyle(background = color2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.background).isEqualTo(lerp(color1, color2, t))
     }

     @Test
     fun `lerp textDecoration with a and b are not Null and t is smaller than half`() {
         val decoration1 = TextDecoration.LineThrough
         val decoration2 = TextDecoration.Underline
         val t = 0.2f
         val style1 = SpanStyle(textDecoration = decoration1)
         val style2 = SpanStyle(textDecoration = decoration2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.textDecoration).isEqualTo(decoration1)
     }

     @Test
     fun `lerp textDecoration with a and b are not Null and t is larger than half`() {
         val decoration1 = TextDecoration.LineThrough
         val decoration2 = TextDecoration.Underline
         val t = 0.8f
         val style1 = SpanStyle(textDecoration = decoration1)
         val style2 = SpanStyle(textDecoration = decoration2)

         val newSpanStyle = lerp(start = style1, stop = style2, fraction = t)

         assertThat(newSpanStyle.textDecoration).isEqualTo(decoration2)
     }
 }