| /* |
| * 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. |
| */ |
| |
| // suppression needed for onChildPositioned import |
| @file:Suppress("DEPRECATION") |
| |
| package androidx.compose.material |
| |
| import android.os.Build |
| import androidx.compose.foundation.Box |
| import androidx.compose.foundation.Text |
| import androidx.compose.foundation.contentColor |
| import androidx.compose.foundation.currentTextStyle |
| import androidx.compose.foundation.layout.Column |
| import androidx.compose.foundation.layout.InnerPadding |
| import androidx.compose.foundation.layout.RowScope |
| import androidx.compose.foundation.layout.Spacer |
| import androidx.compose.foundation.layout.Stack |
| import androidx.compose.foundation.layout.fillMaxSize |
| import androidx.compose.foundation.layout.height |
| import androidx.compose.foundation.layout.heightIn |
| import androidx.compose.foundation.layout.padding |
| import androidx.compose.foundation.layout.preferredSize |
| import androidx.compose.foundation.layout.size |
| import androidx.compose.foundation.layout.width |
| import androidx.compose.foundation.layout.widthIn |
| import androidx.compose.foundation.shape.CutCornerShape |
| import androidx.compose.runtime.Composable |
| import androidx.compose.runtime.Providers |
| import androidx.compose.runtime.getValue |
| import androidx.compose.runtime.mutableStateOf |
| import androidx.compose.runtime.remember |
| import androidx.compose.runtime.setValue |
| import androidx.compose.ui.Modifier |
| import androidx.compose.ui.geometry.Offset |
| import androidx.compose.ui.geometry.Rect |
| import androidx.compose.ui.graphics.Color |
| import androidx.compose.ui.graphics.RectangleShape |
| import androidx.compose.ui.graphics.compositeOver |
| import androidx.compose.ui.layout.LayoutCoordinates |
| import androidx.compose.ui.layout.boundsInRoot |
| import androidx.compose.ui.onChildPositioned |
| import androidx.compose.ui.onPositioned |
| import androidx.compose.ui.platform.testTag |
| import androidx.compose.ui.semantics.semantics |
| import androidx.compose.ui.unit.Dp |
| import androidx.compose.ui.unit.dp |
| import androidx.compose.ui.unit.sp |
| import androidx.test.filters.FlakyTest |
| import androidx.test.filters.MediumTest |
| import androidx.test.filters.SdkSuppress |
| import androidx.ui.test.assertHasClickAction |
| import androidx.ui.test.assertHasNoClickAction |
| import androidx.ui.test.assertHeightIsAtLeast |
| import androidx.ui.test.assertHeightIsEqualTo |
| import androidx.ui.test.assertIsEnabled |
| import androidx.ui.test.assertIsNotEnabled |
| import androidx.ui.test.assertShape |
| import androidx.ui.test.assertWidthIsEqualTo |
| import androidx.ui.test.captureToBitmap |
| import androidx.ui.test.createComposeRule |
| import androidx.ui.test.hasClickAction |
| import androidx.ui.test.onNode |
| import androidx.ui.test.onNodeWithTag |
| import androidx.ui.test.onNodeWithText |
| import androidx.ui.test.performClick |
| import androidx.ui.test.runOnIdle |
| import com.google.common.truth.Truth.assertThat |
| import org.junit.Rule |
| import org.junit.Test |
| import org.junit.runner.RunWith |
| import org.junit.runners.JUnit4 |
| import kotlin.math.abs |
| |
| @MediumTest |
| @RunWith(JUnit4::class) |
| class ButtonTest { |
| |
| @get:Rule |
| val composeTestRule = createComposeRule() |
| |
| @Test |
| fun defaultSemantics() { |
| composeTestRule.setMaterialContent { |
| Stack { |
| Button(modifier = Modifier.testTag("myButton"), onClick = {}) { |
| Text("myButton") |
| } |
| } |
| } |
| |
| onNodeWithTag("myButton") |
| .assertIsEnabled() |
| } |
| |
| @Test |
| fun disabledSemantics() { |
| composeTestRule.setMaterialContent { |
| Stack { |
| Button(modifier = Modifier.testTag("myButton"), onClick = {}, enabled = false) { |
| Text("myButton") |
| } |
| } |
| } |
| |
| onNodeWithTag("myButton") |
| .assertIsNotEnabled() |
| } |
| |
| @Test |
| fun findByTextAndClick() { |
| var counter = 0 |
| val onClick: () -> Unit = { ++counter } |
| val text = "myButton" |
| |
| composeTestRule.setMaterialContent { |
| Stack { |
| Button(onClick = onClick) { |
| Text(text) |
| } |
| } |
| } |
| |
| // TODO(b/129400818): this actually finds the text, not the button as |
| // merge semantics aren't implemented yet |
| onNodeWithText(text) |
| .performClick() |
| |
| runOnIdle { |
| assertThat(counter).isEqualTo(1) |
| } |
| } |
| |
| @Test |
| @FlakyTest // TODO: b/158341686 |
| fun canBeDisabled() { |
| val tag = "myButton" |
| |
| composeTestRule.setMaterialContent { |
| var enabled by remember { mutableStateOf(true) } |
| val onClick = { enabled = false } |
| Stack { |
| Button(modifier = Modifier.testTag(tag), onClick = onClick, enabled = enabled) { |
| Text("Hello") |
| } |
| } |
| } |
| onNodeWithTag(tag) |
| // Confirm the button starts off enabled, with a click action |
| .assertHasClickAction() |
| .assertIsEnabled() |
| .performClick() |
| // Then confirm it's disabled with no click action after clicking it |
| .assertHasNoClickAction() |
| .assertIsNotEnabled() |
| } |
| |
| @Test |
| fun clickIsIndependentBetweenButtons() { |
| var button1Counter = 0 |
| val button1OnClick: () -> Unit = { ++button1Counter } |
| val button1Tag = "button1" |
| |
| var button2Counter = 0 |
| val button2OnClick: () -> Unit = { ++button2Counter } |
| val button2Tag = "button2" |
| |
| val text = "myButton" |
| |
| composeTestRule.setMaterialContent { |
| Column { |
| Button(modifier = Modifier.testTag(button1Tag), onClick = button1OnClick) { |
| Text(text) |
| } |
| Button(modifier = Modifier.testTag(button2Tag), onClick = button2OnClick) { |
| Text(text) |
| } |
| } |
| } |
| |
| onNodeWithTag(button1Tag) |
| .performClick() |
| |
| runOnIdle { |
| assertThat(button1Counter).isEqualTo(1) |
| assertThat(button2Counter).isEqualTo(0) |
| } |
| |
| onNodeWithTag(button2Tag) |
| .performClick() |
| |
| runOnIdle { |
| assertThat(button1Counter).isEqualTo(1) |
| assertThat(button2Counter).isEqualTo(1) |
| } |
| } |
| |
| @Test |
| fun buttonHeightIsFromSpec() { |
| if (composeTestRule.density.fontScale > 1f) { |
| // This test can be reasonable failing on the non default font scales |
| // so lets skip it. |
| return |
| } |
| composeTestRule.setMaterialContent { |
| Button(onClick = {}) { |
| Text("Test button") |
| } |
| } |
| |
| onNode(hasClickAction()) |
| .assertHeightIsEqualTo(36.dp) |
| } |
| |
| @Test |
| fun ButtonWithLargeFontSizeIsLargerThenMinHeight() { |
| composeTestRule.setMaterialContent { |
| Button(onClick = {}) { |
| Text( |
| text = "Test button", |
| fontSize = 50.sp |
| ) |
| } |
| } |
| |
| onNode(hasClickAction()) |
| .assertHeightIsAtLeast(37.dp) |
| } |
| |
| @Test |
| fun containedButtonPropagateDefaultTextStyle() { |
| composeTestRule.setMaterialContent { |
| Button(onClick = {}) { |
| assertThat(currentTextStyle()).isEqualTo(MaterialTheme.typography.button) |
| } |
| } |
| } |
| |
| @Test |
| fun outlinedButtonPropagateDefaultTextStyle() { |
| composeTestRule.setMaterialContent { |
| OutlinedButton(onClick = {}) { |
| assertThat(currentTextStyle()).isEqualTo(MaterialTheme.typography.button) |
| } |
| } |
| } |
| |
| @Test |
| fun textButtonPropagateDefaultTextStyle() { |
| composeTestRule.setMaterialContent { |
| TextButton(onClick = {}) { |
| assertThat(currentTextStyle()).isEqualTo(MaterialTheme.typography.button) |
| } |
| } |
| } |
| |
| @Test |
| fun containedButtonHorPaddingIsFromSpec() { |
| assertLeftPaddingIs(16.dp) { text -> |
| Button(onClick = {}, content = text) |
| } |
| } |
| |
| @Test |
| fun outlinedButtonHorPaddingIsFromSpec() { |
| assertLeftPaddingIs(16.dp) { text -> |
| OutlinedButton(onClick = {}, content = text) |
| } |
| } |
| |
| @Test |
| fun textButtonHorPaddingIsFromSpec() { |
| assertLeftPaddingIs(8.dp) { text -> |
| TextButton(onClick = {}, content = text) |
| } |
| } |
| |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.O) |
| @Test |
| fun shapeAndColorFromThemeIsUsed() { |
| val shape = CutCornerShape(10.dp) |
| var surface = Color.Transparent |
| var primary = Color.Transparent |
| composeTestRule.setMaterialContent { |
| surface = MaterialTheme.colors.surface |
| primary = MaterialTheme.colors.primary |
| Providers(ShapesAmbient provides Shapes(small = shape)) { |
| Button(modifier = Modifier.testTag("myButton"), onClick = {}, elevation = 0.dp) { |
| Box(Modifier.preferredSize(10.dp, 10.dp)) |
| } |
| } |
| } |
| |
| onNodeWithTag("myButton") |
| .captureToBitmap() |
| .assertShape( |
| density = composeTestRule.density, |
| shape = shape, |
| shapeColor = primary, |
| backgroundColor = surface, |
| shapeOverlapPixelCount = with(composeTestRule.density) { 1.dp.toPx() } |
| ) |
| } |
| |
| @Test |
| fun buttonContentColorIsCorrect() { |
| var onPrimary = Color.Transparent |
| var content = Color.Transparent |
| composeTestRule.setMaterialContent { |
| onPrimary = MaterialTheme.colors.onPrimary |
| Button(onClick = {}) { |
| content = contentColor() |
| } |
| } |
| |
| assertThat(content).isEqualTo(onPrimary) |
| } |
| |
| @Test |
| fun outlinedButtonContentColorIsCorrect() { |
| var primary = Color.Transparent |
| var content = Color.Transparent |
| composeTestRule.setMaterialContent { |
| primary = MaterialTheme.colors.primary |
| OutlinedButton(onClick = {}) { |
| content = contentColor() |
| } |
| } |
| |
| assertThat(content).isEqualTo(primary) |
| } |
| |
| @Test |
| fun textButtonContentColorIsCorrect() { |
| var primary = Color.Transparent |
| var content = Color.Transparent |
| composeTestRule.setMaterialContent { |
| primary = MaterialTheme.colors.primary |
| TextButton(onClick = {}) { |
| content = contentColor() |
| } |
| } |
| |
| assertThat(content).isEqualTo(primary) |
| } |
| |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.O) |
| @Test |
| fun containedButtonDisabledBackgroundIsCorrect() { |
| var surface = Color.Transparent |
| var onSurface = Color.Transparent |
| val padding = 8.dp |
| composeTestRule.setMaterialContent { |
| surface = MaterialTheme.colors.surface |
| onSurface = MaterialTheme.colors.onSurface |
| Box(Modifier.testTag("myButton")) { |
| // stack allows to verify there is no shadow |
| Stack(Modifier.padding(padding)) { |
| Button( |
| onClick = {}, |
| enabled = false, |
| shape = RectangleShape |
| ) {} |
| } |
| } |
| } |
| |
| onNodeWithTag("myButton") |
| .captureToBitmap() |
| .assertShape( |
| density = composeTestRule.density, |
| horizontalPadding = padding, |
| verticalPadding = padding, |
| backgroundColor = surface, |
| shapeColor = onSurface.copy(alpha = 0.12f).compositeOver(surface) |
| ) |
| } |
| |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.O) |
| @Test |
| fun containedButtonWithCustomColorDisabledBackgroundIsCorrect() { |
| var surface = Color.Transparent |
| var onSurface = Color.Transparent |
| val padding = 8.dp |
| composeTestRule.setMaterialContent { |
| surface = MaterialTheme.colors.surface |
| onSurface = MaterialTheme.colors.onSurface |
| Box(Modifier.testTag("myButton")) { |
| // stack allows to verify there is no shadow |
| Stack(Modifier.padding(padding)) { |
| Button( |
| onClick = {}, |
| enabled = false, |
| backgroundColor = Color.Red, |
| shape = RectangleShape |
| ) {} |
| } |
| } |
| } |
| |
| onNodeWithTag("myButton") |
| .captureToBitmap() |
| .assertShape( |
| density = composeTestRule.density, |
| horizontalPadding = padding, |
| verticalPadding = padding, |
| backgroundColor = surface, |
| shapeColor = onSurface.copy(alpha = 0.12f).compositeOver(surface) |
| ) |
| } |
| |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.O) |
| @Test |
| fun outlinedButtonDisabledBackgroundIsCorrect() { |
| var surface = Color.Transparent |
| val padding = 8.dp |
| composeTestRule.setMaterialContent { |
| surface = MaterialTheme.colors.surface |
| // stack allows to verify there is no shadow |
| Stack(Modifier.padding(padding)) { |
| OutlinedButton( |
| modifier = Modifier.testTag("myButton"), |
| onClick = {}, |
| enabled = false, |
| shape = RectangleShape, |
| border = null |
| ) {} |
| } |
| } |
| |
| onNodeWithTag("myButton") |
| .captureToBitmap() |
| .assertShape( |
| density = composeTestRule.density, |
| shape = RectangleShape, |
| shapeColor = surface, |
| backgroundColor = surface |
| ) |
| } |
| |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.O) |
| @Test |
| fun textButtonDisabledBackgroundIsCorrect() { |
| var surface = Color.Transparent |
| composeTestRule.setMaterialContent { |
| surface = MaterialTheme.colors.surface |
| // stack allows to verify there is no shadow |
| Stack(Modifier.padding(8.dp)) { |
| TextButton( |
| modifier = Modifier.testTag("myButton"), |
| onClick = {}, |
| enabled = false, |
| shape = RectangleShape |
| ) {} |
| } |
| } |
| |
| onNodeWithTag("myButton") |
| .captureToBitmap() |
| .assertShape( |
| density = composeTestRule.density, |
| shape = RectangleShape, |
| shapeColor = surface, |
| backgroundColor = surface |
| ) |
| } |
| |
| @Test |
| fun containedButtonDisabledContentColorIsCorrect() { |
| var onSurface = Color.Transparent |
| var content = Color.Transparent |
| var emphasis: Emphasis? = null |
| composeTestRule.setMaterialContent { |
| onSurface = MaterialTheme.colors.onSurface |
| emphasis = EmphasisAmbient.current.disabled |
| Button(onClick = {}, enabled = false) { |
| content = contentColor() |
| } |
| } |
| |
| assertThat(content).isEqualTo(emphasis!!.applyEmphasis(onSurface)) |
| } |
| |
| @Test |
| fun outlinedButtonDisabledContentColorIsCorrect() { |
| var onSurface = Color.Transparent |
| var content = Color.Transparent |
| var emphasis: Emphasis? = null |
| composeTestRule.setMaterialContent { |
| onSurface = MaterialTheme.colors.onSurface |
| emphasis = EmphasisAmbient.current.disabled |
| OutlinedButton(onClick = {}, enabled = false) { |
| content = contentColor() |
| } |
| } |
| |
| assertThat(content).isEqualTo(emphasis!!.applyEmphasis(onSurface)) |
| } |
| |
| @Test |
| fun textButtonDisabledContentColorIsCorrect() { |
| var onSurface = Color.Transparent |
| var content = Color.Transparent |
| var emphasis: Emphasis? = null |
| composeTestRule.setMaterialContent { |
| onSurface = MaterialTheme.colors.onSurface |
| emphasis = EmphasisAmbient.current.disabled |
| TextButton(onClick = {}, enabled = false) { |
| content = contentColor() |
| } |
| } |
| |
| assertThat(content).isEqualTo(emphasis!!.applyEmphasis(onSurface)) |
| } |
| |
| @Test |
| fun contentIsWrappedAndCentered() { |
| var buttonCoordinates: LayoutCoordinates? = null |
| var contentCoordinates: LayoutCoordinates? = null |
| composeTestRule.setMaterialContent { |
| Stack { |
| Button({}, Modifier.onPositioned { buttonCoordinates = it }) { |
| Box( |
| Modifier.preferredSize(2.dp) |
| .onPositioned { contentCoordinates = it } |
| ) |
| } |
| } |
| } |
| |
| runOnIdle { |
| val buttonBounds = buttonCoordinates!!.boundsInRoot |
| val contentBounds = contentCoordinates!!.boundsInRoot |
| assertThat(contentBounds.width).isLessThan(buttonBounds.width) |
| assertThat(contentBounds.height).isLessThan(buttonBounds.height) |
| with(composeTestRule.density) { |
| assertThat(contentBounds.width).isEqualTo(2.dp.toIntPx().toFloat()) |
| assertThat(contentBounds.height).isEqualTo(2.dp.toIntPx().toFloat()) |
| } |
| assertWithinOnePixel(buttonBounds.center, contentBounds.center) |
| } |
| } |
| |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.O) |
| @Test |
| fun zOrderingBasedOnElevationIsApplied() { |
| composeTestRule.setMaterialContent { |
| Stack( |
| Modifier.semantics(mergeAllDescendants = true) {} |
| .testTag("stack") |
| .preferredSize(10.dp, 10.dp) |
| ) { |
| Button( |
| backgroundColor = Color.Yellow, |
| elevation = 2.dp, |
| onClick = {}, |
| shape = RectangleShape |
| ) { |
| Box(Modifier.fillMaxSize()) |
| } |
| Button( |
| backgroundColor = Color.Green, |
| elevation = 0.dp, |
| onClick = {}, |
| shape = RectangleShape |
| ) { |
| Box(Modifier.fillMaxSize()) |
| } |
| } |
| } |
| |
| onNodeWithTag("stack") |
| .captureToBitmap() |
| .assertShape( |
| density = composeTestRule.density, |
| shape = RectangleShape, |
| shapeColor = Color.Yellow, |
| backgroundColor = Color.White |
| ) |
| } |
| |
| @Test |
| fun minHeightAndMinWidthCanBeOverridden() { |
| composeTestRule.setMaterialContent { |
| Button(onClick = {}, contentPadding = InnerPadding(), modifier = Modifier.widthIn(20.dp) |
| .heightIn(15.dp).testTag("button")) { |
| Spacer(Modifier.size(10.dp)) |
| } |
| } |
| |
| onNodeWithTag("button") |
| .assertWidthIsEqualTo(20.dp) |
| .assertHeightIsEqualTo(15.dp) |
| } |
| |
| @Test |
| fun weightModifierOnButton() { |
| var item1Bounds = Rect(0f, 0f, 0f, 0f) |
| var buttonBounds = Rect(0f, 0f, 0f, 0f) |
| composeTestRule.setMaterialContent { |
| Column { |
| Spacer(Modifier.size(10.dp).weight(1f).onPositioned { |
| item1Bounds = it.boundsInRoot |
| }) |
| |
| Button(onClick = {}, modifier = Modifier.weight(1f).onPositioned { |
| buttonBounds = it.boundsInRoot |
| }) { |
| Text("Button") |
| } |
| |
| Spacer(Modifier.size(10.dp).weight(1f)) |
| } |
| } |
| |
| assertThat(item1Bounds.top).isNotEqualTo(0f) |
| assertThat(buttonBounds.left).isEqualTo(0f) |
| } |
| |
| @Test |
| fun buttonContentIsRow() { |
| var buttonBounds = Rect(0f, 0f, 0f, 0f) |
| var item1Bounds = Rect(0f, 0f, 0f, 0f) |
| var item2Bounds = Rect(0f, 0f, 0f, 0f) |
| composeTestRule.setMaterialContent { |
| Button(onClick = {}, modifier = Modifier.onPositioned { |
| buttonBounds = it.boundsInRoot |
| }) { |
| Spacer(Modifier.size(10.dp).onPositioned { |
| item1Bounds = it.boundsInRoot |
| }) |
| Spacer(Modifier.width(10.dp).height(5.dp).onPositioned { |
| item2Bounds = it.boundsInRoot |
| }) |
| } |
| } |
| |
| assertThat(item1Bounds.center.y).isWithin(1f).of(buttonBounds.center.y) |
| assertThat(item2Bounds.center.y).isWithin(1f).of(buttonBounds.center.y) |
| assertThat(item1Bounds.right).isWithin(1f).of(buttonBounds.center.x) |
| assertThat(item2Bounds.left).isWithin(1f).of(buttonBounds.center.x) |
| } |
| |
| private fun assertLeftPaddingIs( |
| padding: Dp, |
| button: @Composable (@Composable RowScope.() -> Unit) -> Unit |
| ) { |
| var parentCoordinates: LayoutCoordinates? = null |
| var childCoordinates: LayoutCoordinates? = null |
| composeTestRule.setMaterialContent { |
| Stack(Modifier.onChildPositioned { parentCoordinates = it }) { |
| button { |
| Text("Test button", |
| Modifier.onPositioned { childCoordinates = it } |
| ) |
| } |
| } |
| } |
| |
| runOnIdle { |
| val topLeft = childCoordinates!!.localToGlobal(Offset.Zero).x - |
| parentCoordinates!!.localToGlobal(Offset.Zero).x |
| val currentPadding = with(composeTestRule.density) { |
| padding.toIntPx().toFloat() |
| } |
| assertThat(currentPadding).isEqualTo(topLeft) |
| } |
| } |
| } |
| |
| fun assertWithinOnePixel(expected: Offset, actual: Offset) { |
| assertWithinOnePixel(expected.x, actual.x) |
| assertWithinOnePixel(expected.y, actual.y) |
| } |
| |
| fun assertWithinOnePixel(expected: Float, actual: Float) { |
| val diff = abs(expected - actual) |
| assertThat(diff).isLessThan(1.1f) |
| } |
