[go: nahoru, domu]

Improvements in Compose testing lib sync.

After trying to setup tests for jetnews I identified several issues in
our synchonization. After fixing these several other issues surfaced
that were previously hidden by incorrect sync.

I have introduce ComposeIdlingResource that registers itself into
Espresso. This way we leave synchronization to Espresso. It removed
several flakes we had because we used to wait for idle compose and then
did the "Espresso wait". From now on Espresso does all of it at the same
time. This helps in cases where we have regular Android event that later
leads to invalidation of compose.

Thanks to us having ComposeIdlingResource we no longer need to wait
after we perform actions (doClick) for idle Compose. It also makes tests
faster as we don't sync when not needed. This unfortunately broke tests
that were relying on this fact (incorrectly) and touching the UI thread
from the test thread.

So far lots of tests were using waitForIdleCompose() and touching
variables from different threads or did not use any kind of
synchonization at all. They were lucky because methods like doClick used
to wait for UI being idle before leaving. To address that I have
introduced runOnIdleCompose that waits for idle compose and performs the
given lambda on the UI thread. This makes assertions nice and stable! :)
I have also removed waitForIdle {} as it would encourage bad practices
from now on.

Other thing discovered after I removed the flakes was that we were
always recreating SemanticsConfiguration which previsouly wasn't
detected. This however was something on which the testing API relied on.
So I memoized the SemanticsConfiguration. This will need to work with
merging also.

We were also not disposing compositions between tests. This lead to more
synchronization issues as old compositions were still part of the app.

Another wrong thing was that we always send any events to the first
ComposeView. This was wrong in case the second ComposeView would need to
work with events. It wasn't detected becase  MultipleComposeRootsTest
had wrong assertions. Now it is fixed.

Unfortunately I had to fix several tests so sorry for the diff. However
I couldn't split it because the sync changes go hand in hand with how
the tests are written.

Bug: b/122349846
Test: Verified on current tests and local JetNews tests.
Change-Id: If58d3c300e430de4ce81a7e4a963e41c04f71b5b
diff --git a/ui/ui-material/src/androidTest/java/androidx/ui/material/ButtonTest.kt b/ui/ui-material/src/androidTest/java/androidx/ui/material/ButtonTest.kt
index 746c116..df293973 100644
--- a/ui/ui-material/src/androidTest/java/androidx/ui/material/ButtonTest.kt
+++ b/ui/ui-material/src/androidTest/java/androidx/ui/material/ButtonTest.kt
@@ -16,6 +16,7 @@
 
 package androidx.ui.material
 
+import androidx.compose.state
 import androidx.test.filters.MediumTest
 import androidx.compose.unaryPlus
 import androidx.ui.core.Dp
@@ -34,6 +35,8 @@
 import androidx.ui.layout.Center
 import androidx.ui.layout.Column
 import androidx.ui.layout.Wrap
+import androidx.ui.test.assertHasClickAction
+import androidx.ui.test.assertHasNoClickAction
 import androidx.ui.test.assertSemanticsIsEqualTo
 import androidx.ui.test.createComposeRule
 import androidx.ui.test.createFullSemantics
@@ -41,7 +44,7 @@
 import androidx.ui.test.findByTag
 import androidx.ui.test.findByText
 import androidx.ui.text.TextStyle
-import com.google.common.truth.Truth
+import com.google.common.truth.Truth.assertThat
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Rule
@@ -113,9 +116,45 @@
         findByText(text)
             .doClick()
 
-        Truth
-            .assertThat(counter)
-            .isEqualTo(1)
+        composeTestRule.runOnIdleCompose {
+            assertThat(counter)
+                .isEqualTo(1)
+        }
+    }
+
+    @Test
+    fun buttonTest_canBeDisabled() {
+        val tag = "myButton"
+
+        composeTestRule.setMaterialContent {
+            val enabled = +state { true }
+            val onClick: (() -> Unit)? = if (enabled.value) {
+                { enabled.value = false }
+            } else {
+                null
+            }
+            Center {
+                TestTag(tag = tag) {
+                    Button( text = "Hello")
+                }
+            }
+        }
+        findByTag(tag)
+            // Confirm the button starts off enabled, with a click action
+            .assertHasClickAction()
+            .assertSemanticsIsEqualTo(
+                createFullSemantics(
+                    isEnabled = true
+                )
+            )
+            .doClick()
+            // Then confirm it's disabled with no click action after clicking it
+            .assertHasNoClickAction()
+            .assertSemanticsIsEqualTo(
+                createFullSemantics(
+                    isEnabled = false
+                )
+            )
     }
 
     @Test
@@ -144,24 +183,18 @@
         findByTag(button1Tag)
             .doClick()
 
-        Truth
-            .assertThat(button1Counter)
-            .isEqualTo(1)
-
-        Truth
-            .assertThat(button2Counter)
-            .isEqualTo(0)
+        composeTestRule.runOnIdleCompose {
+            assertThat(button1Counter).isEqualTo(1)
+            assertThat(button2Counter).isEqualTo(0)
+        }
 
         findByTag(button2Tag)
             .doClick()
 
-        Truth
-            .assertThat(button1Counter)
-            .isEqualTo(1)
-
-        Truth
-            .assertThat(button2Counter)
-            .isEqualTo(1)
+        composeTestRule.runOnIdleCompose {
+            assertThat(button1Counter).isEqualTo(1)
+            assertThat(button2Counter).isEqualTo(1)
+        }
     }
 
     @Test
@@ -190,7 +223,7 @@
         }
 
         withDensity(composeTestRule.density) {
-            Truth.assertThat(realSize.height.value)
+            assertThat(realSize.height.value)
                 .isGreaterThan(36.dp.toIntPx().value.toFloat())
         }
     }
@@ -201,7 +234,7 @@
             Button( style = ContainedButtonStyle()) {
                 val style = (+MaterialTheme.typography()).button
                     .copy(color = (+MaterialTheme.colors()).onPrimary)
-                Truth.assertThat(+currentTextStyle()).isEqualTo(style)
+                assertThat(+currentTextStyle()).isEqualTo(style)
             }
         }
     }
@@ -212,7 +245,7 @@
             Button( style = OutlinedButtonStyle()) {
                 val style = (+MaterialTheme.typography()).button
                     .copy(color = (+MaterialTheme.colors()).primary)
-                Truth.assertThat(+currentTextStyle()).isEqualTo(style)
+                assertThat(+currentTextStyle()).isEqualTo(style)
             }
         }
     }
@@ -223,7 +256,7 @@
             Button( style = OutlinedButtonStyle()) {
                 val style = (+MaterialTheme.typography()).button
                     .copy(color = (+MaterialTheme.colors()).primary)
-                Truth.assertThat(+currentTextStyle()).isEqualTo(style)
+                assertThat(+currentTextStyle()).isEqualTo(style)
             }
         }
     }
diff --git a/ui/ui-material/src/androidTest/java/androidx/ui/material/DrawerTest.kt b/ui/ui-material/src/androidTest/java/androidx/ui/material/DrawerTest.kt
index 61a1c8a..64f08a7 100644
--- a/ui/ui-material/src/androidTest/java/androidx/ui/material/DrawerTest.kt
+++ b/ui/ui-material/src/androidTest/java/androidx/ui/material/DrawerTest.kt
@@ -174,21 +174,22 @@
         findByTag("Drawer")
             .doClick()
 
-        Truth.assertThat(drawerClicks).isEqualTo(0)
-        Truth.assertThat(bodyClicks).isEqualTo(1)
+        composeTestRule.runOnIdleCompose {
+            Truth.assertThat(drawerClicks).isEqualTo(0)
+            Truth.assertThat(bodyClicks).isEqualTo(1)
+        }
 
         composeTestRule.runOnUiThread {
             drawerState.state = DrawerState.Opened
         }
-        // TODO: we aren't correctly waiting for recompositions after clicking, so we need to wait
-        // again
-        Thread.sleep(100L)
 
         findByTag("Drawer")
             .doClick()
 
-        Truth.assertThat(drawerClicks).isEqualTo(1)
-        Truth.assertThat(bodyClicks).isEqualTo(1)
+        composeTestRule.runOnIdleCompose {
+            Truth.assertThat(drawerClicks).isEqualTo(1)
+            Truth.assertThat(bodyClicks).isEqualTo(1)
+        }
     }
 
     @Test
diff --git a/ui/ui-material/src/androidTest/java/androidx/ui/material/ListItemTest.kt b/ui/ui-material/src/androidTest/java/androidx/ui/material/ListItemTest.kt
index ab109a0..70c4aa1 100644
--- a/ui/ui-material/src/androidTest/java/androidx/ui/material/ListItemTest.kt
+++ b/ui/ui-material/src/androidTest/java/androidx/ui/material/ListItemTest.kt
@@ -37,7 +37,7 @@
 import androidx.ui.graphics.Image
 import androidx.ui.layout.Container
 import androidx.ui.test.createComposeRule
-import com.google.common.truth.Truth
+import com.google.common.truth.Truth.assertThat
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -59,20 +59,30 @@
     fun listItem_oneLine_size() {
         val dm = composeTestRule.displayMetrics
         val expectedHeightNoIcon = 48.dp
-        val expectedHeightSmallIcon = 56.dp
-        val expectedHeightLargeIcon = 72.dp
         composeTestRule
             .setMaterialContentAndCollectSizes {
                 ListItem(text = "Primary text")
             }
             .assertHeightEqualsTo(expectedHeightNoIcon)
             .assertWidthEqualsTo { dm.widthPixels.ipx }
+    }
+
+    @Test
+    fun listItem_oneLine_withIcon24_size() {
+        val dm = composeTestRule.displayMetrics
+        val expectedHeightSmallIcon = 56.dp
         composeTestRule
             .setMaterialContentAndCollectSizes {
                 ListItem(text = "Primary text", icon = icon24x24)
             }
             .assertHeightEqualsTo(expectedHeightSmallIcon)
             .assertWidthEqualsTo { dm.widthPixels.ipx }
+    }
+
+    @Test
+    fun listItem_oneLine_withIcon56_size() {
+        val dm = composeTestRule.displayMetrics
+        val expectedHeightLargeIcon = 72.dp
         composeTestRule
             .setMaterialContentAndCollectSizes {
                 ListItem(text = "Primary text", icon = icon56x56)
@@ -85,13 +95,19 @@
     fun listItem_twoLine_size() {
         val dm = composeTestRule.displayMetrics
         val expectedHeightNoIcon = 64.dp
-        val expectedHeightWithIcon = 72.dp
         composeTestRule
             .setMaterialContentAndCollectSizes {
                 ListItem(text = "Primary text", secondaryText = "Secondary text")
             }
             .assertHeightEqualsTo(expectedHeightNoIcon)
             .assertWidthEqualsTo { dm.widthPixels.ipx }
+    }
+
+    @Test
+    fun listItem_twoLine_withIcon_size() {
+        val dm = composeTestRule.displayMetrics
+        val expectedHeightWithIcon = 72.dp
+
         composeTestRule
             .setMaterialContentAndCollectSizes {
                 ListItem(
@@ -118,6 +134,12 @@
             }
             .assertHeightEqualsTo(expectedHeight)
             .assertWidthEqualsTo { dm.widthPixels.ipx }
+    }
+
+    @Test
+    fun listItem_threeLine_noSingleLine_size() {
+        val dm = composeTestRule.displayMetrics
+        val expectedHeight = 88.dp
         composeTestRule
             .setMaterialContentAndCollectSizes {
                 ListItem(
@@ -128,6 +150,12 @@
             }
             .assertHeightEqualsTo(expectedHeight)
             .assertWidthEqualsTo { dm.widthPixels.ipx }
+    }
+
+    @Test
+    fun listItem_threeLine_metaText_size() {
+        val dm = composeTestRule.displayMetrics
+        val expectedHeight = 88.dp
         composeTestRule
             .setMaterialContentAndCollectSizes {
                 ListItem(
@@ -139,6 +167,12 @@
             }
             .assertHeightEqualsTo(expectedHeight)
             .assertWidthEqualsTo { dm.widthPixels.ipx }
+    }
+
+    @Test
+    fun listItem_threeLine_noSingleLine_metaText_size() {
+        val dm = composeTestRule.displayMetrics
+        val expectedHeight = 88.dp
         composeTestRule
             .setMaterialContentAndCollectSizes {
                 ListItem(
@@ -173,16 +207,16 @@
             }
         }
         withDensity(composeTestRule.density) {
-            Truth.assertThat(textPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
-            Truth.assertThat(textPosition.value!!.y).isEqualTo(
+            assertThat(textPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
+            assertThat(textPosition.value!!.y).isEqualTo(
                 ((listItemHeight.toIntPx() - textSize.value!!.height.round()) / 2).toPx()
             )
             val dm = composeTestRule.displayMetrics
-            Truth.assertThat(trailingPosition.value!!.x).isEqualTo(
+            assertThat(trailingPosition.value!!.x).isEqualTo(
                 dm.widthPixels.px - trailingSize.value!!.width -
                         expectedRightPadding.toIntPx().toPx()
             )
-            Truth.assertThat(trailingPosition.value!!.y).isEqualTo(
+            assertThat(trailingPosition.value!!.y).isEqualTo(
                 ((listItemHeight.toIntPx() - trailingSize.value!!.height.round()) / 2).toPx()
             )
         }
@@ -207,15 +241,15 @@
             }
         }
         withDensity(composeTestRule.density) {
-            Truth.assertThat(iconPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
-            Truth.assertThat(iconPosition.value!!.y).isEqualTo(
+            assertThat(iconPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
+            assertThat(iconPosition.value!!.y).isEqualTo(
                 ((listItemHeight.toIntPx() - iconSize.value!!.height.round()) / 2).toPx()
             )
-            Truth.assertThat(textPosition.value!!.x).isEqualTo(
+            assertThat(textPosition.value!!.x).isEqualTo(
                 expectedLeftPadding.toIntPx().toPx() + iconSize.value!!.width +
                         expectedTextLeftPadding.toIntPx().toPx()
             )
-            Truth.assertThat(textPosition.value!!.y).isEqualTo(
+            assertThat(textPosition.value!!.y).isEqualTo(
                 ((listItemHeight.toIntPx() - textSize.value!!.height.round()) / 2).toPx()
             )
         }
@@ -263,21 +297,21 @@
             }
         }
         withDensity(composeTestRule.density) {
-            Truth.assertThat(textPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
-            Truth.assertThat(textBaseline.value!!).isEqualTo(expectedTextBaseline.toIntPx().toPx())
-            Truth.assertThat(secondaryTextPosition.value!!.x).isEqualTo(
+            assertThat(textPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
+            assertThat(textBaseline.value!!).isEqualTo(expectedTextBaseline.toIntPx().toPx())
+            assertThat(secondaryTextPosition.value!!.x).isEqualTo(
                 expectedLeftPadding.toIntPx().toPx()
             )
-            Truth.assertThat(secondaryTextBaseline.value!!).isEqualTo(
+            assertThat(secondaryTextBaseline.value!!).isEqualTo(
                 expectedTextBaseline.toIntPx().toPx() +
                         expectedSecondaryTextBaselineOffset.toIntPx().toPx()
             )
             val dm = composeTestRule.displayMetrics
-            Truth.assertThat(trailingPosition.value!!.x).isEqualTo(
+            assertThat(trailingPosition.value!!.x).isEqualTo(
                 dm.widthPixels.px - trailingSize.value!!.width -
                         expectedRightPadding.toIntPx().toPx()
             )
-            Truth.assertThat(trailingBaseline.value!!).isEqualTo(
+            assertThat(trailingBaseline.value!!).isEqualTo(
                 expectedTextBaseline.toIntPx().toPx()
             )
         }
@@ -323,21 +357,21 @@
             }
         }
         withDensity(composeTestRule.density) {
-            Truth.assertThat(textPosition.value!!.x).isEqualTo(
+            assertThat(textPosition.value!!.x).isEqualTo(
                 expectedLeftPadding.toIntPx().toPx() + iconSize.value!!.width +
                         expectedContentLeftPadding.toIntPx().toPx()
             )
-            Truth.assertThat(textBaseline.value!!).isEqualTo(expectedTextBaseline.toIntPx().toPx())
-            Truth.assertThat(secondaryTextPosition.value!!.x).isEqualTo(
+            assertThat(textBaseline.value!!).isEqualTo(expectedTextBaseline.toIntPx().toPx())
+            assertThat(secondaryTextPosition.value!!.x).isEqualTo(
                 expectedLeftPadding.toIntPx().toPx() + iconSize.value!!.width +
                         expectedContentLeftPadding.toIntPx().toPx()
             )
-            Truth.assertThat(secondaryTextBaseline.value!!).isEqualTo(
+            assertThat(secondaryTextBaseline.value!!).isEqualTo(
                 expectedTextBaseline.toIntPx().toPx() +
                         expectedSecondaryTextBaselineOffset.toIntPx().toPx()
             )
-            Truth.assertThat(iconPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
-            Truth.assertThat(iconPosition.value!!.y).isEqualTo(
+            assertThat(iconPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
+            assertThat(iconPosition.value!!.y).isEqualTo(
                 expectedIconTopPadding.toIntPx().toPx()
             )
         }
@@ -390,29 +424,29 @@
             }
         }
         withDensity(composeTestRule.density) {
-            Truth.assertThat(textPosition.value!!.x).isEqualTo(
+            assertThat(textPosition.value!!.x).isEqualTo(
                 expectedLeftPadding.toIntPx().toPx() + iconSize.value!!.width +
                         expectedContentLeftPadding.toIntPx().toPx()
             )
-            Truth.assertThat(textBaseline.value!!).isEqualTo(expectedTextBaseline.toIntPx().toPx())
-            Truth.assertThat(secondaryTextPosition.value!!.x).isEqualTo(
+            assertThat(textBaseline.value!!).isEqualTo(expectedTextBaseline.toIntPx().toPx())
+            assertThat(secondaryTextPosition.value!!.x).isEqualTo(
                 expectedLeftPadding.toIntPx().toPx() + iconSize.value!!.width +
                         expectedContentLeftPadding.toIntPx().toPx()
             )
-            Truth.assertThat(secondaryTextBaseline.value!!).isEqualTo(
+            assertThat(secondaryTextBaseline.value!!).isEqualTo(
                 expectedTextBaseline.toIntPx().toPx() +
                         expectedSecondaryTextBaselineOffset.toIntPx().toPx()
             )
-            Truth.assertThat(iconPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
-            Truth.assertThat(iconPosition.value!!.y).isEqualTo(
+            assertThat(iconPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
+            assertThat(iconPosition.value!!.y).isEqualTo(
                 expectedIconTopPadding.toIntPx().toPx()
             )
             val dm = composeTestRule.displayMetrics
-            Truth.assertThat(trailingPosition.value!!.x).isEqualTo(
+            assertThat(trailingPosition.value!!.x).isEqualTo(
                 dm.widthPixels.px - trailingSize.value!!.width -
                         expectedRightPadding.toIntPx().toPx()
             )
-            Truth.assertThat(trailingPosition.value!!.y).isEqualTo(
+            assertThat(trailingPosition.value!!.y).isEqualTo(
                 ((listItemHeight.toIntPx() - trailingSize.value!!.height.round()) / 2).toPx()
             )
         }
@@ -465,29 +499,29 @@
             }
         }
         withDensity(composeTestRule.density) {
-            Truth.assertThat(textPosition.value!!.x).isEqualTo(
+            assertThat(textPosition.value!!.x).isEqualTo(
                 expectedLeftPadding.toIntPx().toPx() + iconSize.value!!.width +
                         expectedContentLeftPadding.toIntPx().toPx()
             )
-            Truth.assertThat(textBaseline.value!!).isEqualTo(expectedTextBaseline.toIntPx().toPx())
-            Truth.assertThat(secondaryTextPosition.value!!.x).isEqualTo(
+            assertThat(textBaseline.value!!).isEqualTo(expectedTextBaseline.toIntPx().toPx())
+            assertThat(secondaryTextPosition.value!!.x).isEqualTo(
                 expectedLeftPadding.toIntPx().toPx() + iconSize.value!!.width +
                         expectedContentLeftPadding.toIntPx().toPx()
             )
-            Truth.assertThat(secondaryTextBaseline.value!!).isEqualTo(
+            assertThat(secondaryTextBaseline.value!!).isEqualTo(
                 expectedTextBaseline.toIntPx().toPx() +
                         expectedSecondaryTextBaselineOffset.toIntPx().toPx()
             )
-            Truth.assertThat(iconPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
-            Truth.assertThat(iconPosition.value!!.y).isEqualTo(
+            assertThat(iconPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
+            assertThat(iconPosition.value!!.y).isEqualTo(
                 expectedIconTopPadding.toIntPx().toPx()
             )
             val dm = composeTestRule.displayMetrics
-            Truth.assertThat(trailingPosition.value!!.x).isEqualTo(
+            assertThat(trailingPosition.value!!.x).isEqualTo(
                 dm.widthPixels.px - trailingSize.value!!.width -
                         expectedRightPadding.toIntPx().toPx()
             )
-            Truth.assertThat(trailingPosition.value!!.y).isEqualTo(
+            assertThat(trailingPosition.value!!.y).isEqualTo(
                 expectedIconTopPadding.toIntPx().toPx()
             )
         }
@@ -559,40 +593,40 @@
             }
         }
         withDensity(composeTestRule.density) {
-            Truth.assertThat(textPosition.value!!.x).isEqualTo(
+            assertThat(textPosition.value!!.x).isEqualTo(
                 expectedLeftPadding.toIntPx().toPx() + iconSize.value!!.width +
                         expectedContentLeftPadding.toIntPx().toPx()
             )
-            Truth.assertThat(textBaseline.value!!).isEqualTo(
+            assertThat(textBaseline.value!!).isEqualTo(
                 expectedOverlineBaseline.toIntPx().toPx() +
                         expectedTextBaselineOffset.toIntPx().toPx()
             )
-            Truth.assertThat(overlineTextPosition.value!!.x).isEqualTo(
+            assertThat(overlineTextPosition.value!!.x).isEqualTo(
                 expectedLeftPadding.toIntPx().toPx() + iconSize.value!!.width +
                         expectedContentLeftPadding.toIntPx().toPx()
             )
-            Truth.assertThat(overlineTextBaseline.value!!).isEqualTo(
+            assertThat(overlineTextBaseline.value!!).isEqualTo(
                 expectedOverlineBaseline.toIntPx().toPx()
             )
-            Truth.assertThat(secondaryTextPosition.value!!.x).isEqualTo(
+            assertThat(secondaryTextPosition.value!!.x).isEqualTo(
                 expectedLeftPadding.toIntPx().toPx() + iconSize.value!!.width +
                         expectedContentLeftPadding.toIntPx().toPx()
             )
-            Truth.assertThat(secondaryTextBaseline.value!!).isEqualTo(
+            assertThat(secondaryTextBaseline.value!!).isEqualTo(
                 expectedOverlineBaseline.toIntPx().toPx() +
                         expectedTextBaselineOffset.toIntPx().toPx() +
                         expectedSecondaryTextBaselineOffset.toIntPx().toPx()
             )
-            Truth.assertThat(iconPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
-            Truth.assertThat(iconPosition.value!!.y).isEqualTo(
+            assertThat(iconPosition.value!!.x).isEqualTo(expectedLeftPadding.toIntPx().toPx())
+            assertThat(iconPosition.value!!.y).isEqualTo(
                 expectedIconTopPadding.toIntPx().toPx()
             )
             val dm = composeTestRule.displayMetrics
-            Truth.assertThat(trailingPosition.value!!.x).isEqualTo(
+            assertThat(trailingPosition.value!!.x).isEqualTo(
                 dm.widthPixels.px - trailingSize.value!!.width -
                         expectedRightPadding.toIntPx().toPx()
             )
-            Truth.assertThat(trailingBaseline.value!!).isEqualTo(
+            assertThat(trailingBaseline.value!!).isEqualTo(
                 expectedOverlineBaseline.toIntPx().toPx()
             )
         }