Initial Commit
This commit is contained in:
Ashin Walpola
@@ -0,0 +1,354 @@
|
||||
package com.hawhamburg.micr0bu
|
||||
|
||||
import com.hawhamburg.micr0bu.domain.detection.Confidence
|
||||
import com.hawhamburg.micr0bu.domain.detection.DetectedEvent
|
||||
import com.hawhamburg.micr0bu.domain.detection.DetectionConfig
|
||||
import com.hawhamburg.micr0bu.domain.detection.EventDetector
|
||||
import com.hawhamburg.micr0bu.domain.detection.EventType
|
||||
import com.hawhamburg.micr0bu.domain.detection.RunningStats
|
||||
import kotlinx.coroutines.ExperimentalCoroutinesApi
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.test.UnconfinedTestDispatcher
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import kotlin.math.sqrt
|
||||
|
||||
/**
|
||||
* Unit tests for [EventDetector] and [RunningStats] using synthetic sensor data.
|
||||
*
|
||||
* No Android emulator required — all production classes have zero Android imports.
|
||||
*
|
||||
* The test [config] uses a smaller window and fewer sustained frames than the
|
||||
* production defaults so tests run in milliseconds without generating thousands
|
||||
* of synthetic samples.
|
||||
*
|
||||
* Accel-std-dev notes
|
||||
* -------------------
|
||||
* A production threshold of 1.2 m/s² requires genuine variability in the window.
|
||||
* In the "hard brake" tests we alternate between high and low accel values
|
||||
* (e.g. 3.5 / 0.5), which yields std dev ≈ 1.5 with a 10-sample window.
|
||||
*/
|
||||
@OptIn(ExperimentalCoroutinesApi::class)
|
||||
class EventDetectorTest {
|
||||
|
||||
/** Tighter config so fewer frames are needed to trigger each event. */
|
||||
private val config = DetectionConfig(
|
||||
windowSize = 10,
|
||||
brakingSustainedFrames = 5,
|
||||
turningSustainedFrames = 8,
|
||||
stoppingFrames = 20,
|
||||
// Keep production thresholds for all signal values:
|
||||
brakingSpeedDropThreshold = 0.5,
|
||||
brakingAccelStdDevThreshold = 1.2,
|
||||
brakingHighConfidenceRate = 1.5,
|
||||
turningGyroMeanThreshold = 0.4,
|
||||
turningBearingChangeThreshold = 10.0,
|
||||
turningMinSpeedThreshold = 2.0,
|
||||
stoppingSpeedThreshold = 0.5,
|
||||
stoppingAccelStdDevThreshold = 0.15,
|
||||
)
|
||||
|
||||
private lateinit var detector: EventDetector
|
||||
|
||||
@Before fun setUp() { detector = EventDetector(config) }
|
||||
|
||||
// ─── Helpers ──────────────────────────────────────────────────────────────
|
||||
|
||||
/** Runs [block] inside a coroutine that collects all emitted events. */
|
||||
private fun runCollecting(
|
||||
block: suspend kotlinx.coroutines.test.TestScope.(events: MutableList<DetectedEvent>) -> Unit,
|
||||
) = runTest {
|
||||
val events = mutableListOf<DetectedEvent>()
|
||||
val job = launch(UnconfinedTestDispatcher(testScheduler)) {
|
||||
detector.events.collect { events.add(it) }
|
||||
}
|
||||
block(events)
|
||||
job.cancel()
|
||||
}
|
||||
|
||||
/**
|
||||
* Produces [n] frames with alternating accelMagnitude values of [hi] and [lo],
|
||||
* giving a population std dev of |hi - lo| / 2, which exceeds the production
|
||||
* threshold of 1.2 m/s² when hi=3.5 and lo=0.5 (std dev = 1.5).
|
||||
*/
|
||||
private fun alternatingAccelFrames(
|
||||
n: Int,
|
||||
hi: Double = 3.5,
|
||||
lo: Double = 0.5,
|
||||
speedMps: Double = 10.0,
|
||||
bearingChangeDps: Double = 0.0,
|
||||
timeOffset: Int = 0,
|
||||
) {
|
||||
repeat(n) { i ->
|
||||
detector.processSample(
|
||||
accelMagnitude = if (i % 2 == 0) hi else lo,
|
||||
gyroMagnitude = 0.05,
|
||||
speedMps = speedMps,
|
||||
bearingChangeDegPerSec = bearingChangeDps,
|
||||
latitude = 53.5,
|
||||
longitude = 10.0,
|
||||
timestamp = (timeOffset + i) * 20L,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Normal riding — no false triggers ───────────────────────────────────
|
||||
|
||||
@Test fun `normal riding produces no events`() = runCollecting { events ->
|
||||
// Steady 5 m/s, low gyro, very low accel variance (constant value → stdDev = 0)
|
||||
repeat(50) { i ->
|
||||
detector.processSample(
|
||||
accelMagnitude = 0.2,
|
||||
gyroMagnitude = 0.1,
|
||||
speedMps = 5.0,
|
||||
bearingChangeDegPerSec = 2.0,
|
||||
latitude = 53.5,
|
||||
longitude = 10.0,
|
||||
timestamp = i * 20L,
|
||||
)
|
||||
}
|
||||
assertTrue("No events expected during steady riding, got: $events", events.isEmpty())
|
||||
}
|
||||
|
||||
// ─── Hard brake ───────────────────────────────────────────────────────────
|
||||
|
||||
@Test fun `hard brake triggers BRAKING event`() = runCollecting { events ->
|
||||
// Phase 1: fill window at 10 m/s with constant accel (no std dev → no braking)
|
||||
repeat(config.windowSize) { i ->
|
||||
detector.processSample(1.0, 0.05, 10.0, 0.0, 53.5, 10.0, i * 20L)
|
||||
}
|
||||
// Phase 2: GPS drops to 4 m/s (drop = 6 m/s > 0.5 threshold).
|
||||
// Alternate hi/lo accel to exceed the std-dev threshold.
|
||||
alternatingAccelFrames(
|
||||
n = config.brakingSustainedFrames + 5,
|
||||
speedMps = 4.0,
|
||||
timeOffset = config.windowSize,
|
||||
)
|
||||
val braking = events.filter { it.type == EventType.BRAKING }
|
||||
assertTrue("Expected at least one BRAKING event, got: $events", braking.isNotEmpty())
|
||||
}
|
||||
|
||||
@Test fun `hard brake with large speed drop has HIGH confidence`() = runCollecting { events ->
|
||||
repeat(config.windowSize) { i ->
|
||||
detector.processSample(1.0, 0.05, 10.0, 0.0, 53.5, 10.0, i * 20L)
|
||||
}
|
||||
// Drop of 8 m/s > brakingHighConfidenceRate (1.5)
|
||||
alternatingAccelFrames(
|
||||
n = config.brakingSustainedFrames + 5,
|
||||
hi = 3.5,
|
||||
lo = 0.5,
|
||||
speedMps = 2.0, // drop from 10 → 8 m/s
|
||||
timeOffset = config.windowSize,
|
||||
)
|
||||
val braking = events.filter { it.type == EventType.BRAKING }
|
||||
assertTrue(braking.isNotEmpty())
|
||||
assertEquals(
|
||||
"Large speed drop should yield HIGH confidence",
|
||||
Confidence.HIGH,
|
||||
braking.first().confidence,
|
||||
)
|
||||
}
|
||||
|
||||
@Test fun `moderate speed drop has MEDIUM confidence`() = runCollecting { events ->
|
||||
repeat(config.windowSize) { i ->
|
||||
detector.processSample(1.0, 0.05, 3.0, 0.0, 53.5, 10.0, i * 20L)
|
||||
}
|
||||
// Drop of 0.8 m/s — above speed-drop threshold (0.5) but below high-conf rate (1.5)
|
||||
alternatingAccelFrames(
|
||||
n = config.brakingSustainedFrames + 5,
|
||||
hi = 3.5,
|
||||
lo = 0.5,
|
||||
speedMps = 2.2, // drop = 0.8 m/s
|
||||
timeOffset = config.windowSize,
|
||||
)
|
||||
val braking = events.filter { it.type == EventType.BRAKING }
|
||||
assertTrue(braking.isNotEmpty())
|
||||
assertEquals(Confidence.MEDIUM, braking.first().confidence)
|
||||
}
|
||||
|
||||
// ─── Left turn ────────────────────────────────────────────────────────────
|
||||
|
||||
@Test fun `sustained high gyro above 2ms triggers TURNING event`() = runCollecting { events ->
|
||||
val total = config.windowSize + config.turningSustainedFrames + 4
|
||||
repeat(total) { i ->
|
||||
detector.processSample(
|
||||
accelMagnitude = 0.3,
|
||||
gyroMagnitude = 0.8, // mean → well above 0.4 threshold
|
||||
speedMps = 4.0, // above 2 m/s → bearing also checked
|
||||
bearingChangeDegPerSec = 15.0, // above 10 °/s → both signals agree
|
||||
latitude = 53.5,
|
||||
longitude = 10.0,
|
||||
timestamp = i * 20L,
|
||||
)
|
||||
}
|
||||
assertTrue("Expected TURNING event, got: $events", events.any { it.type == EventType.TURNING })
|
||||
}
|
||||
|
||||
@Test fun `turning with both signals agreeing gets HIGH confidence`() = runCollecting { events ->
|
||||
val total = config.windowSize + config.turningSustainedFrames + 4
|
||||
repeat(total) { i ->
|
||||
detector.processSample(0.3, 0.8, 4.0, 15.0, 53.5, 10.0, i * 20L)
|
||||
}
|
||||
val turning = events.filter { it.type == EventType.TURNING }
|
||||
assertTrue(turning.isNotEmpty())
|
||||
assertEquals(Confidence.HIGH, turning.first().confidence)
|
||||
}
|
||||
|
||||
@Test fun `turning at low speed with gyro only gets LOW confidence`() = runCollecting { events ->
|
||||
val total = config.windowSize + config.turningSustainedFrames + 4
|
||||
repeat(total) { i ->
|
||||
detector.processSample(
|
||||
accelMagnitude = 0.2,
|
||||
gyroMagnitude = 0.6, // above gyro threshold
|
||||
speedMps = 1.0, // below 2 m/s → bearing not enforced
|
||||
bearingChangeDegPerSec = 3.0, // below bearing threshold
|
||||
latitude = 53.5,
|
||||
longitude = 10.0,
|
||||
timestamp = i * 20L,
|
||||
)
|
||||
}
|
||||
val turning = events.filter { it.type == EventType.TURNING }
|
||||
assertTrue("Expected TURNING event at low speed, got: $events", turning.isNotEmpty())
|
||||
assertEquals("Low-speed turn should be LOW confidence", Confidence.LOW, turning.first().confidence)
|
||||
}
|
||||
|
||||
// ─── Full stop ────────────────────────────────────────────────────────────
|
||||
|
||||
@Test fun `full stop for required frames triggers STOPPING event`() = runCollecting { events ->
|
||||
val frames = config.stoppingFrames + 5
|
||||
repeat(frames) { i ->
|
||||
detector.processSample(
|
||||
accelMagnitude = 0.02, // constant → stdDev = 0 < 0.15
|
||||
gyroMagnitude = 0.01,
|
||||
speedMps = 0.1, // < 0.5 threshold
|
||||
bearingChangeDegPerSec = 0.0,
|
||||
latitude = 53.5,
|
||||
longitude = 10.0,
|
||||
timestamp = i * 20L,
|
||||
)
|
||||
}
|
||||
val stopping = events.filter { it.type == EventType.STOPPING }
|
||||
assertTrue("Expected STOPPING event, got: $events", stopping.isNotEmpty())
|
||||
assertEquals("STOPPING should always be HIGH confidence", Confidence.HIGH, stopping.first().confidence)
|
||||
}
|
||||
|
||||
@Test fun `STOPPING emitted exactly once per stop episode`() = runCollecting { events ->
|
||||
val frames = config.stoppingFrames + 30
|
||||
repeat(frames) { i ->
|
||||
detector.processSample(0.02, 0.01, 0.1, 0.0, 53.5, 10.0, i * 20L)
|
||||
}
|
||||
val stopping = events.filter { it.type == EventType.STOPPING }
|
||||
assertEquals("STOPPING must emit exactly once per episode", 1, stopping.size)
|
||||
}
|
||||
|
||||
// ─── Bag movement while stationary ───────────────────────────────────────
|
||||
|
||||
@Test fun `bag movement while stationary does not trigger BRAKING or TURNING`() = runCollecting { events ->
|
||||
// Speed stays at zero; occasional accel/gyro spikes from bag jostle
|
||||
repeat(50) { i ->
|
||||
val accel = if (i % 5 == 0) 1.8 else 0.3 // jitter but mean is below std-dev threshold
|
||||
val gyro = if (i % 7 == 0) 0.35 else 0.05 // occasional spike but mean stays < 0.4
|
||||
detector.processSample(
|
||||
accelMagnitude = accel,
|
||||
gyroMagnitude = gyro,
|
||||
speedMps = 0.0,
|
||||
bearingChangeDegPerSec = 1.0,
|
||||
latitude = 53.5,
|
||||
longitude = 10.0,
|
||||
timestamp = i * 20L,
|
||||
)
|
||||
}
|
||||
// speed = 0 → no speed drop possible → no BRAKING
|
||||
// gyro mean stays below 0.4 (only 1/7 frames spike to 0.35) → no TURNING
|
||||
val unwanted = events.filter { it.type == EventType.BRAKING || it.type == EventType.TURNING }
|
||||
assertTrue("Bag movement must not trigger BRAKING or TURNING, got: $events", unwanted.isEmpty())
|
||||
}
|
||||
|
||||
// ─── Starting from stationary ─────────────────────────────────────────────
|
||||
|
||||
@Test fun `starting from stationary does not produce false BRAKING event`() = runCollecting { events ->
|
||||
// Begin at rest then accelerate — speed only INCREASES
|
||||
repeat(10) { i ->
|
||||
detector.processSample(0.1, 0.05, 0.0, 0.0, 53.5, 10.0, i * 20L)
|
||||
}
|
||||
repeat(20) { i ->
|
||||
val speed = i * 0.3 // 0 → 5.7 m/s — monotonically increasing
|
||||
detector.processSample(0.8, 0.1, speed, 1.0, 53.5, 10.0, (10 + i) * 20L)
|
||||
}
|
||||
val braking = events.filter { it.type == EventType.BRAKING }
|
||||
assertTrue("Starting from stationary must not trigger BRAKING, got: $events", braking.isEmpty())
|
||||
}
|
||||
|
||||
@Test fun `stopping then re-accelerating then stopping triggers two STOPPING events`() = runCollecting { events ->
|
||||
val stopFrames = config.stoppingFrames + 5
|
||||
var t = 0
|
||||
|
||||
// First stop episode
|
||||
repeat(stopFrames) {
|
||||
detector.processSample(0.02, 0.01, 0.1, 0.0, 53.5, 10.0, t++ * 20L)
|
||||
}
|
||||
// Brief acceleration — resets the stopping counter
|
||||
repeat(5) {
|
||||
detector.processSample(0.5, 0.1, 5.0, 2.0, 53.5, 10.0, t++ * 20L)
|
||||
}
|
||||
// Second stop episode
|
||||
repeat(stopFrames) {
|
||||
detector.processSample(0.02, 0.01, 0.1, 0.0, 53.5, 10.0, t++ * 20L)
|
||||
}
|
||||
|
||||
val stopping = events.filter { it.type == EventType.STOPPING }
|
||||
assertEquals("Expected two STOPPING events (one per episode)", 2, stopping.size)
|
||||
}
|
||||
|
||||
// ─── RunningStats unit tests ──────────────────────────────────────────────
|
||||
|
||||
@Test fun `RunningStats mean and stdDev are correct for known sequence`() {
|
||||
val stats = RunningStats(windowSize = 4)
|
||||
// [2, 4, 4, 4] → mean = 3.5, variance = 0.75
|
||||
stats.add(2.0); stats.add(4.0); stats.add(4.0); stats.add(4.0)
|
||||
assertEquals(3.5, stats.mean(), 1e-9)
|
||||
assertEquals(0.75, stats.variance(), 1e-9)
|
||||
assertEquals(sqrt(0.75), stats.stdDev(), 1e-9)
|
||||
}
|
||||
|
||||
@Test fun `RunningStats evicts oldest value when window is full`() {
|
||||
val stats = RunningStats(windowSize = 3)
|
||||
stats.add(1.0); stats.add(2.0); stats.add(3.0)
|
||||
assertEquals(2.0, stats.mean(), 1e-9) // [1,2,3] → 2.0
|
||||
stats.add(10.0)
|
||||
assertEquals(5.0, stats.mean(), 1e-9) // [2,3,10] → 5.0
|
||||
}
|
||||
|
||||
@Test fun `RunningStats size grows correctly and caps at windowSize`() {
|
||||
val stats = RunningStats(windowSize = 5)
|
||||
assertEquals(0, stats.size())
|
||||
stats.add(1.0); assertEquals(1, stats.size())
|
||||
stats.add(1.0); assertEquals(2, stats.size())
|
||||
repeat(10) { stats.add(1.0) }
|
||||
assertEquals(5, stats.size())
|
||||
}
|
||||
|
||||
@Test fun `RunningStats reset clears all state`() {
|
||||
val stats = RunningStats(windowSize = 5)
|
||||
repeat(5) { stats.add(it.toDouble()) }
|
||||
stats.reset()
|
||||
assertEquals(0, stats.size())
|
||||
assertEquals(0.0, stats.mean(), 1e-9)
|
||||
assertEquals(0.0, stats.stdDev(), 1e-9)
|
||||
}
|
||||
|
||||
@Test fun `RunningStats variance is zero for constant sequence`() {
|
||||
val stats = RunningStats(windowSize = 10)
|
||||
repeat(10) { stats.add(3.14) }
|
||||
assertEquals(0.0, stats.variance(), 1e-9)
|
||||
}
|
||||
|
||||
@Test fun `RunningStats returns zero mean and stdDev for empty window`() {
|
||||
val stats = RunningStats(windowSize = 10)
|
||||
assertEquals(0.0, stats.mean(), 1e-9)
|
||||
assertEquals(0.0, stats.stdDev(), 1e-9)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user