Merge current main into PR #1042

This commit is contained in:
Kurt Himebauch committed 2026-10-22 12:13:49 -04:00
commit 65a5f69873
127 files changed
+5605 -216

No files matched your search

@@ -13,6 +13,11 @@ import org.robolectric.RobolectricTestRunner
import org.robolectric.Shadows.shadowOf
import org.robolectric.annotation.Config
import org.robolectric.annotation.LooperMode
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.util.concurrent.CountDownLatch
import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.TimeUnit
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [28], manifest = Config.NONE)
@@ -232,4 +237,95 @@ class GlassesCallbacksTest {
field("sink").set(null, null)
}
}
@Test fun pro2CallbacksUseSharedPoseAndRejectThePreviousConnection() {
fun v2(gen: Long) = Glasses::class.java.getDeclaredMethod("v2Listener", Long::class.javaPrimitiveType)
.apply { isAccessible = true }.invoke(Glasses, gen) as VitureV2Link.Listener
var delivered: FloatArray? = null
var timestamp = 0L
field("sink").set(null, Glasses.PoseSink { x, y, z, w, time ->
delivered = floatArrayOf(x, y, z, w)
timestamp = time
})
try {
val q = floatArrayOf(0f, 0f, 0.6f, 0.8f)
v2(0).onPose(ByteArray(24), q, 100)
assertEquals(null, delivered)
v2(1).onPose(ByteArray(24), q, 101)
org.junit.Assert.assertArrayEquals(q, delivered, 0f)
assertEquals(101L, timestamp)
assertEquals(1L, field("imuPackets").getLong(null))
v2(1).onValue(VitureProtocol.MSG_GET_DISPLAY, 0x32)
shadowOf(Looper.getMainLooper()).idle()
assertFalse(Glasses.state.value.sbs)
v2(1).onValue(VitureProtocol.MSG_GET_BRIGHTNESS, 8)
v2(1).onReady()
v2(1).onTracking(true)
v2(1).onLost()
generation(2)
shadowOf(Looper.getMainLooper()).idle()
assertEquals(2, Glasses.state.value.brightness)
assertTrue(Glasses.state.value.connected)
assertFalse(Glasses.state.value.supportsScreen3dof)
assertFalse(Glasses.state.value.tracking)
} finally { field("sink").set(null, null) }
}
@Test fun pro2DemandEndingBeforeTheFirstRestartPoseStillStopsTheStream() {
val writes = LinkedBlockingQueue<ByteArray>()
val incoming = LinkedBlockingQueue<VitureV2Link.Received>()
val firstPose = CountDownLatch(1)
val firstRead = CountDownLatch(1)
val delegate = Glasses::class.java.getDeclaredMethod("v2Listener", Long::class.javaPrimitiveType)
.apply { isAccessible = true }.invoke(Glasses, 1L) as VitureV2Link.Listener
val listener = object : VitureV2Link.Listener by delegate {
override fun onPose(raw: ByteArray, q: FloatArray, timeNs: Long) {
delegate.onPose(raw, q, timeNs)
firstPose.countDown()
}
}
val transport = object : VitureV2Link.Transport {
override fun write(packet: ByteArray): Boolean { writes += packet; return true }
override fun read(timeoutMs: Long): VitureV2Link.Received? {
firstRead.countDown()
return incoming.poll(timeoutMs, TimeUnit.MILLISECONDS)
}
override fun close() {}
}
fun expectStream(stream: Int) = org.junit.Assert.assertArrayEquals(
VitureV2Protocol.imuControl(stream), writes.poll(2, TimeUnit.SECONDS))
fun updateImu() = Glasses::class.java.getDeclaredMethod("updateImu")
.apply { isAccessible = true }.invoke(Glasses)
val link = VitureV2Link(transport, listener)
field("link").set(null, link)
field("sink").set(null, null)
try {
expectStream(VitureV2Protocol.STREAM_POSE)
assertTrue("Bootstrap write did not complete", firstRead.await(2, TimeUnit.SECONDS))
val payload = ByteBuffer.allocate(24).order(ByteOrder.LITTLE_ENDIAN)
.putInt(0).putInt(1).putFloat(1f).putFloat(0f).putFloat(0f).putFloat(0f).array()
incoming += VitureV2Link.Received(VitureV2Protocol.packet(VitureV2Protocol.EVENT_POSE, payload), System.nanoTime())
assertTrue(firstPose.await(2, TimeUnit.SECONDS))
shadowOf(Looper.getMainLooper()).idle()
expectStream(VitureV2Protocol.STREAM_OFF)
assertTrue(Glasses.state.value.supportsScreen3dof)
assertFalse(Glasses.state.value.tracking)
field("sink").set(null, Glasses.PoseSink { _, _, _, _, _ -> })
updateImu()
assertFalse(Glasses.state.value.tracking)
field("sink").set(null, null)
updateImu()
expectStream(VitureV2Protocol.STREAM_POSE)
expectStream(VitureV2Protocol.STREAM_OFF)
assertFalse(link.trackingActive)
assertFalse(Glasses.state.value.tracking)
} finally {
generation(2)
link.close()
field("link").set(null, null)
field("sink").set(null, null)
shadowOf(Looper.getMainLooper()).idle()
}
}
}
@@ -155,6 +155,58 @@ class GlassesUsbTest {
assertEquals(listOf(gt), manager.requests)
}
@Test fun pro2RequestsPermissionWithoutTheSdkAndDoesNotClaimCompanionProducts() {
val pro2 = device(0x1301, name = "VITURE Luma Ultra")
manager.devices[pro2.deviceName] = pro2
refresh(ask = true)
assertEquals("VITURE Pro 2", state.value.model)
assertTrue(state.value.controllable)
assertTrue(state.value.experimental)
assertFalse(state.value.hardwareControls)
assertFalse(state.value.supportsDisplayModeControl)
assertFalse(state.value.supportsScreen3dof)
assertFalse(state.value.supportsSpatial)
assertEquals(listOf(pro2), manager.requests)
assertEquals(null, Glasses.deviceModel(device(0x1301, 0x1234, "VITURE Pro 2")))
assertEquals(null, Glasses.deviceModel(device(0x1102, name = "VITURE Pro 2")))
assertEquals(null, Glasses.deviceModel(device(0x1302, name = "VITURE Pro 2")))
val ultra = Glasses.deviceModel(device(0x1104)) as VitureProtocol.Model
assertEquals(VitureProtocol.Family.ULTRA, ultra.family)
assertTrue(ultra.needsSdk)
}
@Test fun pro2PoseAvailabilityDoesNotEnableDisplayOrHardwareWrites() {
val pro2 = device(0x1301)
manager.devices[pro2.deviceName] = pro2
manager.granted.add(pro2.deviceName)
val sent = mutableListOf<Int>()
field("linkDevice").set(null, pro2)
field("link").set(null, object : GlassesLink {
override val hasImu = true
override fun send(msgId: Int, payload: ByteArray): Boolean { sent += msgId; return true }
override fun close() {}
})
try {
refresh()
assertTrue(state.value.canControl)
assertTrue(state.value.supportsScreen3dof)
assertFalse(state.value.can3d)
assertFalse(state.value.supportsDisplayModeControl)
assertFalse(state.value.hardwareControls)
assertEquals(0, state.value.brightnessMax)
assertEquals(0, state.value.volumeMax)
Glasses.sendMode(0x32)
Glasses.setBrightness(5)
Glasses.setVolume(5)
shadowOf(Looper.getMainLooper()).idle()
assertTrue(sent.isEmpty())
} finally {
field("link").set(null, null)
field("linkDevice").set(null, null)
(field("handler").get(null) as Handler).removeCallbacksAndMessages(null)
}
}
@Test fun gtVendorRequestsPermissionAndRetainsMaxProductName() {
val gt = device(0xaf50, 0x3941, "RayNeo GT MAX")
manager.devices[gt.deviceName] = gt
@@ -130,6 +130,31 @@ class VitureProtocolTest {
assertArrayEquals(floatArrayOf(0f, 0f, sin(half).toFloat(), cos(half).toFloat()), q, 1e-5f)
}
@Test fun directPro2KeepsSdkOnlyFamiliesAndUnknownProductsIsolated() {
val direct = VitureProtocol.model(0x1301, "VITURE Luma Ultra")!!
assertEquals("VITURE Pro 2", direct.name)
assertEquals(VitureProtocol.Family.PRO2, direct.family)
assertFalse(direct.needsSdk)
assertFalse(direct.hardwareControls)
assertFalse(direct.supportsDisplayModeControl)
assertFalse(direct.hasSunblock)
assertEquals(0, direct.brightnessMax)
assertEquals(0, direct.volumeMax)
for (pid in listOf(0x1101, 0x1104, 0x1201, 0x1211)) {
val model = VitureProtocol.model(pid, null)!!
assertTrue(model.needsSdk)
assertTrue(model.hardwareControls)
assertTrue(model.supportsDisplayModeControl)
}
assertNull(VitureProtocol.model(0x1102, "VITURE Pro 2"))
assertNull(VitureProtocol.model(0x1302, "VITURE Pro 2"))
val sdk = VitureProtocol.sdkModel("Pro 2")!!
assertTrue(sdk.needsSdk)
assertTrue(sdk.hardwareControls)
assertTrue(sdk.supportsDisplayModeControl)
}
@Test fun imuFallsBackToEuler() {
val payload = ByteBuffer.allocate(12).putFloat(0f).putFloat(0f).putFloat(30f).array()
val q = VitureProtocol.imuQuaternion(payload)!!
@@ -0,0 +1,404 @@
package com.droiddeck.launcher.glasses
import com.droiddeck.launcher.gpu.HeadPose
import org.junit.After
import org.junit.Assert.assertArrayEquals
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import java.io.IOException
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.util.concurrent.CopyOnWriteArrayList
import java.util.concurrent.CountDownLatch
import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.atomic.AtomicReference
import kotlin.math.sqrt
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [28], manifest = Config.NONE)
class VitureV2LinkTest {
private val transport = FakeTransport()
private val listener = RecordingListener()
private var link: VitureV2Link? = null
@After fun close() { link?.close() }
@Test fun writeAndAckDoNotBecomeReadyWithoutAValidPose() {
val link = start()
transport.feed(ack())
transport.feed(pose(1).also { it[8] = (it[8].toInt() xor 1).toByte() })
transport.feed(pose(2, floatArrayOf(0f, 0f, 0f, 0f)))
transport.feed(VitureV2Protocol.packet(VitureV2Protocol.EVENT_RAW, ByteArray(56)))
transport.flush()
assertFalse(link.ready)
assertFalse(link.hasImu)
assertFalse(link.trackingActive)
assertEquals(0, listener.readyCount.get())
assertTrue(listener.poses.isEmpty())
assertEquals(2L, link.badFrames)
val receiptTime = System.nanoTime()
val valid = pose(3)
transport.feed(valid, receiptTime)
transport.flush()
assertTrue(link.ready)
assertTrue(link.hasImu)
assertTrue(link.trackingActive)
assertEquals(1, listener.readyCount.get())
assertEquals(listOf(true), listener.tracking)
assertEquals(1, listener.poses.size)
assertEquals(receiptTime, listener.poses.single().timeNs)
assertArrayEquals(valid, listener.poses.single().raw)
}
@Test fun duplicatesAndBackwardTicksAreDroppedWhileUnsignedWrapAdvances() {
start()
for (tick in listOf(0xFFFFFFFEL, 0xFFFFFFFEL, 0xFFFFFFFDL, 0L, 0L, 0xFFFFFFFFL, 1L)) {
transport.feed(pose(tick))
}
transport.flush()
assertEquals(3, listener.poses.size)
assertEquals(1, listener.readyCount.get())
assertEquals(listOf(true), listener.tracking)
assertEquals(0L, link!!.badFrames)
}
@Test fun poseCollectedDuringBootstrapWriteDoesNotEstablishReadiness() {
transport.collectDuringNextWrite(pose(1))
val link = start()
assertFalse(link.ready)
assertFalse(link.trackingActive)
assertTrue(listener.poses.isEmpty())
transport.feed(pose(2))
transport.flush()
assertTrue(link.ready)
assertTrue(link.trackingActive)
assertEquals(1, listener.readyCount.get())
assertEquals(1, listener.poses.size)
}
@Test fun poseCollectedDuringResumeWriteDoesNotRestartTracking() {
val link = startReady(100)
assertTrue(link.send(VitureProtocol.MSG_IMU, byteArrayOf(0)))
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_OFF))
transport.flush()
transport.collectDuringNextWrite(pose(101))
assertTrue(link.send(VitureProtocol.MSG_IMU, byteArrayOf(1)))
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_POSE))
transport.flush()
assertFalse(link.trackingActive)
assertEquals(1, listener.poses.size)
transport.feed(pose(102))
transport.flush()
assertTrue(link.trackingActive)
assertEquals(2, listener.poses.size)
assertEquals(listOf(true, false, true), listener.tracking)
}
@Test fun stoppingAndRestartingRequiresANewPoseAndRejectsQueuedOldSamples() {
val link = startReady(100)
assertTrue(link.send(VitureProtocol.MSG_IMU, byteArrayOf(0)))
assertFalse(link.trackingActive)
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_OFF))
transport.feed(pose(101))
transport.feed(ack())
transport.flush()
assertEquals(1, listener.poses.size)
assertTrue(link.ready)
assertFalse(link.trackingActive)
val beforeRestart = System.nanoTime()
assertTrue(link.send(VitureProtocol.MSG_IMU, byteArrayOf(1)))
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_POSE))
transport.feed(pose(102), beforeRestart)
transport.feed(ack())
transport.flush()
assertFalse(link.trackingActive)
assertEquals(1, listener.poses.size)
transport.feed(pose(0))
transport.flush()
assertTrue(link.trackingActive)
assertEquals(2, listener.poses.size)
assertEquals(1, listener.readyCount.get())
assertEquals(listOf(true, false, true), listener.tracking)
}
@Test fun onReadyCanStopBootstrapBeforeTheFirstPoseIsForwarded() {
val link = start()
listener.whenReady = { assertTrue(link.send(VitureProtocol.MSG_IMU, byteArrayOf(0))) }
transport.feed(pose(1))
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_OFF))
transport.flush()
assertEquals(1, listener.readyCount.get())
assertTrue(link.ready)
assertFalse(link.trackingActive)
assertTrue(listener.poses.isEmpty())
assertEquals(listOf(true, false), listener.tracking)
}
@Test fun rapidStopStartCannotAcceptThePreviousStreamsPendingRead() {
val link = startReady()
val held = transport.hold(pose(2))
try {
assertTrue(link.send(VitureProtocol.MSG_IMU, byteArrayOf(0)))
assertTrue(link.send(VitureProtocol.MSG_IMU, byteArrayOf(1)))
} finally {
held.release.countDown()
}
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_OFF))
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_POSE))
transport.flush()
assertFalse(link.trackingActive)
assertEquals(1, listener.poses.size)
assertEquals(listOf(true, false), listener.tracking)
transport.feed(pose(3))
transport.flush()
assertTrue(link.trackingActive)
assertEquals(2, listener.poses.size)
}
@Test fun onReadyCanCloseWithoutForwardingAPoseOrReportingLoss() {
val link = start()
listener.whenReady = link::close
transport.feed(pose(1))
transport.awaitClosed()
assertFalse(link.ready)
assertFalse(link.trackingActive)
assertTrue(listener.poses.isEmpty())
assertEquals(0, listener.lostCount.get())
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_OFF))
}
@Test fun unsupportedSettersNeverProduceWritesAndQueriesKeepGenericIds() {
val link = startReady()
for ((id, payload) in listOf(
VitureProtocol.MSG_BRIGHTNESS to byteArrayOf(3),
VitureProtocol.MSG_VOLUME to byteArrayOf(3),
VitureProtocol.MSG_DISPLAY to byteArrayOf(0x32),
VitureProtocol.MSG_FILM to byteArrayOf(1),
VitureProtocol.MSG_IMU_RATE to byteArrayOf(3),
VitureProtocol.MSG_IMU to byteArrayOf(2),
VitureProtocol.MSG_IMU to byteArrayOf(),
VitureProtocol.MSG_GET_VOLUME to byteArrayOf(1),
)) assertFalse("msgId=$id", link.send(id, payload))
assertTrue(link.send(VitureProtocol.MSG_GET_IMU, byteArrayOf()))
transport.flush()
assertTrue(transport.writes.isEmpty())
val queries = listOf(
Triple(VitureProtocol.MSG_GET_BRIGHTNESS, VitureV2Protocol.MSG_GET_BRIGHTNESS, 3),
Triple(VitureProtocol.MSG_GET_VOLUME, VitureV2Protocol.MSG_GET_VOLUME, 5),
Triple(VitureProtocol.MSG_GET_DISPLAY, VitureV2Protocol.MSG_GET_DISPLAY, 0x31),
)
for ((genericId, wireId, value) in queries) {
assertTrue(link.send(genericId, byteArrayOf()))
transport.expectWrite(VitureV2Protocol.packet(wireId))
transport.feed(VitureV2Protocol.packet(wireId + VitureV2Protocol.RESPONSE_OFFSET,
byteArrayOf(0, value.toByte())))
}
transport.feed(VitureV2Protocol.packet(VitureV2Protocol.MSG_GET_VOLUME + VitureV2Protocol.RESPONSE_OFFSET,
byteArrayOf(1, 7)))
transport.feed(VitureV2Protocol.packet(VitureV2Protocol.MSG_GET_VOLUME + VitureV2Protocol.RESPONSE_OFFSET,
byteArrayOf(0, 7, 8)))
transport.flush()
assertEquals(queries.map { it.first to it.third }, listener.values)
}
@Test fun failureToWriteBootstrapClosesTransportAndReportsLoss() {
transport.failNextWrite.set(true)
val link = VitureV2Link(transport, listener).also { this.link = it }
transport.awaitClosed()
assertFalse(link.ready)
assertFalse(link.hasImu)
assertFalse(link.trackingActive)
assertEquals(0, listener.readyCount.get())
assertEquals(1, listener.lostCount.get())
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_POSE))
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_OFF))
}
@Test fun rejectedStreamAckClosesWithoutMarkingTrackingActive() {
val link = start()
transport.feed(ack(status = 7))
transport.awaitClosed()
assertFalse(link.ready)
assertFalse(link.trackingActive)
assertEquals(1, listener.lostCount.get())
assertEquals(0, listener.readyCount.get())
assertTrue(listener.tracking.isEmpty())
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_OFF))
}
@Test fun readFailureClearsTrackingAndClosesTransport() {
val link = startReady()
transport.disconnect()
transport.awaitClosed()
assertFalse(link.ready)
assertFalse(link.trackingActive)
assertEquals(listOf(true, false), listener.tracking)
assertEquals(1, listener.lostCount.get())
assertFalse(link.send(VitureProtocol.MSG_IMU, byteArrayOf(1)))
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_OFF))
}
@Test fun explicitCloseSendsOffOnceAndDoesNotReportLoss() {
val link = startReady()
link.close()
transport.awaitClosed()
assertFalse(link.ready)
assertFalse(link.trackingActive)
assertEquals(listOf(true, false), listener.tracking)
assertEquals(0, listener.lostCount.get())
assertEquals(1, transport.closeCount.get())
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_OFF))
link.close()
assertFalse(link.send(VitureProtocol.MSG_GET_BRIGHTNESS, byteArrayOf()))
assertEquals(1, transport.closeCount.get())
assertTrue(transport.writes.isEmpty())
}
@Test fun sharedPoseProducesTheSourceRightUpBackRelativeRotation() {
startReady()
val baseline = listener.poses.single().q
val reference = HeadPose.recenter(HeadPose.fromGlasses(baseline[0], baseline[1], baseline[2], baseline[3]),
centerView = true)
val half = sqrt(0.5f)
val rotations = listOf(
floatArrayOf(half, half, 0f, 0f),
floatArrayOf(half, 0f, half, 0f),
floatArrayOf(half, 0f, 0f, half),
floatArrayOf(0.5f, -0.5f, 0.5f, -0.5f),
)
rotations.forEachIndexed { index, q -> transport.feed(pose(index + 2L, q)) }
transport.flush()
for ((source, event) in rotations.zip(listener.poses.drop(1))) {
val q = event.q
val relative = HeadPose.relative(reference, HeadPose.fromGlasses(q[0], q[1], q[2], q[3]))
assertArrayEquals(HeadPose.fromQuaternion(source[1], source[2], source[3], source[0]), relative, 1e-5f)
}
assertEquals(rotations.size + 1, listener.poses.size)
}
private fun start(): VitureV2Link = VitureV2Link(transport, listener).also {
link = it
transport.expectWrite(VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_POSE))
transport.flush()
}
private fun startReady(tick: Long = 1): VitureV2Link = start().also {
transport.feed(pose(tick))
transport.flush()
assertTrue(it.ready)
}
private fun ack(status: Int = 0) = VitureV2Protocol.packet(
VitureV2Protocol.MSG_IMU_CONTROL + VitureV2Protocol.RESPONSE_OFFSET, byteArrayOf(status.toByte()))
private fun pose(tick: Long, wxyz: FloatArray = floatArrayOf(1f, 0f, 0f, 0f)): ByteArray {
val payload = ByteBuffer.allocate(24).order(ByteOrder.LITTLE_ENDIAN)
.putInt(0x126).putInt(tick.toInt())
wxyz.forEach(payload::putFloat)
return VitureV2Protocol.packet(VitureV2Protocol.EVENT_POSE, payload.array())
}
private data class PoseEvent(val raw: ByteArray, val q: FloatArray, val timeNs: Long)
private class RecordingListener : VitureV2Link.Listener {
val readyCount = AtomicInteger()
val lostCount = AtomicInteger()
val tracking = CopyOnWriteArrayList<Boolean>()
val values = CopyOnWriteArrayList<Pair<Int, Int>>()
val poses = CopyOnWriteArrayList<PoseEvent>()
@Volatile var whenReady: (() -> Unit)? = null
override fun onReady() { readyCount.incrementAndGet(); whenReady?.invoke() }
override fun onValue(msgId: Int, value: Int) { values += msgId to value }
override fun onPose(raw: ByteArray, q: FloatArray, timeNs: Long) { poses += PoseEvent(raw.copyOf(), q.copyOf(), timeNs) }
override fun onTracking(active: Boolean) { tracking += active }
override fun onLost() { lostCount.incrementAndGet() }
}
private sealed interface ReadStep {
data class Packet(val received: VitureV2Link.Received) : ReadStep
data class Barrier(val reached: CountDownLatch) : ReadStep
data class HeldPacket(
val received: VitureV2Link.Received,
val entered: CountDownLatch = CountDownLatch(1),
val release: CountDownLatch = CountDownLatch(1),
) : ReadStep
data object Disconnected : ReadStep
}
private class FakeTransport : VitureV2Link.Transport {
val writes = LinkedBlockingQueue<ByteArray>(64)
val closeCount = AtomicInteger()
val failNextWrite = AtomicBoolean()
private val collectedDuringWrite = AtomicReference<ByteArray?>()
private val incoming = LinkedBlockingQueue<ReadStep>(128)
private val closed = CountDownLatch(1)
override fun write(packet: ByteArray): Boolean {
check(writes.offer(packet.copyOf()))
val success = !failNextWrite.getAndSet(false)
if (success) collectedDuringWrite.getAndSet(null)?.let { feed(it, System.nanoTime()) }
return success
}
override fun read(timeoutMs: Long): VitureV2Link.Received? = when (
val step = incoming.poll(timeoutMs, TimeUnit.MILLISECONDS)
) {
is ReadStep.Packet -> step.received
is ReadStep.Barrier -> { step.reached.countDown(); null }
is ReadStep.HeldPacket -> {
step.entered.countDown()
check(step.release.await(2, TimeUnit.SECONDS))
step.received
}
ReadStep.Disconnected -> throw IOException("Device disconnected")
null -> null
}
override fun close() { closeCount.incrementAndGet(); closed.countDown() }
fun feed(packet: ByteArray, timeNs: Long = System.nanoTime()) {
check(incoming.offer(ReadStep.Packet(VitureV2Link.Received(packet.copyOf(), timeNs))))
}
fun collectDuringNextWrite(packet: ByteArray) {
check(collectedDuringWrite.compareAndSet(null, packet.copyOf()))
}
fun disconnect() { check(incoming.offer(ReadStep.Disconnected)) }
fun hold(packet: ByteArray): ReadStep.HeldPacket {
val held = ReadStep.HeldPacket(VitureV2Link.Received(packet.copyOf(), System.nanoTime()))
check(incoming.offer(held))
assertTrue("Worker did not enter the held read", held.entered.await(2, TimeUnit.SECONDS))
return held
}
fun expectWrite(expected: ByteArray) {
assertArrayEquals(expected, writes.poll(2, TimeUnit.SECONDS))
}
fun flush() {
val reached = CountDownLatch(1)
check(incoming.offer(ReadStep.Barrier(reached)))
assertTrue("Worker did not consume queued reports", reached.await(2, TimeUnit.SECONDS))
}
fun awaitClosed() { assertTrue("Transport did not close", closed.await(2, TimeUnit.SECONDS)) }
}
}
@@ -0,0 +1,175 @@
// Fixtures adapted from elasticjava/viture-v2, MIT, Copyright (c) 2026 Holger Bartnick.
// Source: ece8c30485f7d357fefa362ae74f3eabac9b3899; see docs/third-party/viture-v2/.
package com.droiddeck.launcher.glasses
import org.junit.Assert.assertArrayEquals
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertNull
import org.junit.Assert.assertThrows
import org.junit.Assert.assertTrue
import org.junit.Test
import java.nio.ByteBuffer
import java.nio.ByteOrder
import kotlin.math.sqrt
class VitureV2ProtocolTest {
@Test fun requestsMatchUpstreamWireExamples() {
assertArrayEquals(hex("10 00 01 03 02 00 03 00 01 02"),
VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_POSE))
assertArrayEquals(hex("10 00 01 03 02 00 04 00 02 02"),
VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_RAW))
assertArrayEquals(hex("10 00 01 03 02 00 00 00 00 00"),
VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_OFF))
assertArrayEquals(hex("10 00 22 31 00 00 00 00"),
VitureV2Protocol.packet(VitureV2Protocol.MSG_GET_BRIGHTNESS))
}
@Test fun requestBoundsAndStreamLimitsAreEnforced() {
assertThrows(IllegalArgumentException::class.java) { VitureV2Protocol.packet(-1) }
assertThrows(IllegalArgumentException::class.java) { VitureV2Protocol.packet(0x10000) }
assertThrows(IllegalArgumentException::class.java) { VitureV2Protocol.packet(0, ByteArray(57)) }
assertThrows(IllegalArgumentException::class.java) { VitureV2Protocol.imuControl(3) }
assertThrows(IllegalArgumentException::class.java) {
VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_POSE, VitureV2Protocol.Rate.HZ_500)
}
assertArrayEquals(hex("10 00 01 03 02 00 07 00 02 05"),
VitureV2Protocol.imuControl(VitureV2Protocol.STREAM_RAW, VitureV2Protocol.Rate.HZ_1000))
val maximum = VitureV2Protocol.packet(0xFFFF, ByteArray(56) { 0xFF.toByte() })
assertEquals(64, maximum.size)
assertEquals(0x37C8, (maximum[6].toInt() and 0xFF) or ((maximum[7].toInt() and 0xFF) shl 8))
assertNotNull(VitureV2Protocol.parse(maximum))
}
@Test fun brightnessReplyMatchesUpstreamAndKeepsFailureStatus() {
val frame = VitureV2Protocol.parse(hex("10 00 22 51 02 00 03 00 00 03"))!!
val reply = VitureV2Protocol.reply(frame, VitureV2Protocol.MSG_GET_BRIGHTNESS)!!
assertTrue(reply.success)
assertEquals(0, reply.status)
assertArrayEquals(byteArrayOf(3), reply.body)
assertNull(VitureV2Protocol.reply(frame, VitureV2Protocol.MSG_GET_VOLUME))
assertNull(VitureV2Protocol.reply(frame, -1))
val failure = VitureV2Protocol.parse(hex("10 00 01 23 01 00 07 00 07"))!!
val failedReply = VitureV2Protocol.reply(failure, VitureV2Protocol.MSG_IMU_CONTROL)!!
assertFalse(failedReply.success)
assertEquals(7, failedReply.status)
assertTrue(failedReply.body.isEmpty())
val noStatus = VitureV2Protocol.parse(hex("10 00 01 23 00 00 00 00"))!!
assertNull(VitureV2Protocol.reply(noStatus, VitureV2Protocol.MSG_IMU_CONTROL))
}
@Test fun validatesReceiveBoundsBeforeReadingHeader() {
val valid = hex("10 00 22 51 02 00 03 00 00 03")
for (size in listOf(-1, 0, 7, 9, 11, 65, Int.MAX_VALUE)) {
assertNull("size=$size", VitureV2Protocol.parse(valid, size))
}
assertNull(VitureV2Protocol.parse(ByteArray(0)))
assertNull(VitureV2Protocol.parse(valid.copyOf(65)))
assertNull(VitureV2Protocol.parse(valid.copyOf().also { it[0] = 0x11 }))
assertNull(VitureV2Protocol.parse(valid.copyOf().also { it[1] = 1 }))
assertNull(VitureV2Protocol.parse(valid.copyOf().also { it[6] = 0xFF.toByte() }))
assertNull(VitureV2Protocol.parse(valid.copyOf().also { it[9] = 4 }))
}
@Test fun rejectsOversizedAndTruncatedDeclaredPayloads() {
val valid = hex("10 00 22 51 02 00 03 00 00 03")
assertNull(VitureV2Protocol.parse(valid.copyOf(9)))
val tooLong = valid.copyOf(64).also { it[4] = 57 }
assertNull(VitureV2Protocol.parse(tooLong))
tooLong[4] = 0xFF.toByte()
tooLong[5] = 0xFF.toByte()
assertNull(VitureV2Protocol.parse(tooLong))
val padded = valid.copyOf(64)
val parsed = VitureV2Protocol.parse(padded)!!
assertArrayEquals(byteArrayOf(0, 3), parsed.payload)
padded[9] = 8
assertArrayEquals(byteArrayOf(0, 3), parsed.payload)
}
@Test fun poseFixturePreservesDeviceCounterAndConvertsWxyzToNormalizedXyzw() {
val frame = VitureV2Protocol.parse(hex(
"10 00 08 73 18 00 9c 08 " +
"26 01 00 00 59 d6 21 00 dd e3 2b 3e 52 5d 7c 3f dd 45 9a 3b e8 27 52 3a"
))!!
val pose = VitureV2Protocol.pose(frame)!!
assertEquals(0x0021D659L, pose.deviceTick)
assertEquals(0x126L, pose.unknown)
val expected = floatArrayOf(Float.fromBits(0x3F7C5D52), Float.fromBits(0x3B9A45DD),
Float.fromBits(0x3A5227E8), Float.fromBits(0x3E2BE3DD))
val norm = sqrt(expected.sumOf { it.toDouble() * it }).toFloat()
assertArrayEquals(expected.map { it / norm }.toFloatArray(), pose.quaternion, 1e-7f)
assertEquals(1.0, pose.quaternion.sumOf { it.toDouble() * it }, 1e-6)
}
@Test fun poseNormalizesSmallScaleErrorsWithoutChangingAxesOrCounter() {
val payload = posePayload(0.5f, -0.5f, 0.5f, -0.5f)
ByteBuffer.wrap(payload).order(ByteOrder.LITTLE_ENDIAN).putInt(4, -1)
val pose = VitureV2Protocol.pose(event(VitureV2Protocol.EVENT_POSE, payload))!!
assertEquals(0xFFFFFFFFL, pose.deviceTick)
assertArrayEquals(floatArrayOf(-0.5f, 0.5f, -0.5f, 0.5f), pose.quaternion, 0f)
val scaled = VitureV2Protocol.pose(event(VitureV2Protocol.EVENT_POSE, posePayload(1.01f, 0f, 0f, 0f)))!!
assertArrayEquals(floatArrayOf(0f, 0f, 0f, 1f), scaled.quaternion, 1e-7f)
}
@Test fun rejectsMalformedPoseAndInvalidQuaternions() {
val valid = posePayload(1f, 0f, 0f, 0f)
assertNull(VitureV2Protocol.pose(event(VitureV2Protocol.EVENT_RAW, valid)))
for (size in listOf(0, 23, 25, 56)) {
assertNull(VitureV2Protocol.pose(event(VitureV2Protocol.EVENT_POSE, valid.copyOf(size))))
}
for (bad in listOf(0f, 0.5f, 2f, Float.MAX_VALUE, Float.NaN, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY)) {
assertNull("w=$bad", VitureV2Protocol.pose(event(VitureV2Protocol.EVENT_POSE, posePayload(bad, 0f, 0f, 0f))))
}
for (component in 1..3) {
val payload = valid.copyOf()
ByteBuffer.wrap(payload).order(ByteOrder.LITTLE_ENDIAN).putFloat(8 + component * 4, Float.NaN)
assertNull(VitureV2Protocol.pose(event(VitureV2Protocol.EVENT_POSE, payload)))
}
}
@Test fun rawReadsUnalignedFloatsAndPreservesUnknownBytes() {
val payload = rawPayload()
val frame = event(VitureV2Protocol.EVENT_RAW, payload)
val sample = VitureV2Protocol.raw(frame)!!
assertEquals(0xFFFFFFFEL, sample.deviceTick)
assertArrayEquals(floatArrayOf(1.5f, -2f, 0.25f), sample.gyroRadPerSec, 0f)
assertArrayEquals(floatArrayOf(0.0024f, -0.3221f, -0.9287f), sample.accelG, 0f)
assertArrayEquals(payload, sample.payload)
frame.payload.fill(0)
assertArrayEquals(payload, sample.payload)
}
@Test fun rejectsMalformedRawAndNonfiniteMeasurementsButKeepsOpaqueTail() {
val payload = rawPayload()
assertNull(VitureV2Protocol.raw(event(VitureV2Protocol.EVENT_POSE, payload)))
for (size in listOf(0, 24, 33, 34, 55)) {
assertNull(VitureV2Protocol.raw(event(VitureV2Protocol.EVENT_RAW, payload.copyOf(size))))
}
for (offset in listOf(10, 14, 18, 22, 26, 30)) {
for (bad in listOf(Float.NaN, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY)) {
val invalid = payload.copyOf()
ByteBuffer.wrap(invalid).order(ByteOrder.LITTLE_ENDIAN).putFloat(offset, bad)
assertNull("offset=$offset, value=$bad", VitureV2Protocol.raw(event(VitureV2Protocol.EVENT_RAW, invalid)))
}
}
ByteBuffer.wrap(payload).order(ByteOrder.LITTLE_ENDIAN).putFloat(46, Float.NaN)
assertNotNull(VitureV2Protocol.raw(event(VitureV2Protocol.EVENT_RAW, payload)))
}
private fun event(msgId: Int, payload: ByteArray) =
VitureV2Protocol.parse(VitureV2Protocol.packet(msgId, payload))!!
private fun posePayload(w: Float, x: Float, y: Float, z: Float) =
ByteBuffer.allocate(24).order(ByteOrder.LITTLE_ENDIAN)
.putInt(0x126).putInt(123).putFloat(w).putFloat(x).putFloat(y).putFloat(z).array()
private fun rawPayload() = ByteBuffer.allocate(56).order(ByteOrder.LITTLE_ENDIAN)
.putInt(0x126).putInt(-2).putShort(187)
.putFloat(1.5f).putFloat(-2f).putFloat(0.25f)
.putFloat(0.0024f).putFloat(-0.3221f).putFloat(-0.9287f)
.putFloat(117.30f).putFloat(60.75f).putFloat(254.85f)
.put(byteArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)).array()
private fun hex(value: String) = value.split(' ').map { it.toInt(16).toByte() }.toByteArray()
}
@@ -40,6 +40,33 @@ class SessionDisplayTest {
assertEquals(864, SessionDisplay.unfoldedGameHeight(1920, 1080))
}
private fun unfoldedWanted(
enabled: Boolean = true,
controller: Boolean = false,
keepWithController: Boolean = false,
foldable: Boolean = true,
steamDeckPad: Boolean = true,
pip: Boolean = false,
smallestWidthDp: Int = 700,
) = SessionDisplay.unfoldedControlsWanted(enabled, foldable, controller, keepWithController, steamDeckPad, pip,
2448, 1848, smallestWidthDp)
@Test fun unfoldedControlsHideForAControllerUnlessKeptWithOne() {
assertTrue(unfoldedWanted())
assertFalse(unfoldedWanted(controller = true))
assertTrue(unfoldedWanted(controller = true, keepWithController = true))
assertTrue(unfoldedWanted(keepWithController = true))
}
@Test fun keepingUnfoldedControlsWithAControllerLeavesTheOtherConditions() {
assertFalse(unfoldedWanted(enabled = false, controller = true, keepWithController = true))
assertFalse(unfoldedWanted(foldable = false, keepWithController = true))
assertFalse(unfoldedWanted(steamDeckPad = false, keepWithController = true))
assertFalse(unfoldedWanted(pip = true, keepWithController = true))
assertFalse(unfoldedWanted(smallestWidthDp = 599, keepWithController = true))
assertFalse(SessionDisplay.unfoldedControlsWanted(true, true, true, true, true, false, 0, 1848, 700))
}
@Test fun followScreenKeepsTheWindowShapeAndSkipsTinyWindows() {
assertEquals(2520 to 1080, SessionDisplay.resolveChoice(1080 to 2520, SessionDisplay.FOLLOW_SCREEN))
@@ -0,0 +1,27 @@
package com.droiddeck.launcher.session
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test
class SessionVisibilityPolicyTest {
@Test fun handsetScreenStateControlsActivityOnDefaultDisplay() {
assertFalse(SessionVisibilityPolicy.isHidden(true, true, true, false))
assertTrue(SessionVisibilityPolicy.isHidden(true, false, true, true))
}
@Test fun externalDisplayStateControlsActivityIndependentlyOfHandset() {
assertFalse(SessionVisibilityPolicy.isHidden(true, false, false, true))
assertTrue(SessionVisibilityPolicy.isHidden(true, true, false, false))
}
@Test fun missingActivityDisplayIsHiddenUntilActivityMoves() {
assertTrue(SessionVisibilityPolicy.isHidden(true, true, false, false))
assertFalse(SessionVisibilityPolicy.isHidden(true, true, true, false))
}
@Test fun stoppedActivityIsHiddenButVisibleXrKeepsSessionVisible() {
assertTrue(SessionVisibilityPolicy.isHidden(false, true, true, true))
assertFalse(SessionVisibilityPolicy.isHidden(false, false, true, false, xrActivityVisible = true))
}
}
@@ -27,6 +27,7 @@ class SettingsResetTest {
@Test fun settingsGoBackToTheirDefaults() {
SessionPrefs.setTheme(app, "ocean")
SessionPrefs.setUnfoldedControlsWithController(app, true)
SessionPrefs.setNoXalia(app, false)
SessionPrefs.setFpsLimit(app, SessionService.MODE_STEAM, 30)
SessionPrefs.setHdr(app, SessionService.MODE_DESKTOP, true)
@@ -45,6 +46,7 @@ class SettingsResetTest {
assertTrue(SettingsReset.resetAll(app, gameProfiles = false))
assertEquals("graphite", SessionPrefs.theme(app))
assertFalse(SessionPrefs.unfoldedControlsWithController(app))
assertTrue(SessionPrefs.noXalia(app))
assertEquals(0, SessionPrefs.fpsLimit(app, SessionService.MODE_STEAM))
assertFalse(SessionPrefs.hdr(app, SessionService.MODE_DESKTOP))
@@ -30,6 +30,21 @@ import org.robolectric.annotation.Config
class GlassesPanelTest {
@get:Rule val compose = createRobolectricComposeRule()
@Test fun trackingOnlyDeviceHidesDisplayWritesButKeepsHeadTracking() {
show(supportsDisplayModeControl = false)
compose.onNodeWithTag("setting-glasses-hz").assertDoesNotExist()
compose.onNodeWithTag("setting-glasses-resolution-two_d").assertDoesNotExist()
compose.onNodeWithTag("setting-glasses-3d").assertDoesNotExist()
compose.onNodeWithTag("setting-glasses-3dof").assertExists()
}
@Test fun trackingOnlyDeviceHidesVrDisplayWrites() {
show(supportsDisplayModeControl = false, tab = GlassesTab.VR, steamVrRunning = true)
compose.onNodeWithTag("setting-glasses-resolution-vr").assertDoesNotExist()
compose.onNodeWithTag("setting-glasses-3d-hz").assertDoesNotExist()
compose.onNodeWithTag("setting-glasses-auto3d").assertDoesNotExist()
}
@Test fun flatResolutionMenuShowsPerEyeResolutionsBesideRefresh() {
show()
compose.onNodeWithTag("setting-glasses-hz").assertExists()
@@ -397,6 +412,7 @@ class GlassesPanelTest {
outputActive: Boolean = inSession,
controlAvailable: Boolean = true,
supportsScreen3dof: Boolean = true,
supportsDisplayModeControl: Boolean = true,
supportsSpatial: Boolean = false,
supports30Hz: Boolean = false,
sbs90: Boolean = true,
@@ -406,6 +422,7 @@ class GlassesPanelTest {
onRecenter: (() -> Unit)? = {},
) {
val state = GlassesState(present = true, connected = controlAvailable, controllable = true,
supportsDisplayModeControl = supportsDisplayModeControl,
displayId = Display.DEFAULT_DISPLAY + 1, width = if (stereo) 3840 else 1920, height = 1200,
model = "VITURE Luma Ultra", sbs = stereo, sbs90 = sbs90, supportsScreen3dof = supportsScreen3dof,
supports30Hz = supports30Hz, supportsSpatial = supportsSpatial, resolutions = listOf(
@@ -0,0 +1,100 @@
package com.droiddeck.launcher.ui
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.ui.Modifier
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.semantics.SemanticsProperties
import androidx.compose.ui.test.*
import androidx.compose.foundation.layout.size
import androidx.compose.ui.unit.dp
import org.junit.Rule
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [28])
class NavigationSelectionTest {
@get:Rule val compose = createRobolectricComposeRule()
@Before fun controlAnimationFrames() {
compose.mainClock.autoAdvance = false
}
@Test fun tabStripAnnouncesSelectionAndUpdatesAfterClick() {
val selected = mutableIntStateOf(0)
compose.setContent { DroidDeckTheme { TabStrip(listOf("First", "Second"), selected.intValue, { selected.intValue = it }) } }
verify("First", "Second")
}
@Test fun sheetChipsAnnounceSelectionAndUpdateAfterClick() {
val selected = mutableIntStateOf(0)
compose.setContent { DroidDeckTheme { SheetChips(listOf("First", "Second"), selected.intValue) { selected.intValue = it } } }
verify("First", "Second")
}
@Test fun segmentedTabsHaveOneTabRoleAndAnnounceTheirGroup() {
val selected = mutableIntStateOf(0)
compose.setContent { DroidDeckTheme { SegmentedTabs(listOf(0 to "First", 1 to "Second"), selected.intValue) { selected.intValue = it } } }
verify("First", "Second")
}
@Test fun sideRailExposesSelectionEvenWhenOnlyIconsAreVisible() {
val selected = mutableStateOf("steam")
Hops.railPreview = null
compose.setContent {
DroidDeckTheme {
SideRail(FrontEndState(
installed = "r9", ready = true, available = null, busy = false, stage = "", percent = -1,
desktopInstalled = true, offlineAccount = null, offline = false, frameGenLabel = "",
romsDir = null, logsEnabled = false, steamGames = emptyList(), emulators = emptyList(), running = null,
), selected.value, { selected.value = it }, {}, actions, Modifier.size(300.dp, 600.dp))
}
}
compose.mainClock.advanceTimeBy(1_000)
val steam = compose.onNodeWithTag("rail-steam")
val games = compose.onNodeWithTag("rail-games")
assertTab(steam, true)
assertTab(games, false)
games.performClick()
compose.mainClock.advanceTimeBy(1_000)
assertTab(steam, false)
assertTab(games, true)
assertGroup()
}
private fun verify(first: String, second: String) {
compose.mainClock.advanceTimeBy(1_000)
val a = compose.onNodeWithText(first)
val b = compose.onNodeWithText(second)
assertTab(a, true)
assertTab(b, false)
b.performClick()
compose.mainClock.advanceTimeBy(1_000)
assertTab(a, false)
assertTab(b, true)
assertGroup()
}
private fun assertTab(node: SemanticsNodeInteraction, selected: Boolean) {
node.assert(SemanticsMatcher.expectValue(SemanticsProperties.Role, Role.Tab)).assertHasClickAction()
if (selected) node.assertIsSelected() else node.assertIsNotSelected()
}
private fun assertGroup() {
compose.onAllNodes(SemanticsMatcher.keyIsDefined(SemanticsProperties.SelectableGroup)).assertCountEquals(1)
}
private val actions = FrontEndActions(
onPlay = {}, onPlayDesktopUi = {}, onSteamGame = {}, onDesktop = {}, onEmulator = {},
onRom = {}, onResume = {}, onSteamSettings = {}, onDesktopSettings = {},
onInstallPackage = {}, onRemovePackage = {}, onRuntime = {}, onFrameGenPick = {},
onImportLossless = {}, onProtons = {}, onComponents = {}, onPerformance = {},
onRoms = {}, onFiles = {}, onLogs = {}, onOffline = {},
onWirelessAdbPair = { _, _, _, _ -> }, onWirelessAdbApply = { _, _, _, _ -> },
onSetPhantomProcessLimit = { _, _ -> },
)
}
@@ -0,0 +1,135 @@
package com.droiddeck.launcher.ui
import android.content.Context
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.luminance
import androidx.compose.ui.graphics.toArgb
import com.droiddeck.launcher.session.SessionPrefs
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.RuntimeEnvironment
import org.robolectric.annotation.Config
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [33])
class ThemeColorsTest {
private val app get() = RuntimeEnvironment.getApplication()
@Before fun clear() {
app.getSharedPreferences("session", Context.MODE_PRIVATE).edit().clear().commit()
}
private fun near(expected: Int, actual: Int) {
for (shift in listOf(16, 8, 0)) assertTrue("${ThemeColors.hex(expected)} vs ${ThemeColors.hex(actual)}", Math.abs((expected shr shift and 0xFF) - (actual shr shift and 0xFF)) <= 1)
}
@Test fun hueSaturationAndBrightnessComeBackAsTheSameColour() {
for (argb in listOf(0xFF8B5CF6.toInt(), 0xFF22D3EE.toInt(), 0xFFFF0000.toInt(), 0xFF336699.toInt(), 0xFF808080.toInt(), 0xFF000000.toInt(), 0xFFFFFFFF.toInt())) {
val hsv = ThemeColors.toHsv(argb)
near(argb, ThemeColors.fromHsv(hsv.h, hsv.s, hsv.v))
}
}
@Test fun hexIsReadWithOrWithoutTheHashAndInShortForm() {
assertEquals(0xFF8B5CF6.toInt(), ThemeColors.parseHex("#8B5CF6"))
assertEquals(0xFF8B5CF6.toInt(), ThemeColors.parseHex("8b5cf6"))
assertEquals(0xFFFF00AA.toInt(), ThemeColors.parseHex(" #f0a "))
assertEquals("#8B5CF6", ThemeColors.hex(0xFF8B5CF6.toInt()))
for (bad in listOf("", "#", "#12", "#1234", "#1234567", "zzzzzz", "#12345g")) assertNull(bad, ThemeColors.parseHex(bad))
}
@Test fun aTooDarkColourIsLiftedAndABrightOneIsLeftAlone() {
val dark = ThemeColors.readable(0xFF050505.toInt())
assertTrue(Color(dark).luminance() >= 0.10f)
assertEquals(0xFF8B5CF6.toInt(), ThemeColors.readable(0xFF8B5CF6.toInt()))
}
@Test fun aDeepBlueThatBrightnessAloneCannotLiftIsMadePaler() {
assertTrue(Color(ThemeColors.readable(0xFF0000FF.toInt())).luminance() >= 0.10f)
assertTrue(Color(ThemeColors.readable(0xFF000000.toInt())).luminance() >= 0.10f)
}
@Test fun theTextColourSuitsTheWorseOfTheTwoGradientColours() {
assertEquals(Color(0xFF03111F), ThemeColors.inkFor(0xFFFFEB3B.toInt(), 0xFF3B4FA8.toInt()))
assertEquals(Color.White, ThemeColors.inkFor(0xFF3B4FA8.toInt(), 0xFF5B2FA8.toInt()))
assertEquals(Color(0xFF03111F), ThemeColors.inkFor(0xFFFFFFFF.toInt(), 0xFFFFEB3B.toInt()))
}
private fun contrast(a: Color, b: Color) = (maxOf(a.luminance(), b.luminance()) + 0.05f) / (minOf(a.luminance(), b.luminance()) + 0.05f)
@Test fun buttonTextIsReadableOnBothGradientColoursForAnyPair() {
val picks = listOf(0xFFFFEB3B, 0xFF1E3A8A, 0xFF0000FF, 0xFFFF0000, 0xFF00FF00, 0xFF808080, 0xFFFFFFFF, 0xFF000000, 0xFF8B5CF6, 0xFF22D3EE, 0xFFFF5722, 0xFF3F51B5)
for (a in picks) for (b in picks) {
val p = ThemeColors.palette(a.toInt(), b.toInt(), 0, 0)
val first = p.primary.toArgb()
val second = p.primary2.toArgb()
for (step in 0..100) {
val fraction = step / 100f
val color = Color(
0xFF000000.toInt() or
(channel(first, 16, second, fraction) shl 16) or
(channel(first, 8, second, fraction) shl 8) or
channel(first, 0, second, fraction),
)
assertTrue(
"${ThemeColors.hex(first)} ${ThemeColors.hex(second)} at $fraction",
contrast(p.onPrimary, color) >= 4.5f,
)
}
}
}
private fun channel(first: Int, shift: Int, second: Int, fraction: Float): Int {
val start = first shr shift and 0xFF
val end = second shr shift and 0xFF
return (start + (end - start) * fraction).toInt().coerceIn(0, 255)
}
@Test fun onlyTheStopThatFailsIsNudged() {
val p = ThemeColors.palette(0xFFFFEB3B.toInt(), 0xFF1E3A8A.toInt(), 0, 0)
assertEquals(Color(0xFFFFEB3B), p.primary)
assertTrue(p.primary2 != Color(0xFF1E3A8A))
assertEquals(Color(0xFF03111F), p.onPrimary)
}
@Test fun thePaletteKeepsTheTwoColoursAndStaysDarkAndReadable() {
val p = ThemeColors.palette(0xFF8B5CF6.toInt(), 0xFF22D3EE.toInt(), 0, 0)
assertEquals(p.primary, p.signal)
assertEquals(Color(0xFF22D3EE), p.primary2)
assertTrue(contrast(p.onPrimary, p.primary) >= 4.5f)
assertTrue(contrast(p.onPrimary, p.primary2) >= 4.5f)
assertTrue(p.background.luminance() < p.surface.luminance())
assertTrue(p.surface.luminance() < p.surfaceVariant.luminance())
assertTrue(p.background.luminance() < 0.02f)
assertTrue(p.onBackground.luminance() > 0.8f)
assertEquals(Color(0xFF03111F), ThemeColors.palette(0xFFFFEB3B.toInt(), 0xFFFFFFFF.toInt(), 0, 0).onPrimary)
assertEquals(Color.White, ThemeColors.palette(0xFF1E40AF.toInt(), 0xFF1D4ED8.toInt(), 0, 0).onPrimary)
}
@Test fun aGreyPrimaryGivesGreyNeutrals() {
val p = ThemeColors.palette(0xFFB0B0B0.toInt(), 0xFFFFFFFF.toInt(), 0, 0)
assertEquals(p.background.red, p.background.blue, 0.002f)
}
@Test fun theGradientThemeFollowsTheSavedColoursAndComesBackAfterARestart() {
Themes.setGradient(app, 0xFFFF5722.toInt(), 0xFF3F51B5.toInt())
val live = Themes.byId(Themes.GRADIENT)
assertEquals(0xFFFF5722.toInt() to 0xFF3F51B5.toInt(), SessionPrefs.gradientColors(app))
assertTrue(contrast(live.onPrimary, live.primary) >= 4.5f)
assertTrue(contrast(live.onPrimary, live.primary2) >= 4.5f)
SessionPrefs.setTheme(app, Themes.GRADIENT)
Themes.setGradient(app, Themes.DEFAULT_PRIMARY, Themes.DEFAULT_SECONDARY)
SessionPrefs.setGradientColors(app, 0xFF00FF00.toInt(), 0xFF0000FF.toInt())
assertEquals(Color(0xFF00FF00), Themes.current(app).primary)
}
@Test fun theGradientIsAChoiceInTheThemeList() {
assertTrue(Themes.all.any { it.id == Themes.GRADIENT })
assertEquals(Themes.GRAPHITE, Themes.byId("nonsense").id)
}
}