import Foundation import Testing @testable import ParcelAnimation @Suite struct SpringTests { let critical = SpringParameters(duration: 0.2, bounce: 0) let bouncy = SpringParameters(duration: 0.25, bounce: 0.3) @Test func physicalParametersArePreserved() { let spring = SpringParameters(mass: 2, stiffness: 100, damping: 8) #expect(spring.mass == 2) #expect(spring.stiffness == 100) #expect(spring.damping == 8) } @Test func responseMapsToNaturalFrequency() { let spring = SpringParameters(response: 0.5, dampingFraction: 0.7) #expect(near(spring.stiffness, pow(4 * Double.pi, 2))) #expect(near(spring.dampingFraction, 0.7)) } @Test func durationBounceMatchesPhysicalForm() { let spring = SpringParameters(duration: 0.5, bounce: 0.3) #expect(near(spring.stiffness, 157.91367041742973)) #expect(near(spring.damping, 17.59291886010284)) #expect(spring.mass == 1) } @Test func zeroBounceIsCriticallyDamped() { #expect(near(critical.dampingFraction, 1)) } @Test func zeroStepPreservesValueAndVelocity() { let state = SpringState(value: 42, velocity: -100) #expect(state.advanced(to: 8, by: 0, using: bouncy) == state) } @Test func equilibriumRemainsStill() { #expect(SpringState(value: 8).advanced(to: 8, by: 0.1, using: critical) == SpringState(value: 8)) } @Test func criticalSpringConverges() { let result = SpringState(value: 0).advanced(to: 100, by: 2, using: critical) #expect(near(result.value, 100)) #expect(near(result.velocity, 0)) } @Test func underdampedSpringConverges() { let result = SpringState(value: -50, velocity: 200).advanced(to: 100, by: 2, using: bouncy) #expect(near(result.value, 100)) #expect(near(result.velocity, 0)) } @Test func overdampedSpringConverges() { let spring = SpringParameters(response: 0.2, dampingFraction: 2) let result = SpringState(value: 0).advanced(to: 100, by: 10, using: spring) #expect(near(result.value, 100)) #expect(near(result.velocity, 0)) } @Test func bouncySpringCrossesTarget() { let values = (0...100).map { SpringState(value: 0).advanced(to: 1, by: Double($0) / 200, using: bouncy).value } #expect(values.contains { $0 > 1 }) #expect((values.max() ?? 0) < 1.06) } @Test func criticalSpringIsMonotonicWithoutInitialVelocity() { let values = (0...100).map { SpringState(value: 0).advanced(to: 1, by: Double($0) / 200, using: critical).value } #expect(zip(values, values.dropFirst()).allSatisfy { $0 <= $1 }) #expect(values.allSatisfy { (0...1).contains($0) }) } @Test func negativeDirectionIsSymmetric() { let positive = SpringState(value: 0).advanced(to: 10, by: 0.1, using: bouncy) let negative = SpringState(value: 0).advanced(to: -10, by: 0.1, using: bouncy) #expect(near(positive.value, -negative.value)) #expect(near(positive.velocity, -negative.velocity)) } @Test func partitionedStepsMatchSingleStep() { var partitioned = SpringState(value: 3, velocity: -20) for _ in 0..<100 { partitioned.advance(to: 90, by: 0.003, using: bouncy) } let single = SpringState(value: 3, velocity: -20).advanced(to: 90, by: 0.3, using: bouncy) #expect(near(partitioned.value, single.value)) #expect(near(partitioned.velocity, single.velocity)) } @Test func unevenStepsAreStable() { var state = SpringState(value: 0, velocity: 100) for step in [0.001, 0.05, 0.4, 0.009, 3.0] { state.advance(to: 10, by: step, using: bouncy) } #expect(near(state.value, 10)) #expect(state.velocity.isFinite) } @Test func largeStepDoesNotExplode() { let state = SpringState(value: 0, velocity: 100).advanced(to: 10, by: 1000, using: bouncy) #expect(state == SpringState(value: 10)) } @Test func heavyDampingAvoidsOverflow() { let spring = SpringParameters(response: 0.2, dampingFraction: 1_000_000) let state = SpringState(value: 0).advanced(to: 10, by: 1_000_000, using: spring) #expect(state.value.isFinite && state.velocity.isFinite) #expect(state.value > 9.99) } @Test func nearCriticalDampingIsStable() { let spring = SpringParameters(response: 0.2, dampingFraction: 1 + 1e-12) let state = SpringState(value: 0).advanced(to: 1, by: 0.1, using: spring) let reference = SpringState(value: 0).advanced(to: 1, by: 0.1, using: critical) #expect(near(state.value, reference.value)) #expect(near(state.velocity, reference.velocity)) } @Test func massScalingPreservesTrajectory() { let spring = SpringParameters(mass: 2, stiffness: bouncy.stiffness * 2, damping: bouncy.damping * 2) let state = SpringState(value: 0, velocity: 10) #expect(state.advanced(to: 20, by: 0.1, using: spring) == state.advanced(to: 20, by: 0.1, using: bouncy)) } @Test func retargetingKeepsPresentationAndMomentum() { let state = SpringState(value: 0).advanced(to: 100, by: 0.04, using: bouncy) let retargeted = state.advanced(to: -20, by: 0, using: bouncy) #expect(retargeted == state) #expect(retargeted.velocity > 0) } @Test func retargetingEventuallyChangesDirection() { let state = SpringState(value: 0).advanced(to: 100, by: 0.04, using: bouncy) let retargeted = state.advanced(to: -20, by: 1, using: bouncy) #expect(near(retargeted.value, -20, tolerance: 1e-4)) } @Test func velocityMatchesPositionDerivative() { let initial = SpringState(value: 0, velocity: 30) let state = initial.advanced(to: 10, by: 0.1, using: bouncy) let before = initial.advanced(to: 10, by: 0.1 - 1e-6, using: bouncy) let after = initial.advanced(to: 10, by: 0.1 + 1e-6, using: bouncy) #expect(near(state.velocity, (after.value - before.value) / 2e-6, tolerance: 1e-6)) } @Test func undampedSpringIsPeriodic() { let spring = SpringParameters(response: 0.2, dampingFraction: 0) let state = SpringState(value: 0, velocity: 5) let result = state.advanced(to: 10, by: 0.2, using: spring) #expect(near(result.value, state.value)) #expect(near(result.velocity, state.velocity)) } @Test func movingAtTargetCarriesVelocity() { let result = SpringState(value: 10, velocity: 100).advanced(to: 10, by: 0.01, using: bouncy) #expect(result.value > 10) #expect(result.velocity > 0) } @Test(arguments: [0.5, 1.0, 2.0]) func largestFiniteStepConvergesWithoutOverflow(_ dampingFraction: Double) { let spring = SpringParameters(response: 0.2, dampingFraction: dampingFraction) let result = SpringState(value: 1, velocity: 3).advanced(to: 10, by: .greatestFiniteMagnitude, using: spring) #expect(result == SpringState(value: 10)) } @Test func largestFiniteUndampedStepKeepsFiniteEnergy() { let spring = SpringParameters(response: 0.2, dampingFraction: 0) let initial = SpringState(value: 1, velocity: 3) let result = initial.advanced(to: 0, by: .greatestFiniteMagnitude, using: spring) #expect(result.value.isFinite && result.velocity.isFinite) let initialEnergy = pow(initial.velocity, 2) + spring.stiffness * pow(initial.value, 2) let finalEnergy = pow(result.velocity, 2) + spring.stiffness * pow(result.value, 2) #expect(near(initialEnergy, finalEnergy, tolerance: 1e-8)) } @Test func dampingDissipatesEnergy() { let initial = SpringState(value: 0, velocity: 100) let after = initial.advanced(to: 10, by: 0.1, using: bouncy) let initialEnergy = bouncy.mass * pow(initial.velocity, 2) + bouncy.stiffness * pow(initial.value - 10, 2) let finalEnergy = bouncy.mass * pow(after.velocity, 2) + bouncy.stiffness * pow(after.value - 10, 2) #expect(finalEnergy < initialEnergy) } }