compose/animation/animation/src/androidAndroidTest/kotlin/androidx/compose/animation/AnimatedContentTest.kt - platform/frameworks/support - Git at Google

 /*
  * Copyright 2021 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.compose.animation

 import androidx.compose.animation.core.InternalAnimationApi
 import androidx.compose.animation.core.LinearEasing
 import androidx.compose.animation.core.MutableTransitionState
 import androidx.compose.animation.core.Transition
 import androidx.compose.animation.core.keyframes
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.core.updateTransition
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.requiredSize
 import androidx.compose.foundation.layout.size
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.saveable.rememberSaveableStateHolder
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.withFrameMillis
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.layout.LayoutCoordinates
 import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.layout.positionInRoot
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.test.junit4.createComposeRule
 import androidx.compose.ui.test.onNodeWithTag
 import androidx.compose.ui.unit.Density
 import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.LargeTest
 import com.google.common.truth.Truth.assertThat
 import kotlin.math.roundToInt
 import kotlinx.coroutines.delay
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith

 @RunWith(AndroidJUnit4::class)
 @LargeTest
 class AnimatedContentTest {

  @get:Rule
  val rule = createComposeRule()

  @OptIn(InternalAnimationApi::class)
  @Test
  fun AnimatedContentSizeTransformTest() {
  val size1 = 40
  val size2 = 200
  val testModifier by mutableStateOf(TestModifier())
  val transitionState = MutableTransitionState(true)
  var playTimeMillis by mutableStateOf(0)
  rule.mainClock.autoAdvance = false
  rule.setContent {
  CompositionLocalProvider(LocalDensity provides Density(1f)) {
  val transition = updateTransition(transitionState)
  playTimeMillis = (transition.playTimeNanos / 1_000_000L).toInt()
  transition.AnimatedContent(
  testModifier,
  transitionSpec = {
  if (true isTransitioningTo false) {
  fadeIn() togetherWith fadeOut() using
  SizeTransform { initialSize, targetSize ->
  keyframes {
  durationMillis = 320
  IntSize(targetSize.width, initialSize.height) at 160 with
  LinearEasing
  targetSize at 320 with LinearEasing
  }
  }
  } else {
  fadeIn() togetherWith fadeOut() using SizeTransform { _, _ ->
  tween(durationMillis = 80, easing = LinearEasing)
  }
  }
  }
  ) {
  if (it) {
  Box(modifier = Modifier.size(size = size1.dp))
  } else {
  Box(modifier = Modifier.size(size = size2.dp))
  }
  }
  }
  }
  rule.runOnIdle {
  assertEquals(40, testModifier.height)
  assertEquals(40, testModifier.width)
  assertTrue(transitionState.targetState)
  transitionState.targetState = false
  }

  // Transition from item1 to item2 in 320ms, animating to full width in the first 160ms
  // then full height in the next 160ms
  while (transitionState.currentState != transitionState.targetState) {
  rule.runOnIdle {
  if (playTimeMillis <= 160) {
  assertEquals(playTimeMillis + 40, testModifier.width)
  assertEquals(40, testModifier.height)
  } else {
  assertEquals(200, testModifier.width)
  assertEquals(playTimeMillis - 120, testModifier.height)
  }
  }
  rule.mainClock.advanceTimeByFrame()
  }

  rule.runOnIdle {
  assertEquals(200, testModifier.width)
  assertEquals(200, testModifier.height)
  transitionState.targetState = true
  }

  // Transition from item2 to item1 in 80ms
  while (transitionState.currentState != transitionState.targetState) {
  rule.runOnIdle {
  if (playTimeMillis <= 80) {
  assertEquals(200 - playTimeMillis * 2, testModifier.width)
  assertEquals(200 - playTimeMillis * 2, testModifier.height)
  }
  }
  rule.mainClock.advanceTimeByFrame()
  }
  }

  @OptIn(InternalAnimationApi::class)
  @Test
  fun AnimatedContentSizeTransformEmptyComposableTest() {
  val size1 = 160
  val testModifier by mutableStateOf(TestModifier())
  val transitionState = MutableTransitionState(true)
  var playTimeMillis by mutableStateOf(0)
  rule.mainClock.autoAdvance = false
  rule.setContent {
  CompositionLocalProvider(LocalDensity provides Density(1f)) {
  val transition = updateTransition(transitionState)
  playTimeMillis = (transition.playTimeNanos / 1_000_000L).toInt()
  transition.AnimatedContent(
  testModifier,
  transitionSpec = {
  EnterTransition.None togetherWith ExitTransition.None using
  SizeTransform { _, _ ->
  tween(durationMillis = 160, easing = LinearEasing)
  }
  }
  ) {
  if (it) {
  Box(modifier = Modifier.size(size = size1.dp))
  }
  // Empty composable for it == false
  }
  }
  }
  rule.runOnIdle {
  assertEquals(160, testModifier.height)
  assertEquals(160, testModifier.width)
  assertTrue(transitionState.targetState)
  transitionState.targetState = false
  }

  // Transition from item1 to item2 in 320ms, animating to full width in the first 160ms
  // then full height in the next 160ms
  while (transitionState.currentState != transitionState.targetState) {
  rule.runOnIdle {
  assertEquals(160 - playTimeMillis, testModifier.width)
  assertEquals(160 - playTimeMillis, testModifier.height)
  }
  rule.mainClock.advanceTimeByFrame()
  }

  // Now there's only an empty composable
  rule.runOnIdle {
  assertEquals(0, testModifier.width)
  assertEquals(0, testModifier.height)
  transitionState.targetState = true
  }

  // Transition from item2 to item1 in 80ms
  while (transitionState.currentState != transitionState.targetState) {
  rule.runOnIdle {
  assertEquals(playTimeMillis, testModifier.width)
  assertEquals(playTimeMillis, testModifier.height)
  }
  rule.mainClock.advanceTimeByFrame()
  }
  }

  @OptIn(InternalAnimationApi::class)
  @Test
  fun AnimatedContentContentAlignmentTest() {
  val size1 = IntSize(80, 80)
  val size2 = IntSize(160, 240)
  val testModifier by mutableStateOf(TestModifier())
  var offset1 by mutableStateOf(Offset.Zero)
  var offset2 by mutableStateOf(Offset.Zero)
  var playTimeMillis by mutableStateOf(0)
  val transitionState = MutableTransitionState(true)
  val alignment = listOf(
  Alignment.TopStart, Alignment.BottomStart, Alignment.Center,
  Alignment.BottomEnd, Alignment.TopEnd
  )
  var contentAlignment by mutableStateOf(Alignment.TopStart)
  rule.setContent {
  CompositionLocalProvider(LocalDensity provides Density(1f)) {
  val transition = updateTransition(transitionState)
  playTimeMillis = (transition.playTimeNanos / 1_000_000L).toInt()
  transition.AnimatedContent(
  testModifier,
  contentAlignment = contentAlignment,
  transitionSpec = {
  fadeIn(animationSpec = tween(durationMillis = 80)) togetherWith fadeOut(
  animationSpec = tween(durationMillis = 80)
  ) using SizeTransform { _, _ ->
  tween(durationMillis = 80, easing = LinearEasing)
  }
  }
  ) {
  if (it) {
  Box(
  modifier = Modifier
  .onGloballyPositioned {
  offset1 = it.positionInRoot()
  }
  .size(size1.width.dp, size1.height.dp)
  )
  } else {
  Box(
  modifier = Modifier
  .onGloballyPositioned {
  offset2 = it.positionInRoot()
  }
  .size(size2.width.dp, size2.height.dp)
  )
  }
  }
  }
  }

  rule.mainClock.autoAdvance = false

  alignment.forEach {
  rule.runOnIdle {
  assertEquals(80, testModifier.height)
  assertEquals(80, testModifier.width)
  assertTrue(transitionState.targetState)
  contentAlignment = it
  }

  rule.mainClock.advanceTimeByFrame()
  rule.waitForIdle()
  rule.runOnIdle { transitionState.targetState = false }

  // Transition from item1 to item2 in 320ms, animating to full width in the first 160ms
  // then full height in the next 160ms
  while (transitionState.currentState != transitionState.targetState) {
  rule.runOnIdle {
  val space = IntSize(testModifier.width, testModifier.height)
  val position1 = it.align(size1, space, LayoutDirection.Ltr)
  val position2 = it.align(size2, space, LayoutDirection.Ltr)
  if (playTimeMillis < 80) {
  // This gets removed when the animation is finished at 80ms
  assertEquals(
  position1,
  IntOffset(offset1.x.roundToInt(), offset1.y.roundToInt())
  )
  }
  if (playTimeMillis > 0) {
  assertEquals(
  position2,
  IntOffset(offset2.x.roundToInt(), offset2.y.roundToInt())
  )
  }
  }
  rule.mainClock.advanceTimeByFrame()
  }

  rule.runOnIdle {
  assertEquals(size2.width, testModifier.width)
  assertEquals(size2.height, testModifier.height)
  // After the animation the size should be the same as parent, offset should be 0
  assertEquals(offset2, Offset.Zero)
  transitionState.targetState = true
  }

  // Transition from item2 to item1 in 80ms
  while (transitionState.currentState != transitionState.targetState) {
  rule.runOnIdle {
  val space = IntSize(testModifier.width, testModifier.height)
  val position1 = it.align(size1, space, LayoutDirection.Ltr)
  val position2 = it.align(size2, space, LayoutDirection.Ltr)
  if (playTimeMillis > 0) {
  assertEquals(
  position1,
  IntOffset(offset1.x.roundToInt(), offset1.y.roundToInt())
  )
  }
  if (playTimeMillis < 80) {
  assertEquals(
  position2,
  IntOffset(offset2.x.roundToInt(), offset2.y.roundToInt())
  )
  }
  }
  rule.mainClock.advanceTimeByFrame()
  }

  rule.runOnIdle {
  assertEquals(size1.width, testModifier.width)
  assertEquals(size1.height, testModifier.height)
  // After the animation the size should be the same as parent, offset should be 0
  assertEquals(offset1, Offset.Zero)
  }
  }
  }

  @OptIn(ExperimentalAnimationApi::class)
  @Test
  fun AnimatedContentSlideInAndOutOfContainerTest() {
  val transitionState = MutableTransitionState(true)
  // LinearEasing is required to ensure the animation doesn't reach final values before the
  // duration.
  val animSpec = tween<IntOffset>(200, easing = LinearEasing)
  lateinit var trueTransition: Transition<EnterExitState>
  lateinit var falseTransition: Transition<EnterExitState>
  rule.mainClock.autoAdvance = false
  rule.setContent {
  CompositionLocalProvider(LocalDensity provides Density(1f, 1f)) {
  @Suppress("UpdateTransitionLabel")
  val rootTransition = updateTransition(transitionState)
  rootTransition.AnimatedContent(
  transitionSpec = {
  if (true isTransitioningTo false) {
  slideIntoContainer(
  AnimatedContentTransitionScope.SlideDirection.Start, animSpec
  ) togetherWith
  slideOutOfContainer(
  AnimatedContentTransitionScope.SlideDirection.Start, animSpec
  )
  } else {
  slideIntoContainer(
  AnimatedContentTransitionScope.SlideDirection.End, animSpec
  ) togetherWith
  slideOutOfContainer(
  towards = AnimatedContentTransitionScope.SlideDirection.End,
  animSpec
  )
  }
  }
  ) { target ->
  if (target) {
  trueTransition = transition
  } else {
  falseTransition = transition
  }
  Box(
  Modifier
  .requiredSize(200.dp)
  .testTag(target.toString())
  )
  }
  }
  }

  // Kick off the first animation.
  transitionState.targetState = false
  // The initial composition creates the transition…
  rule.mainClock.advanceTimeByFrame()
  rule.onNodeWithTag("true").assertExists()
  rule.onNodeWithTag("false").assertExists()
  // …but the animation won't actually start until one frame later.
  rule.mainClock.advanceTimeByFrame()
  assertThat(trueTransition.animations).isNotEmpty()
  assertThat(falseTransition.animations).isNotEmpty()

  // Loop to ensure the content is offset correctly at each frame.
  var trueAnim = trueTransition.animations[0]
  var falseAnim = falseTransition.animations[0]
  assertThat(transitionState.currentState).isTrue()
  while (transitionState.currentState) {
  // True is leaving: it should start at 0 and slide out to -200.
  assertThat(trueAnim.value).isEqualTo(IntOffset(-trueTransition.playTimeMillis, 0))
  // False is entering: it should start at 200 and slide in to 0.
  assertThat(falseAnim.value)
  .isEqualTo(IntOffset(200 - falseTransition.playTimeMillis, 0))
  rule.mainClock.advanceTimeByFrame()
  }
  // The animation should remove the newly-hidden node from the composition.
  rule.onNodeWithTag("true").assertDoesNotExist()

  // Kick off the second transition.
  transitionState.targetState = true
  rule.mainClock.advanceTimeByFrame()
  rule.onNodeWithTag("true").assertExists()
  rule.onNodeWithTag("false").assertExists()
  rule.mainClock.advanceTimeByFrame()
  assertThat(trueTransition.animations).isNotEmpty()

  trueAnim = trueTransition.animations[0]
  falseAnim = falseTransition.animations[0]
  assertThat(transitionState.currentState).isFalse()
  while (!transitionState.currentState) {
  // True is entering, it should start at -200 and slide in to 0.
  assertThat(trueAnim.value).isEqualTo(IntOffset(trueTransition.playTimeMillis - 200, 0))
  // False is leaving, it should start at 0 and slide out to 200.
  assertThat(falseAnim.value).isEqualTo(IntOffset(falseTransition.playTimeMillis, 0))
  rule.mainClock.advanceTimeByFrame()
  }
  rule.onNodeWithTag("false").assertDoesNotExist()
  }

  @Test
  fun AnimatedContentWithKeysTest() {
  var targetState by mutableStateOf(1)
  val list = mutableListOf<Int>()
  rule.setContent {
  val transition = updateTransition(targetState)
  val holder = rememberSaveableStateHolder()
  transition.AnimatedContent(contentKey = { it > 2 }) {
  if (it <= 2) {
  holder.SaveableStateProvider(11) {
  var count by rememberSaveable { mutableStateOf(0) }
  LaunchedEffect(Unit) {
  list.add(++count)
  }
  }
  }
  Box(Modifier.requiredSize(200.dp))
  }
  LaunchedEffect(Unit) {
  assertFalse(transition.isRunning)
  targetState = 2
  withFrameMillis {
  assertFalse(transition.isRunning)
  assertEquals(1, transition.currentState)
  assertEquals(1, transition.targetState)

  // This state change should now cause an animation
  targetState = 3
  }
  withFrameMillis {
  assertTrue(transition.isRunning)
  }
  }
  }
  rule.waitForIdle()
  rule.runOnIdle {
  assertEquals(1, list.size)
  assertEquals(1, list[0])
  targetState = 1
  }

  rule.runOnIdle {
  // Check that save worked
  assertEquals(2, list.size)
  assertEquals(1, list[0])
  assertEquals(2, list[1])
  }
  }

  @OptIn(ExperimentalAnimationApi::class)
  @Test
  fun AnimatedContentWithInterruption() {
  var flag by mutableStateOf(true)
  var rootCoords: LayoutCoordinates? = null
  rule.setContent {
  AnimatedContent(targetState = flag,
  modifier = Modifier.onGloballyPositioned { rootCoords = it },
  transitionSpec = {
  if (targetState) {
  fadeIn(tween(2000)) togetherWith slideOut(
  tween(2000)
  ) { fullSize ->
  IntOffset(0, fullSize.height / 2)
  } + fadeOut(
  tween(2000)
  )
  } else {
  fadeIn(tween(2000)) togetherWith fadeOut(tween(2000))
  }
  }) { state ->
  if (state) {
  Box(modifier = Modifier
  .onGloballyPositioned {
  assertEquals(
  Offset.Zero,
  rootCoords!!.localPositionOf(it, Offset.Zero)
  )
  }
  .fillMaxSize()
  .background(Color.Green)
  )
  } else {
  LaunchedEffect(key1 = Unit) {
  delay(200)
  assertFalse(flag)
  assertTrue(transition.isRunning)
  // Interrupt
  flag = true
  }
  Box(modifier = Modifier
  .onGloballyPositioned {
  assertEquals(
  Offset.Zero,
  rootCoords!!.localPositionOf(it, Offset.Zero)
  )
  }
  .fillMaxSize()
  .background(Color.Red)
  )
  }
  }
  }
  rule.runOnIdle {
  flag = false
  }
  }

  @OptIn(InternalAnimationApi::class)
  private val Transition<*>.playTimeMillis get() = (playTimeNanos / 1_000_000L).toInt()
 }
	/*
	* Copyright 2021 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.compose.animation

	import androidx.compose.animation.core.InternalAnimationApi
	import androidx.compose.animation.core.LinearEasing
	import androidx.compose.animation.core.MutableTransitionState
	import androidx.compose.animation.core.Transition
	import androidx.compose.animation.core.keyframes
	import androidx.compose.animation.core.tween
	import androidx.compose.animation.core.updateTransition
	import androidx.compose.foundation.background
	import androidx.compose.foundation.layout.Box
	import androidx.compose.foundation.layout.fillMaxSize
	import androidx.compose.foundation.layout.requiredSize
	import androidx.compose.foundation.layout.size
	import androidx.compose.runtime.CompositionLocalProvider
	import androidx.compose.runtime.LaunchedEffect
	import androidx.compose.runtime.getValue
	import androidx.compose.runtime.mutableStateOf
	import androidx.compose.runtime.saveable.rememberSaveable
	import androidx.compose.runtime.saveable.rememberSaveableStateHolder
	import androidx.compose.runtime.setValue
	import androidx.compose.runtime.withFrameMillis
	import androidx.compose.ui.Alignment
	import androidx.compose.ui.Modifier
	import androidx.compose.ui.geometry.Offset
	import androidx.compose.ui.graphics.Color
	import androidx.compose.ui.layout.LayoutCoordinates
	import androidx.compose.ui.layout.onGloballyPositioned
	import androidx.compose.ui.layout.positionInRoot
	import androidx.compose.ui.platform.LocalDensity
	import androidx.compose.ui.platform.testTag
	import androidx.compose.ui.test.junit4.createComposeRule
	import androidx.compose.ui.test.onNodeWithTag
	import androidx.compose.ui.unit.Density
	import androidx.compose.ui.unit.IntOffset
	import androidx.compose.ui.unit.IntSize
	import androidx.compose.ui.unit.LayoutDirection
	import androidx.compose.ui.unit.dp
	import androidx.test.ext.junit.runners.AndroidJUnit4
	import androidx.test.filters.LargeTest
	import com.google.common.truth.Truth.assertThat
	import kotlin.math.roundToInt
	import kotlinx.coroutines.delay
	import org.junit.Assert.assertEquals
	import org.junit.Assert.assertFalse
	import org.junit.Assert.assertTrue
	import org.junit.Rule
	import org.junit.Test
	import org.junit.runner.RunWith

	@RunWith(AndroidJUnit4::class)
	@LargeTest
	class AnimatedContentTest {

	@get:Rule
	val rule = createComposeRule()

	@OptIn(InternalAnimationApi::class)
	@Test
	fun AnimatedContentSizeTransformTest() {
	val size1 = 40
	val size2 = 200
	val testModifier by mutableStateOf(TestModifier())
	val transitionState = MutableTransitionState(true)
	var playTimeMillis by mutableStateOf(0)
	rule.mainClock.autoAdvance = false
	rule.setContent {
	CompositionLocalProvider(LocalDensity provides Density(1f)) {
	val transition = updateTransition(transitionState)
	playTimeMillis = (transition.playTimeNanos / 1_000_000L).toInt()
	transition.AnimatedContent(
	testModifier,
	transitionSpec = {
	if (true isTransitioningTo false) {
	fadeIn() togetherWith fadeOut() using
	SizeTransform { initialSize, targetSize ->
	keyframes {
	durationMillis = 320
	IntSize(targetSize.width, initialSize.height) at 160 with
	LinearEasing
	targetSize at 320 with LinearEasing
	}
	}
	} else {
	fadeIn() togetherWith fadeOut() using SizeTransform { _, _ ->
	tween(durationMillis = 80, easing = LinearEasing)
	}
	}
	}
	) {
	if (it) {
	Box(modifier = Modifier.size(size = size1.dp))
	} else {
	Box(modifier = Modifier.size(size = size2.dp))
	}
	}
	}
	}
	rule.runOnIdle {
	assertEquals(40, testModifier.height)
	assertEquals(40, testModifier.width)
	assertTrue(transitionState.targetState)
	transitionState.targetState = false
	}

	// Transition from item1 to item2 in 320ms, animating to full width in the first 160ms
	// then full height in the next 160ms
	while (transitionState.currentState != transitionState.targetState) {
	rule.runOnIdle {
	if (playTimeMillis <= 160) {
	assertEquals(playTimeMillis + 40, testModifier.width)
	assertEquals(40, testModifier.height)
	} else {
	assertEquals(200, testModifier.width)
	assertEquals(playTimeMillis - 120, testModifier.height)
	}
	}
	rule.mainClock.advanceTimeByFrame()
	}

	rule.runOnIdle {
	assertEquals(200, testModifier.width)
	assertEquals(200, testModifier.height)
	transitionState.targetState = true
	}

	// Transition from item2 to item1 in 80ms
	while (transitionState.currentState != transitionState.targetState) {
	rule.runOnIdle {
	if (playTimeMillis <= 80) {
	assertEquals(200 - playTimeMillis * 2, testModifier.width)
	assertEquals(200 - playTimeMillis * 2, testModifier.height)
	}
	}
	rule.mainClock.advanceTimeByFrame()
	}
	}

	@OptIn(InternalAnimationApi::class)
	@Test
	fun AnimatedContentSizeTransformEmptyComposableTest() {
	val size1 = 160
	val testModifier by mutableStateOf(TestModifier())
	val transitionState = MutableTransitionState(true)
	var playTimeMillis by mutableStateOf(0)
	rule.mainClock.autoAdvance = false
	rule.setContent {
	CompositionLocalProvider(LocalDensity provides Density(1f)) {
	val transition = updateTransition(transitionState)
	playTimeMillis = (transition.playTimeNanos / 1_000_000L).toInt()
	transition.AnimatedContent(
	testModifier,
	transitionSpec = {
	EnterTransition.None togetherWith ExitTransition.None using
	SizeTransform { _, _ ->
	tween(durationMillis = 160, easing = LinearEasing)
	}
	}
	) {
	if (it) {
	Box(modifier = Modifier.size(size = size1.dp))
	}
	// Empty composable for it == false
	}
	}
	}
	rule.runOnIdle {
	assertEquals(160, testModifier.height)
	assertEquals(160, testModifier.width)
	assertTrue(transitionState.targetState)
	transitionState.targetState = false
	}

	// Transition from item1 to item2 in 320ms, animating to full width in the first 160ms
	// then full height in the next 160ms
	while (transitionState.currentState != transitionState.targetState) {
	rule.runOnIdle {
	assertEquals(160 - playTimeMillis, testModifier.width)
	assertEquals(160 - playTimeMillis, testModifier.height)
	}
	rule.mainClock.advanceTimeByFrame()
	}

	// Now there's only an empty composable
	rule.runOnIdle {
	assertEquals(0, testModifier.width)
	assertEquals(0, testModifier.height)
	transitionState.targetState = true
	}

	// Transition from item2 to item1 in 80ms
	while (transitionState.currentState != transitionState.targetState) {
	rule.runOnIdle {
	assertEquals(playTimeMillis, testModifier.width)
	assertEquals(playTimeMillis, testModifier.height)
	}
	rule.mainClock.advanceTimeByFrame()
	}
	}

	@OptIn(InternalAnimationApi::class)
	@Test
	fun AnimatedContentContentAlignmentTest() {
	val size1 = IntSize(80, 80)
	val size2 = IntSize(160, 240)
	val testModifier by mutableStateOf(TestModifier())
	var offset1 by mutableStateOf(Offset.Zero)
	var offset2 by mutableStateOf(Offset.Zero)
	var playTimeMillis by mutableStateOf(0)
	val transitionState = MutableTransitionState(true)
	val alignment = listOf(
	Alignment.TopStart, Alignment.BottomStart, Alignment.Center,
	Alignment.BottomEnd, Alignment.TopEnd
	)
	var contentAlignment by mutableStateOf(Alignment.TopStart)
	rule.setContent {
	CompositionLocalProvider(LocalDensity provides Density(1f)) {
	val transition = updateTransition(transitionState)
	playTimeMillis = (transition.playTimeNanos / 1_000_000L).toInt()
	transition.AnimatedContent(
	testModifier,
	contentAlignment = contentAlignment,
	transitionSpec = {
	fadeIn(animationSpec = tween(durationMillis = 80)) togetherWith fadeOut(
	animationSpec = tween(durationMillis = 80)
	) using SizeTransform { _, _ ->
	tween(durationMillis = 80, easing = LinearEasing)
	}
	}
	) {
	if (it) {
	Box(
	modifier = Modifier
	.onGloballyPositioned {
	offset1 = it.positionInRoot()
	}
	.size(size1.width.dp, size1.height.dp)
	)
	} else {
	Box(
	modifier = Modifier
	.onGloballyPositioned {
	offset2 = it.positionInRoot()
	}
	.size(size2.width.dp, size2.height.dp)
	)
	}
	}
	}
	}

	rule.mainClock.autoAdvance = false

	alignment.forEach {
	rule.runOnIdle {
	assertEquals(80, testModifier.height)
	assertEquals(80, testModifier.width)
	assertTrue(transitionState.targetState)
	contentAlignment = it
	}

	rule.mainClock.advanceTimeByFrame()
	rule.waitForIdle()
	rule.runOnIdle { transitionState.targetState = false }

	// Transition from item1 to item2 in 320ms, animating to full width in the first 160ms
	// then full height in the next 160ms
	while (transitionState.currentState != transitionState.targetState) {
	rule.runOnIdle {
	val space = IntSize(testModifier.width, testModifier.height)
	val position1 = it.align(size1, space, LayoutDirection.Ltr)
	val position2 = it.align(size2, space, LayoutDirection.Ltr)
	if (playTimeMillis < 80) {
	// This gets removed when the animation is finished at 80ms
	assertEquals(
	position1,
	IntOffset(offset1.x.roundToInt(), offset1.y.roundToInt())
	)
	}
	if (playTimeMillis > 0) {
	assertEquals(
	position2,
	IntOffset(offset2.x.roundToInt(), offset2.y.roundToInt())
	)
	}
	}
	rule.mainClock.advanceTimeByFrame()
	}

	rule.runOnIdle {
	assertEquals(size2.width, testModifier.width)
	assertEquals(size2.height, testModifier.height)
	// After the animation the size should be the same as parent, offset should be 0
	assertEquals(offset2, Offset.Zero)
	transitionState.targetState = true
	}

	// Transition from item2 to item1 in 80ms
	while (transitionState.currentState != transitionState.targetState) {
	rule.runOnIdle {
	val space = IntSize(testModifier.width, testModifier.height)
	val position1 = it.align(size1, space, LayoutDirection.Ltr)
	val position2 = it.align(size2, space, LayoutDirection.Ltr)
	if (playTimeMillis > 0) {
	assertEquals(
	position1,
	IntOffset(offset1.x.roundToInt(), offset1.y.roundToInt())
	)
	}
	if (playTimeMillis < 80) {
	assertEquals(
	position2,
	IntOffset(offset2.x.roundToInt(), offset2.y.roundToInt())
	)
	}
	}
	rule.mainClock.advanceTimeByFrame()
	}

	rule.runOnIdle {
	assertEquals(size1.width, testModifier.width)
	assertEquals(size1.height, testModifier.height)
	// After the animation the size should be the same as parent, offset should be 0
	assertEquals(offset1, Offset.Zero)
	}
	}
	}

	@OptIn(ExperimentalAnimationApi::class)
	@Test
	fun AnimatedContentSlideInAndOutOfContainerTest() {
	val transitionState = MutableTransitionState(true)
	// LinearEasing is required to ensure the animation doesn't reach final values before the
	// duration.
	val animSpec = tween<IntOffset>(200, easing = LinearEasing)
	lateinit var trueTransition: Transition<EnterExitState>
	lateinit var falseTransition: Transition<EnterExitState>
	rule.mainClock.autoAdvance = false
	rule.setContent {
	CompositionLocalProvider(LocalDensity provides Density(1f, 1f)) {
	@Suppress("UpdateTransitionLabel")
	val rootTransition = updateTransition(transitionState)
	rootTransition.AnimatedContent(
	transitionSpec = {
	if (true isTransitioningTo false) {
	slideIntoContainer(
	AnimatedContentTransitionScope.SlideDirection.Start, animSpec
	) togetherWith
	slideOutOfContainer(
	AnimatedContentTransitionScope.SlideDirection.Start, animSpec
	)
	} else {
	slideIntoContainer(
	AnimatedContentTransitionScope.SlideDirection.End, animSpec
	) togetherWith
	slideOutOfContainer(
	towards = AnimatedContentTransitionScope.SlideDirection.End,
	animSpec
	)
	}
	}
	) { target ->
	if (target) {
	trueTransition = transition
	} else {
	falseTransition = transition
	}
	Box(
	Modifier
	.requiredSize(200.dp)
	.testTag(target.toString())
	)
	}
	}
	}

	// Kick off the first animation.
	transitionState.targetState = false
	// The initial composition creates the transition…
	rule.mainClock.advanceTimeByFrame()
	rule.onNodeWithTag("true").assertExists()
	rule.onNodeWithTag("false").assertExists()
	// …but the animation won't actually start until one frame later.
	rule.mainClock.advanceTimeByFrame()
	assertThat(trueTransition.animations).isNotEmpty()
	assertThat(falseTransition.animations).isNotEmpty()

	// Loop to ensure the content is offset correctly at each frame.
	var trueAnim = trueTransition.animations[0]
	var falseAnim = falseTransition.animations[0]
	assertThat(transitionState.currentState).isTrue()
	while (transitionState.currentState) {
	// True is leaving: it should start at 0 and slide out to -200.
	assertThat(trueAnim.value).isEqualTo(IntOffset(-trueTransition.playTimeMillis, 0))
	// False is entering: it should start at 200 and slide in to 0.
	assertThat(falseAnim.value)
	.isEqualTo(IntOffset(200 - falseTransition.playTimeMillis, 0))
	rule.mainClock.advanceTimeByFrame()
	}
	// The animation should remove the newly-hidden node from the composition.
	rule.onNodeWithTag("true").assertDoesNotExist()

	// Kick off the second transition.
	transitionState.targetState = true
	rule.mainClock.advanceTimeByFrame()
	rule.onNodeWithTag("true").assertExists()
	rule.onNodeWithTag("false").assertExists()
	rule.mainClock.advanceTimeByFrame()
	assertThat(trueTransition.animations).isNotEmpty()

	trueAnim = trueTransition.animations[0]
	falseAnim = falseTransition.animations[0]
	assertThat(transitionState.currentState).isFalse()
	while (!transitionState.currentState) {
	// True is entering, it should start at -200 and slide in to 0.
	assertThat(trueAnim.value).isEqualTo(IntOffset(trueTransition.playTimeMillis - 200, 0))
	// False is leaving, it should start at 0 and slide out to 200.
	assertThat(falseAnim.value).isEqualTo(IntOffset(falseTransition.playTimeMillis, 0))
	rule.mainClock.advanceTimeByFrame()
	}
	rule.onNodeWithTag("false").assertDoesNotExist()
	}

	@Test
	fun AnimatedContentWithKeysTest() {
	var targetState by mutableStateOf(1)
	val list = mutableListOf<Int>()
	rule.setContent {
	val transition = updateTransition(targetState)
	val holder = rememberSaveableStateHolder()
	transition.AnimatedContent(contentKey = { it > 2 }) {
	if (it <= 2) {
	holder.SaveableStateProvider(11) {
	var count by rememberSaveable { mutableStateOf(0) }
	LaunchedEffect(Unit) {
	list.add(++count)
	}
	}
	}
	Box(Modifier.requiredSize(200.dp))
	}
	LaunchedEffect(Unit) {
	assertFalse(transition.isRunning)
	targetState = 2
	withFrameMillis {
	assertFalse(transition.isRunning)
	assertEquals(1, transition.currentState)
	assertEquals(1, transition.targetState)

	// This state change should now cause an animation
	targetState = 3
	}
	withFrameMillis {
	assertTrue(transition.isRunning)
	}
	}
	}
	rule.waitForIdle()
	rule.runOnIdle {
	assertEquals(1, list.size)
	assertEquals(1, list[0])
	targetState = 1
	}

	rule.runOnIdle {
	// Check that save worked
	assertEquals(2, list.size)
	assertEquals(1, list[0])
	assertEquals(2, list[1])
	}
	}

	@OptIn(ExperimentalAnimationApi::class)
	@Test
	fun AnimatedContentWithInterruption() {
	var flag by mutableStateOf(true)
	var rootCoords: LayoutCoordinates? = null
	rule.setContent {
	AnimatedContent(targetState = flag,
	modifier = Modifier.onGloballyPositioned { rootCoords = it },
	transitionSpec = {
	if (targetState) {
	fadeIn(tween(2000)) togetherWith slideOut(
	tween(2000)
	) { fullSize ->
	IntOffset(0, fullSize.height / 2)
	} + fadeOut(
	tween(2000)
	)
	} else {
	fadeIn(tween(2000)) togetherWith fadeOut(tween(2000))
	}
	}) { state ->
	if (state) {
	Box(modifier = Modifier
	.onGloballyPositioned {
	assertEquals(
	Offset.Zero,
	rootCoords!!.localPositionOf(it, Offset.Zero)
	)
	}
	.fillMaxSize()
	.background(Color.Green)
	)
	} else {
	LaunchedEffect(key1 = Unit) {
	delay(200)
	assertFalse(flag)
	assertTrue(transition.isRunning)
	// Interrupt
	flag = true
	}
	Box(modifier = Modifier
	.onGloballyPositioned {
	assertEquals(
	Offset.Zero,
	rootCoords!!.localPositionOf(it, Offset.Zero)
	)
	}
	.fillMaxSize()
	.background(Color.Red)
	)
	}
	}
	}
	rule.runOnIdle {
	flag = false
	}
	}

	@OptIn(InternalAnimationApi::class)
	private val Transition<*>.playTimeMillis get() = (playTimeNanos / 1_000_000L).toInt()
	}