seuuung
4 days ago
134 changed files with 42 additions and 20974 deletions
@ -1,210 +0,0 @@ |
|||
package com.dct.app.background |
|||
|
|||
import android.app.Notification |
|||
import android.app.NotificationManager |
|||
import android.os.SystemClock |
|||
import androidx.activity.ComponentActivity |
|||
import androidx.lifecycle.Lifecycle |
|||
import androidx.test.core.app.ActivityScenario |
|||
import androidx.test.core.app.ApplicationProvider |
|||
import androidx.test.platform.app.InstrumentationRegistry |
|||
import com.dct.app.DctApplication |
|||
import com.dct.app.data.logger.CsvMeasurementLogger |
|||
import com.dct.app.data.logger.Mf4MeasurementLogger |
|||
import com.dct.app.data.protocol.DctPacketCodec |
|||
import com.dct.app.data.protocol.SlidingRingBufferParser |
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.model.chart.ChartSignalSeries |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.domain.repository.DeviceConnectionState |
|||
import com.dct.app.presentation.main.MainUiState |
|||
import com.dct.app.presentation.main.MeasurementRecordingState |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import org.junit.Assert.* |
|||
import org.junit.Test |
|||
import java.io.File |
|||
import java.net.InetAddress |
|||
import java.net.ServerSocket |
|||
import java.net.Socket |
|||
import java.nio.ByteBuffer |
|||
import java.nio.ByteOrder |
|||
import java.util.concurrent.CopyOnWriteArrayList |
|||
import java.util.concurrent.atomic.AtomicInteger |
|||
import java.util.concurrent.atomic.AtomicReference |
|||
import kotlin.concurrent.thread |
|||
|
|||
/** Local protocol fixture only: no simulation code or alternate network path in the app. */ |
|||
class BackgroundMeasurementServiceTest { |
|||
private val instrumentation = InstrumentationRegistry.getInstrumentation() |
|||
private val app = ApplicationProvider.getApplicationContext<DctApplication>() |
|||
|
|||
@Test |
|||
fun backgroundKeepsReceivingAckGraphAndCsvThenStopKeepsTransport() = runSession(screenOff = false) |
|||
|
|||
@Test |
|||
fun screenOffKeepsReceivingAckGraphAndCsvThenStopKeepsTransport() = runSession(screenOff = true) |
|||
|
|||
private fun runSession(screenOff: Boolean) { |
|||
val scenario = ActivityScenario.launch(ComponentActivity::class.java) |
|||
val server = ServerSocket(0, 1, InetAddress.getByName("127.0.0.1")) |
|||
val peer = AtomicReference<Socket>() |
|||
val peerError = AtomicReference<Throwable>() |
|||
val acknowledgements = AtomicInteger() |
|||
val starts = AtomicInteger() |
|||
val stops = AtomicInteger() |
|||
val codec = DctPacketCodec() |
|||
val directory = File(app.cacheDir, "background-regression-${System.nanoTime()}") |
|||
val logger = CsvMeasurementLogger(directory, listOf("sm_01_01" to "C"), "background.csv") |
|||
val mf4 = Mf4MeasurementLogger(directory, listOf("sm_01_01" to "C"), "background.mf4") |
|||
val session = app.session |
|||
lateinit var series: ChartSignalSeries |
|||
val peerThread = thread(name = "BackgroundProtocolFixture", isDaemon = true) { |
|||
try { |
|||
val socket = server.accept() |
|||
peer.set(socket) |
|||
val parser = SlidingRingBufferParser() |
|||
val input = socket.getInputStream() |
|||
val bytes = ByteArray(4096) |
|||
while (true) { |
|||
val count = input.read(bytes) |
|||
if (count < 0) break |
|||
for (packet in parser.parseStream(bytes, count)) { |
|||
when (packet.command.toInt() and 0xFF) { |
|||
0x20 -> { starts.incrementAndGet(); send(socket, codec.encode(DctPacket(0xA0.toByte(), byteArrayOf(1, packet.payload.single())))) } |
|||
0x21 -> { stops.incrementAndGet(); send(socket, codec.encode(DctPacket(0xA1.toByte(), byteArrayOf(1)))) } |
|||
0x24 -> { assertArrayEquals(byteArrayOf(1), packet.payload); acknowledgements.incrementAndGet() } |
|||
0x05 -> send(socket, codec.encode(DctPacket(0x85.toByte(), byteArrayOf(1)))) |
|||
} |
|||
} |
|||
} |
|||
} catch (error: Throwable) { |
|||
if (!server.isClosed) peerError.set(error) |
|||
} |
|||
} |
|||
try { |
|||
instrumentation.runOnMainSync { |
|||
session.onUiStarted() |
|||
assertTrue(session.ensureForegroundService()) |
|||
session.viewModel.chartRenderer.replaceSignalBindings(listOf( |
|||
ChartSignalSeries("sm_01_01", "sm_01_01", AxisPosition.LEFT_0, 0x0000FF) |
|||
)) |
|||
series = session.viewModel.chartRenderer.seriesListFlow.value.single() |
|||
session.viewModel.wifiSocketManager.connect("127.0.0.1", server.localPort) |
|||
} |
|||
await { session.serviceRunning.value && session.viewModel.wifiSocketManager.isConnected.value && peer.get() != null } |
|||
// Fixture bypasses equipment setup only, exercising the real START/STOP transactions. |
|||
session.viewModel.javaClass.getDeclaredField("configurationRequired").apply { |
|||
isAccessible = true; setBoolean(session.viewModel, false) |
|||
} |
|||
field<MutableStateFlow<DeviceConnectionState>>(session.viewModel.packetRepository, "_connectionState").value = DeviceConnectionState.READY |
|||
instrumentation.runOnMainSync { session.viewModel.startMeasure(30) } |
|||
await { session.viewModel.uiState.value.isMeasuring && starts.get() == 1 } |
|||
assertNotNull(logger.start()) |
|||
assertNotNull(mf4.start()) |
|||
field<CopyOnWriteArrayList<CsvMeasurementLogger>>(session.viewModel, "activeCsvLoggers").add(logger) |
|||
field<CopyOnWriteArrayList<Mf4MeasurementLogger>>(session.viewModel, "activeMf4Loggers").add(mf4) |
|||
val ui = field<MutableStateFlow<MainUiState>>(session.viewModel, "_uiState") |
|||
instrumentation.runOnMainSync { |
|||
ui.value = ui.value.copy(recordingState = MeasurementRecordingState.RECORDING, |
|||
recordingStartedAtMillis = System.currentTimeMillis(), recordingSampleCount = 0, packetCount = 0) |
|||
} |
|||
await { session.executionState.value.recording } |
|||
fun transmit(first: Int, last: Int) { |
|||
for (value in first..last) { |
|||
val frame = codec.encode(DctPacket(0xA4.toByte(), byteArrayOf(1, 0, 1, 0, 0, value.toByte(), 0, 0))) |
|||
// Also check a fragmented frame while using the production parser/writer. |
|||
if (value % 7 == 0) { |
|||
send(peer.get(), frame.copyOfRange(0, 3)) |
|||
send(peer.get(), frame.copyOfRange(3, frame.size)) |
|||
} else send(peer.get(), frame) |
|||
SystemClock.sleep(33) |
|||
} |
|||
await { acknowledgements.get() == last && ui.value.recordingSampleCount == last.toLong() } |
|||
assertEquals(last.toDouble(), series.buffer.getLatestValue()!!, 0.0001) |
|||
} |
|||
transmit(1, 10) |
|||
val original = session.viewModel |
|||
scenario.recreate() |
|||
assertSame(original, app.session.viewModel) |
|||
scenario.moveToState(Lifecycle.State.CREATED) |
|||
instrumentation.runOnMainSync { session.onUiStopped() } |
|||
transmit(11, 40) |
|||
assertTrue(session.serviceRunning.value) |
|||
if (screenOff) shell("input keyevent KEYCODE_SLEEP") |
|||
transmit(41, 60) |
|||
assertEquals(60, series.buffer.toList().count { it.second.isFinite() }) |
|||
val notifications = app.getSystemService(NotificationManager::class.java).activeNotifications |
|||
notifications.firstOrNull { it.id == MeasurementForegroundService.NOTIFICATION_ID }?.let { |
|||
assertTrue(it.notification.flags and Notification.FLAG_ONGOING_EVENT != 0) |
|||
assertEquals("DCT · 계측 및 기록 중", it.notification.extras.getString(Notification.EXTRA_TITLE)) |
|||
} // Drawer visibility is user-controlled; do not grant notification permission silently. |
|||
assertTrue(heldWakeLocks().contains("DCT:MeasurementSession")) |
|||
val notification = MeasurementForegroundService.createNotification(app, session.executionState.value) |
|||
assertEquals("DCT · 계측 및 기록 중", notification.extras.getString(Notification.EXTRA_TITLE)) |
|||
assertTrue(notification.flags and Notification.FLAG_ONGOING_EVENT != 0) |
|||
assertEquals(listOf("계측 정지", "연결 해제"), notification.actions.map { it.title.toString() }) |
|||
notification.actions[0].actionIntent.send() |
|||
await { !ui.value.isMeasuring && stops.get() == 1 } |
|||
assertTrue(session.viewModel.wifiSocketManager.isConnected.value) |
|||
assertTrue(session.serviceRunning.value) |
|||
// Validate sample rows independently of the multi-row header. |
|||
assertEquals(60, logger.outputFile!!.readLines().count { |
|||
Regex("^[0-9]+\\.[0-9]+,").containsMatchIn(it) |
|||
}) |
|||
val mf4Bytes = mf4.outputFile!!.readBytes() |
|||
fun block(name: String) = (0..mf4Bytes.size - 4).first { |
|||
mf4Bytes.copyOfRange(it, it + 4).contentEquals(name.toByteArray(Charsets.US_ASCII)) |
|||
} |
|||
val binary = ByteBuffer.wrap(mf4Bytes).order(ByteOrder.LITTLE_ENDIAN) |
|||
assertEquals(60L, binary.getLong(block("##CG") + 80)) |
|||
val dataBlock = block("##DT") |
|||
assertEquals(24L + 60 * 16, binary.getLong(dataBlock + 8)) |
|||
assertEquals(60.0, binary.getDouble(dataBlock + 24 + 59 * 16 + 8), 0.0001) |
|||
instrumentation.runOnMainSync { session.viewModel.startMeasure(30) } |
|||
await { ui.value.isMeasuring && starts.get() == 2 } |
|||
notification.actions[1].actionIntent.send() |
|||
await { !session.viewModel.wifiSocketManager.isConnected.value && !session.serviceRunning.value } |
|||
if (!screenOff) assertFalse(heldWakeLocks().contains("DCT:MeasurementSession")) |
|||
// Screen-off may disconnect wireless ADB/UiAutomation. Check cleanup via |
|||
// serviceRunning above and via dumpsys after reconnect; the awake test checks OS-held locks. |
|||
assertNull(peerError.get()) |
|||
} finally { |
|||
if (screenOff) shell("input keyevent KEYCODE_WAKEUP") |
|||
server.close() |
|||
peer.get()?.close() |
|||
instrumentation.runOnMainSync { session.onUiStopped(); session.viewModel.disconnectCommunication() } |
|||
logger.stop() |
|||
mf4.stop() |
|||
scenario.close() |
|||
peerThread.join(2000) |
|||
// Delete only this test's uniquely named cache fixture, never project/measurement data. |
|||
directory.deleteRecursively() |
|||
} |
|||
} |
|||
|
|||
private fun send(socket: Socket, bytes: ByteArray) = synchronized(socket) { |
|||
socket.getOutputStream().apply { write(bytes); flush() } |
|||
} |
|||
|
|||
private fun await(condition: () -> Boolean) { |
|||
val deadline = SystemClock.elapsedRealtime() + 15_000 |
|||
while (!condition() && SystemClock.elapsedRealtime() < deadline) SystemClock.sleep(25) |
|||
assertTrue("Timed out waiting for session state", condition()) |
|||
} |
|||
|
|||
@Suppress("UNCHECKED_CAST") |
|||
private fun <T> field(owner: Any, name: String): T = owner.javaClass.getDeclaredField(name).run { |
|||
isAccessible = true |
|||
get(owner) as T |
|||
} |
|||
|
|||
private fun shell(command: String): String = instrumentation.uiAutomation.executeShellCommand(command).use { |
|||
android.os.ParcelFileDescriptor.AutoCloseInputStream(it).bufferedReader().readText() |
|||
} |
|||
|
|||
private fun heldWakeLocks(): String { |
|||
val dump = shell("dumpsys power") |
|||
assertTrue("UiAutomation power dump unavailable", dump.contains("Wake Locks:")) |
|||
return dump.substringAfter("Wake Locks:").substringBefore("Suspend Blockers:") |
|||
} |
|||
} |
|||
@ -1,94 +0,0 @@ |
|||
package com.dct.app.background |
|||
|
|||
import androidx.lifecycle.Lifecycle |
|||
import androidx.test.core.app.ActivityScenario |
|||
import androidx.test.core.app.ApplicationProvider |
|||
import androidx.test.platform.app.InstrumentationRegistry |
|||
import com.dct.app.DctApplication |
|||
import com.dct.app.data.repository.DpcProjectManager |
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.model.project.DpcProject |
|||
import com.dct.app.presentation.main.MainActivity |
|||
import com.dct.app.presentation.mdi.MdiWindowType |
|||
import org.junit.Assert.* |
|||
import org.junit.Test |
|||
import java.io.File |
|||
|
|||
/** No equipment connection: keep the Application/process alive across an explicit exit. */ |
|||
class ProgramExitSessionTest { |
|||
private val instrumentation = InstrumentationRegistry.getInstrumentation() |
|||
private val app = ApplicationProvider.getApplicationContext<DctApplication>() |
|||
|
|||
@Test fun explicitExitSavesProjectAndNextLaunchHasEmptyWorkspace() { |
|||
val name = "exit-session-${System.nanoTime()}.dpc" |
|||
val candidates = savedFiles(name) |
|||
val first = ActivityScenario.launch(MainActivity::class.java) |
|||
val previous = app.session |
|||
try { |
|||
first.onActivity { activity -> |
|||
val vm = previous.viewModel |
|||
vm.setCurrentProject(DpcProject(projectFileName = name, vehicleCode = "Exit test")) |
|||
vm.mdiViewModel.addWindow(MdiWindowType.ALPHANUMERICAL) |
|||
vm.chartRenderer.bindSignal("can_1", "Selected signal", AxisPosition.LEFT_0, 0L) |
|||
activity.exitProgram() |
|||
} |
|||
await { first.state == Lifecycle.State.DESTROYED && previous.isClosed } |
|||
val file = candidates.first { it.isFile } |
|||
val saved = file.readBytes() |
|||
ActivityScenario.launch(MainActivity::class.java).use { second -> |
|||
second.onActivity { |
|||
val fresh = app.session |
|||
assertNotSame(previous, fresh) |
|||
assertNotSame(previous.viewModel, fresh.viewModel) |
|||
assertNull(fresh.viewModel.currentProject.value) |
|||
assertNull(fresh.viewModel.uiState.value.projectFileName) |
|||
assertTrue(fresh.viewModel.mdiViewModel.uiState.value.windows.isEmpty()) |
|||
assertTrue(fresh.viewModel.chartRenderer.seriesListFlow.value.isEmpty()) |
|||
assertArrayEquals(saved, file.readBytes()) |
|||
} |
|||
} |
|||
} finally { |
|||
first.close() |
|||
candidates.forEach { it.delete() } // Only this test's uniquely named project copies. |
|||
} |
|||
} |
|||
|
|||
@Test fun recreationAndBackgroundReturnKeepCurrentWorkspace() { |
|||
val name = "retained-session-${System.nanoTime()}.dpc" |
|||
val candidates = savedFiles(name) |
|||
try { |
|||
ActivityScenario.launch(MainActivity::class.java).use { scenario -> |
|||
val retained = app.session |
|||
scenario.onActivity { |
|||
retained.viewModel.setCurrentProject(DpcProject(projectFileName = name)) |
|||
retained.viewModel.mdiViewModel.addWindow(MdiWindowType.ALPHANUMERICAL) |
|||
} |
|||
scenario.recreate() |
|||
scenario.moveToState(Lifecycle.State.CREATED) |
|||
scenario.moveToState(Lifecycle.State.RESUMED) |
|||
scenario.onActivity { |
|||
assertSame(retained, app.session) |
|||
assertEquals(name, retained.viewModel.currentProject.value?.projectFileName) |
|||
assertFalse(retained.viewModel.mdiViewModel.uiState.value.windows.isEmpty()) |
|||
} |
|||
} |
|||
} finally { |
|||
candidates.forEach { it.delete() } |
|||
} |
|||
} |
|||
|
|||
private fun savedFiles(name: String) = listOfNotNull( |
|||
File(DpcProjectManager.getDefaultConfigurationFolder(app), name), |
|||
app.getExternalFilesDir(null)?.let { File(it, "Documents/DCT Work/Configuration/$name") }, |
|||
File(app.filesDir, "Documents/DCT Work/Configuration/$name") |
|||
) |
|||
|
|||
private fun await(condition: () -> Boolean) { |
|||
val end = android.os.SystemClock.elapsedRealtime() + 10_000 |
|||
while (!condition() && android.os.SystemClock.elapsedRealtime() < end) { |
|||
instrumentation.waitForIdleSync() |
|||
Thread.sleep(25) |
|||
} |
|||
assertTrue("Session lifecycle did not finish", condition()) |
|||
} |
|||
} |
|||
@ -1,114 +0,0 @@ |
|||
package com.dct.app.presentation.dialog |
|||
|
|||
import androidx.compose.material3.MaterialTheme |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.ui.geometry.Offset |
|||
import androidx.compose.ui.graphics.toPixelMap |
|||
import androidx.compose.ui.test.ExperimentalTestApi |
|||
import androidx.compose.ui.test.captureToImage |
|||
import androidx.compose.ui.test.click |
|||
import androidx.compose.ui.test.isDialog |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.test.onNodeWithContentDescription |
|||
import androidx.compose.ui.test.onNodeWithText |
|||
import androidx.compose.ui.test.performClick |
|||
import androidx.compose.ui.test.performMouseInput |
|||
import androidx.compose.ui.test.performTouchInput |
|||
import com.dct.app.presentation.project.NewProjectDialog |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
import java.io.File |
|||
|
|||
/** |
|||
* Mouse and pen hover feed the same Compose HoverInteraction state layer. |
|||
* Hovering a non-interactive title must not paint the full-screen dismiss target. |
|||
* Run on a device/emulator; real stylus input still needs tablet verification. |
|||
*/ |
|||
@OptIn(ExperimentalTestApi::class) |
|||
class ProjectDialogHoverTest { |
|||
@get:Rule |
|||
val compose = createComposeRule() |
|||
|
|||
@Test |
|||
fun newProject_hoverDoesNotDimAndOutsideTapStillDismisses() { |
|||
val visible = mutableStateOf(true) |
|||
compose.setContent { |
|||
MaterialTheme { |
|||
if (visible.value) { |
|||
NewProjectDialog(onDismiss = { visible.value = false }, onConfirm = {}) |
|||
} |
|||
} |
|||
} |
|||
|
|||
assertStableHoverAndBodyTap("New project") |
|||
compose.onNode(isDialog()).performTouchInput { click(Offset(2f, 2f)) } |
|||
compose.onNode(isDialog()).assertDoesNotExist() |
|||
} |
|||
|
|||
@Test |
|||
fun openProject_hoverDoesNotDimAndCloseStillWorks() { |
|||
val visible = mutableStateOf(true) |
|||
compose.setContent { |
|||
MaterialTheme { |
|||
if (visible.value) { |
|||
OpenProjectDialog( |
|||
projectFiles = emptyList(), |
|||
onSelectFile = {}, |
|||
onBrowseOther = {}, |
|||
onDismiss = { visible.value = false } |
|||
) |
|||
} |
|||
} |
|||
} |
|||
|
|||
assertStableHoverAndBodyTap("Open Project file") |
|||
compose.onNodeWithContentDescription("Close").performClick() |
|||
compose.onNode(isDialog()).assertDoesNotExist() |
|||
} |
|||
|
|||
@Test |
|||
fun openProjectFileCanBeSubmittedOnlyOnce() { |
|||
var selections = 0 |
|||
compose.setContent { |
|||
MaterialTheme { |
|||
OpenProjectDialog( |
|||
projectFiles = listOf(File("workspace.dpc")), |
|||
onSelectFile = { selections++ }, |
|||
onBrowseOther = {}, |
|||
onDismiss = {} |
|||
) |
|||
} |
|||
} |
|||
|
|||
compose.onNodeWithText("workspace.dpc").performTouchInput { |
|||
click(center) |
|||
click(center) |
|||
} |
|||
compose.runOnIdle { assertEquals(1, selections) } |
|||
} |
|||
|
|||
private fun assertStableHoverAndBodyTap(title: String) { |
|||
val dialog = compose.onNode(isDialog()) |
|||
val before = dialog.captureToImage().toPixelMap() |
|||
val titleNode = compose.onNodeWithText(title, useUnmergedTree = true) |
|||
|
|||
titleNode.performMouseInput { enter(center) } |
|||
// Allow any default hover indication animation to finish before comparing. |
|||
compose.mainClock.advanceTimeBy(500) |
|||
compose.waitForIdle() |
|||
val after = dialog.captureToImage().toPixelMap() |
|||
|
|||
assertEquals(before.width, after.width) |
|||
assertEquals(before.height, after.height) |
|||
for (y in 0 until before.height) { |
|||
for (x in 0 until before.width) { |
|||
assertEquals("Hover changed dialog pixel ($x, $y)", before[x, y], after[x, y]) |
|||
} |
|||
} |
|||
|
|||
titleNode.performMouseInput { exit() } |
|||
titleNode.performTouchInput { click(center) } |
|||
dialog.assertExists() |
|||
} |
|||
} |
|||
@ -1,416 +0,0 @@ |
|||
package com.dct.app.presentation.dialog |
|||
|
|||
import androidx.compose.material3.MaterialTheme |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.ui.semantics.SemanticsProperties |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import com.dct.app.data.communication.* |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
import android.Manifest |
|||
import android.content.pm.PackageManager |
|||
import androidx.test.platform.app.InstrumentationRegistry |
|||
|
|||
class WifiApConnectionUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
private val device = WifiApDevice("DCT_DEVICE", "", -40, WifiApSecurity.WPA2) |
|||
private val state = mutableStateOf(WifiApUiState(enabled = true, permissionGranted = true, |
|||
locationEnabled = true, devices = listOf(device))) |
|||
private var connected: Pair<WifiApDevice, String>? = null |
|||
private var cancelled = 0 |
|||
private var dismissed = false |
|||
private var disconnected = 0 |
|||
private var current = 0 |
|||
private var scanned = 0 |
|||
private var settingsAction: String? = null |
|||
private val endpoint = mutableStateOf(WifiApEndpoint()) |
|||
private val endpointEditable = mutableStateOf(true) |
|||
private val communicationReady = mutableStateOf(false) |
|||
private val socketConnected = mutableStateOf(false) |
|||
private val communicationFailed = mutableStateOf(false) |
|||
private val connectedEndpoint = mutableStateOf<WifiApEndpoint?>(null) |
|||
private var savedEndpoint: WifiApEndpoint? = null |
|||
@Test fun installedAppHasPermissionToRequestTheEquipmentNetwork() { |
|||
val context = InstrumentationRegistry.getInstrumentation().targetContext |
|||
assertEquals(PackageManager.PERMISSION_GRANTED, |
|||
context.checkSelfPermission(Manifest.permission.CHANGE_NETWORK_STATE)) |
|||
} |
|||
private fun show() { |
|||
compose.setContent { MaterialTheme { |
|||
WifiApConnectionContent(state.value, communicationReady.value, socketConnected.value, |
|||
onScan = { scanned++ }, onConnect = { ap, password -> connected = ap to password }, |
|||
onCancel = { cancelled++ }, onDisconnect = { disconnected++ }, |
|||
onCurrent = { current++ }, onPermissions = {}, onSettings = { settingsAction = it }, |
|||
onDismiss = { dismissed = true }, endpoint = endpoint.value, connectedEndpoint = connectedEndpoint.value, |
|||
canEditEndpoint = endpointEditable.value, communicationFailed = communicationFailed.value, |
|||
onEndpointChange = { savedEndpoint = it; endpoint.value = it; true }) |
|||
} } |
|||
} |
|||
|
|||
@Test fun handshakeFailureDoesNotRemainInitializingOrExposePopupProtocolActions() { |
|||
state.value = state.value.copy(phase = WifiApPhase.CONNECTED, selectedSsid = "DCT_DEVICE", |
|||
localAddress = "192.168.4.2", activeNetworkKey = "test", connectedNetworks = listOf( |
|||
ConnectedWifiNetwork("test", "DCT_DEVICE", "192.168.4.2") |
|||
)) |
|||
socketConnected.value = true |
|||
show() |
|||
compose.onNodeWithText("장비 초기화 중…").assertExists() |
|||
compose.runOnIdle { communicationFailed.value = true; socketConnected.value = false } |
|||
compose.onNodeWithText("장비 초기화 중…").assertDoesNotExist() |
|||
compose.onNodeWithText("통신 연결 실패").assertExists() |
|||
compose.onNodeWithTag("wifi:connected-connect").assertDoesNotExist() |
|||
compose.runOnIdle { assertEquals(0, current) } |
|||
} |
|||
@Test fun fixedEndpointAndPasswordFlowReplaceP2pAndManualTcpInputs() { |
|||
show() |
|||
compose.onNodeWithTag("wifi:ap-endpoint").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:ap-password").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:ap-ssid").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:ap-connect").assertDoesNotExist() |
|||
compose.onNodeWithText("Wi-Fi Direct").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:manual-ip").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:manual-port").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:ap:DCT_DEVICE").performClick() |
|||
compose.onNodeWithTag("wifi:ap-connect").assertIsNotEnabled() |
|||
compose.onNodeWithTag("wifi:ap-password").performTextInput("12345678") |
|||
compose.onNodeWithTag("wifi:ap-connect").assertIsEnabled().performClick() |
|||
compose.runOnIdle { assertEquals(device to "12345678", connected) } |
|||
compose.onNodeWithTag("wifi:ap-password").assertDoesNotExist() |
|||
} |
|||
@Test fun closingTheSheetDoesNotCancelTheApLeaseAndPendingConnectionCanBeCancelled() { |
|||
state.value = state.value.copy(phase = WifiApPhase.CONNECTING, selectedSsid = device.ssid) |
|||
show() |
|||
compose.onNodeWithText("연결 취소").assertIsDisplayed().performClick() |
|||
compose.runOnIdle { assertEquals(1, cancelled) } |
|||
compose.onNodeWithText("닫기").assertIsDisplayed().performClick() |
|||
compose.runOnIdle { assertTrue(dismissed); assertEquals(1, cancelled) } |
|||
} |
|||
@Test fun permissionDenialDisablesApRequestButLeavesSettingsAvailable() { |
|||
state.value = state.value.copy(permissionGranted = false) |
|||
show() |
|||
compose.onNodeWithTag("wifi:ap:DCT_DEVICE").assertIsNotEnabled() |
|||
compose.onNodeWithContentDescription("새로고침").assertIsNotEnabled() |
|||
compose.onNodeWithText("권한 허용").assertIsDisplayed().assertIsEnabled() |
|||
compose.onNodeWithContentDescription("더보기").performClick() |
|||
compose.onNodeWithText("네트워크 추가").assertIsNotEnabled() |
|||
compose.onNodeWithText("Wi-Fi 설정").assertIsEnabled().performClick() |
|||
compose.runOnIdle { assertNull(connected) } |
|||
} |
|||
|
|||
@Test fun cancellingPasswordPromptForgetsCredentialsWithoutConnecting() { |
|||
show() |
|||
compose.onNodeWithTag("wifi:ap:DCT_DEVICE").performClick() |
|||
compose.onNodeWithTag("wifi:ap-password").performTextInput("12345678") |
|||
compose.onNodeWithText("취소").performClick() |
|||
compose.onNodeWithTag("wifi:ap:DCT_DEVICE").performClick() |
|||
assertEquals("", compose.onNodeWithTag("wifi:ap-password").fetchSemanticsNode() |
|||
.config[SemanticsProperties.EditableText].text) |
|||
compose.runOnIdle { assertNull(connected); assertEquals(0, cancelled) } |
|||
} |
|||
|
|||
@Test fun advancedInputsAndFixedEndpointAreOnlyInMenuAndDetails() { |
|||
show() |
|||
compose.onNodeWithContentDescription("더보기").performClick() |
|||
compose.onNodeWithText("네트워크 추가").performClick() |
|||
compose.onNodeWithTag("wifi:ap-ssid").performTextInput("HIDDEN_DCT") |
|||
compose.onNodeWithTag("wifi:ap-password").performTextInput("12345678") |
|||
compose.onNodeWithTag("wifi:ap-connect").performClick() |
|||
compose.runOnIdle { assertEquals("HIDDEN_DCT", connected!!.first.ssid) } |
|||
compose.onNodeWithContentDescription("더보기").performClick() |
|||
compose.onNodeWithText("연결 정보").performClick() |
|||
compose.onNodeWithTag("wifi:ap-endpoint").assertTextContains("192.168.4.1:5000", substring = true) |
|||
compose.onNodeWithText("확인").performClick() |
|||
compose.onNodeWithTag("wifi:ap-endpoint").assertDoesNotExist() |
|||
} |
|||
|
|||
@Test fun connectedRowShowsInlineDisconnectWithoutOpeningDetails() { |
|||
state.value = state.value.copy(phase = WifiApPhase.CONNECTED, |
|||
selectedSsid = device.ssid, localAddress = "192.168.4.20") |
|||
show() |
|||
compose.onNodeWithTag("wifi:ap:DCT_DEVICE").assertDoesNotExist() |
|||
val disconnect = compose.onNodeWithTag("wifi:ap-current:disconnect").assertIsDisplayed() |
|||
val name = compose.onNodeWithText(device.ssid, useUnmergedTree = true).fetchSemanticsNode().boundsInRoot |
|||
assertTrue(name.right <= disconnect.fetchSemanticsNode().boundsInRoot.left) |
|||
compose.onNodeWithTag("wifi:ap-current").performClick() |
|||
compose.onNodeWithText("IP 주소: 192.168.4.20").assertIsDisplayed() |
|||
compose.onNodeWithText("통신 재연결").assertDoesNotExist() |
|||
compose.runOnIdle { assertEquals(0, disconnected) } |
|||
compose.onNodeWithText("확인").performClick() |
|||
disconnect.performClick() |
|||
compose.onNodeWithText("IP 주소: 192.168.4.20").assertDoesNotExist() |
|||
compose.runOnIdle { assertEquals(1, disconnected) } |
|||
} |
|||
|
|||
@Test fun alreadyConnectedSystemWifiIsVisibleBeforeTcpAndIsNotRepeatedInScanResults() { |
|||
state.value = state.value.copy(connectedNetworks = listOf( |
|||
ConnectedWifiNetwork("101", device.ssid, "192.168.1.20"))) |
|||
show() |
|||
compose.onNodeWithTag("wifi:connected:101").assertIsDisplayed() |
|||
compose.onNodeWithText("Wi-Fi 연결됨").assertIsDisplayed() |
|||
compose.onNodeWithTag("wifi:ap:DCT_DEVICE").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:ap-current").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:connected:101").performClick() |
|||
compose.onNodeWithText("IP 주소: 192.168.1.20").assertIsDisplayed() |
|||
compose.onNodeWithTag("wifi:ap-password").assertDoesNotExist() |
|||
compose.onNode(hasText("연결 해제") and hasAnyAncestor(hasTestTag("wifi:connected-details"))) |
|||
.assertDoesNotExist() |
|||
compose.onNodeWithText("확인").performClick() |
|||
compose.onNodeWithTag("wifi:connected:101:disconnect").assertIsDisplayed().performClick() |
|||
compose.runOnIdle { assertEquals(android.provider.Settings.ACTION_WIFI_SETTINGS, settingsAction) } |
|||
compose.runOnIdle { assertEquals(0, current); assertNull(connected) } |
|||
} |
|||
|
|||
@Test fun managedNetworkIsShownOnlyOnceAndOtherConnectedWifiRemainsVisible() { |
|||
state.value = state.value.copy(phase = WifiApPhase.CONNECTED, selectedSsid = device.ssid, |
|||
localAddress = "192.168.4.20", activeNetworkKey = "101", connectedNetworks = listOf( |
|||
ConnectedWifiNetwork("101", device.ssid, "192.168.4.20"), |
|||
ConnectedWifiNetwork("102", "Office", "192.168.1.20"))) |
|||
show() |
|||
compose.onNodeWithTag("wifi:ap-current").assertIsDisplayed() |
|||
compose.onNodeWithTag("wifi:connected:101").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:connected:102").assertIsDisplayed() |
|||
compose.onAllNodesWithText("Wi-Fi 연결됨").assertCountEquals(2) |
|||
compose.onNodeWithTag("wifi:ap-current").performClick() |
|||
compose.onNodeWithText("통신 재연결").assertDoesNotExist() |
|||
} |
|||
|
|||
@Test fun listAndDetailsDoNotExposeProtocolConnectButtons() { |
|||
endpoint.value = WifiApEndpoint("192.168.1.100", 6000) |
|||
state.value = state.value.copy(connectedNetworks = listOf( |
|||
ConnectedWifiNetwork("101", device.ssid, "192.168.1.20"))) |
|||
show() |
|||
compose.onNodeWithTag("wifi:connected-connect").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:connected:101").performClick() |
|||
compose.onNode(hasText("접속 설정: 192.168.1.100:6000") and |
|||
hasAnyAncestor(hasTestTag("wifi:connected-details"))).assertIsDisplayed() |
|||
compose.onAllNodes(hasTestTag("wifi:connected-connect") and |
|||
hasAnyAncestor(hasTestTag("wifi:connected-details"))).assertCountEquals(0) |
|||
compose.onNodeWithTag("wifi:ap-password").assertDoesNotExist() |
|||
compose.runOnIdle { assertEquals(0, current); assertNull(connected) } |
|||
compose.onNodeWithText("확인").performClick() |
|||
compose.onNodeWithTag("wifi:connected-connect").assertDoesNotExist() |
|||
compose.runOnIdle { |
|||
assertEquals(0, current); assertEquals(0, disconnected) |
|||
assertFalse(dismissed) |
|||
assertNull(connected); assertEquals(WifiApEndpoint("192.168.1.100", 6000), endpoint.value) |
|||
} |
|||
} |
|||
|
|||
@Test fun popupDoesNotOfferCommunicationEvenWhenNetworkStateChanges() { |
|||
val network = ConnectedWifiNetwork("101", device.ssid, "192.168.1.20") |
|||
val base = state.value.copy(connectedNetworks = listOf(network)) |
|||
state.value = base |
|||
show() |
|||
compose.onNodeWithTag("wifi:connected-connect").assertDoesNotExist() |
|||
listOf(base.copy(permissionGranted = false), base.copy(enabled = false), |
|||
base.copy(phase = WifiApPhase.CONNECTING), |
|||
base.copy(connectedNetworks = emptyList()), |
|||
base.copy(connectedNetworks = listOf(network.copy(localAddress = null))), |
|||
base.copy(connectedNetworks = listOf(network, ConnectedWifiNetwork("102", "Other", "192.168.2.20")))) |
|||
.forEach { unavailable -> |
|||
compose.runOnIdle { state.value = unavailable } |
|||
compose.onNodeWithTag("wifi:connected-connect").assertDoesNotExist() |
|||
} |
|||
compose.runOnIdle { state.value = base; endpointEditable.value = false } |
|||
compose.onNodeWithTag("wifi:connected-connect").assertDoesNotExist() |
|||
compose.runOnIdle { endpointEditable.value = true; communicationReady.value = true } |
|||
compose.onNodeWithTag("wifi:connected-connect").assertDoesNotExist() |
|||
compose.runOnIdle { communicationReady.value = false; socketConnected.value = true } |
|||
compose.onNodeWithTag("wifi:connected-connect").assertDoesNotExist() |
|||
compose.runOnIdle { socketConnected.value = false; endpoint.value = WifiApEndpoint("0.0.0.0", 6000) } |
|||
compose.onNodeWithTag("wifi:connected-connect").assertDoesNotExist() |
|||
compose.runOnIdle { endpoint.value = WifiApEndpoint() } |
|||
compose.onNodeWithTag("wifi:connected-connect").assertDoesNotExist() |
|||
compose.runOnIdle { assertEquals(0, current); assertNull(connected) } |
|||
} |
|||
|
|||
@Test fun wifiOnlyRowShowsConfiguredIpAndPortWithoutClaimingTcpConnection() { |
|||
endpoint.value = WifiApEndpoint("192.168.1.100", 6000) |
|||
state.value = state.value.copy(connectedNetworks = listOf( |
|||
ConnectedWifiNetwork("101", "Office", "192.168.1.20"))) |
|||
show() |
|||
compose.onNodeWithTag("wifi:connected:101:endpoint", useUnmergedTree = true) |
|||
.assertIsDisplayed().assertTextEquals("접속 설정: 192.168.1.100:6000") |
|||
compose.runOnIdle { endpoint.value = WifiApEndpoint("192.168.4.1", 5000) } |
|||
compose.onNodeWithTag("wifi:connected:101:endpoint", useUnmergedTree = true).assertTextEquals("접속 설정: 192.168.4.1:5000") |
|||
compose.onNodeWithText("Wi-Fi 연결됨").assertIsDisplayed() |
|||
compose.runOnIdle { assertEquals(0, current); assertNull(connected) } |
|||
} |
|||
|
|||
@Test fun connectedRowKeepsTheActualPeerWhenNextConnectionSettingsChange() { |
|||
state.value = state.value.copy(phase = WifiApPhase.CONNECTED, selectedSsid = device.ssid, |
|||
localAddress = "192.168.1.20", activeNetworkKey = "101") |
|||
endpoint.value = WifiApEndpoint("192.168.1.100", 7000) |
|||
connectedEndpoint.value = WifiApEndpoint("192.168.1.100", 6000) |
|||
socketConnected.value = true |
|||
show() |
|||
compose.onNodeWithTag("wifi:ap-current:endpoint", useUnmergedTree = true) |
|||
.assertIsDisplayed().assertTextEquals("통신 주소: 192.168.1.100:6000") |
|||
compose.runOnIdle { |
|||
communicationReady.value = true |
|||
endpoint.value = WifiApEndpoint("192.168.4.1", 5000) |
|||
} |
|||
compose.onNodeWithTag("wifi:ap-current:endpoint", useUnmergedTree = true).assertTextEquals("통신 주소: 192.168.1.100:6000") |
|||
compose.runOnIdle { connectedEndpoint.value = null } |
|||
compose.onNodeWithTag("wifi:ap-current:endpoint", useUnmergedTree = true).assertTextEquals("통신 주소 확인 중…") |
|||
compose.runOnIdle { socketConnected.value = false; communicationReady.value = false } |
|||
compose.onNodeWithTag("wifi:ap-current:endpoint", useUnmergedTree = true).assertTextEquals("접속 설정: 192.168.4.1:5000") |
|||
} |
|||
|
|||
@Test fun unknownSystemWifiIsDisplayedWithoutScanResultsAndDisappearsWhenLost() { |
|||
state.value = state.value.copy(permissionGranted = false, devices = emptyList(), |
|||
connectedNetworks = listOf(ConnectedWifiNetwork("101", localAddress = "192.168.1.20"))) |
|||
show() |
|||
compose.onNodeWithTag("wifi:connected:101").assertIsDisplayed().performClick() |
|||
compose.onNodeWithText("IP 주소: 192.168.1.20").assertIsDisplayed() |
|||
compose.runOnIdle { state.value = state.value.copy(connectedNetworks = emptyList()) } |
|||
compose.onNodeWithTag("wifi:connected:101").assertDoesNotExist() |
|||
compose.onNodeWithText("IP 주소: 192.168.1.20").assertDoesNotExist() |
|||
compose.runOnIdle { assertEquals(0, current); assertEquals(0, disconnected) } |
|||
} |
|||
|
|||
@Test fun openNetworkHasNoPasswordAndUnsupportedSecurityUsesSettings() { |
|||
state.value = state.value.copy(devices = listOf(device.copy(security = WifiApSecurity.OPEN))) |
|||
show() |
|||
compose.onNodeWithTag("wifi:ap:DCT_DEVICE").performClick() |
|||
compose.onNodeWithTag("wifi:ap-password").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:ap-connect").assertIsEnabled().performClick() |
|||
compose.runOnIdle { |
|||
assertEquals("", connected!!.second) |
|||
state.value = state.value.copy(devices = listOf(device.copy(security = WifiApSecurity.UNSUPPORTED))) |
|||
} |
|||
compose.onNodeWithTag("wifi:ap:DCT_DEVICE").performClick() |
|||
compose.onNodeWithTag("wifi:ap-connect").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:ap-password").assertDoesNotExist() |
|||
compose.onNodeWithText("Wi-Fi 설정").performClick() |
|||
compose.runOnIdle { assertEquals(android.provider.Settings.ACTION_WIFI_SETTINGS, settingsAction) } |
|||
} |
|||
|
|||
@Test fun longNetworkListScrollsWithoutHidingHeaderOrCloseButton() { |
|||
state.value = state.value.copy(devices = (1..30).map { device.copy(ssid = "DCT_$it") }, |
|||
connectedNetworks = listOf(ConnectedWifiNetwork("101", "Office", "192.168.1.20"))) |
|||
show() |
|||
compose.onNodeWithTag("wifi:ap-list").performScrollToIndex(31) |
|||
compose.onNodeWithTag("wifi:ap:DCT_30").assertIsDisplayed() |
|||
compose.onNodeWithTag("wifi:connected-connect").assertDoesNotExist() |
|||
compose.onNodeWithContentDescription("새로고침").assertIsDisplayed().performClick() |
|||
compose.onNodeWithText("닫기").assertIsDisplayed().performClick() |
|||
compose.runOnIdle { assertEquals(1, scanned); assertTrue(dismissed) } |
|||
} |
|||
|
|||
@Test fun equipmentConnectionScrollsItsMovedRowToTheTop() { |
|||
state.value = state.value.copy(devices = (1..40).map { device.copy(ssid = "DCT_$it") }) |
|||
show() |
|||
compose.onNodeWithTag("wifi:ap-list").performScrollToIndex(40) |
|||
compose.onNodeWithTag("wifi:ap:DCT_40").assertIsDisplayed() |
|||
compose.runOnIdle { |
|||
state.value = state.value.copy(phase = WifiApPhase.CONNECTING, selectedSsid = "DCT_40") |
|||
} |
|||
compose.runOnIdle { |
|||
state.value = state.value.copy(phase = WifiApPhase.CONNECTED, localAddress = "192.168.4.2", |
|||
activeNetworkKey = "equipment", connectedNetworks = listOf( |
|||
ConnectedWifiNetwork("equipment", "DCT_40", "192.168.4.2"))) |
|||
} |
|||
val row = compose.onNodeWithTag("wifi:ap-current").assertIsDisplayed().fetchSemanticsNode().boundsInRoot |
|||
val list = compose.onNodeWithTag("wifi:ap-list").fetchSemanticsNode().boundsInRoot |
|||
assertEquals(list.top, row.top, 1f) |
|||
compose.onNodeWithText("닫기").assertIsDisplayed() |
|||
compose.runOnIdle { assertEquals(0, current); assertEquals(0, disconnected) } |
|||
} |
|||
|
|||
@Test fun systemWifiConnectionScrollsToTopButScanUpdatesKeepManualScroll() { |
|||
state.value = state.value.copy(devices = (1..40).map { device.copy(ssid = "DCT_$it") }) |
|||
show() |
|||
compose.onNodeWithTag("wifi:ap-list").performScrollToIndex(40) |
|||
compose.onNodeWithTag("wifi:ap:DCT_40").assertIsDisplayed() |
|||
compose.runOnIdle { |
|||
state.value = state.value.copy(connectedNetworks = listOf( |
|||
ConnectedWifiNetwork("system", "DCT_40", "192.168.1.20"))) |
|||
} |
|||
val row = compose.onNodeWithTag("wifi:connected:system").assertIsDisplayed().fetchSemanticsNode().boundsInRoot |
|||
val list = compose.onNodeWithTag("wifi:ap-list").fetchSemanticsNode().boundsInRoot |
|||
assertEquals(list.top, row.top, 1f) |
|||
compose.onNodeWithTag("wifi:ap-list").performScrollToIndex(31) |
|||
compose.onNodeWithTag("wifi:ap:DCT_30").assertIsDisplayed() |
|||
compose.runOnIdle { |
|||
state.value = state.value.copy(devices = state.value.devices.map { it.copy(level = it.level - 1) }) |
|||
} |
|||
compose.onNodeWithTag("wifi:ap:DCT_30").assertIsDisplayed() |
|||
compose.runOnIdle { assertEquals(0, current); assertEquals(0, disconnected) } |
|||
} |
|||
|
|||
@Test fun alreadyConnectedWifiActionRemainsAvailableInOverflow() { |
|||
show() |
|||
compose.onNodeWithText("현재 Wi-Fi로 연결").assertDoesNotExist() |
|||
compose.onNodeWithContentDescription("더보기").performClick() |
|||
compose.onNodeWithText("현재 Wi-Fi로 연결").assertIsEnabled().performClick() |
|||
compose.runOnIdle { assertEquals(1, current) } |
|||
} |
|||
|
|||
@Test fun tcpSettingsValidateAndSavePcAddressWithoutConnectingThenRestoreDefault() { |
|||
show() |
|||
compose.onNodeWithContentDescription("더보기").performClick() |
|||
compose.onNodeWithText("IP / 포트 설정").performClick() |
|||
compose.onNodeWithTag("wifi:tcp-guide").assertIsDisplayed().assertTextEquals( |
|||
"장치와 같은 Wi-Fi에 연결한 뒤 장치의 IPv4 주소와 포트를 입력하세요. 기본값은 192.168.4.1:5000입니다.") |
|||
compose.onNodeWithText("PC", substring = true).assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:tcp-ip").performTextReplacement("192.168.1.100") |
|||
compose.onNodeWithTag("wifi:tcp-port").performTextReplacement("65536") |
|||
compose.onNodeWithTag("wifi:tcp-save").assertIsNotEnabled() |
|||
compose.onNodeWithTag("wifi:tcp-connect").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:tcp-port").performTextReplacement("6000") |
|||
compose.onNodeWithTag("wifi:tcp-save").performClick() |
|||
compose.runOnIdle { |
|||
assertEquals(WifiApEndpoint("192.168.1.100", 6000), savedEndpoint) |
|||
assertEquals(0, current) |
|||
} |
|||
compose.onNodeWithContentDescription("더보기").performClick() |
|||
compose.onNodeWithText("연결 정보").performClick() |
|||
compose.onNodeWithTag("wifi:ap-endpoint").assertTextContains("192.168.1.100:6000", substring = true) |
|||
compose.onNodeWithText("IP / 포트 설정").performClick() |
|||
compose.onNodeWithText("장비 기본값").performClick() |
|||
compose.onNodeWithTag("wifi:tcp-save").performClick() |
|||
compose.runOnIdle { assertEquals(WifiApEndpoint(), savedEndpoint) } |
|||
} |
|||
|
|||
@Test fun savingTargetNeverConnectsForCurrentWifiOrConnectedAp() { |
|||
show() |
|||
compose.onNodeWithContentDescription("더보기").performClick() |
|||
compose.onNodeWithText("IP / 포트 설정").performClick() |
|||
compose.onNodeWithTag("wifi:tcp-ip").performTextReplacement("192.168.1.100") |
|||
compose.onNodeWithTag("wifi:tcp-port").performTextReplacement("6000") |
|||
compose.onNodeWithTag("wifi:tcp-connect").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:tcp-save").performClick() |
|||
compose.runOnIdle { |
|||
assertEquals(WifiApEndpoint("192.168.1.100", 6000), savedEndpoint) |
|||
assertEquals(0, current) |
|||
state.value = state.value.copy(phase = WifiApPhase.CONNECTED, |
|||
selectedSsid = "PC LAN", localAddress = "192.168.1.20") |
|||
} |
|||
compose.onNodeWithTag("wifi:ap-current").performClick() |
|||
compose.onNodeWithText("IP / 포트 설정").performClick() |
|||
compose.onNodeWithTag("wifi:tcp-port").performTextReplacement("7000") |
|||
compose.onNodeWithTag("wifi:tcp-connect").assertDoesNotExist() |
|||
compose.onNodeWithTag("wifi:tcp-save").performClick() |
|||
compose.runOnIdle { |
|||
assertEquals(7000, savedEndpoint!!.port) |
|||
assertEquals(0, current) |
|||
} |
|||
} |
|||
|
|||
@Test fun tcpSettingsCancelAndMeasurementGuardPreserveStoredTarget() { |
|||
show() |
|||
compose.onNodeWithContentDescription("더보기").performClick() |
|||
compose.onNodeWithText("IP / 포트 설정").performClick() |
|||
compose.onNodeWithTag("wifi:tcp-ip").performTextReplacement("192.168.1.100") |
|||
compose.onNodeWithText("취소").performClick() |
|||
compose.runOnIdle { |
|||
assertNull(savedEndpoint); assertEquals(WifiApEndpoint(), endpoint.value) |
|||
endpointEditable.value = false |
|||
} |
|||
compose.onNodeWithContentDescription("더보기").performClick() |
|||
compose.onNodeWithText("IP / 포트 설정").assertIsNotEnabled() |
|||
} |
|||
} |
|||
@ -1,69 +0,0 @@ |
|||
package com.dct.app.presentation.dialog |
|||
|
|||
import androidx.compose.material3.MaterialTheme |
|||
import androidx.compose.runtime.getValue |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.runtime.setValue |
|||
import androidx.compose.runtime.SideEffect |
|||
import androidx.compose.material3.Text |
|||
import androidx.compose.foundation.layout.Column |
|||
import androidx.compose.ui.platform.LocalView |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import com.dct.app.data.communication.WifiConnectionMode |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Assert.assertSame |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class WifiConnectionModeUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun changingTabsKeepsTheSameDialogWindowBoundsAndTabPosition() { |
|||
var mode by mutableStateOf(WifiConnectionMode.TCP) |
|||
var windowView: android.view.View? = null |
|||
compose.setContent { MaterialTheme { |
|||
WifiConnectionDialogFrame(mode, true, { mode=it }, {}) { |
|||
val rootView = LocalView.current.rootView |
|||
SideEffect { windowView=rootView } |
|||
// Different content heights must not resize or replace the parent window. |
|||
if (mode == WifiConnectionMode.TCP) Text("AP 목록") else Column { |
|||
repeat(10) { Text("Direct 기기 $it") } |
|||
} |
|||
} |
|||
} } |
|||
val initialWindow = windowView |
|||
val initialBounds = compose.onNodeWithTag("wifi:dialog").fetchSemanticsNode().boundsInRoot |
|||
val tabBounds = compose.onNodeWithTag("wifi-mode:TCP").fetchSemanticsNode().boundsInRoot |
|||
repeat(3) { |
|||
compose.onNodeWithTag("wifi-mode:DIRECT").performClick().assertIsSelected() |
|||
compose.onNodeWithText("Direct 기기 0").assertIsDisplayed() |
|||
compose.onNodeWithText("AP 목록").assertDoesNotExist() |
|||
assertEquals(initialBounds, compose.onNodeWithTag("wifi:dialog").fetchSemanticsNode().boundsInRoot) |
|||
assertEquals(tabBounds, compose.onNodeWithTag("wifi-mode:TCP").fetchSemanticsNode().boundsInRoot) |
|||
compose.runOnIdle { assertSame(initialWindow, windowView) } |
|||
compose.onNodeWithTag("wifi-mode:TCP").performClick().assertIsSelected() |
|||
compose.onNodeWithText("AP 목록").assertIsDisplayed() |
|||
assertEquals(initialBounds, compose.onNodeWithTag("wifi:dialog").fetchSemanticsNode().boundsInRoot) |
|||
compose.runOnIdle { assertSame(initialWindow, windowView) } |
|||
} |
|||
compose.onAllNodes(isDialog()).assertCountEquals(1) |
|||
} |
|||
|
|||
@Test fun tabsSwitchModesAndLockDuringAnActiveLink() { |
|||
var mode by mutableStateOf(WifiConnectionMode.TCP) |
|||
var enabled by mutableStateOf(true) |
|||
var clicks=0 |
|||
compose.setContent { MaterialTheme { |
|||
WifiConnectionModeSelector(mode,enabled) { mode=it; clicks++ } |
|||
} } |
|||
compose.onNodeWithTag("wifi-mode:TCP").assertIsSelected() |
|||
compose.onNodeWithTag("wifi-mode:DIRECT").performClick().assertIsSelected() |
|||
compose.runOnIdle { enabled=false } |
|||
compose.onNodeWithTag("wifi-mode:TCP").assertIsNotEnabled() |
|||
compose.onNodeWithText("Wi-Fi 해제 후 전환할 수 있습니다.").assertIsDisplayed() |
|||
compose.runOnIdle { assertEquals(1,clicks); enabled=true } |
|||
compose.onNodeWithTag("wifi-mode:TCP").performClick().assertIsSelected() |
|||
compose.runOnIdle { assertEquals(2,clicks) } |
|||
} |
|||
} |
|||
@ -1,94 +0,0 @@ |
|||
package com.dct.app.presentation.dialog |
|||
|
|||
import android.net.wifi.p2p.WifiP2pDevice |
|||
import android.net.wifi.p2p.WifiP2pGroup |
|||
import android.net.wifi.p2p.WifiP2pInfo |
|||
import androidx.compose.material3.MaterialTheme |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.graphics.asAndroidBitmap |
|||
import androidx.compose.ui.unit.dp |
|||
import androidx.test.platform.app.InstrumentationRegistry |
|||
import com.dct.app.data.communication.* |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
import java.io.File |
|||
|
|||
class WifiDirectDeviceListUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
private val peer = WifiP2pDevice().apply { |
|||
deviceName = "DCT_TEST_PEER" |
|||
deviceAddress = "02:00:00:00:00:01" |
|||
status = WifiP2pDevice.AVAILABLE |
|||
} |
|||
private val state = mutableStateOf(WifiDirectUiState(phase = WifiDirectPhase.IDLE, enabled = true, |
|||
permissionGranted = true, locationEnabled = true, synchronizedWithOs = true, peers = listOf(peer))) |
|||
private var disconnected = 0 |
|||
private var portSettings = 0 |
|||
private var cancelled = 0 |
|||
private var selected: WifiP2pDevice? = null |
|||
private var refreshed = 0 |
|||
private var dismissed = 0 |
|||
|
|||
private fun link() = WifiDirectLink(WifiP2pInfo().apply { groupFormed = true; isGroupOwner = true }, WifiP2pGroup()) |
|||
private fun show() { |
|||
compose.setContent { MaterialTheme { |
|||
WifiConnectionDialogFrame(WifiConnectionMode.DIRECT, state.value.link == null, {}, {}) { |
|||
WifiDirectDeviceListContent(state.value, 5000, state.value.link == null, |
|||
onPortSettings = { portSettings++ }, onPermissions = {}, onSettings = {}, |
|||
onDisconnect = { disconnected++ }, onCancel = { cancelled++ }, onConnect = { selected=it }, |
|||
onRefresh = { refreshed++ }, onDismiss = { dismissed++ }) |
|||
} |
|||
} } |
|||
} |
|||
|
|||
@Test fun connectedSummaryKeepsStatusUnderNameAndDisconnectOnRightWithRoomForDiscovery() { |
|||
state.value = state.value.copy(phase = WifiDirectPhase.CONNECTED, link = link(), peers = (1..10).map { i -> |
|||
WifiP2pDevice().apply { deviceName="DCT_PEER_$i"; deviceAddress="peer_$i"; status=WifiP2pDevice.AVAILABLE } |
|||
}) |
|||
show() |
|||
val name = compose.onNodeWithText("Wi-Fi Direct 그룹").assertIsDisplayed().fetchSemanticsNode().boundsInRoot |
|||
val status = compose.onNodeWithTag("wifi:state").assertTextEquals("연결됨").fetchSemanticsNode().boundsInRoot |
|||
val disconnect = compose.onNodeWithTag("wifi:direct-disconnect").assertIsEnabled().assertIsDisplayed() |
|||
val row = compose.onNodeWithTag("wifi:direct-current").fetchSemanticsNode().boundsInRoot |
|||
val list = compose.onNodeWithTag("wifi:direct-list").assertIsDisplayed().fetchSemanticsNode().boundsInRoot |
|||
assertTrue(status.top >= name.bottom) |
|||
assertTrue(name.right <= disconnect.fetchSemanticsNode().boundsInRoot.left) |
|||
with(compose.density) { |
|||
assertTrue("Connected summary should fit one compact row", row.height <= 64.dp.toPx()) |
|||
assertTrue("Discovery list must remain usable after connecting", list.height >= 200.dp.toPx()) |
|||
} |
|||
compose.onAllNodesWithText("연결됨").assertCountEquals(1) |
|||
compose.onNodeWithText("DCT_PEER_1").assertIsDisplayed() |
|||
compose.onNodeWithText("포트 설정").assertIsNotEnabled() |
|||
val bitmap = compose.onNodeWithTag("wifi:dialog").captureToImage().asAndroidBitmap() |
|||
File(InstrumentationRegistry.getInstrumentation().targetContext.cacheDir, "wifi-direct-compact.png") |
|||
.outputStream().use { bitmap.compress(android.graphics.Bitmap.CompressFormat.PNG, 100, it) } |
|||
disconnect.performClick() |
|||
compose.runOnIdle { assertEquals(1, disconnected); assertNull(selected) } |
|||
} |
|||
|
|||
@Test fun disconnectingShowsProgressInTheSameRowAndBlocksRepeatedDisconnect() { |
|||
state.value = state.value.copy(phase = WifiDirectPhase.DISCONNECTING, link = link()) |
|||
show() |
|||
compose.onNodeWithTag("wifi:state").assertTextEquals("연결 해제 중…") |
|||
compose.onNodeWithTag("wifi:direct-disconnect").assertIsNotEnabled().performClick() |
|||
compose.runOnIdle { assertEquals(0, disconnected) } |
|||
compose.onNodeWithText("닫기").assertIsDisplayed() |
|||
} |
|||
|
|||
@Test fun compactLayoutRetainsConnectCancelPortAndFooterActions() { |
|||
show() |
|||
compose.onNodeWithText("포트 설정").assertIsEnabled().performClick() |
|||
compose.onNodeWithText("연결").assertIsEnabled().performClick() |
|||
compose.runOnIdle { assertEquals(1, portSettings); assertSame(peer, selected) } |
|||
compose.runOnIdle { state.value=state.value.copy(phase=WifiDirectPhase.CONNECTING, target=peer) } |
|||
compose.onNodeWithText("취소").assertIsEnabled().performClick() |
|||
compose.runOnIdle { assertEquals(1, cancelled); state.value=state.value.copy(phase=WifiDirectPhase.IDLE, target=null) } |
|||
compose.onNodeWithText("새로고침").assertIsEnabled().performClick() |
|||
compose.onNodeWithText("닫기").performClick() |
|||
compose.runOnIdle { assertEquals(1, refreshed); assertEquals(1, dismissed) } |
|||
} |
|||
} |
|||
@ -1,51 +0,0 @@ |
|||
package com.dct.app.presentation.dialog |
|||
|
|||
import androidx.compose.material3.MaterialTheme |
|||
import androidx.compose.runtime.getValue |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.runtime.setValue |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class WifiDirectPortUiTest { |
|||
@get:Rule val compose=createComposeRule() |
|||
@Test fun default5000CanBeChangedAndSaved() { |
|||
var visible by mutableStateOf(true) |
|||
var saved:Int?=null |
|||
compose.setContent { MaterialTheme { |
|||
if (visible) WifiDirectPortDialog(5000,true,{ saved=it; true },{ visible=false }) |
|||
} } |
|||
compose.onNodeWithTag("wifi-direct-port").assertTextContains("5000").performTextReplacement("6000") |
|||
compose.onNodeWithText("저장").performClick() |
|||
compose.onNodeWithText("Direct 포트 설정").assertDoesNotExist() |
|||
compose.runOnIdle { assertEquals(6000,saved) } |
|||
} |
|||
|
|||
@Test fun invalidPortsAreRejectedAndCancelDoesNotSave() { |
|||
var calls=0 |
|||
var visible by mutableStateOf(true) |
|||
compose.setContent { MaterialTheme { |
|||
if (visible) WifiDirectPortDialog(5000,true,{ calls++; true },{ visible=false }) |
|||
} } |
|||
for (invalid in listOf("","0","65536","abc","999999999999999")) { |
|||
compose.onNodeWithTag("wifi-direct-port").performTextReplacement(invalid) |
|||
compose.onNodeWithText("저장").assertIsNotEnabled() |
|||
compose.onNodeWithText("1~65535 사이의 숫자를 입력하세요.").assertIsDisplayed() |
|||
} |
|||
compose.onNodeWithText("취소").performClick() |
|||
compose.runOnIdle { assertEquals(0,calls) } |
|||
} |
|||
|
|||
@Test fun activeCommunicationDisablesSavingAndRejectedSaveKeepsDialogOpen() { |
|||
var canEdit by mutableStateOf(false) |
|||
compose.setContent { MaterialTheme { WifiDirectPortDialog(5000,canEdit,{ false },{}) } } |
|||
compose.onNodeWithText("저장").assertIsNotEnabled() |
|||
compose.runOnIdle { canEdit=true } |
|||
compose.onNodeWithText("저장").performClick() |
|||
compose.onNodeWithText("통신 상태가 변경되어 저장하지 못했습니다. 연결을 해제한 뒤 다시 시도하세요.").assertIsDisplayed() |
|||
compose.onNodeWithText("Direct 포트 설정").assertIsDisplayed() |
|||
} |
|||
} |
|||
@ -1,67 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.layout.Box |
|||
import androidx.compose.foundation.layout.size |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.geometry.Offset |
|||
import androidx.compose.ui.platform.testTag |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.unit.dp |
|||
import com.dct.app.domain.model.chart.ChartRenderSnapshot |
|||
import com.dct.app.presentation.chart.MultiXGraphCanvas |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class ChartNavigationUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun doubleTapInvokesTheLatestResetCallbackForBothGraphTypesWithoutPanning() { |
|||
val multiAxis = mutableStateOf(false) |
|||
val version = mutableStateOf(1) |
|||
var lastResetVersion = 0 |
|||
var pans = 0 |
|||
compose.setContent { |
|||
val capturedVersion = version.value |
|||
Box(Modifier.size(500.dp, 300.dp).testTag("graph")) { |
|||
MultiXGraphCanvas(ChartRenderSnapshot(0.0, 60.0, emptyList(), emptyMap(), legendPosition = 3), |
|||
isMultiAxis = multiAxis.value, onResetPan = { lastResetVersion = capturedVersion }, |
|||
onPanTime = { pans++ }) |
|||
} |
|||
} |
|||
for (multi in listOf(false, true)) { |
|||
compose.runOnIdle { multiAxis.value = multi; lastResetVersion = 0 } |
|||
// Recompose without restarting the pointerInput key: the callback must not go stale. |
|||
compose.runOnIdle { version.value++ } |
|||
compose.onNodeWithTag("graph").performTouchInput { doubleClick(center) } |
|||
compose.runOnIdle { assertEquals(version.value, lastResetVersion); assertEquals(0, pans) } |
|||
} |
|||
} |
|||
|
|||
@Test fun tinyFingerMovementKeepsTapWhileRealDragsPanInBothDirections() { |
|||
val pans = mutableListOf<Double>() |
|||
compose.setContent { |
|||
Box(Modifier.size(500.dp, 300.dp).testTag("graph")) { |
|||
MultiXGraphCanvas(ChartRenderSnapshot(0.0, 60.0, emptyList(), emptyMap(), legendPosition = 3), |
|||
onPanTime = { pans.add(it) }) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("graph").performTouchInput { |
|||
down(center) |
|||
moveTo(center + Offset(1f, 0f)) |
|||
up() |
|||
} |
|||
compose.runOnIdle { assertTrue(pans.isEmpty()) } |
|||
compose.onNodeWithTag("graph").performTouchInput { |
|||
advanceEventTime(500) |
|||
swipe(center, center + Offset(100f, 0f), 300) |
|||
} |
|||
compose.runOnIdle { assertTrue(pans.sum() < 0.0); pans.clear() } |
|||
compose.onNodeWithTag("graph").performTouchInput { |
|||
swipe(center, center - Offset(100f, 0f), 300) |
|||
} |
|||
compose.runOnIdle { assertTrue(pans.sum() > 0.0) } |
|||
} |
|||
} |
|||
@ -1,167 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.background |
|||
import androidx.compose.foundation.layout.* |
|||
import androidx.compose.material3.MaterialTheme |
|||
import androidx.compose.runtime.* |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.graphics.Color |
|||
import androidx.compose.ui.graphics.toPixelMap |
|||
import androidx.compose.ui.platform.LocalDensity |
|||
import androidx.compose.ui.platform.testTag |
|||
import androidx.compose.ui.semantics.SemanticsActions |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.text.TextLayoutResult |
|||
import androidx.compose.ui.unit.Density |
|||
import androidx.compose.ui.unit.dp |
|||
import com.dct.app.domain.model.mdb.* |
|||
import com.dct.app.presentation.signaltree.* |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class CompensationLayoutUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
private fun map(typeA: Boolean) = CompensationMap( |
|||
if (typeA) CompensationMapType.TYPE_A else CompensationMapType.TYPE_B, |
|||
1, "Y", 0, MdbAttrType.ATTR_3_INT16, 0.0, 100.0, |
|||
"X", 0, MdbAttrType.ATTR_3_INT16, 1.0, 0.0, |
|||
points = listOf(MapPoint(0, 0, -100, -50.0), MapPoint(1, 100, 200, 150.0)) |
|||
) |
|||
|
|||
@Test fun mapHeadersFitAtLargeFontScaleAndNarrowWidthForBothTypes() { |
|||
val typeA = mutableStateOf(true) |
|||
compose.setContent { |
|||
val density = LocalDensity.current |
|||
CompositionLocalProvider(LocalDensity provides Density(density.density, 2f)) { |
|||
MaterialTheme { |
|||
CompensationTable(compensationMapColumns(typeA.value), listOf(map(typeA.value)), |
|||
"test:map", Modifier.size(280.dp, 140.dp), onRowClick = { _, _ -> }) |
|||
} |
|||
} |
|||
} |
|||
for (a in listOf(true, false)) { |
|||
compose.runOnIdle { typeA.value = a } |
|||
for (column in compensationMapColumns(a)) { |
|||
compose.onNodeWithText(column.title).performScrollTo().assertIsDisplayed() |
|||
val layouts = mutableListOf<TextLayoutResult>() |
|||
compose.onNodeWithText(column.title).performSemanticsAction(SemanticsActions.GetTextLayoutResult) { it(layouts) } |
|||
assertTrue(column.title, layouts.isNotEmpty()) |
|||
assertFalse(column.title, layouts.single().hasVisualOverflow) |
|||
} |
|||
} |
|||
} |
|||
|
|||
@Test fun pointHeadersScrollInsteadOfShrinkingAndRetainRowClick() { |
|||
val typeA = mutableStateOf(true) |
|||
var clicked = -1 |
|||
compose.setContent { |
|||
MaterialTheme { |
|||
CompensationTable(compensationPointColumns(typeA.value), map(typeA.value).points, |
|||
"test:point", Modifier.size(120.dp, 140.dp), onRowClick = { index, _ -> clicked = index }) |
|||
} |
|||
} |
|||
for (a in listOf(true, false)) { |
|||
compose.runOnIdle { typeA.value = a } |
|||
for (column in compensationPointColumns(a)) { |
|||
compose.onNodeWithText(column.title).performScrollTo().assertIsDisplayed() |
|||
val layouts = mutableListOf<TextLayoutResult>() |
|||
compose.onNodeWithText(column.title).performSemanticsAction(SemanticsActions.GetTextLayoutResult) { it(layouts) } |
|||
assertFalse(layouts.single().hasVisualOverflow) |
|||
} |
|||
} |
|||
compose.onNodeWithText("-50").performClick() |
|||
compose.runOnIdle { assertEquals(0, clicked) } |
|||
} |
|||
|
|||
@Test fun blankDescriptionCanBeEditedAndSavedWhileEditorStillHasFocus() { |
|||
val rows = mutableStateOf(listOf(map(true).copy(description = ""))) |
|||
val visible = mutableStateOf(true) |
|||
var descriptionInProject = "" |
|||
compose.setContent { |
|||
if (visible.value) MaterialTheme { |
|||
CompensationTable(compensationMapColumns(true), rows.value, "test:edit", |
|||
Modifier.size(280.dp, 140.dp), onRowClick = { _, _ -> }, |
|||
onDescriptionChange = { _, text -> |
|||
descriptionInProject = text |
|||
rows.value = listOf(rows.value.single().copy(description = text)) |
|||
}) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("test:edit:description:0").performScrollTo().performClick() |
|||
compose.onNode(hasSetTextAction()).performTextReplacement("새 보정 설명") |
|||
compose.onNode(hasSetTextAction()).assertIsFocused() |
|||
compose.runOnIdle { |
|||
val project = com.dct.app.domain.model.project.DpcProject( |
|||
parameterDescriptions = mapOf("map_TYPE_A:Y" to descriptionInProject)) |
|||
val json = com.dct.app.data.repository.DpcProjectManager.serializeProjectToJson(project) |
|||
assertEquals("새 보정 설명", com.dct.app.data.repository.DpcProjectManager |
|||
.parseProjectFromJson(json, null).parameterDescriptions["map_TYPE_A:Y"]) |
|||
} |
|||
compose.onNode(hasSetTextAction()).performTextClearance() |
|||
compose.runOnIdle { assertEquals("", descriptionInProject); visible.value = false } |
|||
compose.runOnIdle { assertEquals("", descriptionInProject) } |
|||
} |
|||
|
|||
@Test fun curvesCoincidentWithEachAxisRemainVisibleForBothTypes() { |
|||
val current = mutableStateOf(map(true)) |
|||
compose.setContent { |
|||
CompensationCurveCanvas(current.value, Modifier.size(300.dp, 200.dp) |
|||
.background(Color.White).testTag("edge-curve")) |
|||
} |
|||
val edges = listOf( |
|||
listOf(0 to 0, 50 to 0, 100 to 0), |
|||
listOf(0 to 100, 50 to 100, 100 to 100), |
|||
listOf(0 to 0, 0 to 50, 100 to 100), |
|||
listOf(0 to 0, 100 to 50, 100 to 100) |
|||
) |
|||
for (a in listOf(true, false)) for ((edge, points) in edges.withIndex()) { |
|||
compose.runOnIdle { |
|||
current.value = map(a).copy(points = points.mapIndexed { i, (x, y) -> |
|||
MapPoint(i, x, y, if (a) x.toDouble() else y.toDouble()) |
|||
}) |
|||
} |
|||
val pixels = compose.onNodeWithTag("edge-curve").captureToImage().toPixelMap() |
|||
val b = compensationPlotBounds(pixels.width.toFloat(), pixels.height.toFloat())!! |
|||
var edgePixels = 0 |
|||
for (y in 0 until pixels.height) for (x in 0 until pixels.width) { |
|||
val c = pixels[x, y] |
|||
val colored = if (a) c.red > 0.6f && c.green < 0.4f && c.blue < 0.4f |
|||
else c.blue > 0.6f && c.green < 0.4f && c.red < 0.4f |
|||
val nearEdge = when (edge) { |
|||
0 -> y >= b.bottom - 2f && y < b.bottom |
|||
1 -> y >= b.top && y < b.top + 2f |
|||
2 -> x >= b.left && x < b.left + 2f |
|||
else -> x >= b.right - 2f && x < b.right |
|||
} |
|||
if (colored && nearEdge) edgePixels++ |
|||
} |
|||
assertTrue("Type A=$a, edge=$edge must remain visible", edgePixels > 10) |
|||
} |
|||
} |
|||
|
|||
@Test fun compensationCurvePixelsNeverEscapePlotFrame() { |
|||
val typeA = mutableStateOf(true) |
|||
compose.setContent { |
|||
CompensationCurveCanvas(map(typeA.value), Modifier.size(300.dp, 200.dp) |
|||
.background(Color.White).testTag("curve")) |
|||
} |
|||
for (a in listOf(true, false)) { |
|||
compose.runOnIdle { typeA.value = a } |
|||
val pixels = compose.onNodeWithTag("curve").captureToImage().toPixelMap() |
|||
val bounds = compensationPlotBounds(pixels.width.toFloat(), pixels.height.toFloat())!! |
|||
var curvePixels = 0 |
|||
for (y in 0 until pixels.height) for (x in 0 until pixels.width) { |
|||
val c = pixels[x, y] |
|||
val isCurve = if (a) c.red > 0.6f && c.green < 0.4f && c.blue < 0.4f |
|||
else c.blue > 0.6f && c.green < 0.4f && c.red < 0.4f |
|||
if (isCurve) { |
|||
curvePixels++ |
|||
assertTrue("Curve escaped at $x,$y", x >= bounds.left && x < bounds.right && y >= bounds.top && y < bounds.bottom) |
|||
} |
|||
} |
|||
assertTrue("Curve must actually be rendered", curvePixels > 0) |
|||
} |
|||
} |
|||
} |
|||
@ -1,115 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.layout.* |
|||
import androidx.compose.material3.MaterialTheme |
|||
import androidx.compose.runtime.* |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.platform.LocalDensity |
|||
import androidx.compose.ui.semantics.SemanticsActions |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.text.TextLayoutResult |
|||
import androidx.compose.ui.unit.Density |
|||
import androidx.compose.ui.unit.dp |
|||
import com.dct.app.domain.model.mdb.* |
|||
import com.dct.app.presentation.signaltree.* |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class ConstantWindowUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
private val constant = MdbConstant(1, "Torque", 350.0, 0x1000, 0.0, 500.0, MdbAttrType.ATTR_2_UINT16) |
|||
|
|||
@Test fun onlyValueCellOpensEditorAndNackPreservesInputUntilRetry() { |
|||
var completion: ((String?) -> Unit)? = null |
|||
val rows = mutableStateOf(listOf(constant)) |
|||
compose.setContent { |
|||
MaterialTheme { |
|||
WindowsClassicConstantTableWindow(rows.value, modifier = Modifier.size(550.dp, 300.dp), |
|||
canRequestDevice = true, onValueChange = { _, _, done -> completion = done }) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("constant:name:1").performTouchInput { click() } |
|||
compose.onNodeWithTag("constant:input").assertDoesNotExist() |
|||
compose.onNodeWithTag("constant:value:1").performClick() |
|||
compose.onNodeWithTag("constant:input").performTextReplacement("400.5") |
|||
compose.onNodeWithTag("constant:write").assertIsNotEnabled() |
|||
compose.onNodeWithTag("constant:input").performTextReplacement("400") |
|||
compose.onNodeWithTag("constant:write").performClick() |
|||
compose.onNodeWithText("장비 응답 대기 중").assertIsDisplayed() |
|||
compose.onNodeWithTag("constant:write").assertIsNotEnabled() |
|||
compose.runOnIdle { completion!!("NACK") } |
|||
compose.onNodeWithText("NACK").assertIsDisplayed() |
|||
compose.onNodeWithTag("constant:input").assert(SemanticsMatcher.expectValue(androidx.compose.ui.semantics.SemanticsProperties.EditableText, androidx.compose.ui.text.AnnotatedString("400"))) |
|||
compose.onNodeWithTag("constant:write").performClick() |
|||
compose.runOnIdle { rows.value = listOf(constant.copy(data = 400.0)); completion!!(null) } |
|||
compose.onNodeWithText("장비에 값을 반영했습니다.").assertIsDisplayed() |
|||
} |
|||
|
|||
@Test fun deviceButtonsAreDisabledUntilReadyAndReadRefreshesEditor() { |
|||
val ready = mutableStateOf(false) |
|||
val rows = mutableStateOf(listOf(constant)) |
|||
compose.setContent { |
|||
MaterialTheme { |
|||
WindowsClassicConstantTableWindow(rows.value, modifier = Modifier.size(550.dp, 300.dp), |
|||
canRequestDevice = ready.value, onRead = { _, done -> rows.value = listOf(constant.copy(data = 401.0)); done(null) }) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("constant:value:1").performClick() |
|||
compose.onNodeWithTag("constant:read").assertIsNotEnabled() |
|||
compose.runOnIdle { ready.value = true } |
|||
compose.onNodeWithTag("constant:read").performClick() |
|||
compose.onNodeWithTag("constant:input").assert(SemanticsMatcher.expectValue(androidx.compose.ui.semantics.SemanticsProperties.EditableText, androidx.compose.ui.text.AnnotatedString("401"))) |
|||
} |
|||
|
|||
@Test fun expandedHeadersFitAtLargeFontAndCheckedFilterRestores() { |
|||
var saved = emptyMap<String, String>() |
|||
val visible = mutableStateOf(true) |
|||
compose.setContent { |
|||
val density = LocalDensity.current |
|||
CompositionLocalProvider(LocalDensity provides Density(density.density, 1.5f)) { |
|||
if (visible.value) MaterialTheme { |
|||
WindowUiStateProvider("constant", saved, { saved = it }) { |
|||
WindowsClassicConstantTableWindow(listOf(constant, constant.copy(idx = 2, name = "RPM")), |
|||
modifier = Modifier.size(340.dp, 300.dp)) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
compose.onNodeWithText("Expand").performClick() |
|||
for (key in listOf("name", "value", "desc", "min", "max", "addr")) { |
|||
compose.onNodeWithTag("constant:header:$key").performScrollTo() |
|||
val title = when (key) { "desc" -> "Description"; "addr" -> "Address"; else -> key.replaceFirstChar { it.uppercase() } } |
|||
val layouts = mutableListOf<TextLayoutResult>() |
|||
compose.onNodeWithText(title).performSemanticsAction(SemanticsActions.GetTextLayoutResult) { it(layouts) } |
|||
assertFalse(title, layouts.single().hasVisualOverflow) |
|||
} |
|||
compose.onNodeWithTag("constant:check:2").performScrollTo().performClick() |
|||
compose.onNodeWithTag("constant:only-checked").performClick() |
|||
compose.onNodeWithTag("constant:name:1").assertDoesNotExist() |
|||
compose.runOnIdle { visible.value = false } |
|||
compose.waitForIdle() |
|||
compose.runOnIdle { visible.value = true } |
|||
compose.onNodeWithText("Collapse").assertExists() |
|||
compose.onNodeWithTag("constant:only-checked").assertIsOn() |
|||
compose.onNodeWithTag("constant:check:2").assertIsOn() |
|||
compose.onNodeWithTag("constant:name:1").assertDoesNotExist() |
|||
} |
|||
|
|||
@Test fun emptyDescriptionCommitsBeforeFocusIsLost() { |
|||
val rows = mutableStateOf(listOf(constant)) |
|||
var savedDescription = "" |
|||
compose.setContent { |
|||
MaterialTheme { |
|||
WindowsClassicConstantTableWindow(rows.value, modifier = Modifier.size(550.dp, 300.dp), |
|||
onDescriptionChange = { _, text -> savedDescription = text; rows.value = listOf(constant.copy(description = text)) }) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("constant:desc:1").performTouchInput { click(center) } |
|||
compose.onNode(hasSetTextAction() and isFocused()).performTextReplacement("상수 설명") |
|||
compose.runOnIdle { assertEquals("상수 설명", savedDescription) } |
|||
compose.onNode(hasSetTextAction() and isFocused()).performTextClearance() |
|||
compose.runOnIdle { assertEquals("", savedDescription) } |
|||
} |
|||
} |
|||
@ -1,26 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.material3.MaterialTheme |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class DebugValueResetUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun resetActionIsVisibleOnlyInDebugAndInvokesItsOwnCallback() { |
|||
val debug = mutableStateOf(false) |
|||
var clicks = 0 |
|||
compose.setContent { MaterialTheme { |
|||
DebugValueResetButton(isDebugBuild = debug.value, onClick = { clicks++ }) |
|||
} } |
|||
compose.onNodeWithText("값 초기화").assertDoesNotExist() |
|||
compose.runOnIdle { debug.value = true } |
|||
compose.onNodeWithText("값 초기화").assertIsDisplayed().assertIsEnabled().performClick() |
|||
compose.runOnIdle { assertEquals(1, clicks); debug.value = false } |
|||
compose.onNodeWithText("값 초기화").assertDoesNotExist() |
|||
} |
|||
} |
|||
@ -1,32 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.runtime.getValue |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.runtime.setValue |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class DeveloperOptionsDialogUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun switchShowsCurrentSettingAndChangesItWithoutClosingTheDialog() { |
|||
var enabled by mutableStateOf(true) |
|||
var visible by mutableStateOf(true) |
|||
val changes = mutableListOf<Boolean>() |
|||
compose.setContent { |
|||
if (visible) DeveloperOptionsDialog(enabled, { enabled = it; changes += it }, { visible = false }) |
|||
} |
|||
compose.onNodeWithText("개발자 옵션").assertIsDisplayed() |
|||
compose.onNodeWithTag("ReceiveAutoRecoverySwitch").assertIsOn().performClick() |
|||
compose.onNodeWithTag("ReceiveAutoRecoverySwitch").assertIsOff() |
|||
compose.onNodeWithText("꺼짐").assertIsDisplayed() |
|||
compose.onNodeWithTag("ReceiveAutoRecoverySwitch").performClick().assertIsOn() |
|||
compose.onNodeWithText("켜짐").assertIsDisplayed() |
|||
compose.runOnIdle { assertEquals(listOf(false, true), changes) } |
|||
compose.onNodeWithText("닫기").performClick() |
|||
compose.onNodeWithText("개발자 옵션").assertDoesNotExist() |
|||
} |
|||
} |
|||
@ -1,42 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import com.dct.app.core.theme.SignalColorPresets |
|||
import com.dct.app.domain.model.formula.FormulaDefinition |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class FormulaColorUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun all24PresetsExistAndNewPresetIsSavedInPcFormat() { |
|||
var saved: FormulaDefinition? = null |
|||
compose.setContent { |
|||
FormulaEditDialog(initialFormula = FormulaDefinition(name = "F", expression = "2"), |
|||
onDismiss = {}, onSave = { saved = it }) |
|||
} |
|||
SignalColorPresets.colors.forEach { color -> |
|||
compose.onNodeWithTag("FormulaColorPreset_${color.toString(16).padStart(6, '0')}").assertExists() |
|||
} |
|||
val color = SignalColorPresets.colors.last() |
|||
compose.onNodeWithTag("FormulaColorPreset_${color.toString(16).padStart(6, '0')}").performScrollTo().performClick() |
|||
compose.onNodeWithText("저장").performScrollTo().performClick() |
|||
compose.runOnIdle { assertEquals(color, saved?.color) } |
|||
} |
|||
|
|||
@Test fun customColorPickerOpensAndCancelLeavesOriginalColor() { |
|||
var saved: FormulaDefinition? = null |
|||
val initial = SignalColorPresets.colors.first() |
|||
compose.setContent { |
|||
FormulaEditDialog(initialFormula = FormulaDefinition(name = "F", expression = "2", color = initial), |
|||
onDismiss = {}, onSave = { saved = it }) |
|||
} |
|||
compose.onNodeWithText("사용자 지정 색상").performScrollTo().performClick() |
|||
compose.onNodeWithText("Signal Color").assertExists() |
|||
compose.onNodeWithText("Cancel").performClick() |
|||
compose.onNodeWithText("저장").performScrollTo().performClick() |
|||
compose.runOnIdle { assertEquals(initial, saved?.color) } |
|||
} |
|||
} |
|||
@ -1,258 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.layout.Box |
|||
import androidx.compose.foundation.layout.size |
|||
import androidx.compose.runtime.* |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.geometry.Offset |
|||
import androidx.compose.ui.geometry.Rect |
|||
import androidx.compose.ui.semantics.SemanticsProperties |
|||
import androidx.compose.ui.semantics.SemanticsActions |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.unit.dp |
|||
import androidx.compose.ui.graphics.toPixelMap |
|||
import com.dct.app.core.theme.SignalColorPresets |
|||
import com.dct.app.domain.model.formula.FormulaDefinition |
|||
import com.dct.app.presentation.chart.DraggedSignal |
|||
import com.dct.app.presentation.chart.SignalDragDropManager |
|||
import com.dct.app.presentation.signaltree.WindowUiStateProvider |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class FormulaColumnsUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
private val formula = FormulaDefinition(id = "f", name = "Long Formula Name", expression = "Torque*2", unit = "kW") |
|||
|
|||
@Test fun nameAndColorAreSeparateAndEveryColumnSharesHeaderAndRowWidth() { |
|||
val widths = linkedMapOf("name" to "170.0", "value" to "90.0", "unit" to "65.0", "color" to "70.0", "expression" to "180.0") |
|||
compose.setContent { |
|||
WindowUiStateProvider("formula", widths.mapKeys { "width:${it.key}" }, {}) { |
|||
Box(Modifier.size(1000.dp, 300.dp)) { |
|||
FormulaWindowContent(listOf(formula), onAddFormula = {}, onUpdateFormula = {}, onDeleteFormula = {}) |
|||
} |
|||
} |
|||
} |
|||
compose.onNodeWithTag("FormulaCell_name_f", useUnmergedTree = true).onChildren().filterToOne(hasText(formula.name)).assertExists() |
|||
compose.onNodeWithTag("FormulaCell_unit_f", useUnmergedTree = true).onChildren().filterToOne(hasText(formula.unit)).assertExists() |
|||
compose.onNodeWithText("Expand").assertDoesNotExist() |
|||
compose.onNodeWithText("Collapse").assertDoesNotExist() |
|||
compose.onNodeWithText("Act").assertDoesNotExist() |
|||
compose.onNodeWithTag("FormulaHeader_act").assertDoesNotExist() |
|||
compose.onNodeWithTag("FormulaCell_act_f", useUnmergedTree = true).assertDoesNotExist() |
|||
compose.onNodeWithTag("FormulaActions_f").assertIsDisplayed() |
|||
widths.forEach { (key, width) -> |
|||
compose.onNodeWithTag("FormulaHeader_$key").assertWidthIsEqualTo(width.toFloat().dp) |
|||
compose.onNodeWithTag("FormulaCell_${key}_f", useUnmergedTree = true).assertWidthIsEqualTo(width.toFloat().dp) |
|||
} |
|||
val keys = widths.keys.toList() |
|||
keys.zipWithNext().forEach { (left, right) -> |
|||
val leftHeader = compose.onNodeWithTag("FormulaHeader_$left").fetchSemanticsNode().boundsInRoot |
|||
val rightHeader = compose.onNodeWithTag("FormulaHeader_$right").fetchSemanticsNode().boundsInRoot |
|||
val leftCell = compose.onNodeWithTag("FormulaCell_${left}_f", useUnmergedTree = true).fetchSemanticsNode().boundsInRoot |
|||
val rightCell = compose.onNodeWithTag("FormulaCell_${right}_f", useUnmergedTree = true).fetchSemanticsNode().boundsInRoot |
|||
assertTrue("Header order: $left before $right", leftHeader.left < rightHeader.left) |
|||
assertTrue("Row order: $left before $right", leftCell.left < rightCell.left) |
|||
} |
|||
} |
|||
|
|||
@Test fun actionsStayPinnedWhileHorizontalAndVerticalScrolling() { |
|||
val rows = (0..20).map { formula.copy(id = "f$it", name = "Formula $it") } |
|||
compose.setContent { |
|||
WindowUiStateProvider("formula", mapOf("width:expression" to "1200.0", "width:act" to "1200.0"), {}) { |
|||
Box(Modifier.size(300.dp, 250.dp)) { |
|||
FormulaWindowContent(rows, onAddFormula = {}, onUpdateFormula = {}, onDeleteFormula = {}) |
|||
} |
|||
} |
|||
} |
|||
val before = compose.onNodeWithTag("FormulaActions_f0").fetchSemanticsNode().boundsInRoot |
|||
compose.onNodeWithText("Act").assertDoesNotExist() |
|||
compose.onNodeWithTag("FormulaActions_f0").assertWidthIsEqualTo(48.dp).assertHeightIsEqualTo(48.dp).assertIsDisplayed() |
|||
compose.onNodeWithTag("FormulaViewport_f0").performTouchInput { swipeLeft(durationMillis = 200) } |
|||
val after = compose.onNodeWithTag("FormulaActions_f0").fetchSemanticsNode().boundsInRoot |
|||
assertEquals(before, after) |
|||
val headerScroll = compose.onNodeWithTag("FormulaHeaderViewport").fetchSemanticsNode() |
|||
.config[SemanticsProperties.HorizontalScrollAxisRange].value() |
|||
val rowScroll = compose.onNodeWithTag("FormulaViewport_f0").fetchSemanticsNode() |
|||
.config[SemanticsProperties.HorizontalScrollAxisRange].value() |
|||
assertTrue(headerScroll > 0f) |
|||
assertEquals(headerScroll, rowScroll, 1f) |
|||
compose.onNodeWithTag("FormulaHeaderViewport").performSemanticsAction(SemanticsActions.ScrollBy) { it(10000f, 0f) } |
|||
val expressionEnd = compose.onNodeWithTag("FormulaCell_expression_f0", useUnmergedTree = true).fetchSemanticsNode().boundsInRoot.right |
|||
val maskStart = compose.onNodeWithTag("FormulaMenuBackdrop_f0").fetchSemanticsNode().boundsInRoot.left |
|||
assertTrue("Last expression must scroll clear of the fade mask", expressionEnd <= maskStart + 1f) |
|||
val finalScroll = compose.onNodeWithTag("FormulaHeaderViewport").fetchSemanticsNode() |
|||
.config[SemanticsProperties.HorizontalScrollAxisRange].value() |
|||
compose.onNodeWithTag("FormulaRows").performScrollToIndex(10) |
|||
compose.onNodeWithTag("FormulaActions_f10").assertIsDisplayed() |
|||
val scrolled = compose.onNodeWithTag("FormulaActions_f10").fetchSemanticsNode().boundsInRoot |
|||
assertEquals(before.left, scrolled.left, 1f) |
|||
assertEquals(before.right, scrolled.right, 1f) |
|||
assertEquals(finalScroll, compose.onNodeWithTag("FormulaViewport_f10").fetchSemanticsNode() |
|||
.config[SemanticsProperties.HorizontalScrollAxisRange].value(), 1f) |
|||
compose.onNodeWithTag("FormulaActions_f10").performClick() |
|||
compose.onNodeWithText("수식 삭제").performClick() |
|||
compose.onNodeWithText("‘Formula 10’ 수식을 삭제하시겠습니까?").assertExists() |
|||
} |
|||
|
|||
@Test fun menuBackdropSoftensTextAreaAndMatchesEachRowBackground() { |
|||
val rows = listOf(formula, formula.copy(id = "second", name = "Second")) |
|||
compose.setContent { |
|||
Box(Modifier.size(300.dp, 250.dp)) { |
|||
FormulaWindowContent(rows, onAddFormula = {}, onUpdateFormula = {}, onDeleteFormula = {}) |
|||
} |
|||
} |
|||
compose.onNodeWithText("Act").assertDoesNotExist() |
|||
rows.forEachIndexed { index, row -> |
|||
val backdrop = compose.onNodeWithTag("FormulaMenuBackdrop_${row.id}") |
|||
backdrop.assertWidthIsEqualTo(82.dp) |
|||
val pixels = backdrop.captureToImage().toPixelMap() |
|||
val fade = pixels[(pixels.width * 0.25f).toInt(), (pixels.height * 0.15f).toInt()] |
|||
val opaque = pixels[(pixels.width * 0.65f).toInt(), (pixels.height * 0.15f).toInt()] |
|||
// The Color cell below the transition still tints the fade, but never the button area. |
|||
assertTrue(fade.blue > fade.red + 0.01f) |
|||
val expected = if (index == 0) androidx.compose.ui.graphics.Color.White else androidx.compose.ui.graphics.Color(0xFFF8F9FA) |
|||
assertEquals(expected.red, opaque.red, 0.01f) |
|||
assertEquals(expected.green, opaque.green, 0.01f) |
|||
assertEquals(expected.blue, opaque.blue, 0.01f) |
|||
compose.onNodeWithTag("FormulaActions_${row.id}").assertIsDisplayed() |
|||
} |
|||
} |
|||
|
|||
@Test fun actionMenuEditsWithoutDeletingAndDeleteRequiresConfirmation() { |
|||
var updated: FormulaDefinition? = null |
|||
val deleted = mutableListOf<FormulaDefinition>() |
|||
compose.setContent { |
|||
Box(Modifier.size(300.dp, 250.dp)) { |
|||
FormulaWindowContent(listOf(formula), onAddFormula = {}, onUpdateFormula = { updated = it }, |
|||
onDeleteFormula = { deleted.add(it) }) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("FormulaActions_f").performClick() |
|||
compose.onNodeWithText("수식 수정").performClick() |
|||
compose.onNodeWithText("저장").performScrollTo().performClick() |
|||
compose.runOnIdle { assertEquals(formula, updated); assertTrue(deleted.isEmpty()) } |
|||
compose.onNodeWithTag("FormulaActions_f").performClick() |
|||
compose.onNodeWithText("수식 삭제").performClick() |
|||
compose.runOnIdle { assertTrue(deleted.isEmpty()) } |
|||
compose.onNodeWithText("‘${formula.name}’ 수식을 삭제하시겠습니까?").assertExists() |
|||
compose.onNodeWithText("취소").performClick() |
|||
compose.runOnIdle { assertTrue(deleted.isEmpty()) } |
|||
compose.onNodeWithTag("FormulaConfirmDelete").assertDoesNotExist() |
|||
compose.onNodeWithTag("FormulaActions_f").performClick() |
|||
compose.onNodeWithText("수식 삭제").performClick() |
|||
compose.onNodeWithTag("FormulaConfirmDelete").performClick() |
|||
compose.runOnIdle { assertEquals(listOf(formula), deleted) } |
|||
compose.onNodeWithTag("FormulaConfirmDelete").assertDoesNotExist() |
|||
} |
|||
|
|||
@Test fun pendingDeleteTracksLatestDefinitionAndDisappearsIfRemoved() { |
|||
val rows = mutableStateOf(listOf(formula)) |
|||
val deleted = mutableListOf<FormulaDefinition>() |
|||
compose.setContent { |
|||
Box(Modifier.size(300.dp, 250.dp)) { |
|||
FormulaWindowContent(rows.value, onAddFormula = {}, onUpdateFormula = {}, onDeleteFormula = { deleted.add(it) }) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("FormulaActions_f").performClick() |
|||
compose.onNodeWithText("수식 삭제").performClick() |
|||
val changed = formula.copy(name = "Renamed", expression = "Torque*3") |
|||
compose.runOnIdle { rows.value = listOf(changed) } |
|||
compose.onNodeWithText("‘Renamed’ 수식을 삭제하시겠습니까?").assertExists() |
|||
compose.onNodeWithTag("FormulaConfirmDelete").performClick() |
|||
compose.runOnIdle { assertEquals(listOf(changed), deleted) } |
|||
compose.onNodeWithTag("FormulaActions_f").performClick() |
|||
compose.onNodeWithText("수식 삭제").performClick() |
|||
compose.runOnIdle { rows.value = emptyList() } |
|||
compose.onNodeWithTag("FormulaConfirmDelete").assertDoesNotExist() |
|||
compose.runOnIdle { assertEquals(listOf(changed), deleted) } |
|||
} |
|||
|
|||
@Test fun scrolledDataStillLongPressDragsAtTheVisibleTouchPosition() { |
|||
var dropped: DraggedSignal? = null |
|||
var droppedAt: Offset? = null |
|||
compose.setContent { |
|||
Box(Modifier.size(300.dp, 250.dp)) { |
|||
FormulaWindowContent(listOf(formula), onAddFormula = {}, onUpdateFormula = {}, onDeleteFormula = {}, |
|||
onSignalDrop = { dropped = it; droppedAt = SignalDragDropManager.dragPosition }) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("FormulaViewport_f").performTouchInput { swipeLeft(durationMillis = 200) } |
|||
val bounds = compose.onNodeWithTag("FormulaViewport_f").fetchSemanticsNode().boundsInRoot |
|||
compose.runOnIdle { |
|||
SignalDragDropManager.registerDropTarget("formula-regression", Rect(bounds.left, bounds.top, bounds.right, bounds.bottom + 100f)) |
|||
} |
|||
try { |
|||
compose.onNodeWithTag("FormulaViewport_f").performTouchInput { |
|||
down(center) |
|||
advanceEventTime(700) |
|||
moveBy(Offset(0f, 30f)) |
|||
up() |
|||
} |
|||
compose.runOnIdle { |
|||
assertEquals("formula_${formula.name}", dropped?.signalId) |
|||
assertEquals(formula.unit, dropped?.unit) |
|||
assertEquals(bounds.center.x, requireNotNull(droppedAt).x, 1f) |
|||
assertFalse(SignalDragDropManager.isDragging) |
|||
} |
|||
} finally { |
|||
compose.runOnIdle { |
|||
SignalDragDropManager.unregisterDropTarget("formula-regression") |
|||
SignalDragDropManager.cancelDrag() |
|||
} |
|||
} |
|||
} |
|||
|
|||
@Test fun oldColumnSettingsKeepWidthsAndUseDefaultUnitWidth() { |
|||
compose.setContent { |
|||
WindowUiStateProvider("formula", mapOf("width:name" to "140.0", "width:color" to "75.0"), {}) { |
|||
Box(Modifier.size(800.dp, 300.dp)) { |
|||
FormulaWindowContent(listOf(formula.copy(unit = "")), onAddFormula = {}, onUpdateFormula = {}, onDeleteFormula = {}) |
|||
} |
|||
} |
|||
} |
|||
compose.onNodeWithTag("FormulaHeader_name").assertWidthIsEqualTo(140.dp) |
|||
compose.onNodeWithTag("FormulaHeader_color").assertWidthIsEqualTo(75.dp) |
|||
compose.onNodeWithTag("FormulaHeader_unit").assertWidthIsEqualTo(45.dp) |
|||
compose.onNodeWithTag("FormulaCell_unit_f", useUnmergedTree = true).assertWidthIsEqualTo(45.dp) |
|||
compose.onNodeWithTag("FormulaCell_value_f", useUnmergedTree = true).onChildren().filterToOne(hasText("No value")).assertExists() |
|||
compose.onNodeWithText("Expand").assertDoesNotExist() |
|||
} |
|||
|
|||
@Test fun dividerDragChangesOnlyNameWidthAndRestoresAfterRecreation() { |
|||
var saved = emptyMap<String, String>() |
|||
val visible = mutableStateOf(true) |
|||
compose.setContent { |
|||
if (visible.value) WindowUiStateProvider("formula", saved, { saved = it }) { |
|||
Box(Modifier.size(800.dp, 300.dp)) { |
|||
FormulaWindowContent(listOf(formula), onAddFormula = {}, onUpdateFormula = {}, onDeleteFormula = {}) |
|||
} |
|||
} |
|||
} |
|||
compose.onNodeWithTag("FormulaHeader_name").performTouchInput { |
|||
swipe(Offset(right - 3f, centerY), Offset(right + 70f, centerY), 300) |
|||
} |
|||
compose.runOnIdle { assertTrue(saved.getValue("width:name").toFloat() > 110f); assertFalse("width:color" in saved) } |
|||
compose.onNodeWithTag("FormulaCell_name_f", useUnmergedTree = true).assertWidthIsEqualTo(saved.getValue("width:name").toFloat().dp) |
|||
compose.runOnIdle { visible.value = false } |
|||
compose.waitForIdle() |
|||
compose.runOnIdle { visible.value = true } |
|||
compose.onNodeWithTag("FormulaHeader_name").assertWidthIsEqualTo(saved.getValue("width:name").toFloat().dp) |
|||
compose.onNodeWithTag("FormulaCell_name_f", useUnmergedTree = true).assertWidthIsEqualTo(saved.getValue("width:name").toFloat().dp) |
|||
} |
|||
|
|||
@Test fun colorCellAppliesNewColorWithoutChangingNameOrExpression() { |
|||
var updated: FormulaDefinition? = null |
|||
compose.setContent { |
|||
Box(Modifier.size(800.dp, 300.dp)) { |
|||
FormulaWindowContent(listOf(formula), onAddFormula = {}, onUpdateFormula = { updated = it }, onDeleteFormula = {}) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("FormulaCell_color_f", useUnmergedTree = true).onChildren().filterToOne(hasClickAction()).performClick() |
|||
val color = SignalColorPresets.colors.last() |
|||
compose.onNodeWithTag("SignalColorPreset_${color.toString(16).padStart(6, '0')}").performScrollTo().performClick() |
|||
compose.onNodeWithText("Apply").performClick() |
|||
compose.runOnIdle { assertEquals(formula.copy(color = color), updated) } |
|||
} |
|||
} |
|||
@ -1,116 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.layout.Box |
|||
import androidx.compose.foundation.layout.size |
|||
import androidx.compose.runtime.* |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.graphics.toPixelMap |
|||
import androidx.compose.ui.platform.LocalDensity |
|||
import androidx.compose.ui.platform.testTag |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.unit.Density |
|||
import androidx.compose.ui.unit.dp |
|||
import com.dct.app.domain.model.chart.* |
|||
import com.dct.app.presentation.chart.GraphYAxisDialog |
|||
import com.dct.app.presentation.chart.MultiXGraphCanvas |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class GraphSettingsUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
private fun signal() = SeriesRenderData("a", "Signal A", AxisPosition.LEFT_0, 0xFFL, "V", 2f, |
|||
interpolationMode = InterpolationMode.LINEAR, isVisible = true, |
|||
points = listOf(1000.0 to 150.0, 1001.0 to 200.0), latestValue = 200.0, |
|||
minVisibleValue = 150.0, maxVisibleValue = 200.0) |
|||
private fun snapshot() = ChartRenderSnapshot(1000.0, 1001.0, listOf(signal()), |
|||
mapOf(AxisPosition.LEFT_0 to ChartAxisConfig(AxisPosition.LEFT_0, 0.0, 100.0, false)), |
|||
legendPosition = 3, isYAxisAuto = false, isXAxisAuto = false, xAxisPreset = TimeWindowPreset.MANUAL) |
|||
|
|||
@Composable private fun Menu(state: MutableState<ChartRenderSnapshot>, open: MutableState<Boolean>, |
|||
onPreset: (TimeWindowPreset) -> Unit = {}) { |
|||
GraphContextMenu(expanded = open.value, onDismissRequest = { open.value = false }, |
|||
snapshot = state.value, isMultiAxis = true, |
|||
onRemoveSignal = {}, onToggleVisibility = { id -> state.value = state.value.copy( |
|||
seriesList = state.value.seriesList.map { if (it.signalId == id) it.copy(isVisible = !it.isVisible) else it }) }, |
|||
onChangeThickness = { _, _ -> open.value = false }, onChangeDashStyle = { _, _ -> open.value = false }, |
|||
onSelectLegendPosition = { state.value = state.value.copy(legendPosition = it); open.value = false }, |
|||
onSelectTimePreset = { onPreset(it); open.value = false }, onSelectXAxisManual = {}, |
|||
onSelectYAxisAuto = {}, onOpenYAxisSetting = {}, onChangeTitleName = {}, onQuitWindow = {}) |
|||
} |
|||
|
|||
@Test fun autoSubmenuDoesNotApplyUntilSelectionAndReopensAtRoot() { |
|||
val state = mutableStateOf(snapshot()) |
|||
val open = mutableStateOf(true) |
|||
var selected: TimeWindowPreset? = null |
|||
compose.setContent { Menu(state, open) { selected = it } } |
|||
compose.onNodeWithText("X-Axis").performClick() |
|||
compose.onNodeWithText("Auto").performClick() |
|||
compose.runOnIdle { assertNull(selected) } |
|||
compose.onNodeWithText("10s").assertIsDisplayed().performClick() |
|||
compose.runOnIdle { assertEquals(TimeWindowPreset.SEC_10, selected); open.value = true } |
|||
compose.onNodeWithText("X-Axis").assertIsDisplayed() |
|||
compose.onNodeWithText("Thickness").assertIsDisplayed() |
|||
} |
|||
|
|||
@Test fun showHideKeepsSignalAvailableForReshowAndLegendNoneCanBeSelected() { |
|||
val state = mutableStateOf(snapshot()) |
|||
val open = mutableStateOf(true) |
|||
compose.setContent { Menu(state, open) } |
|||
compose.onNodeWithText("Show/Hide").performClick() |
|||
compose.onNodeWithText("Signal A").performClick() |
|||
compose.runOnIdle { assertFalse(state.value.seriesList.single().isVisible) } |
|||
compose.onNodeWithText("Signal A").assertIsDisplayed().performClick() |
|||
compose.runOnIdle { assertTrue(state.value.seriesList.single().isVisible); open.value = false } |
|||
compose.waitForIdle() |
|||
compose.runOnIdle { open.value = true } |
|||
compose.onNodeWithText("Legend").performClick() |
|||
compose.onNodeWithText("None").performClick() |
|||
compose.runOnIdle { assertEquals(3, state.value.legendPosition) } |
|||
} |
|||
|
|||
@Test fun axisDialogUsesPcIntegerBoundsAndRejectsInvalidInputWithoutDismissing() { |
|||
var saved: Pair<Double, Double>? = null |
|||
compose.setContent { |
|||
GraphYAxisDialog("A", 10.9, 99.9, false, {}, { min,max,_ -> saved = min to max }) |
|||
} |
|||
compose.onNodeWithText("10").assertExists() |
|||
compose.onNodeWithText("99").assertExists() |
|||
compose.onAllNodes(hasSetTextAction())[1].performTextReplacement("NaN") |
|||
compose.onNodeWithText("OK").performClick() |
|||
compose.onNodeWithText("Please input the correct min/max value.").assertIsDisplayed() |
|||
compose.runOnIdle { assertNull(saved) } |
|||
compose.onAllNodes(hasSetTextAction())[1].performTextReplacement("99") |
|||
compose.onNodeWithText("OK").performClick() |
|||
compose.runOnIdle { assertEquals(10.0 to 99.0, saved) } |
|||
} |
|||
|
|||
@Test fun outOfRangeCurvesAreClippedInsteadOfFlattenedOntoAxesForBothGraphTypes() { |
|||
val state = mutableStateOf(snapshot()) |
|||
val multi = mutableStateOf(false) |
|||
compose.setContent { |
|||
CompositionLocalProvider(LocalDensity provides Density(1f)) { |
|||
Box(Modifier.size(400.dp, 240.dp).testTag("graph")) { |
|||
MultiXGraphCanvas(state.value, isMultiAxis = multi.value) |
|||
} |
|||
} |
|||
} |
|||
fun redPixels(): Int { |
|||
val pixels = compose.onNodeWithTag("graph").captureToImage().toPixelMap() |
|||
var count = 0 |
|||
for (y in 12..216) for (x in 70..380) { |
|||
val c = pixels[x,y] |
|||
if (c.red > .8f && c.green < .3f && c.blue < .3f) count++ |
|||
} |
|||
return count |
|||
} |
|||
for (isMulti in listOf(false,true)) { |
|||
compose.runOnIdle { multi.value = isMulti; state.value = snapshot() } |
|||
assertEquals(0, redPixels()) |
|||
compose.runOnIdle { state.value = snapshot().copy(seriesList = listOf(signal().copy( |
|||
points = listOf(1000.0 to 0.0, 1001.0 to 0.0)))) } |
|||
assertTrue(redPixels() > 0) // A real on-axis signal must remain visible. |
|||
} |
|||
} |
|||
} |
|||
@ -1,80 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.layout.Row |
|||
import androidx.compose.material3.Text |
|||
import androidx.compose.runtime.CompositionLocalProvider |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.ui.Alignment |
|||
import androidx.compose.ui.platform.LocalLifecycleOwner |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.lifecycle.Lifecycle |
|||
import androidx.lifecycle.LifecycleOwner |
|||
import androidx.lifecycle.LifecycleRegistry |
|||
import com.dct.app.presentation.main.MainUiState |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Assert.assertTrue |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
import java.util.concurrent.atomic.AtomicLong |
|||
|
|||
class MeasurementElapsedTimeUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun timerIsLeftOfPacketsAndTicksWithoutNewPacketsThenClearsAndRestarts() { |
|||
val ui = mutableStateOf(MainUiState(isMeasuring = true, measurementStartedAtElapsedMillis = 1_000L)) |
|||
val clock = AtomicLong(6_000L) |
|||
compose.setContent { |
|||
Row(verticalAlignment = Alignment.CenterVertically) { |
|||
MeasurementElapsedTime(ui.value, nowMillis = clock::get) |
|||
Text("Packets: 0") |
|||
} |
|||
} |
|||
val timer = compose.onNodeWithTag("MeasurementElapsedTime").assertIsDisplayed() |
|||
.assertTextEquals("재생 00:00:05").fetchSemanticsNode().boundsInRoot |
|||
val packets = compose.onNodeWithText("Packets: 0").assertIsDisplayed().fetchSemanticsNode().boundsInRoot |
|||
assertTrue(timer.right <= packets.left) |
|||
assertEquals(timer.center.y, packets.center.y, 2f) |
|||
clock.set(8_500L) |
|||
compose.mainClock.advanceTimeBy(1_100) |
|||
compose.onNodeWithTag("MeasurementElapsedTime").assertTextEquals("재생 00:00:07") |
|||
// The label must reset as soon as measuring ends, even before ViewModel cleanup clears the start. |
|||
compose.runOnIdle { ui.value = ui.value.copy(isMeasuring = false) } |
|||
compose.onNodeWithTag("MeasurementElapsedTime").assertTextEquals("재생 00:00:00") |
|||
clock.set(20_000L) |
|||
compose.mainClock.advanceTimeBy(1_100) |
|||
compose.onNodeWithTag("MeasurementElapsedTime").assertTextEquals("재생 00:00:00") |
|||
clock.set(22_000L) |
|||
compose.runOnIdle { ui.value = ui.value.copy(isMeasuring = true, |
|||
measurementStartedAtElapsedMillis = 20_000L) } |
|||
compose.onNodeWithTag("MeasurementElapsedTime").assertTextEquals("재생 00:00:02") |
|||
} |
|||
|
|||
@Test fun noSuccessfulStartShowsZero() { |
|||
compose.setContent { MeasurementElapsedTime(MainUiState(), nowMillis = { 99_000L }) } |
|||
compose.onNodeWithTag("MeasurementElapsedTime").assertTextEquals("재생 00:00:00") |
|||
} |
|||
|
|||
@Test fun backgroundStopsUiTicksAndResumeIncludesTimeAsleep() { |
|||
class Owner : LifecycleOwner { |
|||
val registry = LifecycleRegistry(this) |
|||
override val lifecycle: Lifecycle get() = registry |
|||
} |
|||
lateinit var owner: Owner |
|||
compose.runOnUiThread { owner = Owner().also { it.registry.currentState = Lifecycle.State.RESUMED } } |
|||
val clock = AtomicLong(6_000L) |
|||
compose.setContent { |
|||
CompositionLocalProvider(LocalLifecycleOwner provides owner) { |
|||
MeasurementElapsedTime(MainUiState(isMeasuring = true, measurementStartedAtElapsedMillis = 1_000L), |
|||
nowMillis = clock::get) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("MeasurementElapsedTime").assertTextEquals("재생 00:00:05") |
|||
compose.runOnIdle { owner.registry.currentState = Lifecycle.State.CREATED } |
|||
clock.set(30_000L) |
|||
compose.mainClock.advanceTimeBy(1_100) |
|||
compose.onNodeWithTag("MeasurementElapsedTime").assertTextEquals("재생 00:00:05") |
|||
compose.runOnIdle { owner.registry.currentState = Lifecycle.State.RESUMED } |
|||
compose.onNodeWithTag("MeasurementElapsedTime").assertTextEquals("재생 00:00:29") |
|||
} |
|||
} |
|||
@ -1,181 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.background |
|||
import androidx.compose.foundation.layout.Row |
|||
import androidx.compose.foundation.layout.height |
|||
import androidx.compose.runtime.CompositionLocalProvider |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.graphics.Color |
|||
import androidx.compose.ui.graphics.ImageBitmap |
|||
import androidx.compose.ui.graphics.toPixelMap |
|||
import androidx.compose.ui.platform.LocalDensity |
|||
import androidx.compose.ui.platform.LocalLifecycleOwner |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.unit.Density |
|||
import androidx.compose.ui.unit.dp |
|||
import androidx.lifecycle.Lifecycle |
|||
import androidx.lifecycle.LifecycleOwner |
|||
import androidx.lifecycle.LifecycleRegistry |
|||
import com.dct.app.presentation.main.MainUiState |
|||
import com.dct.app.presentation.main.MeasurementRecordingState |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Assert.assertTrue |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
import java.util.concurrent.atomic.AtomicLong |
|||
|
|||
class RecordingRibbonButtonUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun elapsedTimeOnlyAppearsForAnActuallyStartedRecording() { |
|||
val state = mutableStateOf(MainUiState()) |
|||
compose.setContent { |
|||
RecordingRibbonLabel(state.value.recordingState, state.value.recordingStartedAtMillis) { 6_000L } |
|||
} |
|||
compose.onNodeWithText("신호 기록").assertIsDisplayed() |
|||
for (phase in listOf(MeasurementRecordingState.IDLE, MeasurementRecordingState.STARTING, |
|||
MeasurementRecordingState.STOPPING, MeasurementRecordingState.ERROR)) { |
|||
compose.runOnIdle { state.value = MainUiState(recordingState = phase, recordingStartedAtMillis = 1_000L) } |
|||
compose.onNodeWithTag("RecordingElapsedTime").assertDoesNotExist() |
|||
} |
|||
compose.runOnIdle { state.value = MainUiState(recordingState = MeasurementRecordingState.RECORDING) } |
|||
compose.onNodeWithTag("RecordingElapsedTime").assertDoesNotExist() |
|||
compose.runOnIdle { state.value = state.value.copy(recordingStartedAtMillis = 1_000L) } |
|||
compose.onNodeWithTag("RecordingElapsedTime").assertTextEquals("00:00:05") |
|||
} |
|||
|
|||
@Test fun timerTicksWithoutPacketsAndRestartUsesNewRecordingStart() { |
|||
val state = mutableStateOf(MainUiState(recordingState = MeasurementRecordingState.RECORDING, |
|||
recordingStartedAtMillis = 1_000L)) |
|||
val clock = AtomicLong(6_000L) |
|||
compose.setContent { |
|||
RecordingRibbonLabel(state.value.recordingState, state.value.recordingStartedAtMillis, clock::get) |
|||
} |
|||
compose.onNodeWithTag("RecordingElapsedTime").assertTextEquals("00:00:05") |
|||
clock.set(8_000L) |
|||
compose.mainClock.advanceTimeBy(1_100) |
|||
compose.onNodeWithTag("RecordingElapsedTime").assertTextEquals("00:00:07") |
|||
compose.runOnIdle { state.value = MainUiState(recordingState = MeasurementRecordingState.IDLE) } |
|||
compose.onNodeWithTag("RecordingElapsedTime").assertDoesNotExist() |
|||
compose.runOnIdle { state.value = MainUiState(recordingState = MeasurementRecordingState.RECORDING, |
|||
recordingStartedAtMillis = 8_000L) } |
|||
compose.onNodeWithTag("RecordingElapsedTime").assertTextEquals("00:00:00") |
|||
} |
|||
|
|||
@Test fun largeFontKeepsTimeBesideLabelAndSeparateFromRecordingButtons() { |
|||
compose.setContent { |
|||
CompositionLocalProvider(LocalDensity provides Density(LocalDensity.current.density, 1.5f)) { |
|||
Row(Modifier.height(44.dp).background(Color.White)) { |
|||
RecordingRibbonLabel(MeasurementRecordingState.RECORDING, 1_000L) { 3_662_000L } |
|||
RecordingRibbonButton("신호 기록 시작", enabled = false, onClick = {}) |
|||
RecordingRibbonButton("신호 기록 중지", enabled = true, isStop = true, onClick = {}) |
|||
} |
|||
} |
|||
} |
|||
val label = compose.onNodeWithText("신호 기록").assertIsDisplayed().fetchSemanticsNode().boundsInRoot |
|||
val time = compose.onNodeWithTag("RecordingElapsedTime").assertIsDisplayed() |
|||
.assertTextEquals("01:01:01").fetchSemanticsNode().boundsInRoot |
|||
val start = compose.onNodeWithContentDescription("신호 기록 시작").assertIsNotEnabled() |
|||
.fetchSemanticsNode().boundsInRoot |
|||
compose.onNodeWithContentDescription("신호 기록 중지").assertIsEnabled() |
|||
assertTrue(label.right <= time.left) |
|||
assertTrue(time.right <= start.left) |
|||
assertEquals(label.center.y, time.center.y, 1f) |
|||
} |
|||
|
|||
@Test fun backgroundStopsUiTicksAndResumeRecomputesElapsedTime() { |
|||
class Owner : LifecycleOwner { |
|||
val registry = LifecycleRegistry(this) |
|||
override val lifecycle: Lifecycle get() = registry |
|||
} |
|||
lateinit var owner: Owner |
|||
compose.runOnUiThread { owner = Owner().also { it.registry.currentState = Lifecycle.State.RESUMED } } |
|||
val clock = AtomicLong(6_000L) |
|||
compose.setContent { |
|||
CompositionLocalProvider(LocalLifecycleOwner provides owner) { |
|||
RecordingRibbonLabel(MeasurementRecordingState.RECORDING, 1_000L, clock::get) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("RecordingElapsedTime").assertTextEquals("00:00:05") |
|||
compose.runOnIdle { owner.registry.currentState = Lifecycle.State.CREATED } |
|||
clock.set(30_000L) |
|||
compose.mainClock.advanceTimeBy(1_100) |
|||
compose.onNodeWithTag("RecordingElapsedTime").assertTextEquals("00:00:05") |
|||
compose.runOnIdle { owner.registry.currentState = Lifecycle.State.RESUMED } |
|||
compose.onNodeWithTag("RecordingElapsedTime").assertTextEquals("00:00:29") |
|||
} |
|||
|
|||
private fun redPixels(image: ImageBitmap): Int { |
|||
val pixels = image.toPixelMap() |
|||
return (0 until image.width).sumOf { x -> |
|||
(0 until image.height).count { y -> |
|||
val c = pixels[x, y] |
|||
c.red > 0.65f && c.green < 0.35f && c.blue < 0.35f |
|||
} |
|||
} |
|||
} |
|||
|
|||
@Test fun startUsesRedFileBadgeAndStopUsesDarkSquare() { |
|||
compose.setContent { |
|||
Row(Modifier.background(Color.White)) { |
|||
RecordingRibbonButton("기록 시작", enabled = true, onClick = {}) |
|||
RecordingRibbonButton("기록 중지", enabled = true, isStop = true, onClick = {}) |
|||
} |
|||
} |
|||
val start = compose.onNodeWithContentDescription("기록 시작").assertIsEnabled().assertHasClickAction() |
|||
val stop = compose.onNodeWithContentDescription("기록 중지").assertIsEnabled().assertHasClickAction() |
|||
val density = compose.density.density |
|||
// A visible 12dp disc has ~113dp² area; the previous 8dp badge had only ~50dp². |
|||
assertTrue("Record dot must retain its enlarged area", redPixels(start.captureToImage()) > 90 * density * density) |
|||
assertEquals(0, redPixels(stop.captureToImage())) |
|||
val image = stop.captureToImage() |
|||
val pixels = image.toPixelMap() |
|||
// The square occupies the lower-right corner of the centered 24dp file icon. |
|||
val cx = (image.width / 2f + 5f * density).toInt() |
|||
val cy = (image.height / 2f + 5f * density).toInt() |
|||
for (dx in listOf(-4, 0, 4)) for (dy in listOf(-4, 0, 4)) { |
|||
val c = pixels[cx + (dx * density).toInt(), cy + (dy * density).toInt()] |
|||
assertTrue("Stop badge must be a filled square", c.red < 0.4f && c.green < 0.4f && c.blue < 0.4f) |
|||
} |
|||
} |
|||
|
|||
@Test fun disabledButtonsHaveNoRedBadgeAndCannotInvokeActions() { |
|||
var clicks = 0 |
|||
compose.setContent { |
|||
Row(Modifier.background(Color.White)) { |
|||
RecordingRibbonButton("기록 시작", enabled = false, onClick = { clicks++ }) |
|||
RecordingRibbonButton("기록 중지", enabled = false, isStop = true, onClick = { clicks++ }) |
|||
} |
|||
} |
|||
for (label in listOf("기록 시작", "기록 중지")) { |
|||
val button = compose.onNodeWithContentDescription(label).assertIsNotEnabled() |
|||
assertEquals(0, redPixels(button.captureToImage())) |
|||
button.performClick() |
|||
} |
|||
compose.runOnIdle { assertEquals(0, clicks) } |
|||
} |
|||
|
|||
@Test fun recordingStateSwitchKeepsSeparateActionsAndDescriptionsAtLargeFont() { |
|||
val recording = mutableStateOf(false) |
|||
var starts = 0 |
|||
var stops = 0 |
|||
compose.setContent { |
|||
CompositionLocalProvider(LocalDensity provides Density(LocalDensity.current.density, 1.3f)) { |
|||
Row(Modifier.background(Color.White)) { |
|||
RecordingRibbonButton("신호 기록 시작", enabled = !recording.value, |
|||
onClick = { starts++; recording.value = true }) |
|||
RecordingRibbonButton("신호 기록 중지", enabled = recording.value, isStop = true, |
|||
onClick = { stops++; recording.value = false }) |
|||
} |
|||
} |
|||
} |
|||
compose.onNodeWithContentDescription("신호 기록 시작").assertIsDisplayed().assertIsEnabled().performClick() |
|||
compose.onNodeWithContentDescription("신호 기록 시작").assertIsNotEnabled() |
|||
compose.onNodeWithContentDescription("신호 기록 중지").assertIsDisplayed().assertIsEnabled().performClick() |
|||
compose.onNodeWithContentDescription("신호 기록 시작").assertIsEnabled() |
|||
compose.onNodeWithContentDescription("신호 기록 중지").assertIsNotEnabled() |
|||
compose.runOnIdle { assertEquals(1, starts); assertEquals(1, stops) } |
|||
} |
|||
} |
|||
@ -1,62 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.horizontalScroll |
|||
import androidx.compose.foundation.layout.Row |
|||
import androidx.compose.foundation.layout.height |
|||
import androidx.compose.foundation.layout.width |
|||
import androidx.compose.foundation.rememberScrollState |
|||
import androidx.compose.material.icons.Icons |
|||
import androidx.compose.material.icons.filled.BarChart |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.platform.LocalDensity |
|||
import androidx.compose.runtime.CompositionLocalProvider |
|||
import androidx.compose.ui.unit.Density |
|||
import androidx.compose.ui.unit.dp |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class RibbonButtonUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun allThreeLabelsRemainClickableAndScrollableWithLargerFont() { |
|||
val labels = listOf("Graph", "Alphanumerical", "MultiAxisGraph") |
|||
val clicks = mutableListOf<String>() |
|||
compose.setContent { |
|||
val density = LocalDensity.current.density |
|||
CompositionLocalProvider(LocalDensity provides Density(density, 1.3f)) { |
|||
Row(Modifier.width(220.dp).height(44.dp).horizontalScroll(rememberScrollState())) { |
|||
labels.forEach { label -> |
|||
RibbonButton(Icons.Default.BarChart, label, label = label, |
|||
onClick = { clicks += label }) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
labels.forEach { label -> |
|||
compose.onNodeWithText(label).performScrollTo().assertIsDisplayed().assertHasClickAction().performClick() |
|||
} |
|||
compose.runOnIdle { assertEquals(labels, clicks) } |
|||
} |
|||
|
|||
@Test fun disabledLabelCannotRunActionAndIconOnlyToolsStayUnchanged() { |
|||
val enabled = mutableStateOf(false) |
|||
var clicks = 0 |
|||
compose.setContent { |
|||
Row { |
|||
RibbonButton(Icons.Default.BarChart, "New Graph Window", label = "Graph", |
|||
enabled = enabled.value, onClick = { clicks++ }) |
|||
RibbonButton(Icons.Default.BarChart, "Save", onClick = { clicks++ }) |
|||
} |
|||
} |
|||
compose.onNodeWithText("Graph").assertIsNotEnabled().performClick() |
|||
compose.runOnIdle { assertEquals(0, clicks); enabled.value = true } |
|||
compose.onNodeWithText("Graph").assertIsEnabled().performClick() |
|||
compose.onNodeWithContentDescription("Save").assertHasClickAction().performClick() |
|||
compose.onNodeWithText("Save").assertDoesNotExist() |
|||
compose.runOnIdle { assertEquals(2, clicks) } |
|||
} |
|||
} |
|||
@ -1,182 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.layout.Box |
|||
import androidx.compose.foundation.layout.offset |
|||
import androidx.compose.material3.Button |
|||
import androidx.compose.material3.Text |
|||
import androidx.compose.runtime.CompositionLocalProvider |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.geometry.Offset |
|||
import androidx.compose.ui.geometry.Rect |
|||
import androidx.compose.ui.graphics.toPixelMap |
|||
import androidx.compose.ui.platform.LocalDensity |
|||
import androidx.compose.ui.platform.ViewRootForTest |
|||
import androidx.compose.ui.semantics.SemanticsActions |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.text.TextLayoutResult |
|||
import androidx.compose.ui.unit.Density |
|||
import androidx.compose.ui.unit.dp |
|||
import com.dct.app.domain.model.chart.InterpolationMode |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
@OptIn(InternalTestApi::class) |
|||
class RibbonSettingsMenuUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
private val expanded = mutableStateOf(false) |
|||
private val formatsEnabled = mutableStateOf(true) |
|||
private val mode = mutableStateOf(InterpolationMode.LINEAR) |
|||
private val csv = mutableStateOf(true) |
|||
private val mf4 = mutableStateOf(false) |
|||
private val autostart = mutableStateOf(false) |
|||
private val csvMilliseconds = mutableStateOf(false) |
|||
private var formatChanges = 0 |
|||
|
|||
private fun showMenu() { |
|||
compose.setContent { |
|||
val density = LocalDensity.current.density |
|||
CompositionLocalProvider(LocalDensity provides Density(density, 1.3f)) { |
|||
// A real parent popup away from (0, 0) catches nested-window coordinate errors. |
|||
Box(Modifier.offset(x = 40.dp, y = 80.dp)) { |
|||
Button(onClick = { expanded.value = true }) { Text("메뉴") } |
|||
RibbonFileMenu(expanded.value, onDismissRequest = { expanded.value = false }) { |
|||
RibbonSettingsMenuCategories( |
|||
menuExpanded = expanded.value, |
|||
graphMode = mode.value, |
|||
recordingFormatsEnabled = formatsEnabled.value, |
|||
writeCsv = csv.value, writeMf4 = mf4.value, |
|||
autostartRecording = autostart.value, recordingFolder = "Data", |
|||
onGraphModeChange = { mode.value = it }, |
|||
onRecordingFormatsChange = { c, m -> csv.value = c; mf4.value = m; formatChanges++ }, |
|||
onAutostartRecordingChange = { autostart.value = it }, |
|||
csvWithMilliseconds = csvMilliseconds.value, |
|||
onCsvWithMillisecondsChange = { csvMilliseconds.value = it }, |
|||
onDismissMenu = { expanded.value = false } |
|||
) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
compose.onNodeWithText("메뉴").performClick() |
|||
} |
|||
|
|||
private fun screenBounds(node: SemanticsNodeInteraction): Rect { |
|||
val semantics = node.fetchSemanticsNode() |
|||
val view = (semantics.root as ViewRootForTest).view |
|||
var bounds = Rect.Zero |
|||
compose.runOnIdle { |
|||
val location = IntArray(2) |
|||
view.getLocationOnScreen(location) |
|||
bounds = semantics.boundsInRoot.translate(Offset(location[0].toFloat(), location[1].toFloat())) |
|||
} |
|||
return bounds |
|||
} |
|||
|
|||
@Test fun allSubmenusAlignWithTheirCategoryInScreenCoordinates() { |
|||
showMenu() |
|||
listOf("Graph Type" to "GRAPH", "Measurement Recording" to "RECORDING", "계측과 함께 측정" to "AUTOSTART", "CSV 밀리초" to "CSV_MILLISECONDS") |
|||
.forEach { (label, category) -> |
|||
compose.onNodeWithText(label).performClick() |
|||
val row = screenBounds(compose.onNodeWithTag("RibbonSettingsCategory_$category")) |
|||
val submenu = screenBounds(compose.onNodeWithTag("RibbonSettingsSubmenu")) |
|||
assertEquals("$label right edge", row.right, submenu.left, 1f) |
|||
assertEquals("$label top edge", row.top, submenu.top, 1f) |
|||
} |
|||
} |
|||
|
|||
@Test fun bothMenuSurfacesHaveAnOpaqueGrayOutline() { |
|||
showMenu() |
|||
compose.onNodeWithText("Graph Type").performClick() |
|||
listOf("RibbonFileMenu", "RibbonSettingsSubmenu").forEach { tag -> |
|||
val pixels = compose.onNodeWithTag(tag).captureToImage().toPixelMap() |
|||
val border = pixels[0, pixels.height / 2] |
|||
assertEquals("$tag red", RibbonMenuBorderColor.red, border.red, 0.04f) |
|||
assertEquals("$tag green", RibbonMenuBorderColor.green, border.green, 0.04f) |
|||
assertEquals("$tag blue", RibbonMenuBorderColor.blue, border.blue, 0.04f) |
|||
assertEquals("$tag opacity", 1f, border.alpha, 0.01f) |
|||
} |
|||
} |
|||
|
|||
@Test fun csvMillisecondsDefaultsFalseAndCanSwitchBothWaysWhileMeasuring() { |
|||
formatsEnabled.value = false |
|||
showMenu() |
|||
compose.onNodeWithText("True").assertDoesNotExist() |
|||
compose.onNodeWithText("False").assertDoesNotExist() |
|||
compose.onNodeWithText("마이크로초").assertDoesNotExist() |
|||
compose.onNodeWithText("CSV 밀리초").assertIsEnabled().performClick() |
|||
compose.onNodeWithTag("CsvMilliseconds_false", useUnmergedTree = true).assertIsSelected() |
|||
compose.onNodeWithTag("CsvMilliseconds_true", useUnmergedTree = true).assertIsNotSelected() |
|||
compose.onNodeWithText("True").performClick() |
|||
compose.runOnIdle { assertEquals(true, csvMilliseconds.value) } |
|||
compose.onNodeWithText("CSV 밀리초").assertDoesNotExist() |
|||
compose.onNodeWithText("메뉴").performClick() |
|||
compose.onNodeWithText("CSV 밀리초").performClick() |
|||
compose.onNodeWithText("False").performClick() |
|||
compose.runOnIdle { assertEquals(false, csvMilliseconds.value) } |
|||
} |
|||
|
|||
@Test fun rootContainsOnlyCategoriesAndGraphSelectionClosesBothMenus() { |
|||
showMenu() |
|||
listOf("Graph Type", "Measurement Recording", "계측과 함께 측정").forEach { |
|||
compose.onNodeWithText(it).assertIsDisplayed() |
|||
} |
|||
listOf("Linear", "Pulse", "Write CSV", "Write MF4", "On", "Off").forEach { |
|||
compose.onNodeWithText(it).assertDoesNotExist() |
|||
} |
|||
compose.onNodeWithText("Graph Type").performClick() |
|||
compose.onNodeWithText("Pulse").assertIsDisplayed().performClick() |
|||
compose.runOnIdle { assertEquals(InterpolationMode.PWM_STEP, mode.value) } |
|||
compose.onNodeWithText("Graph Type").assertDoesNotExist() |
|||
compose.onNodeWithText("메뉴").performClick() |
|||
compose.onNodeWithText("Pulse").assertDoesNotExist() |
|||
} |
|||
|
|||
@Test fun recordingCheckboxesRemainOpenForMultipleSelections() { |
|||
showMenu() |
|||
compose.onNodeWithText("Measurement Recording").performClick() |
|||
compose.onNodeWithText("Write MF4").performClick() |
|||
compose.onNodeWithText("Write CSV").assertIsDisplayed().performClick() |
|||
compose.runOnIdle { |
|||
assertEquals(false, csv.value); assertEquals(true, mf4.value); assertEquals(2, formatChanges) |
|||
} |
|||
compose.onNodeWithText("Folder: Data").assertIsDisplayed() |
|||
} |
|||
|
|||
@Test fun recordingIsVisiblyDisabledAndCannotOpenWhileMeasuring() { |
|||
formatsEnabled.value = false |
|||
showMenu() |
|||
compose.onNodeWithText("Measurement Recording").assertIsNotEnabled().performClick() |
|||
compose.onNodeWithText("Write CSV").assertDoesNotExist() |
|||
compose.onNodeWithText("계측 중 변경 불가").assertDoesNotExist() |
|||
val layouts = mutableListOf<TextLayoutResult>() |
|||
compose.onNodeWithText("Measurement Recording", useUnmergedTree = true) |
|||
.performSemanticsAction(SemanticsActions.GetTextLayoutResult) { it(layouts) } |
|||
assertEquals(ColorTextSecondary.copy(alpha = 0.5f), layouts.single().layoutInput.style.color) |
|||
compose.runOnIdle { assertEquals(0, formatChanges) } |
|||
} |
|||
|
|||
@Test fun measurementStartingClosesAlreadyOpenRecordingSubmenu() { |
|||
showMenu() |
|||
compose.onNodeWithText("Measurement Recording").performClick() |
|||
compose.onNodeWithText("Write CSV").assertIsDisplayed() |
|||
compose.runOnIdle { formatsEnabled.value = false } |
|||
compose.onNodeWithText("Write CSV").assertDoesNotExist() |
|||
compose.onNodeWithText("Measurement Recording").assertIsNotEnabled() |
|||
compose.runOnIdle { formatsEnabled.value = true } |
|||
compose.onNodeWithText("Write CSV").assertDoesNotExist() |
|||
} |
|||
|
|||
@Test fun switchingCategoryReplacesSubmenuAndAutostartSelectionClosesMenu() { |
|||
showMenu() |
|||
compose.onNodeWithText("Graph Type").performClick() |
|||
compose.onNodeWithText("Linear").assertIsDisplayed() |
|||
compose.onNodeWithText("계측과 함께 측정").performClick() |
|||
compose.onNodeWithText("Linear").assertDoesNotExist() |
|||
compose.onNodeWithText("On").assertIsDisplayed().performClick() |
|||
compose.runOnIdle { assertEquals(true, autostart.value) } |
|||
compose.onNodeWithText("계측과 함께 측정").assertDoesNotExist() |
|||
} |
|||
} |
|||
@ -1,102 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.layout.Row |
|||
import androidx.compose.material3.MaterialTheme |
|||
import androidx.compose.runtime.mutableStateOf |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import com.dct.app.data.communication.WifiApPhase |
|||
import com.dct.app.data.communication.WifiApUiState |
|||
import com.dct.app.presentation.main.CommunicationType |
|||
import com.dct.app.presentation.main.MainUiState |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class WifiConnectionRibbonUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun wifiConnectDisconnectAreAdjacentAndActionsRemainSeparateDuringConnection() { |
|||
val ui = mutableStateOf(MainUiState()) |
|||
val canConnect = mutableStateOf(true) |
|||
var wifiClicks = 0 |
|||
var connectClicks = 0 |
|||
var disconnectClicks = 0 |
|||
var wifiDisconnectClicks = 0 |
|||
compose.setContent { MaterialTheme { Row { |
|||
WifiConnectionRibbonButtons(ui.value, WifiApUiState( |
|||
phase = WifiApPhase.CONNECTED, selectedSsid = "DCT", localAddress = "192.168.4.2"), |
|||
canConnect.value, { wifiClicks++ }, { connectClicks++ }, { disconnectClicks++ }, |
|||
{ wifiDisconnectClicks++ }) |
|||
} } } |
|||
val wifi = compose.onNodeWithContentDescription("Wi-Fi AP 연결됨 (DCT)") |
|||
val connect = compose.onNodeWithText("Connect") |
|||
val disconnect = compose.onNodeWithText("Disconnect") |
|||
val wifiDisconnect = compose.onNodeWithContentDescription("Wi-Fi 연결 해제") |
|||
compose.onNodeWithText("Wi-Fi 해제").assertDoesNotExist() |
|||
val wifiBounds = wifi.fetchSemanticsNode().boundsInRoot |
|||
val connectBounds = connect.fetchSemanticsNode().boundsInRoot |
|||
val disconnectBounds = disconnect.fetchSemanticsNode().boundsInRoot |
|||
assertTrue(connectBounds.left >= wifiBounds.right) |
|||
assertTrue(disconnectBounds.left >= connectBounds.right) |
|||
assertEquals(wifiBounds.center.y, connectBounds.center.y, 1f) |
|||
assertEquals(connectBounds.center.y, disconnectBounds.center.y, 1f) |
|||
compose.onAllNodesWithContentDescription("통신 끊기 (Disconnect)").assertCountEquals(1) |
|||
wifiDisconnect.assertIsEnabled() |
|||
disconnect.assertIsNotEnabled() |
|||
wifi.performClick() |
|||
compose.runOnIdle { assertEquals(1, wifiClicks); assertEquals(0, connectClicks) } |
|||
connect.assertIsEnabled().performClick() |
|||
compose.runOnIdle { |
|||
assertEquals(1, connectClicks) |
|||
ui.value = MainUiState(isCommunicationConnecting = true) |
|||
canConnect.value = false |
|||
} |
|||
connect.assertIsNotEnabled() |
|||
disconnect.assertIsEnabled().performClick() |
|||
compose.runOnIdle { |
|||
assertEquals(1, disconnectClicks) |
|||
assertEquals(0, wifiDisconnectClicks) |
|||
ui.value = MainUiState(isConnected = true, communicationType = CommunicationType.WIFI) |
|||
} |
|||
connect.assertIsNotEnabled() |
|||
wifi.assertIsEnabled() |
|||
disconnect.assertIsEnabled() |
|||
disconnect.performClick() |
|||
compose.runOnIdle { |
|||
assertEquals(2, disconnectClicks) |
|||
assertEquals(1, connectClicks) |
|||
assertEquals(1, wifiClicks) |
|||
ui.value = MainUiState() |
|||
canConnect.value = true |
|||
} |
|||
connect.assertIsEnabled() |
|||
disconnect.assertIsNotEnabled() |
|||
wifi.assertIsEnabled() |
|||
wifiDisconnect.assertIsEnabled().performClick() |
|||
compose.runOnIdle { |
|||
assertEquals(1, wifiDisconnectClicks) |
|||
assertEquals(2, disconnectClicks) |
|||
} |
|||
} |
|||
|
|||
@Test fun wifiDisconnectIsAvailableDuringApConnectionButProtocolDisconnectIsNot() { |
|||
val ap = mutableStateOf(WifiApUiState(phase = WifiApPhase.CONNECTING)) |
|||
var wifiDisconnects = 0 |
|||
var protocolDisconnects = 0 |
|||
compose.setContent { MaterialTheme { Row { |
|||
WifiConnectionRibbonButtons(MainUiState(), ap.value, false, {}, {}, |
|||
{ protocolDisconnects++ }, { wifiDisconnects++ }) |
|||
} } } |
|||
compose.onNodeWithText("Disconnect").assertIsNotEnabled() |
|||
compose.onNodeWithText("Wi-Fi 해제").assertDoesNotExist() |
|||
compose.onNodeWithContentDescription("Wi-Fi 연결 해제").assertIsEnabled().performClick() |
|||
compose.runOnIdle { |
|||
assertEquals(1, wifiDisconnects) |
|||
assertEquals(0, protocolDisconnects) |
|||
ap.value = WifiApUiState() |
|||
} |
|||
compose.onNodeWithContentDescription("Wi-Fi 연결 해제").assertIsNotEnabled() |
|||
compose.onNodeWithText("Disconnect").assertIsNotEnabled() |
|||
} |
|||
} |
|||
@ -1,76 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.layout.* |
|||
import androidx.compose.material3.MaterialTheme |
|||
import androidx.compose.runtime.* |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.semantics.SemanticsProperties |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.text.AnnotatedString |
|||
import androidx.compose.ui.unit.dp |
|||
import androidx.test.platform.app.InstrumentationRegistry |
|||
import com.dct.app.data.communication.* |
|||
import com.dct.app.presentation.dialog.WifiManualConnectionForm |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class WifiManualConnectionUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun inputsStartEmptyAndPresetButtonsAreAbsent() { |
|||
compose.setContent { |
|||
MaterialTheme { Box(Modifier.size(480.dp, 500.dp)) { |
|||
WifiManualConnectionForm(WifiConnectionInput(), {}, emptyList(), {}, { _, _ -> }) |
|||
} } |
|||
} |
|||
for (tag in listOf("wifi:manual-ip", "wifi:manual-port")) { |
|||
compose.onNodeWithTag(tag).assert(SemanticsMatcher.expectValue(SemanticsProperties.EditableText, AnnotatedString(""))) |
|||
} |
|||
compose.onNodeWithTag("wifi:manual-connect").assertIsNotEnabled() |
|||
compose.onNodeWithText("SoftAP (192.168.4.1)").assertDoesNotExist() |
|||
compose.onNodeWithText("Local (127.0.0.1)").assertDoesNotExist() |
|||
} |
|||
|
|||
@Test fun latestInputRestoresAfterDismissWithoutConnectingAndClearingPersists() { |
|||
val context = InstrumentationRegistry.getInstrumentation().targetContext |
|||
val prefs = context.getSharedPreferences("wifi_ui_test_${System.nanoTime()}", android.content.Context.MODE_PRIVATE) |
|||
val visible = mutableStateOf(true) |
|||
try { |
|||
compose.setContent { |
|||
if (visible.value) MaterialTheme { |
|||
val store = remember { WifiConnectionPreferences(prefs) } |
|||
var input by remember { mutableStateOf(store.load()) } |
|||
Box(Modifier.size(480.dp, 500.dp)) { |
|||
WifiManualConnectionForm(input, { input = it; store.save(it) }, emptyList(), {}, { _, _ -> fail("No connection expected") }) |
|||
} |
|||
} |
|||
} |
|||
compose.onNodeWithTag("wifi:manual-ip").performTextReplacement("192.168.10.8") |
|||
compose.onNodeWithTag("wifi:manual-port").performTextReplacement("7777") |
|||
compose.runOnIdle { visible.value = false } |
|||
compose.waitForIdle() |
|||
compose.runOnIdle { visible.value = true } |
|||
compose.onNodeWithTag("wifi:manual-ip").assert(SemanticsMatcher.expectValue(SemanticsProperties.EditableText, AnnotatedString("192.168.10.8"))) |
|||
compose.onNodeWithTag("wifi:manual-port").assert(SemanticsMatcher.expectValue(SemanticsProperties.EditableText, AnnotatedString("7777"))) |
|||
compose.onNodeWithTag("wifi:manual-port").performTextClearance() |
|||
compose.runOnIdle { assertEquals("", WifiConnectionPreferences(prefs).load().port) } |
|||
} finally { prefs.edit().clear().commit() } |
|||
} |
|||
|
|||
@Test fun discoveredPcOnlyAppliesOnTapAndConnectionUsesExplicitPort() { |
|||
val input = mutableStateOf(WifiConnectionInput()) |
|||
var endpoint: Pair<String, Int>? = null |
|||
compose.setContent { |
|||
MaterialTheme { Box(Modifier.size(480.dp, 500.dp)) { |
|||
WifiManualConnectionForm(input.value, { input.value = it }, |
|||
listOf(DiscoveredLanServer("Test PC", "192.168.10.8", 7777)), {}, { ip, port -> endpoint = ip to port }) |
|||
} } |
|||
} |
|||
compose.runOnIdle { assertEquals(WifiConnectionInput(), input.value) } |
|||
compose.onNodeWithText("클릭하여 IP와 포트 적용").performClick() |
|||
compose.onNodeWithTag("wifi:manual-connect").performScrollTo().performClick() |
|||
compose.runOnIdle { assertEquals("192.168.10.8" to 7777, endpoint) } |
|||
} |
|||
} |
|||
@ -1,144 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.background |
|||
import androidx.compose.foundation.ScrollState |
|||
import androidx.compose.foundation.layout.* |
|||
import androidx.compose.foundation.rememberScrollState |
|||
import androidx.compose.foundation.text.BasicTextField |
|||
import androidx.compose.foundation.verticalScroll |
|||
import androidx.compose.material3.Button |
|||
import androidx.compose.material3.MaterialTheme |
|||
import androidx.compose.material3.Text |
|||
import androidx.compose.runtime.* |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.graphics.Color |
|||
import androidx.compose.ui.geometry.Offset |
|||
import androidx.compose.ui.platform.testTag |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.unit.dp |
|||
import androidx.compose.ui.zIndex |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
@OptIn(ExperimentalTestApi::class) |
|||
class WindowActivationTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun childButtonRaisesBackWindowOnlyOnSingleFingerReleaseAndStillClicks() { |
|||
var activations = 0 |
|||
var clicks = 0 |
|||
val backZ = mutableStateOf(0f) |
|||
compose.setContent { |
|||
MaterialTheme { |
|||
Box(Modifier.size(300.dp)) { |
|||
Box(Modifier.size(240.dp).zIndex(backZ.value) |
|||
.background(Color.White) |
|||
.bringWindowToFrontOnPress("back") { activations++; backZ.value = 2f }) { |
|||
Button(onClick = { clicks++ }, modifier = Modifier.size(80.dp).testTag("button")) { |
|||
Text("Button") |
|||
} |
|||
} |
|||
Box(Modifier.offset(x = 100.dp, y = 50.dp).size(160.dp) |
|||
.zIndex(1f).background(Color.Blue) |
|||
.bringWindowToFrontOnPress("front") {}) |
|||
} |
|||
} |
|||
} |
|||
compose.onNodeWithTag("button").performTouchInput { down(center) } |
|||
compose.runOnIdle { |
|||
assertEquals(0, activations) |
|||
assertEquals(0f, backZ.value) |
|||
assertEquals(0, clicks) |
|||
} |
|||
compose.onNodeWithTag("button").performTouchInput { up() } |
|||
compose.runOnIdle { assertEquals(1, clicks); assertEquals(1, activations); assertEquals(2f, backZ.value) } |
|||
} |
|||
|
|||
@Test fun scrollingWindowBodyStillScrollsAndActivatesOnlyOnce() { |
|||
var activations = 0 |
|||
lateinit var scroll: androidx.compose.foundation.ScrollState |
|||
compose.setContent { |
|||
scroll = rememberScrollState() |
|||
Box(Modifier.size(240.dp).bringWindowToFrontOnPress("window") { activations++ }) { |
|||
Column(Modifier.fillMaxSize().verticalScroll(scroll).testTag("scroll")) { |
|||
Spacer(Modifier.height(2000.dp).fillMaxWidth()) |
|||
} |
|||
} |
|||
} |
|||
compose.onNodeWithTag("scroll").performTouchInput { swipeUp() } |
|||
compose.runOnIdle { |
|||
assertEquals(1, activations) |
|||
assertTrue(scroll.value > 0) |
|||
} |
|||
} |
|||
|
|||
@Test fun textFieldCanReceiveFocusAndInputAfterWindowActivation() { |
|||
var activations = 0 |
|||
val value = mutableStateOf("") |
|||
compose.setContent { |
|||
Box(Modifier.size(240.dp).bringWindowToFrontOnPress("window") { activations++ }) { |
|||
BasicTextField(value.value, onValueChange = { value.value = it }, |
|||
modifier = Modifier.size(180.dp, 50.dp).testTag("input")) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("input").performTouchInput { click() } |
|||
compose.onNodeWithTag("input").assertIsFocused().performTextInput("RPM") |
|||
compose.runOnIdle { assertEquals(1, activations); assertEquals("RPM", value.value) } |
|||
} |
|||
|
|||
@Test fun hoveringDoesNotRaiseAWindow() { |
|||
var activations = 0 |
|||
compose.setContent { |
|||
Box(Modifier.size(200.dp).testTag("window") |
|||
.bringWindowToFrontOnPress("window") { activations++ }) |
|||
} |
|||
compose.onNodeWithTag("window").performMouseInput { enter(center); moveTo(center); exit() } |
|||
compose.runOnIdle { assertEquals(0, activations) } |
|||
} |
|||
|
|||
@Test fun fingersOnDifferentWindowsNeverChangeZOrderEvenWithoutMovement() { |
|||
val raised = mutableStateOf("") |
|||
compose.setContent { |
|||
val navigation = remember { WorkspaceTouchNavigation() } |
|||
val x = remember { ScrollState(0) } |
|||
val y = remember { ScrollState(0) } |
|||
CompositionLocalProvider(LocalWorkspaceTouchNavigation provides navigation) { |
|||
Box(Modifier.size(300.dp, 200.dp).testTag("workspace") |
|||
.workspaceTouchNavigation(navigation, x, y)) { |
|||
Box(Modifier.size(140.dp, 200.dp).zIndex(if (raised.value == "back") 3f else 0f) |
|||
.testTag("back").bringWindowToFrontOnPress("back") { raised.value = "back" }) |
|||
Box(Modifier.offset(x = 160.dp).size(140.dp, 200.dp) |
|||
.zIndex(if (raised.value == "front") 3f else 1f) |
|||
.bringWindowToFrontOnPress("front") { raised.value = "front" }) |
|||
} |
|||
} |
|||
} |
|||
compose.onNodeWithTag("workspace").performTouchInput { |
|||
down(0, Offset(width * .2f, height * .5f)) |
|||
} |
|||
compose.runOnIdle { assertEquals("", raised.value) } |
|||
compose.onNodeWithTag("workspace").performTouchInput { |
|||
down(1, Offset(width * .8f, height * .5f)) |
|||
up(0) |
|||
} |
|||
compose.runOnIdle { assertEquals("", raised.value) } |
|||
compose.onNodeWithTag("workspace").performTouchInput { up(1) } |
|||
compose.runOnIdle { assertEquals("", raised.value) } |
|||
compose.onNodeWithTag("back").performTouchInput { advanceEventTime(500); click() } |
|||
compose.runOnIdle { assertEquals("back", raised.value) } |
|||
} |
|||
|
|||
@Test fun mousePressStillActivatesImmediatelyWithoutWaitingForRelease() { |
|||
var activations = 0 |
|||
compose.setContent { |
|||
Box(Modifier.size(200.dp).testTag("window") |
|||
.bringWindowToFrontOnPress("window") { activations++ }) |
|||
} |
|||
compose.onNodeWithTag("window").performMouseInput { moveTo(center); press() } |
|||
compose.runOnIdle { assertEquals(1, activations) } |
|||
compose.onNodeWithTag("window").performMouseInput { release() } |
|||
compose.runOnIdle { assertEquals(1, activations) } |
|||
} |
|||
} |
|||
@ -1,76 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.layout.* |
|||
import androidx.compose.material3.* |
|||
import androidx.compose.runtime.* |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.geometry.Offset |
|||
import androidx.compose.ui.platform.testTag |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.unit.dp |
|||
import com.dct.app.domain.model.chart.* |
|||
import com.dct.app.presentation.signaltree.* |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class WindowParityUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun actualGraphContentForwardsTapToCursorCallback() { |
|||
var cursor: Double? = null |
|||
compose.setContent { |
|||
MaterialTheme { |
|||
Box(Modifier.size(600.dp, 300.dp).testTag("graph")) { |
|||
GraphWindowContent( |
|||
snapshot = ChartRenderSnapshot(0.0, 10.0, emptyList(), emptyMap(), legendPosition = 3), |
|||
windowId = "test", onRemoveSignal = {}, onClearAll = {}, |
|||
onCrosshairTimeChange = { cursor = it } |
|||
) |
|||
} |
|||
} |
|||
} |
|||
compose.onNodeWithTag("graph").performTouchInput { click(center) } |
|||
compose.runOnIdle { assertNotNull(cursor); assertTrue(cursor!! in 0.0..10.0) } |
|||
} |
|||
|
|||
@Test fun headerDividerDragResizesWithoutActivatingSort() { |
|||
val width = mutableStateOf(160.dp) |
|||
var sorts = 0 |
|||
compose.setContent { |
|||
Box(Modifier.size(400.dp, 60.dp)) { |
|||
ResizableTableHeaderCell("Name", width.value, {}, Modifier.testTag("header"), |
|||
onWidthChange = { width.value = it }, onClick = { sorts++ }) |
|||
} |
|||
} |
|||
compose.onNodeWithTag("header").performTouchInput { |
|||
swipe(Offset(right - 3f, centerY), Offset(right + 70f, centerY), 300) |
|||
} |
|||
compose.runOnIdle { assertTrue(width.value > 160.dp); assertEquals(0, sorts) } |
|||
} |
|||
|
|||
@Test fun windowPreferencesAreIsolatedAndRestoredAfterDisposal() { |
|||
var saved = emptyMap<String, String>() |
|||
val visible = mutableStateOf(true) |
|||
lateinit var search: MutableState<String> |
|||
lateinit var expanded: MutableState<Boolean> |
|||
lateinit var checked: MutableState<Set<Long>> |
|||
compose.setContent { |
|||
if (visible.value) { |
|||
WindowUiStateProvider("one", saved, { saved = it }) { |
|||
search = rememberWindowString("search") |
|||
expanded = rememberWindowBoolean("expanded") |
|||
checked = rememberWindowChecked("checked") |
|||
Text(search.value, Modifier.testTag("value")) |
|||
} |
|||
} |
|||
} |
|||
compose.runOnIdle { search.value = "RPM"; expanded.value = true; checked.value = setOf(1L, 2L) } |
|||
compose.runOnIdle { visible.value = false } |
|||
compose.waitForIdle() |
|||
compose.runOnIdle { visible.value = true } |
|||
compose.onNodeWithTag("value").assertTextEquals("RPM") |
|||
compose.runOnIdle { assertTrue(expanded.value); assertEquals(setOf(1L, 2L), checked.value) } |
|||
} |
|||
} |
|||
@ -1,534 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.foundation.ScrollState |
|||
import androidx.compose.foundation.clickable |
|||
import androidx.compose.foundation.gestures.detectDragGestures |
|||
import androidx.compose.foundation.gestures.ScrollableDefaults |
|||
import androidx.compose.foundation.verticalScroll |
|||
import androidx.compose.foundation.layout.Box |
|||
import androidx.compose.foundation.layout.size |
|||
import androidx.compose.runtime.CompositionLocalProvider |
|||
import androidx.compose.runtime.DisposableEffect |
|||
import androidx.compose.runtime.remember |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.geometry.Offset |
|||
import androidx.compose.ui.geometry.Rect |
|||
import androidx.compose.ui.input.pointer.pointerInput |
|||
import androidx.compose.ui.input.nestedscroll.NestedScrollConnection |
|||
import androidx.compose.ui.input.nestedscroll.NestedScrollSource |
|||
import androidx.compose.ui.input.nestedscroll.nestedScroll |
|||
import androidx.compose.ui.platform.testTag |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.unit.dp |
|||
import com.dct.app.domain.model.chart.ChartRenderSnapshot |
|||
import com.dct.app.presentation.chart.MultiXGraphCanvas |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class WorkspaceTouchNavigationUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
private lateinit var x: ScrollState |
|||
private lateinit var y: ScrollState |
|||
private var zooms = 0 |
|||
private var pans = 0 |
|||
private var taps = 0 |
|||
private var drags = 0 |
|||
private var activations = 0 |
|||
private lateinit var innerScroll: ScrollState |
|||
private var movingWindowBounds = Rect(-200f, -200f, -100f, -100f) |
|||
|
|||
private fun content( |
|||
graph: Boolean = false, |
|||
multi: Boolean = false, |
|||
header: Boolean = false, |
|||
table: Boolean = false, |
|||
reserveWindowSurface: Boolean = false, |
|||
movingWindowSurface: Boolean = false, |
|||
canvasEnabled: Boolean = true |
|||
) { |
|||
compose.setContent { |
|||
x = remember { ScrollState(if (canvasEnabled) 150 else 0) } |
|||
y = remember { ScrollState(if (canvasEnabled) 150 else 0) } |
|||
innerScroll = remember { ScrollState(10) } |
|||
val navigation = remember { WorkspaceTouchNavigation() } |
|||
val horizontalFling = ScrollableDefaults.flingBehavior() |
|||
val verticalFling = ScrollableDefaults.flingBehavior() |
|||
CompositionLocalProvider(LocalWorkspaceTouchNavigation provides navigation) { |
|||
if (movingWindowSurface) { |
|||
DisposableEffect(navigation) { |
|||
navigation.registerWindowTouchRegion("moving-window") { movingWindowBounds } |
|||
onDispose { navigation.unregisterWindowTouchRegion("moving-window") } |
|||
} |
|||
} |
|||
if (reserveWindowSurface) { |
|||
// Mirrors MdiSubWindow's persistent root-bounds |
|||
// registration. The synthetic window starts at the |
|||
// viewport origin and is larger than the viewport. |
|||
DisposableEffect(navigation) { |
|||
navigation.registerWindowTouchRegion("test-window") { |
|||
Rect(0f, 0f, 900f, 700f) |
|||
} |
|||
onDispose { navigation.unregisterWindowTouchRegion("test-window") } |
|||
} |
|||
} |
|||
Box(Modifier.size(400.dp, 300.dp).testTag("viewport") |
|||
.workspaceCanvasScroll(canvasEnabled, navigation, x, y, horizontalFling, verticalFling)) { |
|||
val windowModifier = Modifier |
|||
.size(900.dp, 700.dp) |
|||
.then(if (reserveWindowSurface) Modifier.windowTouchScrollBarrier("test-window") else Modifier) |
|||
Box(windowModifier.testTag("window").bringWindowToFrontOnPress("window") { activations++ }) { |
|||
if (graph) { |
|||
MultiXGraphCanvas(ChartRenderSnapshot(0.0, 60.0, emptyList(), emptyMap(), legendPosition = 3), |
|||
Modifier.size(900.dp, 700.dp), isMultiAxis = multi, |
|||
onPanTime = { pans++ }, onZoomTime = { _, _ -> zooms++ }, |
|||
onCrosshairTimeChange = { taps++ }) |
|||
} else if (table) { |
|||
val stopNested = remember { object : NestedScrollConnection { |
|||
override fun onPostScroll(consumed: Offset, available: Offset, source: NestedScrollSource) = available |
|||
} } |
|||
Box(Modifier.size(900.dp, 700.dp).nestedScroll(stopNested).verticalScroll(innerScroll)) { |
|||
Box(Modifier.size(900.dp, 1400.dp).clickable { taps++ }) |
|||
} |
|||
} else if (header) { |
|||
Box(Modifier.size(900.dp, 700.dp).pointerInput(Unit) { |
|||
detectDragGestures(onDragStart = { navigation.claimSinglePointerDrag() }) { change, _ -> |
|||
change.consume(); drags++ |
|||
} |
|||
}) |
|||
} else { |
|||
Box(Modifier.size(900.dp, 700.dp).clickable { taps++ }) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
@Test fun emptyCanvasClampsContentAndPreservesTapWithSmallFingerMovement() { |
|||
content(canvasEnabled = false) |
|||
val viewport = compose.onNodeWithTag("viewport").fetchSemanticsNode().boundsInRoot |
|||
val content = compose.onNodeWithTag("window").fetchSemanticsNode().boundsInRoot |
|||
assertEquals(viewport.width, content.width, 0.1f) |
|||
assertEquals(viewport.height, content.height, 0.1f) |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
down(center) |
|||
moveTo(center + Offset(3f, 2f), delayMillis = 180) |
|||
up() |
|||
} |
|||
compose.runOnIdle { |
|||
assertEquals(1, taps) |
|||
assertEquals(0, x.value) |
|||
assertEquals(0, y.value) |
|||
} |
|||
} |
|||
|
|||
@Test fun emptyCanvasDoesNotPanWithOneOrTwoFingers() { |
|||
content(canvasEnabled = false) |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
down(center) |
|||
moveTo(center - Offset(100f, 80f), delayMillis = 80) |
|||
up() |
|||
} |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
val first = center - Offset(50f, 0f) |
|||
val second = center + Offset(50f, 0f) |
|||
down(0, first) |
|||
down(1, second) |
|||
for (i in 1..5) { |
|||
updatePointerTo(0, first - Offset(i * 15f, i * 10f)) |
|||
updatePointerTo(1, second - Offset(i * 15f, i * 10f)) |
|||
move() |
|||
} |
|||
up(1) |
|||
moveBy(0, Offset(-60f, -60f)) |
|||
up(0) |
|||
} |
|||
compose.runOnIdle { |
|||
assertEquals(0, x.value) |
|||
assertEquals(0, y.value) |
|||
assertEquals(0, pans) |
|||
assertEquals(0, zooms) |
|||
} |
|||
} |
|||
|
|||
private fun slowSingleFingerDrag() { |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
val start = center |
|||
down(start) |
|||
// Real fingers cross touch slop over many MOVE events, unlike |
|||
// the old tests' first jump of 60-140 px. |
|||
for (i in 1..60) moveTo(start - Offset(0f, i * 2f), delayMillis = 8) |
|||
up() |
|||
} |
|||
} |
|||
|
|||
@Test fun slowHeaderDragCrossesSlopWithoutBeingCancelled() { |
|||
content(header = true, reserveWindowSurface = true) |
|||
slowSingleFingerDrag() |
|||
compose.runOnIdle { |
|||
assertTrue("Slow title drag must reach the window handler", drags > 0) |
|||
assertEquals(150, x.value); assertEquals(150, y.value) |
|||
} |
|||
} |
|||
|
|||
@Test fun slowInnerScrollCrossesSlopWithoutBeingCancelled() { |
|||
content(table = true, reserveWindowSurface = true) |
|||
slowSingleFingerDrag() |
|||
compose.runOnIdle { |
|||
assertTrue("Slow drag must scroll the inner list", innerScroll.value > 10) |
|||
assertEquals(150, x.value); assertEquals(150, y.value) |
|||
} |
|||
} |
|||
|
|||
private fun translateWithOneFingerTail() { |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
val a = center - Offset(50f, 0f) |
|||
val b = center + Offset(50f, 0f) |
|||
down(0, a); down(1, b) |
|||
for (i in 1..5) { |
|||
updatePointerTo(0, a - Offset(i * 15f, i * 10f)) |
|||
updatePointerTo(1, b - Offset(i * 15f, i * 10f)) |
|||
move() |
|||
} |
|||
up(1) |
|||
} |
|||
val afterX = x.value |
|||
val afterY = y.value |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
moveBy(0, Offset(-60f, -60f)); up(0) |
|||
} |
|||
compose.runOnIdle { |
|||
assertEquals(afterX, x.value); assertEquals(afterY, y.value) |
|||
assertTrue(x.value > 150); assertTrue(y.value > 150) |
|||
assertEquals(0, taps); assertEquals(0, pans); assertEquals(0, zooms) |
|||
assertEquals(0, activations) |
|||
} |
|||
} |
|||
|
|||
@Test fun twoFingerTranslationOverClickableContentScrollsBothAxesWithoutClickOrTail() { |
|||
content() |
|||
translateWithOneFingerTail() |
|||
} |
|||
@Test fun ordinaryGraphTranslationMovesCanvasNotTimeAxisOrScale() { |
|||
content(graph = true) |
|||
translateWithOneFingerTail() |
|||
} |
|||
@Test fun multiAxisGraphTranslationMovesCanvasNotTimeAxisOrScale() { |
|||
content(graph = true, multi = true) |
|||
translateWithOneFingerTail() |
|||
} |
|||
|
|||
private fun translateAfterFirstFingerStartsScrolling() { |
|||
val start = compose.onNodeWithTag("viewport").fetchSemanticsNode().boundsInRoot.size |
|||
val a = Offset(start.width * .5f, start.height * .6f) |
|||
val drift = Offset(-45f, -45f) |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
down(0, a) |
|||
// Fingers rarely land in the same event. A scroll can already have |
|||
// consumed movement when the second finger reaches the screen. |
|||
moveTo(0, a + drift, delayMillis = 32) |
|||
} |
|||
val beforeX = x.value |
|||
val beforeY = y.value |
|||
val beforePans = pans |
|||
val beforeInner = innerScroll.value |
|||
val beforeActivations = activations |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
val b = a + drift + Offset(80f, 0f) |
|||
down(1, b) |
|||
for (i in 1..6) { |
|||
val delta = Offset(-i * 15f, -i * 10f) |
|||
updatePointerTo(0, a + drift + delta) |
|||
updatePointerTo(1, b + delta) |
|||
move() |
|||
} |
|||
advanceEventTime(300) |
|||
up(1); up(0) |
|||
} |
|||
compose.runOnIdle { |
|||
assertTrue("Second finger must take over horizontal canvas scroll", x.value > beforeX) |
|||
assertTrue("Second finger must take over vertical canvas scroll", y.value > beforeY) |
|||
assertEquals("Time axis must stop moving after the second finger lands", beforePans, pans) |
|||
assertEquals("Table must stop scrolling after the second finger lands", beforeInner, innerScroll.value) |
|||
assertEquals(0, zooms) |
|||
assertEquals(0, taps) |
|||
assertEquals("Two-finger takeover must not activate another window", beforeActivations, activations) |
|||
} |
|||
} |
|||
|
|||
@Test fun delayedSecondFingerOverGraphTakesOverCanvasScroll() { |
|||
content(graph = true) |
|||
translateAfterFirstFingerStartsScrolling() |
|||
} |
|||
|
|||
@Test fun delayedSecondFingerOverTableTakesOverCanvasScroll() { |
|||
content(table = true) |
|||
translateAfterFirstFingerStartsScrolling() |
|||
} |
|||
|
|||
@Test fun delayedSecondFingerOverReservedTableTakesOverCanvasScroll() { |
|||
content(table = true, reserveWindowSurface = true) |
|||
translateAfterFirstFingerStartsScrolling() |
|||
} |
|||
|
|||
@Test fun delayedSecondFingerOverCanvasTakesOverBothScrollAxes() { |
|||
content() |
|||
translateAfterFirstFingerStartsScrolling() |
|||
} |
|||
|
|||
@Test fun delayedSecondFingerOverMultiAxisGraphTakesOverCanvasScroll() { |
|||
content(graph = true, multi = true) |
|||
translateAfterFirstFingerStartsScrolling() |
|||
} |
|||
|
|||
@Test fun canvasPanContinuesWhenWindowMovesAcrossOriginalDownPoint() { |
|||
content(movingWindowSurface = true) |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
down(center) |
|||
for (i in 1..20) moveBy(Offset(-3f, -2f), delayMillis = 16) |
|||
} |
|||
compose.runOnIdle { |
|||
assertEquals(210, x.value) |
|||
assertEquals(190, y.value) |
|||
// Model a neighbouring window moving under the original DOWN point. |
|||
movingWindowBounds = Rect(0f, 0f, 10000f, 10000f) |
|||
} |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
for (i in 1..20) moveBy(Offset(-3f, -2f), delayMillis = 16) |
|||
} |
|||
compose.runOnIdle { |
|||
assertEquals(270, x.value) |
|||
assertEquals(230, y.value) |
|||
} |
|||
compose.onNodeWithTag("viewport").performTouchInput { up() } |
|||
} |
|||
|
|||
@Test fun oneFingerCanvasTracksExactDistanceBeforeRelease() { |
|||
content() |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
down(center) |
|||
for (i in 1..40) moveBy(Offset(-3f, -2f), delayMillis = 16) |
|||
} |
|||
compose.runOnIdle { |
|||
assertEquals("Horizontal movement must be applied once", 270, x.value) |
|||
assertEquals("Vertical movement must be applied once", 230, y.value) |
|||
} |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
for (i in 1..20) moveBy(Offset(3f, 2f), delayMillis = 16) |
|||
} |
|||
compose.runOnIdle { |
|||
assertEquals(210, x.value) |
|||
assertEquals(190, y.value) |
|||
} |
|||
compose.onNodeWithTag("viewport").performTouchInput { up() } |
|||
} |
|||
|
|||
@Test fun oneFingerDiagonalDragMovesWorkspaceOnBothAxes() { |
|||
content() |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
val start = center |
|||
down(0, start) |
|||
for (i in 1..8) { |
|||
updatePointerTo(0, start - Offset(i * 18f, i * 14f)) |
|||
move() |
|||
} |
|||
up(0) |
|||
} |
|||
compose.runOnIdle { |
|||
assertTrue("Diagonal drag must move the horizontal canvas", x.value > 150) |
|||
assertTrue("Diagonal drag must move the vertical canvas", y.value > 150) |
|||
assertEquals(0, taps) |
|||
} |
|||
} |
|||
|
|||
@Test fun nestedWindowScrollDoesNotMoveWorkspaceCanvas() { |
|||
content(table = true, reserveWindowSurface = true) |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
down(0, center) |
|||
moveTo(0, center - Offset(0f, 140f), delayMillis = 16) |
|||
moveTo(0, center - Offset(0f, 220f), delayMillis = 16) |
|||
up(0) |
|||
} |
|||
compose.runOnIdle { |
|||
assertEquals("Window scroll must not move horizontal canvas", 150, x.value) |
|||
assertEquals("Window scroll must not move vertical canvas", 150, y.value) |
|||
assertTrue("The nested window list should consume the vertical drag", innerScroll.value > 10) |
|||
} |
|||
} |
|||
|
|||
@Test fun anyGestureStartingInsideWindowDoesNotFallBackToCanvas() { |
|||
content(reserveWindowSurface = true) |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
down(0, center) |
|||
moveTo(0, center - Offset(140f, 100f), delayMillis = 16) |
|||
up(0) |
|||
} |
|||
compose.runOnIdle { |
|||
assertEquals(150, x.value) |
|||
assertEquals(150, y.value) |
|||
assertEquals(0, taps) |
|||
} |
|||
} |
|||
|
|||
@Test fun oneFingerDiagonalDragKeepsGraphPlotGestureOnTimeAxis() { |
|||
content(graph = true) |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
val start = center |
|||
down(0, start) |
|||
for (i in 1..8) { |
|||
updatePointerTo(0, start - Offset(i * 18f, i * 14f)) |
|||
move() |
|||
} |
|||
up(0) |
|||
} |
|||
compose.runOnIdle { |
|||
assertTrue("Graph plot drag must pan the time axis", pans > 0) |
|||
assertEquals("Graph plot drag must not move the workspace vertically", 150, y.value) |
|||
} |
|||
} |
|||
@Test fun twoFingersOverHeaderPanCanvasWithoutActivatingWindow() { |
|||
content(header = true, reserveWindowSurface = true) |
|||
translateWithOneFingerTail() |
|||
compose.runOnIdle { assertEquals(0, drags) } |
|||
} |
|||
@Test fun twoFingersOverReservedTablePanCanvasWithoutMovingInnerTable() { |
|||
content(table = true, reserveWindowSurface = true) |
|||
translateWithOneFingerTail() |
|||
compose.runOnIdle { |
|||
assertEquals("A two-finger page pan must not scroll the inner table", 10, innerScroll.value) |
|||
} |
|||
} |
|||
@Test fun tableNestedScrollBarrierDoesNotBlockTwoFingerCanvasNavigation() { |
|||
content(table = true) |
|||
translateWithOneFingerTail() |
|||
compose.runOnIdle { assertEquals(10, innerScroll.value) } |
|||
} |
|||
@Test fun canvasFlingStopsAtTopLeftBoundary() { |
|||
content() |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
val a = Offset(30f, 30f) |
|||
val b = Offset(90f, 30f) |
|||
down(0, a); down(1, b) |
|||
for (i in 1..12) { |
|||
updatePointerTo(0, a + Offset(i * 20f, i * 20f)) |
|||
updatePointerTo(1, b + Offset(i * 20f, i * 20f)) |
|||
move() |
|||
} |
|||
up(0); up(1) |
|||
} |
|||
compose.runOnIdle { assertEquals(0, x.value); assertEquals(0, y.value) } |
|||
compose.mainClock.advanceTimeBy(1000) |
|||
compose.runOnIdle { assertEquals(0, x.value); assertEquals(0, y.value) } |
|||
} |
|||
@Test fun thirdFingerEndsNavigationUntilAllContactsLift() { |
|||
content() |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
down(0, center - Offset(50f, 0f)); down(1, center + Offset(50f, 0f)) |
|||
down(2, center + Offset(0f, 60f)); up(2) |
|||
updatePointerTo(0, center - Offset(100f, 50f)) |
|||
updatePointerTo(1, center - Offset(0f, 50f)) |
|||
move(); up(1); up(0) |
|||
} |
|||
compose.runOnIdle { assertEquals(150, x.value); assertEquals(150, y.value); assertEquals(0, taps); assertEquals(0, activations) } |
|||
} |
|||
@Test fun pinchOverGraphChangesScaleWithoutMovingCanvasOrClicking() { |
|||
content(graph = true) |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
down(0, center - Offset(30f, 0f)); down(1, center + Offset(30f, 0f)) |
|||
for (i in 1..5) { |
|||
updatePointerTo(0, center - Offset(30f + i * 12f, 0f)) |
|||
updatePointerTo(1, center + Offset(30f + i * 12f, 0f)) |
|||
move() |
|||
} |
|||
up(0); up(1) |
|||
} |
|||
compose.runOnIdle { |
|||
assertTrue(zooms > 0); assertEquals(0, pans); assertEquals(0, taps) |
|||
assertEquals(0, activations) |
|||
assertEquals(150, x.value); assertEquals(150, y.value) |
|||
} |
|||
} |
|||
@Test fun establishedWindowDragIsNotCancelledBySecondFinger() { |
|||
content(header = true, reserveWindowSurface = true) |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
down(0, center) |
|||
moveTo(0, center + Offset(60f, 0f)) |
|||
down(1, center - Offset(50f, 0f)) |
|||
updatePointerTo(0, center + Offset(100f, 0f)) |
|||
updatePointerTo(1, center - Offset(10f, 0f)) |
|||
move(); up(1); up(0) |
|||
} |
|||
compose.runOnIdle { |
|||
assertTrue(drags > 0); assertEquals(150, x.value); assertEquals(150, y.value) |
|||
assertEquals(1, activations) |
|||
} |
|||
} |
|||
|
|||
private fun fastTwoFingerSwipe(releaseJitter: Boolean = false) { |
|||
compose.onNodeWithTag("viewport").performTouchInput { |
|||
val a = center - Offset(50f, 0f) |
|||
val b = center + Offset(50f, 0f) |
|||
down(0, a); down(1, b) |
|||
for (i in 1..8) { |
|||
updatePointerTo(0, a - Offset(i * 12f, i * 6f)) |
|||
updatePointerTo(1, b - Offset(i * 12f, i * 6f)) |
|||
move(delayMillis = 10) |
|||
} |
|||
up(0) |
|||
if (releaseJitter) { |
|||
// Real touch hardware can emit small MOVE events between the two UPs. |
|||
moveBy(1, Offset(-1f, -1f), delayMillis = 16) |
|||
} |
|||
up(1) |
|||
} |
|||
} |
|||
|
|||
@Test fun twoFingerReleaseFlingsBothAxesWithoutActivatingWindow() { |
|||
content() |
|||
compose.mainClock.autoAdvance = false |
|||
fastTwoFingerSwipe() |
|||
val releasedX = x.value |
|||
val releasedY = y.value |
|||
compose.mainClock.advanceTimeBy(200) |
|||
compose.runOnIdle { |
|||
assertTrue(x.value > releasedX); assertTrue(y.value > releasedY) |
|||
assertEquals(0, activations); assertEquals(0, taps) |
|||
} |
|||
compose.mainClock.advanceTimeBy(5000) |
|||
compose.runOnIdle { assertFalse(x.isScrollInProgress); assertFalse(y.isScrollInProgress) } |
|||
} |
|||
|
|||
@Test fun smallMovementBetweenFingerReleasesPreservesInertia() { |
|||
content() |
|||
compose.mainClock.autoAdvance = false |
|||
fastTwoFingerSwipe(releaseJitter = true) |
|||
val releasedX = x.value |
|||
val releasedY = y.value |
|||
compose.mainClock.advanceTimeBy(200) |
|||
compose.runOnIdle { |
|||
assertTrue("Horizontal inertia was cancelled by release jitter", x.value > releasedX) |
|||
assertTrue("Vertical inertia was cancelled by release jitter", y.value > releasedY) |
|||
assertEquals(0, activations) |
|||
assertEquals(0, taps) |
|||
} |
|||
compose.mainClock.advanceTimeBy(5000) |
|||
} |
|||
|
|||
@Test fun newTouchOverWindowStopsTwoFingerInertiaImmediately() { |
|||
content() |
|||
compose.mainClock.autoAdvance = false |
|||
fastTwoFingerSwipe() |
|||
compose.mainClock.advanceTimeBy(80) |
|||
compose.onNodeWithTag("viewport").performTouchInput { down(center) } |
|||
val stoppedX = x.value |
|||
val stoppedY = y.value |
|||
compose.mainClock.advanceTimeBy(200) |
|||
compose.runOnIdle { |
|||
assertEquals(stoppedX, x.value); assertEquals(stoppedY, y.value) |
|||
assertEquals(0, activations) |
|||
} |
|||
compose.onNodeWithTag("viewport").performTouchInput { up() } |
|||
} |
|||
} |
|||
@ -1,85 +0,0 @@ |
|||
package com.dct.app.presentation.signaltree |
|||
|
|||
import androidx.compose.foundation.layout.Box |
|||
import androidx.compose.foundation.layout.size |
|||
import androidx.compose.material3.ProvideTextStyle |
|||
import androidx.compose.runtime.CompositionLocalProvider |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.platform.LocalDensity |
|||
import androidx.compose.ui.semantics.SemanticsActions |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.text.TextLayoutResult |
|||
import androidx.compose.ui.text.TextStyle |
|||
import androidx.compose.ui.unit.Density |
|||
import androidx.compose.ui.unit.dp |
|||
import androidx.compose.ui.unit.sp |
|||
import com.dct.app.core.theme.DctTheme |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.MdbDatabase |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import com.dct.app.domain.model.mdb.SignalGroup |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
import kotlin.math.abs |
|||
|
|||
class SignalTableTextAlignmentUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
|
|||
@Test fun mdbAtTabletScale() = assertAlignment("mdb", 1.3f) |
|||
@Test fun canAtTabletScale() = assertAlignment("can", 1.3f) |
|||
@Test fun a2lAtTabletScale() = assertAlignment("a2l", 1.3f) |
|||
@Test fun mdbAtLargeScale() = assertAlignment("mdb", 2f) |
|||
@Test fun canAtLargeScale() = assertAlignment("can", 2f) |
|||
@Test fun a2lAtLargeScale() = assertAlignment("a2l", 2f) |
|||
|
|||
private fun assertAlignment(kind: String, scale: Float) { |
|||
val signal = SignalDefinition( |
|||
reclid = 1, idx = 2, name = "RPM_CENTER", attr = MdbAttrType.ATTR_2_UINT16, |
|||
cvsA = 1.0, cvsB = 0.0, unit = "rpm", color = 0xFF0000, |
|||
min = 321.0, max = 999.0, description = "센터 gy 신호", messageName = "Engine" |
|||
) |
|||
var density = 1f |
|||
compose.setContent { |
|||
density = LocalDensity.current.density |
|||
CompositionLocalProvider(LocalDensity provides Density(density, scale)) { |
|||
DctTheme { |
|||
// Reproduce the large inherited line height that caused the original regression. |
|||
ProvideTextStyle(TextStyle(fontSize = 16.sp, lineHeight = 24.sp)) { |
|||
// Keep horizontal width clipping separate from this vertical alignment test. |
|||
WindowUiStateProvider(kind, mapOf("expanded" to "true", "width:name" to "200.0", |
|||
"width:unit" to "100.0", "width:desc" to "300.0", "width:min" to "120.0"), {}) { |
|||
Box(Modifier.size(1200.dp, 200.dp)) { |
|||
when (kind) { |
|||
"mdb" -> WindowsClassicMdbSignalTableWindow( |
|||
MdbDatabase(groups = listOf(SignalGroup(1, "", "", true, signals = listOf(signal)))), emptyMap() |
|||
) |
|||
"can" -> WindowsClassicCanSignalTableWindow(listOf(signal), emptyMap()) |
|||
else -> WindowsClassicA2lSignalTableWindow(listOf(signal), emptyMap()) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
val row = compose.onNode(hasClickAction() and hasText(signal.name)).fetchSemanticsNode().boundsInRoot |
|||
val expectedRow = with(Density(density, scale)) { signalTableRowHeight(this).toPx() } |
|||
assertEquals(expectedRow, row.height, 1f) |
|||
for ((text, style) in listOf( |
|||
signal.name to SignalTableTextStyle, signal.unit to SignalTableTextStyle, |
|||
signal.description to SignalTableDetailTextStyle, "321.000" to SignalTableDetailTextStyle |
|||
)) { |
|||
val node = compose.onNodeWithText(text, useUnmergedTree = true) |
|||
val layouts = mutableListOf<TextLayoutResult>() |
|||
node.performSemanticsAction(SemanticsActions.GetTextLayoutResult) { assertTrue(it(layouts)) } |
|||
val layout = layouts.single() |
|||
assertEquals(style.lineHeight, layout.layoutInput.style.lineHeight) |
|||
assertFalse("Clipped text: $kind/$scale/$text size=${layout.size} paragraph=${layout.multiParagraph.width}x${layout.multiParagraph.height} ellipsized=${layout.isLineEllipsized(0)}", layout.didOverflowHeight) |
|||
val bounds = node.fetchSemanticsNode().boundsInRoot |
|||
assertTrue("Not vertically centered: $kind/$scale/$text", abs(bounds.center.y - row.center.y) <= 1f) |
|||
assertTrue("No vertical breathing room: $kind/$scale/$text", bounds.height < row.height) |
|||
} |
|||
} |
|||
} |
|||
@ -1,163 +0,0 @@ |
|||
package com.dct.app.presentation.signaltree |
|||
|
|||
import androidx.compose.foundation.layout.Box |
|||
import androidx.compose.foundation.layout.size |
|||
import androidx.compose.material3.Text |
|||
import androidx.compose.runtime.* |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.geometry.Offset |
|||
import androidx.compose.ui.platform.LocalDensity |
|||
import androidx.compose.ui.semantics.SemanticsActions |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.text.TextLayoutResult |
|||
import androidx.compose.ui.unit.Density |
|||
import androidx.compose.ui.unit.dp |
|||
import com.dct.app.core.theme.DctTheme |
|||
import com.dct.app.data.parser.A2lParser.A2lCharacteristic |
|||
import com.dct.app.data.parser.A2lParser.A2lCharacteristicArray |
|||
import com.dct.app.domain.model.formula.FormulaDefinition |
|||
import com.dct.app.domain.model.mdb.* |
|||
import com.dct.app.presentation.monitor.components.FormulaWindowContent |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
class TableAutoFitUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
private val name = "WMWM_온도_Shift_iiiiMMMM_WMWM" |
|||
private val description = "Description_온도_WMWM_아주긴설명" |
|||
|
|||
@Test fun mdbManualWidthAndTinyClipping() = assertWindow("mdb") |
|||
@Test fun canManualWidthAndTinyClipping() = assertWindow("can") |
|||
@Test fun a2lManualWidthAndTinyClipping() = assertWindow("a2l") |
|||
@Test fun formulaManualWidthAndTinyClipping() = assertWindow("formula") |
|||
@Test fun constantManualWidthAndTinyClipping() = assertWindow("constant") |
|||
@Test fun compensationManualWidthAndTinyClipping() = assertWindow("compensation") |
|||
@Test fun characteristicCheckboxIsIncludedInFit() = assertWindow("characteristic") |
|||
@Test fun characteristicArrayManualWidthAndTinyClipping() = assertWindow("array") |
|||
|
|||
private fun assertWindow(kind: String) { |
|||
val signal = SignalDefinition(1, 2, name, MdbAttrType.ATTR_2_UINT16, |
|||
1.0, 0.0, "rpm", 0xFF0000, 0.0, 999.0, description = description) |
|||
val key = if (kind == "compensation") "test:YNAME" else "name" |
|||
lateinit var widths: WindowColumnWidths |
|||
val visible = mutableStateOf(true) |
|||
var saved = mapOf("width:$key" to "130.0") |
|||
var pixelsPerDp = 1f |
|||
compose.setContent { |
|||
val current = LocalDensity.current |
|||
pixelsPerDp = current.density |
|||
CompositionLocalProvider(LocalDensity provides Density(current.density, 1.3f)) { |
|||
DctTheme { |
|||
if (visible.value) WindowUiStateProvider(kind, saved, { saved = it }) { |
|||
widths = rememberWindowColumnWidths() |
|||
Box(Modifier.size(1200.dp, 450.dp)) { |
|||
when (kind) { |
|||
"mdb" -> WindowsClassicMdbSignalTableWindow( |
|||
MdbDatabase(groups = listOf(SignalGroup(1, "", "", true, signals = listOf(signal)))), emptyMap()) |
|||
"can" -> WindowsClassicCanSignalTableWindow(listOf(signal), emptyMap()) |
|||
"a2l" -> WindowsClassicA2lSignalTableWindow(listOf(signal), emptyMap()) |
|||
"formula" -> FormulaWindowContent(listOf(FormulaDefinition(id = "f", name = name, |
|||
expression = "1", unit = "rpm")), onAddFormula = {}, onUpdateFormula = {}, onDeleteFormula = {}) |
|||
"constant" -> WindowsClassicConstantTableWindow(listOf(MdbConstant(1, name, 1.0, |
|||
0x1000, 0.0, 100.0, MdbAttrType.ATTR_2_UINT16, description))) |
|||
"characteristic" -> WindowsClassicA2lCharacteristicTableWindow(listOf(A2lCharacteristic(name, description))) |
|||
"array" -> WindowsClassicA2lCharacteristicArrayTableWindow(listOf(A2lCharacteristicArray(name, description))) |
|||
else -> CompensationTable(compensationMapColumns(true), listOf(CompensationMap( |
|||
CompensationMapType.TYPE_A, 1, name, 0, MdbAttrType.ATTR_2_UINT16, 0.0, 100.0, |
|||
"X", 0, MdbAttrType.ATTR_2_UINT16, 1.0, 0.0, description |
|||
)), "test", selectedIndex = 0, onRowClick = { _, _ -> }, onDescriptionChange = { _, _ -> }) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
// Legacy saved widths must not imply that the column is already auto-fitted. |
|||
compose.onAllNodesWithContentDescription("열 너비 닫기").assertCountEquals(0) |
|||
compose.onAllNodesWithContentDescription("열 너비 열기")[0].performClick() |
|||
val fitted = widths[key]!! |
|||
assertTrue(fitted > 130.dp) |
|||
assertTextFits(name) |
|||
val title = when (kind) { "mdb" -> "Signal name"; "can" -> "DBC name"; "compensation" -> "YNAME"; else -> "Name" } |
|||
assertTextFits(title) |
|||
compose.onAllNodesWithContentDescription("열 너비 닫기").assertCountEquals(1) |
|||
|
|||
val icon = compose.onNodeWithContentDescription("열 너비 닫기").fetchSemanticsNode().boundsInRoot |
|||
val root = compose.onRoot().fetchSemanticsNode().boundsInRoot |
|||
val grip = Offset(icon.right + 6f * pixelsPerDp, icon.center.y) - root.topLeft |
|||
compose.onRoot().performTouchInput { swipe(grip, grip - Offset(30f * pixelsPerDp, 0f), 300) } |
|||
assertTrue("Grip drag did not resize $kind", widths[key]!! < fitted) |
|||
compose.onAllNodesWithContentDescription("열 너비 닫기").assertCountEquals(0) |
|||
compose.onAllNodesWithContentDescription("열 너비 열기")[0].performClick() |
|||
assertEquals(fitted, widths[key]) |
|||
assertTextFits(name) |
|||
|
|||
// A tiny manual reduction clears fit mode. Opening must recover, not reset to default. |
|||
compose.runOnIdle { widths[key] = fitted - 2.dp } |
|||
compose.onAllNodesWithContentDescription("열 너비 닫기").assertCountEquals(0) |
|||
compose.onAllNodesWithContentDescription("열 너비 열기")[0].performClick() |
|||
assertEquals(fitted, widths[key]) |
|||
assertTextFits(name) |
|||
|
|||
compose.runOnIdle { visible.value = false } |
|||
compose.waitForIdle() |
|||
compose.runOnIdle { visible.value = true } |
|||
compose.onAllNodesWithContentDescription("열 너비 닫기").assertCountEquals(1) |
|||
compose.onNodeWithContentDescription("열 너비 닫기").performClick() |
|||
assertFalse(saved.containsKey("width:$key")) |
|||
assertFalse(saved.containsKey("autoFit:$key")) |
|||
|
|||
// Exercise the shared description path, including nested padding in calibration tables. |
|||
if (kind != "formula") { |
|||
val descriptionIndex = if (kind == "compensation") 2 else 1 |
|||
compose.onAllNodesWithContentDescription("열 너비 열기")[descriptionIndex].performScrollTo().performClick() |
|||
assertTextFits(description) |
|||
compose.onNodeWithContentDescription("열 너비 닫기").performClick() |
|||
} |
|||
} |
|||
|
|||
private fun assertTextFits(text: String) { |
|||
val layouts = mutableListOf<TextLayoutResult>() |
|||
compose.onNodeWithText(text, useUnmergedTree = true) |
|||
.performSemanticsAction(SemanticsActions.GetTextLayoutResult) { assertTrue(it(layouts)) } |
|||
val layout = layouts.single() |
|||
val details = "$text size=${layout.size} paragraph=${layout.multiParagraph.width}x${layout.multiParagraph.height} " + |
|||
"constraints=${layout.layoutInput.constraints} style=${layout.layoutInput.style}" |
|||
// A naturally sized Text can have a paragraph as wide as its parent's constraint. |
|||
// didOverflowWidth compares those different boxes, not whether glyphs are clipped. |
|||
assertTrue("Clipped line: $details", layout.getLineRight(0) <= layout.layoutInput.constraints.maxWidth + 1f) |
|||
assertFalse("Hidden lines: $details", layout.multiParagraph.didExceedMaxLines) |
|||
assertFalse("Ellipsized: $details", layout.isLineEllipsized(0)) |
|||
} |
|||
|
|||
@Test fun packetOnlyRecompositionDoesNotRemeasureMetadataButScaleAndNamesDo() { |
|||
val packet = mutableStateOf(0) |
|||
val scale = mutableStateOf(1.3f) |
|||
val items = mutableStateOf(listOf(name)) |
|||
var extractions = 0 |
|||
var measured = 0.dp |
|||
compose.setContent { |
|||
val density = LocalDensity.current |
|||
CompositionLocalProvider(LocalDensity provides Density(density.density, scale.value)) { |
|||
measured = rememberAutoFitWidth("Name", items.value, 110.dp) { extractions++; it } |
|||
Text(packet.value.toString()) |
|||
} |
|||
} |
|||
val initial = extractions |
|||
val initialWidth = measured |
|||
repeat(5) { compose.runOnIdle { packet.value++ }; compose.waitForIdle() } |
|||
assertEquals(initial, extractions) |
|||
compose.runOnIdle { items.value = listOf(name + name) } |
|||
compose.waitForIdle() |
|||
assertTrue(extractions > initial) |
|||
assertTrue(measured > initialWidth) |
|||
val beforeScale = extractions |
|||
val beforeWidth = measured |
|||
compose.runOnIdle { scale.value = 2f } |
|||
compose.waitForIdle() |
|||
assertTrue(extractions > beforeScale) |
|||
assertTrue(measured > beforeWidth) |
|||
} |
|||
} |
|||
@ -1,90 +0,0 @@ |
|||
package com.dct.app.presentation.signaltree |
|||
|
|||
import androidx.compose.foundation.layout.Box |
|||
import androidx.compose.foundation.layout.size |
|||
import androidx.compose.runtime.CompositionLocalProvider |
|||
import androidx.compose.ui.Modifier |
|||
import androidx.compose.ui.platform.LocalDensity |
|||
import androidx.compose.ui.semantics.SemanticsActions |
|||
import androidx.compose.ui.test.* |
|||
import androidx.compose.ui.test.junit4.createComposeRule |
|||
import androidx.compose.ui.text.TextLayoutResult |
|||
import androidx.compose.ui.text.style.TextOverflow |
|||
import androidx.compose.ui.unit.Density |
|||
import androidx.compose.ui.unit.dp |
|||
import com.dct.app.core.theme.DctTheme |
|||
import com.dct.app.data.parser.A2lParser.A2lCharacteristic |
|||
import com.dct.app.data.parser.A2lParser.A2lCharacteristicArray |
|||
import com.dct.app.domain.model.mdb.* |
|||
import org.junit.Assert.* |
|||
import org.junit.Rule |
|||
import org.junit.Test |
|||
|
|||
/** 원문을 자르지 않고 실제 TextLayout의 말줄임과 열 확장 후 복원을 확인한다. */ |
|||
class TableTextOverflowUiTest { |
|||
@get:Rule val compose = createComposeRule() |
|||
private val longUnit = "UNIT_NAME_TOO_LONG" |
|||
private val longMinimum = "-123456.789" |
|||
|
|||
@Test fun mdbNarrowCellsEllipsizeAndWideningRestoresFullText() = checkWindow("mdb") |
|||
@Test fun canNarrowCellsEllipsizeAndWideningRestoresFullText() = checkWindow("can") |
|||
@Test fun a2lNarrowCellsEllipsizeAndWideningRestoresFullText() = checkWindow("a2l") |
|||
@Test fun characteristicLimitsAndAddressEllipsize() = checkWindow("characteristic") |
|||
@Test fun arrayLimitsAddressAndMatrixValuesEllipsize() = checkWindow("array") |
|||
|
|||
private fun checkWindow(kind: String) { |
|||
lateinit var widths: WindowColumnWidths |
|||
val signal = SignalDefinition(1, 2, "Signal", MdbAttrType.ATTR_2_UINT16, |
|||
1.0, 0.0, longUnit, 0xFF0000, -123456.789, 654321.987) |
|||
compose.setContent { |
|||
val density = LocalDensity.current |
|||
CompositionLocalProvider(LocalDensity provides Density(density.density, 1.3f)) { |
|||
DctTheme { |
|||
WindowUiStateProvider(kind, mapOf("expanded" to "true", "width:unit" to "40.0", |
|||
"width:min" to "40.0", "width:max" to "40.0", "width:addr" to "40.0"), {}) { |
|||
widths = rememberWindowColumnWidths() |
|||
Box(Modifier.size(1100.dp, 450.dp)) { |
|||
when (kind) { |
|||
"mdb" -> WindowsClassicMdbSignalTableWindow( |
|||
MdbDatabase(groups = listOf(SignalGroup(1, "", "", true, signals = listOf(signal)))), emptyMap()) |
|||
"can" -> WindowsClassicCanSignalTableWindow(listOf(signal), emptyMap()) |
|||
"a2l" -> WindowsClassicA2lSignalTableWindow(listOf(signal), emptyMap()) |
|||
"characteristic" -> WindowsClassicA2lCharacteristicTableWindow(listOf( |
|||
A2lCharacteristic("Scalar", lowerLimit = -123456.789, upperLimit = 654321.987, |
|||
ecuAddress = 0x12345678))) |
|||
else -> WindowsClassicA2lCharacteristicArrayTableWindow(listOf( |
|||
A2lCharacteristicArray("Array", lowerLimit = -123456.789, upperLimit = 654321.987, |
|||
ecuAddress = 0x12345678, matrixDim = listOf(1), values = listOf(123456789.12)))) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
assertEllipsized(longMinimum, true) |
|||
if (kind in setOf("mdb", "can", "a2l")) assertEllipsized(longUnit, true) |
|||
else assertEllipsized("0x12345678", true) |
|||
if (kind == "array") assertEllipsized("123456789.12", true) |
|||
|
|||
compose.runOnIdle { |
|||
widths["min"] = 220.dp |
|||
widths["unit"] = 220.dp |
|||
widths["addr"] = 220.dp |
|||
} |
|||
compose.waitForIdle() |
|||
assertEllipsized(longMinimum, false) |
|||
if (kind in setOf("mdb", "can", "a2l")) assertEllipsized(longUnit, false) |
|||
else assertEllipsized("0x12345678", false) |
|||
} |
|||
|
|||
private fun assertEllipsized(original: String, expected: Boolean) { |
|||
val results = mutableListOf<TextLayoutResult>() |
|||
compose.onNodeWithText(original, useUnmergedTree = true) |
|||
.performSemanticsAction(SemanticsActions.GetTextLayoutResult) { assertTrue(it(results)) } |
|||
val layout = results.single() |
|||
assertEquals(original, layout.layoutInput.text.text) |
|||
assertEquals(TextOverflow.Ellipsis, layout.layoutInput.overflow) |
|||
assertFalse(layout.layoutInput.softWrap) |
|||
assertEquals("Unexpected truncation for $original", expected, layout.isLineEllipsized(0)) |
|||
} |
|||
} |
|||
@ -1,291 +0,0 @@ |
|||
package com.dct.app.data.maintenance |
|||
|
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.data.communication.WifiSocketManager |
|||
import com.dct.app.data.protocol.DctProtocolRequests |
|||
import com.dct.app.data.repository.PacketRepositoryImpl |
|||
import com.dct.app.domain.model.protocol.DctCommand |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.domain.repository.DeviceConnectionState |
|||
import com.dct.app.domain.repository.PacketRepository |
|||
import io.mockk.* |
|||
import kotlinx.coroutines.async |
|||
import kotlinx.coroutines.flow.MutableSharedFlow |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import kotlinx.coroutines.test.StandardTestDispatcher |
|||
import kotlinx.coroutines.test.advanceTimeBy |
|||
import kotlinx.coroutines.test.runTest |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.params.ParameterizedTest |
|||
import org.junit.jupiter.params.provider.ValueSource |
|||
|
|||
@DisplayName("Heartbeat 주기 루프 및 OTA 유지보수 단위 테스트") |
|||
class HeartbeatAndOtaParityTest { |
|||
|
|||
@Test |
|||
fun `removeFirmware는 슬롯 인덱스 검증과 0x06 삭제 응답을 정확히 처리한다`() = runTest { |
|||
val repo = mockk<PacketRepository>() |
|||
every { repo.connectionState } returns MutableStateFlow(DeviceConnectionState.READY) |
|||
|
|||
// 슬롯 1 삭제 성공 (0x06, 0x01) |
|||
coEvery { repo.sendCommand(match { it.payload[0] == 0x06.toByte() && it.payload[1] == 1.toByte() }) } returns |
|||
DctResult.Success(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x06, 0x01))) |
|||
|
|||
val service = MaintenanceService(repo) |
|||
val success = service.removeFirmware(1) |
|||
assertTrue(success.isSuccess) |
|||
|
|||
// 단말 삭제 거절 (0x06, 0x02) |
|||
coEvery { repo.sendCommand(match { it.payload[0] == 0x06.toByte() && it.payload[1] == 2.toByte() }) } returns |
|||
DctResult.Success(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x06, 0x02))) |
|||
val failed = service.removeFirmware(2) |
|||
assertTrue(failed.isFailure) |
|||
|
|||
// 슬롯 범위 초과 |
|||
assertTrue(service.removeFirmware(-1).isFailure) |
|||
assertTrue(service.removeFirmware(256).isFailure) |
|||
|
|||
// 비READY 상태에서 요청 시 거절 |
|||
every { repo.connectionState } returns MutableStateFlow(DeviceConnectionState.MEASURING) |
|||
assertTrue(service.removeFirmware(1).isFailure) |
|||
} |
|||
|
|||
@Test |
|||
fun `triggerFirmwareUpdate는 0x07 발송 후 0x08 진행 및 완료 패킷을 수신하고 상태별 ACK를 회신한다`() = runTest { |
|||
val repo = mockk<PacketRepository>() |
|||
every { repo.connectionState } returns MutableStateFlow(DeviceConnectionState.READY) |
|||
val stream = MutableSharedFlow<DctPacket>(replay = 10, extraBufferCapacity = 16) |
|||
every { repo.packetStream } returns stream |
|||
|
|||
val sentCommands = mutableListOf<DctPacket>() |
|||
coEvery { repo.sendCommand(capture(sentCommands)) } returns |
|||
DctResult.Success(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x07, 0x01))) |
|||
|
|||
val service = MaintenanceService(repo) |
|||
val job = async { service.triggerFirmwareUpdate(0) } |
|||
|
|||
// 단말의 0x08 진행 보고 방출 (30%, 75%) |
|||
stream.emit(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x08, 0x01, 30))) |
|||
stream.emit(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x08, 0x01, 75))) |
|||
// 단말의 0x08 완료 보고 방출 |
|||
stream.emit(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x08, 0x02))) |
|||
|
|||
val result = job.await() |
|||
assertTrue(result.isSuccess) |
|||
|
|||
// 0x07 요청, 0x08 ACK(0x01), 0x08 ACK(0x01), 0x08 ACK(0x02) 전송 확인 |
|||
val fwInfoCommands = sentCommands.filter { it.command == DctCommand.CMD_FW_INFO.code } |
|||
assertTrue(fwInfoCommands.any { it.payload[0] == 0x07.toByte() }) |
|||
assertTrue(fwInfoCommands.any { it.payload[0] == 0x08.toByte() && it.payload[1] == 0x01.toByte() }) |
|||
assertTrue(fwInfoCommands.any { it.payload[0] == 0x08.toByte() && it.payload[1] == 0x02.toByte() }) |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@ValueSource(booleans = [false, true]) |
|||
fun `재생 전 무응답은 종료하고 재생 요청 이후에는 실제 링크 단절까지 연결을 유지한다`(measuring: Boolean) = runTest { |
|||
val wifi = mockk<WifiSocketManager>(relaxed = true) |
|||
val packets = MutableSharedFlow<DctPacket>(extraBufferCapacity = 16) |
|||
val isConnected = MutableStateFlow(true) |
|||
every { wifi.isConnected } returns isConnected |
|||
every { wifi.packetStream } returns packets |
|||
every { wifi.currentSessionId } returns 1L |
|||
coEvery { wifi.disconnectSuspend() } coAnswers { isConnected.value = false } |
|||
every { wifi.invalidateConnectionIfSession(1L) } answers { |
|||
isConnected.value = false |
|||
true |
|||
} |
|||
|
|||
val sentList = mutableListOf<DctPacket>() |
|||
coEvery { wifi.sendCommand(capture(sentList)) } returns true |
|||
|
|||
val testDispatcher = StandardTestDispatcher(testScheduler) |
|||
val repository = PacketRepositoryImpl( |
|||
wifiSocketManager = wifi, |
|||
ioDispatcher = testDispatcher, |
|||
heartbeatDispatcher = testDispatcher, |
|||
heartbeatIntervalMs = 1000L, |
|||
heartbeatTimeoutMs = 5000L, |
|||
enableHeartbeat = true, |
|||
monotonicTimeMillis = { testScheduler.currentTime } |
|||
) |
|||
|
|||
// 핸드셰이크 통과 설정 |
|||
coEvery { wifi.sendCommand(match { it.command == 0x00.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(command = 0x80.toByte(), payload = byteArrayOf(1))) |
|||
true |
|||
} |
|||
coEvery { wifi.sendCommand(match { it.command == 0x01.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(command = 0x81.toByte(), payload = byteArrayOf(4, 68, 67, 84, 0))) |
|||
true |
|||
} |
|||
coEvery { wifi.sendCommand(match { it.command == 0x09.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(command = 0x89.toByte(), payload = byteArrayOf(1))) |
|||
true |
|||
} |
|||
coEvery { wifi.sendCommand(match { it.command == 0x03.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(command = 0x83.toByte(), payload = ByteArray(6))) |
|||
true |
|||
} |
|||
coEvery { wifi.sendCommand(match { it.command == 0x04.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(command = 0x84.toByte(), payload = byteArrayOf(1))) |
|||
true |
|||
} |
|||
|
|||
assertTrue(repository.connect("") is DctResult.Success) |
|||
assertEquals(DeviceConnectionState.READY, repository.connectionState.value) |
|||
if (measuring) { |
|||
coEvery { wifi.sendCommand(match { it.command == 0x20.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(command = 0xA0.toByte(), payload = byteArrayOf(1, 1))) |
|||
true |
|||
} |
|||
assertTrue(repository.startStreaming(30) is DctResult.Success) |
|||
} |
|||
|
|||
// 1초 후 첫 번째 Heartbeat(0x05) 발송 시점 |
|||
advanceTimeBy(1001L) |
|||
val heartbeat1 = sentList.find { it.command == DctCommand.CMD_POSSIBLE_TO_CONNECT.code } |
|||
assertNotNull(heartbeat1) |
|||
|
|||
// 5초 응답 대기 예산 안에서는 연결을 유지한다. |
|||
advanceTimeBy(4998L) |
|||
assertTrue(isConnected.value) |
|||
advanceTimeBy(3L) |
|||
if (measuring) { |
|||
advanceTimeBy(18001L) // Several fully silent heartbeat periods must not close playback. |
|||
assertEquals(DeviceConnectionState.MEASURING, repository.connectionState.value) |
|||
assertTrue(repository.isConnected.value) |
|||
assertTrue(repository.isStreaming.value) |
|||
assertTrue(isConnected.value) |
|||
verify(exactly = 0) { wifi.invalidateConnectionIfSession(any()) } |
|||
assertFalse(sentList.any { it.command == 0x21.toByte() || it.command == 0x0F.toByte() }) |
|||
|
|||
coEvery { wifi.sendCommand(match { it.command == 0x21.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(0xA1.toByte(), byteArrayOf(1))) |
|||
true |
|||
} |
|||
assertTrue(repository.stopStreaming() is DctResult.Success) |
|||
advanceTimeBy(12001L) |
|||
assertEquals(DeviceConnectionState.READY, repository.connectionState.value) |
|||
assertTrue(isConnected.value) // STOP does not re-enable automatic liveness disconnect. |
|||
verify(exactly = 0) { wifi.invalidateConnectionIfSession(any()) } |
|||
|
|||
isConnected.value = false // An actual transport/link loss still ends the session. |
|||
testScheduler.runCurrent() |
|||
assertEquals(DeviceConnectionState.ERROR, repository.connectionState.value) |
|||
assertFalse(repository.isConnected.value) |
|||
assertFalse(repository.isStreaming.value) |
|||
|
|||
every { wifi.currentSessionId } returns 2L |
|||
every { wifi.invalidateConnectionIfSession(2L) } answers { isConnected.value = false; true } |
|||
isConnected.value = true |
|||
assertTrue(repository.connect("") is DctResult.Success) |
|||
advanceTimeBy(6002L) |
|||
assertEquals(DeviceConnectionState.ERROR, repository.connectionState.value) |
|||
verify(exactly = 1) { wifi.invalidateConnectionIfSession(2L) } |
|||
return@runTest |
|||
} |
|||
assertEquals(DeviceConnectionState.ERROR, repository.connectionState.value) |
|||
assertFalse(repository.isConnected.value) |
|||
assertFalse(repository.isStreaming.value) |
|||
assertFalse(isConnected.value) |
|||
verify(exactly = 1) { wifi.invalidateConnectionIfSession(1L) } |
|||
// 무응답 장비에 STOP/DISABLE ACK를 추가로 기다리지 않는다. |
|||
assertFalse(sentList.any { it.command == 0x21.toByte() || it.command == 0x0F.toByte() }) |
|||
coVerify(exactly = 0) { wifi.disconnectSuspend() } |
|||
|
|||
// 종료 뒤 늦게 도착한 START ACK로 연결/계측을 되살리지 않는다. |
|||
packets.emit(DctPacket( |
|||
command = DctCommand.RES_START_TRANSMIT_DATA.code, |
|||
payload = byteArrayOf(1, 1), |
|||
transportSessionId = 1L |
|||
)) |
|||
advanceTimeBy(6001L) |
|||
assertEquals(DeviceConnectionState.ERROR, repository.connectionState.value) |
|||
assertFalse(isConnected.value) |
|||
assertEquals(1, sentList.count { it.command == DctCommand.CMD_POSSIBLE_TO_CONNECT.code }) |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@ValueSource(booleans = [false, true]) |
|||
fun `계측 데이터 또는 Heartbeat 응답이 있으면 연결을 유지한다`(heartbeatReply: Boolean) = runTest { |
|||
val wifi = mockk<WifiSocketManager>(relaxed = true) |
|||
val packets = MutableSharedFlow<DctPacket>(extraBufferCapacity = 64) |
|||
val isConnected = MutableStateFlow(true) |
|||
every { wifi.isConnected } returns isConnected |
|||
every { wifi.packetStream } returns packets |
|||
every { wifi.currentSessionId } returns 2L |
|||
every { wifi.offerCommand(any()) } returns true |
|||
|
|||
val sentList = mutableListOf<DctPacket>() |
|||
coEvery { wifi.sendCommand(capture(sentList)) } returns true |
|||
|
|||
val testDispatcher = StandardTestDispatcher(testScheduler) |
|||
val repository = PacketRepositoryImpl( |
|||
wifiSocketManager = wifi, |
|||
ioDispatcher = testDispatcher, |
|||
heartbeatDispatcher = testDispatcher, |
|||
heartbeatIntervalMs = 2000L, |
|||
heartbeatTimeoutMs = 5000L, |
|||
enableHeartbeat = true, |
|||
monotonicTimeMillis = { testScheduler.currentTime } |
|||
) |
|||
|
|||
// 핸드셰이크 통과 |
|||
coEvery { wifi.sendCommand(match { it.command == 0x00.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(command = 0x80.toByte(), payload = byteArrayOf(1))) |
|||
true |
|||
} |
|||
coEvery { wifi.sendCommand(match { it.command == 0x01.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(command = 0x81.toByte(), payload = byteArrayOf(4, 68, 67, 84, 0))) |
|||
true |
|||
} |
|||
coEvery { wifi.sendCommand(match { it.command == 0x09.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(command = 0x89.toByte(), payload = byteArrayOf(1))) |
|||
true |
|||
} |
|||
coEvery { wifi.sendCommand(match { it.command == 0x03.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(command = 0x83.toByte(), payload = ByteArray(6))) |
|||
true |
|||
} |
|||
coEvery { wifi.sendCommand(match { it.command == 0x04.toByte() }) } coAnswers { |
|||
packets.emit(DctPacket(command = 0x84.toByte(), payload = byteArrayOf(1))) |
|||
true |
|||
} |
|||
coEvery { wifi.sendCommand(match { it.command == DctCommand.CMD_START_TRANSMIT_DATA.code }) } coAnswers { |
|||
packets.emit(DctPacket(command = DctCommand.RES_START_TRANSMIT_DATA.code, payload = byteArrayOf(1, 1))) |
|||
true |
|||
} |
|||
|
|||
assertTrue(repository.connect("") is DctResult.Success) |
|||
assertTrue(repository.startStreaming(30) is DctResult.Success) |
|||
assertEquals(DeviceConnectionState.MEASURING, repository.connectionState.value) |
|||
|
|||
// 계측 중 대량의 CAN 텔레메트리 스트림 수신 (A3 패킷들) |
|||
repeat(5) { |
|||
packets.emit(DctPacket( |
|||
command = DctCommand.SEND_CAN_FRAME.code, |
|||
payload = byteArrayOf(0, 8, 1, 2, 3, 4, 5, 6, 7, 8), |
|||
transportSessionId = 2L |
|||
)) |
|||
} |
|||
|
|||
// Heartbeat 주기(2000ms) 전진 |
|||
advanceTimeBy(2001L) |
|||
|
|||
// 정상 데이터만 수신하는 경우와 0x85 응답만 받는 경우를 각각 검증한다. |
|||
packets.emit(DctPacket( |
|||
command = if (heartbeatReply) DctCommand.RES_POSSIBLE_TO_CONNECT.code else DctCommand.SEND_CAN_FRAME.code, |
|||
payload = if (heartbeatReply) byteArrayOf() else byteArrayOf(1, 0xA4.toByte(), 1), |
|||
transportSessionId = 2L |
|||
)) |
|||
advanceTimeBy(5001L) |
|||
|
|||
assertEquals(DeviceConnectionState.MEASURING, repository.connectionState.value) |
|||
assertTrue(sentList.any { it.command == DctCommand.CMD_POSSIBLE_TO_CONNECT.code }) |
|||
verify(exactly = 0) { wifi.invalidateConnectionIfSession(any()) } |
|||
|
|||
repository.disconnect() |
|||
} |
|||
} |
|||
@ -1,81 +0,0 @@ |
|||
package com.dct.app.data.protocol |
|||
|
|||
import com.dct.app.domain.model.protocol.DctCommand |
|||
import com.google.common.truth.Truth.assertThat |
|||
import org.junit.jupiter.api.Assertions.assertThrows |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@DisplayName("DctProtocolRequests OTA 및 Alive Check 바이트 규격 검증") |
|||
class DctOtaProtocolTest { |
|||
private val codec = DctPacketCodec() |
|||
|
|||
@Test |
|||
fun `buildRemoveFirmwareRequest는 0x31 서브타입 0x06의 유효한 바이너리 프레임을 생성한다`() { |
|||
val frame = DctProtocolRequests.buildRemoveFirmwareRequest(3) |
|||
// Header: 0xA1, Length: 0x00 0x03, Cmd: 0x31, Payload: 0x06 0x03, Checksum, Footer: 0x7E |
|||
assertThat(frame.size).isEqualTo(8) |
|||
assertThat(frame[0]).isEqualTo(0xA1.toByte()) |
|||
assertThat(frame[1]).isEqualTo(0x00.toByte()) |
|||
assertThat(frame[2]).isEqualTo(0x03.toByte()) |
|||
assertThat(frame[3]).isEqualTo(0x31.toByte()) |
|||
assertThat(frame[4]).isEqualTo(0x06.toByte()) |
|||
assertThat(frame[5]).isEqualTo(0x03.toByte()) |
|||
assertThat(frame[7]).isEqualTo(0x7E.toByte()) |
|||
|
|||
val decoded = codec.decode(frame) |
|||
assertThat(decoded).isNotNull() |
|||
assertThat(decoded!!.command).isEqualTo(DctCommand.CMD_FW_INFO.code) |
|||
assertThat(decoded.payload).isEqualTo(byteArrayOf(0x06, 0x03)) |
|||
} |
|||
|
|||
@Test |
|||
fun `buildTriggerFirmwareUpdateRequest는 0x31 서브타입 0x07의 유효한 바이너리 프레임을 생성한다`() { |
|||
val frame = DctProtocolRequests.buildTriggerFirmwareUpdateRequest() |
|||
assertThat(frame.size).isEqualTo(8) |
|||
assertThat(frame[0]).isEqualTo(0xA1.toByte()) |
|||
assertThat(frame[1]).isEqualTo(0x00.toByte()) |
|||
assertThat(frame[2]).isEqualTo(0x03.toByte()) |
|||
assertThat(frame[3]).isEqualTo(0x31.toByte()) |
|||
assertThat(frame[4]).isEqualTo(0x07.toByte()) |
|||
assertThat(frame[5]).isEqualTo(0x00.toByte()) |
|||
assertThat(frame[7]).isEqualTo(0x7E.toByte()) |
|||
|
|||
val decoded = codec.decode(frame) |
|||
assertThat(decoded).isNotNull() |
|||
assertThat(decoded!!.command).isEqualTo(DctCommand.CMD_FW_INFO.code) |
|||
assertThat(decoded.payload).isEqualTo(byteArrayOf(0x07, 0x00)) |
|||
} |
|||
|
|||
@Test |
|||
fun `firmwareUpdateResponse는 0x31 서브타입 0x08 상태 ACK 패킷을 생성한다`() { |
|||
val progressAck = DctProtocolRequests.firmwareUpdateResponse(0x01) |
|||
assertThat(progressAck.command).isEqualTo(0x31.toByte()) |
|||
assertThat(progressAck.payload).isEqualTo(byteArrayOf(0x08, 0x01)) |
|||
|
|||
val completeAck = DctProtocolRequests.firmwareUpdateResponse(0x02) |
|||
assertThat(completeAck.command).isEqualTo(0x31.toByte()) |
|||
assertThat(completeAck.payload).isEqualTo(byteArrayOf(0x08, 0x02)) |
|||
|
|||
assertThrows(IllegalArgumentException::class.java) { |
|||
DctProtocolRequests.firmwareUpdateResponse(256) |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
fun `possibleToConnect는 0x05 커맨드 패킷을 생성한다`() { |
|||
val packet = DctProtocolRequests.possibleToConnect() |
|||
assertThat(packet.command).isEqualTo(DctCommand.CMD_POSSIBLE_TO_CONNECT.code) |
|||
assertThat(packet.payload).isEmpty() |
|||
} |
|||
|
|||
@Test |
|||
fun `슬롯 범위 초과 시 예외가 발생한다`() { |
|||
assertThrows(IllegalArgumentException::class.java) { |
|||
DctProtocolRequests.buildRemoveFirmwareRequest(-1) |
|||
} |
|||
assertThrows(IllegalArgumentException::class.java) { |
|||
DctProtocolRequests.buildRemoveFirmwareRequest(256) |
|||
} |
|||
} |
|||
} |
|||
@ -1,292 +0,0 @@ |
|||
package com.dct.app.presentation.maintenance |
|||
|
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.data.maintenance.DeviceMaintenanceProtocol |
|||
import com.dct.app.data.maintenance.MaintenanceService |
|||
import com.dct.app.data.protocol.DctProtocolRequests |
|||
import com.dct.app.domain.model.maintenance.RemoteLogFile |
|||
import com.dct.app.domain.model.protocol.DctCommand |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.domain.repository.DeviceConnectionState |
|||
import com.dct.app.domain.repository.PacketRepository |
|||
import io.mockk.coEvery |
|||
import io.mockk.every |
|||
import io.mockk.mockk |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import kotlinx.coroutines.test.runTest |
|||
import org.junit.jupiter.api.Assertions.assertArrayEquals |
|||
import org.junit.jupiter.api.Assertions.assertEquals |
|||
import org.junit.jupiter.api.Assertions.assertNotNull |
|||
import org.junit.jupiter.api.Assertions.assertTrue |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
/** |
|||
* M3 UI/UX & Maintenance Dialog Parity 단위 테스트. |
|||
* |
|||
* 1. [ISSUE-R3-01] WorkspaceRibbonBar 유지보수 활성화 및 표준 DID 7종 정의/비트마스크 사양 |
|||
* 2. [ISSUE-R3-02] UDS DID 개별/전체 읽기/쓰기 및 차종/DB 제어 프로토콜 |
|||
* 3. [ISSUE-R3-03] 단말 로그 삭제(0x26), 전체 선택, 내림차순(rbegin) 삭제 순서 |
|||
*/ |
|||
class MaintenanceUiParityTest { |
|||
|
|||
@Test |
|||
fun testStandardDidDefinitionsParity() { |
|||
// PC CDIDInformationDlg.cpp 와 1:1 일치하는 표준 7종 DID 정의 검증 |
|||
assertEquals(7, STANDARD_DIDS.size) |
|||
|
|||
val f187 = STANDARD_DIDS.find { it.did == 0xF187 } |
|||
assertNotNull(f187) |
|||
assertEquals("Part Number", f187!!.name) |
|||
assertEquals(0x40, f187.bitmask) |
|||
assertEquals(10, f187.maxChars) |
|||
|
|||
val f1a1 = STANDARD_DIDS.find { it.did == 0xF1A1 } |
|||
assertNotNull(f1a1) |
|||
assertEquals("Supplier Code", f1a1!!.name) |
|||
assertEquals(0x20, f1a1.bitmask) |
|||
assertEquals(4, f1a1.maxChars) |
|||
|
|||
val f18b = STANDARD_DIDS.find { it.did == 0xF18B } |
|||
assertNotNull(f18b) |
|||
assertEquals("Product Date", f18b!!.name) |
|||
assertEquals(0x10, f18b.bitmask) |
|||
assertEquals(8, f18b.maxChars) |
|||
|
|||
val f197 = STANDARD_DIDS.find { it.did == 0xF197 } |
|||
assertNotNull(f197) |
|||
assertEquals("System Name", f197!!.name) |
|||
assertEquals(0x08, f197.bitmask) |
|||
assertEquals(4, f197.maxChars) |
|||
|
|||
val f191 = STANDARD_DIDS.find { it.did == 0xF191 } |
|||
assertNotNull(f191) |
|||
assertEquals("HW Version", f191!!.name) |
|||
assertEquals(0x04, f191.bitmask) |
|||
assertEquals(4, f191.maxChars) |
|||
|
|||
val f193 = STANDARD_DIDS.find { it.did == 0xF193 } |
|||
assertNotNull(f193) |
|||
assertEquals("Supplier HW Version", f193!!.name) |
|||
assertEquals(0x02, f193.bitmask) |
|||
assertEquals(4, f193.maxChars) |
|||
|
|||
val f100 = STANDARD_DIDS.find { it.did == 0xF100 } |
|||
assertNotNull(f100) |
|||
assertEquals("Part Name 2 / SW Version", f100!!.name) |
|||
assertEquals(0x01, f100.bitmask) |
|||
assertEquals(25, f100.maxChars) |
|||
|
|||
// 전체 선택 시 비트마스크 합: 0x40 | 0x20 | 0x10 | 0x08 | 0x04 | 0x02 | 0x01 = 0x7F (127) |
|||
val fullMask = STANDARD_DIDS.fold(0) { acc, def -> acc or def.bitmask } |
|||
assertEquals(0x7F, fullMask) |
|||
|
|||
// 부분 선택 마스크 조합 계산 검증 (F187 + F100 = 0x41) |
|||
val partialMask = f187.bitmask or f100.bitmask |
|||
assertEquals(0x41, partialMask) |
|||
} |
|||
|
|||
@Test |
|||
fun testDidProtocolRequestsAndResponses() = runTest { |
|||
val repo = mockk<PacketRepository>() |
|||
every { repo.connectionState } returns MutableStateFlow(DeviceConnectionState.READY) |
|||
|
|||
// 1. 개별 DID 읽기 (0x15 -> 0x95) |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_REQ_DID_INFO.code }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create( |
|||
DctCommand.RES_REQ_DID_INFO, |
|||
byteArrayOf(0xF1.toByte(), 0x87.toByte(), 0x01, 0x04, 'D'.code.toByte(), 'C'.code.toByte(), 'T'.code.toByte(), '1'.code.toByte()) |
|||
) |
|||
) |
|||
|
|||
val service = MaintenanceService(repo) |
|||
val readBytes = service.readDid(0xF187) |
|||
assertEquals("DCT1", readBytes.toString(Charsets.US_ASCII)) |
|||
|
|||
// 2. 개별 DID 쓰기 (0x16 -> 0x96) |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_DID_INFO.code }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create( |
|||
DctCommand.RES_DID_INFO, |
|||
byteArrayOf(0xF1.toByte(), 0x87.toByte(), 0x01, 0x04, 'D'.code.toByte(), 'C'.code.toByte(), 'T'.code.toByte(), '1'.code.toByte()) |
|||
) |
|||
) |
|||
service.writeDid(0xF187, "DCT1".toByteArray(Charsets.US_ASCII)) |
|||
|
|||
// 3. 전체 DID 읽기 (0x18 -> 0x98) |
|||
val allDidPayload = byteArrayOf( |
|||
0x01, // status success |
|||
0xF1.toByte(), 0x87.toByte(), 0x02, 'P'.code.toByte(), 'N'.code.toByte(), // F187 |
|||
0xF1.toByte(), 0x00.toByte(), 0x03, 'S'.code.toByte(), 'W'.code.toByte(), '1'.code.toByte() // F100 |
|||
) |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_REQ_ALL_DID_INFO.code }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_REQ_ALL_DID_INFO, allDidPayload) |
|||
) |
|||
val allResults = service.readAllDid(0x41) |
|||
assertEquals(2, allResults.size) |
|||
assertEquals("PN", allResults[0xF187]?.toString(Charsets.US_ASCII)) |
|||
assertEquals("SW1", allResults[0xF100]?.toString(Charsets.US_ASCII)) |
|||
|
|||
// 4. Setup DID 프리셋 저장 (0x17 -> 0x97) |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_SETUP_DID_INFO.code }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_SETUP_DID_INFO, byteArrayOf(0x01)) |
|||
) |
|||
service.setupDid(0x7F) |
|||
} |
|||
|
|||
@Test |
|||
fun testSavedLogRemoveProtocolAndService() = runTest { |
|||
// [ISSUE-R3-03] 0x26 단말 로그 삭제 패킷 빌더 검증 |
|||
val packet = DctProtocolRequests.savedLogRemove(0x0102) |
|||
assertEquals(DctCommand.CMD_SAVED_LOGFILE_COPY.code, packet.command) |
|||
assertArrayEquals(byteArrayOf(0x03, 0x01, 0x02), packet.payload) |
|||
|
|||
val repo = mockk<PacketRepository>() |
|||
every { repo.connectionState } returns MutableStateFlow(DeviceConnectionState.READY) |
|||
|
|||
// 성공 응답 (0x03, 0x01) |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_SAVED_LOGFILE_COPY.code && it.payload[0] == 0x03.toByte() }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_SAVED_LOGFILE_COPY, byteArrayOf(0x03, 0x01)) |
|||
) |
|||
|
|||
val service = MaintenanceService(repo) |
|||
service.deleteLogFile(0x0102) |
|||
|
|||
// 장비 거절 응답 (0x03, 0x02) |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_SAVED_LOGFILE_COPY.code && it.payload[0] == 0x03.toByte() }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_SAVED_LOGFILE_COPY, byteArrayOf(0x03, 0x02)) |
|||
) |
|||
assertTrue(runCatching { service.deleteLogFile(0x0102) }.isFailure) |
|||
|
|||
// 유효하지 않은 인덱스 (16비트 초과) 방어 |
|||
assertTrue(runCatching { service.deleteLogFile(0x10000) }.isFailure) |
|||
} |
|||
|
|||
@Test |
|||
fun testSavedLogDescendingDeleteOrder() { |
|||
// PC CLogfileDownloadDlg.cpp m_listDeleteItem.rbegin() 과 동등한 역순(내림차순) 정렬 검증 |
|||
val selectedIndices = setOf(2, 10, 5, 1, 8) |
|||
val sortedForDelete = selectedIndices.sortedDescending() |
|||
|
|||
assertEquals(listOf(10, 8, 5, 2, 1), sortedForDelete) |
|||
|
|||
// RemoteLogFile 필터링 및 정렬 동작 검증 |
|||
val files = listOf( |
|||
RemoteLogFile(1, "log_01.csv"), |
|||
RemoteLogFile(2, "log_02.csv"), |
|||
RemoteLogFile(5, "log_05.csv") |
|||
) |
|||
val selectedFiles = files.filter { it.index in setOf(1, 5) }.map { it.index }.sortedDescending() |
|||
assertEquals(listOf(5, 1), selectedFiles) |
|||
} |
|||
|
|||
@Test |
|||
fun testCarTypeAndDatabaseMaintenanceParity() = runTest { |
|||
val repo = mockk<PacketRepository>() |
|||
every { repo.connectionState } returns MutableStateFlow(DeviceConnectionState.READY) |
|||
|
|||
// 1. 차종 목록 조회 (0x07 / 0x08) |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_CARTYPE_CONTROL.code && it.payload[0] == 0x00.toByte() }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_CARTYPE_CONTROL, byteArrayOf(0x00, 0x01, 0x01, 0x02)) // 2개 차종 |
|||
) |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_CARTYPE_CONTROL.code && it.payload[0] == 0x01.toByte() && it.payload[2] == 0.toByte() }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_CARTYPE_CONTROL, byteArrayOf(0x01, 0x01, 0x01, 0x00, 0x03, 'S'.code.toByte(), 'G'.code.toByte(), '2'.code.toByte())) |
|||
) |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_CARTYPE_CONTROL.code && it.payload[0] == 0x01.toByte() && it.payload[2] == 1.toByte() }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_CARTYPE_CONTROL, byteArrayOf(0x01, 0x01, 0x01, 0x01, 0x03, 'N'.code.toByte(), 'Q'.code.toByte(), '5'.code.toByte())) |
|||
) |
|||
|
|||
val service = MaintenanceService(repo) |
|||
val carList = service.listCarTypes(1) |
|||
assertEquals(listOf("SG2", "NQ5"), carList) |
|||
|
|||
// 2. 차종 삭제 |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_CARTYPE_CONTROL.code && it.payload[0] == 0x02.toByte() }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_CARTYPE_CONTROL, byteArrayOf(0x02, 0x01, 0x01)) |
|||
) |
|||
service.deleteCarType(1, 0) |
|||
|
|||
// 3. DB 목록 및 선택/삭제 |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_DB.code && it.payload[0] == 0x01.toByte() }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_DB, byteArrayOf(0x01, 0x01, 0x01)) // 1개 DB |
|||
) |
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_DB.code && it.payload[0] == 0x02.toByte() }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_DB, byteArrayOf(0x02, 0x01, 0x00, 0x04, 'T'.code.toByte(), 'E'.code.toByte(), 'S'.code.toByte(), 'T'.code.toByte())) |
|||
) |
|||
val dbs = service.listDatabases() |
|||
assertEquals(listOf("TEST"), dbs) |
|||
|
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_DB.code && it.payload[0] == 0x03.toByte() }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_DB, byteArrayOf(0x03, 0x01)) |
|||
) |
|||
service.deleteDatabase(0) |
|||
|
|||
coEvery { |
|||
repo.sendCommand(match { it.command == DctCommand.CMD_DB.code && it.payload[0] == 0x00.toByte() }) |
|||
} returns DctResult.Success( |
|||
DctPacket.create(DctCommand.RES_DB, byteArrayOf(0x00, 0x01)) |
|||
) |
|||
service.selectDatabase("TEST") |
|||
} |
|||
|
|||
@Test |
|||
fun testMaintenanceTabStringFormattingParity() { |
|||
// 1. UdsDidTab 문자열 템플릿 보간자 검증 |
|||
val f187 = STANDARD_DIDS.first { it.did == 0xF187 } |
|||
assertEquals("0xF187", "0x${f187.didHex}") |
|||
assertEquals("최대 10자 입력", "최대 ${f187.maxChars}자 입력") |
|||
val sampleBytes = byteArrayOf(1, 2, 3, 4) |
|||
assertEquals("DID 0xF187 읽기 성공 (4 bytes)", "DID 0x${f187.didHex} 읽기 성공 (${sampleBytes.size} bytes)") |
|||
val readResults = mapOf(0xF187 to sampleBytes, 0xF100 to byteArrayOf(0x01)) |
|||
assertEquals("DID 일괄 읽기 완료 (2개 응답 수신)", "DID 일괄 읽기 완료 (${readResults.size}개 응답 수신)") |
|||
|
|||
// 2. VehicleDbTab 문자열 템플릿 보간자 검증 |
|||
val selectedMaker = 1 |
|||
assertEquals("단말 차종 목록 조회 중 (Maker=1)...", "단말 차종 목록 조회 중 (Maker=$selectedMaker)...") |
|||
val carList = listOf("SG2", "NQ5") |
|||
assertEquals("(2개)", "(${carList.size}개)") |
|||
assertEquals("[#0] SG2", "[#0] ${carList[0]}") |
|||
assertEquals("[#1] NQ5", "[#1] ${carList[1]}") |
|||
val selectedCount = 2 |
|||
assertEquals("삭제 (2)", "삭제 ($selectedCount)") |
|||
val dbList = listOf("TEST_DB") |
|||
assertEquals("(1개)", "(${dbList.size}개)") |
|||
assertEquals("[#0] TEST_DB", "[#0] ${dbList[0]}") |
|||
val targetIndices = listOf(0, 1) |
|||
assertEquals("선택한 2개 차종을 단말에서 삭제하시겠습니까?\n이 작업은 되돌릴 수 없습니다.", "선택한 ${targetIndices.size}개 차종을 단말에서 삭제하시겠습니까?\n이 작업은 되돌릴 수 없습니다.") |
|||
assertEquals("2개 차종 삭제 완료", "${targetIndices.size}개 차종 삭제 완료") |
|||
|
|||
// 3. LogTab 문자열 템플릿 보간자 검증 |
|||
val logFiles = listOf(RemoteLogFile(1, "log01.csv"), RemoteLogFile(2, "log02.csv")) |
|||
assertEquals("(2개 파일)", "(${logFiles.size}개 파일)") |
|||
assertEquals("선택 로그 삭제 (1)", "선택 로그 삭제 (1)") |
|||
assertEquals("#1", "#${logFiles[0].index}") |
|||
assertEquals("#2", "#${logFiles[1].index}") |
|||
assertEquals("선택한 2개의 로그 파일을 단말 플래시 메모리에서 영구 삭제하시겠습니까?\n이 작업은 되돌릴 수 없습니다.", "선택한 ${logFiles.size}개의 로그 파일을 단말 플래시 메모리에서 영구 삭제하시겠습니까?\n이 작업은 되돌릴 수 없습니다.") |
|||
assertEquals("2개 로그 파일 삭제 완료", "${logFiles.size}개 로그 파일 삭제 완료") |
|||
} |
|||
} |
|||
@ -1,54 +0,0 @@ |
|||
package com.dct.app.presentation.monitor.components |
|||
|
|||
import androidx.compose.ui.unit.* |
|||
import org.junit.jupiter.api.Assertions.assertEquals |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class RibbonSubmenuPositionTest { |
|||
private val provider = RibbonSubmenuPositionProvider() |
|||
|
|||
@Test fun opensToRightAlignedWithSelectedCategory() { |
|||
assertEquals(IntOffset(280, 180), provider.calculatePosition( |
|||
IntRect(20, 180, 280, 228), IntSize(1200, 800), LayoutDirection.Ltr, IntSize(240, 160) |
|||
)) |
|||
} |
|||
|
|||
@Test fun narrowScreenFallsBackToLeftAndAvoidsBottomClipping() { |
|||
assertEquals(IntOffset(360, 340), provider.calculatePosition( |
|||
IntRect(600, 450, 860, 498), IntSize(900, 500), LayoutDirection.Ltr, IntSize(240, 160) |
|||
)) |
|||
} |
|||
|
|||
@Test fun oversizedPopupNeverProducesNegativeCoordinates() { |
|||
assertEquals(IntOffset.Zero, provider.calculatePosition( |
|||
IntRect(10, 20, 90, 68), IntSize(100, 80), LayoutDirection.Ltr, IntSize(240, 160) |
|||
)) |
|||
} |
|||
|
|||
@Test fun nestedMenuAddsParentWindowOriginToBothCoordinates() { |
|||
val nested = RibbonSubmenuPositionProvider { IntOffset(55, 190) } |
|||
assertEquals(IntOffset(335, 370), nested.calculatePosition( |
|||
IntRect(20, 180, 280, 228), IntSize(1200, 800), LayoutDirection.Ltr, IntSize(240, 160) |
|||
)) |
|||
} |
|||
|
|||
@Test fun fallbackUsesScreenCoordinatesRatherThanLocalMenuCoordinates() { |
|||
val nested = RibbonSubmenuPositionProvider { IntOffset(600, 190) } |
|||
assertEquals(IntOffset(380, 340), nested.calculatePosition( |
|||
IntRect(20, 180, 280, 228), IntSize(900, 500), LayoutDirection.Ltr, IntSize(240, 160) |
|||
)) |
|||
} |
|||
|
|||
@Test fun parentWindowOriginIsReadAgainAfterRelocation() { |
|||
var offset = IntOffset(55, 190) |
|||
val nested = RibbonSubmenuPositionProvider { offset } |
|||
val anchor = IntRect(20, 180, 280, 228) |
|||
assertEquals(IntOffset(335, 370), nested.calculatePosition( |
|||
anchor, IntSize(1200, 800), LayoutDirection.Ltr, IntSize(240, 160) |
|||
)) |
|||
offset = IntOffset(85, 220) |
|||
assertEquals(IntOffset(365, 400), nested.calculatePosition( |
|||
anchor, IntSize(1200, 800), LayoutDirection.Ltr, IntSize(240, 160) |
|||
)) |
|||
} |
|||
} |
|||
@ -1,32 +0,0 @@ |
|||
package com.dct.app.presentation.signaltree |
|||
|
|||
import androidx.compose.ui.unit.Density |
|||
import androidx.compose.ui.unit.dp |
|||
import org.junit.jupiter.api.Assertions.assertEquals |
|||
import org.junit.jupiter.api.Assertions.assertTrue |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class SignalTableTextStylesTest { |
|||
@Test |
|||
fun `normal and tablet font scales retain compact rows`() { |
|||
for (scale in listOf(1f, 1.3f)) { |
|||
for (density in listOf(1f, 1.75f, 3f)) { |
|||
assertEquals(24.dp, signalTableRowHeight(Density(density, scale))) |
|||
} |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
fun `large fonts reserve room for every cell style and vertical padding`() { |
|||
for (scale in listOf(1.3f, 1.5f, 2f, 3f)) { |
|||
with(Density(1.75f, scale)) { |
|||
val row = signalTableRowHeight(this) |
|||
for (style in listOf(SignalTableTextStyle, SignalTableDetailTextStyle, SignalTableColorTextStyle)) { |
|||
assertTrue(row >= style.lineHeight.toDp() + 4.dp) |
|||
assertTrue(style.lineHeight > style.fontSize) |
|||
assertEquals(false, style.platformStyle?.paragraphStyle?.includeFontPadding) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,78 +0,0 @@ |
|||
package com.dct.app.presentation.signaltree |
|||
|
|||
import androidx.compose.ui.unit.dp |
|||
import com.dct.app.data.repository.DpcWorkspaceJson |
|||
import com.dct.app.domain.model.project.DpcPageState |
|||
import com.dct.app.domain.model.project.DpcWindowState |
|||
import com.dct.app.domain.model.project.DpcWorkspaceState |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class TableAutoFitTest { |
|||
@Test fun `opening respects default header controls and fractional clipping`() { |
|||
assertEquals(110.dp, calculateAutoFitWidth(110.dp, 30.dp, 20.dp)) |
|||
assertEquals(126.25.dp, calculateAutoFitWidth(110.dp, 90.25.dp, 50.dp)) |
|||
assertEquals(110.25.dp, calculateAutoFitWidth(110.dp, 30.dp, 101.25.dp)) |
|||
} |
|||
|
|||
@Test fun `checkbox and nested description padding fit and maximum matches manual resize`() { |
|||
assertEquals(161.dp, calculateAutoFitWidth(130.dp, 30.dp, 130.dp, 30.dp)) |
|||
assertEquals(209.dp, calculateAutoFitWidth(140.dp, 30.dp, 190.dp, 18.dp)) |
|||
assertEquals(1200.dp, calculateAutoFitWidth(110.dp, 100.dp, 2000.dp)) |
|||
} |
|||
|
|||
@Test fun `old saved narrow width opens instead of closing and close restores default`() { |
|||
val store = WindowUiStore(mapOf("width:name" to "70.0", "search" to "RPM")) {} |
|||
val widths = WindowColumnWidths(store) |
|||
assertFalse(widths.isAutoFit("name", 151.dp)) |
|||
widths.toggleAutoFit("name", 110.dp, 151.dp) |
|||
assertEquals(151.dp, widths["name"]) |
|||
assertTrue(widths.isAutoFit("name", 151.dp)) |
|||
widths.toggleAutoFit("name", 110.dp, 151.dp) |
|||
assertNull(widths["name"]) |
|||
assertFalse(store.values.containsKey("autoFit:name")) |
|||
assertEquals("RPM", store.values["search"]) |
|||
} |
|||
|
|||
@Test fun `manual drag clears fit mode even when width is larger than default`() { |
|||
val widths = WindowColumnWidths(WindowUiStore(emptyMap()) {}) |
|||
widths.toggleAutoFit("name", 110.dp, 200.dp) |
|||
widths["name"] = 150.dp |
|||
assertFalse(widths.isAutoFit("name", 200.dp)) |
|||
widths.toggleAutoFit("name", 110.dp, 200.dp) |
|||
assertEquals(200.dp, widths["name"]) |
|||
widths["name"] = 300.dp |
|||
assertFalse(widths.isAutoFit("name", 200.dp)) |
|||
widths.toggleAutoFit("name", 110.dp, 200.dp) |
|||
assertEquals(300.dp, widths["name"]) |
|||
assertTrue(widths.isAutoFit("name", 200.dp)) |
|||
} |
|||
|
|||
@Test fun `fractional stale fit is reopened not collapsed after metadata or scale change`() { |
|||
val widths = WindowColumnWidths(WindowUiStore(emptyMap()) {}) |
|||
widths.toggleAutoFit("name", 110.dp, 180.dp) |
|||
assertFalse(widths.isAutoFit("name", 180.25.dp)) |
|||
widths.toggleAutoFit("name", 110.dp, 180.25.dp) |
|||
assertEquals(180.25.dp, widths["name"]) |
|||
assertTrue(widths.isAutoFit("name", 180.25.dp)) |
|||
} |
|||
|
|||
@Test fun `width and fit mode are saved atomically and round trip with window preferences`() { |
|||
var writes = 0 |
|||
val store = WindowUiStore(mapOf("width:value" to "65.0")) { writes++ } |
|||
val widths = WindowColumnWidths(store) |
|||
widths.toggleAutoFit("name", 110.dp, 200.dp) |
|||
assertEquals(1, writes) |
|||
val window = DpcWindowState("one", "MDB_SIGNAL_LIST", "MDB", contentState = store.values) |
|||
val workspace = DpcWorkspaceState("p", listOf(DpcPageState("p", "Page", listOf(window)))) |
|||
val restored = DpcWorkspaceJson.decode(DpcWorkspaceJson.encode(workspace))!! |
|||
val preferences = restored.pages.single().windows.single().contentState |
|||
val reopened = WindowColumnWidths(WindowUiStore(preferences) {}) |
|||
assertEquals(200.dp, reopened["name"]) |
|||
assertTrue(reopened.isAutoFit("name", 200.dp)) |
|||
assertEquals("65.0", preferences["width:value"]) |
|||
widths["name"] = Float.NaN.dp |
|||
assertEquals(1, writes) |
|||
assertTrue(widths.isAutoFit("name", 200.dp)) |
|||
} |
|||
} |
|||
@ -1,113 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.parser.A2lParser |
|||
import com.dct.app.domain.model.a2l.A2lDataType |
|||
import com.dct.app.data.protocol.DctProtocolRequests |
|||
import org.junit.Assert.* |
|||
import org.junit.Test |
|||
|
|||
class A2lCharacteristicLayoutTest { |
|||
private fun parse(dimensions: String = "20 2", fnc: String = "1 SWORD COLUMN_DIR DIRECT") = |
|||
A2lParser.parseA2lFull(""" |
|||
/begin CHARACTERISTIC Table "table" |
|||
VAL_BLK 0x011E0020 AUTO_EXTRACTION_VALUE_S16 0 NO_COMPU_METHOD -32768 32767 |
|||
MATRIX_DIM $dimensions |
|||
/end CHARACTERISTIC |
|||
/begin CHARACTERISTIC Scalar "scalar" |
|||
VALUE 0x011E0000 AUTO_EXTRACTION_VALUE_S16 0 NO_COMPU_METHOD -32768 32767 |
|||
/end CHARACTERISTIC |
|||
/begin RECORD_LAYOUT AUTO_EXTRACTION_VALUE_S16 |
|||
FNC_VALUES $fnc |
|||
/end RECORD_LAYOUT |
|||
""".trimIndent().byteInputStream()) |
|||
|
|||
@Test fun recordLayoutAfterCharacteristicsResolvesActualTypeInsteadOfName() { |
|||
val result = parse() |
|||
assertEquals(A2lDataType.SWORD, result.characteristics.single().a2lDataType) |
|||
val array = result.characteristicsArray.single() |
|||
assertEquals("SWORD", array.dataType) |
|||
assertEquals("COLUMN_DIR", array.indexMode) |
|||
assertEquals(40, array.values.size) |
|||
assertNull(array.calibrationLayoutError) |
|||
} |
|||
|
|||
@Test fun allFortyCellsHaveUniquePcCompatibleAddressesFor20By2() { |
|||
val array = parse().characteristicsArray.single() |
|||
// PC GetArrayAddressIDby2D: base + (2*x+y)*2, not row-major y*20+x. |
|||
for (y in 0..1) for (x in 0..19) { |
|||
assertEquals(0x011E0020L + (2 * x + y) * 2, array.cellAddress(y * 20 + x)) |
|||
} |
|||
assertEquals(40, array.values.indices.map(array::cellAddress).distinct().size) |
|||
assertEquals(0x011E0024L, array.cellAddress(1)) |
|||
assertEquals(0x011E0022L, array.cellAddress(20)) |
|||
} |
|||
|
|||
@Test fun columnOrderUsesActualRowCountInsteadOfHardcodedTwo() { |
|||
val array = parse("4 3").characteristicsArray.single() |
|||
assertEquals(0x011E0026L, array.cellAddress(1)) |
|||
assertEquals(0x011E0022L, array.cellAddress(4)) |
|||
assertEquals(0x011E0036L, array.cellAddress(11)) |
|||
} |
|||
|
|||
@Test fun rowOrderAndOneDimensionalArraysRemainContiguous() { |
|||
val row = parse("4 3", "1 UWORD ROW_DIR DIRECT").characteristicsArray.single() |
|||
for (i in row.values.indices) assertEquals(0x011E0020L + i * 2, row.cellAddress(i)) |
|||
val one = parse("20").characteristicsArray.single() |
|||
for (i in one.values.indices) assertEquals(0x011E0020L + i * 2, one.cellAddress(i)) |
|||
} |
|||
|
|||
@Test fun declaredTypeOverridesMisleadingDepositNameIncluding64BitTypes() { |
|||
for ((declared, expected) in listOf("UBYTE" to A2lDataType.UBYTE, "UWORD" to A2lDataType.UWORD, |
|||
"A_UINT64" to A2lDataType.UINT64, "A_INT64" to A2lDataType.INT64, |
|||
"FLOAT64_IEEE" to A2lDataType.FLOAT64_IEEE)) { |
|||
assertEquals(expected, parse(fnc = "1 $declared ROW_DIR DIRECT").characteristicsArray.single().a2lDataType) |
|||
} |
|||
} |
|||
|
|||
@Test fun unsupportedLayoutsRejectAddressCalculationInsteadOfWritingGuessedBytes() { |
|||
for (fnc in listOf("2 SWORD COLUMN_DIR DIRECT", "1 SWORD COLUMN_DIR PWORD", |
|||
"1 SWORD ALTERNATE_CURVES DIRECT", "1 UNKNOWN COLUMN_DIR DIRECT")) { |
|||
val result = parse(fnc = fnc) |
|||
assertNotNull(result.characteristics.single().calibrationLayoutError) |
|||
val array = result.characteristicsArray.single() |
|||
assertNotNull(array.calibrationLayoutError) |
|||
assertThrows(IllegalArgumentException::class.java) { array.cellAddress(0) } |
|||
} |
|||
} |
|||
|
|||
@Test fun missingLayoutDoesNotSilentlyEnableUnknownTypeOrMultidimensionalWrites() { |
|||
val unknown = A2lParser.parseA2lFull(""" |
|||
/begin CHARACTERISTIC Unknown "unknown" |
|||
VAL_BLK 0x1000 MissingLayout 0 NO_COMPU_METHOD 0 100 MATRIX_DIM 2 2 |
|||
/end CHARACTERISTIC |
|||
""".trimIndent().byteInputStream()).characteristicsArray.single() |
|||
assertNotNull(unknown.calibrationLayoutError) |
|||
assertThrows(IllegalArgumentException::class.java) { unknown.cellAddress(0) } |
|||
// 이름에 자료형이 들어 있어도 실제 선언이 없으면 장비 쓰기를 허용하지 않는다. |
|||
val named = A2lParser.parseA2lFull(""" |
|||
/begin CHARACTERISTIC Named "named" |
|||
VALUE 0x1000 Deposit_UWORD 0 NO_COMPU_METHOD 0 100 |
|||
/end CHARACTERISTIC |
|||
""".trimIndent().byteInputStream()).characteristics.single() |
|||
assertEquals(A2lDataType.UWORD, named.a2lDataType) |
|||
assertNotNull(named.calibrationLayoutError) |
|||
} |
|||
|
|||
@Test fun negativeOutOfBoundsHigherDimensionalAndOverflowAddressesAreRejected() { |
|||
val array = parse().characteristicsArray.single() |
|||
for (index in listOf(-1, 40)) assertThrows(IllegalArgumentException::class.java) { array.cellAddress(index) } |
|||
assertThrows(IllegalArgumentException::class.java) { parse("2 2 2").characteristicsArray.single().cellAddress(0) } |
|||
assertThrows(IllegalArgumentException::class.java) { array.copy(ecuAddress = 0xFFFF_FFFFL).cellAddress(0) } |
|||
assertThrows(IllegalArgumentException::class.java) { array.copy(ecuAddress = Long.MAX_VALUE).cellAddress(0) } |
|||
} |
|||
|
|||
@Test fun correctedCellAddressAndSignedValueProducePcCompatibleWriteAndReadPayloads() { |
|||
val array = parse().characteristicsArray.single() |
|||
val address = array.cellAddress(1) |
|||
val write = DctProtocolRequests.xcpCharacteristicWrite(address, array.a2lDataType, -123.0, false) |
|||
assertArrayEquals(byteArrayOf(3, 0x85.toByte(), 0xFF.toByte(), 0x24, 0, 0x1E, 1), write.payload) |
|||
val read = DctProtocolRequests.xcpCharacteristicRead(address, array.a2lDataType, false) |
|||
assertArrayEquals(byteArrayOf(3, 0x24, 0, 0x1E, 1), read.payload) |
|||
assertEquals(-123.0, array.a2lDataType.unpackRawValue(write.payload, 1, false), 0.0) |
|||
} |
|||
} |
|||
@ -1,223 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.parser.A2lParser |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Assert.assertNotNull |
|||
import org.junit.Assert.assertTrue |
|||
import org.junit.Test |
|||
import java.io.ByteArrayInputStream |
|||
|
|||
class A2lParserTest { |
|||
|
|||
@Test |
|||
fun `XCP ON CAN 설정과 COMPU 포맷 단위를 PC처럼 상속한다`() { |
|||
val sample = """ |
|||
/begin IF_DATA XCP |
|||
BYTE_ORDER_MSB_FIRST |
|||
/end IF_DATA |
|||
/begin IF_DATA XCP |
|||
/begin XCP_ON_CAN |
|||
CAN_ID_MASTER 0x690 |
|||
CAN_ID_SLAVE 0x693 |
|||
BYTE_ORDER_MSB_LAST |
|||
/end XCP_ON_CAN |
|||
/end IF_DATA |
|||
/begin IF_DATA XCP |
|||
BYTE_ORDER_MSB_FIRST |
|||
/end IF_DATA |
|||
/begin COMPU_METHOD Conv "conversion" |
|||
LINEAR "%8.4" "km/h" |
|||
COEFFS_LINEAR 0.5 1.0 |
|||
/end COMPU_METHOD |
|||
/begin MEASUREMENT VehicleSpeed "speed" |
|||
UWORD Conv 1 0 0 300 |
|||
ECU_ADDRESS 0x1000 |
|||
SYMBOL_LINK "ECU.VehicleSpeed" 0 |
|||
/end MEASUREMENT |
|||
/begin MEASUREMENT Temperature "temp" |
|||
SWORD Conv 1 0 -40 200 |
|||
ECU_ADDRESS 0x1002 |
|||
FORMAT "%5.1f" |
|||
PHYS_UNIT "degC" |
|||
/end MEASUREMENT |
|||
""".trimIndent() |
|||
|
|||
val result = A2lParser.parseA2lFull(ByteArrayInputStream(sample.toByteArray())) |
|||
assertEquals(0x690L, result.ifData!!.masterCanId) |
|||
assertEquals(false, result.ifData!!.isMsbFirst) |
|||
val speed = result.measurements.first { it.name == "VehicleSpeed" } |
|||
assertEquals("ECU.VehicleSpeed", result.rawMeasurements.first { it.name == "VehicleSpeed" }.symbolLink) |
|||
assertEquals("%8.4", speed.measurementFormat) |
|||
assertEquals("km/h", speed.unit) |
|||
assertEquals("2.2350", speed.formatMeasurementValue(2.2346)) |
|||
val temperature = result.measurements.first { it.name == "Temperature" } |
|||
assertEquals("%5.1f", temperature.measurementFormat) |
|||
assertEquals("℃", temperature.unit) |
|||
} |
|||
|
|||
@Test |
|||
fun testA2lParsing() { |
|||
val sampleA2l = """ |
|||
ASAP2_VERSION 1 60 |
|||
/begin PROJECT TestProject "Project Description" |
|||
/begin MODULE TestModule "Module Description" |
|||
|
|||
/begin IF_DATA XCP |
|||
/begin XCP_ON_CAN |
|||
CAN_ID_MASTER 0x7E0 |
|||
CAN_ID_SLAVE 0x7E8 |
|||
BAUDRATE 500000 |
|||
BYTE_ORDER MSB_LAST |
|||
/end XCP_ON_CAN |
|||
/end IF_DATA |
|||
|
|||
/begin COMPU_VTAB StateVTab "State verbal mapping" |
|||
TAB_VERB |
|||
0 "INIT" |
|||
1 "RUNNING" |
|||
2 "ERROR" |
|||
/end COMPU_VTAB |
|||
|
|||
/begin COMPU_TAB IntpTab "Piecewise linear mapping" |
|||
TAB_INTP |
|||
0.0 0.0 |
|||
50.0 100.0 |
|||
100.0 300.0 |
|||
/end COMPU_TAB |
|||
|
|||
/begin COMPU_METHOD EngineSpeedConv "Engine Speed conversion" |
|||
LINEAR "%6.2f" "rpm" |
|||
COEFFS_LINEAR 0.25 0.0 |
|||
/end COMPU_METHOD |
|||
|
|||
/begin COMPU_METHOD ThrottlePosConv "Throttle Pos conversion" |
|||
LINEAR "%5.1f" "%" |
|||
COEFFS_LINEAR 0.1 0.0 |
|||
/end COMPU_METHOD |
|||
|
|||
/begin COMPU_METHOD StateConv "State conversion" |
|||
TAB_VERB "%s" "" StateVTab |
|||
/end COMPU_METHOD |
|||
|
|||
/begin COMPU_METHOD CustomCurveConv "Custom curve conversion" |
|||
TAB_INTP "%6.1f" "bar" IntpTab |
|||
/end COMPU_METHOD |
|||
|
|||
/begin MEASUREMENT EngineSpeed "Current engine speed in RPM" |
|||
UWORD EngineSpeedConv 1 0.0 0.0 8000.0 |
|||
ECU_ADDRESS 0x70001000 |
|||
FORMAT "%6.2f" |
|||
/end MEASUREMENT |
|||
|
|||
/begin MEASUREMENT ThrottlePos "Throttle valve position" |
|||
UBYTE ThrottlePosConv 1 0.0 0.0 100.0 |
|||
ECU_ADDRESS 0x70001004 |
|||
FORMAT "%5.1f" |
|||
/end MEASUREMENT |
|||
|
|||
/begin MEASUREMENT TempArray "Temperature Array" |
|||
SWORD NO_COMPU_METHOD 1 0.0 -40.0 150.0 |
|||
ECU_ADDRESS 0x70001008 |
|||
MATRIX_DIM 2 |
|||
/end MEASUREMENT |
|||
|
|||
/begin CHARACTERISTIC K_IDLE_SPEED "Idle Target Speed" |
|||
VALUE |
|||
0x70002000 |
|||
Deposit_UWORD |
|||
0.0 |
|||
EngineSpeedConv |
|||
600.0 |
|||
1200.0 |
|||
FORMAT "%6.2f" |
|||
UNIT "rpm" |
|||
/end CHARACTERISTIC |
|||
|
|||
/begin CHARACTERISTIC MAP_THROTTLE_CURVE "Throttle Map Array" |
|||
VAL_BLK |
|||
0x70002020 |
|||
Deposit_UWORD |
|||
0.0 |
|||
ThrottlePosConv |
|||
0.0 |
|||
100.0 |
|||
MATRIX_DIM 4 |
|||
FORMAT "%5.1f" |
|||
UNIT "%" |
|||
/end CHARACTERISTIC |
|||
|
|||
/end MODULE |
|||
/end PROJECT |
|||
""".trimIndent() |
|||
|
|||
val inputStream = ByteArrayInputStream(sampleA2l.toByteArray(Charsets.UTF_8)) |
|||
val result = A2lParser.parseA2lFull(inputStream) |
|||
|
|||
// 1. IF_DATA 검증 |
|||
assertNotNull(result.ifData) |
|||
assertEquals(0x7E0L, result.ifData!!.masterCanId) |
|||
assertEquals(0x7E8L, result.ifData!!.slaveCanId) |
|||
assertEquals(500000, result.ifData!!.baudrate) |
|||
assertEquals(false, result.ifData!!.isMsbFirst) |
|||
|
|||
// 2. COMPU_VTAB 및 COMPU_TAB 검증 |
|||
val stateMethod = result.compuMethods["stateconv"] |
|||
assertNotNull(stateMethod) |
|||
assertEquals("INIT", stateMethod!!.getVerbalString(0.0)) |
|||
assertEquals("RUNNING", stateMethod.getVerbalString(1.0)) |
|||
assertEquals("ERROR", stateMethod.getVerbalString(2.0)) |
|||
|
|||
val curveMethod = result.compuMethods["customcurveconv"] |
|||
assertNotNull(curveMethod) |
|||
assertEquals(0.0, curveMethod!!.calculatePhysicalValue(0.0), 0.001) |
|||
assertEquals(50.0, curveMethod.calculatePhysicalValue(25.0), 0.001) // 0~50 interpolate |
|||
assertEquals(100.0, curveMethod.calculatePhysicalValue(50.0), 0.001) |
|||
assertEquals(200.0, curveMethod.calculatePhysicalValue(75.0), 0.001) // 50~100 interpolate |
|||
assertEquals(300.0, curveMethod.calculatePhysicalValue(100.0), 0.001) |
|||
|
|||
// 3. Measurements 검증 |
|||
val signals = result.measurements |
|||
assertEquals(4, signals.size) // EngineSpeed, ThrottlePos, TempArray[0], TempArray[1] |
|||
|
|||
val speed = signals.find { it.name == "EngineSpeed" } |
|||
assertNotNull(speed) |
|||
assertEquals(0x70001000.toInt(), speed!!.adl) |
|||
assertEquals("rpm", speed.unit) |
|||
assertEquals(0.25, speed.cvsA, 0.0001) |
|||
assertEquals(8000.0, speed.max, 0.0001) |
|||
|
|||
val throttle = signals.find { it.name == "ThrottlePos" } |
|||
assertNotNull(throttle) |
|||
assertEquals(0x70001004.toInt(), throttle!!.adl) |
|||
assertEquals("%", throttle.unit) |
|||
assertEquals(0.1, throttle.cvsA, 0.0001) |
|||
|
|||
val temp0 = signals.find { it.name == "TempArray[0]" } |
|||
val temp1 = signals.find { it.name == "TempArray[1]" } |
|||
assertNotNull(temp0) |
|||
assertNotNull(temp1) |
|||
assertEquals(0x70001008.toInt(), temp0!!.adl) |
|||
assertEquals(0x7000100A.toInt(), temp1!!.adl) // SWORD = 2 bytes offset |
|||
|
|||
// 4. Characteristics 검증 |
|||
val characteristics = result.characteristics |
|||
assertEquals(1, characteristics.size) |
|||
val idleSpeed = characteristics[0] |
|||
assertEquals("K_IDLE_SPEED", idleSpeed.name) |
|||
assertEquals(0x70002000L, idleSpeed.ecuAddress) |
|||
assertEquals("rpm", idleSpeed.unit) |
|||
assertEquals("VALUE", idleSpeed.type) |
|||
assertEquals(600.0, idleSpeed.lowerLimit, 0.0001) |
|||
assertEquals(1200.0, idleSpeed.upperLimit, 0.0001) |
|||
|
|||
// 5. CharacteristicsArray 검증 |
|||
val charArrays = result.characteristicsArray |
|||
assertEquals(1, charArrays.size) |
|||
val throttleCurve = charArrays[0] |
|||
assertEquals("MAP_THROTTLE_CURVE", throttleCurve.name) |
|||
assertEquals(0x70002020L, throttleCurve.ecuAddress) |
|||
assertEquals("VAL_BLK", throttleCurve.type) |
|||
assertEquals(listOf(4), throttleCurve.matrixDim) |
|||
assertEquals(4, throttleCurve.values.size) |
|||
} |
|||
} |
|||
@ -1,106 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import com.dct.app.presentation.monitor.components.AlphaSignal |
|||
import com.dct.app.presentation.monitor.components.alphaDisplayValues |
|||
import com.dct.app.presentation.monitor.components.resolveAlphaSignalSelection |
|||
import com.dct.app.presentation.monitor.components.selectAlphaValues |
|||
import kotlinx.coroutines.ExperimentalCoroutinesApi |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import kotlinx.coroutines.flow.collect |
|||
import kotlinx.coroutines.launch |
|||
import kotlinx.coroutines.test.UnconfinedTestDispatcher |
|||
import kotlinx.coroutines.test.advanceTimeBy |
|||
import kotlinx.coroutines.test.runCurrent |
|||
import kotlinx.coroutines.test.runTest |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@OptIn(ExperimentalCoroutinesApi::class) |
|||
class AlphanumericalUpdatesTest { |
|||
private fun signal(name: String = "RPM", idx: Int = 1) = SignalDefinition( |
|||
1, idx, name, MdbAttrType.ATTR_2_UINT16, 0.1, 0.0, "", 0x123456, 0.0, 100.0 |
|||
) |
|||
|
|||
@Test |
|||
fun restoredAliasesKeepOrderDeduplicateAndReportOnlyMissingReferences() { |
|||
val mdb = signal() |
|||
val can = signal("Speed", 7).copy(messageId = 291) |
|||
val result = resolveAlphaSignalSelection( |
|||
listOf("can_7", "sig_1_1", "can_291_Speed", "missing", "mdb_sig_1_1"), |
|||
listOf(can), listOf(mdb), emptyList(), emptyList(), emptyList() |
|||
) |
|||
assertEquals(listOf("can_291_Speed", "sig_1_1"), result.signals.map { it.id }) |
|||
assertEquals(listOf("missing"), result.unresolvedIds) |
|||
assertSame(mdb, result.signals.last().definition) |
|||
} |
|||
|
|||
@Test |
|||
fun sourceReplacementRefreshesDefinitionAndResolvesPreviouslyMissingSignal() { |
|||
val ids = listOf("sig_1_1", "a2l_4660") |
|||
val old = resolveAlphaSignalSelection(ids, emptyList(), listOf(signal()), emptyList(), emptyList(), emptyList()) |
|||
val replacement = signal("New RPM").copy(unit = "rpm", color = 0x0000FF) |
|||
val a2l = signal("Pressure").copy(adl = 4660, measurementFormat = "%6.2f") |
|||
val updated = resolveAlphaSignalSelection(ids, emptyList(), listOf(replacement), listOf(a2l), emptyList(), emptyList()) |
|||
|
|||
assertEquals(listOf("a2l_4660"), old.unresolvedIds) |
|||
assertTrue(updated.unresolvedIds.isEmpty()) |
|||
assertSame(replacement, updated.signals.first().definition) |
|||
assertEquals("12.35", updated.signals.last().formatValue(12.345)) |
|||
} |
|||
|
|||
@Test |
|||
fun valueProjectionPreservesCanonicalPriorityNameFallbackAndMissingValues() { |
|||
val entries = listOf(AlphaSignal("sig_1_1", signal()), AlphaSignal("sig_1_2", signal("Temp", 2))) |
|||
assertEquals( |
|||
mapOf("sig_1_1" to 10.0, "sig_1_2" to 20.0), |
|||
selectAlphaValues(entries, mapOf("sig_1_1" to 10.0, "RPM" to 99.0, "Temp" to 20.0, "other" to 50.0)) |
|||
) |
|||
val cleared = selectAlphaValues(entries, emptyMap()) |
|||
assertEquals(setOf("sig_1_1", "sig_1_2"), cleared.keys) |
|||
assertNull(cleared["sig_1_1"]) |
|||
assertEquals("N/A", entries.first().formatValue(cleared["sig_1_1"])) |
|||
} |
|||
|
|||
@Test |
|||
fun unrelatedPacketsDoNotPublishNewAlphaValues() = runTest { |
|||
val entry = AlphaSignal("sig_1_1", signal()) |
|||
val telemetry = MutableStateFlow(mapOf("sig_1_1" to 1.0)) |
|||
val received = mutableListOf<Map<String, Double?>>() |
|||
backgroundScope.launch(UnconfinedTestDispatcher(testScheduler)) { |
|||
telemetry.alphaDisplayValues(listOf(entry)).collect { received.add(it) } |
|||
} |
|||
advanceTimeBy(34) |
|||
runCurrent() |
|||
repeat(5) { i -> |
|||
telemetry.value = mapOf(entry.id to 1.0, "other" to i.toDouble()) |
|||
advanceTimeBy(34) |
|||
runCurrent() |
|||
} |
|||
assertEquals(listOf(mapOf(entry.id to 1.0)), received) |
|||
} |
|||
|
|||
@Test |
|||
fun burstUsesLatestValueAndPublishesFinalValueWithoutAnotherPacket() = runTest { |
|||
val entry = AlphaSignal("sig_1_1", signal()) |
|||
val telemetry = MutableStateFlow<Map<String, Double>>(emptyMap()) |
|||
val received = mutableListOf<Map<String, Double?>>() |
|||
backgroundScope.launch(UnconfinedTestDispatcher(testScheduler)) { |
|||
telemetry.alphaDisplayValues(listOf(entry)).collect { received.add(it) } |
|||
} |
|||
repeat(20) { i -> |
|||
telemetry.value = mapOf(entry.id to i.toDouble()) |
|||
advanceTimeBy(1) |
|||
} |
|||
assertTrue(received.isEmpty()) |
|||
advanceTimeBy(14) |
|||
runCurrent() |
|||
assertEquals(listOf(mapOf(entry.id to 19.0)), received) |
|||
telemetry.value = emptyMap() |
|||
advanceTimeBy(34) |
|||
runCurrent() |
|||
assertEquals(mapOf(entry.id to null), received.last()) |
|||
assertEquals(2, received.size) |
|||
} |
|||
} |
|||
@ -1,213 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.google.common.truth.Truth.assertThat |
|||
import com.dct.app.data.mdb.AttrConverter |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.assertThrows |
|||
|
|||
@DisplayName("M3 AttrConverter: ATTR 0~5 Little-Endian 언팩/패킹 및 물리값 선형 변환 검증") |
|||
class AttrConverterTest { |
|||
|
|||
// ========================================================================= |
|||
// 1. ATTR 0: 1-Byte Unsigned Integer (0 ~ 255) |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("ATTR 0: 0, 127, 255 경계값 언팩 및 패킹 검증") |
|||
fun testAttr0UnpackAndPack() { |
|||
val testValues = listOf(0L, 1L, 127L, 128L, 254L, 255L) |
|||
for (v in testValues) { |
|||
val packed = AttrConverter.packRawValue(v, MdbAttrType.ATTR_0_UINT8) |
|||
assertThat(packed.size).isEqualTo(1) |
|||
val unpacked = AttrConverter.unpackRawValue(packed, 0, MdbAttrType.ATTR_0_UINT8) |
|||
assertThat(unpacked).isEqualTo(v) |
|||
} |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 2. ATTR 1: 1-Byte Signed Integer (-128 ~ 127) |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("ATTR 1: -128, -1, 0, 1, 127 경계값 언팩 및 패킹 검증") |
|||
fun testAttr1UnpackAndPack() { |
|||
val testValues = listOf(-128L, -100L, -1L, 0L, 1L, 100L, 127L) |
|||
for (v in testValues) { |
|||
val packed = AttrConverter.packRawValue(v, MdbAttrType.ATTR_1_INT8) |
|||
assertThat(packed.size).isEqualTo(1) |
|||
val unpacked = AttrConverter.unpackRawValue(packed, 0, MdbAttrType.ATTR_1_INT8) |
|||
assertThat(unpacked).isEqualTo(v) |
|||
} |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 3. ATTR 2: 2-Byte Unsigned Integer (0 ~ 65535, Little-Endian) |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("ATTR 2: 0, 256, 32767, 65535 경계값 및 Little-Endian 바이트 오더 검증") |
|||
fun testAttr2UnpackAndPack() { |
|||
val testValues = listOf(0L, 1L, 255L, 256L, 1000L, 32767L, 32768L, 65534L, 65535L) |
|||
for (v in testValues) { |
|||
val packed = AttrConverter.packRawValue(v, MdbAttrType.ATTR_2_UINT16) |
|||
assertThat(packed.size).isEqualTo(2) |
|||
|
|||
// Little-Endian 검증: 하위 바이트 우선 |
|||
val expectedB0 = (v and 0xFFL).toByte() |
|||
val expectedB1 = ((v shr 8) and 0xFFL).toByte() |
|||
assertThat(packed[0]).isEqualTo(expectedB0) |
|||
assertThat(packed[1]).isEqualTo(expectedB1) |
|||
|
|||
val unpacked = AttrConverter.unpackRawValue(packed, 0, MdbAttrType.ATTR_2_UINT16) |
|||
assertThat(unpacked).isEqualTo(v) |
|||
} |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 4. ATTR 3: 2-Byte Signed Integer (-32768 ~ 32767, Little-Endian) |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("ATTR 3: -32768, -1, 0, 1, 32767 음수/양수 경계값 언팩 및 패킹 검증") |
|||
fun testAttr3UnpackAndPack() { |
|||
val testValues = listOf(-32768L, -10000L, -256L, -1L, 0L, 1L, 256L, 10000L, 32767L) |
|||
for (v in testValues) { |
|||
val packed = AttrConverter.packRawValue(v, MdbAttrType.ATTR_3_INT16) |
|||
assertThat(packed.size).isEqualTo(2) |
|||
|
|||
val unpacked = AttrConverter.unpackRawValue(packed, 0, MdbAttrType.ATTR_3_INT16) |
|||
assertThat(unpacked).isEqualTo(v) |
|||
} |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 5. ATTR 4: 4-Byte Unsigned Integer (0 ~ 4294967295, Little-Endian) |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("ATTR 4: 0, 65536, 2147483647, 4294967295 경계값 언팩 및 패킹 검증") |
|||
fun testAttr4UnpackAndPack() { |
|||
val testValues = listOf(0L, 1L, 65535L, 65536L, 2147483647L, 2147483648L, 4294967295L) |
|||
for (v in testValues) { |
|||
val packed = AttrConverter.packRawValue(v, MdbAttrType.ATTR_4_UINT32) |
|||
assertThat(packed.size).isEqualTo(4) |
|||
|
|||
// Little-Endian 4바이트 검증 |
|||
val b0 = (v and 0xFFL).toByte() |
|||
val b1 = ((v shr 8) and 0xFFL).toByte() |
|||
val b2 = ((v shr 16) and 0xFFL).toByte() |
|||
val b3 = ((v shr 24) and 0xFFL).toByte() |
|||
assertThat(packed).isEqualTo(byteArrayOf(b0, b1, b2, b3)) |
|||
|
|||
val unpacked = AttrConverter.unpackRawValue(packed, 0, MdbAttrType.ATTR_4_UINT32) |
|||
assertThat(unpacked).isEqualTo(v) |
|||
} |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 6. ATTR 5: 4-Byte Signed Integer (-2147483648 ~ 2147483647, Little-Endian) |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("ATTR 5: -2147483648, -1, 0, 1, 2147483647 32비트 부호 정수 경계값 검증") |
|||
fun testAttr5UnpackAndPack() { |
|||
val testValues = listOf(-2147483648L, -1000000L, -1L, 0L, 1L, 1000000L, 2147483647L) |
|||
for (v in testValues) { |
|||
val packed = AttrConverter.packRawValue(v, MdbAttrType.ATTR_5_INT32) |
|||
assertThat(packed.size).isEqualTo(4) |
|||
|
|||
val unpacked = AttrConverter.unpackRawValue(packed, 0, MdbAttrType.ATTR_5_INT32) |
|||
assertThat(unpacked).isEqualTo(v) |
|||
} |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 7. 물리값 선형 변환 수식: Y = A * X + B 및 X = (Y - B) / A |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("물리값 선형 변환 수식(Y = A * X + B) 및 역변환(X = (Y - B) / A) 정밀도 검증") |
|||
fun testPhysicalFormulaScalingAndInverse() { |
|||
// 케이스 1: 엔진 RPM (CVS_A = 1.0, CVS_B = 0.0) -> 850 raw -> 850.0 rpm |
|||
val rpmPhysical = AttrConverter.toPhysicalValue(850, 1.0, 0.0) |
|||
assertThat(rpmPhysical).isEqualTo(850.0) |
|||
val rpmRaw = AttrConverter.toRawValue(850.0, 1.0, 0.0) |
|||
assertThat(rpmRaw).isEqualTo(850.0) |
|||
|
|||
// 케이스 2: 냉각수 온도 (CVS_A = 0.1, CVS_B = -40.0) -> 1250 raw -> 85.0 °C |
|||
val tempPhysical = AttrConverter.toPhysicalValue(1250, 0.1, -40.0) |
|||
assertThat(tempPhysical).isEqualTo(85.0) |
|||
val tempRaw = AttrConverter.toRawValue(85.0, 0.1, -40.0) |
|||
assertThat(tempRaw).isEqualTo(1250.0) |
|||
|
|||
// 케이스 3: 스로틀 개도율 (CVS_A = 0.5, CVS_B = 0.0) -> 150 raw -> 75.0 % |
|||
val throttlePhysical = AttrConverter.toPhysicalValue(150, 0.5, 0.0) |
|||
assertThat(throttlePhysical).isEqualTo(75.0) |
|||
val throttleRaw = AttrConverter.toRawValue(75.0, 0.5, 0.0) |
|||
assertThat(throttleRaw).isEqualTo(150.0) |
|||
|
|||
// 케이스 4: 클러치 유압 (CVS_A = 0.05, CVS_B = 0.0) -> 600 raw -> 30.0 bar |
|||
val clutchPhysical = AttrConverter.toPhysicalValue(600, 0.05, 0.0) |
|||
assertThat(clutchPhysical).isEqualTo(30.0) |
|||
val clutchRaw = AttrConverter.toRawValue(30.0, 0.05, 0.0) |
|||
assertThat(clutchRaw).isEqualTo(600.0) |
|||
|
|||
// 케이스 5: 0 나눗셈 방어 |
|||
val divZero = AttrConverter.toRawValue(100.0, 0.0, 10.0) |
|||
assertThat(divZero).isEqualTo(0.0) |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 8. 패킷 오프셋 기반 unpackPhysicalValue 통합 검증 |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("복합 바이트 버퍼에서 오프셋별 unpackPhysicalValue 연속 파싱 검증") |
|||
fun testUnpackPhysicalValueFromCombinedBuffer() { |
|||
// 가상 패킷 페이로드: |
|||
// [0..3]: EngineRPM (ATTR 4, cvsA 1.0, cvsB 0.0) = 3500 (0x00000DAC -> AC 0D 00 00) |
|||
// [4..5]: CoolantTemp (ATTR 2, cvsA 0.1, cvsB -40.0) = 1350 (0x0546 -> 46 05) -> 95.0 °C |
|||
// [6]: ThrottlePos (ATTR 0, cvsA 0.5, cvsB 0.0) = 120 (0x78) -> 60.0 % |
|||
// [7..8]: IntakePressure (ATTR 2, cvsA 0.1, cvsB 0.0) = 1850 (0x073A -> 3A 07) -> 185.0 kPa |
|||
val buffer = byteArrayOf( |
|||
0xAC.toByte(), 0x0D, 0x00, 0x00, // 3500 |
|||
0x46, 0x05, // 1350 |
|||
0x78, // 120 |
|||
0x3A, 0x07 // 1850 |
|||
) |
|||
|
|||
val rpm = AttrConverter.unpackPhysicalValue(buffer, 0, MdbAttrType.ATTR_4_UINT32, 1.0, 0.0) |
|||
assertThat(rpm).isEqualTo(3500.0) |
|||
|
|||
val temp = AttrConverter.unpackPhysicalValue(buffer, 4, MdbAttrType.ATTR_2_UINT16, 0.1, -40.0) |
|||
assertThat(temp).isEqualTo(95.0) |
|||
|
|||
val throttle = AttrConverter.unpackPhysicalValue(buffer, 6, MdbAttrType.ATTR_0_UINT8, 0.5, 0.0) |
|||
assertThat(throttle).isEqualTo(60.0) |
|||
|
|||
val pressure = AttrConverter.unpackPhysicalValue(buffer, 7, MdbAttrType.ATTR_2_UINT16, 0.1, 0.0) |
|||
assertThat(pressure).isEqualTo(185.0) |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 9. 버퍼 언더플로우 / 경계 예외 방어 검증 |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("버퍼 크기 부족 시 IllegalArgumentException 예외 발생 검증") |
|||
fun testBufferUnderflowThrowsException() { |
|||
val shortBuffer = byteArrayOf(0x01, 0x02) |
|||
|
|||
// ATTR 4는 4바이트 필요하지만 버퍼는 2바이트 -> 예외 |
|||
assertThrows<IllegalArgumentException> { |
|||
AttrConverter.unpackRawValue(shortBuffer, 0, MdbAttrType.ATTR_4_UINT32) |
|||
} |
|||
|
|||
// 오프셋 초과 -> 예외 |
|||
assertThrows<IllegalArgumentException> { |
|||
AttrConverter.unpackRawValue(shortBuffer, 2, MdbAttrType.ATTR_2_UINT16) |
|||
} |
|||
} |
|||
} |
|||
@ -1,236 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.core.common.DefaultDispatcherProvider |
|||
import com.dct.app.domain.model.mdb.* |
|||
import com.dct.app.domain.repository.MdbRepository |
|||
import com.dct.app.presentation.calibration.CalibrationEditorMode |
|||
import com.dct.app.presentation.calibration.CalibrationViewModel |
|||
import io.mockk.* |
|||
import kotlinx.coroutines.test.runTest |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.BeforeEach |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@DisplayName("M5 - CalibrationViewModel 캘리브레이션 튜너 및 맵 편집기 단위 테스트") |
|||
class CalibrationEditorTest { |
|||
|
|||
private lateinit var mdbRepository: MdbRepository |
|||
private lateinit var dispatchers: DefaultDispatcherProvider |
|||
private lateinit var viewModel: CalibrationViewModel |
|||
|
|||
private lateinit var sampleConstant: MdbConstant |
|||
private lateinit var sampleMap: CompensationMap |
|||
|
|||
@BeforeEach |
|||
fun setUp() { |
|||
mdbRepository = mockk(relaxed = true) |
|||
dispatchers = DefaultDispatcherProvider() |
|||
viewModel = CalibrationViewModel(mdbRepository, dispatchers) |
|||
|
|||
sampleConstant = MdbConstant( |
|||
idx = 1, |
|||
name = "K_ENG_IDLE_TARGET", |
|||
data = 750.0, |
|||
addr = 0x1020L, |
|||
min = 600.0, |
|||
max = 1200.0, |
|||
attr = MdbAttrType.ATTR_2_UINT16, |
|||
description = "엔진 아이들 목표 속도" |
|||
) |
|||
|
|||
val points = listOf( |
|||
MapPoint(idx = 1, bkp = 1000, data = 100, phy = 25.0), |
|||
MapPoint(idx = 2, bkp = 2000, data = 200, phy = 50.0), |
|||
MapPoint(idx = 3, bkp = 3000, data = 300, phy = 75.0) |
|||
) |
|||
sampleMap = CompensationMap( |
|||
type = CompensationMapType.TYPE_A, |
|||
idx = 1, |
|||
yName = "TB_TQ_OFFSET", |
|||
yAddr = 0x2050L, |
|||
yAttr = MdbAttrType.ATTR_2_UINT16, |
|||
yMin = 0.0, |
|||
yMax = 100.0, |
|||
xName = "RPM_AXIS", |
|||
xAddr = 0x2060L, |
|||
xAttr = MdbAttrType.ATTR_2_UINT16, |
|||
cvsA = 0.25, |
|||
cvsB = 0.0, |
|||
description = "토크 보정 맵", |
|||
points = points |
|||
) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("상수 선택 시 초기 상태가 정상 구성되어야 한다") |
|||
fun testSelectConstantInitialState() { |
|||
viewModel.selectConstant(sampleConstant) |
|||
|
|||
val state = viewModel.uiState.value |
|||
assertEquals(CalibrationEditorMode.CONSTANT, state.mode) |
|||
assertNotNull(state.constantState) |
|||
val constState = state.constantState!! |
|||
assertEquals(750.0, constState.currentValue) |
|||
assertEquals("750.0", constState.textValue) |
|||
assertTrue(constState.isValid) |
|||
assertFalse(constState.isDirty) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("상수 입력값 변경 시 정상 범위이면 isValid=true 및 dirty=true가 되어야 한다") |
|||
fun testConstantValidTextChange() { |
|||
viewModel.selectConstant(sampleConstant) |
|||
viewModel.onConstantTextChanged("850.0") |
|||
|
|||
val state = viewModel.uiState.value.constantState!! |
|||
assertEquals(850.0, state.currentValue) |
|||
assertTrue(state.isValid) |
|||
assertTrue(state.isDirty) |
|||
assertNull(state.errorMessage) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("상수 입력값이 Min/Max 범위를 벗어나면 isValid=false 및 에러 메시지가 설정되어야 한다") |
|||
fun testConstantOutOfRangeValidation() { |
|||
viewModel.selectConstant(sampleConstant) |
|||
|
|||
// 1. Max(1200) 초과 |
|||
viewModel.onConstantTextChanged("1500.0") |
|||
val state1 = viewModel.uiState.value.constantState!! |
|||
assertFalse(state1.isValid) |
|||
assertNotNull(state1.errorMessage) |
|||
|
|||
// 2. Min(600) 미만 |
|||
viewModel.onConstantTextChanged("400.0") |
|||
val state2 = viewModel.uiState.value.constantState!! |
|||
assertFalse(state2.isValid) |
|||
assertNotNull(state2.errorMessage) |
|||
|
|||
// 3. 비정상 텍스트 |
|||
viewModel.onConstantTextChanged("abc") |
|||
val state3 = viewModel.uiState.value.constantState!! |
|||
assertFalse(state3.isValid) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("상수 슬라이더 이동 시 값이 소수점 2자리로 정밀 갱신되어야 한다") |
|||
fun testConstantSliderChange() { |
|||
viewModel.selectConstant(sampleConstant) |
|||
viewModel.onConstantSliderChanged(825.456) |
|||
|
|||
val state = viewModel.uiState.value.constantState!! |
|||
assertEquals(825.46, state.currentValue, 0.01) |
|||
assertTrue(state.isDirty) |
|||
assertTrue(state.isValid) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("상수 초기화(resetConstant) 시 원래 값으로 복원되어야 한다") |
|||
fun testResetConstant() { |
|||
viewModel.selectConstant(sampleConstant) |
|||
viewModel.onConstantTextChanged("900.0") |
|||
assertTrue(viewModel.uiState.value.constantState!!.isDirty) |
|||
|
|||
viewModel.resetConstant() |
|||
val state = viewModel.uiState.value.constantState!! |
|||
assertEquals(750.0, state.currentValue) |
|||
assertFalse(state.isDirty) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("상수 Live Commit 시 MdbRepository.updateConstant가 호출되고 성공 피드백이 갱신되어야 한다") |
|||
fun testCommitConstant() = runTest { |
|||
coEvery { mdbRepository.updateConstant("K_ENG_IDLE_TARGET", 850.0) } returns DctResult.Success(Unit) |
|||
|
|||
viewModel.selectConstant(sampleConstant) |
|||
viewModel.onConstantTextChanged("850.0") |
|||
viewModel.commitConstant() |
|||
|
|||
coVerify { mdbRepository.updateConstant("K_ENG_IDLE_TARGET", 850.0) } |
|||
val state = viewModel.uiState.value |
|||
assertTrue(state.isSuccessFeedback) |
|||
assertNotNull(state.statusMessage) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("보정 맵 선택 시 포인트 목록이 복사되어 초기화되어야 한다") |
|||
fun testSelectCompensationMap() { |
|||
viewModel.selectCompensationMap(sampleMap) |
|||
|
|||
val state = viewModel.uiState.value |
|||
assertEquals(CalibrationEditorMode.COMPENSATION_MAP, state.mode) |
|||
assertNotNull(state.mapState) |
|||
val mapState = state.mapState!! |
|||
assertEquals(3, mapState.editedPoints.size) |
|||
assertFalse(mapState.isDirty) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("보정 맵에서 Raw Data 수정 시 Y=AX+B 공식에 따라 Physical 값이 자동 계산되어야 한다") |
|||
fun testUpdateMapPointRawData() { |
|||
viewModel.selectCompensationMap(sampleMap) |
|||
|
|||
// cvsA = 0.25, cvsB = 0.0 -> Raw=400 입력 시 Phy = 400 * 0.25 + 0.0 = 100.0 |
|||
viewModel.updateMapPoint(index = 0, newBkp = 1000, newRawData = 400, newPhy = null) |
|||
|
|||
val mapState = viewModel.uiState.value.mapState!! |
|||
val pt0 = mapState.editedPoints[0] |
|||
assertEquals(400, pt0.data) |
|||
assertEquals(100.0, pt0.phy, 0.001) |
|||
assertTrue(mapState.isDirty) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("보정 맵에서 Physical 값 수정 시 Raw Data가 역산되어야 한다") |
|||
fun testUpdateMapPointPhysicalValue() { |
|||
viewModel.selectCompensationMap(sampleMap) |
|||
|
|||
// cvsA = 0.25, cvsB = 0.0 -> Phy=60.0 입력 시 Raw = (60.0 - 0.0) / 0.25 = 240 |
|||
viewModel.updateMapPoint(index = 1, newBkp = 2000, newRawData = null, newPhy = 60.0) |
|||
|
|||
val mapState = viewModel.uiState.value.mapState!! |
|||
val pt1 = mapState.editedPoints[1] |
|||
assertEquals(240, pt1.data) |
|||
assertEquals(60.0, pt1.phy, 0.001) |
|||
assertTrue(mapState.isDirty) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("보정 맵 포인트 추가 및 삭제가 정상 동작해야 한다 (최소 2개 보장)") |
|||
fun testAddAndDeleteMapPoint() { |
|||
viewModel.selectCompensationMap(sampleMap) |
|||
assertEquals(3, viewModel.uiState.value.mapState!!.editedPoints.size) |
|||
|
|||
// 1. 포인트 추가 |
|||
viewModel.addMapPoint() |
|||
assertEquals(4, viewModel.uiState.value.mapState!!.editedPoints.size) |
|||
|
|||
// 2. 포인트 삭제 |
|||
viewModel.deleteMapPoint(3) |
|||
assertEquals(3, viewModel.uiState.value.mapState!!.editedPoints.size) |
|||
|
|||
viewModel.deleteMapPoint(2) |
|||
assertEquals(2, viewModel.uiState.value.mapState!!.editedPoints.size) |
|||
|
|||
// 최소 2개 남아있을 때 삭제 시도 -> 삭제되지 않음 |
|||
viewModel.deleteMapPoint(1) |
|||
assertEquals(2, viewModel.uiState.value.mapState!!.editedPoints.size) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("보정 맵 Live Commit 시 MdbRepository로 포인트 목록 및 메타데이터가 정상 저장되어야 한다") |
|||
fun testCommitCompensationMap() = runTest { |
|||
coEvery { mdbRepository.updateCompensationMap(any(), any()) } returns DctResult.Success(Unit) |
|||
coEvery { mdbRepository.updateCompensationMetadata(any(), any(), any(), any(), any(), any(), any()) } returns DctResult.Success(Unit) |
|||
|
|||
viewModel.selectCompensationMap(sampleMap) |
|||
viewModel.addMapPoint() |
|||
viewModel.commitMap() |
|||
|
|||
coVerify { mdbRepository.updateCompensationMap("TB_TQ_OFFSET", any()) } |
|||
coVerify { mdbRepository.updateCompensationMetadata(true, "TB_TQ_OFFSET", any(), any(), any(), any(), any()) } |
|||
assertTrue(viewModel.uiState.value.isSuccessFeedback) |
|||
} |
|||
} |
|||
@ -1,108 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.util.TextStreamDecoder |
|||
import com.dct.app.data.parser.CanDbcParser |
|||
import com.dct.app.domain.model.mdb.CanMultiplexRole |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Assert.assertNotNull |
|||
import org.junit.Test |
|||
import java.io.ByteArrayInputStream |
|||
import java.nio.charset.Charset |
|||
|
|||
class CanDbcParserTest { |
|||
|
|||
@Test |
|||
fun testCanDbcParsingUtf8() { |
|||
val sampleDbc = """ |
|||
VERSION "" |
|||
BO_ 512 ALDC_Status: 8 ALDC |
|||
SG_ ALDC_SysTempVal : 0|8@1+ (1,-40) [-40|150] "℃" Vector__XXX |
|||
SG_ ALDC_PwrMonVal : 8|16@1+ (0.1,0) [0|1000] "W" Vector__XXX |
|||
SG_ ALDC_EwpRpmCtrlVal : 24|16@1+ (1,0) [0|10000] "rpm" Vector__XXX |
|||
""".trimIndent() |
|||
|
|||
val inputStream = ByteArrayInputStream(sampleDbc.toByteArray(Charsets.UTF_8)) |
|||
val signals = CanDbcParser.parseDbc(inputStream) |
|||
|
|||
assertEquals(3, signals.size) |
|||
val tempSig = signals.find { it.name == "ALDC_SysTempVal" } |
|||
assertNotNull(tempSig) |
|||
assertEquals("℃", tempSig!!.unit) |
|||
assertEquals(-40.0, tempSig.cvsB, 0.001) |
|||
assertEquals("ALDC_Status", tempSig.messageName) |
|||
assertEquals(512L, tempSig.messageId) |
|||
} |
|||
|
|||
@Test |
|||
fun testCanDbcParsingEucKrEncodedSpecialUnits() { |
|||
// EUC-KR / CP949 인코딩으로 저장된 DBC 파일 시뮬레이션 |
|||
val rawDbc = """ |
|||
VERSION "" |
|||
BO_ 512 ALDC_Status: 8 ALDC |
|||
SG_ ALDC_SysTempVal : 0|8@1+ (1,-40) [-40|150] "℃" Vector__XXX |
|||
SG_ ALDC_MotorTemp : 8|8@1+ (1,-40) [-40|150] "°C" Vector__XXX |
|||
SG_ ALDC_PwrMonVal : 16|16@1+ (0.1,0) [0|1000] "W" Vector__XXX |
|||
""".trimIndent() |
|||
|
|||
val eucKrCharset = Charset.forName("EUC-KR") |
|||
val bytes = rawDbc.toByteArray(eucKrCharset) |
|||
val inputStream = ByteArrayInputStream(bytes) |
|||
|
|||
val signals = CanDbcParser.parseDbc(inputStream) |
|||
|
|||
assertEquals(3, signals.size) |
|||
val tempSig = signals.find { it.name == "ALDC_SysTempVal" } |
|||
assertNotNull(tempSig) |
|||
assertEquals("℃", tempSig!!.unit) |
|||
|
|||
val motorTempSig = signals.find { it.name == "ALDC_MotorTemp" } |
|||
assertNotNull(motorTempSig) |
|||
assertEquals("°C", motorTempSig!!.unit) |
|||
} |
|||
|
|||
@Test |
|||
fun testCanDbcParsingWindows1252DegreeUnits() { |
|||
// Windows-1252 / ISO-8859-1 (0xB0 0x43 = °C) |
|||
val rawDbc = "BO_ 512 Test: 8 XXX\n SG_ Temp : 0|8@1+ (1,0) [0|100] \"\u00B0C\" XXX\n" |
|||
val winCharset = Charset.forName("windows-1252") |
|||
val bytes = rawDbc.toByteArray(winCharset) |
|||
val inputStream = ByteArrayInputStream(bytes) |
|||
|
|||
val signals = CanDbcParser.parseDbc(inputStream) |
|||
|
|||
assertEquals(1, signals.size) |
|||
assertEquals("°C", signals[0].unit) |
|||
} |
|||
|
|||
@Test |
|||
fun testTextStreamDecoderSanitizeUnit() { |
|||
assertEquals("℃", TextStreamDecoder.sanitizeUnit("\uFFFD\uFFFD")) |
|||
assertEquals("℃", TextStreamDecoder.sanitizeUnit("'C")) |
|||
assertEquals("℃", TextStreamDecoder.sanitizeUnit("deg C")) |
|||
assertEquals("℃", TextStreamDecoder.sanitizeUnit("degC")) |
|||
assertEquals("°", TextStreamDecoder.sanitizeUnit("deg")) |
|||
assertEquals("rpm", TextStreamDecoder.sanitizeUnit("rpm")) |
|||
assertEquals("V", TextStreamDecoder.sanitizeUnit("V")) |
|||
assertEquals("W", TextStreamDecoder.sanitizeUnit("W")) |
|||
} |
|||
|
|||
@Test |
|||
fun `기본 DBC 멀티플렉서 M과 m값을 파싱한다`() { |
|||
val sampleDbc = """ |
|||
BO_ 291 MuxMessage: 8 ECU |
|||
SG_ Mode M : 0|4@1+ (1,0) [0|15] "" ECU |
|||
SG_ Value0 m0 : 8|8@1+ (1,0) [0|255] "" ECU |
|||
SG_ Value7 m7 : 8|8@1+ (1,0) [0|255] "" ECU |
|||
SG_ Always : 16|8@1+ (1,0) [0|255] "" ECU |
|||
""".trimIndent() |
|||
|
|||
val signals = CanDbcParser.parseDbc(ByteArrayInputStream(sampleDbc.toByteArray())) |
|||
|
|||
assertEquals(4, signals.size) |
|||
assertEquals(CanMultiplexRole.MULTIPLEXOR, signals[0].multiplexRole) |
|||
assertEquals(CanMultiplexRole.MULTIPLEXED, signals[1].multiplexRole) |
|||
assertEquals(0L, signals[1].multiplexValue) |
|||
assertEquals(7L, signals[2].multiplexValue) |
|||
assertEquals(CanMultiplexRole.NONE, signals[3].multiplexRole) |
|||
} |
|||
} |
|||
@ -1,212 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.theme.PcColorRef |
|||
import com.dct.app.data.logger.CsvMeasurementLogger |
|||
import com.dct.app.data.logger.Mf4MeasurementLogger |
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.model.formula.FormulaDefinition |
|||
import com.dct.app.domain.model.mdb.CanSignalKey |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import com.dct.app.domain.model.project.DpcProject |
|||
import com.dct.app.domain.model.project.DpcSensorModuleConfig |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.presentation.main.MainUiState |
|||
import com.dct.app.presentation.main.MainViewModel |
|||
import com.dct.app.presentation.main.MeasurementRecordingState |
|||
import kotlinx.coroutines.cancel |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import org.junit.jupiter.params.ParameterizedTest |
|||
import org.junit.jupiter.params.provider.ValueSource |
|||
import java.io.File |
|||
import java.nio.ByteBuffer |
|||
import java.nio.ByteOrder |
|||
import java.util.UUID |
|||
import java.util.zip.Inflater |
|||
|
|||
@Suppress("UNCHECKED_CAST") |
|||
class CanPageRecordingTest { |
|||
@TempDir lateinit var directory: File |
|||
private fun field(target: Any, name: String) = target.javaClass.getDeclaredField(name).also { it.isAccessible = true } |
|||
private val a = SignalDefinition(0, 1, "CanA", MdbAttrType.ATTR_0_UINT8, 2.0, -10.0, "V", 0L, 0.0, 255.0, |
|||
messageId = 0x101, startBit = 0, bitLength = 8) |
|||
private val b = a.copy(idx = 2, name = "CanB", attr = MdbAttrType.ATTR_3_INT16, messageId = 0x102, |
|||
bitLength = 16, cvsA = .1, cvsB = -40.0) |
|||
|
|||
private inner class Fixture(sensorAndFormula: Boolean = false) : AutoCloseable { |
|||
val owner = MainViewModelTest().also { it.setUp() } |
|||
val vm = field(owner, "viewModel").get(owner) as MainViewModel |
|||
val process = MainViewModel::class.java.getDeclaredMethod("processIncomingPacket", DctPacket::class.java, |
|||
Double::class.javaPrimitiveType).also { it.isAccessible = true } |
|||
val csv get() = (field(vm, "activeCsvLoggers").get(vm) as List<CsvMeasurementLogger>).single { |
|||
it.outputFile!!.name.endsWith("_dbc.csv") } |
|||
val mf4 get() = (field(vm, "activeMf4Loggers").get(vm) as List<Mf4MeasurementLogger>).single { |
|||
it.outputFile!!.name.endsWith("_dbc.mf4") } |
|||
var start = 0L |
|||
var sequence = 0L |
|||
init { |
|||
vm.setCurrentProject(DpcProject(projectFileName = "PAGES.dpc", canDbcFileName = "fixture.dbc", |
|||
measuredFilesFolder = directory.resolve(UUID.randomUUID().toString()).absolutePath, |
|||
writeCsv = true, writeMf4 = true, csvWithMilliseconds = true, |
|||
sensorModules = listOf(DpcSensorModuleConfig(0, isUsed = sensorAndFormula)))) |
|||
(field(vm, "_canSignals").get(vm) as MutableStateFlow<List<SignalDefinition>>).value = listOf(a, b) |
|||
val ui = field(vm, "_uiState").get(vm) as MutableStateFlow<MainUiState> |
|||
ui.value = ui.value.copy(isConnected = true, isMeasuring = true) |
|||
if (sensorAndFormula) vm.addFormula(FormulaDefinition(name = "F", expression = "CanA*2")) |
|||
vm.chartRenderer.bindSignal(CanSignalKey.stable(a), a.name, AxisPosition.LEFT_0, PcColorRef.DEFAULT_DASHBOARD) |
|||
vm.chartRenderer.bindSignal(CanSignalKey.stable(b), b.name, AxisPosition.LEFT_0, PcColorRef.DEFAULT_DASHBOARD) |
|||
startRecording() |
|||
} |
|||
fun startRecording() { |
|||
vm.startMeasurementRecording() |
|||
assertEquals(MeasurementRecordingState.RECORDING, vm.uiState.value.recordingState) |
|||
start = vm.uiState.value.recordingStartedAtMillis!! |
|||
} |
|||
fun can(page: Int, total: Int, offset: Long, vararg frames: Pair<Int, ByteArray>, notReceived: Boolean = false) { |
|||
val payload = byteArrayOf(2, page.toByte(), total.toByte(), frames.size.toByte()) + frames.fold(byteArrayOf()) { out, (id, data) -> |
|||
out + byteArrayOf((id ushr 8).toByte(), id.toByte(), (data.size or if (notReceived) 128 else 0).toByte()) + data |
|||
} |
|||
receive(DctPacket(0xA3.toByte(), payload, receivedAtMillis = start + offset, ingressSequence = ++sequence)) |
|||
} |
|||
fun receive(packet: DctPacket) = process.invoke(vm, packet, packet.receivedAtMillis / 1000.0) |
|||
fun stop() = vm.stopMeasurementRecording() |
|||
override fun close() { |
|||
stop() |
|||
vm.scope.cancel() |
|||
vm.chartRenderer.stop() |
|||
owner.tearDown() |
|||
} |
|||
} |
|||
|
|||
private fun csvRows(file: File) = file.readLines().drop(7).filter { it.isNotBlank() } |
|||
.map { line -> line.split(',').map(String::trim) } |
|||
private fun binary(file: File) = ByteBuffer.wrap(file.readBytes()).order(ByteOrder.LITTLE_ENDIAN) |
|||
private fun records(file: File): ByteBuffer { |
|||
val data = binary(file) |
|||
val recordSize = data.getInt(232 + 96) |
|||
val hl = data.getLong(168 + 40).toInt() |
|||
val dl = data.getLong(hl + 24).toInt() |
|||
if (dl == 0) return ByteBuffer.allocate(0) |
|||
val dz = data.getLong(dl + 32).toInt() |
|||
val rawSize = data.getLong(dz + 32).toInt() |
|||
val compressedSize = data.getLong(dz + 40).toInt() |
|||
val transposed = ByteArray(rawSize) |
|||
val inflater = Inflater() |
|||
try { |
|||
inflater.setInput(data.array(), dz + 48, compressedSize) |
|||
assertEquals(rawSize, inflater.inflate(transposed)) |
|||
assertTrue(inflater.finished()) |
|||
} finally { inflater.end() } |
|||
val count = rawSize / recordSize |
|||
val raw = ByteArray(rawSize) |
|||
for (column in 0 until recordSize) for (row in 0 until count) { |
|||
raw[row * recordSize + column] = transposed[column * count + row] |
|||
} |
|||
return ByteBuffer.wrap(raw).order(ByteOrder.LITTLE_ENDIAN) |
|||
} |
|||
|
|||
@Test fun fourPagesUpdateGraphsImmediatelyButWriteOneFullSnapshotAtTheLastPage() { |
|||
Fixture().use { f -> |
|||
val csv = f.csv.outputFile!!; val mf4 = f.mf4.outputFile!! |
|||
f.can(1, 4, 100, 0x101 to byteArrayOf(12)) |
|||
f.can(2, 4, 200, 0x102 to byteArrayOf(0xF4.toByte(), 1)) // Raw 500. |
|||
f.can(3, 4, 300, 0x101 to byteArrayOf(20)) |
|||
assertEquals(0L, f.vm.uiState.value.recordingSampleCount) |
|||
assertEquals(2, f.vm.chartRenderer.seriesListFlow.value.first { it.signalName == "CanA" }.buffer.size) |
|||
assertEquals(30.0, f.vm.liveTelemetryValues.value["CanA"]) |
|||
f.can(4, 4, 400, 0x102 to byteArrayOf(0x58, 2)) // Raw 600. |
|||
assertEquals(1L, f.vm.uiState.value.recordingSampleCount) |
|||
f.stop() |
|||
val rows = csvRows(csv) |
|||
assertEquals(1, rows.size) |
|||
assertEquals("0", rows.single()[1]) |
|||
assertEquals(30.0, rows.single()[2].toDouble()) |
|||
assertEquals(20.0, rows.single()[3].toDouble()) |
|||
assertEquals(1L, binary(mf4).getLong(232 + 80)) |
|||
val raw = records(mf4) |
|||
assertEquals(.4, raw.double, 0.000001) |
|||
assertEquals(20, raw.get().toInt() and 255) |
|||
assertEquals(600, raw.short.toInt()) |
|||
assertFalse(raw.hasRemaining()) |
|||
} |
|||
} |
|||
|
|||
@ParameterizedTest @ValueSource(ints = [0, 1, 2]) |
|||
fun finalPageWithNoNewDecodedSignalsStillWritesEarlierPageValues(lastKind: Int) { |
|||
Fixture().use { f -> |
|||
val csv = f.csv.outputFile!!; val mf4 = f.mf4.outputFile!! |
|||
f.can(1, 2, 100, 0x101 to byteArrayOf(12)) |
|||
assertEquals(0L, f.vm.uiState.value.recordingSampleCount) |
|||
when (lastKind) { |
|||
0 -> f.can(2, 2, 200) |
|||
1 -> f.can(2, 2, 200, 0x777 to byteArrayOf(1)) |
|||
else -> f.can(2, 2, 200, 0x102 to byteArrayOf(0, 0), notReceived = true) |
|||
} |
|||
f.stop() |
|||
assertEquals(14.0, csvRows(csv).single()[2].toDouble()) |
|||
assertEquals("No value", csvRows(csv).single()[3]) |
|||
val raw = records(mf4) |
|||
assertEquals(.2, raw.double, 0.000001) |
|||
assertEquals(12, raw.get().toInt() and 255) |
|||
assertEquals(0, raw.short.toInt()) |
|||
assertEquals(1L, f.vm.uiState.value.recordingSampleCount) |
|||
} |
|||
} |
|||
|
|||
@ParameterizedTest @ValueSource(ints = [0, 1]) |
|||
fun equalSinglePageNumbersRecordEveryPacket(page: Int) { |
|||
Fixture().use { f -> |
|||
val csv = f.csv.outputFile!!; val mf4 = f.mf4.outputFile!! |
|||
f.can(page, page, 100, 0x101 to byteArrayOf(12)) |
|||
f.can(page, page, 200, 0x101 to byteArrayOf(20)) |
|||
f.stop() |
|||
assertEquals(2, csvRows(csv).size) |
|||
assertEquals(2L, binary(mf4).getLong(232 + 80)) |
|||
} |
|||
} |
|||
|
|||
@Test fun interleavedSensorAndFormulaRecordingDoesNotWriteAnExtraCanRow() { |
|||
Fixture(sensorAndFormula = true).use { f -> |
|||
val loggers = field(f.vm, "activeCsvLoggers").get(f.vm) as List<CsvMeasurementLogger> |
|||
val csv = f.csv.outputFile!!; val mf4 = f.mf4.outputFile!! |
|||
val formula = loggers.single { it.outputFile!!.name.endsWith("_formula.csv") }.outputFile!! |
|||
val sensor = loggers.single { it.outputFile!!.name.endsWith("_sm.csv") }.outputFile!! |
|||
f.can(1, 2, 100, 0x101 to byteArrayOf(12)) |
|||
f.receive(DctPacket(0xA4.toByte(), byteArrayOf(1, 0, 1, 0, 0, 25, 0, 0), receivedAtMillis = f.start + 150)) |
|||
f.can(2, 2, 200, 0x102 to byteArrayOf(0xF4.toByte(), 1)) |
|||
f.stop() |
|||
assertEquals(1, csvRows(csv).size) |
|||
assertEquals(1L, binary(mf4).getLong(232 + 80)) |
|||
assertEquals(1, csvRows(formula).size) |
|||
assertEquals(28.0, csvRows(formula).single()[2].toDouble()) |
|||
assertEquals(1, csvRows(sensor).size) |
|||
assertEquals(25.0, csvRows(sensor).single()[2].toDouble()) |
|||
assertEquals(3L, f.vm.uiState.value.recordingSampleCount) |
|||
} |
|||
} |
|||
|
|||
@Test fun stoppingBeforeTheLastPageAndRestartingKeepsFilesAndCountersSeparate() { |
|||
Fixture().use { f -> |
|||
val firstCsv = f.csv.outputFile!!; val firstMf4 = f.mf4.outputFile!! |
|||
f.can(1, 2, 100, 0x101 to byteArrayOf(12)) |
|||
f.stop() |
|||
assertTrue(csvRows(firstCsv).isEmpty()) |
|||
assertEquals(0L, binary(firstMf4).getLong(232 + 80)) |
|||
f.startRecording() |
|||
val secondCsv = f.csv.outputFile!!; val secondMf4 = f.mf4.outputFile!! |
|||
f.can(2, 2, 200, 0x102 to byteArrayOf(0xF4.toByte(), 1)) |
|||
f.stop() |
|||
assertEquals(1, csvRows(secondCsv).size) |
|||
assertEquals(14.0, csvRows(secondCsv).single()[2].toDouble()) |
|||
assertEquals(1L, binary(secondMf4).getLong(232 + 80)) |
|||
val raw = records(secondMf4) |
|||
raw.double |
|||
assertEquals(12, raw.get().toInt() and 255) |
|||
assertEquals(500, raw.short.toInt()) |
|||
assertEquals(1L, f.vm.uiState.value.recordingSampleCount) |
|||
} |
|||
} |
|||
} |
|||
@ -1,44 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.mdb.CanSignalKey |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import org.junit.Assert.assertEquals |
|||
import org.junit.Assert.assertNotEquals |
|||
import org.junit.Assert.assertSame |
|||
import org.junit.Test |
|||
|
|||
class CanSignalKeyTest { |
|||
private fun signal(idx: Int, messageId: Long, name: String) = SignalDefinition( |
|||
reclid = 0, |
|||
idx = idx, |
|||
name = name, |
|||
attr = MdbAttrType.ATTR_0_UINT8, |
|||
cvsA = 1.0, |
|||
cvsB = 0.0, |
|||
unit = "", |
|||
color = 0L, |
|||
min = 0.0, |
|||
max = 255.0, |
|||
messageId = messageId |
|||
) |
|||
|
|||
@Test |
|||
fun stableKeyDoesNotDependOnParserIndex() { |
|||
val first = signal(1, 0x123, "VehicleSpeed") |
|||
val reparsed = signal(999, 0x123, "VehicleSpeed") |
|||
|
|||
assertEquals(CanSignalKey.stable(first), CanSignalKey.stable(reparsed)) |
|||
assertNotEquals(CanSignalKey.legacy(first), CanSignalKey.legacy(reparsed)) |
|||
} |
|||
|
|||
@Test |
|||
fun findsStableAndLegacyProjectKeys() { |
|||
val target = signal(7, 0x456, "MotorTorque") |
|||
val signals = listOf(target) |
|||
|
|||
assertSame(target, CanSignalKey.find("can_1110_MotorTorque", signals)) |
|||
assertSame(target, CanSignalKey.find("can_7", signals)) |
|||
assertSame(target, CanSignalKey.find("can_7_MotorTorque", signals)) |
|||
} |
|||
} |
|||
@ -1,253 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.model.chart.TimeWindowPreset |
|||
import com.dct.app.domain.usecase.chart.ChartBatchRenderer |
|||
import kotlinx.coroutines.test.StandardTestDispatcher |
|||
import kotlinx.coroutines.test.TestScope |
|||
import kotlinx.coroutines.test.advanceTimeBy |
|||
import kotlinx.coroutines.test.runCurrent |
|||
import kotlinx.coroutines.test.runTest |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class) |
|||
class ChartContinuousScrollTest { |
|||
private val presets = TimeWindowPreset.entries.filter { it.tickIntervalSec != null } |
|||
private fun TestScope.renderer() = ChartBatchRenderer(TestDispatcherProvider(StandardTestDispatcher(testScheduler))).apply { |
|||
bindSignal("s", "Signal", AxisPosition.LEFT_0, 0xFF0000L) |
|||
} |
|||
private fun ChartBatchRenderer.sample(time: Double) = addSampleSec("s", time, 1.0) |
|||
|
|||
@Test fun allFixedPresetsHoldRangeBetweenBoundaryJumps() = runTest { |
|||
for (preset in presets) { |
|||
val r = renderer() |
|||
r.sample(10000.0 - preset.displaySpanSec) |
|||
r.sample(10000.0) |
|||
r.setTimeWindow(preset) |
|||
for (time in listOf(10000.016, 10000.033, 10000.1, 10001.0, 10002.0)) { |
|||
r.sample(time) |
|||
val frame = r.buildSnapshot(600) |
|||
assertEquals(10000.016 + preset.tickIntervalSec!!, frame.timeMaxSec, 1e-8) |
|||
assertEquals(preset.displaySpanSec, frame.timeMaxSec - frame.timeMinSec, 1e-8) |
|||
assertEquals(preset, frame.xAxisPreset) |
|||
assertTrue(frame.isXAxisAuto) |
|||
} |
|||
} |
|||
} |
|||
|
|||
@Test fun clearRetainsInitialSixIntervalsThenJumpsByTick() = runTest { |
|||
for (preset in presets) { |
|||
val r = renderer() |
|||
r.setTimeWindow(preset) |
|||
r.clearAllData() |
|||
r.sample(10000.0) |
|||
val end = 10000.0 + preset.resetSpanSec |
|||
assertEquals(end, r.buildSnapshot(600).timeMaxSec) |
|||
r.sample(end - .1) |
|||
assertEquals(end, r.buildSnapshot(600).timeMaxSec) |
|||
r.sample(end) |
|||
assertEquals(end + preset.tickIntervalSec!!, r.buildSnapshot(600).timeMaxSec) |
|||
r.sample(end + .016) |
|||
val frame = r.buildSnapshot(600) |
|||
assertEquals(end + preset.tickIntervalSec!!, frame.timeMaxSec, 1e-8) |
|||
assertEquals(preset.resetSpanSec, frame.timeMaxSec - frame.timeMinSec, 1e-8) |
|||
} |
|||
} |
|||
|
|||
@Test fun clearSamplesOnlyKeepsGraphItemsAndOptions() = runTest { |
|||
val r = renderer() |
|||
r.setTimeWindow(TimeWindowPreset.SEC_10) |
|||
r.setYAxisRange(-5.0, 25.0) |
|||
r.setLegendPosition(2) |
|||
r.setSeriesColor("s", 0x00FF00L) |
|||
r.setSeriesThickness("s", 4.0f) |
|||
r.addSampleSec("s", 1000.0, 2.0) |
|||
r.addSampleSec("s", 1010.0, 4.0) |
|||
val before = r.exportWorkspaceState() |
|||
|
|||
r.clearSamplesOnly() |
|||
|
|||
val series = r.seriesListFlow.value.single() |
|||
val after = r.exportWorkspaceState() |
|||
assertEquals(1, r.seriesListFlow.value.size, "Signal item must remain bound") |
|||
assertEquals(0, series.buffer.size, "Only samples must be removed") |
|||
assertEquals(before.axes, after.axes) |
|||
assertEquals(before.timeWindowSec, after.timeWindowSec) |
|||
assertEquals(before.timeWindowPreset, after.timeWindowPreset) |
|||
assertEquals(before.isAutoTimeWindow, after.isAutoTimeWindow) |
|||
assertEquals(before.isXAxisAuto, after.isXAxisAuto) |
|||
assertEquals(before.isYAxisAuto, after.isYAxisAuto) |
|||
assertEquals(before.legendPosition, after.legendPosition) |
|||
assertEquals(0x00FF00L, series.color) |
|||
assertEquals(4.0f, series.lineWidthDp) |
|||
} |
|||
|
|||
@Test fun firstBatchLargerThanWindowDoesNotAllocateAnExtraBlankTick() = runTest { |
|||
val r = renderer() |
|||
r.setTimeWindow(TimeWindowPreset.SEC_10) |
|||
r.sample(1000.0) |
|||
r.sample(1500.0) |
|||
val frame = r.buildSnapshot(600) |
|||
assertEquals(1500.0, frame.timeMaxSec) |
|||
assertEquals(1460.0, frame.timeMinSec) |
|||
} |
|||
|
|||
@Test fun holdAccumulatesFromFirstSampleAndKeepsWholeRecordingVisible() = runTest { |
|||
val r = renderer() |
|||
r.setTimeWindow(TimeWindowPreset.HOLD) |
|||
r.sample(1000.0) |
|||
val initial = r.buildSnapshot(600) |
|||
assertEquals(1000.0, initial.timeMinSec, 1e-8) |
|||
assertEquals(1060.0, initial.timeMaxSec, 1e-8) |
|||
assertFalse(initial.isXAxisAuto) |
|||
assertEquals(TimeWindowPreset.HOLD, initial.xAxisPreset) |
|||
|
|||
r.sample(1010.0) |
|||
val withinInitialSpan = r.buildSnapshot(600) |
|||
assertEquals(1000.0, withinInitialSpan.timeMinSec, 1e-8) |
|||
assertEquals(1060.0, withinInitialSpan.timeMaxSec, 1e-8) |
|||
|
|||
r.sample(1100.0) |
|||
val accumulated = r.buildSnapshot(600) |
|||
assertEquals(1000.0, accumulated.timeMinSec, 1e-8) |
|||
assertEquals(1110.0, accumulated.timeMaxSec, 1e-8) |
|||
|
|||
r.sample(2000.0) |
|||
val later = r.buildSnapshot(600) |
|||
assertEquals(1000.0, later.timeMinSec, 1e-8) |
|||
assertEquals(2030.0, later.timeMaxSec, 1e-8) |
|||
|
|||
// Hold guarantees both endpoints stay visible; historical panning is |
|||
// available after explicitly switching to Manual/zooming. |
|||
r.panTimeWindow(-100.0) |
|||
val stillFit = r.buildSnapshot(600) |
|||
assertEquals(1000.0, stillFit.timeMinSec, 1e-8) |
|||
assertEquals(later.timeMaxSec, stillFit.timeMaxSec, 1e-8) |
|||
} |
|||
|
|||
@Test fun holdWaitsForEachBoundaryThenAddsOneCurrentTickInBothGraphLayouts() = runTest { |
|||
for (axis in listOf(AxisPosition.LEFT_0, AxisPosition.LEFT_1)) { |
|||
val r = ChartBatchRenderer(TestDispatcherProvider(StandardTestDispatcher(testScheduler))) |
|||
r.bindSignal("s", "Signal", axis, 0xFF0000L) |
|||
r.setTimeWindow(TimeWindowPreset.HOLD) |
|||
r.sample(1000.0) |
|||
var before = r.buildSnapshot(600) |
|||
repeat(12) { |
|||
r.sample(before.timeMaxSec - 0.033) |
|||
assertEquals(before.timeMaxSec, r.buildSnapshot(600).timeMaxSec, 1e-8) |
|||
val step = com.dct.app.domain.model.chart.ChartAxisTicks.time( |
|||
before.timeMinSec, before.timeMaxSec, 600f, TimeWindowPreset.HOLD).interval.seconds |
|||
r.sample(before.timeMaxSec) |
|||
val expanded = r.buildSnapshot(600) |
|||
assertEquals(1000.0, expanded.timeMinSec, 1e-8) |
|||
assertEquals(before.timeMaxSec + step, expanded.timeMaxSec, 1e-8) |
|||
assertEquals(expanded.timeMaxSec, r.buildSnapshot(600).timeMaxSec, 1e-8, |
|||
"Rendering the same sample must not keep expanding the range") |
|||
r.sample(before.timeMaxSec + 0.033) |
|||
assertEquals(expanded.timeMaxSec, r.buildSnapshot(600).timeMaxSec, 1e-8) |
|||
before = expanded |
|||
} |
|||
} |
|||
} |
|||
|
|||
@Test fun holdUsesEachWindowsTickAndKeepsOptionsAndSamplesThroughClearAndRestore() = runTest { |
|||
val wide = renderer() |
|||
val narrow = renderer() |
|||
for (r in listOf(wide, narrow)) { |
|||
r.setTimeWindow(TimeWindowPreset.HOLD) |
|||
r.setYAxisRange(-10.0, 10.0) |
|||
r.setLegendPosition(2) |
|||
r.sample(1000.0) |
|||
} |
|||
val wideBefore = wide.buildSnapshot(1200) |
|||
val narrowBefore = narrow.buildSnapshot(300) |
|||
wide.sample(wideBefore.timeMaxSec) |
|||
narrow.sample(narrowBefore.timeMaxSec) |
|||
assertEquals(1065.0, wide.buildSnapshot(1200).timeMaxSec) |
|||
assertEquals(1090.0, narrow.buildSnapshot(300).timeMaxSec) |
|||
wide.sample(1060.1) |
|||
assertEquals(1065.0, wide.buildSnapshot(1200).timeMaxSec) |
|||
val state = wide.exportWorkspaceState() |
|||
val frame = wide.buildSnapshot(1200) |
|||
assertEquals(-10.0, frame.axesConfig.getValue(AxisPosition.LEFT_0).minVal) |
|||
assertEquals(3, wide.seriesListFlow.value.single().buffer.size) |
|||
val restored = renderer() |
|||
restored.restoreWorkspaceState(wide.seriesListFlow.value, state) |
|||
restored.sample(2000.0) |
|||
assertEquals(2060.0, restored.buildSnapshot(600).timeMaxSec) |
|||
assertEquals(TimeWindowPreset.HOLD, restored.buildSnapshot(600).xAxisPreset) |
|||
wide.clearSamplesOnly() |
|||
wide.sample(3000.0) |
|||
assertEquals(3000.0, wide.buildSnapshot(1200).timeMinSec) |
|||
assertEquals(3060.0, wide.buildSnapshot(1200).timeMaxSec) |
|||
assertEquals(state.axes, wide.exportWorkspaceState().axes) |
|||
assertEquals(state.legendPosition, wide.exportWorkspaceState().legendPosition) |
|||
} |
|||
|
|||
@Test fun selectingHoldWithExistingHistoryFitsEntireRecordingThenWaitsForBoundary() = runTest { |
|||
val r = renderer() |
|||
r.sample(1000.0) |
|||
r.sample(2000.0) |
|||
r.setTimeWindow(TimeWindowPreset.HOLD) |
|||
val initial = r.buildSnapshot(600) |
|||
assertEquals(1000.0, initial.timeMinSec) |
|||
assertTrue(initial.timeMaxSec > 2000.0) |
|||
r.sample(2000.033) |
|||
assertEquals(initial.timeMaxSec, r.buildSnapshot(600).timeMaxSec) |
|||
r.resetPan() |
|||
val reset = r.buildSnapshot(600) |
|||
assertEquals(1000.0, reset.timeMinSec) |
|||
assertTrue(reset.timeMaxSec >= 2000.033) |
|||
assertEquals(TimeWindowPreset.HOLD, reset.xAxisPreset) |
|||
} |
|||
|
|||
@Test fun renderFlowRollsAtFrameCadenceAndStopsMovingWhenSamplesStop() = runTest { |
|||
val r = renderer() |
|||
r.sample(960.0) |
|||
r.sample(1000.0) |
|||
r.setTimeWindow(TimeWindowPreset.SEC_10) |
|||
r.start(backgroundScope) |
|||
r.resume() |
|||
runCurrent() |
|||
for (time in listOf(1000.033, 1000.066, 1000.099)) { |
|||
r.sample(time) |
|||
advanceTimeBy(20) |
|||
runCurrent() |
|||
assertEquals(1010.033, r.renderSnapshotFlow.value.timeMaxSec, 1e-8) |
|||
} |
|||
advanceTimeBy(1000) |
|||
runCurrent() |
|||
assertEquals(1010.033, r.renderSnapshotFlow.value.timeMaxSec, 1e-8) |
|||
} |
|||
|
|||
@Test fun historyBrowsingStillFreezesAndDoubleTapReturnsToContinuousPresetTracking() = runTest { |
|||
val r = renderer() |
|||
r.sample(700.0) |
|||
r.sample(1000.0) |
|||
r.setTimeWindow(TimeWindowPreset.MIN_1) |
|||
r.panTimeWindow(-50.0) |
|||
r.sample(2000.0) |
|||
assertEquals(950.0, r.buildSnapshot(600).timeMaxSec) |
|||
r.resetPan() |
|||
r.sample(2000.033) |
|||
val frame = r.buildSnapshot(600) |
|||
assertEquals(2060.033, frame.timeMaxSec, 1e-8) |
|||
assertEquals(300.0, frame.timeMaxSec - frame.timeMinSec, 1e-8) |
|||
assertEquals(TimeWindowPreset.MIN_1, frame.xAxisPreset) |
|||
} |
|||
|
|||
@Test fun rollingWindowsDoNotChangeOtherWindowsInitialFillRange() = runTest { |
|||
val a = renderer() |
|||
val b = renderer() |
|||
a.sample(960.0) |
|||
a.sample(1000.0) |
|||
a.setTimeWindow(TimeWindowPreset.SEC_10) |
|||
b.setTimeWindow(TimeWindowPreset.MIN_1) |
|||
b.sample(1000.0) |
|||
val before = b.buildSnapshot(600) |
|||
a.sample(1000.5) |
|||
assertEquals(1010.5, a.buildSnapshot(600).timeMaxSec) |
|||
assertEquals(before.timeMaxSec, b.buildSnapshot(600).timeMaxSec) |
|||
} |
|||
} |
|||
@ -1,138 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.ringbuffer.TimeSeriesRingBuffer |
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.model.chart.InterpolationMode |
|||
import com.dct.app.domain.usecase.chart.ChartBatchRenderer |
|||
import kotlinx.coroutines.test.StandardTestDispatcher |
|||
import kotlinx.coroutines.test.TestScope |
|||
import kotlinx.coroutines.test.advanceTimeBy |
|||
import kotlinx.coroutines.test.runCurrent |
|||
import kotlinx.coroutines.test.runTest |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class) |
|||
class ChartCursorStabilityTest { |
|||
private fun TestScope.renderer() = ChartBatchRenderer(TestDispatcherProvider(StandardTestDispatcher(testScheduler))).apply { |
|||
bindSignal("s", "Signal", AxisPosition.LEFT_0, 0xFF0000L) |
|||
addSampleSec("s", 0.0, 10.0) |
|||
addSampleSec("s", 2.0, 20.0) |
|||
setTimeWindow(2.0) |
|||
} |
|||
private fun ChartBatchRenderer.value(width: Int = 600) = buildSnapshot(width).seriesList.single().cursorValue |
|||
|
|||
@Test fun originalSamplesRemainStableAcrossDownsamplingScrollingAndZoom() = runTest { |
|||
val r = renderer() |
|||
for (i in 201..1000) r.addSampleSec("s", i / 100.0, (i % 7).toDouble()) |
|||
r.setTimeWindow(10.0) |
|||
r.setCrosshairTimeSec(2.035) |
|||
assertEquals(0.5, r.value()!!, 1e-10) |
|||
val oldPoints = r.buildSnapshot(2).seriesList.single().points |
|||
for (i in 1001..1030) r.addSampleSec("s", i / 100.0, (i % 7).toDouble()) |
|||
for (width in listOf(1, 2, 10, 1200)) assertEquals(0.5, r.value(width)!!, 1e-10) |
|||
assertNotEquals(oldPoints, r.buildSnapshot(2).seriesList.single().points) |
|||
r.panTimeWindow(-1.0) |
|||
r.zoomTimeWindow(2f, .5) |
|||
assertEquals(0.5, r.value()!!, 1e-10) |
|||
} |
|||
|
|||
@Test fun linearPulseAndExactTransitionUseCapturedOriginalNeighbors() = runTest { |
|||
val r = renderer() |
|||
r.setCrosshairTimeSec(1.0) |
|||
assertEquals(15.0, r.value()) |
|||
r.setGraphInterpolationMode(InterpolationMode.PWM_STEP) |
|||
assertEquals(10.0, r.value()) |
|||
r.setCrosshairTimeSec(2.0) |
|||
assertEquals(20.0, r.value()) |
|||
r.setSeriesInterpolationMode("s", InterpolationMode.LINEAR) |
|||
assertEquals(20.0, r.value()) |
|||
} |
|||
|
|||
@Test fun overwritesAndEvictionDoNotChangeSelectionButRetappingRefreshes() = runTest { |
|||
val r = renderer() |
|||
r.setCrosshairTimeSec(2.0) |
|||
r.addSampleSec("s", 2.0, 99.0) |
|||
assertEquals(20.0, r.value()) |
|||
r.setCrosshairTimeSec(2.0) |
|||
assertEquals(99.0, r.value()) |
|||
for (i in 3..100003) r.addSampleSec("s", i.toDouble(), -1.0) |
|||
assertEquals(99.0, r.value()) |
|||
r.setCrosshairTimeSec(2.0) |
|||
assertNull(r.value()) |
|||
} |
|||
|
|||
@Test fun missingDataDoesNotFollowLatestOrBecomeAValueUntilReselected() = runTest { |
|||
val r = renderer() |
|||
for (time in listOf(-1.0, 3.0, Double.NaN, Double.POSITIVE_INFINITY)) { |
|||
r.setCrosshairTimeSec(time) |
|||
assertNull(r.value()) |
|||
} |
|||
r.setCrosshairTimeSec(3.0) |
|||
r.addSampleSec("s", 3.0, 30.0) |
|||
assertNull(r.value()) |
|||
r.setCrosshairTimeSec(3.0) |
|||
assertEquals(30.0, r.value()) |
|||
} |
|||
|
|||
@Test fun resetClearAndRebindCannotReusePreviousSelection() = runTest { |
|||
val r = renderer() |
|||
r.setCrosshairTimeSec(1.0) |
|||
r.resetPan() |
|||
assertNull(r.value()) |
|||
r.setCrosshairTimeSec(1.0) |
|||
r.clearAllData() |
|||
assertNull(r.value()) |
|||
r.addSampleSec("s", 1.0, 30.0) |
|||
r.setCrosshairTimeSec(1.0) |
|||
r.unbindSignal("s") |
|||
r.bindSignal("s", "Replacement", AxisPosition.RIGHT_0, 0xFF00FFL) |
|||
r.addSampleSec("s", 1.0, 50.0) |
|||
assertNull(r.value()) |
|||
r.setCrosshairTimeSec(1.0) |
|||
assertEquals(50.0, r.value()) |
|||
r.setCrosshairTimeSec(null) |
|||
assertNull(r.renderSnapshotFlow.value.crosshairTimeSec) |
|||
assertNull(r.renderSnapshotFlow.value.seriesList.single().cursorValue) |
|||
} |
|||
|
|||
@Test fun liveFramesKeepValuesWhileScrollingAndMetadataStillUpdatesOnAllAxes() = runTest { |
|||
val r = renderer() |
|||
r.bindSignal("other", "Other", AxisPosition.RIGHT_0, 0xFF00FFL) |
|||
r.addSampleSec("other", 0.0, 100.0) |
|||
r.addSampleSec("other", 2.0, 200.0) |
|||
r.setSeriesVisible("other", false) |
|||
r.setCrosshairTimeSec(1.0) |
|||
r.start(backgroundScope) |
|||
r.resume() |
|||
runCurrent() |
|||
r.addSampleSec("s", 2.1, 999.0) |
|||
advanceTimeBy(20) |
|||
runCurrent() |
|||
val live = r.renderSnapshotFlow.value |
|||
assertTrue(live.timeMaxSec > 2.1, "Live edge reserves the next tick without changing sample values") |
|||
assertEquals(1.0, live.crosshairTimeSec) |
|||
assertEquals(listOf(15.0, 150.0), live.seriesList.map { it.cursorValue }) |
|||
r.setSeriesVisible("other", true) |
|||
r.setSeriesColor("other", 0xFFFFFFFFL) |
|||
val other = r.renderSnapshotFlow.value.seriesList.last() |
|||
assertTrue(other.isVisible) |
|||
assertEquals(0x00FFFFFFL, other.color) |
|||
assertEquals(150.0, other.cursorValue) |
|||
} |
|||
|
|||
@Test fun ringCaptureHandlesEmptyExactSingleAndWrappedBuffersWithoutClamping() { |
|||
val b = TimeSeriesRingBuffer(3) |
|||
assertTrue(b.captureAt(1.0).isEmpty()) |
|||
b.addSample(1.0, 10.0) |
|||
assertEquals(listOf(1.0 to 10.0), b.captureAt(1.0)) |
|||
assertTrue(b.captureAt(1.1).isEmpty()) |
|||
for (i in 2..4) b.addSample(i.toDouble(), i * 10.0) |
|||
val captured = b.captureAt(2.5) |
|||
assertEquals(listOf(2.0 to 20.0, 3.0 to 30.0), captured) |
|||
assertTrue(b.captureAt(1.0).isEmpty()) |
|||
assertTrue(b.captureAt(Double.NaN).isEmpty()) |
|||
b.clear() |
|||
assertEquals(listOf(2.0 to 20.0, 3.0 to 30.0), captured) |
|||
} |
|||
} |
|||
@ -1,49 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.model.chart.InterpolationMode |
|||
import com.dct.app.domain.model.chart.SeriesRenderData |
|||
import com.dct.app.presentation.chart.chartCursorTooltipRows |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class ChartCursorTooltipTest { |
|||
private fun series() = SeriesRenderData( |
|||
signalId = "sig_1_1", signalName = "Voltage", axisPosition = AxisPosition.LEFT_0, |
|||
color = 0x0000FFL, unit = "V", lineWidthDp = 1f, |
|||
interpolationMode = InterpolationMode.LINEAR, isVisible = true, |
|||
points = listOf(0.0 to 10.0, 2.0 to 20.0), |
|||
latestValue = 20.0, minVisibleValue = 10.0, maxVisibleValue = 20.0, cursorValue = 15.0 |
|||
) |
|||
|
|||
@Test fun tooltipValuesStayOpaqueWhiteRegardlessOfSignalColor() { |
|||
for (color in listOf(0x000000L, 0x0000FFL, 0xFF0000L, 0x00FF00L, 0xFFFFFFFFL)) { |
|||
val row = chartCursorTooltipRows(listOf(series().copy(color = color))).single() |
|||
assertEquals(0xFFFFFFFF.toInt(), row.valueColorArgb) |
|||
} |
|||
} |
|||
|
|||
@Test fun linearShowsCursorValueAndUnitInsteadOfLatestValue() { |
|||
val row = chartCursorTooltipRows(listOf(series())).single() |
|||
assertEquals("Voltage", row.name) |
|||
assertEquals("15.00 V", row.value) |
|||
} |
|||
|
|||
@Test fun displayPointsCannotChangeCapturedCursorValue() { |
|||
val signal = series().copy(points = listOf(0.0 to 999.0, 2.0 to -999.0), latestValue = -999.0) |
|||
assertEquals("15.00 V", chartCursorTooltipRows(listOf(signal)).single().value) |
|||
assertEquals("15.00 V", chartCursorTooltipRows(listOf(signal.copy(points = emptyList()))).single().value) |
|||
} |
|||
|
|||
@Test fun missingAndNonFiniteValuesAreExplicitAndHiddenSignalsAreOmitted() { |
|||
assertEquals("N/A", chartCursorTooltipRows(listOf(series().copy(cursorValue = null))).single().value) |
|||
assertEquals("N/A", chartCursorTooltipRows(listOf(series().copy(cursorValue = Double.NaN))).single().value) |
|||
assertEquals("N/A", chartCursorTooltipRows(listOf(series().copy(cursorValue = Double.POSITIVE_INFINITY))).single().value) |
|||
assertTrue(chartCursorTooltipRows(listOf(series().copy(isVisible = false))).isEmpty()) |
|||
} |
|||
|
|||
@Test fun noUnitHasNoTrailingSpaceAndNegativeValuesArePreserved() { |
|||
val signal = series().copy(unit = "", cursorValue = -1.25) |
|||
assertEquals("-1.25", chartCursorTooltipRows(listOf(signal)).single().value) |
|||
} |
|||
} |
|||
@ -1,90 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.chart.* |
|||
import com.dct.app.domain.model.project.DpcChartState |
|||
import com.dct.app.domain.usecase.chart.ChartBatchRenderer |
|||
import kotlinx.coroutines.test.UnconfinedTestDispatcher |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class) |
|||
class ChartInitialFillTest { |
|||
private fun renderer() = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())).apply { |
|||
bindSignal("s", "Signal", AxisPosition.LEFT_0, 0xFF00FFL) |
|||
} |
|||
private fun ChartBatchRenderer.sample(t: Double) = addSampleSec("s", t, 1.0) |
|||
private fun ChartBatchRenderer.assertRange(left: Double, right: Double) { |
|||
val frame = buildSnapshot(600) |
|||
assertEquals(left, frame.timeMinSec, 1e-8) |
|||
assertEquals(right, frame.timeMaxSec, 1e-8) |
|||
} |
|||
@Test fun presetsFillFromFirstSampleRegardlessOfConfigurationOrder() { |
|||
for (preset in TimeWindowPreset.entries.filter { it.tickIntervalSec != null }) { |
|||
for (sampleFirst in listOf(true, false)) { |
|||
val r = renderer() |
|||
if (sampleFirst) r.sample(1000.0) |
|||
r.setTimeWindow(preset) |
|||
if (!sampleFirst) r.sample(1000.0) |
|||
val right = 1000.0 + preset.displaySpanSec |
|||
r.assertRange(1000.0, right) |
|||
r.sample(1001.0) |
|||
r.resetPan() |
|||
r.assertRange(1000.0, right) |
|||
r.sample(right) |
|||
r.assertRange(1000.0 + preset.tickIntervalSec!!, right + preset.tickIntervalSec!!) |
|||
r.sample(right + .033) |
|||
r.assertRange(1000.0 + preset.tickIntervalSec!!, right + preset.tickIntervalSec!!) |
|||
} |
|||
} |
|||
} |
|||
@Test fun doubleTapAfterZoomRestoresLeftAlignedRangeForBothAxisLayouts() { |
|||
for (multi in listOf(false, true)) { |
|||
val r = renderer() |
|||
if (multi) r.bindSignal("b", "Second", AxisPosition.RIGHT_0, 0xFFFFFFL) |
|||
r.sample(10.0) |
|||
r.sample(12.0) |
|||
r.setTimeWindow(TimeWindowPreset.SEC_10) |
|||
r.setYAxisRange(-5.0, 5.0) |
|||
r.zoomTimeWindow(2f, .5) |
|||
r.panTimeWindow(-1.0) |
|||
r.setCrosshairTimeSec(11.0) |
|||
repeat(3) { r.resetPan(); r.assertRange(10.0, 50.0) } |
|||
assertNull(r.renderSnapshotFlow.value.crosshairTimeSec) |
|||
assertEquals(-5.0, r.renderSnapshotFlow.value.axesConfig.getValue(AxisPosition.LEFT_0).minVal) |
|||
r.sample(51.0) |
|||
r.resetPan() |
|||
r.assertRange(11.0, 51.0) |
|||
r.sample(51.02) |
|||
r.assertRange(21.02, 61.02) |
|||
} |
|||
} |
|||
@Test fun customDurationAndRestoredFollowingScaleFillBeforeRolling() { |
|||
val r = renderer() |
|||
r.setTimeWindow(25.0) |
|||
r.sample(1000.0) |
|||
r.assertRange(1000.0, 1025.0) |
|||
r.sample(1002.0) |
|||
r.assertRange(1000.0, 1025.0) |
|||
val signals = r.seriesListFlow.value |
|||
val saved = r.exportWorkspaceState() |
|||
r.restoreWorkspaceState(signals, saved) |
|||
r.sample(2000.0) |
|||
r.resetPan() |
|||
r.assertRange(2000.0, 2025.0) |
|||
r.sample(2026.0) |
|||
val shifted = r.buildSnapshot(600) |
|||
assertTrue(shifted.timeMaxSec > 2026.0) |
|||
assertEquals(25.0, shifted.timeMaxSec - shifted.timeMinSec) |
|||
} |
|||
@Test fun restoredManualGetsInitialDataRangeThenRemainsFrozenUntilReset() { |
|||
val r = renderer() |
|||
r.restoreWorkspaceState(r.seriesListFlow.value, DpcChartState(timeWindowSec = 25.0, |
|||
timeWindowPreset = TimeWindowPreset.MANUAL, isXAxisAuto = false)) |
|||
r.sample(1000.0) |
|||
r.assertRange(1000.0, 1025.0) |
|||
r.sample(1100.0) |
|||
r.assertRange(1000.0, 1025.0) |
|||
r.resetPan() |
|||
r.assertRange(1075.0, 1100.0) |
|||
} |
|||
} |
|||
@ -1,395 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.chart.* |
|||
import com.dct.app.data.repository.DpcWorkspaceJson |
|||
import com.dct.app.domain.model.project.DpcChartState |
|||
import com.dct.app.domain.model.project.DpcPageState |
|||
import com.dct.app.domain.model.project.DpcWindowState |
|||
import com.dct.app.domain.model.project.DpcWorkspaceState |
|||
import com.dct.app.domain.usecase.chart.ChartBatchRenderer |
|||
import kotlinx.coroutines.test.UnconfinedTestDispatcher |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class) |
|||
class ChartNavigationTest { |
|||
private fun renderer() = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())).apply { |
|||
bindSignal("s", "Signal", AxisPosition.LEFT_0, 0x0000FFL) |
|||
addSampleSec("s", 1000.0, 1.0) |
|||
setTimeWindow(TimeWindowPreset.MIN_1) |
|||
} |
|||
private fun ChartBatchRenderer.sample(time: Double) = addSampleSec("s", time, 2.0) |
|||
private fun ChartBatchRenderer.snapshot() = buildSnapshot(600) |
|||
private fun ChartRenderSnapshot.span() = timeMaxSec - timeMinSec |
|||
|
|||
@Test fun doubleTapRestoresPreNavigationScalePresetAndLatestTrackingWithoutChangingYAxisOrData() { |
|||
val r = renderer() |
|||
r.setYAxisRange(-5.0, 5.0) |
|||
r.zoomTimeWindow(2f, .5) |
|||
r.zoomTimeWindow(2f, .2) |
|||
r.panTimeWindow(-20.0) |
|||
r.setCrosshairTimeSec(900.0) |
|||
r.sample(1400.0) |
|||
r.resetPan() |
|||
val restored = r.snapshot() |
|||
assertEquals(300.0, restored.span()) |
|||
assertEquals(1400.0, restored.timeMaxSec) |
|||
assertEquals(TimeWindowPreset.MIN_1, restored.xAxisPreset) |
|||
assertTrue(restored.isXAxisAuto) |
|||
assertNull(restored.crosshairTimeSec) |
|||
assertEquals(300.0, r.renderSnapshotFlow.value.span()) // Includes paused rendering. |
|||
assertEquals(-5.0, restored.axesConfig.getValue(AxisPosition.LEFT_0).minVal) |
|||
assertEquals(5.0, restored.axesConfig.getValue(AxisPosition.LEFT_0).maxVal) |
|||
assertEquals(0x0000FFL, r.seriesListFlow.value.single().color) |
|||
assertEquals(1000.0, r.seriesListFlow.value.single().buffer.getOldestTimestamp()) |
|||
r.sample(1401.0) |
|||
assertTrue(r.snapshot().timeMaxSec > 1400.0) |
|||
} |
|||
|
|||
@Test fun forwardPanCanPassTheOldRightEdgeAsNewSamplesArriveButNotTheLatestSample() { |
|||
val r = renderer() |
|||
r.clearAllData() |
|||
r.sample(700.0) |
|||
r.sample(1000.0) |
|||
r.setTimeWindow(TimeWindowPreset.MIN_1) |
|||
r.panTimeWindow(-50.0) |
|||
assertEquals(950.0, r.snapshot().timeMaxSec) |
|||
r.sample(1200.0) |
|||
r.panTimeWindow(100.0) |
|||
assertEquals(1050.0, r.snapshot().timeMaxSec) |
|||
r.panTimeWindow(10000.0) |
|||
assertEquals(1200.0, r.snapshot().timeMaxSec) |
|||
assertEquals(300.0, r.snapshot().span()) |
|||
assertTrue(r.snapshot().isXAxisAuto) |
|||
r.sample(1300.0) |
|||
assertEquals(1330.0, r.snapshot().timeMaxSec) |
|||
r.panTimeWindow(-30.0) |
|||
assertEquals(1300.0, r.snapshot().timeMaxSec) |
|||
} |
|||
|
|||
@Test fun forwardPanAfterZoomAlsoUsesCurrentLatestData() { |
|||
val r = renderer() |
|||
r.zoomTimeWindow(2f, .5) |
|||
r.panTimeWindow(-10.0) // Browse history before testing return to newer live data. |
|||
r.sample(2000.0) |
|||
r.panTimeWindow(10000.0) |
|||
assertTrue(r.snapshot().timeMaxSec >= 2000.0) |
|||
assertEquals(150.0, r.snapshot().span()) |
|||
assertTrue(r.renderSnapshotFlow.value.isXAxisAuto) |
|||
r.sample(2001.0) |
|||
assertTrue(r.snapshot().timeMaxSec > 2001.0) |
|||
assertEquals(150.0, r.snapshot().span()) |
|||
} |
|||
|
|||
@Test fun forwardPanAfterZoomOutResumesRollingAtExpandedScale() { |
|||
val r = renderer() |
|||
r.panTimeWindow(-500.0) |
|||
r.zoomTimeWindow(.5f, .5) |
|||
assertEquals(600.0, r.snapshot().span()) |
|||
assertFalse(r.snapshot().isXAxisAuto) |
|||
r.panTimeWindow(10000.0) |
|||
assertTrue(r.snapshot().isXAxisAuto) |
|||
r.sample(1001.0) |
|||
assertTrue(r.snapshot().timeMaxSec > 1001.0) |
|||
assertEquals(600.0, r.snapshot().span()) |
|||
} |
|||
|
|||
@Test fun zoomOutReachingLatestEdgeResumesWithoutAnotherDrag() { |
|||
val r = renderer() |
|||
r.panTimeWindow(-350.0) // Move the right edge past the initial 300-second future margin. |
|||
r.zoomTimeWindow(.5f, .5) |
|||
assertEquals(1000.0, r.renderSnapshotFlow.value.timeMaxSec) |
|||
assertTrue(r.renderSnapshotFlow.value.isXAxisAuto) |
|||
r.sample(1100.0) |
|||
assertTrue(r.snapshot().timeMaxSec > 1100.0) |
|||
assertEquals(600.0, r.snapshot().span()) |
|||
} |
|||
|
|||
@Test fun pinchAnchoredAtLatestEdgeKeepsFollowingForZoomInAndOut() { |
|||
val r = renderer() |
|||
for ((factor, expectedSpan) in listOf(2f to 150.0, .5f to 300.0, 3f to 100.0)) { |
|||
r.zoomTimeWindow(factor, 1.0) |
|||
assertTrue(r.snapshot().isXAxisAuto) |
|||
assertEquals(expectedSpan, r.snapshot().span(), 1e-8) |
|||
val latest = r.snapshot().timeMaxSec + 1.0 |
|||
r.sample(latest) |
|||
assertTrue(r.snapshot().timeMaxSec > latest) |
|||
assertEquals(expectedSpan, r.snapshot().span(), 1e-8) |
|||
} |
|||
r.resetPan() |
|||
assertEquals(300.0, r.snapshot().span()) |
|||
assertEquals(TimeWindowPreset.MIN_1, r.snapshot().xAxisPreset) |
|||
} |
|||
|
|||
@Test fun draggingAwayStopsFollowingAndReturningResumesWithoutChangingZoom() { |
|||
val r = renderer() |
|||
r.zoomTimeWindow(2f, 1.0) |
|||
r.panTimeWindow(-10.0) |
|||
assertFalse(r.renderSnapshotFlow.value.isXAxisAuto) |
|||
r.sample(1010.0) |
|||
assertEquals(990.0, r.snapshot().timeMaxSec) |
|||
r.panTimeWindow(19.0) |
|||
assertFalse(r.snapshot().isXAxisAuto) |
|||
assertEquals(1009.0, r.snapshot().timeMaxSec) |
|||
r.panTimeWindow(1.0) |
|||
assertTrue(r.renderSnapshotFlow.value.isXAxisAuto) |
|||
r.sample(1011.0) |
|||
assertTrue(r.snapshot().timeMaxSec > 1011.0) |
|||
assertEquals(150.0, r.snapshot().span()) |
|||
r.resetPan() |
|||
assertEquals(300.0, r.snapshot().span()) |
|||
assertEquals(TimeWindowPreset.MIN_1, r.snapshot().xAxisPreset) |
|||
} |
|||
|
|||
@Test fun minimumZoomAtEpochTimestampDoesNotSnapHistoryPrematurely() { |
|||
val r = renderer() |
|||
r.sample(1700000000.0) |
|||
r.setTimeWindow(.05) |
|||
r.panTimeWindow(-.01) |
|||
r.panTimeWindow(.009) |
|||
assertFalse(r.snapshot().isXAxisAuto) |
|||
r.panTimeWindow(.001) |
|||
assertTrue(r.snapshot().isXAxisAuto) |
|||
r.sample(1700000000.1) |
|||
assertTrue(r.snapshot().timeMaxSec > 1700000000.1) |
|||
assertTrue(r.snapshot().timeMaxSec < 1700000001.0, "Epoch must not determine the extension step") |
|||
assertTrue(r.snapshot().timeMinSec <= 1700000000.1, "Extreme zoom must keep the latest sample visible") |
|||
assertEquals(.05, r.snapshot().span(), 1e-6) |
|||
} |
|||
|
|||
@Test fun forwardDragWhileFollowingMovesBeyondInitialFutureMarginAndPinsTheRange() { |
|||
val r = renderer() |
|||
r.clearAllData() |
|||
r.sample(2000.0) |
|||
val before = r.snapshot() |
|||
assertTrue(before.timeMaxSec > 2000.0) |
|||
r.panTimeWindow(10.0) |
|||
assertEquals(before.timeMaxSec + 10.0, r.snapshot().timeMaxSec) |
|||
assertEquals(before.span(), r.snapshot().span()) |
|||
assertEquals(TimeWindowPreset.MANUAL, r.snapshot().xAxisPreset) |
|||
assertFalse(r.snapshot().isXAxisAuto) |
|||
r.panTimeWindow(10.0) |
|||
assertEquals(before.timeMaxSec + 20.0, r.snapshot().timeMaxSec) |
|||
r.sample(2100.0) |
|||
assertEquals(before.timeMaxSec + 20.0, r.snapshot().timeMaxSec) |
|||
r.panTimeWindow(-5.0) |
|||
assertEquals(before.timeMaxSec + 15.0, r.snapshot().timeMaxSec) |
|||
r.resetPan() |
|||
assertEquals(TimeWindowPreset.MIN_1, r.snapshot().xAxisPreset) |
|||
assertTrue(r.snapshot().isXAxisAuto) |
|||
assertEquals(before.span(), r.snapshot().span()) |
|||
} |
|||
|
|||
@Test fun forwardDragCanContinueBeyondLatestAfterReturningFromHistory() { |
|||
val r = renderer() |
|||
r.panTimeWindow(-320.0) // Initial range is 1000..1300; actual history ends at 980. |
|||
r.panTimeWindow(20.0) |
|||
assertTrue(r.snapshot().isXAxisAuto) |
|||
r.panTimeWindow(10.0) |
|||
assertEquals(1010.0, r.snapshot().timeMaxSec) |
|||
assertFalse(r.snapshot().isXAxisAuto) |
|||
r.panTimeWindow(10.0) |
|||
assertEquals(1020.0, r.snapshot().timeMaxSec) |
|||
r.panTimeWindow(-30.0) |
|||
assertEquals(990.0, r.snapshot().timeMaxSec) |
|||
r.panTimeWindow(10.0) |
|||
assertEquals(1000.0, r.snapshot().timeMaxSec) |
|||
assertTrue(r.snapshot().isXAxisAuto) |
|||
} |
|||
|
|||
@Test fun zoomInFutureRangeKeepsTheAnchorAndDoesNotSnapBackToLatest() { |
|||
val r = renderer() |
|||
val initialRight = r.snapshot().timeMaxSec |
|||
r.panTimeWindow(600.0) |
|||
r.zoomTimeWindow(2f, 1.0) |
|||
assertEquals(initialRight + 600.0, r.snapshot().timeMaxSec) |
|||
assertEquals(150.0, r.snapshot().span()) |
|||
assertFalse(r.snapshot().isXAxisAuto) |
|||
assertTrue(r.snapshot().seriesList.single().points.isEmpty()) |
|||
} |
|||
|
|||
@Test fun emptyOrExplicitlyFrozenViewportDoesNotResumeWithoutReachingDataByGesture() { |
|||
val r = renderer() |
|||
r.setXAxisManualMode() |
|||
r.panTimeWindow(0.0) |
|||
r.zoomTimeWindow(1f, 1.0) |
|||
assertFalse(r.snapshot().isXAxisAuto) |
|||
r.clearAllData() |
|||
r.zoomTimeWindow(2f, 1.0) |
|||
r.panTimeWindow(100.0) |
|||
assertFalse(r.snapshot().isXAxisAuto) |
|||
assertTrue(r.snapshot().timeMaxSec.isFinite()) |
|||
} |
|||
|
|||
@Test fun resumedCustomScaleIsSavedAndOtherWindowsRemainFrozen() { |
|||
val r = renderer() |
|||
val other = renderer() |
|||
other.panTimeWindow(-50.0) |
|||
r.zoomTimeWindow(2f, 1.0) |
|||
val state = r.exportWorkspaceState() |
|||
assertTrue(state.isXAxisAuto) |
|||
assertFalse(state.isAutoTimeWindow) |
|||
assertEquals(TimeWindowPreset.MANUAL, state.timeWindowPreset) |
|||
assertEquals(150.0, state.timeWindowSec) |
|||
r.restoreWorkspaceState(r.seriesListFlow.value, state) |
|||
r.sample(2000.0) |
|||
other.sample(2000.0) |
|||
assertEquals(2000.0, r.snapshot().timeMinSec) |
|||
assertEquals(2150.0, r.snapshot().timeMaxSec) |
|||
assertEquals(150.0, r.snapshot().span()) |
|||
assertEquals(1250.0, other.snapshot().timeMaxSec) |
|||
assertFalse(other.snapshot().isXAxisAuto) |
|||
} |
|||
|
|||
@Test fun doubleTapRestoresAutoAndIncludesDataReceivedWhileBrowsingHistory() { |
|||
val r = renderer() |
|||
r.setTimeWindow(TimeWindowPreset.AUTO) |
|||
r.sample(1100.0) |
|||
r.zoomTimeWindow(2f, .5) |
|||
r.panTimeWindow(-10.0) |
|||
r.sample(2000.0) |
|||
r.resetPan() |
|||
val restored = r.snapshot() |
|||
assertEquals(TimeWindowPreset.AUTO, restored.xAxisPreset) |
|||
assertEquals(1000.0, restored.timeMinSec) |
|||
assertTrue(restored.timeMaxSec > 2000.0) |
|||
assertTrue(r.exportWorkspaceState().isAutoTimeWindow) |
|||
} |
|||
|
|||
@Test fun doubleTapPreservesCustomDurationAndSixIntervalResetScale() { |
|||
val r = renderer() |
|||
r.setTimeWindow(17.5) |
|||
r.zoomTimeWindow(2f, .5) |
|||
r.resetPan() |
|||
assertEquals(17.5, r.snapshot().span()) |
|||
r.setTimeWindow(TimeWindowPreset.MIN_1) |
|||
r.clearAllData() |
|||
r.sample(2000.0) |
|||
assertEquals(360.0, r.snapshot().span()) |
|||
r.zoomTimeWindow(3f, .5) |
|||
r.resetPan() |
|||
assertEquals(360.0, r.snapshot().span()) |
|||
assertEquals(TimeWindowPreset.MIN_1, r.snapshot().xAxisPreset) |
|||
} |
|||
|
|||
@Test fun selectingAnotherPresetReplacesPreviousResetTarget() { |
|||
val r = renderer() |
|||
r.zoomTimeWindow(2f, .5) |
|||
r.setTimeWindow(TimeWindowPreset.SEC_10) |
|||
r.panTimeWindow(-10.0) |
|||
r.zoomTimeWindow(2f, .5) |
|||
r.resetPan() |
|||
assertEquals(40.0, r.snapshot().span()) |
|||
assertEquals(TimeWindowPreset.SEC_10, r.snapshot().xAxisPreset) |
|||
} |
|||
|
|||
@Test fun stationaryPinchAndZeroPanDoNotEnterManualMode() { |
|||
val r = renderer() |
|||
r.zoomTimeWindow(1f, .5) |
|||
r.panTimeWindow(0.0) |
|||
r.panTimeWindow(Double.NaN) |
|||
assertEquals(TimeWindowPreset.MIN_1, r.snapshot().xAxisPreset) |
|||
assertTrue(r.snapshot().isXAxisAuto) |
|||
} |
|||
|
|||
@Test fun restoredManualRangeCanReturnToLatestWithoutAnOldNavigationTarget() { |
|||
val r = renderer() |
|||
r.zoomTimeWindow(3f, .5) |
|||
val signal = r.seriesListFlow.value.single() |
|||
r.restoreWorkspaceState(listOf(signal), DpcChartState(timeWindowSec = 25.0, |
|||
timeWindowPreset = TimeWindowPreset.MANUAL, isXAxisAuto = false)) |
|||
r.sample(5000.0) |
|||
r.resetPan() |
|||
assertEquals(25.0, r.snapshot().span()) |
|||
assertEquals(5000.0, r.snapshot().timeMinSec) |
|||
assertEquals(5025.0, r.snapshot().timeMaxSec) |
|||
assertTrue(r.snapshot().isXAxisAuto) |
|||
} |
|||
|
|||
@Test fun resetWithoutSamplesIsFiniteAndIndependentBetweenWindows() { |
|||
val a = renderer() |
|||
val b = renderer() |
|||
a.zoomTimeWindow(2f, .5) |
|||
b.setTimeWindow(TimeWindowPreset.SEC_10) |
|||
b.zoomTimeWindow(4f, .5) |
|||
a.resetPan() |
|||
assertEquals(300.0, a.snapshot().span()) |
|||
assertEquals(10.0, b.snapshot().span()) |
|||
a.clearAllData() |
|||
a.zoomTimeWindow(2f, .5) |
|||
a.resetPan() |
|||
assertEquals(360.0, a.snapshot().span(), .001) |
|||
assertTrue(a.snapshot().timeMaxSec.isFinite()) |
|||
} |
|||
|
|||
@Test fun directManualXAxisRangeIsPinnedBeforeAndAfterFirstSample() { |
|||
val r = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())).apply { |
|||
bindSignal("s", "Signal", AxisPosition.LEFT_0, 0x0000FFL) |
|||
} |
|||
|
|||
assertTrue(r.setXAxisManualRange(100.0, 125.0)) |
|||
assertEquals(100.0, r.snapshot().timeMinSec, 1e-8) |
|||
assertEquals(125.0, r.snapshot().timeMaxSec, 1e-8) |
|||
assertFalse(r.snapshot().isXAxisAuto) |
|||
|
|||
// A first sample must not replace the explicitly entered interval with |
|||
// the normal initial-fill range. |
|||
r.sample(1000.0) |
|||
assertEquals(100.0, r.snapshot().timeMinSec, 1e-8) |
|||
assertEquals(125.0, r.snapshot().timeMaxSec, 1e-8) |
|||
assertFalse(r.setXAxisManualRange(125.0, 125.0)) |
|||
} |
|||
|
|||
@Test fun explicitManualXAxisRangeRoundTripsThroughWorkspaceState() { |
|||
val r = renderer() |
|||
assertTrue(r.setXAxisManualRange(1010.25, 1042.75)) |
|||
val state = r.exportWorkspaceState() |
|||
assertEquals(1010.25, state.xAxisMinSec) |
|||
assertEquals(1042.75, state.xAxisMaxSec) |
|||
|
|||
val workspace = DpcWorkspaceState( |
|||
activePageId = "p", |
|||
pages = listOf( |
|||
DpcPageState( |
|||
id = "p", |
|||
title = "Page", |
|||
windows = listOf(DpcWindowState("w", "GRAPH", "Graph", chart = state)) |
|||
) |
|||
) |
|||
) |
|||
val decodedState = DpcWorkspaceJson.decode(DpcWorkspaceJson.encode(workspace))!! |
|||
.pages.single().windows.single().chart!! |
|||
assertEquals(1010.25, decodedState.xAxisMinSec) |
|||
assertEquals(1042.75, decodedState.xAxisMaxSec) |
|||
|
|||
val restored = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())) |
|||
restored.restoreWorkspaceState(emptyList(), decodedState) |
|||
assertEquals(1010.25, restored.snapshot().timeMinSec, 1e-8) |
|||
assertEquals(1042.75, restored.snapshot().timeMaxSec, 1e-8) |
|||
assertFalse(restored.snapshot().isXAxisAuto) |
|||
} |
|||
|
|||
@Test fun clearingSamplesKeepsExplicitManualXAxisBounds() { |
|||
val r = renderer() |
|||
assertTrue(r.setXAxisManualRange(900.0, 930.0)) |
|||
r.sample(1000.0) |
|||
r.clearSamplesOnly() |
|||
assertEquals(900.0, r.snapshot().timeMinSec, 1e-8) |
|||
assertEquals(930.0, r.snapshot().timeMaxSec, 1e-8) |
|||
r.sample(1100.0) |
|||
assertEquals(900.0, r.snapshot().timeMinSec, 1e-8) |
|||
assertEquals(930.0, r.snapshot().timeMaxSec, 1e-8) |
|||
} |
|||
|
|||
@Test fun restoredExplicitManualRangeSurvivesDoubleTapReset() { |
|||
val source = renderer() |
|||
assertTrue(source.setXAxisManualRange(1010.0, 1040.0)) |
|||
val restored = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())) |
|||
restored.restoreWorkspaceState(emptyList(), source.exportWorkspaceState()) |
|||
restored.sample(2000.0) |
|||
restored.resetPan() |
|||
assertEquals(1010.0, restored.snapshot().timeMinSec, 1e-8) |
|||
assertEquals(1040.0, restored.snapshot().timeMaxSec, 1e-8) |
|||
assertFalse(restored.snapshot().isXAxisAuto) |
|||
} |
|||
} |
|||
@ -1,74 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.usecase.chart.ChartBatchRenderer |
|||
import kotlinx.coroutines.test.* |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class) |
|||
class ChartPerformanceLifecycleTest { |
|||
@Test fun backgroundChartKeepsEverySampleAndRestoresOnlyVisibleWindows() = runTest { |
|||
val renderer = ChartBatchRenderer(TestDispatcherProvider(StandardTestDispatcher(testScheduler))) |
|||
renderer.bindSignal("s", "Signal", AxisPosition.LEFT_0, 0xFF000000) |
|||
renderer.start(backgroundScope) |
|||
runCurrent() |
|||
renderer.setApplicationVisible(false) |
|||
val previous = renderer.renderSnapshotFlow.value |
|||
for (i in 1..60) renderer.addSampleSec("s", i.toDouble(), i.toDouble()) |
|||
renderer.setRenderingEnabled(true) // Late composable callback cannot override background visibility. |
|||
advanceTimeBy(100) |
|||
runCurrent() |
|||
assertSame(previous, renderer.renderSnapshotFlow.value) |
|||
assertEquals(60, renderer.seriesListFlow.value.single().buffer.size) |
|||
renderer.setRenderingEnabled(false) // Hidden page must remain hidden on return. |
|||
renderer.setApplicationVisible(true) |
|||
advanceTimeBy(100) |
|||
runCurrent() |
|||
assertSame(previous, renderer.renderSnapshotFlow.value) |
|||
renderer.setRenderingEnabled(true) |
|||
advanceTimeBy(20) |
|||
runCurrent() |
|||
assertEquals(60.0, renderer.renderSnapshotFlow.value.seriesList.single().latestValue) |
|||
renderer.dispose() |
|||
} |
|||
|
|||
@Test fun hiddenChartRetainsSamplesWithoutPublishingFramesAndDisposalReleasesBindings() = runTest { |
|||
val renderer = ChartBatchRenderer(TestDispatcherProvider(StandardTestDispatcher(testScheduler))) |
|||
renderer.bindSignal("s", "Signal", AxisPosition.LEFT_0, 0xFF000000) |
|||
renderer.start(backgroundScope) |
|||
runCurrent() |
|||
renderer.setRenderingEnabled(false) |
|||
val previous = renderer.renderSnapshotFlow.value |
|||
renderer.addSampleSec("s", 100.0, 10.0) |
|||
advanceTimeBy(100) |
|||
runCurrent() |
|||
assertSame(previous, renderer.renderSnapshotFlow.value) |
|||
assertEquals(1, renderer.seriesListFlow.value.single().buffer.size) |
|||
renderer.setRenderingEnabled(true) |
|||
advanceTimeBy(20) |
|||
runCurrent() |
|||
assertEquals(10.0, renderer.renderSnapshotFlow.value.seriesList.single().latestValue) |
|||
renderer.dispose() |
|||
assertTrue(renderer.seriesListFlow.value.isEmpty()) |
|||
assertTrue(renderer.renderSnapshotFlow.value.seriesList.isEmpty()) |
|||
} |
|||
|
|||
@Test fun successivePinchesComposeBeforeBackgroundFrameIsBuilt() = runTest { |
|||
val renderer = ChartBatchRenderer(TestDispatcherProvider(StandardTestDispatcher(testScheduler))) |
|||
renderer.bindSignal("s", "Signal", AxisPosition.LEFT_0, 0xFF000000) |
|||
for (i in 0..100) renderer.addSampleSec("s", i.toDouble(), i.toDouble()) |
|||
renderer.setTimeWindow(20.0) |
|||
renderer.start(backgroundScope) |
|||
runCurrent() |
|||
val before = renderer.renderSnapshotFlow.value |
|||
renderer.zoomTimeWindow(2f, 0.5) |
|||
renderer.zoomTimeWindow(2f, 0.5) |
|||
assertSame(before, renderer.renderSnapshotFlow.value, "Input must not resample synchronously") |
|||
advanceTimeBy(20) |
|||
runCurrent() |
|||
val after = renderer.renderSnapshotFlow.value |
|||
assertEquals(5.0, after.timeMaxSec - after.timeMinSec, 1e-8) |
|||
renderer.dispose() |
|||
} |
|||
} |
|||
@ -1,167 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.usecase.chart.ChartBatchRenderer |
|||
import kotlinx.coroutines.test.StandardTestDispatcher |
|||
import kotlinx.coroutines.test.TestScope |
|||
import kotlinx.coroutines.test.advanceTimeBy |
|||
import kotlinx.coroutines.test.runCurrent |
|||
import kotlinx.coroutines.test.runTest |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class) |
|||
class ChartStoppedNavigationTest { |
|||
private fun TestScope.renderer() = ChartBatchRenderer( |
|||
TestDispatcherProvider(StandardTestDispatcher(testScheduler)) |
|||
).apply { |
|||
bindSignal("s", "Signal", AxisPosition.LEFT_0, 0xFF0000L) |
|||
for (second in 900..1000) addSampleSec("s", second.toDouble(), second.toDouble()) |
|||
setTimeWindow(30.0) |
|||
} |
|||
|
|||
// Assert the flow the UI collects, not buildSnapshot(), which would mask the missing render. |
|||
private fun TestScope.assertRight(r: ChartBatchRenderer, expected: Double, span: Double = 30.0) { |
|||
runCurrent() // A stopped chart publishes one background frame, without restarting its loop. |
|||
val frame = r.renderSnapshotFlow.value |
|||
assertEquals(expected, frame.timeMaxSec, 1e-8) |
|||
assertEquals(span, frame.timeMaxSec - frame.timeMinSec, 1e-8) |
|||
assertTrue(frame.seriesList.single().points.isNotEmpty()) |
|||
} |
|||
|
|||
@Test fun stopThenRepeatedDragsPublishBothDirectionsWithoutNewSamplesOrRenderLoop() = runTest { |
|||
val r = renderer() |
|||
val job = r.start(backgroundScope) |
|||
r.resume() |
|||
runCurrent() |
|||
r.stop() // Same renderer lifecycle used for STOP ACK and connection loss. |
|||
assertTrue(job.isCancelled) |
|||
r.panTimeWindow(-10.0) |
|||
assertRight(r, 990.0) |
|||
assertTrue(r.renderSnapshotFlow.value.isPaused) |
|||
r.panTimeWindow(-10.0) |
|||
assertRight(r, 980.0) |
|||
r.panTimeWindow(5.0) |
|||
assertRight(r, 985.0) |
|||
r.panTimeWindow(15.0) |
|||
assertRight(r, 1000.0) |
|||
assertTrue(r.renderSnapshotFlow.value.isXAxisAuto) |
|||
r.panTimeWindow(-5.0) |
|||
assertRight(r, 995.0) |
|||
assertTrue(job.isCancelled) // Navigation must not restart measurement/render jobs. |
|||
assertEquals(900.0, r.seriesListFlow.value.single().buffer.getOldestTimestamp()) |
|||
assertEquals(1000.0, r.seriesListFlow.value.single().buffer.getLatestTimestamp()) |
|||
} |
|||
|
|||
@Test fun stoppingAnAlreadyManualViewportDoesNotLoseFurtherDragUpdates() = runTest { |
|||
val r = renderer() |
|||
r.start(backgroundScope) |
|||
r.panTimeWindow(-20.0) |
|||
runCurrent() |
|||
assertRight(r, 980.0) |
|||
r.stop() |
|||
r.panTimeWindow(5.0) |
|||
assertRight(r, 985.0) |
|||
r.panTimeWindow(-10.0) |
|||
assertRight(r, 975.0) |
|||
assertFalse(r.renderSnapshotFlow.value.isXAxisAuto) |
|||
} |
|||
|
|||
@Test fun stoppedChartPublishesFutureBlankRangeAndCanReturnWithoutNewSamples() = runTest { |
|||
val r = renderer() |
|||
val job = r.start(backgroundScope) |
|||
r.resume() |
|||
runCurrent() |
|||
r.stop() |
|||
r.panTimeWindow(60.0) |
|||
runCurrent() |
|||
val future = r.renderSnapshotFlow.value |
|||
assertEquals(1060.0, future.timeMaxSec, 1e-8) |
|||
assertEquals(1030.0, future.timeMinSec, 1e-8) |
|||
assertFalse(future.isXAxisAuto) |
|||
assertTrue(future.isPaused) |
|||
assertTrue(future.seriesList.single().points.isEmpty()) |
|||
r.panTimeWindow(-60.0) |
|||
assertRight(r, 1000.0) |
|||
r.resetPan() |
|||
assertRight(r, 1000.0) |
|||
assertTrue(r.renderSnapshotFlow.value.isXAxisAuto) |
|||
assertTrue(job.isCancelled) |
|||
assertEquals(900.0, r.seriesListFlow.value.single().buffer.getOldestTimestamp()) |
|||
assertEquals(1000.0, r.seriesListFlow.value.single().buffer.getLatestTimestamp()) |
|||
} |
|||
|
|||
@Test fun cancelledJobAndNeverStartedRendererAlsoPublishNavigation() = runTest { |
|||
val r = renderer() |
|||
r.panTimeWindow(-10.0) |
|||
assertRight(r, 990.0) |
|||
val job = r.start(backgroundScope) |
|||
runCurrent() |
|||
job.cancel() // Non-null but inactive job must not count as a rendering consumer. |
|||
r.panTimeWindow(-5.0) |
|||
assertRight(r, 985.0) |
|||
r.panTimeWindow(10.0) |
|||
assertRight(r, 995.0) |
|||
} |
|||
|
|||
@Test fun pauseWithAnActiveLoopStillRendersDirtyNavigationAtNormalCadence() = runTest { |
|||
val r = renderer() |
|||
val job = r.start(backgroundScope) |
|||
r.resume() |
|||
runCurrent() |
|||
r.pause() |
|||
r.panTimeWindow(-10.0) |
|||
advanceTimeBy(20) |
|||
runCurrent() |
|||
assertRight(r, 990.0) |
|||
assertTrue(r.renderSnapshotFlow.value.isPaused) |
|||
r.panTimeWindow(5.0) |
|||
advanceTimeBy(20) |
|||
runCurrent() |
|||
assertRight(r, 995.0) |
|||
assertTrue(job.isActive) |
|||
} |
|||
|
|||
@Test fun stoppedZoomAndPanKeepScaleAndAllowLiveFollowAfterMeasurementResumes() = runTest { |
|||
val r = renderer() |
|||
r.start(backgroundScope) |
|||
r.resume() |
|||
runCurrent() |
|||
r.stop() |
|||
r.zoomTimeWindow(2f, 1.0) |
|||
r.panTimeWindow(-10.0) |
|||
assertRight(r, 990.0, 15.0) |
|||
r.panTimeWindow(10.0) |
|||
assertRight(r, 1000.0, 15.0) |
|||
r.resume() |
|||
r.start(backgroundScope) |
|||
r.addSampleSec("s", 1001.0, 1001.0) |
|||
runCurrent() |
|||
assertRight(r, 1002.0, 15.0) |
|||
r.stop() |
|||
r.resetPan() |
|||
assertRight(r, 1001.0, 30.0) |
|||
} |
|||
|
|||
@Test fun stoppedWindowsKeepIndependentOffsetsAndAxisSettings() = runTest { |
|||
val a = renderer() |
|||
val b = renderer() |
|||
a.setYAxisRange(-50.0, 2000.0) |
|||
a.start(backgroundScope) |
|||
b.start(backgroundScope) |
|||
runCurrent() |
|||
a.stop() |
|||
b.stop() |
|||
a.panTimeWindow(-10.0) |
|||
b.panTimeWindow(-20.0) |
|||
assertRight(a, 990.0) |
|||
assertRight(b, 980.0) |
|||
a.panTimeWindow(5.0) |
|||
assertRight(a, 995.0) |
|||
assertRight(b, 980.0) |
|||
val axis = a.renderSnapshotFlow.value.axesConfig.getValue(AxisPosition.LEFT_0) |
|||
assertFalse(axis.isAuto) |
|||
assertEquals(-50.0, axis.minVal) |
|||
assertEquals(2000.0, axis.maxVal) |
|||
} |
|||
} |
|||
@ -1,127 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.model.chart.ChartSignalSeries |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.MdbDatabase |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import com.dct.app.domain.model.mdb.SignalGroup |
|||
import com.dct.app.domain.usecase.chart.ChartTelemetryResolver |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class ChartTelemetryResolverTest { |
|||
private fun signal(idx: Int, name: String = "Speed", reclid: Int = 0, adl: Int = 42) = |
|||
SignalDefinition(reclid, idx, name, MdbAttrType.ATTR_0_UINT8, 1.0, 0.0, "", 0, 0.0, 255.0, |
|||
adl = adl, messageId = 0x456) |
|||
|
|||
private fun series(id: String, name: String = "Old name") = |
|||
ChartSignalSeries(id, name, AxisPosition.LEFT_0, 0L) |
|||
|
|||
private fun database(signals: List<SignalDefinition>) = |
|||
MdbDatabase(groups = listOf(SignalGroup(1, "", "", true, signals = signals))) |
|||
|
|||
@Test fun canStableLegacyHexAndCaseInsensitiveKeysKeepExistingValues() { |
|||
val resolver = ChartTelemetryResolver() |
|||
resolver.updateSources(null, listOf(signal(7)), emptyList()) |
|||
val values = mapOf("can_1110_Speed" to 17.0) |
|||
for (id in listOf("can_7", "can_7_Speed", "can_1110_speed", "CAN_0x456_SPEED", "can_Speed")) { |
|||
assertEquals(17.0, resolver.updatedValue(series(id), values, values.keys), id) |
|||
} |
|||
assertEquals(17.0, resolver.updatedValue(series("unknown", "speed"), values, values.keys)) |
|||
} |
|||
|
|||
@Test fun directKeyWinsAndUnrelatedPacketDoesNotReuseCachedValueOrCreateZero() { |
|||
val resolver = ChartTelemetryResolver() |
|||
resolver.updateSources(null, listOf(signal(7)), emptyList()) |
|||
val binding = series("can_7", "Speed") |
|||
val values = mapOf("can_7" to 0.0, "Speed" to 4.0, "can_1110_Speed" to 8.0) |
|||
assertEquals(0.0, resolver.updatedValue(binding, values, values.keys)) |
|||
assertEquals(8.0, resolver.updatedValue(binding, values, setOf("can_1110_Speed"))) |
|||
assertNull(resolver.updatedValue(binding, values, setOf("sig_1_1"))) |
|||
assertNull(resolver.updatedValue(series("absent"), values, values.keys)) |
|||
} |
|||
|
|||
@Test fun mdbAndA2lAliasesSurviveLegacyNamesAndKeepFamilyPrecedence() { |
|||
val resolver = ChartTelemetryResolver() |
|||
resolver.updateSources(database(listOf(signal(2, reclid = 1))), emptyList(), listOf(signal(3))) |
|||
val binding = series("namespace_Speed", "speed") |
|||
val values = mapOf("sig_1_2" to 12.0, "a2l_42" to 34.0, "sig_0_3" to 56.0) |
|||
assertEquals(12.0, resolver.updatedValue(binding, values, values.keys)) |
|||
assertEquals(34.0, resolver.updatedValue(binding, values, setOf("a2l_42", "sig_0_3"))) |
|||
assertEquals(56.0, resolver.updatedValue(series("SIG_0_3"), values, setOf("sig_0_3"))) |
|||
assertNull(resolver.updatedValue(binding, values, setOf("sm_01_01"))) |
|||
} |
|||
|
|||
@Test fun eachDefinitionReplacementAndRemovalInvalidatesCachedMatches() { |
|||
val resolver = ChartTelemetryResolver() |
|||
val binding = series("namespace_Speed", "speed") |
|||
val oldCan = listOf(signal(7)) |
|||
val newCan = listOf(signal(8).copy(messageId = 0x457)) |
|||
resolver.updateSources(null, oldCan, emptyList()) |
|||
assertEquals(1.0, resolver.updatedValue(binding, mapOf("can_7" to 1.0), setOf("can_7"))) |
|||
resolver.updateSources(null, newCan, emptyList()) |
|||
assertNull(resolver.updatedValue(binding, mapOf("can_7" to 1.0), setOf("can_7"))) |
|||
assertEquals(2.0, resolver.updatedValue(binding, mapOf("can_8" to 2.0), setOf("can_8"))) |
|||
resolver.updateSources(database(listOf(signal(2, reclid = 1))), emptyList(), emptyList()) |
|||
assertEquals(3.0, resolver.updatedValue(binding, mapOf("sig_1_2" to 3.0), setOf("sig_1_2"))) |
|||
resolver.updateSources(database(listOf(signal(9, reclid = 2))), emptyList(), emptyList()) |
|||
assertNull(resolver.updatedValue(binding, mapOf("sig_1_2" to 3.0), setOf("sig_1_2"))) |
|||
assertEquals(4.0, resolver.updatedValue(binding, mapOf("sig_2_9" to 4.0), setOf("sig_2_9"))) |
|||
resolver.updateSources(null, emptyList(), listOf(signal(3))) |
|||
assertEquals(5.0, resolver.updatedValue(binding, mapOf("a2l_42" to 5.0), setOf("a2l_42"))) |
|||
resolver.updateSources(null, emptyList(), listOf(signal(3, adl = 99))) |
|||
assertNull(resolver.updatedValue(binding, mapOf("a2l_42" to 5.0), setOf("a2l_42"))) |
|||
assertEquals(6.0, resolver.updatedValue(binding, mapOf("a2l_99" to 6.0), setOf("a2l_99"))) |
|||
resolver.updateSources(null, emptyList(), emptyList()) |
|||
assertNull(resolver.updatedValue(binding, mapOf("a2l_99" to 6.0), setOf("a2l_99"))) |
|||
} |
|||
|
|||
@Test fun previouslyUnresolvedBindingIsRetriedWhenDefinitionsLoadAndNameChanges() { |
|||
val resolver = ChartTelemetryResolver() |
|||
val values = mapOf("can_7" to 7.0, "can_8" to 8.0) |
|||
assertNull(resolver.updatedValue(series("namespace", "speed"), values, values.keys)) |
|||
resolver.updateSources(null, listOf(signal(7), signal(8, "RPM")), emptyList()) |
|||
assertEquals(7.0, resolver.updatedValue(series("namespace", "speed"), values, values.keys)) |
|||
assertEquals(8.0, resolver.updatedValue(series("namespace", "RPM"), values, values.keys)) |
|||
} |
|||
|
|||
@Test fun duplicateNamesUseFirstDefinitionJustLikeUncachedResolver() { |
|||
val resolver = ChartTelemetryResolver() |
|||
resolver.updateSources(null, listOf(signal(7), signal(8)), emptyList()) |
|||
val values = mapOf("can_7" to 7.0, "can_8" to 8.0) |
|||
assertEquals(7.0, resolver.updatedValue(series("namespace", "speed"), values, values.keys)) |
|||
assertNull(resolver.updatedValue(series("namespace", "speed"), values, setOf("can_8"))) |
|||
} |
|||
|
|||
/** Count definition reads instead of relying on noisy wall-clock performance thresholds. */ |
|||
@Test fun repeatedMixedPacketsDoNotScanThousandsOfDefinitionsAfterWarmup() { |
|||
val definitions = CountingList((1..2_000).map { signal(it, "CAN_$it") }) |
|||
val mdb = CountingList(listOf(signal(1, "MDB", 1))) |
|||
val a2l = CountingList(listOf(signal(1, "A2L"))) |
|||
val db = database(mdb) |
|||
val resolver = ChartTelemetryResolver() |
|||
resolver.updateSources(db, definitions, a2l) |
|||
val bindings = listOf(series("legacy", "can_2000"), series("namespace_MDB", "mdb"), series("missing")) |
|||
val values = mapOf("can_2000" to 2.0, "sig_1_1" to 3.0) |
|||
bindings.forEach { resolver.updatedValue(it, values, setOf("unrelated")) } |
|||
val reads = listOf(definitions.reads, mdb.reads, a2l.reads) |
|||
repeat(1_000) { |
|||
resolver.updateSources(db, definitions, a2l) |
|||
assertEquals(2.0, resolver.updatedValue(bindings[0], values, setOf("can_2000"))) |
|||
assertNull(resolver.updatedValue(bindings[0], values, setOf("sig_1_1"))) |
|||
assertEquals(3.0, resolver.updatedValue(bindings[1], values, setOf("sig_1_1"))) |
|||
assertNull(resolver.updatedValue(bindings[2], values, values.keys)) |
|||
} |
|||
assertEquals(reads, listOf(definitions.reads, mdb.reads, a2l.reads)) |
|||
} |
|||
|
|||
private class CountingList<T>(private val items: List<T>) : AbstractList<T>() { |
|||
var reads = 0 |
|||
override val size: Int get() = items.size |
|||
override fun get(index: Int): T { |
|||
reads++ |
|||
return items[index] |
|||
} |
|||
} |
|||
} |
|||
@ -1,248 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.repository.DpcWorkspaceJson |
|||
import com.dct.app.domain.model.chart.* |
|||
import com.dct.app.domain.model.project.* |
|||
import com.dct.app.domain.usecase.chart.ChartBatchRenderer |
|||
import kotlinx.coroutines.test.UnconfinedTestDispatcher |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import java.time.Instant |
|||
import java.time.ZoneId |
|||
|
|||
@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class) |
|||
class ChartXAxisParityTest { |
|||
private val utc = ZoneId.of("UTC") |
|||
private fun renderer() = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())).apply { |
|||
bindSignal("s", "Signal", AxisPosition.LEFT_0, 0xFF000000L) |
|||
} |
|||
private fun ChartBatchRenderer.sample(t: Double) = addSampleSec("s", t, t) |
|||
private fun span(s: ChartRenderSnapshot) = s.timeMaxSec - s.timeMinSec |
|||
|
|||
@Test fun fixedMenuValuesAreTickIntervalsAndUsePcMenuSpans() { |
|||
val cases = listOf(TimeWindowPreset.SEC_10 to 40.0, TimeWindowPreset.SEC_30 to 150.0, |
|||
TimeWindowPreset.MIN_1 to 300.0, TimeWindowPreset.MIN_5 to 1200.0, TimeWindowPreset.MIN_10 to 2400.0) |
|||
for ((preset, expected) in cases) { |
|||
val r = renderer() |
|||
r.sample(10000.0) |
|||
r.setTimeWindow(preset) |
|||
val s = r.buildSnapshot(600) |
|||
assertEquals(expected, span(s), 1e-8) |
|||
assertEquals(10000.0, s.timeMinSec, 1e-8) |
|||
assertEquals(10000.0 + expected, s.timeMaxSec, 1e-8) |
|||
for (width in listOf(80f, 600f, 2400f)) { |
|||
val ticks = ChartAxisTicks.time(s.timeMinSec, s.timeMaxSec, width, s.xAxisPreset, zone = utc) |
|||
assertEquals(preset.durationSec, ticks.interval.seconds, 1e-8) |
|||
assertTrue(ticks.values.size >= 4) |
|||
ticks.values.zipWithNext().forEach { (a, b) -> assertEquals(preset.durationSec, b - a, 1e-8) } |
|||
} |
|||
} |
|||
} |
|||
|
|||
@Test fun autoUsesPc60PixelRuleAndDoesNotCapAtEightIntervals() { |
|||
for ((span, step) in listOf(10.0 to 1.0, 30.0 to 5.0, 60.0 to 10.0, 300.0 to 30.0, 600.0 to 120.0)) { |
|||
assertEquals(step, ChartAxisTicks.time(0.0, span, 600f, zone = utc).interval.seconds) |
|||
} |
|||
val wide = ChartAxisTicks.time(0.0, 60.0, 1200f, zone = utc) |
|||
assertEquals(5.0, wide.interval.seconds) |
|||
assertEquals(13, wide.values.size) |
|||
} |
|||
|
|||
@Test fun transformHelperAndProductionTicksUseTheSameAlgorithm() { |
|||
assertEquals(ChartAxisTicks.time(1000.0, 1300.0, 600f).values, |
|||
MultiAxisCoordinateTransformer.generateTimeTicks(1000.0, 1300.0, 600f)) |
|||
} |
|||
|
|||
@Test fun labelsAdaptToSecondsMinutesHoursAndMilliseconds() { |
|||
val t = Instant.parse("2026-09-03T12:34:56Z").epochSecond.toDouble() |
|||
assertEquals("12:34:56", ChartAxisTicks.time(t, t + 40, 600f, TimeWindowPreset.SEC_10).label(t, utc)) |
|||
assertEquals("12:34", ChartAxisTicks.time(t, t + 300, 600f, TimeWindowPreset.MIN_1).label(t, utc)) |
|||
val hourly = ChartAxisTicks.time(t, t + 86400, 600f) |
|||
assertEquals("12:00", hourly.label(t, utc)) |
|||
val zoom = ChartAxisTicks.time(t + .1, t + .15, 600f, zone = utc) |
|||
assertTrue(zoom.values.size > 1) |
|||
assertEquals(zoom.values.size, zoom.values.map { zoom.label(it, utc) }.distinct().size) |
|||
assertTrue(zoom.values.all { it >= t + .1 && it <= t + .15 }) |
|||
} |
|||
|
|||
@Test fun longRangesUseCalendarTicksInsteadOfCappingAtTenMinutes() { |
|||
val start = Instant.parse("2026-01-01T00:00:00Z").epochSecond.toDouble() |
|||
val end = Instant.parse("2027-01-01T00:00:00Z").epochSecond.toDouble() |
|||
val ticks = ChartAxisTicks.time(start, end, 600f, zone = utc) |
|||
assertEquals(ChartAxisTicks.Unit.MONTH, ticks.interval.unit) |
|||
assertEquals(listOf("Jan 2026", "Mar 2026", "May 2026", "Jul 2026", "Sep 2026", "Nov 2026", "Jan 2027"), |
|||
ticks.values.map { ticks.label(it, utc) }) |
|||
} |
|||
|
|||
@Test fun hourlyTicksAlignToLocalClockEvenWithHalfHourTimezone() { |
|||
val zone = ZoneId.of("Asia/Kolkata") |
|||
val ticks = ChartAxisTicks.time(1700000000.0, 1700086400.0, 600f, zone = zone) |
|||
assertTrue(ticks.values.isNotEmpty()) |
|||
ticks.values.forEach { assertEquals(0, Instant.ofEpochSecond(it.toLong()).atZone(zone).minute) } |
|||
} |
|||
|
|||
@Test fun numericCompensationTicksUseRoundValuesAndFollowWidth() { |
|||
val ticks = ChartAxisTicks.numeric(0.0, 100.0, 300f) |
|||
assertEquals((0..10).map { it * 10.0 }, ticks.values) |
|||
assertEquals(listOf("0", "10", "20", "30", "40", "50", "60", "70", "80", "90", "100"), ticks.values.map(ticks::label)) |
|||
assertTrue(ChartAxisTicks.numeric(0.0, 100.0, 90f).step > ticks.step) |
|||
} |
|||
|
|||
@Test fun numericTicksHandleNegativeAndTinyRangesWithoutRepeatedLabels() { |
|||
for ((min, max) in listOf(-.03 to .03, .000001 to .000002, -100.0 to -10.0)) { |
|||
val ticks = ChartAxisTicks.numeric(min, max, 300f) |
|||
assertTrue(ticks.values.isNotEmpty()) |
|||
assertEquals(ticks.values.size, ticks.values.map(ticks::label).distinct().size) |
|||
assertFalse(ticks.values.map(ticks::label).contains("-0")) |
|||
} |
|||
} |
|||
|
|||
@Test fun invalidOrCollapsedBoundsNeverGenerateUnboundedTicks() { |
|||
for ((min, max, width) in listOf(Triple(0.0, 1.0, 0f), Triple(1.0, 1.0, 600f), |
|||
Triple(Double.NaN, 2.0, 100f), Triple(0.0, Double.POSITIVE_INFINITY, 100f))) { |
|||
assertTrue(ChartAxisTicks.time(min, max, width).values.isEmpty()) |
|||
assertTrue(ChartAxisTicks.numeric(min, max, width).values.isEmpty()) |
|||
} |
|||
assertTrue(ChartAxisTicks.time(0.0, 86400.0, 1f).values.size <= 3) |
|||
} |
|||
|
|||
@Test fun labelPlacementKeepsLabelsInsidePlotWithoutOverlaps() { |
|||
val centers = listOf(50f, 80f, 110f, 140f, 170f, 200f) |
|||
val widths = List(centers.size) { 55f } |
|||
val placements = placeAxisLabels(centers, widths, 50f, 200f) |
|||
assertTrue(placements.size < centers.size) |
|||
placements.forEach { assertTrue(it.left >= 50 && it.left + widths[it.index] <= 200) } |
|||
placements.zipWithNext().forEach { (a, b) -> assertTrue(a.left + widths[a.index] + 4 <= b.left) } |
|||
assertTrue(placeAxisLabels(listOf(10f), listOf(100f), 0f, 20f).isEmpty()) |
|||
} |
|||
|
|||
@Test fun fixedRangeFillsThenReservesOneTickAtEachBoundary() { |
|||
val r = renderer() |
|||
r.setTimeWindow(TimeWindowPreset.SEC_10) |
|||
r.sample(1000.0) |
|||
val first = r.buildSnapshot(600) |
|||
assertEquals(1000.0, first.timeMinSec) |
|||
assertEquals(1040.0, first.timeMaxSec) |
|||
r.sample(1005.0) |
|||
assertEquals(first.timeMaxSec, r.buildSnapshot(600).timeMaxSec) |
|||
r.sample(1040.0) |
|||
val moved = r.buildSnapshot(600) |
|||
assertEquals(1010.0, moved.timeMinSec) |
|||
assertEquals(1050.0, moved.timeMaxSec) |
|||
r.sample(1040.033) |
|||
val rolling = r.buildSnapshot(600) |
|||
assertEquals(1010.0, rolling.timeMinSec, 1e-8) |
|||
assertEquals(1050.0, rolling.timeMaxSec, 1e-8) |
|||
r.sample(1050.0) |
|||
assertEquals(1060.0, r.buildSnapshot(600).timeMaxSec) |
|||
r.sample(5000.0) |
|||
val gap = r.buildSnapshot(600) |
|||
assertEquals(40.0, span(gap)) |
|||
assertEquals(5010.0, gap.timeMaxSec) |
|||
} |
|||
|
|||
@Test fun autoIncludesSingleSampleAndFutureMarginWithoutDegenerateRange() { |
|||
val r = renderer() |
|||
r.setTimeWindow(TimeWindowPreset.AUTO) |
|||
r.sample(1000.0) |
|||
val first = r.buildSnapshot(600) |
|||
assertEquals(1000.0, first.timeMinSec) |
|||
assertTrue(first.timeMaxSec > 1000) |
|||
r.sample(1000.01) |
|||
assertEquals(first.timeMaxSec, r.buildSnapshot(600).timeMaxSec) |
|||
r.sample(1100.0) |
|||
val next = r.buildSnapshot(600) |
|||
assertEquals(1000.0, next.timeMinSec) |
|||
assertTrue(next.timeMaxSec > 1100) |
|||
} |
|||
|
|||
@Test fun manualAndPanDoNotFollowNewSamples() { |
|||
val r = renderer() |
|||
r.sample(1000.0) |
|||
r.setTimeWindow(TimeWindowPreset.SEC_10) |
|||
r.setXAxisManualMode() |
|||
val before = r.buildSnapshot(600) |
|||
r.sample(1100.0) |
|||
assertEquals(before.timeMaxSec, r.buildSnapshot(600).timeMaxSec) |
|||
r.panTimeWindow(-5.0) |
|||
assertEquals(before.timeMinSec - 5, r.buildSnapshot(600).timeMinSec) |
|||
r.resetPan() |
|||
assertEquals(1100.0, r.buildSnapshot(600).timeMaxSec) |
|||
assertEquals(span(before), span(r.buildSnapshot(600))) |
|||
assertTrue(r.buildSnapshot(600).isXAxisAuto) |
|||
} |
|||
|
|||
@Test fun zoomPreservesAnchorAndFreezesManualRange() { |
|||
val r = renderer() |
|||
r.sample(700.0) |
|||
r.sample(1000.0) |
|||
r.setTimeWindow(TimeWindowPreset.MIN_1) |
|||
val before = r.buildSnapshot(600) |
|||
val anchor = before.timeMinSec + span(before) * .25 |
|||
r.zoomTimeWindow(2f, .25) |
|||
val zoom = r.buildSnapshot(600) |
|||
assertEquals(150.0, span(zoom)) |
|||
assertEquals(anchor, zoom.timeMinSec + span(zoom) * .25) |
|||
r.sample(2000.0) |
|||
assertEquals(zoom.timeMinSec, r.buildSnapshot(600).timeMinSec) |
|||
assertEquals(TimeWindowPreset.MANUAL, zoom.xAxisPreset) |
|||
} |
|||
|
|||
@Test fun clearUsesPcSixTickResetSpanWithoutOldTimestamps() { |
|||
for (preset in TimeWindowPreset.entries.filter { it.tickIntervalSec != null }) { |
|||
val r = renderer() |
|||
r.sample(1000.0) |
|||
r.setTimeWindow(preset) |
|||
r.clearAllData() |
|||
r.sample(2000.0) |
|||
val cleared = r.buildSnapshot(600) |
|||
assertEquals(preset.durationSec * 6, span(cleared)) |
|||
assertEquals(2000.0, cleared.timeMinSec) |
|||
assertEquals(1, cleared.seriesList.single().points.size) |
|||
} |
|||
} |
|||
|
|||
@Test fun projectRoundTripPreservesNewPresetRangeAndMigratesOldRange() { |
|||
val r = renderer() |
|||
r.setTimeWindow(TimeWindowPreset.MIN_1) |
|||
val workspace = DpcWorkspaceState("p", listOf(DpcPageState("p", "Page", windows = listOf( |
|||
DpcWindowState("w", "GRAPH", "Graph", chart = r.exportWorkspaceState()) |
|||
)))) |
|||
val decoded = DpcWorkspaceJson.decode(DpcWorkspaceJson.encode(workspace))!! |
|||
val saved = decoded.pages.single().windows.single().chart!! |
|||
val restored = renderer() |
|||
restored.restoreWorkspaceState(emptyList(), saved) |
|||
assertEquals(300.0, restored.exportWorkspaceState().timeWindowSec) |
|||
restored.restoreWorkspaceState(emptyList(), saved.copy(timeWindowSec = 60.0)) |
|||
assertEquals(300.0, restored.exportWorkspaceState().timeWindowSec) |
|||
restored.restoreWorkspaceState(emptyList(), saved.copy(timeWindowSec = 60.0, |
|||
timeWindowPreset = TimeWindowPreset.MANUAL, isXAxisAuto = false)) |
|||
assertEquals(60.0, restored.exportWorkspaceState().timeWindowSec) |
|||
} |
|||
|
|||
@Test fun independentGraphControllersDoNotShareRangeOrPreset() { |
|||
val a = renderer() |
|||
val b = renderer() |
|||
a.sample(1000.0); b.sample(1000.0) |
|||
a.setTimeWindow(TimeWindowPreset.SEC_10) |
|||
b.setTimeWindow(TimeWindowPreset.MIN_5) |
|||
a.sample(1500.0) |
|||
a.buildSnapshot(600) |
|||
assertEquals(1200.0, span(b.buildSnapshot(600))) |
|||
assertEquals(2200.0, b.buildSnapshot(600).timeMaxSec) |
|||
} |
|||
|
|||
@Test fun explicitDurationApiRemainsARollingSpanNotAFixedTickPreset() { |
|||
val r = renderer() |
|||
r.setTimeWindow(30.0) |
|||
r.sample(1000.0) |
|||
val first = r.buildSnapshot(600) |
|||
assertEquals(1000.0, first.timeMinSec) |
|||
assertEquals(1030.0, first.timeMaxSec) |
|||
r.sample(1001.0) |
|||
assertEquals(1030.0, r.buildSnapshot(600).timeMaxSec) |
|||
r.sample(1031.0) |
|||
assertEquals(1036.0, r.buildSnapshot(600).timeMaxSec) |
|||
assertEquals(30.0, span(r.buildSnapshot(600))) |
|||
} |
|||
} |
|||
@ -1,108 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.google.common.truth.Truth.assertThat |
|||
import com.dct.app.data.protocol.ChecksumCalculator |
|||
import com.dct.app.data.protocol.DefaultChecksumCalculator |
|||
import org.junit.jupiter.api.BeforeEach |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.assertThrows |
|||
import org.junit.jupiter.params.ParameterizedTest |
|||
import org.junit.jupiter.params.provider.ValueSource |
|||
|
|||
@DisplayName("ChecksumCalculator (8-bit NOT Checksum) 단위 테스트") |
|||
class ChecksumCalculatorTest { |
|||
|
|||
private lateinit var calculator: ChecksumCalculator |
|||
|
|||
@BeforeEach |
|||
fun setUp() { |
|||
calculator = DefaultChecksumCalculator() |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("C++ 레퍼런스 패킷(ENABLE ACK: 0xA1 0x00 0x01 0x80)의 체크섬은 0xDD이어야 함") |
|||
fun testCppReferenceEnableAckChecksum() { |
|||
// C++ DCTTestServerDlg.cpp: char buffer[] = { 0xA1, 0x00, 0x01, 0x80, 0xDD, 0x7E }; |
|||
val data = byteArrayOf(0xA1.toByte(), 0x00, 0x01, 0x80.toByte()) |
|||
val checksum = calculator.calculate(data, 0, data.size) |
|||
|
|||
// 0xA1(161) + 0x00(0) + 0x01(1) + 0x80(128) = 290 = 0x122 -> 8비트 누적합 0x22 |
|||
// 0x22 xor 0xFF = 0xDD (-35 / 221) |
|||
assertThat(checksum).isEqualTo(0xDD.toByte()) |
|||
|
|||
// 완전한 프레임 검증 |
|||
val fullFrame = byteArrayOf(0xA1.toByte(), 0x00, 0x01, 0x80.toByte(), 0xDD.toByte(), 0x7E) |
|||
assertThat(calculator.verify(fullFrame)).isTrue() |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("모든 바이트가 0x00인 경우 체크섬은 0xFF이어야 함") |
|||
fun testAllZerosChecksum() { |
|||
val zeros = ByteArray(10) { 0x00 } |
|||
val checksum = calculator.calculate(zeros) |
|||
assertThat(checksum).isEqualTo(0xFF.toByte()) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("모든 바이트가 0xFF인 경우 체크섬 누적 오버플로우 정상 처리") |
|||
fun testAll0xFFChecksum() { |
|||
// 0xFF * 256의 누적합은 8비트에서 0이 되므로 NOT 취하면 0xFF |
|||
val data = ByteArray(256) { 0xFF.toByte() } |
|||
val checksum = calculator.calculate(data) |
|||
assertThat(checksum).isEqualTo(0xFF.toByte()) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("대용량 4096바이트 데이터의 체크섬 누적 연산이 정확해야 함") |
|||
fun testLargeDataChecksum() { |
|||
val data = ByteArray(4096) { (it and 0xFF).toByte() } |
|||
var expectedSum = 0 |
|||
for (b in data) { |
|||
expectedSum = (expectedSum + (b.toInt() and 0xFF)) and 0xFF |
|||
} |
|||
val expectedChecksum = (expectedSum xor 0xFF).toByte() |
|||
|
|||
val actualChecksum = calculator.calculate(data) |
|||
assertThat(actualChecksum).isEqualTo(expectedChecksum) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("체크섬 1바이트 변조 시 verify는 false를 반환해야 함") |
|||
fun testCorruptedChecksumVerification() { |
|||
val fullFrame = byteArrayOf(0xA1.toByte(), 0x00, 0x01, 0x80.toByte(), 0xDD.toByte(), 0x7E) |
|||
|
|||
// 체크섬 바이트 변조 (0xDD -> 0xDC) |
|||
fullFrame[4] = 0xDC.toByte() |
|||
assertThat(calculator.verify(fullFrame)).isFalse() |
|||
|
|||
// 페이로드 데이터 변조 |
|||
fullFrame[4] = 0xDD.toByte() |
|||
fullFrame[3] = 0x81.toByte() |
|||
assertThat(calculator.verify(fullFrame)).isFalse() |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@ValueSource(ints = [0, 1, 2, 3, 4, 5]) |
|||
@DisplayName("최소 프레임 길이(6바이트) 미만인 경우 verify는 false를 반환해야 함") |
|||
fun testUnderflowFrameLengthVerification(length: Int) { |
|||
val smallFrame = ByteArray(length) |
|||
assertThat(calculator.verify(smallFrame)).isFalse() |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("유효하지 않은 오프셋 또는 길이 입력 시 IllegalArgumentException 발생") |
|||
fun testInvalidOffsetAndLengthThrowsException() { |
|||
val data = ByteArray(10) |
|||
|
|||
assertThrows<IllegalArgumentException> { |
|||
calculator.calculate(data, offset = -1, length = 5) |
|||
} |
|||
assertThrows<IllegalArgumentException> { |
|||
calculator.calculate(data, offset = 0, length = -1) |
|||
} |
|||
assertThrows<IllegalArgumentException> { |
|||
calculator.calculate(data, offset = 8, length = 5) |
|||
} |
|||
} |
|||
} |
|||
@ -1,21 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.theme.PcColorRef |
|||
import com.dct.app.core.theme.toColorRef |
|||
import org.junit.jupiter.api.Assertions.assertEquals |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class ColorRefCompatibilityTest { |
|||
@Test |
|||
fun legacyArgbIsConvertedToPcColorRefWithoutChannelLoss() { |
|||
assertEquals(0x00F39621L, 0xFF2196F3L.toColorRef()) |
|||
assertEquals(0x004C9A00L, 0xFF009A4CL.toColorRef()) |
|||
} |
|||
|
|||
@Test |
|||
fun existingPcColorRefRemainsUnchanged() { |
|||
val colorRef = PcColorRef.fromRgb(0x12, 0x34, 0x56) |
|||
assertEquals(0x00563412L, colorRef) |
|||
assertEquals(colorRef, colorRef.toColorRef()) |
|||
} |
|||
} |
|||
@ -1,128 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.chart.MultiAxisCoordinateTransformer |
|||
import com.dct.app.domain.model.mdb.* |
|||
import com.dct.app.presentation.signaltree.* |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class CompensationLayoutTest { |
|||
@Test fun physicalValuePreservesUpToFourDecimalPlacesForBothTypes() { |
|||
val expected = mapOf(12.0 to "12", 12.3 to "12.3", 12.34 to "12.34", |
|||
12.345 to "12.345", 12.34567 to "12.3457", -0.00001 to "0", -12.3456 to "-12.3456") |
|||
for ((value, text) in expected) { |
|||
assertEquals(text, formatCompensationPhysicalValue(value)) |
|||
for (typeA in listOf(true, false)) { |
|||
assertEquals(text, compensationPointColumns(typeA).single { it.title == "PHY" } |
|||
.text(MapPoint(0, 0, 0, value))) |
|||
} |
|||
} |
|||
assertEquals("N/A", formatCompensationPhysicalValue(Double.NaN)) |
|||
} |
|||
|
|||
@Test fun coefficientPrecisionMatchesPcTypeAAndTypeB() { |
|||
for (typeA in listOf(true, false)) { |
|||
val columns = compensationMapColumns(typeA) |
|||
val sample = map().copy(cvsA = 0.12345, cvsB = -1.23456) |
|||
assertEquals(if (typeA) "0.1235" else "0.123", columns.single { it.title == "CVS_A" }.text(sample)) |
|||
assertEquals(if (typeA) "-1.2346" else "-1.235", columns.single { it.title == "CVS_B" }.text(sample)) |
|||
assertEquals(if (typeA) "1.0000" else "1.000", formatCompensationCoefficient(1.0, typeA)) |
|||
} |
|||
} |
|||
|
|||
private fun map(type: CompensationMapType = CompensationMapType.TYPE_A) = CompensationMap( |
|||
type, 1, "Y", 0, MdbAttrType.ATTR_3_INT16, 0.0, 100.0, |
|||
"X", 0, MdbAttrType.ATTR_3_INT16, 1.0, 0.0, |
|||
points = listOf(MapPoint(0, 10, -20, -30.0), MapPoint(1, 20, 200, 150.0)) |
|||
) |
|||
|
|||
@Test fun typeARangeIncludesDataOutsideConfiguredLimitsWithoutChangingSamples() { |
|||
val original = map() |
|||
val curve = compensationCurveGeometry(original)!! |
|||
assertEquals(-20.0, curve.minY) |
|||
assertEquals(200.0, curve.maxY) |
|||
assertEquals(listOf(-30.0 to -20.0, 150.0 to 200.0), curve.points) |
|||
assertEquals(100.0, original.yMax) |
|||
assertEquals(200, original.points.last().data) |
|||
} |
|||
|
|||
@Test fun typeBUsesBkpAndPhyAndIncludesConfiguredRangeAndZero() { |
|||
val original = map(CompensationMapType.TYPE_B).copy(yMin = -100.0, yMax = 300.0) |
|||
val curve = compensationCurveGeometry(original)!! |
|||
assertEquals(listOf(10.0 to -30.0, 20.0 to 150.0), curve.points) |
|||
assertEquals(-100.0, curve.minY) |
|||
assertEquals(300.0, curve.maxY) |
|||
val positive = compensationCurveGeometry(original.copy(yMin = 10.0, yMax = 20.0, |
|||
points = listOf(MapPoint(0, 1, 0, 15.0))))!! |
|||
assertEquals(0.0, positive.minY) |
|||
} |
|||
|
|||
@Test fun equalValuesHaveNonzeroDisplayRanges() { |
|||
val curve = compensationCurveGeometry(map().copy(yMin = 0.0, yMax = 0.0, |
|||
points = listOf(MapPoint(0, 0, 0, 0.0))))!! |
|||
assertEquals(-10.0, curve.minX) |
|||
assertEquals(10.0, curve.maxX) |
|||
assertEquals(-10.0, curve.minY) |
|||
assertEquals(10.0, curve.maxY) |
|||
} |
|||
|
|||
@Test fun invalidDataDoesNotPoisonRangeAndRemainsAGap() { |
|||
val original = map().copy(yMin = Double.NaN, yMax = Double.POSITIVE_INFINITY, |
|||
points = listOf(MapPoint(0, 1, 10, 1.0), MapPoint(1, 2, 20, Double.NaN), MapPoint(2, 3, 30, 3.0))) |
|||
val curve = compensationCurveGeometry(original)!! |
|||
assertEquals(1.0, curve.minX) |
|||
assertEquals(3.0, curve.maxX) |
|||
assertTrue(curve.points[1].first.isNaN()) |
|||
assertNull(compensationCurveGeometry(original.copy(points = listOf(original.points[1])))) |
|||
assertNull(compensationCurveGeometry(original.copy(points = emptyList()))) |
|||
} |
|||
|
|||
@Test fun compensationBoundsStayInsideCanvasAndRejectTooSmallAreas() { |
|||
assertNull(compensationPlotBounds(81f, 300f)) |
|||
assertNull(compensationPlotBounds(300f, 63f)) |
|||
assertNull(compensationPlotBounds(Float.NaN, 300f)) |
|||
val bounds = compensationPlotBounds(300f, 200f)!! |
|||
assertEquals(60f, bounds.left) |
|||
assertEquals(288f, bounds.right) |
|||
assertEquals(162f, bounds.bottom) |
|||
assertTrue(bounds.isDrawable) |
|||
} |
|||
|
|||
@Test fun timeGraphBoundsNeverExceedCanvasEvenWithManyAxesAndLargeLegend() { |
|||
for (width in listOf(0f, 20f, 120f, 300f, 1000f)) { |
|||
for (height in listOf(0f, 10f, 50f, 300f)) { |
|||
for (legend in 0..3) { |
|||
val b = MultiAxisCoordinateTransformer.calculatePlotBounds(width, height, 4, |
|||
rightAxisCount = 4, legendPosition = legend, legendWidthPx = 600f, seriesCount = 20) |
|||
assertTrue(b.left in 0f..width && b.right in b.left..width) |
|||
assertTrue(b.top in 0f..height && b.bottom in b.top..height) |
|||
} |
|||
} |
|||
} |
|||
assertFalse(MultiAxisCoordinateTransformer.calculatePlotBounds(0f, 0f, 1).isDrawable) |
|||
} |
|||
|
|||
@Test fun columnDefinitionsPreserveTypeSpecificOrderAndValues() { |
|||
assertEquals(listOf("IDX", "PHY", "BKP", "Data"), compensationPointColumns(true).map { it.title }) |
|||
assertEquals(listOf("IDX", "BKP", "Data", "PHY"), compensationPointColumns(false).map { it.title }) |
|||
assertEquals(listOf("0", "-30", "10", "-20"), compensationPointColumns(true).map { it.text(map().points[0]) }) |
|||
for (typeA in listOf(true, false)) { |
|||
val columns = compensationMapColumns(typeA) |
|||
assertEquals(11, columns.size) |
|||
assertEquals("DESCRIPTION", columns.last().title) |
|||
assertEquals(11, columns.map { it.title }.distinct().size) |
|||
assertEquals(if (typeA) "XNAME" else "CVS_A", columns[5].title) |
|||
} |
|||
} |
|||
|
|||
@Test fun pointAndMetadataWidthsAreIsolatedAndRestored() { |
|||
var saved = emptyMap<String, String>() |
|||
val widths = WindowColumnWidths(WindowUiStore(emptyMap()) { saved = it }) |
|||
widths["comp:map:YNAME"] = androidx.compose.ui.unit.Dp(240f) |
|||
widths["comp:point:PHY"] = androidx.compose.ui.unit.Dp(110f) |
|||
val restored = WindowColumnWidths(WindowUiStore(saved) {}) |
|||
assertEquals(240f, restored["comp:map:YNAME"]!!.value) |
|||
assertEquals(110f, restored["comp:point:PHY"]!!.value) |
|||
assertNull(restored["comp:map:PHY"]) |
|||
} |
|||
} |
|||
@ -1,50 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.mdb.* |
|||
import com.dct.app.presentation.signaltree.* |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class ConstantPresentationTest { |
|||
private val constant = MdbConstant(1, "Torque", 350.0, 0x1000, 0.0, 500.0, MdbAttrType.ATTR_2_UINT16) |
|||
|
|||
@Test fun numbersAreIntegersIncludingUint32WithoutExponentOrNegativeZero() { |
|||
assertEquals("350", formatConstantInteger(350.0)) |
|||
assertEquals("4294967295", formatConstantInteger(4294967295.0)) |
|||
assertEquals("-2147483648", formatConstantInteger(-2147483648.0)) |
|||
assertEquals("0", formatConstantInteger(-0.0)) |
|||
for (bad in listOf(Double.NaN, Double.POSITIVE_INFINITY, 1.5)) assertEquals("N/A", formatConstantInteger(bad)) |
|||
} |
|||
|
|||
@Test fun editorRejectsFractionsNonFiniteAndMdbRangeViolations() { |
|||
for (text in listOf("", "abc", "NaN", "Infinity", "1.5", "501", "-1")) assertNotNull(constantInputError(text, constant), text) |
|||
for (text in listOf("0", "350", "500", "350.0")) assertNull(constantInputError(text, constant), text) |
|||
} |
|||
|
|||
@Test fun allSignedAndUnsignedAttributeBoundariesAreChecked() { |
|||
for (attr in MdbAttrType.entries) { |
|||
val bits = attr.byteSize * 8 |
|||
val min = if (attr.isSigned) -(1L shl (bits - 1)) else 0L |
|||
val max = if (attr.isSigned) (1L shl (bits - 1)) - 1 else (1L shl bits) - 1 |
|||
val c = constant.copy(attr = attr, min = -1e15, max = 1e15) |
|||
assertNull(constantInputError(min.toString(), c)) |
|||
assertNull(constantInputError(max.toString(), c)) |
|||
assertNotNull(constantInputError((min - 1).toString(), c)) |
|||
assertNotNull(constantInputError((max + 1).toString(), c)) |
|||
} |
|||
} |
|||
|
|||
@Test fun checkedFilterUsesStableIdsAndDoesNotLoseChecksWhenSearchChanges() { |
|||
val constants = listOf(constant, constant.copy(idx = 2, name = "RPM")) |
|||
assertEquals(listOf(constant), filterConstants(constants, "torQUE", emptySet(), false)) |
|||
assertEquals(listOf(constants[1]), filterConstants(constants, "torQUE", setOf(2L), true)) |
|||
assertTrue(filterConstants(constants, "", emptySet(), true).isEmpty()) |
|||
assertEquals(constants, filterConstants(constants, "", setOf(2L), false)) |
|||
} |
|||
|
|||
@Test fun invalidMetadataRangeDoesNotPermitWrites() { |
|||
for (c in listOf(constant.copy(min = Double.NaN), constant.copy(max = Double.POSITIVE_INFINITY), constant.copy(min = 600.0))) { |
|||
assertNotNull(constantInputError("350", c)) |
|||
} |
|||
} |
|||
} |
|||
@ -1,218 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.protocol.DctPacketCodec |
|||
import com.dct.app.data.protocol.DctProtocolRequests |
|||
import com.dct.app.domain.model.a2l.A2lDataType |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import com.dct.app.domain.model.protocol.DctCanMessageConfiguration |
|||
import com.dct.app.domain.model.project.createDefaultSensorModules |
|||
import com.google.common.truth.Truth.assertThat |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import java.time.LocalDateTime |
|||
|
|||
@DisplayName("PC DCT 프로토콜 요청 바이트 정합성") |
|||
class DctProtocolRequestsTest { |
|||
@Test |
|||
fun `P3 maintenance request bytes match PC protocol`() { |
|||
assertThat(DctProtocolRequests.savedLogInfo(0x1234).payload) |
|||
.isEqualTo(byteArrayOf(0x02, 0x12, 0x34, 0x01)) |
|||
assertThat(DctProtocolRequests.savedLogChunk(0x1234, 0x01020304, 4096).payload) |
|||
.isEqualTo(byteArrayOf(0x02, 0x12, 0x34, 0x01, 0x02, 0x03, 0x04, 0x10, 0x00)) |
|||
assertThat(DctProtocolRequests.firmwareChunk(2, 0x0123, true, byteArrayOf(0x55, 0x66)).payload) |
|||
.isEqualTo(byteArrayOf(0x05, 0x02, 0x01, 0x23, 0x02, 0x00, 0x02, 0x55, 0x66)) |
|||
assertThat(DctProtocolRequests.firmwareKeySuccess(byteArrayOf(0x11, 0x22), 0x01020304, 99).payload) |
|||
.isEqualTo(byteArrayOf(0x02, 0x01, 0x02, 0x11, 0x22, 0x01, 0x02, 0x03, 0x04, 99)) |
|||
assertThat(DctProtocolRequests.firmwareKeyFailure().payload) |
|||
.isEqualTo(byteArrayOf(0x02, 0x02, 0x00)) |
|||
|
|||
// [ISSUE-R1-01] OTA firmware subcommands (0x06, 0x07, 0x08) & Heartbeat (0x05) |
|||
val removePacket = DctProtocolRequests.firmwareRemove(2) |
|||
assertThat(removePacket.command).isEqualTo(0x31.toByte()) |
|||
assertThat(removePacket.payload).isEqualTo(byteArrayOf(0x06, 0x02)) |
|||
|
|||
val removeBytes = DctProtocolRequests.buildRemoveFirmwareRequest(2) |
|||
assertThat(removeBytes.first()).isEqualTo(0xA1.toByte()) |
|||
assertThat(removeBytes.last()).isEqualTo(0x7E.toByte()) |
|||
|
|||
val triggerPacket = DctProtocolRequests.firmwareTriggerUpdate(0) |
|||
assertThat(triggerPacket.command).isEqualTo(0x31.toByte()) |
|||
assertThat(triggerPacket.payload).isEqualTo(byteArrayOf(0x07, 0x00)) |
|||
|
|||
val triggerBytes = DctProtocolRequests.buildTriggerFirmwareUpdateRequest() |
|||
assertThat(triggerBytes.first()).isEqualTo(0xA1.toByte()) |
|||
assertThat(triggerBytes.last()).isEqualTo(0x7E.toByte()) |
|||
|
|||
val progressAck = DctProtocolRequests.firmwareUpdateResponse(0x01) |
|||
assertThat(progressAck.command).isEqualTo(0x31.toByte()) |
|||
assertThat(progressAck.payload).isEqualTo(byteArrayOf(0x08, 0x01)) |
|||
|
|||
val completedAck = DctProtocolRequests.firmwareUpdateResponse(0x02) |
|||
assertThat(completedAck.command).isEqualTo(0x31.toByte()) |
|||
assertThat(completedAck.payload).isEqualTo(byteArrayOf(0x08, 0x02)) |
|||
|
|||
val alivePacket = DctProtocolRequests.possibleToConnect() |
|||
assertThat(alivePacket.command).isEqualTo(0x05.toByte()) |
|||
assertThat(alivePacket.payload).isEmpty() |
|||
} |
|||
private val codec = DctPacketCodec() |
|||
|
|||
@Test |
|||
fun `핵심 제어 명령은 PC 골든 프레임과 일치한다`() { |
|||
assertThat(codec.encode(DctProtocolRequests.enable())).isEqualTo(hex("A1 00 01 00 5D 7E")) |
|||
assertThat(codec.encode(DctProtocolRequests.version())).isEqualTo(hex("A1 00 01 01 5C 7E")) |
|||
assertThat(codec.encode(DctProtocolRequests.hardwareId())).isEqualTo(hex("A1 00 01 03 5A 7E")) |
|||
assertThat(codec.encode(DctProtocolRequests.startAll())).isEqualTo(hex("A1 00 02 20 01 3B 7E")) |
|||
assertThat(codec.encode(DctProtocolRequests.stop())).isEqualTo(hex("A1 00 01 21 3C 7E")) |
|||
assertThat(codec.encode(DctProtocolRequests.canStreamAck())).isEqualTo(hex("A1 00 02 23 01 38 7E")) |
|||
assertThat(codec.encode(DctProtocolRequests.smStreamAck())).isEqualTo(hex("A1 00 02 24 01 37 7E")) |
|||
assertThat(codec.encode(DctProtocolRequests.xcpStreamAck())).isEqualTo(hex("A1 00 02 50 01 0B 7E")) |
|||
assertThat(codec.encode(DctProtocolRequests.dctEnvQuery(0x00))).isEqualTo(hex("A1 00 02 09 00 53 7E")) |
|||
assertThat(codec.encode(DctProtocolRequests.dctEnvQuery(0x03))).isEqualTo(hex("A1 00 02 09 03 50 7E")) |
|||
assertThat(codec.encode(DctProtocolRequests.smInfoCountQuery())).isEqualTo(hex("A1 00 03 12 01 00 48 7E")) |
|||
} |
|||
|
|||
@Test |
|||
fun `프로젝트 DB 설정은 PC SendDBInfo 형식과 일치한다`() { |
|||
val request = DctProtocolRequests.dbInfo("HE1ID") |
|||
// HE1ID: [0x00][length 5][48 45 31 49 44] |
|||
assertThat(request.payload).isEqualTo(byteArrayOf(0x00, 5, 0x48, 0x45, 0x31, 0x49, 0x44)) |
|||
} |
|||
|
|||
@Test |
|||
fun `시간 동기화는 PC의 8바이트 날짜 형식을 사용한다`() { |
|||
val monday = LocalDateTime.of(2026, 8, 31, 14, 5, 9) |
|||
assertThat(DctProtocolRequests.syncTime(monday).payload).isEqualTo( |
|||
hex("0E 05 09 07 EA 08 1F 40") |
|||
) |
|||
} |
|||
|
|||
@Test |
|||
fun `MDB 상수 주소는 범위에 따라 3바이트 또는 4바이트로 직렬화한다`() { |
|||
assertThat(DctProtocolRequests.constantWrite(0x123456, hex("12 34")).payload) |
|||
.isEqualTo(hex("03 12 34 56 02 12 34")) |
|||
assertThat(DctProtocolRequests.constantRead(0x12345678, 4).payload) |
|||
.isEqualTo(hex("04 12 34 56 78 04")) |
|||
} |
|||
|
|||
@Test |
|||
fun `XCP Characteristic은 타입 값 주소 순서를 따른다`() { |
|||
val request = DctProtocolRequests.xcpCharacteristicWrite( |
|||
address = 0x12345678, |
|||
dataType = A2lDataType.UWORD, |
|||
value = 0x1020.toDouble(), |
|||
isMsbFirst = true |
|||
) |
|||
assertThat(request.payload).isEqualTo(hex("02 10 20 12 34 56 78")) |
|||
|
|||
val read = DctProtocolRequests.xcpCharacteristicRead( |
|||
address = 0x12345678, |
|||
dataType = A2lDataType.UWORD, |
|||
isMsbFirst = false |
|||
) |
|||
assertThat(read.payload).isEqualTo(hex("02 78 56 34 12")) |
|||
} |
|||
|
|||
@Test |
|||
fun `XCP 측정 목록은 FLOAT 원본 타입과 주소 엔디안을 보존한다`() { |
|||
val signal = SignalDefinition( |
|||
reclid = 0, |
|||
idx = 0, |
|||
name = "FloatValue", |
|||
attr = MdbAttrType.ATTR_4_UINT32, |
|||
cvsA = 1.0, |
|||
cvsB = 0.0, |
|||
unit = "", |
|||
color = 0, |
|||
min = 0.0, |
|||
max = 1.0, |
|||
adl = 0x12345678, |
|||
a2lDataType = A2lDataType.FLOAT32_IEEE |
|||
) |
|||
|
|||
assertThat(DctProtocolRequests.xcpMeasurements(listOf(signal), isMsbFirst = true).payload) |
|||
.isEqualTo(hex("00 01 09 12 34 56 78")) |
|||
assertThat(DctProtocolRequests.xcpMeasurements(listOf(signal), isMsbFirst = false).payload) |
|||
.isEqualTo(hex("00 01 09 78 56 34 12")) |
|||
} |
|||
|
|||
@Test |
|||
fun `DID 명령과 응답 값은 PC enum과 일치한다`() { |
|||
assertThat(com.dct.app.domain.model.protocol.DctCommand.CMD_DID_INFO.code).isEqualTo(0x15.toByte()) |
|||
assertThat(com.dct.app.domain.model.protocol.DctCommand.CMD_REQ_ALL_DID_INFO.code).isEqualTo(0x18.toByte()) |
|||
assertThat(com.dct.app.domain.model.protocol.DctCommand.RES_DID_INFO.code).isEqualTo(0x95.toByte()) |
|||
assertThat(com.dct.app.domain.model.protocol.DctCommand.RES_REQ_ALL_DID_INFO.code).isEqualTo(0x98.toByte()) |
|||
} |
|||
|
|||
@Test |
|||
fun `P0 장비 설정 페이로드는 PC MainFrm 직렬화와 일치한다`() { |
|||
val signals = listOf( |
|||
SignalDefinition(1, 1, "Speed", MdbAttrType.ATTR_2_UINT16, 1.0, 0.0, "", 0, 0.0, 1.0), |
|||
SignalDefinition(1, 2, "Temp", MdbAttrType.ATTR_0_UINT8, 1.0, 0.0, "", 0, 0.0, 1.0) |
|||
) |
|||
|
|||
assertThat(DctProtocolRequests.carType("NQ5", 2).payload) |
|||
.isEqualTo(hex("03 4E 51 35 02")) |
|||
assertThat(DctProtocolRequests.mdbInfo(signals).payload) |
|||
.isEqualTo(hex("01 00 01 00 02 00 01 02 00 02 01")) |
|||
assertThat(DctProtocolRequests.mdbSelectedIds(signals).payload) |
|||
.isEqualTo(hex("01 01 02 01 02")) |
|||
assertThat(DctProtocolRequests.canDbcInfo(listOf(DctCanMessageConfiguration(0x7E0, 8))).payload) |
|||
.isEqualTo(hex("01 00 01 07 E0 08")) |
|||
assertThat(DctProtocolRequests.canDbcInfo(emptyList()).payload) |
|||
.isEqualTo(hex("00 00 00")) |
|||
assertThat(DctProtocolRequests.sensorModuleInfo(createDefaultSensorModules()).payload) |
|||
.isEqualTo(hex("01 01 FF 00 00 00")) |
|||
assertThat(DctProtocolRequests.sensorModuleInfo(emptyList()).payload) |
|||
.isEqualTo(hex("01 00")) |
|||
assertThat(DctProtocolRequests.canMode(isHighSpeedCan = true, isOldModel = true).payload) |
|||
.isEqualTo(hex("06 11")) |
|||
} |
|||
|
|||
@Test |
|||
fun `미사용 센서 모듈은 저장된 채널 타입과 무관하게 PC처럼 0으로 전송한다`() { |
|||
val modules = createDefaultSensorModules().map { module -> |
|||
module.copy(isUsed = module.moduleIndex == 2) |
|||
} |
|||
assertThat(DctProtocolRequests.sensorModuleInfo(modules.reversed()).payload) |
|||
.isEqualTo(hex("01 04 00 00 FF 00")) |
|||
assertThat(DctProtocolRequests.sensorModuleInfo(modules.map { it.copy(isUsed = false) }).payload) |
|||
.isEqualTo(hex("01 00 00 00 00 00")) |
|||
val mixed = modules.map { module -> |
|||
module.copy(channels = module.channels.map { it.copy(isVoltage = it.channelIndex % 2 == 0) }) |
|||
} |
|||
assertThat(DctProtocolRequests.sensorModuleInfo(mixed).payload) |
|||
.isEqualTo(hex("01 04 00 00 AA 00")) |
|||
} |
|||
|
|||
@Test |
|||
fun `MDB wire 폭 축소 후 중복되는 ID와 Index는 설정 전에 거절한다`() { |
|||
val base = SignalDefinition(1, 1, "A", MdbAttrType.ATTR_0_UINT8, 1.0, 0.0, "", 0, 0.0, 1.0) |
|||
assertThat(runCatching { |
|||
DctProtocolRequests.mdbSelectedIds(listOf(base, base.copy(reclid = 257, name = "B"))) |
|||
}.isFailure).isTrue() |
|||
assertThat(runCatching { |
|||
DctProtocolRequests.mdbSelectedIds(listOf(base, base.copy(idx = 257, name = "B"))) |
|||
}.isFailure).isTrue() |
|||
} |
|||
|
|||
@Test |
|||
fun `PC처럼 넓은 원본 ID를 전송 필드 하위 바이트로 직렬화한다`() { |
|||
val wideSignal = SignalDefinition( |
|||
0x1234, 0x5678, "Wide", MdbAttrType.ATTR_0_UINT8, |
|||
1.0, 0.0, "", 0, 0.0, 1.0 |
|||
) |
|||
|
|||
assertThat(DctProtocolRequests.mdbInfo(listOf(wideSignal)).payload) |
|||
.isEqualTo(hex("01 12 34 00 01 56 78 01")) |
|||
assertThat(DctProtocolRequests.mdbSelectedIds(listOf(wideSignal)).payload) |
|||
.isEqualTo(hex("01 34 01 78")) |
|||
assertThat(DctProtocolRequests.canDbcInfo(listOf(DctCanMessageConfiguration(0x800007E0, 8))).payload) |
|||
.isEqualTo(hex("01 00 01 07 E0 08")) |
|||
} |
|||
|
|||
private fun hex(value: String): ByteArray = value.trim().split(Regex("\\s+")) |
|||
.map { it.toInt(16).toByte() } |
|||
.toByteArray() |
|||
} |
|||
@ -1,170 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.protocol.CanSignalBitDecoder |
|||
import com.dct.app.data.protocol.CanFrameSignalDecoder |
|||
import com.dct.app.data.protocol.DctStreamPayloadParser |
|||
import com.dct.app.data.protocol.MdbRecordDecoder |
|||
import com.dct.app.domain.model.mdb.CanMultiplexRole |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import com.google.common.truth.Truth.assertThat |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@DisplayName("DCT A3/A4 실시간 payload 파서") |
|||
class DctStreamPayloadParserTest { |
|||
@Test |
|||
fun `MDB 스트림은 type과 ReclID를 데이터에서 분리한다`() { |
|||
val parsed = DctStreamPayloadParser.parseCanStream(hex("01 07 34 12")) |
|||
as DctStreamPayloadParser.CanStreamPayload.Mdb |
|||
assertThat(parsed.recordId).isEqualTo(7) |
|||
assertThat(parsed.data).isEqualTo(hex("34 12")) |
|||
} |
|||
|
|||
@Test |
|||
fun `CAN 스트림은 페이지와 복수 프레임 및 NA flag를 파싱한다`() { |
|||
val parsed = DctStreamPayloadParser.parseCanStream( |
|||
hex("02 01 02 02 01 23 02 AA BB 04 56 81 CC") |
|||
) as DctStreamPayloadParser.CanStreamPayload.Can |
|||
assertThat(parsed.currentPage).isEqualTo(1) |
|||
assertThat(parsed.totalPages).isEqualTo(2) |
|||
assertThat(parsed.frames).hasSize(2) |
|||
assertThat(parsed.frames[0].canId).isEqualTo(0x0123) |
|||
assertThat(parsed.frames[0].data).isEqualTo(hex("AA BB")) |
|||
assertThat(parsed.frames[0].isReceived).isTrue() |
|||
assertThat(parsed.frames[1].canId).isEqualTo(0x0456) |
|||
assertThat(parsed.frames[1].isReceived).isFalse() |
|||
} |
|||
|
|||
@Test |
|||
fun `SM 스트림은 모듈 채널 부호 소수와 NC를 파싱한다`() { |
|||
val parsed = DctStreamPayloadParser.parseSensorStream( |
|||
hex("01 02 03 03 10 25 00 22 04 FF FF 00 00 05 01 23 00 38") |
|||
)!! |
|||
assertThat(parsed).hasSize(1) |
|||
assertThat(parsed[0].moduleIndex).isEqualTo(2) |
|||
assertThat(parsed[0].channels[0].channelIndex).isEqualTo(3) |
|||
assertThat(parsed[0].channels[0].value).isWithin(0.0001).of(-37.34) |
|||
assertThat(parsed[0].channels[1].isNotConnected).isTrue() |
|||
assertThat(parsed[0].channels[1].value).isNull() |
|||
assertThat(parsed[0].channels[2].value).isWithin(0.0001).of(291.56) |
|||
} |
|||
|
|||
@Test |
|||
fun `잘린 프레임과 잘못된 DLC는 거절한다`() { |
|||
assertThat(DctStreamPayloadParser.parseCanStream(hex("02 01 01 01 23"))).isNull() |
|||
assertThat(DctStreamPayloadParser.parseCanStream(hex("02 01 01 01 23 01 41"))).isNull() |
|||
assertThat(DctStreamPayloadParser.parseSensorStream(hex("01 00 01 00 01"))).isNull() |
|||
} |
|||
|
|||
@Test |
|||
fun `Intel 및 Motorola DBC bit field를 추출한다`() { |
|||
assertThat(CanSignalBitDecoder.decode(hex("F0 0A"), 4, 8, false, false)).isEqualTo(0xAF) |
|||
assertThat(CanSignalBitDecoder.decode(hex("12 34"), 7, 8, true, false)).isEqualTo(0x12) |
|||
assertThat(CanSignalBitDecoder.decode(hex("F0"), 4, 4, false, true)).isEqualTo(-1) |
|||
} |
|||
|
|||
@Test |
|||
fun `멀티플렉서 값과 일치하는 DBC 신호만 디코딩한다`() { |
|||
fun signal(name: String, startBit: Int, role: CanMultiplexRole, mux: Long? = null) = |
|||
SignalDefinition( |
|||
reclid = 0, |
|||
idx = startBit, |
|||
name = name, |
|||
attr = MdbAttrType.ATTR_0_UINT8, |
|||
cvsA = 1.0, |
|||
cvsB = 0.0, |
|||
unit = "", |
|||
color = 0, |
|||
min = 0.0, |
|||
max = 255.0, |
|||
startBit = startBit, |
|||
bitLength = if (role == CanMultiplexRole.MULTIPLEXOR) 4 else 8, |
|||
multiplexRole = role, |
|||
multiplexValue = mux |
|||
) |
|||
|
|||
val decoded = CanFrameSignalDecoder.decode( |
|||
data = hex("07 2A 63"), |
|||
signals = listOf( |
|||
signal("Mode", 0, CanMultiplexRole.MULTIPLEXOR), |
|||
signal("Value0", 8, CanMultiplexRole.MULTIPLEXED, 0), |
|||
signal("Value7", 8, CanMultiplexRole.MULTIPLEXED, 7), |
|||
signal("Always", 16, CanMultiplexRole.NONE) |
|||
) |
|||
) |
|||
|
|||
assertThat(decoded.map { it.definition.name }).containsExactly("Mode", "Value7", "Always").inOrder() |
|||
assertThat(decoded.first { it.definition.name == "Value7" }.physicalValue).isEqualTo(42.0) |
|||
} |
|||
|
|||
@Test |
|||
fun `스트림의 중복 인덱스 잔여 바이트와 잘린 XCP 항목을 거절한다`() { |
|||
assertThat(DctStreamPayloadParser.parseCanStream(hex("02 01 01 00 FF"))).isNull() |
|||
assertThat(DctStreamPayloadParser.parseSensorStream(hex("01 00 00 FF"))).isNull() |
|||
assertThat(DctStreamPayloadParser.parseSensorStream(hex("02 00 00 00 00"))).isNull() |
|||
assertThat(DctStreamPayloadParser.parseXcpStream(hex("00 01 02 34"))).isNull() |
|||
|
|||
val xcp = DctStreamPayloadParser.parseXcpStream(hex("00 02 02 A0 0F 00 96"))!! |
|||
assertThat(xcp.values).hasSize(2) |
|||
assertThat(xcp.values[0].data).isEqualTo(hex("A0 0F")) |
|||
} |
|||
|
|||
@Test |
|||
fun `MDB 정의 길이가 달라도 수신 가능한 신호는 부분 디코딩한다`() { |
|||
val first = SignalDefinition( |
|||
7, 1, "First", MdbAttrType.ATTR_0_UINT8, 1.0, 0.0, "", 0, 0.0, 255.0, |
|||
arrayIndex = 0 |
|||
) |
|||
val second = SignalDefinition( |
|||
7, 2, "Second", MdbAttrType.ATTR_2_UINT16, 1.0, 0.0, "", 0, 0.0, 65535.0, |
|||
arrayIndex = 1 |
|||
) |
|||
val success = MdbRecordDecoder.decode(7, hex("0A 12 34"), listOf(first, second)) |
|||
as MdbRecordDecoder.DecodeResult.Success |
|||
assertThat(success.signals.map { it.physicalValue }).containsExactly(10.0, 4660.0).inOrder() |
|||
|
|||
val partial = MdbRecordDecoder.decode(7, hex("0A 12"), listOf(first, second)) |
|||
as MdbRecordDecoder.DecodeResult.Success |
|||
assertThat(partial.signals.map { it.definition.name }).containsExactly("First") |
|||
assertThat(partial.signals.single().physicalValue).isEqualTo(10.0) |
|||
assertThat(partial.warning).contains("필요=3, 수신=2") |
|||
assertThat(MdbRecordDecoder.decode(7, hex("0A 12 34"), listOf(first, second.copy(idx = 1)))) |
|||
.isInstanceOf(MdbRecordDecoder.DecodeResult.Failure::class.java) |
|||
|
|||
val extra = MdbRecordDecoder.decode(7, hex("0A 12 34 FF"), listOf(first, second)) |
|||
as MdbRecordDecoder.DecodeResult.Success |
|||
assertThat(extra.signals).hasSize(2) |
|||
assertThat(extra.warning).contains("초과 바이트 1B 무시") |
|||
} |
|||
|
|||
@Test |
|||
fun `64비트 unsigned CAN raw는 음수로 변환하지 않는다`() { |
|||
val signal = SignalDefinition( |
|||
0, 0, "U64", MdbAttrType.ATTR_4_UINT32, 1.0, 0.0, "", 0, 0.0, Double.MAX_VALUE, |
|||
startBit = 0, |
|||
bitLength = 64 |
|||
) |
|||
val decoded = CanFrameSignalDecoder.decode(ByteArray(8) { 0xFF.toByte() }, listOf(signal)).single() |
|||
assertThat(decoded.physicalValue).isGreaterThan(Long.MAX_VALUE.toDouble()) |
|||
} |
|||
|
|||
@Test |
|||
fun `DBC signed 값은 PC 저장 버킷 캐스팅 규칙을 따른다`() { |
|||
fun signed(length: Int) = SignalDefinition( |
|||
0, length, "S$length", MdbAttrType.ATTR_1_INT8, 1.0, 0.0, "", 0, -1.0, 1.0, |
|||
startBit = 0, |
|||
bitLength = length |
|||
) |
|||
|
|||
// PC는 4-bit 0xF와 12-bit 0xFFF를 각각 int8/int16 버킷으로 캐스팅한다. |
|||
assertThat(CanFrameSignalDecoder.decode(hex("0F"), listOf(signed(4))).single().rawValue).isEqualTo(15) |
|||
assertThat(CanFrameSignalDecoder.decode(hex("FF 0F"), listOf(signed(12))).single().rawValue).isEqualTo(4095) |
|||
assertThat(CanFrameSignalDecoder.decode(hex("FF"), listOf(signed(8))).single().rawValue).isEqualTo(-1) |
|||
assertThat(CanFrameSignalDecoder.decode(hex("FF FF"), listOf(signed(16))).single().rawValue).isEqualTo(-1) |
|||
} |
|||
|
|||
private fun hex(value: String): ByteArray = value.trim().split(Regex("\\s+")) |
|||
.map { it.toInt(16).toByte() } |
|||
.toByteArray() |
|||
} |
|||
@ -1,61 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.protocol.DctPacketCodec |
|||
import com.dct.app.data.protocol.DctProtocolRequests |
|||
import com.dct.app.data.protocol.DctResponseValidator |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class DctVersionResponseTest { |
|||
private fun validate(payload: ByteArray) { |
|||
// Include wire encoding/decoding; the frame length and version length are different fields. |
|||
val codec = DctPacketCodec() |
|||
val response = codec.decode(codec.encode(DctPacket(command = 0x81.toByte(), payload = payload)))!! |
|||
DctResponseValidator.validateSetup(DctProtocolRequests.version(), response) |
|||
} |
|||
|
|||
@Test fun acceptsPcLengthPrefixedVersion() { |
|||
val version = "DCT-MOBI-v1.0.0".toByteArray(Charsets.US_ASCII) |
|||
assertEquals(15, version.size) |
|||
validate(byteArrayOf(0x0F) + version) |
|||
} |
|||
|
|||
@Test fun versionLengthIsUnsigned() { |
|||
validate(byteArrayOf(0xFF.toByte()) + ByteArray(255) { 65 }) |
|||
} |
|||
|
|||
@Test fun acceptsOnlyIdentifiableNullTerminatedLegacyTestVersions() { |
|||
validate("DCT-MOBI-v1.0.0\u0000".toByteArray(Charsets.US_ASCII)) |
|||
validate("DCT-MOBI-v12.34.56\u0000".toByteArray(Charsets.US_ASCII)) |
|||
} |
|||
|
|||
@Test fun rejectsMalformedLengthPrefixedResponses() { |
|||
listOf( |
|||
byteArrayOf(), byteArrayOf(0), byteArrayOf(1), byteArrayOf(8, 65), |
|||
byteArrayOf(1, 65, 66), byteArrayOf(0xFF.toByte()) + ByteArray(254) { 65 }, |
|||
byteArrayOf(15) + "DCT-MOBI-v1.0.0\u0000".toByteArray(Charsets.US_ASCII) |
|||
).forEach { payload -> |
|||
assertThrows(IllegalArgumentException::class.java) { validate(payload) } |
|||
} |
|||
} |
|||
|
|||
@Test fun legacyCompatibilityDoesNotAcceptArbitraryTextOrCorruptedData() { |
|||
listOf( |
|||
"DCT-MOBI-v1.0.0", "DCT-MOBI-v1.0.0\u0000\u0000", |
|||
"DCT-MOBI-v1.0.0\u0000junk", "DCT-MOBI-v1.0\u0000", |
|||
"DCT-MOBI-v1.A.0\u0000", "DCT-MOBI-v1.\u0000.0\u0000", "other firmware\u0000", |
|||
"DCT-MOBI-v" + "1".repeat(250) + ".0.0\u0000" |
|||
).forEach { text -> |
|||
assertThrows(IllegalArgumentException::class.java) { validate(text.toByteArray(Charsets.US_ASCII)) } |
|||
} |
|||
} |
|||
|
|||
@Test fun validVersionCannotApproveWrongResponseCommand() { |
|||
assertThrows(IllegalArgumentException::class.java) { |
|||
DctResponseValidator.validateSetup( |
|||
DctProtocolRequests.version(), DctPacket(command = 0x83.toByte(), payload = byteArrayOf(1, 65)) |
|||
) |
|||
} |
|||
} |
|||
} |
|||
@ -1,54 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import android.content.SharedPreferences |
|||
import com.dct.app.data.preferences.DeveloperOptionsPreferences |
|||
import com.dct.app.presentation.main.DeveloperOptionsAccess |
|||
import io.mockk.every |
|||
import io.mockk.mockk |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class DeveloperOptionsTest { |
|||
@Test fun fiveConsecutiveTapsUnlockThenOneTapReopensUntilANewSession() { |
|||
val access = DeveloperOptionsAccess() |
|||
repeat(4) { assertFalse(access.onTitleTap(it * 150L)) } |
|||
assertTrue(access.onTitleTap(600)) |
|||
assertTrue(access.onTitleTap(100_000)) |
|||
assertFalse(DeveloperOptionsAccess().onTitleTap(100_150)) |
|||
} |
|||
|
|||
@Test fun pausesAndClockDiscontinuityResetTheTapSequence() { |
|||
val access = DeveloperOptionsAccess() |
|||
repeat(4) { assertFalse(access.onTitleTap(it * 100L)) } |
|||
assertFalse(access.onTitleTap(1_301)) |
|||
assertFalse(access.onTitleTap(1_000)) |
|||
repeat(3) { assertFalse(access.onTitleTap(1_100L + it * 100)) } |
|||
assertTrue(access.onTitleTap(1_400)) |
|||
} |
|||
|
|||
@Test fun closingTheUiRelocksEvenIfTheBackgroundSessionIsRetained() { |
|||
val access = DeveloperOptionsAccess() |
|||
repeat(5) { access.onTitleTap(it * 100L) } |
|||
assertTrue(access.onTitleTap(500)) |
|||
access.lock() |
|||
repeat(4) { assertFalse(access.onTitleTap(600L + it * 100)) } |
|||
assertTrue(access.onTitleTap(1_000)) |
|||
} |
|||
|
|||
@Test fun preferenceSurvivesNewStoreAndLockedAccessWithoutBeingReset() { |
|||
val values = mutableMapOf<String, Boolean>() |
|||
val prefs = mockk<SharedPreferences>() |
|||
val editor = mockk<SharedPreferences.Editor>() |
|||
every { prefs.getBoolean(any(), any()) } answers { values[firstArg()] ?: secondArg() } |
|||
every { prefs.edit() } returns editor |
|||
every { editor.putBoolean(any(), any()) } answers { values[firstArg()] = secondArg(); editor } |
|||
every { editor.apply() } returns Unit |
|||
assertFalse(DeveloperOptionsPreferences(prefs).receiveAutoRecoveryEnabled()) |
|||
DeveloperOptionsPreferences(prefs).setReceiveAutoRecoveryEnabled(false) |
|||
assertFalse(DeveloperOptionsAccess().onTitleTap(0)) |
|||
assertFalse(DeveloperOptionsPreferences(prefs).receiveAutoRecoveryEnabled()) |
|||
DeveloperOptionsPreferences(prefs).setReceiveAutoRecoveryEnabled(true) |
|||
assertTrue(DeveloperOptionsPreferences(prefs).receiveAutoRecoveryEnabled()) |
|||
assertEquals(setOf("receive_auto_recovery"), values.keys) |
|||
} |
|||
} |
|||
@ -1,721 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import android.os.Environment |
|||
import com.dct.app.data.repository.DpcProjectManager |
|||
import com.dct.app.domain.model.mdb.CompensationMap |
|||
import com.dct.app.domain.model.mdb.CompensationMapType |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.MdbConstant |
|||
import com.dct.app.domain.model.mdb.MdbDatabase |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import com.dct.app.domain.model.mdb.SignalGroup |
|||
import com.dct.app.domain.model.project.DpcProject |
|||
import io.mockk.every |
|||
import io.mockk.mockkStatic |
|||
import io.mockk.unmockkStatic |
|||
import java.io.File |
|||
import org.json.JSONObject |
|||
import org.junit.jupiter.api.Assertions.assertEquals |
|||
import org.junit.jupiter.api.Assertions.assertFalse |
|||
import org.junit.jupiter.api.Assertions.assertNotNull |
|||
import org.junit.jupiter.api.Assertions.assertTrue |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
|
|||
class DpcProjectManagerTest { |
|||
@Test |
|||
fun csvMillisecondsDefaultFalseAndProjectSaveRestorePreservesThePcKey() { |
|||
assertFalse(DpcProject().csvWithMilliseconds) |
|||
assertFalse(DpcProjectManager.parseProjectFromJson("{}", null).csvWithMilliseconds) |
|||
val legacy = DpcProjectManager.parseProjectFromJson("{\"android_log_microseconds\":true}", null) |
|||
assertFalse(legacy.csvWithMilliseconds) |
|||
assertFalse(JSONObject(DpcProjectManager.serializeProjectToJson(legacy)).has("android_log_microseconds")) |
|||
listOf(false, true).forEach { enabled -> |
|||
val json = DpcProjectManager.serializeProjectToJson(DpcProject(csvWithMilliseconds = enabled)) |
|||
assertEquals(enabled, JSONObject(json).getBoolean("csv_with_miliseconds")) |
|||
assertEquals(enabled, DpcProjectManager.parseProjectFromJson(json, null).csvWithMilliseconds) |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
fun pcProjectNameOmitsDpcExtensionWithoutChangingTheStoredFileName() { |
|||
val project = DpcProject(projectFileName = "example.dpc") |
|||
val json = JSONObject(DpcProjectManager.serializeProjectToJson(project)) |
|||
assertEquals("example", json.getString("name")) |
|||
assertEquals("example.dpc", project.projectFileName) |
|||
} |
|||
@Test |
|||
@DisplayName("P3 ask_info가 저장과 복원에서 보존되어야 한다") |
|||
fun testAskInfoRoundtrip() { |
|||
val project = DpcProject( |
|||
askInfo = com.dct.app.domain.model.project.DpcAskInfo( |
|||
firmwareAddress = "1234ABCD", |
|||
stMin = 5, |
|||
seedKeyPath = "vendor.so", |
|||
dependsOnRom = true |
|||
) |
|||
) |
|||
|
|||
val parsed = DpcProjectManager.parseProjectFromJson( |
|||
DpcProjectManager.serializeProjectToJson(project), |
|||
null |
|||
) |
|||
|
|||
assertEquals(project.askInfo, parsed.askInfo) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("DPC 프로젝트 직렬화 시 PC C++ 호환 27개 루트 키 및 프로퍼티 구조가 완벽히 생성되어야 한다") |
|||
fun testSerializeProjectToJson_FullPcCompatibility() { |
|||
val signals = listOf( |
|||
SignalDefinition( |
|||
reclid = 1, |
|||
idx = 1, |
|||
name = "Engine_Speed", |
|||
attr = MdbAttrType.ATTR_2_UINT16, |
|||
cvsA = 1.0, |
|||
cvsB = 0.0, |
|||
unit = "rpm", |
|||
color = 0x00FF0000L, |
|||
min = 0.0, |
|||
max = 8000.0, |
|||
description = "실시간 RPM", |
|||
adl = 100 |
|||
) |
|||
) |
|||
val constants = listOf( |
|||
MdbConstant( |
|||
idx = 10, |
|||
name = "Target_Idle_RPM", |
|||
data = 750.0, |
|||
addr = 200L, |
|||
min = 500.0, |
|||
max = 1200.0, |
|||
attr = MdbAttrType.ATTR_2_UINT16, |
|||
description = "목표 아이들 RPM" |
|||
) |
|||
) |
|||
val compA = listOf( |
|||
CompensationMap( |
|||
type = CompensationMapType.TYPE_A, |
|||
idx = 1, |
|||
yName = "Idle_Base_Duty", |
|||
yAddr = 310L, |
|||
yAttr = MdbAttrType.ATTR_2_UINT16, |
|||
yMin = 0.0, |
|||
yMax = 100.0, |
|||
xName = "Coolant_Temp", |
|||
xAddr = 300L, |
|||
xAttr = MdbAttrType.ATTR_2_UINT16, |
|||
cvsA = 1.0, |
|||
cvsB = 0.0, |
|||
description = "냉각수온 보정" |
|||
) |
|||
) |
|||
|
|||
val mdbDb = MdbDatabase( |
|||
groups = listOf(SignalGroup(reclid = 1, strIndex = "1", description = "Engine", usage = true, signals = signals)), |
|||
constants = constants, |
|||
compensationMaps = compA |
|||
) |
|||
|
|||
val canSignals = listOf( |
|||
SignalDefinition( |
|||
reclid = 2, |
|||
idx = 1, |
|||
name = "CAN_Vehicle_Speed", |
|||
attr = MdbAttrType.ATTR_2_UINT16, |
|||
cvsA = 1.0, |
|||
cvsB = 0.0, |
|||
unit = "km/h", |
|||
color = 0x0000FF00L, |
|||
min = 0.0, |
|||
max = 250.0, |
|||
description = "차량 차속", |
|||
adl = 50 |
|||
) |
|||
) |
|||
|
|||
val a2lSignals = listOf( |
|||
SignalDefinition( |
|||
reclid = 3, |
|||
idx = 1, |
|||
name = "A2L_Battery_Voltage", |
|||
attr = MdbAttrType.ATTR_2_UINT16, |
|||
cvsA = 0.1, |
|||
cvsB = 0.0, |
|||
unit = "V", |
|||
color = 0x000000FFL, |
|||
min = 0.0, |
|||
max = 18.0, |
|||
description = "배터리 전압", |
|||
adl = 60 |
|||
) |
|||
) |
|||
|
|||
val project = DpcProject( |
|||
projectFileName = "TEST_PROJECT", |
|||
vehicleCode = "GENESIS_G90", |
|||
mdbFileName = "Engine_Data.mdb", |
|||
canDbcFileName = "Vehicle_CAN.dbc", |
|||
a2lFileName = "ECU_Firmware.a2l", |
|||
writeCsv = true, |
|||
writeMf4 = false, |
|||
canMode = "CAN(HiSpeed)", |
|||
forOldModel = false, |
|||
mdbDatabase = mdbDb, |
|||
canSignals = canSignals, |
|||
a2lSignals = a2lSignals |
|||
) |
|||
|
|||
val jsonStr = DpcProjectManager.serializeProjectToJson(project) |
|||
val json = JSONObject(jsonStr) |
|||
|
|||
// 1. Root Keys 검증 |
|||
assertEquals("TEST_PROJECT", json.getString("name")) |
|||
assertEquals("GENESIS_G90", json.getString("cartype")) |
|||
assertEquals(1, json.getInt("canmode")) |
|||
assertEquals(0, json.getInt("oldcanmode")) |
|||
assertEquals(1, json.getInt("writecsv")) |
|||
assertEquals(0, json.getInt("writemf4")) |
|||
assertTrue(json.has("base_folder")) |
|||
assertTrue(json.has("DID_INFO")) |
|||
assertTrue(json.has("hw_device")) |
|||
assertTrue(json.has("ask_info")) |
|||
assertTrue(json.has("ota_info")) |
|||
assertTrue(json.has("view_rect")) |
|||
assertTrue(json.has("graphItem_property")) |
|||
|
|||
// 2. external_file 검증 (4개 엔트리) |
|||
val extFiles = json.getJSONArray("external_file") |
|||
assertEquals(4, extFiles.length()) |
|||
val mdbExt = extFiles.getJSONObject(0) |
|||
assertEquals("mdb", mdbExt.getString("ext")) |
|||
assertEquals("\\MDB\\Engine_Data.mdb", mdbExt.getString("path")) |
|||
assertEquals(1, mdbExt.getInt("mdbfile_path_use_basefolder")) |
|||
|
|||
val dbcExt = extFiles.getJSONObject(1) |
|||
assertEquals("dbc", dbcExt.getString("ext")) |
|||
assertEquals("\\DBC\\Vehicle_CAN.dbc", dbcExt.getString("path")) |
|||
assertEquals(1, dbcExt.getInt("dbcfile_path_use_basefolder")) |
|||
|
|||
// 3. candbc_property 검증 |
|||
assertTrue(json.has("candbc_property")) |
|||
val canProp = json.getJSONObject("candbc_property").getJSONArray("property").getJSONObject(0) |
|||
val canItems = canProp.getJSONArray("items") |
|||
assertEquals("CAN_Vehicle_Speed", canItems.getJSONObject(0).getString("Name")) |
|||
assertEquals(0x0000FF00L, canItems.getJSONObject(0).getLong("USER_COLOR")) |
|||
assertEquals("차량 차속", canItems.getJSONObject(0).getString("Descrip")) |
|||
|
|||
// 4. mdb_recv_property 검증 |
|||
assertTrue(json.has("mdb_recv_property")) |
|||
val mdbRecv = json.getJSONObject("mdb_recv_property").getJSONArray("property") |
|||
val sigGroup = mdbRecv.getJSONObject(0) |
|||
assertEquals("MDB Signal", sigGroup.getString("name")) |
|||
val sigItems = sigGroup.getJSONArray("items") |
|||
assertEquals("Engine_Speed", sigItems.getJSONObject(0).getString("Name")) |
|||
assertEquals(0x00FF0000L, sigItems.getJSONObject(0).getLong("USER_COLOR")) |
|||
assertEquals("실시간 RPM", sigItems.getJSONObject(0).getString("Descrip")) |
|||
|
|||
val conGroup = mdbRecv.getJSONObject(1) |
|||
assertEquals("Constant Signal", conGroup.getString("name")) |
|||
val conItems = conGroup.getJSONArray("items") |
|||
assertEquals("Target_Idle_RPM", conItems.getJSONObject(0).getString("Name")) |
|||
assertEquals(750.0, conItems.getJSONObject(0).getDouble("Value")) |
|||
|
|||
// 5. mdb_compensation_A_property 검증 |
|||
assertTrue(json.has("mdb_compensation_A_property")) |
|||
val compAProp = json.getJSONObject("mdb_compensation_A_property").getJSONArray("items") |
|||
assertEquals("Coolant_Temp", compAProp.getJSONObject(0).getString("XNAME")) |
|||
assertEquals("Idle_Base_Duty", compAProp.getJSONObject(0).getString("YNAME")) |
|||
|
|||
// 6. a2l_property 검증 |
|||
assertTrue(json.has("a2l_property")) |
|||
val a2lItems = json.getJSONObject("a2l_property").getJSONObject("measurement").getJSONArray("items") |
|||
assertEquals("A2L_Battery_Voltage", a2lItems.getJSONObject(0).getString("Name")) |
|||
assertEquals(0x000000FFL, a2lItems.getJSONObject(0).getLong("USER_COLOR")) |
|||
assertEquals("배터리 전압", a2lItems.getJSONObject(0).getString("Descrip")) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("PC 원본 .dpc JSON을 로드하여 파싱하고 다시 저장할 때 원본 속성이 100% 보존되어야 한다") |
|||
fun testParseAndRoundtripPcJson() { |
|||
val samplePcJson = """ |
|||
{ |
|||
"DID_INFO" : { |
|||
"DIDF100PN2" : "", |
|||
"DIDF187PN" : "", |
|||
"DIDF18BPD" : "", |
|||
"DIDF191HW" : "", |
|||
"DIDF193SHW" : "", |
|||
"DIDF197SN" : "", |
|||
"DIDF1A1SC" : "", |
|||
"DIDPreSetting" : 49 |
|||
}, |
|||
"ask_info" : { |
|||
"ASKFWAddr" : "", |
|||
"ASKSTMin" : 0, |
|||
"seedKeyPath" : "" |
|||
}, |
|||
"autostart_measuring_recording" : 0, |
|||
"base_folder" : "C:\\Users\\COMPUTER1\\Documents\\DCT Work", |
|||
"candbc_property" : { |
|||
"property" : [ |
|||
{ |
|||
"id" : 0, |
|||
"items" : [ |
|||
{ |
|||
"Descrip" : "엔진 속도", |
|||
"Name" : "Engine_RPM", |
|||
"USER_COLOR" : 65280, |
|||
"item_dashstyle" : 0, |
|||
"item_thickness" : 2 |
|||
} |
|||
], |
|||
"name" : "CAN Signal" |
|||
} |
|||
] |
|||
}, |
|||
"canmode" : 1, |
|||
"cartype" : "NQ5", |
|||
"copy_savedfolder" : "C:\\Users\\COMPUTER1\\Documents\\DCT Work\\Data", |
|||
"external_file" : [ |
|||
{ |
|||
"ext" : "mdb", |
|||
"mdbfile_path_use_basefolder" : 1, |
|||
"path" : "\\MDB\\NQ5_Seat.mdb" |
|||
}, |
|||
{ |
|||
"dbcfile_path_use_basefolder" : 0, |
|||
"ext" : "dbc", |
|||
"path" : "C:\\CanDb.dbc" |
|||
}, |
|||
{ |
|||
"ext" : "smf", |
|||
"path" : "", |
|||
"smffile_path_use_basefolder" : 0 |
|||
}, |
|||
{ |
|||
"a2lfile_path_use_basefolder" : 0, |
|||
"ext" : "a2l", |
|||
"path" : "" |
|||
} |
|||
], |
|||
"graphItem_property" : { |
|||
"graph_linear" : true |
|||
}, |
|||
"hw_device" : { |
|||
"com_port" : "", |
|||
"connectedType" : 1, |
|||
"host_address" : "", |
|||
"macaddr" : "", |
|||
"sm_count" : 0 |
|||
}, |
|||
"isave_logfile" : 1, |
|||
"layout_wnd" : { |
|||
"items" : [], |
|||
"layoutcnt" : 0 |
|||
}, |
|||
"logfile_path" : "\\Data", |
|||
"logfile_path_use_basefolder" : 1, |
|||
"maker" : 2, |
|||
"name" : "PROJECT", |
|||
"oldcanmode" : 0, |
|||
"version" : "0.0.0.2", |
|||
"writecsv" : 1, |
|||
"writemf4" : 0 |
|||
} |
|||
""".trimIndent() |
|||
|
|||
val parsed = DpcProjectManager.parseProjectFromJson(samplePcJson, null) |
|||
assertEquals("PROJECT", parsed.projectFileName) |
|||
assertEquals("NQ5", parsed.vehicleCode) |
|||
assertEquals("NQ5_Seat.mdb", parsed.mdbFileName) |
|||
assertEquals("CanDb.dbc", parsed.canDbcFileName) |
|||
assertEquals("CAN(HiSpeed)", parsed.canMode) |
|||
assertEquals(true, parsed.writeCsv) |
|||
assertEquals(65280L, parsed.canSignalColors["Engine_RPM"]) |
|||
assertEquals("엔진 속도", parsed.canSignalDescriptions["Engine_RPM"]) |
|||
assertNotNull(parsed.rawJsonRoot) |
|||
|
|||
// 수정 후 재직렬화 |
|||
val modified = parsed.copy(vehicleCode = "NQ5_FACELIFT") |
|||
val reSerialized = DpcProjectManager.serializeProjectToJson(modified) |
|||
val reJson = JSONObject(reSerialized) |
|||
|
|||
assertEquals("NQ5_FACELIFT", reJson.getString("cartype")) |
|||
assertEquals("PROJECT", reJson.getString("name")) |
|||
assertEquals(1, reJson.getInt("canmode")) |
|||
assertEquals(1, reJson.getInt("writecsv")) |
|||
assertTrue(reJson.has("DID_INFO")) |
|||
assertTrue(reJson.has("candbc_property")) |
|||
assertTrue(reJson.has("layout_wnd")) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("하드코딩 없는 동적 base_folder 및 use_basefolder 상대 경로 직렬화/역직렬화가 정상 동작해야 한다") |
|||
fun testDynamicBaseFolderAndUseBaseFolderResolution() { |
|||
val proj = DpcProject( |
|||
projectFileName = "CustomTest", |
|||
baseFolder = "D:\\MyWorks\\CustomDCT", |
|||
mdbFileName = "MyEcu.mdb", |
|||
canDbcFileName = "MyCan.dbc", |
|||
a2lFileName = "MyA2l.a2l", |
|||
measuredFilesFolder = "D:\\MyWorks\\CustomDCT\\Data" |
|||
) |
|||
|
|||
val jsonStr = DpcProjectManager.serializeProjectToJson(proj) |
|||
val json = JSONObject(jsonStr) |
|||
|
|||
assertEquals("D:\\MyWorks\\CustomDCT", json.getString("base_folder")) |
|||
assertEquals("\\Data", json.getString("logfile_path")) |
|||
assertEquals(1, json.getInt("logfile_path_use_basefolder")) |
|||
|
|||
val extFiles = json.getJSONArray("external_file") |
|||
var mdbObj: JSONObject? = null |
|||
var dbcObj: JSONObject? = null |
|||
var a2lObj: JSONObject? = null |
|||
for (i in 0 until extFiles.length()) { |
|||
val item = extFiles.getJSONObject(i) |
|||
when (item.getString("ext")) { |
|||
"mdb" -> mdbObj = item |
|||
"dbc" -> dbcObj = item |
|||
"a2l" -> a2lObj = item |
|||
} |
|||
} |
|||
|
|||
assertNotNull(mdbObj) |
|||
assertEquals("\\MDB\\MyEcu.mdb", mdbObj!!.getString("path")) |
|||
assertEquals(1, mdbObj.getInt("mdbfile_path_use_basefolder")) |
|||
|
|||
assertNotNull(dbcObj) |
|||
assertEquals("\\DBC\\MyCan.dbc", dbcObj!!.getString("path")) |
|||
assertEquals(1, dbcObj.getInt("dbcfile_path_use_basefolder")) |
|||
|
|||
assertNotNull(a2lObj) |
|||
assertEquals("\\A2L\\MyA2l.a2l", a2lObj!!.getString("path")) |
|||
assertEquals(1, a2lObj.getInt("a2lfile_path_use_basefolder")) |
|||
|
|||
// 역직렬화 검증 |
|||
val parsed = DpcProjectManager.parseProjectFromJson(jsonStr, null) |
|||
assertEquals("D:\\MyWorks\\CustomDCT", parsed.baseFolder) |
|||
assertEquals("MyEcu.mdb", parsed.mdbFileName) |
|||
assertEquals("MyCan.dbc", parsed.canDbcFileName) |
|||
assertEquals("MyA2l.a2l", parsed.a2lFileName) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("createDefaultProject 호출 시 안드로이드 Documents/DCT Work/Data 경로가 기본값으로 고정되고 projectFileName은 빈칸이어야 한다") |
|||
fun testDefaultMeasuredFolderAndCreateDefaultProject() { |
|||
val proj = DpcProjectManager.createDefaultProject() |
|||
assertEquals("", proj.projectFileName) |
|||
assertNotNull(proj.baseFolder) |
|||
assertTrue(proj.baseFolder.contains("DCT Work")) |
|||
assertNotNull(proj.measuredFilesFolder) |
|||
assertTrue(proj.measuredFilesFolder.contains("DCT Work") && proj.measuredFilesFolder.contains("Data")) |
|||
|
|||
val jsonStr = DpcProjectManager.serializeProjectToJson(proj) |
|||
val json = JSONObject(jsonStr) |
|||
assertTrue(json.has("base_folder")) |
|||
assertTrue(json.has("logfile_path")) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("DID 정보 및 Sensor Module 1~4 설정이 .dpc JSON으로 정확히 직렬화되고 역직렬화되어야 한다") |
|||
fun testDidInfoAndSensorModulesSerializationAndDeserialization() { |
|||
val did = com.dct.app.domain.model.project.DpcDidInfo( |
|||
partName2 = "GENESIS_ECU_V2", |
|||
ecuHwVersion = "H010", |
|||
partNumber = "391102B000", |
|||
productDate = "20260825", |
|||
supplierCode = "MOBI", |
|||
systemName = "DCTS", |
|||
supplierHwVersion = "S001" |
|||
) |
|||
val smList = com.dct.app.domain.model.project.createDefaultSensorModules().toMutableList() |
|||
// SM 1 채널 1을 Voltage로 변경하고 Description 설정 |
|||
val sm0Ch = smList[0].channels.toMutableList() |
|||
sm0Ch[0] = sm0Ch[0].copy(isVoltage = true, unit = "V", description = "배터리 전압 센서") |
|||
smList[0] = smList[0].copy(isUsed = true, channels = sm0Ch) |
|||
|
|||
val project = com.dct.app.domain.model.project.DpcProject( |
|||
projectFileName = "TEST_ADVANCED", |
|||
writeCsv = true, |
|||
writeMf4 = false, |
|||
canMode = "CAN(FD)", |
|||
forOldModel = true, |
|||
didInfo = did, |
|||
sensorModules = smList |
|||
) |
|||
|
|||
val jsonStr = DpcProjectManager.serializeProjectToJson(project) |
|||
val json = JSONObject(jsonStr) |
|||
|
|||
// 1. DID_INFO 키 검증 |
|||
assertTrue(json.has("DID_INFO")) |
|||
val didObj = json.getJSONObject("DID_INFO") |
|||
assertEquals("GENESIS_ECU_V2", didObj.getString("DIDF100PN2")) |
|||
assertEquals("H010", didObj.getString("DIDF191HW")) |
|||
assertEquals("391102B000", didObj.getString("DIDF187PN")) |
|||
assertEquals("20260825", didObj.getString("DIDF18BPD")) |
|||
assertEquals("MOBI", didObj.getString("DIDF1A1SC")) |
|||
assertEquals("DCTS", didObj.getString("DIDF197SN")) |
|||
assertEquals("S001", didObj.getString("DIDF193SHW")) |
|||
|
|||
// 2. sensormodule_property 키 검증 (PC C++ EnvSetting.cpp 표준 스키마) |
|||
assertTrue(json.has("sensormodule_property")) |
|||
val smArr = json.getJSONObject("sensormodule_property").getJSONArray("property") |
|||
assertEquals(4, smArr.length()) |
|||
val sm0 = smArr.getJSONObject(0) |
|||
assertEquals(1, sm0.getInt("sm_use")) |
|||
val ch0 = sm0.getJSONArray("items").getJSONObject(0) |
|||
assertEquals(1, ch0.getInt("VOLTAGE")) |
|||
assertEquals("배터리 전압 센서", ch0.getString("Descrip")) |
|||
|
|||
// 3. CAN mode 및 Logging 플래그 검증 |
|||
assertEquals(0, json.getInt("canmode")) // CAN(FD) -> 0 |
|||
assertEquals(1, json.getInt("oldcanmode")) // For old model -> 1 |
|||
assertEquals(1, json.getInt("writecsv")) |
|||
assertEquals(0, json.getInt("writemf4")) |
|||
|
|||
// 4. 역직렬화 검증 |
|||
val parsed = DpcProjectManager.parseProjectFromJson(jsonStr, null) |
|||
assertEquals("GENESIS_ECU_V2", parsed.didInfo.partName2) |
|||
assertEquals("391102B000", parsed.didInfo.partNumber) |
|||
assertEquals("CAN(FD)", parsed.canMode) |
|||
assertTrue(parsed.forOldModel) |
|||
assertTrue(parsed.writeCsv) |
|||
assertFalse(parsed.writeMf4) |
|||
assertEquals(4, parsed.sensorModules.size) |
|||
assertTrue(parsed.sensorModules[0].channels[0].isVoltage) |
|||
assertEquals("배터리 전압 센서", parsed.sensorModules[0].channels[0].description) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("기존 안드로이드 키(sm_property 및 formula_info)가 포함된 JSON도 완벽히 역직렬화되어야 한다") |
|||
fun testLegacyAndroidKeysCompatibility() { |
|||
val legacyJson = """ |
|||
{ |
|||
"name": "LEGACY_ANDROID", |
|||
"cartype": "NQ5", |
|||
"formula_info": { |
|||
"items": [ |
|||
{ |
|||
"Name": "CalcPower", |
|||
"Expression": "\"Torque\" * \"Speed\" / 9549", |
|||
"Unit": "kW", |
|||
"Color": 16711680, |
|||
"IsForSM": 0, |
|||
"Descrip": "출력 계산식" |
|||
} |
|||
] |
|||
}, |
|||
"sm_property": { |
|||
"modules": [ |
|||
{ |
|||
"index": 0, |
|||
"is_used": 1, |
|||
"channels": [ |
|||
{ |
|||
"index": 0, |
|||
"name": "01-01 ch", |
|||
"is_voltage": 1, |
|||
"unit": "V", |
|||
"description": "배터리 전압", |
|||
"color": 65280 |
|||
} |
|||
] |
|||
} |
|||
] |
|||
} |
|||
} |
|||
""".trimIndent() |
|||
|
|||
val parsed = DpcProjectManager.parseProjectFromJson(legacyJson, null) |
|||
assertEquals("LEGACY_ANDROID", parsed.projectFileName) |
|||
assertEquals("NQ5", parsed.vehicleCode) |
|||
|
|||
// Formula 검증 |
|||
assertEquals(1, parsed.formulas.size) |
|||
val f = parsed.formulas[0] |
|||
assertEquals("CalcPower", f.name) |
|||
assertEquals("\"Torque\" * \"Speed\" / 9549", f.expression) |
|||
assertEquals("kW", f.unit) |
|||
assertFalse(f.isForSm) |
|||
assertEquals("출력 계산식", f.description) |
|||
|
|||
// SM 검증 |
|||
assertTrue(parsed.sensorModules[0].isUsed) |
|||
val ch0 = parsed.sensorModules[0].channels[0] |
|||
assertEquals(0, ch0.channelIndex) |
|||
assertEquals("01-01 ch", ch0.name) |
|||
assertTrue(ch0.isVoltage) |
|||
assertEquals("V", ch0.unit) |
|||
assertEquals("배터리 전압", ch0.description) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("PC C++ 표준 formula_property 및 sensormodule_property 직렬화 및 양방향 라운드트립이 보장되어야 한다") |
|||
fun testPcFormulaAndSensorModuleRoundtrip() { |
|||
val formulas = listOf( |
|||
com.dct.app.domain.model.formula.FormulaDefinition( |
|||
name = "EnginePower", |
|||
expression = "\"Torque\" * \"EngineSpeed\" / 9549", |
|||
unit = "kW", |
|||
color = 0x00FF0000L, |
|||
isForSm = false, |
|||
description = "엔진 출력 수식" |
|||
), |
|||
com.dct.app.domain.model.formula.FormulaDefinition( |
|||
name = "SmTempComp", |
|||
expression = "LIN(\"01-01\"; 0; 0; 5; 100)", |
|||
unit = "'C", |
|||
color = 0x0000FF00L, |
|||
isForSm = true, |
|||
description = "센서모듈 온도 보정" |
|||
) |
|||
) |
|||
|
|||
val smList = com.dct.app.domain.model.project.createDefaultSensorModules().toMutableList() |
|||
val sm0Ch = smList[0].channels.toMutableList() |
|||
sm0Ch[0] = sm0Ch[0].copy(name = "01-01 Custom", isVoltage = false, unit = "'C", description = "온도 센서") |
|||
smList[0] = smList[0].copy(isUsed = true, channels = sm0Ch) |
|||
|
|||
val project = DpcProject( |
|||
projectFileName = "PC_COMPAT_TEST", |
|||
vehicleCode = "RG3", |
|||
formulas = formulas, |
|||
sensorModules = smList |
|||
) |
|||
|
|||
val jsonStr = DpcProjectManager.serializeProjectToJson(project) |
|||
val json = JSONObject(jsonStr) |
|||
|
|||
// PC C++ 키 존재 및 내부 스키마 검증 |
|||
assertTrue(json.has("formula_property")) |
|||
assertFalse(json.has("formula_info")) // 기존 키는 깔끔히 정리 |
|||
val fItems = json.getJSONObject("formula_property").getJSONArray("items") |
|||
assertEquals(2, fItems.length()) |
|||
assertEquals("EnginePower", fItems.getJSONObject(0).getString("name")) |
|||
assertEquals("\"Torque\" * \"EngineSpeed\" / 9549", fItems.getJSONObject(0).getString("expression")) |
|||
assertFalse(fItems.getJSONObject(0).getBoolean("forSM")) |
|||
assertEquals(0, fItems.getJSONObject(0).getInt("index")) |
|||
assertTrue(fItems.getJSONObject(1).getBoolean("forSM")) |
|||
|
|||
assertTrue(json.has("sensormodule_property")) |
|||
assertFalse(json.has("sm_property")) // 기존 키는 깔끔히 정리 |
|||
val smPropArr = json.getJSONObject("sensormodule_property").getJSONArray("property") |
|||
val sm0Obj = smPropArr.getJSONObject(0) |
|||
assertEquals(0, sm0Obj.getInt("sm_index")) |
|||
assertEquals(1, sm0Obj.getInt("sm_use")) |
|||
val chItems = sm0Obj.getJSONArray("items") |
|||
assertEquals("01-01 Custom", chItems.getJSONObject(0).getString("name")) |
|||
assertEquals(0, chItems.getJSONObject(0).getInt("VOLTAGE")) |
|||
assertEquals("온도 센서", chItems.getJSONObject(0).getString("Descrip")) |
|||
|
|||
// 역직렬화 라운드트립 검증 |
|||
val parsed = DpcProjectManager.parseProjectFromJson(jsonStr, null) |
|||
assertEquals(2, parsed.formulas.size) |
|||
assertEquals("EnginePower", parsed.formulas[0].name) |
|||
assertFalse(parsed.formulas[0].isForSm) |
|||
assertEquals("SmTempComp", parsed.formulas[1].name) |
|||
assertTrue(parsed.formulas[1].isForSm) |
|||
assertEquals("'C", parsed.formulas[1].unit) |
|||
|
|||
assertTrue(parsed.sensorModules[0].isUsed) |
|||
assertFalse(parsed.sensorModules[0].channels[0].isVoltage) |
|||
assertEquals("01-01 Custom", parsed.sensorModules[0].channels[0].name) |
|||
assertEquals("온도 센서", parsed.sensorModules[0].channels[0].description) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("기본 6개 폴더만 만들고 미사용 Screen/SMC는 반복 초기화에도 생성하지 않는다") |
|||
fun testEnsureDctWorkDirectoriesSkipsUnusedFolders(@TempDir documents: File) { |
|||
mockkStatic(Environment::class) |
|||
try { |
|||
every { Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS) } returns documents |
|||
val baseDir = DpcProjectManager.ensureDctWorkDirectories() |
|||
assertEquals(File(documents, "DCT Work"), baseDir) |
|||
DpcProjectManager.ensureDctWorkDirectories() |
|||
for (sub in listOf("Configuration", "Data", "MDB", "DBC", "A2L", "Log")) { |
|||
assertTrue(File(baseDir, sub).isDirectory, "서브폴더 $sub 가 자동 생성되어야 합니다.") |
|||
} |
|||
assertFalse(File(baseDir, "Screen").exists()) |
|||
assertFalse(File(baseDir, "SMC").exists()) |
|||
} finally { |
|||
unmockkStatic(Environment::class) |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("기존 Screen/SMC 폴더와 파일은 초기화 시 삭제하거나 덮어쓰지 않는다") |
|||
fun testEnsureDctWorkDirectoriesPreservesExistingUnusedFolders(@TempDir documents: File) { |
|||
val base = File(documents, "DCT Work") |
|||
val screenFolder = File(base, "Screen").also { assertTrue(it.mkdirs()) } |
|||
val smcFolder = File(base, "SMC").also { assertTrue(it.mkdirs()) } |
|||
val screenFile = File(screenFolder, "screen.keep").apply { writeText("existing screen") } |
|||
val smcFile = File(smcFolder, "preset.smc").apply { writeText("existing sensor config") } |
|||
mockkStatic(Environment::class) |
|||
try { |
|||
every { Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS) } returns documents |
|||
assertEquals(base, DpcProjectManager.ensureDctWorkDirectories()) |
|||
DpcProjectManager.ensureDctWorkDirectories() |
|||
assertEquals("existing screen", screenFile.readText()) |
|||
assertEquals("existing sensor config", smcFile.readText()) |
|||
assertEquals(listOf("screen.keep"), screenFolder.list()?.toList()) |
|||
assertEquals(listOf("preset.smc"), smcFolder.list()?.toList()) |
|||
} finally { |
|||
unmockkStatic(Environment::class) |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("파일 기반 프로젝트 저장 및 loadProjectFromFile 역직렬화 검증") |
|||
fun testSaveAndLoadProjectFromFile() { |
|||
val tempDir = java.io.File(System.getProperty("java.io.tmpdir"), "dct_test_config") |
|||
tempDir.mkdirs() |
|||
val tempFile = java.io.File(tempDir, "TEST_CONFIG_PROJ.dpc") |
|||
|
|||
val project = DpcProject( |
|||
projectFileName = "TEST_CONFIG_PROJ", |
|||
vehicleCode = "DN8", |
|||
mdbFileName = "DN8_Engine.mdb", |
|||
canDbcFileName = "DN8_CAN.dbc", |
|||
canMode = "CAN(HiSpeed)", |
|||
writeCsv = true |
|||
) |
|||
val json = DpcProjectManager.serializeProjectToJson(project) |
|||
tempFile.writeText(json, Charsets.UTF_8) |
|||
|
|||
val loaded = DpcProjectManager.loadProjectFromFile(tempFile) |
|||
assertNotNull(loaded) |
|||
assertEquals("TEST_CONFIG_PROJ.dpc", loaded!!.projectFileName) |
|||
assertEquals("DN8", loaded.vehicleCode) |
|||
assertEquals("DN8_Engine.mdb", loaded.mdbFileName) |
|||
assertEquals("DN8_CAN.dbc", loaded.canDbcFileName) |
|||
assertEquals(tempFile.absolutePath, loaded.localProjectPath) |
|||
|
|||
tempFile.delete() |
|||
tempDir.delete() |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("isProjectFileExists 및 getFilesByExtension 동작 검증") |
|||
fun testIsProjectFileExistsAndGetFilesByExtension() { |
|||
val configDir = java.io.File(DpcProjectManager.getDefaultConfigurationFolder()) |
|||
configDir.mkdirs() |
|||
val testFile = java.io.File(configDir, "EXISTS_TEST_PROJ.dpc") |
|||
testFile.writeText("{}", Charsets.UTF_8) |
|||
|
|||
assertTrue(DpcProjectManager.isProjectFileExists(null, "EXISTS_TEST_PROJ")) |
|||
assertTrue(DpcProjectManager.isProjectFileExists(null, "EXISTS_TEST_PROJ.dpc")) |
|||
assertFalse(DpcProjectManager.isProjectFileExists(null, "NON_EXISTING_PROJ_999")) |
|||
|
|||
val foundFiles = DpcProjectManager.getFilesByExtension(".dpc", "Configuration", null) |
|||
assertTrue(foundFiles.any { it.name.equals("EXISTS_TEST_PROJ.dpc", ignoreCase = true) }) |
|||
|
|||
testFile.delete() |
|||
assertFalse(DpcProjectManager.isProjectFileExists(null, "EXISTS_TEST_PROJ")) |
|||
} |
|||
} |
|||
@ -1,107 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.repository.DpcProjectManager |
|||
import com.dct.app.data.repository.DpcWorkspaceJson |
|||
import com.dct.app.core.theme.PcColorRef |
|||
import com.dct.app.domain.model.chart.* |
|||
import com.dct.app.domain.model.project.* |
|||
import com.dct.app.domain.usecase.chart.ChartBatchRenderer |
|||
import kotlinx.coroutines.test.UnconfinedTestDispatcher |
|||
import org.json.JSONObject |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class) |
|||
class DpcWorkspacePersistenceTest { |
|||
private fun sample(): DpcWorkspaceState { |
|||
val signal = DpcSignalBindingState("sig_1_2", "RPM", AxisPosition.RIGHT_1, PcColorRef.fromRgb(0xAA, 0xBB, 0xCC), |
|||
"rpm", 4f, 3, false, InterpolationMode.PWM_STEP) |
|||
return DpcWorkspaceState("page_2", listOf( |
|||
DpcPageState("page_1", "Engine", windows = listOf( |
|||
DpcWindowState("graph", "MULTI_AXIS_GRAPH", "Engine Graph", x = 730f, y = 90f, |
|||
width = 650f, height = 420f, zIndex = 3f, isMinimized = true, createdAt = 42, |
|||
signals = listOf(signal), chart = DpcChartState( |
|||
axes = listOf(ChartAxisConfig(AxisPosition.RIGHT_1, -10.0, 9000.0, false, label = "RPM")), |
|||
timeWindowSec = 17.0, timeWindowPreset = TimeWindowPreset.MANUAL, |
|||
isXAxisAuto = false, isYAxisAuto = false, legendPosition = 2 |
|||
)), |
|||
DpcWindowState("alpha", "ALPHANUMERICAL", "Values", targetSignals = listOf("sig_1_2", "can_4"), |
|||
isTileMode = false, hiddenSignalIds = setOf("RPM"), highlightColors = mapOf("RPM" to PcColorRef.fromRgb(0xFF, 0x00, 0x00))) |
|||
), activeWindowId = "graph", scrollX = 250f, scrollY = 60f, signals = listOf(signal), |
|||
alphanumericalSignals = listOf("can_4"), mdbSearchQuery = "speed", canSearchQuery = "engine"), |
|||
DpcPageState("page_2", "Intentionally empty") |
|||
)) |
|||
} |
|||
|
|||
@Test |
|||
fun workspaceRoundTripPreservesAllFieldsAndPcKeys() { |
|||
val workspace = sample() |
|||
val root = JSONObject("""{"layout_wnd":{"items":[{"opaque":"AABBCC"}]},"vendor_custom":{"keep":true}}""") |
|||
val encoded = DpcProjectManager.serializeProjectToJson(DpcProject(workspace = workspace, rawJsonRoot = root)) |
|||
val restored = DpcProjectManager.parseProjectFromJson(encoded, null) |
|||
assertEquals(workspace, restored.workspace) |
|||
assertEquals(root.getJSONObject("layout_wnd").toString(), restored.rawJsonRoot!!.getJSONObject("layout_wnd").toString()) |
|||
assertTrue(restored.rawJsonRoot!!.getJSONObject("vendor_custom").getBoolean("keep")) |
|||
assertFalse(encoded.contains("buffer")) |
|||
assertFalse(encoded.contains("isConnected")) |
|||
} |
|||
|
|||
@Test |
|||
fun legacyAndFutureExtensionsAreSafe() { |
|||
assertNull(DpcProjectManager.parseProjectFromJson("{}", null).workspace) |
|||
val future = JSONObject("""{"android_workspace":{"schema_version":99,"future":"untouched"}}""") |
|||
val parsed = DpcProjectManager.parseProjectFromJson(future.toString(), null) |
|||
assertNull(parsed.workspace) |
|||
val saved = JSONObject(DpcProjectManager.serializeProjectToJson(parsed.copy(workspace = sample()))) |
|||
assertEquals(future.getJSONObject(DpcWorkspaceJson.KEY).toString(), saved.getJSONObject(DpcWorkspaceJson.KEY).toString()) |
|||
} |
|||
|
|||
@Test |
|||
fun malformedFieldsCannotBreakRemainingWorkspace() { |
|||
val json = DpcWorkspaceJson.encode(sample()) |
|||
json.put("active_page_id", "missing") |
|||
val page = json.getJSONArray("pages").getJSONObject(0) |
|||
val window = page.getJSONArray("windows").getJSONObject(0) |
|||
window.put("width", -1).put("x", "NaN") |
|||
val signal = window.getJSONArray("signals").getJSONObject(0) |
|||
signal.put("axis", "NEW_AXIS").put("line_width", "Infinity") |
|||
val axis = window.getJSONObject("chart").getJSONArray("axes").getJSONObject(0) |
|||
axis.put("min", 100).put("max", -100) |
|||
val decoded = DpcWorkspaceJson.decode(json)!! |
|||
assertEquals("page_1", decoded.activePageId) |
|||
val restored = decoded.pages.first().windows.first() |
|||
assertEquals(120f, restored.width) |
|||
assertEquals(20f, restored.x) |
|||
assertEquals(AxisPosition.LEFT_0, restored.signals.first().axisPosition) |
|||
assertEquals(2f, restored.signals.first().lineWidthDp) |
|||
assertEquals(100.0, restored.chart!!.axes.first().maxVal) |
|||
assertEquals(2, decoded.pages.size) |
|||
} |
|||
|
|||
@Test |
|||
fun rendererRestoresStylesAndAxesWithoutTelemetryOrSharedBuffers() { |
|||
val renderer = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())) |
|||
val saved = sample().pages.first().windows.first() |
|||
val series = saved.signals.first().toSeries() |
|||
assertEquals(1, series.buffer.capacity) |
|||
series.buffer.addSample(1.0, 123.0) |
|||
renderer.restoreWorkspaceState(listOf(series), saved.chart) |
|||
assertNull(renderer.seriesListFlow.value.first().buffer.getLatestTimestamp()) |
|||
assertNotSame(series.buffer, renderer.seriesListFlow.value.first().buffer) |
|||
assertEquals(saved.signals, renderer.seriesListFlow.value.map(DpcSignalBindingState::fromSeries)) |
|||
assertEquals(saved.chart!!.axes.first(), renderer.exportWorkspaceState().axes.find { it.position == AxisPosition.RIGHT_1 }) |
|||
assertEquals(17.0, renderer.exportWorkspaceState().timeWindowSec) |
|||
renderer.setSeriesDashStyle(series.signalId, 4) |
|||
renderer.setLegendPosition(1) |
|||
assertEquals(4, renderer.seriesListFlow.value.first().dashStyle) |
|||
assertEquals(1, renderer.exportWorkspaceState().legendPosition) |
|||
} |
|||
|
|||
@Test |
|||
fun rendererKeepsInsertionOrderAcrossRestores() { |
|||
val renderer = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())) |
|||
val series = listOf("z", "a", "m").map { ChartSignalSeries(it, it, AxisPosition.LEFT_0, PcColorRef.fromRgb(0x11, 0x22, 0x33)) } |
|||
renderer.restoreWorkspaceState(series, null) |
|||
assertEquals(listOf("z", "a", "m"), renderer.buildSnapshot(100).seriesList.map { it.signalId }) |
|||
} |
|||
} |
|||
@ -1,51 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.maintenance.FirmwareFileParser |
|||
import com.dct.app.domain.model.maintenance.FirmwareFormat |
|||
import org.junit.jupiter.api.Assertions.assertArrayEquals |
|||
import org.junit.jupiter.api.Assertions.assertEquals |
|||
import org.junit.jupiter.api.Assertions.assertThrows |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class FirmwareFileParserTest { |
|||
@Test |
|||
fun `intel hex validates checksum and fills address gaps with FF`() { |
|||
val source = listOf( |
|||
":020000040001F9", |
|||
":020010001122BB", |
|||
":0100130033B9", |
|||
":00000001FF" |
|||
).joinToString("\n").toByteArray() |
|||
|
|||
val image = FirmwareFileParser.parse("ecu.hex", source) |
|||
|
|||
assertEquals(FirmwareFormat.INTEL_HEX, image.format) |
|||
assertEquals(0x10010L, image.startAddress) |
|||
assertEquals(2 * 1024 * 1024, image.bytes.size) |
|||
assertArrayEquals(byteArrayOf(0x11, 0x22, 0xFF.toByte(), 0x33), image.bytes.copyOfRange(0, 4)) |
|||
assertEquals(0xFF.toByte(), image.bytes.last()) |
|||
} |
|||
|
|||
@Test |
|||
fun `s19 validates checksum and fills address gaps with zero`() { |
|||
val source = listOf( |
|||
"S10510001122B7", |
|||
"S104100333B5", |
|||
"S9031000EC" |
|||
).joinToString("\n").toByteArray() |
|||
|
|||
val image = FirmwareFileParser.parse("ecu.s19", source) |
|||
|
|||
assertEquals(FirmwareFormat.MOTOROLA_S19, image.format) |
|||
assertEquals(0x1000L, image.startAddress) |
|||
assertArrayEquals(byteArrayOf(0x11, 0x22, 0x00, 0x33), image.bytes) |
|||
} |
|||
|
|||
@Test |
|||
fun `corrupt checksum is rejected`() { |
|||
val badHex = ":0100000001FF\n:00000001FF".toByteArray() |
|||
assertThrows(IllegalArgumentException::class.java) { |
|||
FirmwareFileParser.parse("bad.hex", badHex) |
|||
} |
|||
} |
|||
} |
|||
@ -1,96 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.formula.FormulaEvaluator |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.BeforeEach |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import kotlin.math.PI |
|||
|
|||
class FormulaEvaluatorTest { |
|||
|
|||
@BeforeEach |
|||
fun setUp() { |
|||
FormulaEvaluator.clearCache() |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("기본 사칙연산 및 연산자 우선순위 검증") |
|||
fun testBasicArithmetic() { |
|||
val vars = emptyMap<String, Double>() |
|||
assertEquals(7.0, FormulaEvaluator.evaluate("1 + 2 * 3", vars), 0.0001) |
|||
assertEquals(9.0, FormulaEvaluator.evaluate("(1 + 2) * 3", vars), 0.0001) |
|||
assertEquals(3.5, FormulaEvaluator.evaluate("10 / 2 - 1.5", vars), 0.0001) |
|||
assertEquals(1.0, FormulaEvaluator.evaluate("10 % 3", vars), 0.0001) |
|||
assertEquals(8.0, FormulaEvaluator.evaluate("2 ^ 3", vars), 0.0001) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("단항 연산자(Unary Minus/Plus) 검증") |
|||
fun testUnaryOperators() { |
|||
val vars = emptyMap<String, Double>() |
|||
assertEquals(-5.0, FormulaEvaluator.evaluate("-5", vars), 0.0001) |
|||
assertEquals(5.0, FormulaEvaluator.evaluate("-5 + 10", vars), 0.0001) |
|||
assertEquals(-5.0, FormulaEvaluator.evaluate("-(3 + 2)", vars), 0.0001) |
|||
assertEquals(2.0, FormulaEvaluator.evaluate("-3 + 5", vars), 0.0001) |
|||
assertEquals(-6.0, FormulaEvaluator.evaluate("2 * -3", vars), 0.0001) |
|||
assertEquals(0.125, FormulaEvaluator.evaluate("2 ^ -3", vars), 0.0001) |
|||
assertEquals(-4.0, FormulaEvaluator.evaluate("-2 ^ 2", vars), 0.0001) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("수학 함수 및 상수(sin, cos, sqrt, abs, min, max, pow, pi) 검증") |
|||
fun testMathFunctionsAndConstants() { |
|||
val vars = emptyMap<String, Double>() |
|||
assertEquals(4.0, FormulaEvaluator.evaluate("sqrt(16)", vars), 0.0001) |
|||
assertEquals(42.0, FormulaEvaluator.evaluate("abs(-42)", vars), 0.0001) |
|||
assertEquals(0.0, FormulaEvaluator.evaluate("sin(0)", vars), 0.0001) |
|||
assertEquals(1.0, FormulaEvaluator.evaluate("cos(0)", vars), 0.0001) |
|||
assertEquals(10.0, FormulaEvaluator.evaluate("min(10, 20)", vars), 0.0001) |
|||
assertEquals(20.0, FormulaEvaluator.evaluate("max(10, 20)", vars), 0.0001) |
|||
assertEquals(16.0, FormulaEvaluator.evaluate("pow(2, 4)", vars), 0.0001) |
|||
assertEquals(PI, FormulaEvaluator.evaluate("pi", vars), 0.0001) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("신호 변수 바인딩(큰따옴표 및 식별자) 및 복합 수식 연산 검증") |
|||
fun testVariableSubstitution() { |
|||
val telemetry = mapOf( |
|||
"EngineSpeed" to 3000.0, |
|||
"Torque" to 200.0, |
|||
"T_Inlet" to 85.5, |
|||
"T_Outlet" to 72.3 |
|||
) |
|||
|
|||
// PC 레거시 큰따옴표 형식 |
|||
val powerKw = FormulaEvaluator.evaluate("\"Torque\" * \"EngineSpeed\" / 9549", telemetry) |
|||
assertEquals(3000.0 * 200.0 / 9549.0, powerKw, 0.001) |
|||
|
|||
// 온도차 수식 |
|||
val tempDiff = FormulaEvaluator.evaluate("\"T_Inlet\" - \"T_Outlet\"", telemetry) |
|||
assertEquals(13.2, tempDiff, 0.001) |
|||
|
|||
// 따옴표 없는 식별자 형식 |
|||
val halfSpeed = FormulaEvaluator.evaluate("EngineSpeed * 0.5", telemetry) |
|||
assertEquals(1500.0, halfSpeed, 0.001) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("0 나누기 및 잘못된 문법에 대한 안전성(NaN / Validation) 검증") |
|||
fun testErrorHandling() { |
|||
val vars = emptyMap<String, Double>() |
|||
assertTrue(FormulaEvaluator.evaluate("10 / 0", vars).isNaN()) |
|||
assertTrue(FormulaEvaluator.evaluate("sqrt(-1)", vars).isNaN()) |
|||
assertTrue(FormulaEvaluator.evaluate("", vars).isNaN()) |
|||
assertTrue(FormulaEvaluator.evaluate("+++", vars).isNaN()) |
|||
|
|||
assertTrue(FormulaEvaluator.validate("1 + 2 * 3")) |
|||
assertTrue(FormulaEvaluator.validate("\"Torque\" * 2")) |
|||
assertFalse(FormulaEvaluator.validate("")) |
|||
assertFalse(FormulaEvaluator.validate("1 + * 2")) |
|||
assertFalse(FormulaEvaluator.validate("1 + 2)")) |
|||
assertFalse(FormulaEvaluator.validate("(1 + 2")) |
|||
assertFalse(FormulaEvaluator.validate("1 # + 2")) |
|||
assertFalse(FormulaEvaluator.validate("\"Torque * 2")) |
|||
} |
|||
} |
|||
@ -1,87 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.formula.FormulaEvaluator |
|||
import com.dct.app.data.logger.CsvMeasurementLogger |
|||
import com.dct.app.data.logger.Mf4MeasurementLogger |
|||
import com.dct.app.data.repository.DpcProjectManager |
|||
import com.dct.app.domain.model.formula.FormulaDefinition |
|||
import com.dct.app.domain.model.project.DpcProject |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
|
|||
class FormulaIntegrationTest { |
|||
|
|||
@Test |
|||
@DisplayName("DpcProject JSON 직렬화 및 역직렬화 시 Formula 목록이 100% 보존되어야 한다") |
|||
fun testFormulaProjectSerialization() { |
|||
val f1 = FormulaDefinition( |
|||
name = "Power_kW", |
|||
expression = "\"Torque\" * \"EngineSpeed\" / 9549", |
|||
unit = "kW", |
|||
color = 0xFF2196F3L, |
|||
isForSm = false, |
|||
description = "엔진 출력 수식" |
|||
) |
|||
val f2 = FormulaDefinition( |
|||
name = "Diff_Temp", |
|||
expression = "\"T_Inlet\" - \"T_Outlet\"", |
|||
unit = "'C", |
|||
color = 0xFFFF9800L, |
|||
isForSm = true, |
|||
description = "입출구 온도차" |
|||
) |
|||
|
|||
val project = DpcProject( |
|||
projectFileName = "FORMULA_TEST.dpc", |
|||
formulas = listOf(f1, f2) |
|||
) |
|||
|
|||
val json = DpcProjectManager.serializeProjectToJson(project) |
|||
assertTrue(json.contains("Power_kW")) |
|||
assertTrue(json.contains("Diff_Temp")) |
|||
|
|||
val parsed = DpcProjectManager.parseProjectFromJson(json, null) |
|||
assertEquals(2, parsed.formulas.size) |
|||
assertEquals("Power_kW", parsed.formulas[0].name) |
|||
assertEquals("\"Torque\" * \"EngineSpeed\" / 9549", parsed.formulas[0].expression) |
|||
assertEquals("kW", parsed.formulas[0].unit) |
|||
assertEquals("Diff_Temp", parsed.formulas[1].name) |
|||
assertTrue(parsed.formulas[1].isForSm) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("Formula 수식 결과가 실시간 CSV 및 MF4 로거 파일에 _formula 접미사로 기록되어야 한다", ) |
|||
fun testFormulaLogging(@TempDir tempDir: File) { |
|||
val formulaHeaders = listOf("Power_kW" to "kW", "Diff_Temp" to "'C") |
|||
val csvName = "TEST_PROJ_2026-08-27_13-30-00_formula.csv" |
|||
val mf4Name = "TEST_PROJ_2026-08-27_13-30-00_formula.mf4" |
|||
|
|||
val telemetry = mapOf("Torque" to 250.0, "EngineSpeed" to 3600.0, "T_Inlet" to 90.0, "T_Outlet" to 75.0) |
|||
val pCalc = FormulaEvaluator.evaluate("\"Torque\" * \"EngineSpeed\" / 9549", telemetry) |
|||
val tCalc = FormulaEvaluator.evaluate("\"T_Inlet\" - \"T_Outlet\"", telemetry) |
|||
|
|||
val csvLogger = CsvMeasurementLogger(tempDir, formulaHeaders, csvName) |
|||
val csvFile = csvLogger.start() |
|||
assertNotNull(csvFile) |
|||
assertEquals(csvName, csvFile!!.name) |
|||
|
|||
csvLogger.logSample(0.1, listOf(pCalc, tCalc)) |
|||
csvLogger.stop() |
|||
|
|||
val csvContent = csvFile.readText() |
|||
assertTrue(csvContent.contains("Power_kW")) |
|||
assertTrue(csvContent.contains("Diff_Temp")) |
|||
|
|||
val mf4Logger = Mf4MeasurementLogger(tempDir, formulaHeaders, mf4Name) |
|||
val mf4File = mf4Logger.start() |
|||
assertNotNull(mf4File) |
|||
assertEquals(mf4Name, mf4File!!.name) |
|||
|
|||
mf4Logger.logSample(0.1, listOf(pCalc, tCalc)) |
|||
mf4Logger.stop() |
|||
assertTrue(mf4File.length() > 0) |
|||
} |
|||
} |
|||
@ -1,173 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.formula.FormulaEvaluator |
|||
import com.dct.app.core.formula.FormulaTelemetryEngine |
|||
import com.dct.app.domain.model.formula.FormulaDefinition |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class FormulaTelemetryEngineTest { |
|||
private fun formula(name: String, expression: String) = FormulaDefinition(name = name, expression = expression) |
|||
|
|||
@Test fun reverseRegistrationOrderAndAliasesUseCurrentInputs() { |
|||
val engine = FormulaTelemetryEngine() |
|||
val formulas = listOf(formula("B", "formula_A+1"), formula("A", "TORQUE*2")) |
|||
val values = mutableMapOf("Torque" to 2.0) |
|||
engine.update(formulas, values, mutableSetOf("Torque")) |
|||
assertEquals(5.0, values["B"]) |
|||
values["Torque"] = 3.0 |
|||
engine.update(formulas, values, mutableSetOf("Torque")) |
|||
assertEquals(7.0, values["B"]) |
|||
} |
|||
|
|||
@Test fun unrelatedPacketsDoNotMarkFormulaOutputsUpdated() { |
|||
val engine = FormulaTelemetryEngine() |
|||
val formulas = listOf(formula("F", "X*2"), formula("G", "F+1")) |
|||
val values = mutableMapOf("X" to 2.0) |
|||
engine.update(formulas, values, mutableSetOf("X")) |
|||
val updated = mutableSetOf("Y") |
|||
values["Y"] = 10.0 |
|||
engine.update(formulas, values, updated) |
|||
assertEquals(setOf("Y"), updated) |
|||
assertEquals(5.0, values["G"]) |
|||
values["X"] = 2.0 // Receiving the same value still represents a new real sample. |
|||
val repeated = mutableSetOf("X") |
|||
engine.update(formulas, values, repeated) |
|||
assertTrue("G" in repeated) |
|||
} |
|||
|
|||
@Test fun constantsReuseValuesButStillProvideGraphAndRecordingSamples() { |
|||
val engine = FormulaTelemetryEngine() |
|||
val formulas = listOf(formula("Dependent", "Constant+1"), formula("Constant", "42")) |
|||
val values = mutableMapOf<String, Double>() |
|||
engine.update(formulas, values, mutableSetOf()) |
|||
values["X"] = 2.0 |
|||
val updated = mutableSetOf("X") |
|||
engine.update(formulas, values, updated) |
|||
assertEquals(42.0, values["Constant"]) |
|||
assertTrue("Constant" in updated) |
|||
assertTrue("formula_Constant" in updated) |
|||
assertEquals(43.0, values["Dependent"]) |
|||
assertTrue("Dependent" in updated) |
|||
} |
|||
|
|||
@Test fun exactFormulaNamesTakePrecedenceAndDuplicateOutputsAreInvalid() { |
|||
val engine = FormulaTelemetryEngine() |
|||
val formulas = listOf(formula("B", "A+1"), formula("A", "X*2"), formula("a", "X*3")) |
|||
val values = mutableMapOf("X" to 2.0) |
|||
engine.update(formulas, values, mutableSetOf("X")) |
|||
assertEquals(5.0, values["B"]) |
|||
engine.update(listOf(formula("A", "2"), formula("A", "3"), formula("B", "A+1")), values, mutableSetOf()) |
|||
assertTrue(values.getValue("A").isNaN()) |
|||
assertTrue(values.getValue("B").isNaN()) |
|||
} |
|||
|
|||
@Test fun invalidInputsReplaceOldResultsAndPropagateThenRecover() { |
|||
val engine = FormulaTelemetryEngine() |
|||
val formulas = listOf(formula("A", "10/X"), formula("B", "A+1")) |
|||
val values = mutableMapOf("X" to 2.0) |
|||
engine.update(formulas, values, mutableSetOf("X")) |
|||
assertEquals(6.0, values["B"]) |
|||
for (invalid in listOf(0.0, Double.NaN, Double.POSITIVE_INFINITY)) { |
|||
values["X"] = invalid |
|||
val updated = mutableSetOf("X") |
|||
engine.update(formulas, values, updated) |
|||
assertTrue(values.getValue("A").isNaN()) |
|||
assertTrue(values.getValue("B").isNaN()) |
|||
assertTrue("formula_B" in updated) |
|||
} |
|||
values["X"] = 5.0 |
|||
engine.update(formulas, values, mutableSetOf("X")) |
|||
assertEquals(3.0, values["B"]) |
|||
} |
|||
|
|||
@Test fun missingInputIsNotZeroAndNewCaseInsensitiveKeysRecover() { |
|||
val engine = FormulaTelemetryEngine() |
|||
val formulas = listOf(formula("F", "MISSING+1")) |
|||
val values = mutableMapOf("Other" to 2.0) |
|||
engine.update(formulas, values, mutableSetOf("Other")) |
|||
assertTrue(values.getValue("F").isNaN()) |
|||
values["Missing"] = 9.0 |
|||
engine.update(formulas, values, mutableSetOf("Missing")) |
|||
assertEquals(10.0, values["F"]) |
|||
} |
|||
|
|||
@Test fun cyclesAndDescendantsAreInvalidButIndependentFormulasWork() { |
|||
val engine = FormulaTelemetryEngine() |
|||
val formulas = listOf(formula("A", "B+1"), formula("B", "A+1"), formula("C", "B+1"), formula("Self", "Self+1"), formula("Good", "X*2")) |
|||
val values = mutableMapOf("X" to 3.0) |
|||
engine.update(formulas, values, mutableSetOf("X")) |
|||
listOf("A", "B", "C", "Self").forEach { assertTrue(values.getValue(it).isNaN()) } |
|||
assertEquals(6.0, values["Good"]) |
|||
} |
|||
|
|||
@Test fun expressionEditRenameDeletionAndResetInvalidateCachedResults() { |
|||
val engine = FormulaTelemetryEngine() |
|||
val a = formula("A", "X*2") |
|||
val b = formula("B", "A+1") |
|||
val values = mutableMapOf("X" to 2.0) |
|||
engine.update(listOf(a, b), values, mutableSetOf("X")) |
|||
engine.update(listOf(a.copy(expression = "X*3"), b), values, mutableSetOf()) |
|||
assertEquals(7.0, values["B"]) |
|||
engine.update(listOf(a.copy(name = "New"), b), values, mutableSetOf()) |
|||
assertFalse("A" in values) |
|||
assertFalse("formula_A" in values) |
|||
assertTrue(values.getValue("B").isNaN()) |
|||
engine.update(listOf(b), values, mutableSetOf()) |
|||
assertFalse("New" in values) |
|||
engine.reset() |
|||
values.clear() |
|||
engine.update(listOf(a), values, mutableSetOf()) |
|||
assertTrue(values.getValue("A").isNaN()) |
|||
} |
|||
|
|||
@Test fun cachedIndexNeverEnumeratesAllSignalsOnSubsequentPackets() { |
|||
val backing = (0 until 10_000).associate { "Signal$it" to it.toDouble() }.toMutableMap() |
|||
backing["Torque"] = 20.0 |
|||
var enumerations = 0 |
|||
val values = object : MutableMap<String, Double> by backing { |
|||
override val keys: MutableSet<String> |
|||
get() { enumerations++; return backing.keys } |
|||
override val entries: MutableSet<MutableMap.MutableEntry<String, Double>> |
|||
get() = error("Per-variable full scan is forbidden") |
|||
} |
|||
val engine = FormulaTelemetryEngine() |
|||
val formulas = listOf(formula("A", "TORQUE*2"), formula("B", "NotReceived+1")) |
|||
engine.update(formulas, values, mutableSetOf("Torque")) |
|||
assertEquals(1, enumerations) |
|||
repeat(100) { |
|||
backing["Torque"] = it.toDouble() |
|||
engine.update(formulas, values, mutableSetOf("Torque")) |
|||
} |
|||
assertEquals(1, enumerations) |
|||
assertEquals(198.0, values["A"]) |
|||
} |
|||
|
|||
@Test fun linValidationIsIndependentOfTelemetryAndAllModuleNumbers() { |
|||
for (module in 1..16) { |
|||
val channel = "%02d-05".format(module) |
|||
val expression = "LIN(\"$channel\";0;0;5;100)" |
|||
assertTrue(FormulaEvaluator.validate(expression)) |
|||
assertEquals(50.0, FormulaEvaluator.evaluate(expression, mapOf("sm_${channel.replace('-', '_')}" to 2.5))) |
|||
} |
|||
assertFalse(FormulaEvaluator.validate("LIN(\"02-05\";0;0;0;100)")) |
|||
assertFalse(FormulaEvaluator.validate("LIN(\"02-05\";0;NaN;5;100)")) |
|||
} |
|||
|
|||
@Test fun linAliasesParticipateInSelectiveUpdatesAndDependencies() { |
|||
val engine = FormulaTelemetryEngine() |
|||
val formulas = listOf(formula("B", "A+1"), formula("A", "LIN(\"02-05\";0;0;5;100)")) |
|||
val values = mutableMapOf("sm_02_05" to 2.5) |
|||
engine.update(formulas, values, mutableSetOf("sm_02_05")) |
|||
assertEquals(51.0, values["B"]) |
|||
values["sm_02_05"] = 5.0 |
|||
engine.update(formulas, values, mutableSetOf("sm_02_05")) |
|||
assertEquals(101.0, values["B"]) |
|||
} |
|||
|
|||
@Test fun missingAndNonFiniteMathNeverProducePlausibleValues() { |
|||
assertTrue(FormulaEvaluator.evaluate("Unknown+1", emptyMap()).isNaN()) |
|||
assertTrue(FormulaEvaluator.evaluate("exp(10000)", emptyMap()).isNaN()) |
|||
assertTrue(FormulaEvaluator.evaluate("sqrt(-1)^0", emptyMap()).isNaN()) |
|||
} |
|||
} |
|||
@ -1,371 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.model.formula.FormulaDefinition |
|||
import com.dct.app.domain.model.mdb.MdbDatabase |
|||
import com.dct.app.domain.repository.MdbRepository |
|||
import com.dct.app.domain.model.protocol.DctMeasurementConfiguration |
|||
import com.dct.app.domain.model.project.DpcProject |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.domain.repository.DeviceConnectionState |
|||
import com.dct.app.domain.repository.PacketRepository |
|||
import com.dct.app.presentation.main.MainViewModel |
|||
import com.dct.app.presentation.main.MainUiState |
|||
import kotlinx.coroutines.flow.MutableSharedFlow |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import org.junit.jupiter.api.AfterEach |
|||
import org.junit.jupiter.api.BeforeEach |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
import java.nio.ByteBuffer |
|||
import java.nio.ByteOrder |
|||
import io.mockk.coEvery |
|||
import io.mockk.every |
|||
import io.mockk.coVerify |
|||
import io.mockk.coVerifyOrder |
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.core.error.DctError |
|||
|
|||
@Suppress("UNCHECKED_CAST") |
|||
class FormulaTelemetryRegressionTest { |
|||
@TempDir lateinit var directory: File |
|||
private lateinit var fixture: MainViewModelTest |
|||
private lateinit var vm: MainViewModel |
|||
private lateinit var packets: MutableSharedFlow<DctPacket> |
|||
private lateinit var repository: PacketRepository |
|||
private var telemetrySequence = 0L |
|||
private fun field(target: Any, name: String) = target.javaClass.getDeclaredField(name).also { it.isAccessible = true } |
|||
|
|||
@BeforeEach fun setUp() { |
|||
fixture = MainViewModelTest().also { it.setUp() } |
|||
vm = field(fixture, "viewModel").get(fixture) as MainViewModel |
|||
repository = field(fixture, "packetRepository").get(fixture) as PacketRepository |
|||
packets = repository.packetStream as MutableSharedFlow<DctPacket> |
|||
vm.setCurrentProject(DpcProject(measuredFilesFolder = directory.path, writeCsv = true, writeMf4 = false)) |
|||
(field(fixture, "connectionState").get(fixture) as MutableStateFlow<DeviceConnectionState>).value = DeviceConnectionState.READY |
|||
} |
|||
|
|||
@AfterEach fun tearDown() = fixture.tearDown() |
|||
|
|||
private fun telemetry(value: Float, receivedAtMillis: Long = 0L) { |
|||
// Real transport assigns an ingress sequence, preserving distinct same-millisecond packets. |
|||
assertTrue(packets.tryEmit(DctPacket(0x02, ByteArray(18).also { |
|||
val buffer = ByteBuffer.wrap(it).order(ByteOrder.LITTLE_ENDIAN) |
|||
buffer.position(2) |
|||
buffer.putFloat(value).putFloat(2f).putFloat(3f).putFloat(4f) |
|||
}, ingressSequence = ++telemetrySequence, receivedAtMillis = receivedAtMillis))) |
|||
} |
|||
|
|||
private fun openMdbWithoutRawConsumers() { |
|||
// MainViewModelTest's UI fixture leaves both byte offsets at zero. Use a |
|||
// valid record layout when exercising the real binary decoder (UINT16 + INT8). |
|||
val sample = field(fixture, "sampleDb").get(fixture) as MdbDatabase |
|||
val source = sample.copy(groups = sample.groups.map { group -> |
|||
group.copy(signals = group.signals.mapIndexed { index, signal -> signal.copy(arrayIndex = if (index == 0) 0 else 2) }) |
|||
}) |
|||
val mdb = field(fixture, "mdbRepository").get(fixture) as MdbRepository |
|||
every { mdb.getCurrentDatabase() } returns source |
|||
vm.openMdbFromFile(File("Sample.mdb")) |
|||
// Legacy dashboard defaults must not register inputs on behalf of Formula. |
|||
val ui = field(vm, "_uiState").get(vm) as MutableStateFlow<MainUiState> |
|||
ui.value = ui.value.copy(dashboardTiles = emptyList()) |
|||
} |
|||
|
|||
@Test fun reverseOrderAndErrorsUseSamePacketValues() { |
|||
vm.startMeasure() |
|||
vm.addFormula(FormulaDefinition(name = "B", expression = "A+1")) |
|||
vm.addFormula(FormulaDefinition(name = "A", expression = "10/Incar_Snr")) |
|||
telemetry(2f) |
|||
assertEquals(6.0, vm.liveTelemetryValues.value["B"]) |
|||
telemetry(0f) |
|||
assertTrue(vm.liveTelemetryValues.value.getValue("A").isNaN()) |
|||
assertTrue(vm.liveTelemetryValues.value.getValue("B").isNaN()) |
|||
telemetry(5f) |
|||
assertEquals(3.0, vm.liveTelemetryValues.value["B"]) |
|||
} |
|||
|
|||
@Test fun measurementRestartClearsAllPagesAndLiveCachesThenUsesOnlyNewSamples() { |
|||
vm.startMeasure() |
|||
vm.addFormula(FormulaDefinition(name = "F", expression = "Incar_Snr*2", unit = "V")) |
|||
val binding = com.dct.app.domain.model.project.DpcSignalBindingState( |
|||
"formula_F", "F", AxisPosition.LEFT_0, 0x123456L, "V") |
|||
vm.restoreProjectWorkspace(com.dct.app.domain.model.project.DpcWorkspaceState("page_1", listOf( |
|||
com.dct.app.domain.model.project.DpcPageState("page_1", "One", listOf( |
|||
com.dct.app.domain.model.project.DpcWindowState("graph_one", "GRAPH", "Graph", signals = listOf(binding)))), |
|||
com.dct.app.domain.model.project.DpcPageState("page_2", "Two", listOf( |
|||
com.dct.app.domain.model.project.DpcWindowState("multi_two", "MULTI_AXIS_GRAPH", "Multi", signals = listOf(binding))))))) |
|||
vm.chartRenderer.bindSignal("formula_F", "F", AxisPosition.LEFT_0, 0x123456L) |
|||
val renderers = listOf(vm.chartRenderer, vm.getChartRenderer("graph_one"), vm.getChartRenderer("multi_two")) |
|||
val ui = field(vm, "_uiState").get(vm) as MutableStateFlow<MainUiState> |
|||
ui.value = ui.value.copy(dashboardTiles = listOf( |
|||
com.dct.app.domain.model.dashboard.TileWidgetItem("Incar_Snr", "Incar_Snr"))) |
|||
telemetry(2f) |
|||
vm.stopMeasure() |
|||
val raw = field(vm, "latestMf4RawValues").get(vm) as MutableMap<String, Number> |
|||
raw.putAll(mapOf("sig_1_1" to 42, "can_1" to 55, "a2l_1" to 66)) |
|||
val beforeCount = vm.uiState.value.packetCount |
|||
val project = vm.currentProject.value |
|||
val formulas = vm.formulas.value |
|||
val pages = vm.pages.value.map { it.id to it.title } |
|||
val bindings = renderers.map { it.exportWorkspaceState() } |
|||
renderers.forEach { assertTrue(it.seriesListFlow.value.single().buffer.size > 0) } |
|||
assertEquals(4.0, vm.liveTelemetryValues.value["F"]) |
|||
|
|||
vm.startMeasure() |
|||
|
|||
assertTrue(vm.liveTelemetryValues.value.isEmpty()) |
|||
assertTrue(raw.isEmpty()) |
|||
assertEquals(beforeCount, vm.uiState.value.packetCount) |
|||
assertTrue(vm.uiState.value.dashboardTiles.all { it.value == 0.0 && it.historyBuffer.size == 0 }) |
|||
assertEquals(project, vm.currentProject.value) |
|||
assertEquals(formulas, vm.formulas.value) |
|||
assertEquals(pages, vm.pages.value.map { it.id to it.title }) |
|||
renderers.forEachIndexed { index, renderer -> |
|||
assertEquals(bindings[index], renderer.exportWorkspaceState()) |
|||
assertEquals(0, renderer.seriesListFlow.value.single().buffer.size) |
|||
} |
|||
telemetry(7f) |
|||
assertEquals(14.0, vm.liveTelemetryValues.value["F"]) |
|||
renderers.forEach { |
|||
assertEquals(1, it.seriesListFlow.value.single().buffer.size) |
|||
assertEquals(14.0, it.seriesListFlow.value.single().buffer.getLatestValue()) |
|||
} |
|||
assertEquals(7.0, vm.uiState.value.dashboardTiles.single().value) |
|||
} |
|||
|
|||
@Test fun pendingAndFailedStartRetainOldValuesUntilStartSucceeds() { |
|||
vm.startMeasure() |
|||
vm.chartRenderer.bindSignal("s", "Incar_Snr", AxisPosition.LEFT_0, 0x123456L) |
|||
telemetry(2f) |
|||
vm.stopMeasure() |
|||
val before = vm.chartRenderer.seriesListFlow.value.single().buffer.size |
|||
val response = kotlinx.coroutines.CompletableDeferred<DctResult<Unit>>() |
|||
coEvery { repository.startStreaming(any()) } coAnswers { response.await() } |
|||
vm.startMeasure() |
|||
assertEquals(2.0, vm.liveTelemetryValues.value["Incar_Snr"]) |
|||
assertEquals(before, vm.chartRenderer.seriesListFlow.value.single().buffer.size) |
|||
response.complete(DctResult.Failure(DctError.ProtocolError.ConnectionFailed("START failed"))) |
|||
assertEquals(2.0, vm.liveTelemetryValues.value["Incar_Snr"]) |
|||
assertEquals(before, vm.chartRenderer.seriesListFlow.value.single().buffer.size) |
|||
coEvery { repository.startStreaming(any()) } returns DctResult.Success(Unit) |
|||
vm.startMeasure() |
|||
assertTrue(vm.liveTelemetryValues.value.isEmpty()) |
|||
assertEquals(0, vm.chartRenderer.seriesListFlow.value.single().buffer.size) |
|||
} |
|||
|
|||
@Test fun automaticRecoveryRetainsValuesGraphsAndRawSnapshot() { |
|||
vm.startMeasure() |
|||
vm.chartRenderer.bindSignal("s", "Incar_Snr", AxisPosition.LEFT_0, 0x123456L) |
|||
// Separate the sample from the recovery gap, which may replace a same-millisecond point. |
|||
telemetry(2f, receivedAtMillis = System.currentTimeMillis() - 100L) |
|||
val before = vm.chartRenderer.seriesListFlow.value.single().buffer.size |
|||
val raw = field(vm, "latestMf4RawValues").get(vm) as MutableMap<String, Number> |
|||
raw["can_1"] = 55 |
|||
val recovery = repository.streamRecovery as MutableStateFlow<com.dct.app.domain.repository.StreamRecoveryState> |
|||
recovery.value = com.dct.app.domain.repository.StreamRecoveryState.RECOVERING |
|||
recovery.value = com.dct.app.domain.repository.StreamRecoveryState.RECEIVING |
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
assertEquals(2.0, vm.liveTelemetryValues.value["Incar_Snr"]) |
|||
val buffer = vm.chartRenderer.seriesListFlow.value.single().buffer |
|||
assertEquals(before + 1, buffer.size) |
|||
assertEquals(2.0, buffer.getValueAt(0)) |
|||
assertTrue(buffer.getLatestValue()!!.isNaN()) |
|||
assertEquals(55, raw["can_1"]) |
|||
} |
|||
|
|||
@Test fun debugResetClearsAllPagesAndValuesWithoutStoppingRecordingOrRemovingConfiguration() { |
|||
vm.startMeasure() |
|||
vm.addFormula(FormulaDefinition(name = "F", expression = "Incar_Snr*2", unit = "V")) |
|||
val binding = com.dct.app.domain.model.project.DpcSignalBindingState( |
|||
"formula_F", "F", AxisPosition.LEFT_0, 0x123456L, "V") |
|||
vm.restoreProjectWorkspace(com.dct.app.domain.model.project.DpcWorkspaceState("page_1", listOf( |
|||
com.dct.app.domain.model.project.DpcPageState("page_1", "One", listOf( |
|||
com.dct.app.domain.model.project.DpcWindowState("graph_one", "GRAPH", "Graph", signals = listOf(binding)))), |
|||
com.dct.app.domain.model.project.DpcPageState("page_2", "Two", listOf( |
|||
com.dct.app.domain.model.project.DpcWindowState("multi_two", "MULTI_AXIS_GRAPH", "Multi", signals = listOf(binding))))))) |
|||
vm.chartRenderer.bindSignal("formula_F", "F", AxisPosition.LEFT_0, 0x123456L) |
|||
val renderers = listOf(vm.chartRenderer, vm.getChartRenderer("graph_one"), vm.getChartRenderer("multi_two")) |
|||
val ui = field(vm, "_uiState").get(vm) as MutableStateFlow<MainUiState> |
|||
ui.value = ui.value.copy(dashboardTiles = listOf( |
|||
com.dct.app.domain.model.dashboard.TileWidgetItem("Incar_Snr", "Incar_Snr"))) |
|||
vm.startMeasurementRecording() |
|||
telemetry(2f) |
|||
renderers.forEach { assertTrue(it.seriesListFlow.value.single().buffer.size > 0) } |
|||
assertTrue(vm.uiState.value.dashboardTiles.any { it.historyBuffer.size > 0 }) |
|||
val uiBefore = vm.uiState.value |
|||
val project = vm.currentProject.value |
|||
val formulas = vm.formulas.value |
|||
val pages = vm.pages.value.map { it.id to it.title } |
|||
val bindings = renderers.map { it.exportWorkspaceState() } |
|||
val raw = field(vm, "latestMf4RawValues").get(vm) as MutableMap<String, Number> |
|||
raw.putAll(mapOf("sig_1_1" to 42, "can_1" to 55, "a2l_1" to 66)) |
|||
|
|||
vm.resetDebugValues() |
|||
|
|||
assertTrue(vm.liveTelemetryValues.value.isEmpty()) |
|||
assertTrue(raw.isEmpty()) |
|||
assertEquals(0L, vm.uiState.value.packetCount) |
|||
assertTrue(vm.uiState.value.dashboardTiles.all { it.value == 0.0 && it.historyBuffer.size == 0 }) |
|||
assertEquals(uiBefore.dashboardTiles.map { it.signalId }, vm.uiState.value.dashboardTiles.map { it.signalId }) |
|||
assertEquals(project, vm.currentProject.value) |
|||
assertEquals(formulas, vm.formulas.value) |
|||
assertEquals(pages, vm.pages.value.map { it.id to it.title }) |
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
assertTrue(vm.uiState.value.isConnected) |
|||
assertEquals(uiBefore.recordingState, vm.uiState.value.recordingState) |
|||
assertEquals(uiBefore.recordingSampleCount, vm.uiState.value.recordingSampleCount) |
|||
assertEquals(uiBefore.recordingStartedAtMillis, vm.uiState.value.recordingStartedAtMillis) |
|||
renderers.forEachIndexed { index, renderer -> |
|||
val series = renderer.seriesListFlow.value.single() |
|||
assertEquals(0, series.buffer.size) |
|||
assertEquals("formula_F", series.signalId) |
|||
assertEquals(0x123456L, series.color) |
|||
assertEquals(bindings[index].axes, renderer.exportWorkspaceState().axes) |
|||
} |
|||
coVerify(exactly = 0) { repository.stopStreaming() } |
|||
coVerify(exactly = 0) { repository.disconnect() } |
|||
telemetry(3f) |
|||
assertEquals(6.0, vm.liveTelemetryValues.value["F"]) |
|||
assertEquals(1L, vm.uiState.value.packetCount) |
|||
assertEquals(uiBefore.recordingSampleCount + 1, vm.uiState.value.recordingSampleCount) |
|||
renderers.forEach { assertEquals(1, it.seriesListFlow.value.single().buffer.size) } |
|||
vm.stopMeasurementRecording() |
|||
val rows = directory.listFiles()!!.single { it.name.endsWith("_formula.csv") }.readLines() |
|||
.filter { it.matches(Regex("^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2},.*")) } |
|||
assertEquals(listOf("0", "1"), rows.map { it.split(',')[1].trim() }) |
|||
assertEquals(listOf(4.0, 6.0), rows.map { it.substringAfterLast(',').toDouble() }) |
|||
} |
|||
|
|||
@Test fun debugResetWhileStoppedDoesNotReuseOldFormulaInputs() { |
|||
vm.addFormula(FormulaDefinition(name = "F", expression = "Incar_Snr*2")) |
|||
telemetry(2f) |
|||
assertEquals(4.0, vm.liveTelemetryValues.value["F"]) |
|||
vm.resetDebugValues() |
|||
assertTrue(vm.liveTelemetryValues.value.isEmpty()) |
|||
vm.resetDebugValues() // Repeated reset without a project/measurement is safe. |
|||
assertTrue(packets.tryEmit(DctPacket(0xA4.toByte(), byteArrayOf(1, 0, 1, 0, 0, 10, 0, 0)))) |
|||
assertTrue(vm.liveTelemetryValues.value.isEmpty()) // A stopped session ignores stream data. |
|||
assertFalse(vm.uiState.value.isMeasuring) |
|||
vm.startMeasure() |
|||
assertTrue(packets.tryEmit(DctPacket(0xA4.toByte(), byteArrayOf(1, 0, 1, 0, 0, 10, 0, 0)))) |
|||
assertTrue(vm.liveTelemetryValues.value.getValue("F").isNaN()) |
|||
telemetry(5f) |
|||
assertEquals(10.0, vm.liveTelemetryValues.value["F"]) |
|||
} |
|||
|
|||
@Test fun unrelatedSmPacketAddsNeitherFormulaGraphNorCsvSample() { |
|||
vm.startMeasure() |
|||
vm.addFormula(FormulaDefinition(name = "F", expression = "Incar_Snr*2")) |
|||
vm.chartRenderer.bindSignal("formula_F", "F", AxisPosition.LEFT_0, 0xFF0000L) |
|||
vm.startMeasurementRecording() |
|||
telemetry(2f) |
|||
val graph = vm.chartRenderer.seriesListFlow.value.single { it.signalId == "formula_F" } |
|||
assertEquals(1, graph.buffer.size) |
|||
val before = vm.uiState.value.packetCount |
|||
// One connected SM channel; it has no dependency edge to Incar_Snr. |
|||
assertTrue(packets.tryEmit(DctPacket(0xA4.toByte(), byteArrayOf(1, 0, 1, 0, 0, 10, 0, 0)))) |
|||
assertEquals(before + 1, vm.uiState.value.packetCount) |
|||
assertEquals(1, graph.buffer.size) |
|||
telemetry(3f) |
|||
assertEquals(2, graph.buffer.size) |
|||
vm.stopMeasurementRecording() |
|||
val csv = directory.listFiles()!!.single { it.name.endsWith("_formula.csv") } |
|||
// The PC-compatible default includes the date and omits milliseconds. |
|||
val rows = csv.readLines().filter { it.matches(Regex("^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2},.*")) } |
|||
assertEquals(2, rows.size) |
|||
assertEquals(listOf("0", "1"), rows.map { it.split(',')[1].trim() }) |
|||
assertEquals(listOf(4.0, 6.0), rows.map { it.substringAfterLast(',').toDouble() }) |
|||
} |
|||
|
|||
@Test fun editsRenameAndDeletionRefreshWithoutWaitingForAnotherPacket() { |
|||
vm.startMeasure() |
|||
val f = FormulaDefinition(name = "F", expression = "Incar_Snr*2") |
|||
vm.addFormula(f) |
|||
telemetry(2f) |
|||
vm.updateFormula(f.copy(expression = "Incar_Snr*3")) |
|||
assertEquals(6.0, vm.liveTelemetryValues.value["F"]) |
|||
val renamed = f.copy(name = "New") |
|||
vm.updateFormula(renamed) |
|||
assertFalse("F" in vm.liveTelemetryValues.value) |
|||
assertFalse("formula_F" in vm.liveTelemetryValues.value) |
|||
assertEquals(4.0, vm.liveTelemetryValues.value["New"]) |
|||
vm.deleteFormula(renamed) |
|||
assertFalse("New" in vm.liveTelemetryValues.value) |
|||
assertFalse("formula_New" in vm.liveTelemetryValues.value) |
|||
} |
|||
|
|||
@Test fun calculationErrorIsRecordedAsNoValueNotOldGoodValue() { |
|||
vm.startMeasure() |
|||
vm.addFormula(FormulaDefinition(name = "F", expression = "10/Incar_Snr")) |
|||
vm.startMeasurementRecording() |
|||
telemetry(2f) |
|||
telemetry(0f) |
|||
vm.stopMeasurementRecording() |
|||
val csv = directory.listFiles()!!.single { it.name.endsWith("_formula.csv") } |
|||
assertTrue(csv.readLines().last().contains("No value")) |
|||
} |
|||
|
|||
@Test fun formulaCreatedWhileIdleRecoversFromMissingValueOnFirstInput() { |
|||
vm.addFormula(FormulaDefinition(name = "F", expression = "INCAR_SNR*2")) |
|||
assertFalse(vm.uiState.value.isMeasuring) |
|||
assertTrue(vm.liveTelemetryValues.value.getValue("F").isNaN()) |
|||
vm.startMeasure() |
|||
telemetry(3f) |
|||
assertEquals(6.0, vm.liveTelemetryValues.value["F"]) |
|||
} |
|||
|
|||
@Test fun idleFormulaRegistersItsMdbInputsWithoutBindingRawSignalsToGraph() { |
|||
openMdbWithoutRawConsumers() |
|||
vm.addFormula(FormulaDefinition(name = "F", expression = "TA_MOTOR_SPEED*2")) |
|||
val configurationMethod = MainViewModel::class.java.getDeclaredMethod("createDeviceMeasurementConfiguration").also { it.isAccessible = true } |
|||
val configuration = configurationMethod.invoke(vm) as DctMeasurementConfiguration |
|||
assertEquals(listOf("Ta_Motor_Speed"), configuration.selectedMdbSignals.map { it.name }) |
|||
vm.startMeasure() |
|||
coVerifyOrder { |
|||
repository.configureMeasurement(match { it.selectedMdbSignals.any { signal -> signal.name == "Ta_Motor_Speed" } }) |
|||
repository.startStreaming(any()) |
|||
} |
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
val before = vm.uiState.value.packetCount |
|||
assertTrue(packets.tryEmit(DctPacket(0xA3.toByte(), byteArrayOf(1, 1, 0, 12, 0)))) |
|||
assertEquals(before + 1, vm.uiState.value.packetCount, "Live values: ${vm.liveTelemetryValues.value}") |
|||
assertEquals(3.0, vm.liveTelemetryValues.value["Ta_Motor_Speed"]) |
|||
assertEquals(6.0, vm.liveTelemetryValues.value["F"]) |
|||
} |
|||
|
|||
@Test fun formulaAddedAfterReadySynchronizationIsRegisteredBeforeStart() { |
|||
openMdbWithoutRawConsumers() |
|||
vm.syncDeviceConfiguration() |
|||
vm.addFormula(FormulaDefinition(name = "F", expression = "Ta_Motor_Speed*2")) |
|||
vm.startMeasure() |
|||
coVerify(exactly = 2) { repository.configureMeasurement(any()) } |
|||
coVerify(exactly = 1) { repository.configureMeasurement(match { it.selectedMdbSignals.map { s -> s.idx } == listOf(1) }) } |
|||
vm.stopMeasure() |
|||
vm.startMeasure() |
|||
// Unchanged selection is reused; no full configuration on every restart. |
|||
coVerify(exactly = 2) { repository.configureMeasurement(any()) } |
|||
} |
|||
|
|||
@Test fun failedFormulaInputConfigurationDoesNotStartAndCanBeRetried() { |
|||
openMdbWithoutRawConsumers() |
|||
vm.syncDeviceConfiguration() |
|||
vm.addFormula(FormulaDefinition(name = "F", expression = "Ta_Motor_Speed*2")) |
|||
coEvery { repository.configureMeasurement(any()) } returns DctResult.Failure(DctError.Unknown("configuration NACK")) |
|||
vm.startMeasure() |
|||
assertFalse(vm.uiState.value.isMeasuring) |
|||
coVerify(exactly = 0) { repository.startStreaming(any()) } |
|||
coEvery { repository.configureMeasurement(any()) } returns DctResult.Success(Unit) |
|||
vm.startMeasure() |
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
} |
|||
|
|||
@Test fun nestedFormulasAndRawIdsRegisterAllMdbInputs() { |
|||
openMdbWithoutRawConsumers() |
|||
vm.addFormula(FormulaDefinition(name = "Result", expression = "Intermediate+RAW_SIG_1_2")) |
|||
vm.addFormula(FormulaDefinition(name = "Intermediate", expression = "ta_motor_speed*2")) |
|||
val method = MainViewModel::class.java.getDeclaredMethod("createDeviceMeasurementConfiguration").also { it.isAccessible = true } |
|||
assertEquals(listOf(1, 2), (method.invoke(vm) as DctMeasurementConfiguration).selectedMdbSignals.map { it.idx }) |
|||
} |
|||
} |
|||
@ -1,31 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import androidx.compose.ui.unit.dp |
|||
import com.dct.app.data.repository.DpcProjectManager |
|||
import com.dct.app.domain.model.formula.FormulaDefinition |
|||
import com.dct.app.domain.model.project.* |
|||
import com.dct.app.presentation.signaltree.WindowColumnWidths |
|||
import com.dct.app.presentation.signaltree.WindowUiStore |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class FormulaWindowStateTest { |
|||
@Test fun independentFormulaColumnWidthsAndSearchRoundTripThroughDpc() { |
|||
var saved = emptyMap<String, String>() |
|||
val widths = WindowColumnWidths(WindowUiStore(mapOf("search" to "Power")) { saved = it }) |
|||
val expected = mapOf("name" to 210f, "value" to 110f, "unit" to 65f, "color" to 90f, "expression" to 330f, "act" to 70f) |
|||
expected.forEach { (key, width) -> widths[key] = width.dp } |
|||
val project = DpcProject(formulas = listOf(FormulaDefinition(name = "Power", expression = "Torque*2", unit = "kW")), |
|||
workspace = DpcWorkspaceState(activePageId = "page_1", pages = listOf(DpcPageState("page_1", "Page 1", windows = listOf( |
|||
DpcWindowState("formula", "FORMULA_LIST", "Formula", contentState = saved) |
|||
))))) |
|||
val restored = DpcProjectManager.parseProjectFromJson(DpcProjectManager.serializeProjectToJson(project), null) |
|||
val content = restored.workspace!!.pages.single().windows.single().contentState |
|||
val restoredWidths = WindowColumnWidths(WindowUiStore(content) {}) |
|||
assertEquals("Power", content["search"]) |
|||
expected.forEach { (key, width) -> assertEquals(width.dp, restoredWidths[key]) } |
|||
// PC formula_property persists fields/name/index, not the runtime UUID. |
|||
val restoredFormula = restored.formulas.single() |
|||
assertEquals(project.formulas.single().copy(id = restoredFormula.id), restoredFormula) |
|||
} |
|||
} |
|||
@ -1,168 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.protocol.* |
|||
import com.dct.app.data.maintenance.* |
|||
import com.dct.app.domain.model.mdb.* |
|||
import com.dct.app.domain.model.a2l.A2lDataType |
|||
import com.dct.app.domain.model.protocol.* |
|||
import com.dct.app.domain.model.chart.MultiAxisCoordinateTransformer |
|||
import com.dct.app.domain.usecase.chart.ChartBatchRenderer |
|||
import com.dct.app.presentation.mdi.* |
|||
import kotlinx.coroutines.test.UnconfinedTestDispatcher |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class GapClosureRegressionTest { |
|||
private fun map() = CompensationMap(CompensationMapType.TYPE_A, 1, "Y", 0x345678, MdbAttrType.ATTR_3_INT16, |
|||
-300.0, 300.0, "X", 0x123456, MdbAttrType.ATTR_2_UINT16, 0.5, 1.0, |
|||
points = listOf(MapPoint(0, 0x1234, -2, 0.0), MapPoint(1, 0x5678, 3, 0.0))) |
|||
private fun response(bytes: ByteArray) = DctPacket.create(DctCommand.RES_COMPENSATION_TYPE_DATA, bytes) |
|||
|
|||
@Test fun calibrationIntegersUseBigEndianAndSignedValues() { |
|||
assertArrayEquals(byteArrayOf(0x12, 0x34), DctCalibrationProtocol.encodeInteger(4660.0, MdbAttrType.ATTR_2_UINT16)) |
|||
assertArrayEquals(byteArrayOf(-1, -2), DctCalibrationProtocol.encodeInteger(-2.0, MdbAttrType.ATTR_3_INT16)) |
|||
assertEquals(-2.0, DctCalibrationProtocol.decodeInteger(byteArrayOf(-1, -2), MdbAttrType.ATTR_3_INT16)) |
|||
assertEquals(4294967295.0, DctCalibrationProtocol.decodeInteger(byteArrayOf(-1,-1,-1,-1), MdbAttrType.ATTR_4_UINT32)) |
|||
} |
|||
@Test fun integerValuesAreNotSilentlyTruncated() { |
|||
for (value in listOf(-1.0, 256.0, 1.5, Double.NaN, Double.POSITIVE_INFINITY)) { |
|||
assertThrows(IllegalArgumentException::class.java) { DctCalibrationProtocol.encodeInteger(value, MdbAttrType.ATTR_0_UINT8) } |
|||
} |
|||
} |
|||
@Test fun mapGoldenReadAndWrite() { |
|||
assertArrayEquals(byteArrayOf(1,0x12,0x34,0x56,2,2), DctCalibrationProtocol.mapRequest(map(), true, false).payload) |
|||
assertArrayEquals(byteArrayOf(4,0x34,0x56,0x78,2,2,-1,-2,0,3), DctCalibrationProtocol.mapRequest(map(), false, true).payload) |
|||
} |
|||
@Test fun mapRejectsTruncatedAddressesAndEmptyPoints() { |
|||
for (m in listOf(map().copy(xAddr = 0x1000000), map().copy(xAddr = 0xFFFFFE), map().copy(points = emptyList()))) { |
|||
assertThrows(IllegalArgumentException::class.java) { DctCalibrationProtocol.mapRequest(m, true, true) } |
|||
} |
|||
} |
|||
@Test fun mapReadUpdatesRawAndPhysicalForTypeA() { |
|||
val read = DctCalibrationProtocol.mapResponse(map(), true, false, response(byteArrayOf(1,1,0x12,0x34,0x56,2,2,0,4,0,8))) |
|||
assertEquals(listOf(4,8), read.points.map { it.bkp }) |
|||
assertEquals(listOf(3.0,5.0), read.points.map { it.phy }) |
|||
assertEquals(map().points.map { it.data }, read.points.map { it.data }) |
|||
} |
|||
@Test fun mapReadUpdatesPhysicalOnYAxisForTypeB() { |
|||
val read = DctCalibrationProtocol.mapResponse(map().copy(type = CompensationMapType.TYPE_B), false, false, |
|||
response(byteArrayOf(1,2,0x34,0x56,0x78,2,2,-1,-2,0,4))) |
|||
assertEquals(listOf(0.0,3.0), read.points.map { it.phy }) |
|||
} |
|||
@Test fun mapRejectsNackWrongAddressWrongTypeCountAndLength() { |
|||
val good = byteArrayOf(1,1,0x12,0x34,0x56,2,2,0,4,0,8) |
|||
for (index in 0..6) { |
|||
val invalid = good.copyOf().also { it[index] = 99 } |
|||
assertThrows(IllegalArgumentException::class.java) { DctCalibrationProtocol.mapResponse(map(), true, false, response(invalid)) } |
|||
} |
|||
assertThrows(IllegalArgumentException::class.java) { DctCalibrationProtocol.mapResponse(map(), true, false, response(good.dropLast(1).toByteArray())) } |
|||
} |
|||
@Test fun mapWriteRequiresEchoedOperationAndAddress() { |
|||
val request = DctCalibrationProtocol.mapRequest(map(), true, true) |
|||
assertEquals(map(), DctCalibrationProtocol.mapResponse(map(), true, true, response(byteArrayOf(1) + request.payload.take(6).toByteArray()))) |
|||
assertThrows(IllegalArgumentException::class.java) { DctCalibrationProtocol.mapResponse(map(), true, true, response(byteArrayOf(1))) } |
|||
} |
|||
@Test fun setupRejectsNackAndWrongCommand() { |
|||
val request = DctProtocolRequests.mdbInfo(emptyList()) |
|||
DctResponseValidator.validateSetup(request, DctPacket.create(DctCommand.RES_MDB_INFO, byteArrayOf(1))) |
|||
assertThrows(IllegalArgumentException::class.java) { DctResponseValidator.validateSetup(request, DctPacket.create(DctCommand.RES_MDB_INFO, byteArrayOf(2))) } |
|||
assertThrows(IllegalArgumentException::class.java) { DctResponseValidator.validateSetup(request, DctPacket.create(DctCommand.RES_ENABLE, byteArrayOf(1))) } |
|||
} |
|||
@Test fun setupSubtypeIsNotMistakenForSuccess() { |
|||
val request = DctProtocolRequests.canMode(true, false) |
|||
DctResponseValidator.validateSetup(request, DctPacket.create(DctCommand.RES_DCT_ENV, byteArrayOf(6,1,1))) |
|||
// DCT_test compatibility: a legacy peer may omit the subtype/mode and |
|||
// return either [06, ACK] or a generic [ACK]. Both still require ACK=1. |
|||
DctResponseValidator.validateSetup(request, DctPacket.create(DctCommand.RES_DCT_ENV, byteArrayOf(6,1))) |
|||
DctResponseValidator.validateSetup(request, DctPacket.create(DctCommand.RES_DCT_ENV, byteArrayOf(1))) |
|||
for (payload in listOf(byteArrayOf(6,2,1), byteArrayOf(6,1,0), byteArrayOf(6,2), byteArrayOf(2), byteArrayOf(1,1))) { |
|||
assertThrows(IllegalArgumentException::class.java) { DctResponseValidator.validateSetup(request, DctPacket.create(DctCommand.RES_DCT_ENV, payload)) } |
|||
} |
|||
} |
|||
@Test fun handshakeValidatesVersionAndHardwareIdLengths() { |
|||
DctResponseValidator.validateSetup(DctProtocolRequests.version(), DctPacket.create(DctCommand.RES_VERSION, byteArrayOf(1,65))) |
|||
assertThrows(IllegalArgumentException::class.java) { DctResponseValidator.validateSetup(DctProtocolRequests.version(), DctPacket.create(DctCommand.RES_VERSION, byteArrayOf(8,65))) } |
|||
assertThrows(IllegalArgumentException::class.java) { DctResponseValidator.validateSetup(DctProtocolRequests.hardwareId(), DctPacket.create(DctCommand.RES_HWID, byteArrayOf(1))) } |
|||
} |
|||
@Test fun xcpHalfPrecisionGoldenFrames() { |
|||
assertArrayEquals(byteArrayOf(0x3E,0), XcpValueCodec.encode(A2lDataType.FLOAT16_IEEE, 1.5, true)) |
|||
assertArrayEquals(byteArrayOf(0,0xC0.toByte()), XcpValueCodec.encode(A2lDataType.FLOAT16_IEEE, -2.0, false)) |
|||
assertArrayEquals(byteArrayOf(0,1), XcpValueCodec.encode(A2lDataType.FLOAT16_IEEE, Math.scalb(1.0,-24), true)) |
|||
} |
|||
@Test fun xcpRejectsOverflowFractionsAndUnsafe64Bit() { |
|||
for ((type, value) in listOf(A2lDataType.UBYTE to 256.0, A2lDataType.SBYTE to 128.0, |
|||
A2lDataType.UWORD to 1.1, A2lDataType.UINT64 to 9007199254740992.0, |
|||
A2lDataType.FLOAT32_IEEE to Double.MAX_VALUE, A2lDataType.FLOAT16_IEEE to 65505.0)) { |
|||
assertThrows(IllegalArgumentException::class.java) { XcpValueCodec.encode(type, value, false) } |
|||
} |
|||
assertThrows(IllegalArgumentException::class.java) { DctProtocolRequests.xcpCharacteristicWrite(0xFFFFFFFF, A2lDataType.UWORD, 1.0, false) } |
|||
} |
|||
@Test fun didGoldenFramesAndBatchParsing() { |
|||
assertArrayEquals(byteArrayOf(0xF1.toByte(),0x87.toByte(),2,65,66), DeviceMaintenanceProtocol.writeDid(0xF187, byteArrayOf(65,66)).payload) |
|||
assertArrayEquals(byteArrayOf(65), DeviceMaintenanceProtocol.parseDid(byteArrayOf(0xF1.toByte(),0x87.toByte(),1,1,65), 0xF187)) |
|||
val all = DeviceMaintenanceProtocol.parseAllDid(byteArrayOf(1,0xF1.toByte(),0x87.toByte(),1,65,0xF1.toByte(),0x91.toByte(),1,66)) |
|||
assertEquals(setOf(0xF187,0xF191), all.keys) |
|||
} |
|||
@Test fun didRejectsNackTruncationAndDuplicateIds() { |
|||
assertThrows(IllegalArgumentException::class.java) { DeviceMaintenanceProtocol.parseDid(byteArrayOf(-15,-121,2,0),0xF187) } |
|||
assertThrows(IllegalArgumentException::class.java) { DeviceMaintenanceProtocol.parseAllDid(byteArrayOf(1,-15,-121,8,65)) } |
|||
assertThrows(IllegalArgumentException::class.java) { DeviceMaintenanceProtocol.parseAllDid(byteArrayOf(1,-15,-121,0,-15,-121,0)) } |
|||
} |
|||
@Test fun firmwareHashUsesActualPcOpcode() { |
|||
val packet = DeviceMaintenanceProtocol.hashResponse(DeviceMaintenanceProtocol.HashInfo("fw", ByteArray(32) { it.toByte() }, "A")) |
|||
assertEquals(0x32.toByte(), packet.command) |
|||
assertArrayEquals(byteArrayOf(3,1,2,102,119,2,32), packet.payload.take(7).toByteArray()) |
|||
assertArrayEquals(byteArrayOf(3,2), DeviceMaintenanceProtocol.hashResponse(null).payload) |
|||
} |
|||
@Test fun firmwareAddressBanksGoldenFrameAndOverflow() { |
|||
val packet = DeviceMaintenanceProtocol.firmwareAddresses(listOf(DeviceMaintenanceProtocol.MemoryRegion(0x12345678,0x1000)), emptyList()) |
|||
assertArrayEquals(byteArrayOf(1,0x12,0x34,0x56,0x78,0,0,0x10,0,0), packet.payload) |
|||
assertThrows(IllegalArgumentException::class.java) { DeviceMaintenanceProtocol.firmwareAddresses(listOf(DeviceMaintenanceProtocol.MemoryRegion(0xFFFFFFFF,2)), emptyList()) } |
|||
} |
|||
@Test fun maintenanceRequestBoundsAndAsciiValidation() { |
|||
assertThrows(IllegalArgumentException::class.java) { DeviceMaintenanceProtocol.databaseName("한글") } |
|||
assertThrows(IllegalArgumentException::class.java) { DeviceMaintenanceProtocol.databaseItem(256) } |
|||
assertThrows(IllegalArgumentException::class.java) { DeviceMaintenanceProtocol.setSavedInterval(true,3) } |
|||
assertArrayEquals(byteArrayOf(0,1), DeviceMaintenanceProtocol.carTypeControl(1,0).payload) |
|||
} |
|||
@Test fun minimizeMaximizePreserveOriginalBounds() { |
|||
val vm = MdiViewModel(TestDispatcherProvider(UnconfinedTestDispatcher())) |
|||
val id = vm.addWindow(MdiWindowType.GRAPH, offsetX = 123f, offsetY = 45f, width = 500f)!! |
|||
val original = vm.uiState.value.windows.single() |
|||
vm.toggleMinimized(id) |
|||
assertTrue(vm.uiState.value.windows.single().isMinimized) |
|||
vm.toggleMaximized(id) |
|||
assertTrue(vm.uiState.value.windows.single().isMaximized) |
|||
assertFalse(vm.uiState.value.windows.single().isMinimized) |
|||
vm.toggleMaximized(id) |
|||
assertEquals(original.width, vm.uiState.value.windows.single().width) |
|||
assertEquals(original.offsetX, vm.uiState.value.windows.single().offsetX) |
|||
} |
|||
@Test fun restoredWindowsCannotBeStrandedWithoutSizeStateButtons() { |
|||
val vm = MdiViewModel(TestDispatcherProvider(UnconfinedTestDispatcher())) |
|||
vm.addWindow(MdiWindowType.GRAPH, offsetX = 123f, offsetY = 45f, width = 500f, height = 300f) |
|||
val normal = vm.uiState.value.windows.single() |
|||
for (saved in listOf(normal.copy(isMinimized = true), normal.copy(isMaximized = true))) { |
|||
vm.setWindows(listOf(saved), normal.id) |
|||
assertEquals(normal, vm.uiState.value.windows.single()) |
|||
assertEquals(normal.id, vm.uiState.value.activeWindowId) |
|||
} |
|||
} |
|||
@Test fun rightAxesReserveSeparateSpaceFromLegend() { |
|||
val without = MultiAxisCoordinateTransformer.calculatePlotBounds(1000f,600f,1,hasLegend=false) |
|||
val with = MultiAxisCoordinateTransformer.calculatePlotBounds(1000f,600f,1,hasLegend=false,rightAxisCount=4) |
|||
assertEquals( |
|||
without.right - MultiAxisCoordinateTransformer.DEFAULT_AXIS_WIDTH_PX * 4f, |
|||
with.right |
|||
) |
|||
} |
|||
@Test fun pinchZoomClampsAndPersistsManualSpan() { |
|||
val renderer = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())) |
|||
renderer.setTimeWindow(30.0) |
|||
renderer.zoomTimeWindow(2f,0.5) |
|||
assertEquals(15.0, renderer.exportWorkspaceState().timeWindowSec) |
|||
assertFalse(renderer.exportWorkspaceState().isXAxisAuto) |
|||
renderer.zoomTimeWindow(Float.NaN,0.5) |
|||
assertEquals(15.0, renderer.exportWorkspaceState().timeWindowSec) |
|||
} |
|||
} |
|||
@ -1,223 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.chart.* |
|||
import com.dct.app.domain.model.project.* |
|||
import com.dct.app.data.repository.DpcWorkspaceJson |
|||
import com.dct.app.domain.usecase.chart.ChartBatchRenderer |
|||
import kotlinx.coroutines.test.UnconfinedTestDispatcher |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import java.time.ZoneOffset |
|||
|
|||
@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class) |
|||
class GraphSettingsRegressionTest { |
|||
private fun renderer() = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())).apply { |
|||
bindSignal("a", "A", AxisPosition.LEFT_0, 0xFFL) |
|||
bindSignal("b", "B", AxisPosition.LEFT_1, 0xFF0000L) |
|||
addSampleSec("a", 1000.0, 1.0) |
|||
addSampleSec("a", 1001.0, 2.0) |
|||
addSampleSec("b", 1000.0, 500.0) |
|||
addSampleSec("b", 1001.0, 600.0) |
|||
setTimeWindow(TimeWindowPreset.AUTO) |
|||
} |
|||
|
|||
@Test fun hideKeepsMenuMetadataAndCanBeReversedEvenWhenEverythingIsHidden() { |
|||
val r = renderer() |
|||
r.setSeriesVisible("a", false) |
|||
r.setSeriesVisible("b", false) |
|||
val hidden = r.buildSnapshot(600).seriesList |
|||
assertEquals(listOf("a", "b"), hidden.map { it.signalId }) |
|||
assertTrue(hidden.all { !it.isVisible && it.points.isEmpty() }) |
|||
assertNull(hidden[0].minVisibleValue) |
|||
r.addSampleSec("a", 1002.0, 3.0) |
|||
r.setSeriesVisible("a", true) |
|||
assertTrue(r.buildSnapshot(600).seriesList.first().points.isNotEmpty()) |
|||
assertEquals(3.0, r.buildSnapshot(600).seriesList.first().latestValue) |
|||
} |
|||
|
|||
@Test fun manualAxisDoesNotDisableOtherAutoAxesAndCanReturnToAuto() { |
|||
val r = renderer() |
|||
r.setAxisRange(AxisPosition.LEFT_0, -5.0, 5.0, false) |
|||
r.addSampleSec("b", 1002.0, 900.0) |
|||
val mixed = r.buildSnapshot(600) |
|||
assertEquals(5.0, mixed.axesConfig.getValue(AxisPosition.LEFT_0).maxVal) |
|||
assertTrue(mixed.axesConfig.getValue(AxisPosition.LEFT_1).maxVal > 900.0) |
|||
assertFalse(mixed.isYAxisAuto) |
|||
r.setAxisRange(AxisPosition.LEFT_0, -5.0, 5.0, true) |
|||
r.addSampleSec("a", 1003.0, 20.0) |
|||
assertTrue(r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_0).maxVal > 20.0) |
|||
assertTrue(r.buildSnapshot(600).isYAxisAuto) |
|||
r.setYAxisAuto(false) |
|||
r.setAxisAuto(AxisPosition.LEFT_0, true) |
|||
assertTrue(r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_0).maxVal > 20.0) |
|||
assertFalse(r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_1).isAuto) |
|||
} |
|||
|
|||
@Test fun yAxisScaleIsIndependentAndFingerDirectionMatchesRangeSemantics() { |
|||
val r = renderer() |
|||
val autoBefore = r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_0) |
|||
r.scaleYAxis(AxisPosition.LEFT_0, 2.0) |
|||
val autoAfter = r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_0) |
|||
assertEquals(autoBefore.span * 2.0, autoAfter.span, 1e-9) |
|||
assertFalse(autoAfter.isAuto) |
|||
|
|||
r.setAxisRange(AxisPosition.LEFT_0, 0.0, 100.0, false) |
|||
r.setAxisRange(AxisPosition.LEFT_1, -10.0, 10.0, false) |
|||
|
|||
// Upward swipe is represented by a factor > 1 and expands only L1. |
|||
r.scaleYAxis(AxisPosition.LEFT_1, 2.0) |
|||
val expanded = r.buildSnapshot(600) |
|||
assertEquals(-20.0, expanded.axesConfig.getValue(AxisPosition.LEFT_1).minVal, 1e-9) |
|||
assertEquals(20.0, expanded.axesConfig.getValue(AxisPosition.LEFT_1).maxVal, 1e-9) |
|||
assertEquals(0.0, expanded.axesConfig.getValue(AxisPosition.LEFT_0).minVal, 1e-9) |
|||
assertEquals(100.0, expanded.axesConfig.getValue(AxisPosition.LEFT_0).maxVal, 1e-9) |
|||
assertFalse(expanded.axesConfig.getValue(AxisPosition.LEFT_1).isAuto) |
|||
|
|||
// Downward swipe is represented by a factor < 1 and narrows L1. |
|||
r.scaleYAxis(AxisPosition.LEFT_1, 0.5) |
|||
val narrowed = r.buildSnapshot(600) |
|||
assertEquals(-10.0, narrowed.axesConfig.getValue(AxisPosition.LEFT_1).minVal, 1e-9) |
|||
assertEquals(10.0, narrowed.axesConfig.getValue(AxisPosition.LEFT_1).maxVal, 1e-9) |
|||
} |
|||
|
|||
@Test fun yAxisPanMovesOnlyTheSelectedAxisAndDoubleTapResetRestoresManualBaseline() { |
|||
val r = renderer() |
|||
r.setAxisRange(AxisPosition.LEFT_0, 0.0, 100.0, false) |
|||
r.setAxisRange(AxisPosition.LEFT_1, -10.0, 10.0, false) |
|||
|
|||
// A downward drag equal to 25% of the plot height translates the |
|||
// selected axis by one quarter of its current 20-unit span. |
|||
r.panYAxis(AxisPosition.LEFT_1, 0.25) |
|||
val moved = r.buildSnapshot(600) |
|||
assertEquals(-5.0, moved.axesConfig.getValue(AxisPosition.LEFT_1).minVal, 1e-9) |
|||
assertEquals(15.0, moved.axesConfig.getValue(AxisPosition.LEFT_1).maxVal, 1e-9) |
|||
assertEquals(0.0, moved.axesConfig.getValue(AxisPosition.LEFT_0).minVal, 1e-9) |
|||
assertEquals(100.0, moved.axesConfig.getValue(AxisPosition.LEFT_0).maxVal, 1e-9) |
|||
assertFalse(moved.axesConfig.getValue(AxisPosition.LEFT_1).isAuto) |
|||
|
|||
// Axis double-tap is represented by resetYAxis in the renderer layer. |
|||
r.resetYAxis(AxisPosition.LEFT_1) |
|||
val restored = r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_1) |
|||
assertEquals(-10.0, restored.minVal, 1e-9) |
|||
assertEquals(10.0, restored.maxVal, 1e-9) |
|||
assertFalse(restored.isAuto) |
|||
|
|||
// A second reset has no stale baseline and must not change the range. |
|||
r.resetYAxis(AxisPosition.LEFT_1) |
|||
val unchanged = r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_1) |
|||
assertEquals(restored, unchanged) |
|||
} |
|||
|
|||
@Test fun yAxisPinchZoomUsesCentroidAnchorAndResetReturnsAutoMode() { |
|||
val r = renderer() |
|||
val before = r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_0) |
|||
val anchor = 0.25 |
|||
|
|||
// Pinch-out factor 2 narrows the visible span by half around the |
|||
// quarter-height value (the same anchor convention used by Canvas). |
|||
r.zoomYAxis(AxisPosition.LEFT_0, factor = 2.0, anchorFraction = anchor) |
|||
val zoomed = r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_0) |
|||
val anchorValue = before.minVal + before.span * anchor |
|||
assertEquals(before.span / 2.0, zoomed.span, 1e-9) |
|||
assertEquals(anchorValue, zoomed.minVal + zoomed.span * anchor, 1e-9) |
|||
assertFalse(zoomed.isAuto) |
|||
|
|||
r.resetYAxis(AxisPosition.LEFT_0) |
|||
val restored = r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_0) |
|||
assertTrue(restored.isAuto) |
|||
assertEquals(before.minVal, restored.minVal, 1e-9) |
|||
assertEquals(before.maxVal, restored.maxVal, 1e-9) |
|||
} |
|||
|
|||
@Test fun hiddenSeriesDoesNotAffectSharedAutoRange() { |
|||
val r = renderer() |
|||
r.assignSeriesAxis("b", AxisPosition.LEFT_0) |
|||
r.setSeriesVisible("b", false) |
|||
assertTrue(r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_0).maxVal < 10.0) |
|||
} |
|||
|
|||
@Test fun legendNoneAndHiddenSignalsAndMixedAxesSurviveProjectRoundTrip() { |
|||
val r = renderer() |
|||
r.setLegendPosition(3) |
|||
r.setSeriesVisible("b", false) |
|||
r.setAxisRange(AxisPosition.LEFT_0, .0123, .0987, false) |
|||
val workspace = DpcWorkspaceState("p", listOf(DpcPageState("p", "Page", windows = listOf( |
|||
DpcWindowState("w", "MULTI_AXIS_GRAPH", "Graph", chart = r.exportWorkspaceState(), |
|||
signals = r.seriesListFlow.value.map(DpcSignalBindingState::fromSeries)) |
|||
)))) |
|||
val window = DpcWorkspaceJson.decode(DpcWorkspaceJson.encode(workspace))!!.pages.single().windows.single() |
|||
val restored = renderer() |
|||
restored.restoreWorkspaceState(window.signals.map { it.toSeries() }, window.chart) |
|||
assertEquals(3, restored.buildSnapshot(600).legendPosition) |
|||
assertFalse(restored.buildSnapshot(600).seriesList.last().isVisible) |
|||
assertEquals(.0123, restored.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_0).minVal) |
|||
assertTrue(restored.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_1).isAuto) |
|||
} |
|||
|
|||
@Test fun allFiveThicknessesAreDistinctPhysicalPixels() { |
|||
assertEquals(listOf(1f, 2f, 3f, 4f, 5f), (1..5).map { chartLineWidthPx(it.toFloat()) }) |
|||
assertEquals(1f, chartLineWidthPx(Float.NaN)) |
|||
} |
|||
|
|||
@Test fun rawOutOfRangeVerticesAreNotClampedAndPulseHoldsPreviousValue() { |
|||
val input = listOf(0.0 to 150.0, 1.0 to 200.0) |
|||
val linear = mutableListOf<Triple<Double, Double, Boolean>>() |
|||
forEachChartVertex(input, InterpolationMode.LINEAR) { x, y, move -> linear.add(Triple(x,y,move)) } |
|||
assertEquals(listOf(Triple(0.0,150.0,true), Triple(1.0,200.0,false)), linear) |
|||
val pulse = mutableListOf<Triple<Double, Double, Boolean>>() |
|||
forEachChartVertex(input, InterpolationMode.PWM_STEP) { x,y,move -> pulse.add(Triple(x,y,move)) } |
|||
assertEquals(listOf(Triple(0.0,150.0,true), Triple(1.0,150.0,false), Triple(1.0,200.0,false)), pulse) |
|||
} |
|||
|
|||
@Test fun nonFiniteSamplesBreakPathsAndNeverPolluteAutoBounds() { |
|||
val commands = mutableListOf<Boolean>() |
|||
forEachChartVertex(listOf(0.0 to 1.0, 1.0 to Double.NaN, 2.0 to 3.0), InterpolationMode.LINEAR) { _,_,move -> commands.add(move) } |
|||
assertEquals(listOf(true, true), commands) |
|||
val r = renderer() |
|||
r.addSampleSec("a", 1002.0, Double.POSITIVE_INFINITY) |
|||
val axis = r.buildSnapshot(600).axesConfig.getValue(AxisPosition.LEFT_0) |
|||
assertTrue(isValidChartAxisRange(axis.minVal, axis.maxVal)) |
|||
} |
|||
|
|||
@Test fun axisEditingRetainsPrecisionAndRejectsInvalidOrOverflowingBounds() { |
|||
for (value in listOf(.0123456789, -.00000012345, 123456.7890123)) { |
|||
assertEquals(value, chartAxisInputText(value).toDouble()) |
|||
} |
|||
for ((min,max) in listOf(Double.NaN to 1.0, 0.0 to Double.POSITIVE_INFINITY, |
|||
1.0 to 1.0, 2.0 to 1.0, -Double.MAX_VALUE to Double.MAX_VALUE)) { |
|||
assertFalse(isValidChartAxisRange(min,max)) |
|||
val r = renderer() |
|||
val before = r.exportWorkspaceState() |
|||
r.setAxisRange(AxisPosition.LEFT_0,min,max,false) |
|||
r.setYAxisRange(min,max) |
|||
r.setAxisMinMax(AxisPosition.LEFT_0,min,max) |
|||
assertEquals(before, r.exportWorkspaceState()) |
|||
} |
|||
} |
|||
|
|||
@Test fun xAxisManualTimeUsesReadableLocalTextAndParsesLegacySeconds() { |
|||
val value = 1_789_447_222.234 |
|||
val text = chartTimeInputText(value, ZoneOffset.UTC) |
|||
assertEquals("2026-09-15 04:40:22.234", text) |
|||
assertFalse(text.contains('E', ignoreCase = true)) |
|||
assertEquals(value, parseChartTimeInput(text, value, ZoneOffset.UTC)!!, 0.001) |
|||
assertEquals(value, parseChartTimeInput("04:40:22.234", value, ZoneOffset.UTC)!!, 0.001) |
|||
assertEquals(value, parseChartTimeInput(value.toString(), value, ZoneOffset.UTC)!!, 0.001) |
|||
} |
|||
|
|||
@Test fun zoomSwitchesFromFixedPresetToAdaptiveTicksEvenWhileLive() { |
|||
val r = renderer() |
|||
r.setTimeWindow(TimeWindowPreset.MIN_1) |
|||
r.zoomTimeWindow(1000f, .4) |
|||
val s = r.buildSnapshot(600) |
|||
assertEquals(TimeWindowPreset.MANUAL, s.xAxisPreset) |
|||
val ticks = ChartAxisTicks.time(s.timeMinSec, s.timeMaxSec, 600f, s.xAxisPreset) |
|||
assertTrue(ticks.values.size > 1) |
|||
assertTrue(ticks.interval.seconds < 1.0) |
|||
} |
|||
|
|||
@Test fun smallYAxisTicksKeepDistinctDecimalValues() { |
|||
val ticks = listOf(.02, .04, .06, .08) |
|||
assertEquals(listOf("0.02", "0.04", "0.06", "0.08"), ticks.map { chartAxisTickText(it, ticks) }) |
|||
} |
|||
} |
|||
@ -1,79 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.repository.DpcProjectManager |
|||
import com.dct.app.domain.model.chart.* |
|||
import com.dct.app.domain.model.project.DpcProject |
|||
import com.dct.app.domain.usecase.chart.ChartBatchRenderer |
|||
import kotlinx.coroutines.test.UnconfinedTestDispatcher |
|||
import org.json.JSONObject |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class) |
|||
class GraphTypeTest { |
|||
@Test fun globalModeChangesPausedSnapshotWithoutLosingDataOrStyle() { |
|||
val renderer = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())) |
|||
renderer.bindSignal("rpm", "RPM", AxisPosition.RIGHT_1, 0xFFAABBCC, "rpm") |
|||
renderer.setAxisRange(AxisPosition.RIGHT_1, 0.0, 100.0, false) |
|||
renderer.setSeriesThickness("rpm", 4f) |
|||
renderer.setSeriesDashStyle("rpm", 2) |
|||
renderer.addSampleSec("rpm", 1.0, 10.0) |
|||
renderer.addSampleSec("rpm", 2.0, 20.0) |
|||
renderer.pause() |
|||
val original = renderer.seriesListFlow.value.single() |
|||
val axes = renderer.exportWorkspaceState().axes |
|||
|
|||
renderer.setGraphInterpolationMode(InterpolationMode.PWM_STEP) |
|||
assertEquals(original.copy(interpolationMode = InterpolationMode.PWM_STEP), renderer.seriesListFlow.value.single()) |
|||
val pulse = renderer.renderSnapshotFlow.value.seriesList.single() |
|||
assertEquals(InterpolationMode.PWM_STEP, pulse.interpolationMode) |
|||
assertEquals(20.0, pulse.latestValue) |
|||
assertSame(original.buffer, renderer.seriesListFlow.value.single().buffer) |
|||
assertEquals(axes, renderer.exportWorkspaceState().axes) |
|||
|
|||
renderer.setGraphInterpolationMode(InterpolationMode.LINEAR) |
|||
assertEquals(original, renderer.seriesListFlow.value.single()) |
|||
assertEquals(InterpolationMode.LINEAR, renderer.renderSnapshotFlow.value.seriesList.single().interpolationMode) |
|||
} |
|||
|
|||
@Test fun newAndRestoredSignalsInheritCommonMode() { |
|||
val renderer = ChartBatchRenderer(TestDispatcherProvider(UnconfinedTestDispatcher())) |
|||
renderer.setGraphInterpolationMode(InterpolationMode.PWM_STEP) |
|||
renderer.bindSignal("new", "New", AxisPosition.LEFT_0, 0xFF123456) |
|||
assertEquals(InterpolationMode.PWM_STEP, renderer.seriesListFlow.value.single().interpolationMode) |
|||
val savedLinear = renderer.seriesListFlow.value.single().copy(interpolationMode = InterpolationMode.LINEAR) |
|||
renderer.restoreWorkspaceState(listOf(savedLinear), null) |
|||
assertEquals(InterpolationMode.PWM_STEP, renderer.seriesListFlow.value.single().interpolationMode) |
|||
} |
|||
|
|||
@Test fun pulseAndLinearCursorValuesMatchTheirPaths() { |
|||
val points = listOf(0.0 to 0.0, 1.0 to 10.0, 2.0 to 0.0) |
|||
assertEquals(5.0, interpolateChartValue(points, 0.5, InterpolationMode.LINEAR)) |
|||
assertEquals(0.0, interpolateChartValue(points, 0.5, InterpolationMode.PWM_STEP)) |
|||
assertEquals(10.0, interpolateChartValue(points, 1.0, InterpolationMode.PWM_STEP)) |
|||
assertEquals(10.0, interpolateChartValue(points, 1.5, InterpolationMode.PWM_STEP)) |
|||
assertEquals(0.0, interpolateChartValue(points, 2.0, InterpolationMode.PWM_STEP)) |
|||
assertEquals(0.0, interpolateChartValue(points, -1.0, InterpolationMode.LINEAR)) |
|||
assertNull(interpolateChartValue(emptyList(), 0.0, InterpolationMode.LINEAR)) |
|||
assertNull(interpolateChartValue(points, Double.NaN, InterpolationMode.PWM_STEP)) |
|||
} |
|||
|
|||
@Test fun pcGraphPropertyRoundTripsAndPreservesOtherKeys() { |
|||
val raw = JSONObject("""{"graphItem_property":{"graph_linear":true,"vendor_setting":123}}""") |
|||
val project = DpcProject(rawJsonRoot = raw, graphLinear = false) |
|||
val saved = DpcProjectManager.serializeProjectToJson(project) |
|||
val property = JSONObject(saved).getJSONObject("graphItem_property") |
|||
assertFalse(property.getBoolean("graph_linear")) |
|||
assertEquals(123, property.getInt("vendor_setting")) |
|||
val restored = DpcProjectManager.parseProjectFromJson(saved, null) |
|||
assertFalse(restored.graphLinear) |
|||
val linear = DpcProjectManager.serializeProjectToJson(restored.copy(graphLinear = true)) |
|||
assertTrue(DpcProjectManager.parseProjectFromJson(linear, null).graphLinear) |
|||
} |
|||
|
|||
@Test fun importsPcPulseAndDefaultsOlderProjectsToLinear() { |
|||
assertFalse(DpcProjectManager.parseProjectFromJson("""{"graphItem_property":{"graph_linear":false}}""", null).graphLinear) |
|||
assertTrue(DpcProjectManager.parseProjectFromJson("{}", null).graphLinear) |
|||
assertTrue(DpcProjectManager.parseProjectFromJson("""{"graphItem_property":{}}""", null).graphLinear) |
|||
} |
|||
} |
|||
@ -1,70 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.protocol.* |
|||
import com.dct.app.domain.model.protocol.* |
|||
import com.dct.app.domain.model.mdb.* |
|||
import com.google.common.truth.Truth.assertThat |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.Assertions.assertThrows |
|||
|
|||
class HardwareWireRegressionTest { |
|||
private fun hex(s: String) = s.split(" ").map { it.toInt(16).toByte() }.toByteArray() |
|||
|
|||
@Test fun capturedHardwareResponses() { |
|||
val codec = DctPacketCodec() |
|||
// 20260716_104112_log.txt: untouched complete hardware frames. |
|||
val mode = codec.decode(hex("A1 00 04 89 06 01 00 CA 7E"))!! |
|||
DctResponseValidator.validateSetup(DctProtocolRequests.canMode(false, false), mode) |
|||
val start = codec.decode(hex("A1 00 03 A0 01 01 B9 7E"))!! |
|||
DctResponseValidator.validateSetup(DctProtocolRequests.startAll(), start) |
|||
} |
|||
|
|||
@Test fun startStatusPrecedesTypeAndMalformedRepliesFail() { |
|||
for (payload in listOf("02 01", "01 02", "01 00", "01", "01 01 00", "")) { |
|||
val bytes = if (payload.isEmpty()) byteArrayOf() else hex(payload) |
|||
assertThrows(IllegalArgumentException::class.java) { |
|||
DctResponseValidator.validateSetup(DctProtocolRequests.startAll(), |
|||
DctPacket.create(DctCommand.RES_START_TRANSMIT_DATA, bytes)) |
|||
} |
|||
} |
|||
} |
|||
|
|||
@Test fun allCanModeFlagsMustBeEchoed() { |
|||
for (modern in listOf(false, true)) for (old in listOf(false, true)) { |
|||
val request = DctProtocolRequests.canMode(modern, old) |
|||
DctResponseValidator.validateSetup(request, |
|||
DctPacket.create(DctCommand.RES_DCT_ENV, byteArrayOf(6, 1, request.payload[1]))) |
|||
} |
|||
} |
|||
|
|||
@Test fun wireCanIdIsIndependentOfDbcSignalByteOrder() { |
|||
val parsed = DctStreamPayloadParser.parseCanStream(hex("02 01 01 01 00 10 02 12 34")) |
|||
as DctStreamPayloadParser.CanStreamPayload.Can |
|||
assertThat(parsed.frames.single().canId).isEqualTo(0x10L) |
|||
assertThat(parsed.frames.single().data).isEqualTo(hex("12 34")) |
|||
} |
|||
|
|||
// Golden bytes follow PC MAKEWORD(low, high) / MAKELONG(low, high), not the encoder. |
|||
@Test fun mdbBigEndianSignedUnsignedBoundariesAndScaling() { |
|||
val vectors = listOf( |
|||
Triple(MdbAttrType.ATTR_2_UINT16, "00 64", 100.0), |
|||
Triple(MdbAttrType.ATTR_2_UINT16, "12 34", 4660.0), |
|||
Triple(MdbAttrType.ATTR_2_UINT16, "FF FF", 65535.0), |
|||
Triple(MdbAttrType.ATTR_3_INT16, "FF 9C", -100.0), |
|||
Triple(MdbAttrType.ATTR_3_INT16, "80 00", -32768.0), |
|||
Triple(MdbAttrType.ATTR_4_UINT32, "12 34 56 78", 305419896.0), |
|||
Triple(MdbAttrType.ATTR_4_UINT32, "FF FF FF FF", 4294967295.0), |
|||
Triple(MdbAttrType.ATTR_5_INT32, "80 00 00 00", -2147483648.0), |
|||
Triple(MdbAttrType.ATTR_5_INT32, "7F FF FF FF", 2147483647.0), |
|||
Triple(MdbAttrType.ATTR_5_INT32, "FF FF FF 9C", -100.0) |
|||
) |
|||
for ((attr, bytes, raw) in vectors) { |
|||
val definition = SignalDefinition(7, 1, "Value", attr, 0.5, -2.0, "", 0, |
|||
-Double.MAX_VALUE, Double.MAX_VALUE, arrayIndex = 0) |
|||
val result = MdbRecordDecoder.decode(7, hex(bytes), listOf(definition)) |
|||
as MdbRecordDecoder.DecodeResult.Success |
|||
assertThat(result.signals.single().rawValue.toDouble()).isEqualTo(raw) |
|||
assertThat(result.signals.single().physicalValue).isEqualTo(raw * 0.5 - 2.0) |
|||
} |
|||
} |
|||
} |
|||
@ -1,137 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.data.communication.WifiSocketManager |
|||
import com.dct.app.data.repository.PacketRepositoryImpl |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.domain.repository.DeviceConnectionState |
|||
import io.mockk.* |
|||
import kotlinx.coroutines.ExperimentalCoroutinesApi |
|||
import kotlinx.coroutines.flow.MutableSharedFlow |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import kotlinx.coroutines.test.* |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.params.ParameterizedTest |
|||
import org.junit.jupiter.params.provider.ValueSource |
|||
|
|||
@OptIn(ExperimentalCoroutinesApi::class) |
|||
class HeartbeatIdleRegressionTest { |
|||
private class Fixture(scope: TestScope) { |
|||
val wifi = mockk<WifiSocketManager>(relaxed = true) |
|||
val packets = MutableSharedFlow<DctPacket>(extraBufferCapacity = 64) |
|||
val connected = MutableStateFlow(true) |
|||
val sent = mutableListOf<DctPacket>() |
|||
val acks = mutableListOf<DctPacket>() |
|||
var sessionId = 7L |
|||
val repository: PacketRepositoryImpl |
|||
|
|||
init { |
|||
every { wifi.isConnected } returns connected |
|||
every { wifi.packetStream } returns packets |
|||
every { wifi.currentSessionId } answers { sessionId } |
|||
every { wifi.offerCommand(capture(acks)) } returns true |
|||
coEvery { wifi.disconnectSuspend() } coAnswers { connected.value = false } |
|||
every { wifi.invalidateConnectionIfSession(any()) } answers { |
|||
connected.value = false |
|||
true |
|||
} |
|||
coEvery { wifi.sendCommand(any()) } coAnswers { |
|||
val request = firstArg<DctPacket>() |
|||
sent += request |
|||
val payload = when (request.command.toInt() and 255) { |
|||
0x00, 0x04, 0x09, 0x21 -> byteArrayOf(1) |
|||
0x01 -> byteArrayOf(4, 68, 67, 84, 0) |
|||
0x03 -> ByteArray(6) |
|||
0x20 -> byteArrayOf(1, 1) |
|||
else -> null // Probes intentionally remain silent. |
|||
} |
|||
if (payload != null) packets.emit(DctPacket( |
|||
((request.command.toInt() and 255) + 0x80).toByte(), payload, |
|||
transportSessionId = sessionId)) |
|||
true |
|||
} |
|||
val dispatcher = StandardTestDispatcher(scope.testScheduler) |
|||
repository = PacketRepositoryImpl(wifiSocketManager = wifi, ioDispatcher = dispatcher, |
|||
heartbeatDispatcher = dispatcher, heartbeatIntervalMs = 1000, |
|||
heartbeatTimeoutMs = 5000, monotonicTimeMillis = { scope.testScheduler.currentTime }) |
|||
} |
|||
|
|||
suspend fun connect() { assertTrue(repository.connect("") is DctResult.Success) } |
|||
fun probes() = sent.count { it.command == 0x05.toByte() } |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@ValueSource(ints = [0, 1, 2, 3]) |
|||
fun continuousMdbCanSensorAndXcpKeepTheirAcksWithoutHeartbeatProbes(source: Int) = runTest { |
|||
val f = Fixture(this) |
|||
f.connect() |
|||
assertTrue(f.repository.startStreaming() is DctResult.Success) |
|||
val (command, payload, ack) = when (source) { |
|||
0 -> Triple(0xA3, byteArrayOf(1, 0xA0.toByte(), 42), 0x23) |
|||
1 -> Triple(0xA3, byteArrayOf(2, 1, 1, 1, 1, 0x23, 1, 42), 0x23) |
|||
2 -> Triple(0xA4, byteArrayOf(0), 0x24) |
|||
else -> Triple(0xD0, byteArrayOf(0, 1, 0, 42), 0x50) |
|||
} |
|||
repeat(20) { |
|||
advanceTimeBy(500) |
|||
f.packets.emit(DctPacket(command.toByte(), payload, transportSessionId = f.sessionId)) |
|||
runCurrent() |
|||
} |
|||
assertEquals(0, f.probes()) |
|||
assertEquals(20, f.acks.size) |
|||
assertTrue(f.acks.all { it.command == ack.toByte() && it.payload.contentEquals(byteArrayOf(1)) }) |
|||
assertEquals(DeviceConnectionState.MEASURING, f.repository.connectionState.value) |
|||
f.repository.disconnect() |
|||
} |
|||
|
|||
@Test fun probeWaitsForFullSilenceFromLastPacketNotTheOriginalTimerTick() = runTest { |
|||
val f = Fixture(this) |
|||
f.connect() |
|||
advanceTimeBy(900) |
|||
f.packets.emit(DctPacket(0xA4.toByte(), byteArrayOf(0), transportSessionId = f.sessionId)) |
|||
runCurrent() |
|||
advanceTimeBy(999) |
|||
runCurrent() |
|||
assertEquals(0, f.probes()) |
|||
advanceTimeBy(1) |
|||
runCurrent() |
|||
assertEquals(1, f.probes()) |
|||
assertTrue(f.connected.value) |
|||
f.repository.disconnect() |
|||
} |
|||
|
|||
@Test fun normalControlResponsesAlsoSuppressIdleProbes() = runTest { |
|||
val f = Fixture(this) |
|||
f.connect() |
|||
repeat(8) { |
|||
advanceTimeBy(750) |
|||
f.packets.emit(DctPacket(0x85.toByte(), byteArrayOf(), transportSessionId = f.sessionId)) |
|||
runCurrent() |
|||
} |
|||
assertEquals(0, f.probes()) |
|||
assertTrue(f.acks.isEmpty()) |
|||
f.repository.disconnect() |
|||
} |
|||
|
|||
@Test fun staleSessionPacketsCannotPostponeProbeAndReconnectStartsFreshBudget() = runTest { |
|||
val f = Fixture(this) |
|||
f.connect() |
|||
advanceTimeBy(900) |
|||
f.packets.emit(DctPacket(0xA4.toByte(), byteArrayOf(0), transportSessionId = f.sessionId)) |
|||
runCurrent() |
|||
f.repository.disconnect() |
|||
f.sessionId++ |
|||
f.connected.value = true |
|||
f.connect() |
|||
val before = f.probes() |
|||
advanceTimeBy(900) |
|||
f.packets.emit(DctPacket(0xA4.toByte(), byteArrayOf(0), transportSessionId = f.sessionId - 1)) |
|||
runCurrent() |
|||
advanceTimeBy(100) |
|||
runCurrent() |
|||
assertEquals(before + 1, f.probes()) |
|||
assertEquals(1, f.acks.size) // Only the first session's real packet was acknowledged. |
|||
f.repository.disconnect() |
|||
} |
|||
} |
|||
@ -1,94 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.google.common.truth.Truth.assertThat |
|||
import com.healthmarketscience.jackcess.ColumnBuilder |
|||
import com.healthmarketscience.jackcess.CursorBuilder |
|||
import com.healthmarketscience.jackcess.DataType |
|||
import com.healthmarketscience.jackcess.Database |
|||
import com.healthmarketscience.jackcess.DatabaseBuilder |
|||
import com.healthmarketscience.jackcess.TableBuilder |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
import java.nio.charset.Charset |
|||
|
|||
class JackcessLoadUnitTest { |
|||
|
|||
@Test |
|||
@DisplayName("T1-MDB-01: Jackcess 4.0.11 MDB 생성, VarNif/VarLst 테이블 스키마 정의 및 데이터 CRUD 검증") |
|||
fun testJackcessMdbOperations(@TempDir tempDir: File) { |
|||
val mdbFile = File(tempDir, "test_dct_calibration.mdb") |
|||
|
|||
// 1. MDB 파일 생성 (V2000 포맷) |
|||
val db: Database = DatabaseBuilder.create(Database.FileFormat.V2000, mdbFile) |
|||
|
|||
assertThat(db).isNotNull() |
|||
|
|||
// 2. VarNif (신호 그룹 메타데이터) 테이블 생성 |
|||
val varNifTable = TableBuilder("VarNif") |
|||
.addColumn(ColumnBuilder("RECLID", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("IDX", DataType.TEXT).setLength(50).toColumn()) |
|||
.addColumn(ColumnBuilder("DESCRIP", DataType.TEXT).setLength(255).toColumn()) |
|||
.addColumn(ColumnBuilder("USAGE", DataType.BOOLEAN).toColumn()) |
|||
.toTable(db) |
|||
|
|||
// 3. VarLst (개별 신호 정의) 테이블 생성 |
|||
val varLstTable = TableBuilder("VarLst") |
|||
.addColumn(ColumnBuilder("RECLID", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("IDX", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("NAME", DataType.TEXT).setLength(255).toColumn()) |
|||
.addColumn(ColumnBuilder("ATTR", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("CVS_A", DataType.DOUBLE).toColumn()) |
|||
.addColumn(ColumnBuilder("CVS_B", DataType.DOUBLE).toColumn()) |
|||
.addColumn(ColumnBuilder("UNIT", DataType.TEXT).setLength(50).toColumn()) |
|||
.toTable(db) |
|||
|
|||
// 4. 데이터 추가 |
|||
varNifTable.addRow(1L, "NIF_01", "엔진_센서_그룹", true) |
|||
varLstTable.addRow(1L, 0L, "EngineRPM", 4L, 1.0, 0.0, "rpm") |
|||
varLstTable.addRow(1L, 1L, "CoolantTemp", 2L, 0.1, -40.0, "°C") |
|||
|
|||
db.flush() |
|||
db.close() |
|||
|
|||
// 5. MDB 파일 재오픈 및 데이터 검증 |
|||
val reOpenedDb = DatabaseBuilder.open(mdbFile) |
|||
|
|||
val readVarNif = reOpenedDb.getTable("VarNif") |
|||
val readVarLst = reOpenedDb.getTable("VarLst") |
|||
|
|||
assertThat(readVarNif.rowCount).isEqualTo(1) |
|||
assertThat(readVarLst.rowCount).isEqualTo(2) |
|||
|
|||
val firstNifRow = readVarNif.iterator().next() |
|||
assertThat((firstNifRow["RECLID"] as Number).toLong()).isEqualTo(1L) |
|||
assertThat(firstNifRow["DESCRIP"]).isEqualTo("엔진_센서_그룹") |
|||
|
|||
// 6. 데이터 수정 (CursorBuilder 활용) |
|||
val cursor = CursorBuilder.createCursor(readVarLst) |
|||
var updated = false |
|||
while (cursor.moveToNextRow()) { |
|||
val row = cursor.currentRow |
|||
if (row["NAME"] == "EngineRPM") { |
|||
row["UNIT"] = "RPM" |
|||
cursor.updateCurrentRowFromMap(row) |
|||
updated = true |
|||
break |
|||
} |
|||
} |
|||
assertThat(updated).isTrue() |
|||
|
|||
reOpenedDb.flush() |
|||
reOpenedDb.close() |
|||
|
|||
// 7. 수정 결과 최종 확인 |
|||
val verifiedDb = DatabaseBuilder.open(mdbFile) |
|||
|
|||
val verifiedVarLst = verifiedDb.getTable("VarLst") |
|||
val rpmRow = verifiedVarLst.iterator().asSequence().first { it["NAME"] == "EngineRPM" } |
|||
assertThat(rpmRow["UNIT"]).isEqualTo("RPM") |
|||
|
|||
verifiedDb.close() |
|||
} |
|||
} |
|||
@ -1,89 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.logger.Mf4MeasurementLogger |
|||
import com.dct.app.data.logger.PcMf4Channel |
|||
import com.dct.app.data.ringbuffer.TimeSeriesRingBuffer |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
import java.nio.ByteBuffer |
|||
import java.nio.ByteOrder |
|||
import java.util.zip.Inflater |
|||
|
|||
/** Accelerated component checks; these do not simulate radio, Doze, heat or 24 hours of wall time. */ |
|||
class LongRunMeasurementReviewTest { |
|||
@TempDir lateinit var directory: File |
|||
private val samples = 24 * 60 * 60 * 30 |
|||
|
|||
@Test fun twentyFourHoursAtThirtyHertzKeepsRingCapacityAndNewestSamples() { |
|||
val ring = TimeSeriesRingBuffer() |
|||
repeat(samples) { index -> ring.addSample(index / 30.0, index.toDouble()) } |
|||
assertEquals(100_000, ring.capacity) |
|||
assertEquals(ring.capacity, ring.size) |
|||
assertEquals((samples - ring.capacity) / 30.0, ring.getOldestTimestamp()!!, 1e-6) |
|||
assertEquals((samples - 1) / 30.0, ring.getLatestTimestamp()!!, 1e-6) |
|||
assertEquals((samples - 1).toDouble(), ring.getLatestValue()) |
|||
assertEquals((samples - ring.capacity).toDouble(), ring.getOldestValue()) |
|||
} |
|||
|
|||
@Test fun compressedMf4RetainsCountTimesAndValuesAcrossTwentyFourLogicalHours() { |
|||
val channel = PcMf4Channel("Counter", dataType = 0, bitCount = 16) |
|||
val logger = Mf4MeasurementLogger(directory, listOf("Counter" to ""), "24h.mf4", listOf(channel)) |
|||
// 23:59:59 KST: the simulated stream crosses midnight almost immediately. |
|||
val origin = java.time.Instant.parse("2026-10-28T14:59:59Z").toEpochMilli() |
|||
val file = logger.start(origin)!! |
|||
try { |
|||
repeat(samples) { index -> |
|||
logger.logRawSampleAtMillis(origin + index * 1000L / 30L, listOf(index and 0xFFFF)) |
|||
} |
|||
} finally { logger.stop() } |
|||
val bytes = file.readBytes() |
|||
val data = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN) |
|||
assertEquals(samples.toLong(), data.getLong(232 + 80)) |
|||
assertEquals(10, data.getInt(232 + 96)) // Time float64 + original uint16. |
|||
assertEquals(0, data.getShort(60).toInt()) // Finalized only after links/counts are patched. |
|||
val hl = data.getLong(168 + 40).toInt() |
|||
assertEquals("##HL", String(bytes, hl, 4)) |
|||
var dl = data.getLong(hl + 24).toInt() |
|||
var total = 0 |
|||
var chunks = 0 |
|||
var previousTime = -1.0 |
|||
while (dl != 0) { |
|||
assertTrue(++chunks < 1000, "Invalid/cyclic DL chain") |
|||
val dz = data.getLong(dl + 32).toInt() |
|||
assertEquals("##DZ", String(bytes, dz, 4)) |
|||
val rawSize = data.getLong(dz + 32).toInt() |
|||
val zipSize = data.getLong(dz + 40).toInt() |
|||
val transposed = ByteArray(rawSize) |
|||
val inflater = Inflater() |
|||
try { |
|||
inflater.setInput(bytes, dz + 48, zipSize) |
|||
var count = 0 |
|||
while (!inflater.finished() && count < rawSize) { |
|||
val n = inflater.inflate(transposed, count, rawSize - count) |
|||
assertTrue(n > 0, "Truncated compressed chunk") |
|||
count += n |
|||
} |
|||
assertTrue(inflater.finished()) |
|||
assertEquals(rawSize, count) |
|||
} finally { inflater.end() } |
|||
val rows = rawSize / 10 |
|||
for (row in listOf(0, rows - 1).distinct()) { |
|||
val timeBytes = ByteArray(8) { column -> transposed[column * rows + row] } |
|||
val time = ByteBuffer.wrap(timeBytes).order(ByteOrder.LITTLE_ENDIAN).double |
|||
assertEquals(((total + row) * 1000L / 30L) / 1000.0, time, 1e-6) |
|||
assertTrue(time >= previousTime) |
|||
previousTime = time |
|||
val raw = (transposed[8 * rows + row].toInt() and 255) or |
|||
((transposed[9 * rows + row].toInt() and 255) shl 8) |
|||
assertEquals((total + row) and 0xFFFF, raw) |
|||
} |
|||
total += rows |
|||
dl = data.getLong(dl + 24).toInt() |
|||
} |
|||
assertEquals(samples, total) |
|||
assertEquals(260, chunks) |
|||
assertEquals(86_399.966, previousTime, 1e-6) |
|||
} |
|||
} |
|||
File diff suppressed because it is too large
@ -1,100 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.data.maintenance.* |
|||
import com.dct.app.domain.model.protocol.* |
|||
import com.dct.app.domain.repository.* |
|||
import io.mockk.* |
|||
import kotlinx.coroutines.async |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import kotlinx.coroutines.test.runTest |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class MaintenanceServiceTest { |
|||
@Test fun didReadChecksStatusAndEchoedAddress() = runTest { |
|||
val repo = mockk<PacketRepository>() |
|||
every { repo.connectionState } returns MutableStateFlow(DeviceConnectionState.READY) |
|||
coEvery { repo.sendCommand(any()) } returns DctResult.Success(DctPacket.create(DctCommand.RES_REQ_DID_INFO, byteArrayOf(-15,-121,1,2,65,66))) |
|||
val service = MaintenanceService(repo) |
|||
assertArrayEquals(byteArrayOf(65,66), service.readDid(0xF187)) |
|||
assertTrue(runCatching { service.readDid(0xF191) }.isFailure) |
|||
coEvery { repo.sendCommand(any()) } returns DctResult.Success(DctPacket.create(DctCommand.RES_REQ_DID_INFO, byteArrayOf(-15,-121,2,0))) |
|||
assertTrue(runCatching { service.readDid(0xF187) }.isFailure) |
|||
} |
|||
@Test fun maintenanceNeverSendsWhileMeasuring() = runTest { |
|||
val repo = mockk<PacketRepository>() |
|||
every { repo.connectionState } returns MutableStateFlow(DeviceConnectionState.MEASURING) |
|||
assertTrue(runCatching { MaintenanceService(repo).deleteDatabase(0) }.isFailure) |
|||
coVerify(exactly = 0) { repo.sendCommand(any()) } |
|||
} |
|||
@Test fun databaseListValidatesIndexAndLength() = runTest { |
|||
val repo = mockk<PacketRepository>() |
|||
every { repo.connectionState } returns MutableStateFlow(DeviceConnectionState.READY) |
|||
coEvery { repo.sendCommand(any()) } coAnswers { |
|||
val request = firstArg<DctPacket>() |
|||
DctResult.Success(DctPacket.create(DctCommand.RES_DB, |
|||
if (request.payload[0] == 1.toByte()) byteArrayOf(1,1,1) else byteArrayOf(2,1,0,2,65,66))) |
|||
} |
|||
assertEquals(listOf("AB"), MaintenanceService(repo).listDatabases()) |
|||
coEvery { repo.sendCommand(match { it.payload[0] == 2.toByte() }) } returns DctResult.Success(DctPacket.create(DctCommand.RES_DB, byteArrayOf(2,1,8,2,65,66))) |
|||
assertTrue(runCatching { MaintenanceService(repo).listDatabases() }.isFailure) |
|||
} |
|||
|
|||
@Test fun removeFirmwareValidatesSlotAndHandlesSuccessAndRejection() = runTest { |
|||
val repo = mockk<PacketRepository>() |
|||
every { repo.connectionState } returns MutableStateFlow(DeviceConnectionState.READY) |
|||
coEvery { repo.sendCommand(match { it.payload[0] == 0x06.toByte() && it.payload[1] == 1.toByte() }) } returns |
|||
DctResult.Success(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x06, 0x01))) |
|||
|
|||
val service = MaintenanceService(repo) |
|||
val successResult = service.removeFirmware(1) |
|||
assertTrue(successResult.isSuccess) |
|||
|
|||
// 단말 거절 (0x02) |
|||
coEvery { repo.sendCommand(match { it.payload[0] == 0x06.toByte() && it.payload[1] == 2.toByte() }) } returns |
|||
DctResult.Success(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x06, 0x02))) |
|||
val rejectedResult = service.removeFirmware(2) |
|||
assertTrue(rejectedResult.isFailure) |
|||
|
|||
// 슬롯 인덱스 범위 초과 |
|||
assertTrue(service.removeFirmware(-1).isFailure) |
|||
assertTrue(service.removeFirmware(256).isFailure) |
|||
} |
|||
|
|||
@Test fun triggerFirmwareUpdateHandlesProgressAndCompletion() = runTest { |
|||
val repo = mockk<PacketRepository>() |
|||
every { repo.connectionState } returns MutableStateFlow(DeviceConnectionState.READY) |
|||
val packetStream = kotlinx.coroutines.flow.MutableSharedFlow<DctPacket>(replay = 10, extraBufferCapacity = 10) |
|||
every { repo.packetStream } returns packetStream |
|||
|
|||
// 0x07 트리거 성공 응답 |
|||
coEvery { repo.sendCommand(match { it.payload[0] == 0x07.toByte() }) } returns |
|||
DctResult.Success(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x07, 0x01))) |
|||
|
|||
// 0x08 ACK 송신 모킹 |
|||
coEvery { repo.sendCommand(match { it.payload[0] == 0x08.toByte() }) } returns |
|||
DctResult.Success(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x08, 0x01))) |
|||
|
|||
val service = MaintenanceService(repo) |
|||
|
|||
val updateJob = async { |
|||
service.triggerFirmwareUpdate(0) |
|||
} |
|||
|
|||
// 진행 패킷 방출 (50%) |
|||
packetStream.emit(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x08, 0x01, 50))) |
|||
// 완료 패킷 방출 |
|||
packetStream.emit(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x08, 0x02))) |
|||
|
|||
val result = updateJob.await() |
|||
assertTrue(result.isSuccess) |
|||
assertEquals(100L, service.transferProgress.value.transferredBytes) |
|||
assertFalse(service.transferProgress.value.isRunning) |
|||
|
|||
// 0x07 시작 거절 시 실패 검증 |
|||
coEvery { repo.sendCommand(match { it.payload[0] == 0x07.toByte() }) } returns |
|||
DctResult.Success(DctPacket.create(DctCommand.RES_FW_INFO, byteArrayOf(0x07, 0x02))) |
|||
assertTrue(service.triggerFirmwareUpdate(0).isFailure) |
|||
} |
|||
} |
|||
@ -1,127 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.protocol.MdbRecordDecoder |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import org.junit.jupiter.api.Assertions.assertEquals |
|||
import org.junit.jupiter.api.Assertions.assertTrue |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@DisplayName("MdbRecordDecoder - uint32_t 인덱스(256 이상) 지원 및 디코딩 무결성 단위 테스트") |
|||
class MdbRecordDecoderTest { |
|||
|
|||
@Test |
|||
@DisplayName("[ISSUE-R2-05] 256 이상의 신호 Index(0x0100, 0x0200)가 0xFF 마스킹으로 오인되지 않고 정상 디코딩되어야 한다") |
|||
fun testSignalIndexAbove255WithoutMasking() { |
|||
// idx = 0과 idx = 256은 0xFF 마스킹 시 둘 다 0이 되어 과거에는 중복 실패했으나, |
|||
// 마스킹 제거 후에는 서로 다른 uint32_t 인덱스로 정상 인식되어야 함 |
|||
val sigA = SignalDefinition( |
|||
reclid = 10, |
|||
idx = 0, |
|||
name = "Signal_0", |
|||
attr = MdbAttrType.ATTR_0_UINT8, |
|||
cvsA = 1.0, |
|||
cvsB = 0.0, |
|||
unit = "", |
|||
color = 0L, |
|||
min = 0.0, |
|||
max = 255.0, |
|||
arrayIndex = 0 |
|||
) |
|||
val sigB = SignalDefinition( |
|||
reclid = 10, |
|||
idx = 256, // 0x0100: 과거에는 256 and 0xFF == 0 으로 sigA와 중복 판정됨 |
|||
name = "Signal_256", |
|||
attr = MdbAttrType.ATTR_2_UINT16, |
|||
cvsA = 0.5, |
|||
cvsB = 10.0, |
|||
unit = "rpm", |
|||
color = 0L, |
|||
min = 0.0, |
|||
max = 32767.0, |
|||
arrayIndex = 1 |
|||
) |
|||
val sigC = SignalDefinition( |
|||
reclid = 10, |
|||
idx = 512, // 0x0200: 512 and 0xFF == 0 |
|||
name = "Signal_512", |
|||
attr = MdbAttrType.ATTR_4_UINT32, |
|||
cvsA = 0.1, |
|||
cvsB = 0.0, |
|||
unit = "km/h", |
|||
color = 0L, |
|||
min = 0.0, |
|||
max = 100000.0, |
|||
arrayIndex = 3 |
|||
) |
|||
|
|||
val definitions = listOf(sigA, sigB, sigC) |
|||
// 페이로드 데이터: |
|||
// [0]: 0x55 (85) |
|||
// [1..2]: 0x03, 0xE8 (1000) |
|||
// [3..6]: 0x00, 0x01, 0x86, 0xA0 (100000) |
|||
val payload = byteArrayOf( |
|||
0x55.toByte(), |
|||
0x03.toByte(), 0xE8.toByte(), |
|||
0x00.toByte(), 0x01.toByte(), 0x86.toByte(), 0xA0.toByte() |
|||
) |
|||
|
|||
val result = MdbRecordDecoder.decode(10, payload, definitions) |
|||
assertTrue(result is MdbRecordDecoder.DecodeResult.Success, "256 이상 인덱스가 중복 에러 없이 정상 디코딩되어야 합니다.") |
|||
|
|||
val success = result as MdbRecordDecoder.DecodeResult.Success |
|||
assertEquals(3, success.signals.size) |
|||
|
|||
// sigA 검증 |
|||
assertEquals("Signal_0", success.signals[0].definition.name) |
|||
assertEquals(85, success.signals[0].rawValue.toInt()) |
|||
assertEquals(85.0, success.signals[0].physicalValue) |
|||
|
|||
// sigB 검증 (1000 * 0.5 + 10.0 = 510.0) |
|||
assertEquals("Signal_256", success.signals[1].definition.name) |
|||
assertEquals(1000, success.signals[1].rawValue.toInt()) |
|||
assertEquals(510.0, success.signals[1].physicalValue) |
|||
|
|||
// sigC 검증 (100000 * 0.1 = 10000.0) |
|||
assertEquals("Signal_512", success.signals[2].definition.name) |
|||
assertEquals(100000L, success.signals[2].rawValue.toLong()) |
|||
assertEquals(10000.0, success.signals[2].physicalValue) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("동일한 실제 Index(예: 300과 300)가 존재하는 경우에는 중복 에러로 실패해야 한다") |
|||
fun testDuplicateActualIndexFails() { |
|||
val sig1 = SignalDefinition( |
|||
reclid = 5, |
|||
idx = 300, |
|||
name = "Sig1", |
|||
attr = MdbAttrType.ATTR_0_UINT8, |
|||
cvsA = 1.0, |
|||
cvsB = 0.0, |
|||
unit = "", |
|||
color = 0L, |
|||
min = 0.0, |
|||
max = 255.0, |
|||
arrayIndex = 0 |
|||
) |
|||
val sig2 = SignalDefinition( |
|||
reclid = 5, |
|||
idx = 300, // 실제 인덱스 중복 |
|||
name = "Sig2", |
|||
attr = MdbAttrType.ATTR_0_UINT8, |
|||
cvsA = 1.0, |
|||
cvsB = 0.0, |
|||
unit = "", |
|||
color = 0L, |
|||
min = 0.0, |
|||
max = 255.0, |
|||
arrayIndex = 1 |
|||
) |
|||
|
|||
val result = MdbRecordDecoder.decode(5, byteArrayOf(0x01, 0x02), listOf(sig1, sig2)) |
|||
assertTrue(result is MdbRecordDecoder.DecodeResult.Failure) |
|||
val failure = result as MdbRecordDecoder.DecodeResult.Failure |
|||
assertTrue(failure.reason.contains("Index가 중복됩니다")) |
|||
} |
|||
} |
|||
@ -1,253 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.google.common.truth.Truth.assertThat |
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.core.common.DispatcherProvider |
|||
import com.dct.app.data.mdb.VirtualMdbGenerator |
|||
import com.dct.app.data.repository.MdbRepositoryImpl |
|||
import com.dct.app.domain.model.mdb.MapPoint |
|||
import com.dct.app.domain.usecase.* |
|||
import kotlinx.coroutines.CoroutineDispatcher |
|||
import kotlinx.coroutines.ExperimentalCoroutinesApi |
|||
import kotlinx.coroutines.test.StandardTestDispatcher |
|||
import kotlinx.coroutines.test.runTest |
|||
import org.junit.jupiter.api.AfterEach |
|||
import org.junit.jupiter.api.BeforeEach |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.ByteArrayInputStream |
|||
import java.io.ByteArrayOutputStream |
|||
import java.io.File |
|||
|
|||
@OptIn(ExperimentalCoroutinesApi::class) |
|||
@DisplayName("M3 MdbRepository & UseCase CRUD 및 영속성 통합 검증") |
|||
class MdbRepositoryCrudTest { |
|||
|
|||
@TempDir |
|||
lateinit var tempDir: File |
|||
|
|||
private val testDispatcher = StandardTestDispatcher() |
|||
private val testDispatchers = object : DispatcherProvider { |
|||
override val main: CoroutineDispatcher = testDispatcher |
|||
override val mainImmediate: CoroutineDispatcher = testDispatcher |
|||
override val io: CoroutineDispatcher = testDispatcher |
|||
override val default: CoroutineDispatcher = testDispatcher |
|||
override val unconfined: CoroutineDispatcher = testDispatcher |
|||
} |
|||
|
|||
private lateinit var repository: MdbRepositoryImpl |
|||
|
|||
// UseCases |
|||
private lateinit var getMdbDatabaseUseCase: GetMdbDatabaseUseCase |
|||
private lateinit var updateConstantUseCase: UpdateConstantUseCase |
|||
private lateinit var updateCompensationMapUseCase: UpdateCompensationMapUseCase |
|||
private lateinit var saveMdbUseCase: SaveMdbUseCase |
|||
private lateinit var createStandardSampleMdbUseCase: CreateStandardSampleMdbUseCase |
|||
|
|||
@BeforeEach |
|||
fun setUp() { |
|||
repository = MdbRepositoryImpl(testDispatchers) |
|||
getMdbDatabaseUseCase = GetMdbDatabaseUseCase(repository) |
|||
updateConstantUseCase = UpdateConstantUseCase(repository) |
|||
updateCompensationMapUseCase = UpdateCompensationMapUseCase(repository) |
|||
saveMdbUseCase = SaveMdbUseCase(repository) |
|||
createStandardSampleMdbUseCase = CreateStandardSampleMdbUseCase(repository) |
|||
} |
|||
|
|||
@AfterEach |
|||
fun tearDown() { |
|||
repository.close() |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 1. File 및 InputStream 기반 로드 검증 |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("표준 MDB 파일 로드 및 도메인 객체 트리 구성 검증") |
|||
fun testLoadMdbFromFile() = runTest(testDispatcher) { |
|||
val mdbFile = File(tempDir, "test_load.mdb") |
|||
VirtualMdbGenerator.createStandardDatabase(mdbFile).close() |
|||
|
|||
val result = getMdbDatabaseUseCase(mdbFile) |
|||
assertThat(result).isInstanceOf(DctResult.Success::class.java) |
|||
|
|||
val db = (result as DctResult.Success).data |
|||
assertThat(db.groups).hasSize(3) |
|||
assertThat(db.constants).hasSize(4) |
|||
assertThat(db.compensationMaps).hasSize(2) |
|||
|
|||
assertThat(repository.getCurrentDatabase()).isEqualTo(db) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("InputStream으로부터 MDB 로드 및 도메인 객체 변환 검증") |
|||
fun testLoadMdbFromInputStream() = runTest(testDispatcher) { |
|||
val outStream = ByteArrayOutputStream() |
|||
VirtualMdbGenerator.createStandardDatabase(outStream) |
|||
val inStream = ByteArrayInputStream(outStream.toByteArray()) |
|||
|
|||
val result = getMdbDatabaseUseCase(inStream) |
|||
assertThat(result).isInstanceOf(DctResult.Success::class.java) |
|||
|
|||
val db = (result as DctResult.Success).data |
|||
assertThat(db.groups).hasSize(3) |
|||
assertThat(db.allSignals).hasSize(10) |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 2. ConLst 상수 CRUD 검증 |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("ConLst 상수 값(Target_RPM 850 -> 920.0) 및 설명 수정 영속성 검증") |
|||
fun testUpdateConstantAndPersistence() = runTest(testDispatcher) { |
|||
val mdbFile = File(tempDir, "test_const.mdb") |
|||
VirtualMdbGenerator.createStandardDatabase(mdbFile).close() |
|||
|
|||
getMdbDatabaseUseCase(mdbFile) |
|||
|
|||
// 1. 상수 값 수정 |
|||
val updateRes = updateConstantUseCase("Target_RPM", 920.0, "변경된 목표 RPM") |
|||
assertThat(updateRes).isInstanceOf(DctResult.Success::class.java) |
|||
|
|||
val updatedDb = repository.getCurrentDatabase() |
|||
val constItem = updatedDb?.findConstant("Target_RPM") |
|||
assertThat(constItem?.data).isEqualTo(920.0) |
|||
assertThat(constItem?.description).isEqualTo("변경된 목표 RPM") |
|||
|
|||
// 2. 다른 상수 TCRmin 수정 |
|||
val tcrRes = updateConstantUseCase("TCRmin", 25.0) |
|||
assertThat(tcrRes).isInstanceOf(DctResult.Success::class.java) |
|||
assertThat(repository.getCurrentDatabase()?.findConstant("TCRmin")?.data).isEqualTo(25.0) |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 3. 1D 보정 맵 포인트 및 메타데이터 수정 검증 |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("1D 보정 맵 포인트 일괄 수정 및 영속화 검증") |
|||
fun testUpdateCompensationMapPoints() = runTest(testDispatcher) { |
|||
val mdbFile = File(tempDir, "test_comp_points.mdb") |
|||
VirtualMdbGenerator.createStandardDatabase(mdbFile).close() |
|||
|
|||
getMdbDatabaseUseCase(mdbFile) |
|||
|
|||
val newPoints = listOf( |
|||
MapPoint(idx = 0, bkp = 600, data = 130, phy = 1.30), |
|||
MapPoint(idx = 1, bkp = 1200, data = 115, phy = 1.15), |
|||
MapPoint(idx = 2, bkp = 2200, data = 102, phy = 1.02), |
|||
MapPoint(idx = 3, bkp = 3200, data = 98, phy = 0.98), |
|||
MapPoint(idx = 4, bkp = 4200, data = 91, phy = 0.91) |
|||
) |
|||
|
|||
val updateRes = updateCompensationMapUseCase("MAP_COOLANT_TEMP_COMP", newPoints) |
|||
assertThat(updateRes).isInstanceOf(DctResult.Success::class.java) |
|||
|
|||
val map = repository.getCurrentDatabase()?.findCompensationMap("MAP_COOLANT_TEMP_COMP") |
|||
assertThat(map).isNotNull() |
|||
assertThat(map?.points).hasSize(5) |
|||
assertThat(map?.points?.get(0)?.bkp).isEqualTo(600) |
|||
assertThat(map?.points?.get(0)?.data).isEqualTo(130) |
|||
assertThat(map?.points?.get(0)?.phy).isEqualTo(1.30) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("1D 보정 맵 메타데이터(YMIN, YMAX, CVS_A, CVS_B, 설명) 수정 검증") |
|||
fun testUpdateCompensationMetadata() = runTest(testDispatcher) { |
|||
val mdbFile = File(tempDir, "test_comp_meta.mdb") |
|||
VirtualMdbGenerator.createStandardDatabase(mdbFile).close() |
|||
|
|||
getMdbDatabaseUseCase(mdbFile) |
|||
|
|||
val metaRes = updateCompensationMapUseCase.updateMetadata( |
|||
isTypeA = true, |
|||
yName = "MAP_COOLANT_TEMP_COMP", |
|||
min = -50.0, |
|||
max = 160.0, |
|||
cvsA = 1.5, |
|||
cvsB = -10.0, |
|||
description = "수정된 냉각수 보정 맵" |
|||
) |
|||
assertThat(metaRes).isInstanceOf(DctResult.Success::class.java) |
|||
|
|||
val map = repository.getCurrentDatabase()?.findCompensationMap("MAP_COOLANT_TEMP_COMP") |
|||
assertThat(map).isNotNull() |
|||
assertThat(map?.yMin).isEqualTo(-50.0) |
|||
assertThat(map?.yMax).isEqualTo(160.0) |
|||
assertThat(map?.cvsA).isEqualTo(1.5) |
|||
assertThat(map?.cvsB).isEqualTo(-10.0) |
|||
assertThat(map?.description).isEqualTo("수정된 냉각수 보정 맵") |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 4. SaveMdb 및 OutputStream 내보내기 검증 |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("수정된 MDB 데이터베이스 OutputStream 내보내기 및 재로드 검증") |
|||
fun testSaveMdbToOutputStream() = runTest(testDispatcher) { |
|||
val mdbFile = File(tempDir, "test_export_src.mdb") |
|||
VirtualMdbGenerator.createStandardDatabase(mdbFile).close() |
|||
|
|||
getMdbDatabaseUseCase(mdbFile) |
|||
updateConstantUseCase("Target_RPM", 999.0) |
|||
|
|||
val currentDb = repository.getCurrentDatabase()!! |
|||
val exportedStream = ByteArrayOutputStream() |
|||
|
|||
val saveRes = saveMdbUseCase(currentDb, exportedStream) |
|||
assertThat(saveRes).isInstanceOf(DctResult.Success::class.java) |
|||
|
|||
// 내보낸 바이트 스트림을 새 레포지토리에 로드하여 수정값 보존 확인 |
|||
val verifyRepo = MdbRepositoryImpl(testDispatchers) |
|||
val verifyRes = verifyRepo.loadMdb(ByteArrayInputStream(exportedStream.toByteArray())) |
|||
assertThat(verifyRes).isInstanceOf(DctResult.Success::class.java) |
|||
|
|||
val reloadedDb = (verifyRes as DctResult.Success).data |
|||
assertThat(reloadedDb.findConstant("Target_RPM")?.data).isEqualTo(999.0) |
|||
verifyRepo.close() |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 5. 표준 샘플 MDB 생성 유스케이스 검증 |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("CreateStandardSampleMdbUseCase 파일 및 스트림 생성 검증") |
|||
fun testCreateStandardSampleDatabaseUseCase() = runTest(testDispatcher) { |
|||
// 1. File 대상 생성 |
|||
val targetFile = File(tempDir, "standard_created.mdb") |
|||
val fileRes = createStandardSampleMdbUseCase(targetFile) |
|||
assertThat(fileRes).isInstanceOf(DctResult.Success::class.java) |
|||
|
|||
val db = (fileRes as DctResult.Success).data |
|||
assertThat(db.groups).hasSize(3) |
|||
assertThat(targetFile.exists()).isTrue() |
|||
assertThat(targetFile.length()).isGreaterThan(0L) |
|||
|
|||
// 2. OutputStream 대상 생성 |
|||
val stream = ByteArrayOutputStream() |
|||
val streamRes = createStandardSampleMdbUseCase(stream) |
|||
assertThat(streamRes).isInstanceOf(DctResult.Success::class.java) |
|||
assertThat(stream.size()).isGreaterThan(0) |
|||
} |
|||
|
|||
// ========================================================================= |
|||
// 6. 에러 및 비정상 입력 방어 검증 |
|||
// ========================================================================= |
|||
|
|||
@Test |
|||
@DisplayName("존재하지 않는 파일 및 손상된 바이트 로드 시 DctResult.Failure 반환 검증") |
|||
fun testErrorHandlingNonExistentAndCorruptFiles() = runTest(testDispatcher) { |
|||
val nonExistentFile = File(tempDir, "ghost.mdb") |
|||
val ghostRes = getMdbDatabaseUseCase(nonExistentFile) |
|||
assertThat(ghostRes).isInstanceOf(DctResult.Failure::class.java) |
|||
|
|||
val corruptStream = ByteArrayInputStream(byteArrayOf(0x00, 0x01, 0x02, 0x03)) |
|||
val corruptRes = getMdbDatabaseUseCase(corruptStream) |
|||
assertThat(corruptRes).isInstanceOf(DctResult.Failure::class.java) |
|||
} |
|||
} |
|||
@ -1,246 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.google.common.truth.Truth.assertThat |
|||
import com.healthmarketscience.jackcess.* |
|||
import com.dct.app.data.mdb.MdbSchemaParser |
|||
import com.dct.app.data.mdb.VirtualMdbGenerator |
|||
import com.dct.app.domain.model.mdb.CompensationMapType |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
|
|||
@DisplayName("M3 MdbSchemaParser: C++ LibDB.cpp 스키마 파싱 및 오프셋 계산 검증") |
|||
class MdbSchemaParserTest { |
|||
|
|||
@Test |
|||
@DisplayName("표준 가상 MDB 파싱: VarNif, VarLst, ConLst, Tb1Dm*, [YNAME] 전수 정합성 검증") |
|||
fun testParseStandardVirtualMdb(@TempDir tempDir: File) { |
|||
val targetFile = File(tempDir, "standard_test.mdb") |
|||
val db = VirtualMdbGenerator.createStandardDatabase(targetFile) |
|||
|
|||
val parsed = MdbSchemaParser.parseDatabase(db, targetFile.name) |
|||
db.close() |
|||
|
|||
assertThat(parsed.fileName).isEqualTo("standard_test.mdb") |
|||
|
|||
// 1. VarNif 그룹 검증 |
|||
assertThat(parsed.groups).hasSize(3) |
|||
val g1 = parsed.groups[0] |
|||
assertThat(g1.reclid).isEqualTo(1) |
|||
assertThat(g1.description).isEqualTo("Engine_Sensors") |
|||
assertThat(g1.startIndex).isEqualTo(0) |
|||
assertThat(g1.itemCount).isEqualTo(4) |
|||
|
|||
val g2 = parsed.groups[1] |
|||
assertThat(g2.reclid).isEqualTo(2) |
|||
assertThat(g2.description).isEqualTo("Transmission_Sensors") |
|||
assertThat(g2.itemCount).isEqualTo(3) |
|||
|
|||
val g3 = parsed.groups[2] |
|||
assertThat(g3.reclid).isEqualTo(3) |
|||
assertThat(g3.description).isEqualTo("Climate_Control") |
|||
assertThat(g3.itemCount).isEqualTo(3) |
|||
|
|||
// 2. CalculateVarLstItemIndex 오프셋 누적 검증 |
|||
// Group 1 신호 오프셋 검증: |
|||
// Sig0: EngineRPM (ATTR 4 -> size 4) => arrayIndex 0 |
|||
// Sig1: CoolantTemp (ATTR 2 -> size 2) => arrayIndex 4 |
|||
// Sig2: ThrottlePos (ATTR 0 -> size 1) => arrayIndex 6 |
|||
// Sig3: IntakePressure (ATTR 2 -> size 2) => arrayIndex 7 |
|||
assertThat(g1.signals).hasSize(4) |
|||
val rpmSig = g1.signals[0] |
|||
assertThat(rpmSig.name).isEqualTo("EngineRPM") |
|||
assertThat(rpmSig.attr).isEqualTo(MdbAttrType.ATTR_4_UINT32) |
|||
assertThat(rpmSig.itemSize).isEqualTo(4) |
|||
assertThat(rpmSig.arrayIndex).isEqualTo(0) |
|||
|
|||
val tempSig = g1.signals[1] |
|||
assertThat(tempSig.name).isEqualTo("CoolantTemp") |
|||
assertThat(tempSig.attr).isEqualTo(MdbAttrType.ATTR_2_UINT16) |
|||
assertThat(tempSig.itemSize).isEqualTo(2) |
|||
assertThat(tempSig.arrayIndex).isEqualTo(4) |
|||
|
|||
val throttleSig = g1.signals[2] |
|||
assertThat(throttleSig.name).isEqualTo("ThrottlePos") |
|||
assertThat(throttleSig.attr).isEqualTo(MdbAttrType.ATTR_0_UINT8) |
|||
assertThat(throttleSig.itemSize).isEqualTo(1) |
|||
assertThat(throttleSig.arrayIndex).isEqualTo(6) |
|||
|
|||
val pressureSig = g1.signals[3] |
|||
assertThat(pressureSig.name).isEqualTo("IntakePressure") |
|||
assertThat(pressureSig.attr).isEqualTo(MdbAttrType.ATTR_2_UINT16) |
|||
assertThat(pressureSig.itemSize).isEqualTo(2) |
|||
assertThat(pressureSig.arrayIndex).isEqualTo(7) |
|||
|
|||
// Group 2 신호 오프셋 검증: |
|||
// Sig0: VehicleSpeed (ATTR 2 -> size 2) => arrayIndex 0 |
|||
// Sig1: ClutchPressure (ATTR 2 -> size 2) => arrayIndex 2 |
|||
// Sig2: GearPosition (ATTR 1 -> size 1) => arrayIndex 4 |
|||
assertThat(g2.signals).hasSize(3) |
|||
assertThat(g2.signals[0].arrayIndex).isEqualTo(0) |
|||
assertThat(g2.signals[1].arrayIndex).isEqualTo(2) |
|||
assertThat(g2.signals[2].arrayIndex).isEqualTo(4) |
|||
|
|||
// 3. ConLst 상수 검증 |
|||
assertThat(parsed.constants).hasSize(4) |
|||
val tcr = parsed.findConstant("TCRmin") |
|||
assertThat(tcr).isNotNull() |
|||
assertThat(tcr?.data).isEqualTo(10.0) |
|||
assertThat(tcr?.addr).isEqualTo(0x1000L) |
|||
assertThat(tcr?.attr).isEqualTo(MdbAttrType.ATTR_2_UINT16) |
|||
|
|||
val targetRpm = parsed.findConstant("Target_RPM") |
|||
assertThat(targetRpm).isNotNull() |
|||
assertThat(targetRpm?.data).isEqualTo(850.0) |
|||
assertThat(targetRpm?.min).isEqualTo(500.0) |
|||
assertThat(targetRpm?.max).isEqualTo(6000.0) |
|||
|
|||
// 4. CompensationMap Type A & Type B 검증 |
|||
assertThat(parsed.compensationMaps).hasSize(2) |
|||
|
|||
val typeAMap = parsed.findCompensationMap("MAP_COOLANT_TEMP_COMP") |
|||
assertThat(typeAMap).isNotNull() |
|||
assertThat(typeAMap?.type).isEqualTo(CompensationMapType.TYPE_A) |
|||
assertThat(typeAMap?.isTypeA).isTrue() |
|||
assertThat(typeAMap?.xName).isEqualTo("ENGINE_SPEED") |
|||
assertThat(typeAMap?.points).hasSize(5) |
|||
assertThat(typeAMap?.points?.get(0)?.bkp).isEqualTo(500) |
|||
assertThat(typeAMap?.points?.get(0)?.phy).isEqualTo(1.20) |
|||
|
|||
val typeBMap = parsed.findCompensationMap("CURVE_BLOWER_PWM") |
|||
assertThat(typeBMap).isNotNull() |
|||
assertThat(typeBMap?.type).isEqualTo(CompensationMapType.TYPE_B) |
|||
assertThat(typeBMap?.isTypeB).isTrue() |
|||
assertThat(typeBMap?.xName).isEqualTo("CABIN_TEMP_DIFF") |
|||
assertThat(typeBMap?.points).hasSize(4) |
|||
assertThat(typeBMap?.points?.get(3)?.bkp).isEqualTo(15) |
|||
assertThat(typeBMap?.points?.get(3)?.phy).isEqualTo(100.0) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("VarNif 부재 시 VarLst의 RECLID 기반 자동 그룹 생성 검증") |
|||
fun testFallbackWhenVarNifMissing(@TempDir tempDir: File) { |
|||
val targetFile = File(tempDir, "varnif_missing.mdb") |
|||
val db = DatabaseBuilder.create(Database.FileFormat.V2000, targetFile) |
|||
|
|||
// VarLst 테이블만 단독 생성 |
|||
val tbVarLst = TableBuilder("VarLst") |
|||
.addColumn(ColumnBuilder("RECLID", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("IDX", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("NAME", DataType.TEXT).setLength(255).toColumn()) |
|||
.addColumn(ColumnBuilder("ATTR", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("CVS_A", DataType.DOUBLE).toColumn()) |
|||
.addColumn(ColumnBuilder("CVS_B", DataType.DOUBLE).toColumn()) |
|||
.toTable(db) |
|||
|
|||
tbVarLst.addRow(10L, 0L, "SensorA", 2L, 1.0, 0.0) |
|||
tbVarLst.addRow(10L, 1L, "SensorB", 4L, 1.0, 0.0) |
|||
tbVarLst.addRow(20L, 0L, "SensorC", 0L, 1.0, 0.0) |
|||
db.flush() |
|||
|
|||
val parsed = MdbSchemaParser.parseDatabase(db, targetFile.name) |
|||
db.close() |
|||
|
|||
assertThat(parsed.groups).hasSize(2) |
|||
assertThat(parsed.groups[0].reclid).isEqualTo(10) |
|||
assertThat(parsed.groups[0].signals).hasSize(2) |
|||
assertThat(parsed.groups[0].signals[0].arrayIndex).isEqualTo(0) |
|||
assertThat(parsed.groups[0].signals[1].arrayIndex).isEqualTo(2) |
|||
|
|||
assertThat(parsed.groups[1].reclid).isEqualTo(20) |
|||
assertThat(parsed.groups[1].signals).hasSize(1) |
|||
assertThat(parsed.groups[1].signals[0].arrayIndex).isEqualTo(0) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("포인트 테이블의 ID 컬럼명(IDX vs ID) 및 DESCRIPTION 컬럼 누락 방어 검증") |
|||
fun testPointTableColumnNameVariantsAndMissingDescription(@TempDir tempDir: File) { |
|||
val targetFile = File(tempDir, "variants.mdb") |
|||
val db = DatabaseBuilder.create(Database.FileFormat.V2000, targetFile) |
|||
|
|||
// Tb1DmPxDyLst (DESCRIPTION 컬럼 없음) |
|||
val tbPxDy = TableBuilder("Tb1DmPxDyLst") |
|||
.addColumn(ColumnBuilder("IDX", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("YNAME", DataType.TEXT).setLength(50).toColumn()) |
|||
.addColumn(ColumnBuilder("YADDR", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("YATTR", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("YMIN", DataType.DOUBLE).toColumn()) |
|||
.addColumn(ColumnBuilder("YMAX", DataType.DOUBLE).toColumn()) |
|||
.addColumn(ColumnBuilder("XNAME", DataType.TEXT).setLength(50).toColumn()) |
|||
.addColumn(ColumnBuilder("XADDR", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("XATTR", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("CVS_A", DataType.DOUBLE).toColumn()) |
|||
.addColumn(ColumnBuilder("CVS_B", DataType.DOUBLE).toColumn()) |
|||
.toTable(db) |
|||
|
|||
tbPxDy.addRow(0L, "MAP_CUSTOM", 0x1000L, 2L, 0.0, 100.0, "MAP_X", 0x2000L, 2L, 1.0, 0.0) |
|||
|
|||
// MAP_CUSTOM 테이블 (첫 컬럼명이 ID) |
|||
val tbMap = TableBuilder("MAP_CUSTOM") |
|||
.addColumn(ColumnBuilder("ID", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("BKP", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("DATA", DataType.LONG).toColumn()) |
|||
.addColumn(ColumnBuilder("PHY", DataType.DOUBLE).toColumn()) |
|||
.toTable(db) |
|||
|
|||
tbMap.addRow(1L, 100L, 10L, 1.0) |
|||
tbMap.addRow(2L, 200L, 20L, 2.0) |
|||
db.flush() |
|||
|
|||
val parsed = MdbSchemaParser.parseDatabase(db, targetFile.name) |
|||
db.close() |
|||
|
|||
val map = parsed.findCompensationMap("MAP_CUSTOM") |
|||
assertThat(map).isNotNull() |
|||
assertThat(map?.points).hasSize(2) |
|||
assertThat(map?.points?.get(0)?.idx).isEqualTo(1) |
|||
assertThat(map?.points?.get(0)?.bkp).isEqualTo(100) |
|||
} |
|||
|
|||
@Test |
|||
fun testInspectRealMdbAndDbc() { |
|||
val mdbFile = File("C:/Users/COMPUTER1/.gemini/antigravity/brain/8a1b68ca-0b32-4fa8-acae-6f6d866f992b/test_sample.mdb") |
|||
if (mdbFile.exists()) { |
|||
val db = DatabaseBuilder.open(mdbFile) |
|||
println("=== MDB TABLES: ${db.tableNames} ===") |
|||
val varLst = db.getTable("VarLst") |
|||
if (varLst != null) { |
|||
println("=== VarLst COLUMNS: ${varLst.columns.map { it.name }} ===") |
|||
var count = 0 |
|||
for (row in varLst) { |
|||
if (count++ < 15) { |
|||
val name = row.get("NAME") |
|||
val color = row.get("COLOR") |
|||
val desc = row.get("DESCRIPTION") |
|||
val descrip = row.get("DESCRIP") |
|||
val reclid = row.get("RECLID") |
|||
val idx = row.get("IDX") |
|||
println("MDB VarLst Sig: name=$name, reclid=$reclid, idx=$idx, COLOR=$color (0x${java.lang.Long.toHexString((color as? Number)?.toLong() ?: 0L)}), desc=$desc, descrip=$descrip") |
|||
} |
|||
} |
|||
} |
|||
val varNif = db.getTable("VarNif") |
|||
if (varNif != null) { |
|||
println("=== VarNif COLUMNS: ${varNif.columns.map { it.name }} ===") |
|||
for (row in varNif) { |
|||
println("VarNif Row: RECLID=${row.get("RECLID")}, IDX=${row.get("IDX")}, DESCRIP=${row.get("DESCRIP")}") |
|||
} |
|||
} |
|||
db.close() |
|||
} |
|||
|
|||
val dbcFile = File("C:/Users/COMPUTER1/.gemini/antigravity/brain/8a1b68ca-0b32-4fa8-acae-6f6d866f992b/test_sample.dbc") |
|||
if (dbcFile.exists()) { |
|||
dbcFile.inputStream().use { stream -> |
|||
val signals = com.dct.app.data.parser.CanDbcParser.parseDbc(stream) |
|||
println("=== DBC SIGNALS COUNT: ${signals.size} ===") |
|||
for (sig in signals.take(15)) { |
|||
println("DBC Sig: name=${sig.name}, color=0x${java.lang.Long.toHexString(sig.color)}, desc='${sig.description}', msg=${sig.messageName}") |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
@ -1,247 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.common.DefaultDispatcherProvider |
|||
import com.dct.app.presentation.mdi.MdiViewModel |
|||
import com.dct.app.presentation.mdi.MdiWindowConfig |
|||
import com.dct.app.presentation.mdi.MdiWindowType |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.BeforeEach |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@DisplayName("M5 - MdiWorkspaceManager MDI 서브윈도우 관리자 단위 테스트") |
|||
class MdiWorkspaceManagerTest { |
|||
|
|||
private lateinit var dispatchers: DefaultDispatcherProvider |
|||
private lateinit var viewModel: MdiViewModel |
|||
|
|||
@BeforeEach |
|||
fun setUp() { |
|||
dispatchers = DefaultDispatcherProvider() |
|||
viewModel = MdiViewModel(dispatchers) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("초기 상태에서 윈도우 목록은 비어 있고 activeWindowId는 null이어야 한다") |
|||
fun testInitialState() { |
|||
val state = viewModel.uiState.value |
|||
assertTrue(state.windows.isEmpty()) |
|||
assertNull(state.activeWindowId) |
|||
} |
|||
|
|||
@Test |
|||
fun compensationDefaultsFitPointColumnsAndPreserveResizedWindows() { |
|||
listOf(MdiWindowType.COMPENSATION_TYPE_A, MdiWindowType.COMPENSATION_TYPE_B).forEach { type -> |
|||
val id = viewModel.openOrFocusCategoryWindow(type) |
|||
val window = viewModel.uiState.value.windows.first { it.id == id } |
|||
assertEquals(800f, window.width) |
|||
assertEquals(620f, window.height) |
|||
assertTrue(window.width - 12f - 6f - 300f >= 400f) |
|||
viewModel.updateWindowBounds(id, window.offsetX, window.offsetY, 800f, 700f) |
|||
assertEquals(id, viewModel.openOrFocusCategoryWindow(type)) |
|||
val resized = viewModel.uiState.value.windows.first { it.id == id } |
|||
assertEquals(800f, resized.width) |
|||
assertEquals(700f, resized.height) |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("새 서브윈도우 탭을 추가하면 윈도우 목록이 증가하고 새로 추가된 탭이 활성화되어야 한다") |
|||
fun testAddWindow() { |
|||
val createdId = viewModel.addWindow( |
|||
type = MdiWindowType.CALIBRATION, |
|||
title = "제어기 캘리브레이션 1" |
|||
) |
|||
|
|||
assertNotNull(createdId) |
|||
val state = viewModel.uiState.value |
|||
assertEquals(1, state.windows.size) |
|||
assertEquals(createdId, state.activeWindowId) |
|||
assertEquals("제어기 캘리브레이션 1", state.activeWindow?.title) |
|||
assertEquals(MdiWindowType.CALIBRATION, state.activeWindow?.type) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("윈도우 탭을 닫으면 목록에서 제거되어야 한다") |
|||
fun testCloseWindow() { |
|||
val id1 = viewModel.addWindow(type = MdiWindowType.CHART, title = "Chart") |
|||
val id2 = viewModel.addWindow(type = MdiWindowType.CALIBRATION, title = "Calib") |
|||
assertNotNull(id1) |
|||
assertNotNull(id2) |
|||
assertEquals(2, viewModel.uiState.value.windows.size) |
|||
|
|||
viewModel.closeWindow(id2!!) |
|||
val state = viewModel.uiState.value |
|||
assertEquals(1, state.windows.size) |
|||
assertEquals(id1, state.activeWindowId) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("닫기 불가(isClosable = false)로 설정된 윈도우는 닫히지 않아야 한다") |
|||
fun testUnclosableWindow() { |
|||
val id = viewModel.addWindow( |
|||
type = MdiWindowType.CHART, |
|||
title = "Primary Chart", |
|||
isClosable = false |
|||
) |
|||
assertNotNull(id) |
|||
assertEquals(1, viewModel.uiState.value.windows.size) |
|||
|
|||
viewModel.closeWindow(id!!) |
|||
// isClosable=false이므로 닫히지 않음 |
|||
assertEquals(1, viewModel.uiState.value.windows.size) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("서브윈도우 탭 전환(selectWindow)이 정상적으로 동작해야 한다") |
|||
fun testSelectWindow() { |
|||
val id1 = viewModel.addWindow(type = MdiWindowType.CHART, title = "Chart") |
|||
val id2 = viewModel.addWindow(type = MdiWindowType.DASHBOARD, title = "Dashboard") |
|||
|
|||
// id2가 활성화된 상태에서 id1으로 전환 |
|||
viewModel.selectWindow(id1!!) |
|||
assertEquals(id1, viewModel.uiState.value.activeWindowId) |
|||
|
|||
viewModel.selectWindow(id2!!) |
|||
assertEquals(id2, viewModel.uiState.value.activeWindowId) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("서브윈도우 제목 변경(renameWindow)이 정상적으로 동작해야 한다") |
|||
fun testRenameWindow() { |
|||
val id = viewModel.addWindow(type = MdiWindowType.CHART, title = "Original") |
|||
assertNotNull(id) |
|||
|
|||
viewModel.renameWindow(id!!, "Renamed Chart") |
|||
val win = viewModel.uiState.value.windows.find { it.id == id } |
|||
assertEquals("Renamed Chart", win?.title) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("윈도우 설정(config) 업데이트가 정상적으로 반영되어야 한다") |
|||
fun testUpdateWindowConfig() { |
|||
val id = viewModel.addWindow(type = MdiWindowType.CHART, title = "Chart") |
|||
assertNotNull(id) |
|||
|
|||
val newConfig = MdiWindowConfig(autoScroll = false, targetTableName = "TestTable") |
|||
viewModel.updateWindowConfig(id!!, newConfig) |
|||
|
|||
val win = viewModel.uiState.value.windows.find { it.id == id } |
|||
assertNotNull(win) |
|||
assertEquals(false, win?.config?.autoScroll) |
|||
assertEquals("TestTable", win?.config?.targetTableName) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("최대 윈도우 개수(10개) 한도를 초과하여 윈도우를 추가할 수 없어야 한다") |
|||
fun testMaxWindowLimit() { |
|||
repeat(10) { i -> |
|||
viewModel.addWindow(type = MdiWindowType.CHART, title = "Chart $i") |
|||
} |
|||
assertEquals(10, viewModel.uiState.value.windows.size) |
|||
|
|||
// 11번째 시도 - null 반환 |
|||
val extra = viewModel.addWindow(type = MdiWindowType.CHART, title = "Extra") |
|||
assertNull(extra) |
|||
assertEquals(10, viewModel.uiState.value.windows.size) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("getOrCreateWindow는 기존 윈도우가 있으면 해당 윈도우를 포커스하고 없으면 생성해야 한다") |
|||
fun testGetOrCreateWindow() { |
|||
val id1 = viewModel.getOrCreateWindow(type = MdiWindowType.CHART, title = "Chart") |
|||
assertNotNull(id1) |
|||
assertEquals(1, viewModel.uiState.value.windows.size) |
|||
|
|||
// 같은 타입으로 다시 요청 → 기존 것 포커스 |
|||
val id2 = viewModel.getOrCreateWindow(type = MdiWindowType.CHART, title = "Chart") |
|||
assertEquals(id1, id2) |
|||
assertEquals(1, viewModel.uiState.value.windows.size) |
|||
|
|||
// 다른 타입 → 새로 생성 |
|||
val id3 = viewModel.getOrCreateWindow(type = MdiWindowType.CALIBRATION, title = "Calib") |
|||
assertNotNull(id3) |
|||
assertNotEquals(id1, id3) |
|||
assertEquals(2, viewModel.uiState.value.windows.size) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("moveWindow 및 resizeWindow를 통한 실시간 드래그/리사이즈가 정확하게 갱신되어야 한다") |
|||
fun testMoveAndResizeWindow() { |
|||
val id = viewModel.addWindow(type = MdiWindowType.CHART, title = "Chart") |
|||
assertNotNull(id) |
|||
val initialWin = viewModel.uiState.value.windows.first() |
|||
|
|||
// 1. 이동 델타 적용 (+20, +30) |
|||
viewModel.moveWindow(id!!, 20f, 30f) |
|||
val movedWin = viewModel.uiState.value.windows.first() |
|||
assertEquals(initialWin.offsetX + 20f, movedWin.offsetX) |
|||
assertEquals(initialWin.offsetY + 30f, movedWin.offsetY) |
|||
|
|||
// 2. 크기 변경 델타 적용 (+50, +40) |
|||
viewModel.resizeWindow(id, 50f, 40f) |
|||
val resizedWin = viewModel.uiState.value.windows.first() |
|||
assertEquals(initialWin.width + 50f, resizedWin.width) |
|||
assertEquals(initialWin.height + 40f, resizedWin.height) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("closeWindowsByTypes 호출 시 지정된 타입들의 윈도우가 일괄 닫혀야 한다") |
|||
fun testCloseWindowsByTypes() { |
|||
viewModel.addWindow(type = MdiWindowType.MDB_SIGNAL_LIST, title = "MDB Sig") |
|||
viewModel.addWindow(type = MdiWindowType.CONSTANT_SIGNAL_LIST, title = "Const Sig") |
|||
viewModel.addWindow(type = MdiWindowType.CHART, title = "Chart") |
|||
assertEquals(3, viewModel.uiState.value.windows.size) |
|||
|
|||
viewModel.closeWindowsByTypes(MdiWindowType.MDB_SIGNAL_LIST, MdiWindowType.CONSTANT_SIGNAL_LIST) |
|||
val remaining = viewModel.uiState.value.windows |
|||
assertEquals(1, remaining.size) |
|||
assertEquals(MdiWindowType.CHART, remaining.first().type) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("addGraphWindow 호출 시 GraphWindow 01, GraphWindow 02, GraphWindow 03 등 순차 번호가 올바르게 부여되어야 한다") |
|||
fun testAddGraphWindowNumbered() { |
|||
val g1 = viewModel.addGraphWindow() |
|||
val g2 = viewModel.addGraphWindow() |
|||
val g3 = viewModel.addGraphWindow() |
|||
|
|||
val windows = viewModel.uiState.value.windows |
|||
assertEquals(3, windows.size) |
|||
assertEquals("GraphWindow 01", windows[0].title) |
|||
assertEquals("GraphWindow 02", windows[1].title) |
|||
assertEquals("GraphWindow 03", windows[2].title) |
|||
|
|||
// 중간의 GraphWindow 02를 닫고 다시 추가하면 미사용 번호(GraphWindow 02)가 재사용되어야 한다 |
|||
viewModel.closeWindow(g2) |
|||
assertEquals(2, viewModel.uiState.value.windows.size) |
|||
|
|||
val g2New = viewModel.addGraphWindow() |
|||
val updatedWindows = viewModel.uiState.value.windows |
|||
assertEquals(3, updatedWindows.size) |
|||
assertTrue(updatedWindows.any { it.title == "GraphWindow 02" }) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("뷰포트 스크롤 좌표가 주어졌을 때 addGraphWindow와 openOrFocusCategoryWindow는 현재 화면 영역 내에 창을 배치해야 한다") |
|||
fun testWindowPlacementWithViewportCoordinates() { |
|||
val graphId = viewModel.addGraphWindow( |
|||
viewportScrollX = 500f, |
|||
viewportScrollY = 300f |
|||
) |
|||
val graphWin = viewModel.uiState.value.windows.find { it.id == graphId } |
|||
assertNotNull(graphWin) |
|||
assertTrue(graphWin!!.offsetX >= 500f) |
|||
assertTrue(graphWin.offsetY >= 300f) |
|||
|
|||
val catId = viewModel.openOrFocusCategoryWindow( |
|||
type = MdiWindowType.CAN_SIGNAL_LIST, |
|||
viewportScrollX = 800f, |
|||
viewportScrollY = 400f |
|||
) |
|||
val catWin = viewModel.uiState.value.windows.find { it.id == catId } |
|||
assertNotNull(catWin) |
|||
assertTrue(catWin!!.offsetX >= 800f) |
|||
assertTrue(catWin.offsetY >= 400f) |
|||
} |
|||
} |
|||
@ -1,114 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.core.error.DctError |
|||
import com.dct.app.domain.repository.DeviceConnectionState |
|||
import com.dct.app.domain.repository.PacketRepository |
|||
import com.dct.app.domain.repository.StreamRecoveryState |
|||
import com.dct.app.presentation.main.MainViewModel |
|||
import io.mockk.coEvery |
|||
import kotlinx.coroutines.CompletableDeferred |
|||
import kotlinx.coroutines.cancel |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import org.junit.jupiter.api.AfterEach |
|||
import org.junit.jupiter.api.BeforeEach |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.Assertions.* |
|||
|
|||
@Suppress("UNCHECKED_CAST") |
|||
class MeasurementElapsedTimeTest { |
|||
private lateinit var fixture: MainViewModelTest |
|||
private lateinit var vm: MainViewModel |
|||
private lateinit var repository: PacketRepository |
|||
private lateinit var connection: MutableStateFlow<DeviceConnectionState> |
|||
private fun field(target: Any, name: String) = target.javaClass.getDeclaredField(name).also { it.isAccessible = true } |
|||
private fun clock(time: Long) = field(fixture, "measurementClockMillis").setLong(fixture, time) |
|||
|
|||
@BeforeEach fun setUp() { |
|||
fixture = MainViewModelTest().also { it.setUp() } |
|||
vm = field(fixture, "viewModel").get(fixture) as MainViewModel |
|||
repository = field(fixture, "packetRepository").get(fixture) as PacketRepository |
|||
connection = field(fixture, "connectionState").get(fixture) as MutableStateFlow<DeviceConnectionState> |
|||
connection.value = DeviceConnectionState.READY |
|||
} |
|||
|
|||
@AfterEach fun cleanUp() { |
|||
vm.scope.cancel() |
|||
fixture.tearDown() |
|||
} |
|||
|
|||
@Test fun timerStartsOnlyAfterSuccessfulStartNotWhileWaitingForResponse() { |
|||
val response = CompletableDeferred<DctResult<Unit>>() |
|||
coEvery { repository.startStreaming(any()) } coAnswers { response.await() } |
|||
clock(1_000) |
|||
vm.startMeasure() |
|||
assertNull(vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
clock(50_000) |
|||
response.complete(DctResult.Success(Unit)) |
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
assertEquals(50_000L, vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
} |
|||
|
|||
@Test fun failedStartDoesNotCreateTimer() { |
|||
coEvery { repository.startStreaming(any()) } returns DctResult.Failure(DctError.ProtocolError.Disconnected) |
|||
clock(5_000) |
|||
vm.startMeasure() |
|||
assertFalse(vm.uiState.value.isMeasuring) |
|||
assertNull(vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
} |
|||
|
|||
@Test fun stopClearsTimeAndSuccessfulRestartStartsFromNewTime() { |
|||
clock(1_000) |
|||
vm.startMeasure() |
|||
clock(61_000) |
|||
vm.stopMeasure() |
|||
assertNull(vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
clock(99_000) |
|||
vm.stopMeasure() |
|||
assertNull(vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
clock(120_000) |
|||
vm.startMeasure() |
|||
assertEquals(120_000L, vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
} |
|||
|
|||
@Test fun pendingOrFailedStopKeepsTimerUntilMeasurementActuallyEnds() { |
|||
clock(1_000) |
|||
vm.startMeasure() |
|||
val response = CompletableDeferred<DctResult<Unit>>() |
|||
coEvery { repository.stopStreaming() } coAnswers { response.await() } |
|||
vm.stopMeasure() |
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
assertEquals(1_000L, vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
response.complete(DctResult.Failure(DctError.ProtocolError.ConnectionFailed("STOP failed"))) |
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
assertEquals(1_000L, vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
coEvery { repository.stopStreaming() } returns DctResult.Success(Unit) |
|||
vm.stopMeasure() |
|||
assertFalse(vm.uiState.value.isMeasuring) |
|||
assertNull(vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
} |
|||
|
|||
@Test fun automaticRecoveryAndDebugValueResetKeepOriginalMeasurementStart() { |
|||
clock(1_000) |
|||
vm.startMeasure() |
|||
clock(300_000) |
|||
val recovery = repository.streamRecovery as MutableStateFlow<StreamRecoveryState> |
|||
recovery.value = StreamRecoveryState.RECOVERING |
|||
vm.resetDebugValues() |
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
assertEquals(1_000L, vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
recovery.value = StreamRecoveryState.RECEIVING |
|||
assertEquals(1_000L, vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
} |
|||
|
|||
@Test fun disconnectAndNewProjectClearTimer() { |
|||
clock(1_000) |
|||
vm.startMeasure() |
|||
clock(11_000) |
|||
connection.value = DeviceConnectionState.DISCONNECTED |
|||
assertFalse(vm.uiState.value.isMeasuring) |
|||
assertNull(vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
vm.resetWorkspaceForNewProject() |
|||
assertNull(vm.uiState.value.measurementStartedAtElapsedMillis) |
|||
} |
|||
} |
|||
@ -1,89 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.background.MeasurementExecutionState |
|||
import com.dct.app.data.communication.WifiDirectPhase |
|||
import com.dct.app.domain.repository.DeviceConnectionState |
|||
import com.dct.app.presentation.main.MainUiState |
|||
import com.dct.app.presentation.main.MeasurementRecordingState |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class MeasurementExecutionStateTest { |
|||
@Test fun recoveryKeepsRecordingAndItsStartTimeWhileShowingReceptionIsUnavailable() { |
|||
val notification = state(MainUiState(isMeasuring = true, isStreamRecovering = true, |
|||
recordingState = MeasurementRecordingState.RECORDING, recordingStartedAtMillis = 1234)) |
|||
assertTrue(notification.active) |
|||
assertTrue(notification.measuring) |
|||
assertTrue(notification.recording) |
|||
assertEquals(1234L, notification.startedAtMillis) |
|||
assertTrue(notification.title.contains("수신 복구 중")) |
|||
} |
|||
@Test fun apNegotiationAndTcpWaitKeepServiceButScanningDoesNot() { |
|||
fun ap(phase: com.dct.app.data.communication.WifiApPhase, present: Boolean = false) = |
|||
MeasurementExecutionState.from(MainUiState(), DeviceConnectionState.DISCONNECTED, false, |
|||
WifiDirectPhase.IDLE, false, phase, present) |
|||
assertFalse(ap(com.dct.app.data.communication.WifiApPhase.SCANNING).active) |
|||
assertTrue(ap(com.dct.app.data.communication.WifiApPhase.CONNECTING).active) |
|||
val waiting = ap(com.dct.app.data.communication.WifiApPhase.CONNECTED, true) |
|||
assertTrue(waiting.active); assertTrue(waiting.title.contains("Wi-Fi AP")) |
|||
assertFalse(ap(com.dct.app.data.communication.WifiApPhase.ERROR).active) |
|||
} |
|||
@Test fun notificationOmitsFrequencyWithoutChangingMeasurementSettingsOrProgress() { |
|||
for (frequency in listOf(30, 60, 120)) { |
|||
val ui = MainUiState(isMeasuring = true, measurementFrequencyHz = frequency, |
|||
projectFileName = "Test.dpc", connectedDeviceName = "Device", packetCount = 100, |
|||
recordingSampleCount = 42, recordingState = MeasurementRecordingState.RECORDING) |
|||
val notification = state(ui) |
|||
assertEquals("Test.dpc · Device · 수신 100건 · 기록 42건", notification.detail) |
|||
assertFalse(notification.title.contains("Hz")) |
|||
assertEquals(frequency, ui.measurementFrequencyHz) |
|||
assertTrue(notification.measuring) |
|||
assertTrue(notification.recording) |
|||
} |
|||
} |
|||
|
|||
private fun state(ui: MainUiState = MainUiState(), connection: DeviceConnectionState = DeviceConnectionState.DISCONNECTED, |
|||
socket: Boolean = false, phase: WifiDirectPhase = WifiDirectPhase.IDLE, group: Boolean = false) = |
|||
MeasurementExecutionState.from(ui, connection, socket, phase, group) |
|||
|
|||
@Test fun idleAndSearchDoNotKeepForegroundServiceRunning() { |
|||
assertFalse(state().active) |
|||
assertFalse(state(phase = WifiDirectPhase.DISCOVERING).active) |
|||
} |
|||
|
|||
@Test fun negotiationSocketAndGroupOwnerWaitingAreActiveBeforeHandshake() { |
|||
assertTrue(state(phase = WifiDirectPhase.CONNECTING).active) |
|||
assertTrue(state(connection = DeviceConnectionState.HANDSHAKING).active) |
|||
assertTrue(state(socket = true).active) |
|||
val waiting = state(group = true, phase = WifiDirectPhase.CONNECTED) |
|||
assertTrue(waiting.active) |
|||
assertTrue(waiting.title.contains("TCP 대기")) |
|||
assertFalse(waiting.measuring) |
|||
} |
|||
|
|||
@Test fun measurementAndRecordingRemainSeparateAndIncludeProgress() { |
|||
val ui = MainUiState(isMeasuring = true, projectFileName = "Test.dpc", connectedDeviceName = "Device", |
|||
packetCount = 100, recordingSampleCount = 42, recordingStartedAtMillis = 1234, |
|||
recordingState = MeasurementRecordingState.RECORDING) |
|||
val recording = state(ui) |
|||
assertTrue(recording.active) |
|||
assertTrue(recording.measuring) |
|||
assertTrue(recording.recording) |
|||
assertTrue(recording.title.contains("계측 및 기록")) |
|||
assertEquals(1234L, recording.startedAtMillis) |
|||
assertTrue(recording.detail.contains("수신 100건")) |
|||
assertTrue(recording.detail.contains("기록 42건")) |
|||
val measuringOnly = state(ui.copy(recordingState = MeasurementRecordingState.IDLE, recordingStartedAtMillis = null)) |
|||
assertTrue(measuringOnly.title.contains("기록 안 함")) |
|||
assertFalse(measuringOnly.recording) |
|||
} |
|||
|
|||
@Test fun stopMeasurementKeepsConnectionAndServiceButDisconnectEndsIt() { |
|||
val waiting = state(connection = DeviceConnectionState.READY) |
|||
assertTrue(waiting.active) |
|||
assertFalse(waiting.measuring) |
|||
assertTrue(waiting.title.contains("계측 대기")) |
|||
assertFalse(state(connection = DeviceConnectionState.ERROR).active) |
|||
assertTrue(state(MainUiState(recordingState = MeasurementRecordingState.STOPPING)).active) |
|||
} |
|||
} |
|||
@ -1,31 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.logger.MeasurementLogPaths |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import java.io.File |
|||
|
|||
class MeasurementLogPathsTest { |
|||
private val base = File(System.getProperty("java.io.tmpdir"), "DctWork").absoluteFile |
|||
@Test fun pcSlashDataIsResolvedUnderAndroidWorkFolder() { |
|||
assertEquals(File(base, "Data"), MeasurementLogPaths.resolve("/Data", base.path, true, base)) |
|||
assertEquals(File(base, "Data"), MeasurementLogPaths.resolve("/Data", base.path, false, base)) |
|||
assertEquals(File(base, "Data/logs"), MeasurementLogPaths.resolve("\\Data\\logs", base.path, true, base)) |
|||
} |
|||
@Test fun emptyBaseAndPathUseFallback() { |
|||
assertEquals(File(base, "Data"), MeasurementLogPaths.resolve("", "", false, base)) |
|||
assertEquals(File(base, "Data"), MeasurementLogPaths.resolve("/Data", "", true, base)) |
|||
} |
|||
@Test fun actualAbsoluteDirectoryIsNotRebasedAndRelativeCannotEscape() { |
|||
val absolute = File(base.parentFile, "ExplicitLogs") |
|||
assertEquals(absolute, MeasurementLogPaths.resolve(absolute.path, base.path, false, base)) |
|||
assertEquals(File(base, "Data"), MeasurementLogPaths.resolve("../../outside", base.path, true, base)) |
|||
} |
|||
@Test fun uncPcDirectoryFallsBackToLocalData() { |
|||
assertEquals(File(base, "Data"), MeasurementLogPaths.resolve("\\\\PC\\Logs", "\\\\PC\\Project", false, base)) |
|||
} |
|||
@Test fun oldSafDisplayPathNeverBecomesARealFilesystemPath() { |
|||
assertEquals(File(base, "Data"), MeasurementLogPaths.resolve("/tree/primary:Documents/Logs", base.path, false, base)) |
|||
assertEquals(File(base, "Data"), MeasurementLogPaths.resolve("content://com.android.externalstorage.documents/tree/primary%3ADocuments", base.path, false, base)) |
|||
} |
|||
} |
|||
@ -1,244 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.logger.CsvMeasurementLogger |
|||
import com.dct.app.data.logger.Mf4MeasurementLogger |
|||
import com.dct.app.data.logger.PcCsvColumn |
|||
import com.dct.app.data.logger.PcMeasurementNames |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
import java.io.RandomAccessFile |
|||
|
|||
@DisplayName("MeasurementLogger - CSV 및 ASAM MF4 실시간 계측 로거 단위 테스트") |
|||
class MeasurementLoggerTest { |
|||
|
|||
@Test |
|||
fun pcProjectNameAndSecondPrecisionAreUsedForMeasurementFiles() { |
|||
val stamp = PcMeasurementNames.timestamp(java.util.Date(0L)) |
|||
assertEquals("TEST", PcMeasurementNames.projectName("TEST.dpc")) |
|||
assertEquals("test", PcMeasurementNames.projectName("test.DPC")) |
|||
assertEquals("PROJECT", PcMeasurementNames.projectName("")) |
|||
assertTrue(stamp.matches(Regex("\\d{4}-\\d{2}-\\d{2}_\\d{2}-\\d{2}-\\d{2}"))) |
|||
assertEquals("TEST_${stamp}_mdb.mf4", PcMeasurementNames.fileName("TEST", stamp, "mdb", "mf4")) |
|||
} |
|||
|
|||
@Test |
|||
fun pcCsvHeaderKeepsIdentityPrecisionAndMissingValues(@TempDir tempDir: File) { |
|||
val file = CsvMeasurementLogger( |
|||
tempDir, |
|||
listOf("EngineSpeed" to "rpm", "Coolant" to "C"), |
|||
"TEST_2026-09-28_14-30-00_mdb.csv", |
|||
listOf(PcCsvColumn("12", "[0xA3-12]", 0), PcCsvColumn("13", "[0xA3-13]", 2)) |
|||
).apply { |
|||
start() |
|||
logSample(0.1, listOf(1500.0, null)) |
|||
logSample(0.2, listOf(1512.0, 87.125)) |
|||
stop() |
|||
}.outputFile!! |
|||
val lines = file.readLines() |
|||
assertEquals("File: ${file.name}", lines[0]) |
|||
assertTrue(lines[1].startsWith("Date: ")) |
|||
assertTrue(lines[3].contains("12,")) |
|||
assertTrue(lines[4].contains("[0xA3-12]")) |
|||
assertTrue(lines[6].startsWith(" Time, Count,")) |
|||
assertTrue(lines[7].matches(Regex("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}, 0,1500,No value"))) |
|||
assertTrue(lines[8].endsWith(",1512,87.13")) |
|||
} |
|||
|
|||
@Test |
|||
fun a2lMissingMeasurementUsesPcNcMarker(@TempDir tempDir: File) { |
|||
val file = CsvMeasurementLogger(tempDir, listOf("Measurement" to "V"), "A2L_measurement.csv", |
|||
listOf(PcCsvColumn("0", "[0x1234]")), "NC").apply { |
|||
start() |
|||
logSample(0.1, listOf(null)) |
|||
stop() |
|||
}.outputFile!! |
|||
assertTrue(file.readLines().last().endsWith(",NC")) |
|||
} |
|||
|
|||
@Test |
|||
fun missingMf4ChannelIsNotWrittenAsMeasuredZero(@TempDir tempDir: File) { |
|||
val file = Mf4MeasurementLogger(tempDir, listOf("Signal" to "V"), "missing.mf4").apply { |
|||
start() |
|||
logSample(0.1, listOf(null)) |
|||
stop() |
|||
}.outputFile!! |
|||
RandomAccessFile(file, "r").use { raf -> |
|||
raf.seek(file.length() - 8) |
|||
val data = ByteArray(8).also(raf::readFully) |
|||
assertTrue(java.nio.ByteBuffer.wrap(data).order(java.nio.ByteOrder.LITTLE_ENDIAN).double.isNaN()) |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("CsvMeasurementLogger가 정상적으로 CSV 헤더 및 시계열 물리값 레코드를 생성해야 한다") |
|||
fun testCsvMeasurementLogger(@TempDir tempDir: File) { |
|||
val headers = listOf("EngineSpeed" to "RPM", "VehicleSpeed" to "km/h") |
|||
val logger = CsvMeasurementLogger(tempDir, headers) |
|||
|
|||
val createdFile = logger.start() |
|||
assertNotNull(createdFile) |
|||
assertTrue(createdFile!!.exists()) |
|||
|
|||
// 3개 샘플 기록 |
|||
logger.logSample(0.033, listOf(1500.0, 60.5)) |
|||
logger.logSample(0.066, listOf(1550.0, 61.2)) |
|||
logger.logSample(0.099, listOf(1600.0, 62.0)) |
|||
logger.stop() |
|||
|
|||
val lines = createdFile.readLines() |
|||
assertTrue(lines.isNotEmpty()) |
|||
assertEquals("Time(s),EngineSpeed [RPM],VehicleSpeed [km/h]", lines[0]) |
|||
assertTrue(lines[1].startsWith("0.0330,1500.0000,60.5000")) |
|||
assertTrue(lines[2].startsWith("0.0660,1550.0000,61.2000")) |
|||
assertTrue(lines[3].startsWith("0.0990,1600.0000,62.0000")) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("Mf4MeasurementLogger가 ASAM MDF v4.10 전체 계층 블록(HD->DG->CG->CN 체인->TX->DT) 및 cycle_count를 정확히 기록해야 한다") |
|||
fun testMf4MeasurementLogger(@TempDir tempDir: File) { |
|||
val headers = listOf("EngineSpeed" to "RPM", "CoolantTemp" to "'C") |
|||
val logger = Mf4MeasurementLogger(tempDir, headers) |
|||
|
|||
val createdFile = logger.start() |
|||
assertNotNull(createdFile) |
|||
assertTrue(createdFile!!.exists()) |
|||
|
|||
// 2개 샘플 기록 |
|||
logger.logSample(0.033, listOf(2000.0, 85.0)) |
|||
logger.logSample(0.066, listOf(2050.0, 85.5)) |
|||
logger.stop() |
|||
|
|||
// 바이너리 파일 크기 및 ASAM MDF 4.10 블록 계층 전수 검증 |
|||
assertTrue(createdFile.length() > 296) |
|||
RandomAccessFile(createdFile, "r").use { raf -> |
|||
val buf4 = ByteArray(4) |
|||
val buf8 = ByteArray(8) |
|||
|
|||
// 1. ID Block (0..63) |
|||
val idMagic = ByteArray(8) |
|||
raf.seek(0) |
|||
raf.readFully(idMagic) |
|||
assertEquals("MDF ", String(idMagic, Charsets.US_ASCII)) |
|||
|
|||
val versionMagic = ByteArray(8) |
|||
raf.readFully(versionMagic) |
|||
assertEquals("4.10 ", String(versionMagic, Charsets.US_ASCII)) |
|||
|
|||
// 2. HD Block (64..167, 104B) |
|||
raf.seek(64) |
|||
raf.readFully(buf4) |
|||
assertEquals("##HD", String(buf4, Charsets.US_ASCII)) |
|||
raf.seek(64 + 8) |
|||
assertEquals(104L, java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long) // HD length |
|||
assertEquals(6L, java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long) // link count |
|||
val dgOffset = java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long // hd_dg_first |
|||
assertEquals(168L, dgOffset) |
|||
|
|||
// 3. DG Block (168..231, 64B) |
|||
raf.seek(dgOffset) |
|||
raf.readFully(buf4) |
|||
assertEquals("##DG", String(buf4, Charsets.US_ASCII)) |
|||
raf.seek(dgOffset + 8) |
|||
assertEquals(64L, java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long) // DG length |
|||
assertEquals(4L, java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long) // link count |
|||
raf.readFully(buf8) // dg_next (0L) |
|||
val cgOffset = java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long // dg_cg_first |
|||
assertEquals(232L, cgOffset) |
|||
val dtOffset = java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long // dg_data |
|||
assertTrue(dtOffset > cgOffset) |
|||
|
|||
// ASAM 4.10 CG: 24-byte common header, six links, 32-byte data. |
|||
raf.seek(cgOffset) |
|||
raf.readFully(buf4) |
|||
assertEquals("##CG", String(buf4, Charsets.US_ASCII)) |
|||
raf.seek(cgOffset + 8) |
|||
assertEquals(104L, java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long) // CG length |
|||
assertEquals(6L, java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long) |
|||
raf.readFully(buf8) // next CG |
|||
val firstCnOffset = java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long // cg_cn_first |
|||
assertEquals(336L, firstCnOffset) |
|||
raf.seek(cgOffset + 72) |
|||
val recordId = java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long // record_id |
|||
assertEquals(0L, recordId) |
|||
|
|||
// cycle_count follows all six links and record_id: CG + 80. |
|||
val cycleCount = java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long // cycle_count |
|||
assertEquals(2L, cycleCount, "stop() 후 cycle_count는 기록된 레코드 수(2)와 일치해야 합니다.") |
|||
|
|||
// 5. CN Block 체인 검증 (첫 번째 채널: Time 마스터 채널) |
|||
raf.seek(firstCnOffset) |
|||
raf.readFully(buf4) |
|||
assertEquals("##CN", String(buf4, Charsets.US_ASCII)) |
|||
raf.seek(firstCnOffset + 8) |
|||
assertEquals(160L, java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long) // CN length |
|||
assertEquals(8L, java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long) // link count |
|||
val secondCnOffset = java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long // cn_next |
|||
assertTrue(secondCnOffset > firstCnOffset) |
|||
raf.readFully(buf8) // cn_composition (0L) |
|||
val timeNameTxOffset = java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long // cn_tx_name |
|||
assertTrue(timeNameTxOffset > 0) |
|||
|
|||
// Name TXBlock 확인 ("Time") |
|||
raf.seek(timeNameTxOffset) |
|||
raf.readFully(buf4) |
|||
assertEquals("##TX", String(buf4, Charsets.US_ASCII)) |
|||
raf.seek(timeNameTxOffset + 24) |
|||
val nameBytes = ByteArray(5) |
|||
raf.readFully(nameBytes) |
|||
assertEquals("Time\u0000", String(nameBytes, Charsets.UTF_8)) |
|||
|
|||
// Time 채널의 cn_type (마스터 = 2), cn_sync_type (시간 = 1), cn_data_type (Float LE = 4) |
|||
raf.seek(firstCnOffset + 88) |
|||
assertEquals(2.toByte(), raf.readByte()) // cn_type |
|||
assertEquals(1.toByte(), raf.readByte()) // cn_sync_type |
|||
assertEquals(4.toByte(), raf.readByte()) // cn_data_type |
|||
|
|||
// 6. DT Block 검증 |
|||
raf.seek(dtOffset) |
|||
raf.readFully(buf4) |
|||
assertEquals("##DT", String(buf4, Charsets.US_ASCII)) |
|||
raf.seek(dtOffset + 8) |
|||
val expectedDtLength = 24L + (2L * (8 + 2 * 8)) // 24 header + 2 records * 24 bytes = 72L |
|||
val actualDtLength = java.nio.ByteBuffer.wrap(buf8.apply { raf.readFully(this) }).order(java.nio.ByteOrder.LITTLE_ENDIAN).long |
|||
assertEquals(expectedDtLength, actualDtLength, "DT 블록 길이는 헤더 24B + 레코드 크기 합산과 일치해야 합니다.") |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("표준 파일명 규칙(프로젝트명_날짜_시간_소스타입.csv/mf4)으로 로거가 정상 생성되어야 한다") |
|||
fun testStandardNamingFormat(@TempDir tempDir: File) { |
|||
val headers = listOf("EngSpd" to "rpm", "Torque" to "Nm") |
|||
val customCsvName = "241213_SW_EU_TEST01_2026-07-02_08-39-15_dbc.csv" |
|||
val customMf4Name = "241213_SW_EU_TEST01_2026-07-02_08-39-15_mdb.mf4" |
|||
|
|||
val csvLogger = CsvMeasurementLogger(tempDir, headers, customCsvName) |
|||
val csvFile = csvLogger.start() |
|||
assertNotNull(csvFile) |
|||
assertEquals("241213_SW_EU_TEST01_2026-07-02_08-39-15_dbc.csv", csvFile!!.name) |
|||
csvLogger.stop() |
|||
|
|||
val mf4Logger = Mf4MeasurementLogger(tempDir, headers, customMf4Name) |
|||
val mf4File = mf4Logger.start() |
|||
assertNotNull(mf4File) |
|||
assertEquals("241213_SW_EU_TEST01_2026-07-02_08-39-15_mdb.mf4", mf4File!!.name) |
|||
mf4Logger.stop() |
|||
|
|||
// A2L / 통합 계측: _measurement |
|||
val a2lCsvName = "SP3_20260622_2026-07-02_13-40-46_measurement.csv" |
|||
val a2lMf4Name = "SP3_20260622_2026-07-02_13-40-17_measurement.mf4" |
|||
val a2lCsvLogger = CsvMeasurementLogger(tempDir, headers, a2lCsvName) |
|||
val a2lCsvFile = a2lCsvLogger.start() |
|||
assertNotNull(a2lCsvFile) |
|||
assertEquals("SP3_20260622_2026-07-02_13-40-46_measurement.csv", a2lCsvFile!!.name) |
|||
a2lCsvLogger.stop() |
|||
|
|||
val a2lMf4Logger = Mf4MeasurementLogger(tempDir, headers, a2lMf4Name) |
|||
val a2lMf4File = a2lMf4Logger.start() |
|||
assertNotNull(a2lMf4File) |
|||
assertEquals("SP3_20260622_2026-07-02_13-40-17_measurement.mf4", a2lMf4File!!.name) |
|||
a2lMf4Logger.stop() |
|||
} |
|||
} |
|||
@ -1,100 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.logger.CsvMeasurementLogger |
|||
import com.dct.app.data.logger.Mf4MeasurementLogger |
|||
import com.dct.app.data.logger.PcCsvColumn |
|||
import com.dct.app.data.logger.PcMf4Channel |
|||
import com.dct.app.domain.model.project.DpcProject |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.presentation.main.MainUiState |
|||
import com.dct.app.presentation.main.MainViewModel |
|||
import com.dct.app.presentation.main.MeasurementRecordingState |
|||
import kotlinx.coroutines.cancel |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
import java.nio.ByteBuffer |
|||
import java.nio.ByteOrder |
|||
import java.util.concurrent.CountDownLatch |
|||
import java.util.concurrent.Executors |
|||
import java.util.concurrent.TimeUnit |
|||
import java.util.concurrent.TimeoutException |
|||
import java.util.concurrent.atomic.AtomicBoolean |
|||
|
|||
@Suppress("UNCHECKED_CAST") |
|||
class MeasurementRecordingConcurrencyTest { |
|||
@TempDir lateinit var directory: File |
|||
private fun field(target: Any, name: String) = target.javaClass.getDeclaredField(name).also { it.isAccessible = true } |
|||
|
|||
@Test fun stopAckAndDisconnectCannotSplitAnInFlightCsvMf4Sample() { |
|||
// Both automatic termination and explicit recording-stop share the actual close path. |
|||
for (termination in listOf("finishMeasurementSession", "closeMeasurementLoggers")) { |
|||
val fixture = MainViewModelTest().also { it.setUp() } |
|||
val vm = field(fixture, "viewModel").get(fixture) as MainViewModel |
|||
val betweenFormats = CountDownLatch(1) |
|||
val releaseSample = CountDownLatch(1) |
|||
val stopping = CountDownLatch(1) |
|||
val armed = AtomicBoolean(false) |
|||
val executor = Executors.newFixedThreadPool(2) |
|||
val blockedOnce = AtomicBoolean(false) |
|||
val headers = object : AbstractList<Pair<String, String>>() { |
|||
override val size = 1 |
|||
override fun get(index: Int): Pair<String, String> { |
|||
if (armed.get() && blockedOnce.compareAndSet(false, true)) { |
|||
betweenFormats.countDown() |
|||
check(releaseSample.await(10, TimeUnit.SECONDS)) |
|||
} |
|||
return "Incar_Snr" to "C" |
|||
} |
|||
} |
|||
val csv = CsvMeasurementLogger(directory, listOf("Incar_Snr" to "C"), "$termination.csv", listOf(PcCsvColumn())) |
|||
val mf4 = Mf4MeasurementLogger(directory, headers, "$termination.mf4", |
|||
listOf(PcMf4Channel("Incar_Snr", "C", bitCount = 32, physicalInput = true))) |
|||
try { |
|||
vm.setCurrentProject(DpcProject(writeCsv = false, writeMf4 = false)) |
|||
assertNotNull(csv.start()) |
|||
assertNotNull(mf4.start(0L)) |
|||
(field(vm, "activeCsvLoggers").get(vm) as MutableList<CsvMeasurementLogger>).add(csv) |
|||
(field(vm, "activeMf4Loggers").get(vm) as MutableList<Mf4MeasurementLogger>).add(mf4) |
|||
val ui = field(vm, "_uiState").get(vm) as MutableStateFlow<MainUiState> |
|||
ui.value = ui.value.copy(isMeasuring = true, recordingState = MeasurementRecordingState.RECORDING) |
|||
val packet = DctPacket(0x02, ByteArray(18).also { |
|||
val buffer = ByteBuffer.wrap(it).order(ByteOrder.LITTLE_ENDIAN) |
|||
buffer.position(2) |
|||
buffer.putFloat(15f).putFloat(2f).putFloat(3f).putFloat(4f) |
|||
}) |
|||
val process = MainViewModel::class.java.getDeclaredMethod("processIncomingPacket", DctPacket::class.java, Double::class.javaPrimitiveType).also { it.isAccessible = true } |
|||
armed.set(true) |
|||
val writing = executor.submit { process.invoke(vm, packet, 0.5) } |
|||
assertTrue(betweenFormats.await(5, TimeUnit.SECONDS)) |
|||
val stop = executor.submit { |
|||
stopping.countDown() |
|||
MainViewModel::class.java.getDeclaredMethod(termination).also { it.isAccessible = true }.invoke(vm) |
|||
} |
|||
assertTrue(stopping.await(5, TimeUnit.SECONDS)) |
|||
assertThrows(TimeoutException::class.java) { stop.get(100, TimeUnit.MILLISECONDS) } |
|||
releaseSample.countDown() |
|||
writing.get(5, TimeUnit.SECONDS) |
|||
stop.get(5, TimeUnit.SECONDS) |
|||
assertEquals(1, csv.outputFile!!.readLines().drop(7).size) |
|||
val binary = ByteBuffer.wrap(mf4.outputFile!!.readBytes()).order(ByteOrder.LITTLE_ENDIAN) |
|||
assertEquals(1L, binary.getLong(232 + 80)) |
|||
assertEquals(1L, vm.uiState.value.recordingSampleCount) |
|||
// A late packet after close must not reopen or extend either file. |
|||
process.invoke(vm, packet, 1.0) |
|||
assertEquals(1, csv.outputFile!!.readLines().drop(7).size) |
|||
assertEquals(1L, vm.uiState.value.recordingSampleCount) |
|||
} finally { |
|||
releaseSample.countDown() |
|||
executor.shutdown() |
|||
executor.awaitTermination(10, TimeUnit.SECONDS) |
|||
csv.stop() |
|||
mf4.stop() |
|||
vm.scope.cancel() |
|||
fixture.tearDown() |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,251 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.data.communication.WifiSocketManager |
|||
import com.dct.app.data.logger.CsvMeasurementLogger |
|||
import com.dct.app.domain.model.project.DpcProject |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.domain.repository.DeviceConnectionState |
|||
import com.dct.app.domain.repository.PacketRepository |
|||
import com.dct.app.presentation.main.MainViewModel |
|||
import com.dct.app.presentation.main.MeasurementRecordingState |
|||
import io.mockk.* |
|||
import kotlinx.coroutines.CompletableDeferred |
|||
import kotlinx.coroutines.cancel |
|||
import kotlinx.coroutines.flow.MutableSharedFlow |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import org.junit.jupiter.api.AfterEach |
|||
import org.junit.jupiter.api.BeforeEach |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
import java.nio.file.Path |
|||
import java.nio.ByteBuffer |
|||
import java.nio.ByteOrder |
|||
|
|||
@Suppress("UNCHECKED_CAST") |
|||
class MeasurementRestartRegressionTest { |
|||
@TempDir lateinit var directory: Path |
|||
private lateinit var fixture: MainViewModelTest |
|||
private lateinit var vm: MainViewModel |
|||
private lateinit var repository: PacketRepository |
|||
private lateinit var packets: MutableSharedFlow<DctPacket> |
|||
private lateinit var state: MutableStateFlow<DeviceConnectionState> |
|||
private lateinit var loggers: MutableList<CsvMeasurementLogger> |
|||
private lateinit var socket: WifiSocketManager |
|||
private fun field(target: Any, name: String) = target.javaClass.getDeclaredField(name).also { it.isAccessible = true } |
|||
|
|||
@BeforeEach fun setUp() { |
|||
fixture = MainViewModelTest().also { it.setUp() } |
|||
vm = field(fixture, "viewModel").get(fixture) as MainViewModel |
|||
repository = field(fixture, "packetRepository").get(fixture) as PacketRepository |
|||
packets = repository.packetStream as MutableSharedFlow<DctPacket> |
|||
state = field(fixture, "connectionState").get(fixture) as MutableStateFlow<DeviceConnectionState> |
|||
loggers = field(vm, "activeCsvLoggers").get(vm) as MutableList<CsvMeasurementLogger> |
|||
socket = mockk(relaxed = true) |
|||
field(vm, "wifiSocketManager").set(vm, socket) |
|||
vm.setCurrentProject(DpcProject(measuredFilesFolder = directory.toString(), writeCsv = false, writeMf4 = false)) |
|||
state.value = DeviceConnectionState.READY |
|||
} |
|||
|
|||
@AfterEach fun cleanUp() { |
|||
vm.scope.cancel() |
|||
fixture.tearDown() |
|||
} |
|||
|
|||
@Test fun receptionRecoveryPreservesMeasurementRecordingAndExistingLoggerUntilDataReturns() { |
|||
vm.startMeasure() |
|||
val logger = CsvMeasurementLogger(directory.toFile(), listOf("Incar_Snr" to "")) |
|||
loggers.add(logger) |
|||
val ui = field(vm, "_uiState").get(vm) as MutableStateFlow<com.dct.app.presentation.main.MainUiState> |
|||
ui.value = ui.value.copy(recordingState = MeasurementRecordingState.RECORDING, |
|||
recordingStartedAtMillis = 1234, recordingSampleCount = 10) |
|||
val recovery = repository.streamRecovery as MutableStateFlow<com.dct.app.domain.repository.StreamRecoveryState> |
|||
val before = ui.value.packetCount |
|||
recovery.value = com.dct.app.domain.repository.StreamRecoveryState.RECOVERING |
|||
assertTrue(ui.value.isMeasuring) |
|||
assertTrue(ui.value.isStreamRecovering) |
|||
assertEquals(MeasurementRecordingState.RECORDING, ui.value.recordingState) |
|||
assertEquals(1234L, ui.value.recordingStartedAtMillis) |
|||
assertEquals(10L, ui.value.recordingSampleCount) |
|||
assertSame(logger, loggers.single()) |
|||
recovery.value = com.dct.app.domain.repository.StreamRecoveryState.RECEIVING |
|||
packets.tryEmit(DctPacket(0x02, ByteArray(18).also { |
|||
ByteBuffer.wrap(it).order(ByteOrder.LITTLE_ENDIAN).putFloat(10f).putFloat(2f).putFloat(3f).putFloat(4f) |
|||
})) |
|||
assertFalse(ui.value.isStreamRecovering) |
|||
assertEquals(before + 1, ui.value.packetCount) |
|||
assertEquals(11L, ui.value.recordingSampleCount) |
|||
assertEquals(1234L, ui.value.recordingStartedAtMillis) |
|||
assertSame(logger, loggers.single()) |
|||
vm.stopMeasure() |
|||
} |
|||
|
|||
@Test fun clearingLoggerListDuringPacketProcessingDoesNotKillSubscription() { |
|||
vm.startMeasure() |
|||
val subscribers = packets.subscriptionCount.value |
|||
val headers = object : AbstractList<Pair<String, String>>() { |
|||
override val size = 1 |
|||
override fun get(index: Int): Pair<String, String> { |
|||
loggers.clear() // Force STOP's list mutation between iterator steps. |
|||
return "test" to "" |
|||
} |
|||
} |
|||
loggers.add(CsvMeasurementLogger(directory.toFile(), headers)) |
|||
loggers.add(CsvMeasurementLogger(directory.toFile(), emptyList())) |
|||
val before = vm.uiState.value.packetCount |
|||
// Unknown commands are intentionally not counted as measurement data. |
|||
val telemetry = DctPacket(0x02, ByteArray(18)) |
|||
packets.tryEmit(telemetry) |
|||
packets.tryEmit(telemetry) |
|||
assertEquals(subscribers, packets.subscriptionCount.value) |
|||
assertEquals(before + 2, vm.uiState.value.packetCount) |
|||
} |
|||
|
|||
@Test fun measurementStartDoesNotAutomaticallyStartFileRecording() { |
|||
vm.setCurrentProject( |
|||
DpcProject( |
|||
measuredFilesFolder = directory.toString(), |
|||
writeCsv = true, |
|||
writeMf4 = true |
|||
) |
|||
) |
|||
|
|||
vm.startMeasure() |
|||
|
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
assertEquals(MeasurementRecordingState.IDLE, vm.uiState.value.recordingState) |
|||
assertTrue(loggers.isEmpty()) |
|||
val mf4Loggers = field(vm, "activeMf4Loggers").get(vm) as List<*> |
|||
assertTrue(mf4Loggers.isEmpty()) |
|||
} |
|||
|
|||
@Test fun malformedStreamIsDiagnosticOnlyAndDoesNotChangeToastStatus() { |
|||
vm.startMeasure() |
|||
val before = vm.uiState.value.statusMessage |
|||
// A3 requires a type byte and a complete payload structure. This is |
|||
// deliberately malformed and must be dropped without a user Toast. |
|||
packets.tryEmit(DctPacket(0xA3.toByte(), byteArrayOf(0x09))) |
|||
assertEquals(before, vm.uiState.value.statusMessage) |
|||
} |
|||
|
|||
@Test fun restartTimestampGraceAcceptsSmallClockSkewButDropsOlderPackets() { |
|||
vm.startMeasure() |
|||
val requestMillis = 1_000L |
|||
field(vm, "measurementRequestMillis").setLong(vm, requestMillis) |
|||
val before = vm.uiState.value.packetCount |
|||
|
|||
// A packet older than the 200 ms grace window belongs to the previous |
|||
// measurement session and must not update the dashboard. |
|||
packets.tryEmit(DctPacket(0x02, ByteArray(18), receivedAtMillis = requestMillis - 201L)) |
|||
assertEquals(before, vm.uiState.value.packetCount) |
|||
|
|||
// The exact boundary is intentionally accepted to tolerate the small |
|||
// wall-clock/monotonic-clock offset observed after STOP -> START. |
|||
packets.tryEmit(DctPacket(0x02, ByteArray(18), receivedAtMillis = requestMillis - 200L)) |
|||
assertEquals(before + 1, vm.uiState.value.packetCount) |
|||
} |
|||
|
|||
@Test fun packetProcessingExceptionDoesNotPreventStopStartOrReconnectReceiving() { |
|||
vm.chartRenderer.bindSignal("s", "Incar_Snr", com.dct.app.domain.model.chart.AxisPosition.LEFT_0, 0xFF0000L) |
|||
fun telemetry(value: Float) = DctPacket(0x02, ByteArray(18).also { |
|||
val buffer = ByteBuffer.wrap(it).order(ByteOrder.LITTLE_ENDIAN) |
|||
buffer.position(2) |
|||
buffer.putFloat(value).putFloat(2f).putFloat(3f).putFloat(4f) |
|||
}) |
|||
vm.startMeasure() |
|||
val subscribers = packets.subscriptionCount.value |
|||
val badHeaders = object : AbstractList<Pair<String, String>>() { |
|||
override val size = 1 |
|||
override fun get(index: Int): Pair<String, String> { |
|||
loggers.clear() |
|||
throw IllegalStateException("injected packet failure") |
|||
} |
|||
} |
|||
loggers.add(CsvMeasurementLogger(directory.toFile(), badHeaders)) |
|||
packets.tryEmit(telemetry(10f)) |
|||
// Processing failures are diagnostic-only and must not surface as a |
|||
// global Toast/status message while the subscription stays alive. |
|||
assertFalse(vm.uiState.value.statusMessage.orEmpty().contains("수신 패킷 처리 실패")) |
|||
assertEquals(subscribers, packets.subscriptionCount.value) |
|||
val before = vm.uiState.value.packetCount |
|||
vm.stopMeasure() |
|||
vm.startMeasure() |
|||
packets.tryEmit(telemetry(20f)) |
|||
assertEquals(before + 1, vm.uiState.value.packetCount) |
|||
assertEquals(20.0, vm.liveTelemetryValues.value["Incar_Snr"]) |
|||
state.value = DeviceConnectionState.ERROR |
|||
state.value = DeviceConnectionState.DISCONNECTED |
|||
state.value = DeviceConnectionState.READY |
|||
vm.syncDeviceConfiguration() |
|||
vm.startMeasure() |
|||
packets.tryEmit(telemetry(30f)) |
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
assertEquals(before + 2, vm.uiState.value.packetCount) |
|||
assertEquals(30.0, vm.liveTelemetryValues.value["Incar_Snr"]) |
|||
val buffer = vm.chartRenderer.seriesListFlow.value.single().buffer |
|||
assertEquals(30.0, buffer.getValueAt(buffer.size - 1)) |
|||
} |
|||
|
|||
@Test fun startWaitsForStopCompletionAndDuplicateStartIsNotSent() { |
|||
vm.startMeasure() |
|||
val stopAck = CompletableDeferred<DctResult<Unit>>() |
|||
coEvery { repository.stopStreaming() } coAnswers { stopAck.await() } |
|||
vm.stopMeasure() |
|||
vm.startMeasure() |
|||
vm.startMeasure() |
|||
coVerify(exactly = 1) { repository.startStreaming(any()) } |
|||
stopAck.complete(DctResult.Success(Unit)) |
|||
coVerify(exactly = 2) { repository.startStreaming(any()) } |
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
} |
|||
|
|||
@Test fun pendingConfigurationMustFinishBeforeStartAndFailureBlocksStart() { |
|||
val configAck = CompletableDeferred<DctResult<Unit>>() |
|||
coEvery { repository.configureMeasurement(any()) } coAnswers { configAck.await() } |
|||
vm.syncDeviceConfiguration() |
|||
vm.startMeasure() |
|||
coVerify(exactly = 0) { repository.startStreaming(any()) } |
|||
configAck.complete(DctResult.Success(Unit)) |
|||
coVerify(exactly = 1) { repository.startStreaming(any()) } |
|||
vm.stopMeasure() |
|||
coEvery { repository.configureMeasurement(any()) } returns DctResult.Failure(com.dct.app.core.error.DctError.Unknown("NACK")) |
|||
vm.syncDeviceConfiguration() |
|||
vm.startMeasure() |
|||
coVerify(exactly = 1) { repository.startStreaming(any()) } |
|||
assertFalse(vm.uiState.value.isMeasuring) |
|||
} |
|||
|
|||
@Test fun disconnectInvalidatesDelayedStartAck() { |
|||
val startAck = CompletableDeferred<DctResult<Unit>>() |
|||
coEvery { repository.startStreaming(any()) } coAnswers { startAck.await() } |
|||
vm.startMeasure() |
|||
vm.disconnectCommunication() |
|||
startAck.complete(DctResult.Success(Unit)) |
|||
assertFalse(vm.uiState.value.isMeasuring) |
|||
coVerify(exactly = 1) { repository.disconnect() } |
|||
assertFalse(vm.uiState.value.isConnected) |
|||
} |
|||
|
|||
@Test fun reconnectWaitsForDisconnectAndOldConnectionCallbackIsIgnored() { |
|||
val callbacks = mutableListOf<(Boolean, String) -> Unit>() |
|||
every { socket.startDualMode(any(), any(), any(), capture(callbacks), any(), any()) } just Runs |
|||
coEvery { repository.connect(any()) } returns DctResult.Success(Unit) |
|||
vm.connectWifi("first", "127.0.0.1") |
|||
assertEquals(1, callbacks.size) |
|||
val disconnectAck = CompletableDeferred<DctResult<Unit>>() |
|||
coEvery { repository.disconnect() } coAnswers { disconnectAck.await() } |
|||
vm.disconnectCommunication() |
|||
vm.connectWifi("second", "127.0.0.1") |
|||
assertEquals(1, callbacks.size) |
|||
callbacks[0](false, "stale") |
|||
disconnectAck.complete(DctResult.Success(Unit)) |
|||
assertEquals(2, callbacks.size) |
|||
coVerify(exactly = 0) { repository.connect("stale") } |
|||
callbacks[1](false, "current") |
|||
coVerify(exactly = 1) { repository.connect("current") } |
|||
vm.startMeasure() |
|||
assertTrue(vm.uiState.value.isMeasuring) |
|||
} |
|||
} |
|||
@ -1,396 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.data.communication.WifiApEndpoint |
|||
import com.dct.app.data.communication.WifiSocketManager |
|||
import com.dct.app.data.repository.PacketRepositoryImpl |
|||
import com.dct.app.domain.model.protocol.DctMeasurementConfiguration |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.domain.repository.DeviceConnectionState |
|||
import com.dct.app.domain.repository.StreamRecoveryState |
|||
import io.mockk.* |
|||
import kotlinx.coroutines.* |
|||
import kotlinx.coroutines.flow.MutableSharedFlow |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import kotlinx.coroutines.test.* |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.params.ParameterizedTest |
|||
import org.junit.jupiter.params.provider.ValueSource |
|||
|
|||
@OptIn(ExperimentalCoroutinesApi::class) |
|||
class MeasurementStreamRecoveryTest { |
|||
private class Fixture(val scope: TestScope, timeout: Long = 50, autoRecovery: Boolean = true) { |
|||
val wifi = mockk<WifiSocketManager>(relaxed = true) |
|||
val packets = MutableSharedFlow<DctPacket>(extraBufferCapacity = 32) |
|||
val connected = MutableStateFlow(true) |
|||
var session = 7L |
|||
var owner = 42L |
|||
var nextSession = 8L |
|||
val sent = mutableListOf<DctPacket>() |
|||
val times = mutableListOf<Long>() |
|||
val acks = mutableListOf<DctPacket>() |
|||
val reconnects = mutableListOf<Pair<Long, Long>>() |
|||
val events = mutableListOf<String>() |
|||
var silent: Int? = null |
|||
var reject: Int? = null |
|||
var reconnectWorks = true |
|||
var emptyStop = false |
|||
var endpoint: WifiApEndpoint? = WifiApEndpoint("192.168.4.1", 5000) |
|||
var holdCommand: Int? = null |
|||
val gate = CompletableDeferred<Unit>() |
|||
val dispatcher = UnconfinedTestDispatcher(scope.testScheduler) |
|||
init { |
|||
every { wifi.isConnected } returns connected |
|||
every { wifi.currentSessionId } answers { session } |
|||
every { wifi.recoveryGeneration } answers { owner } |
|||
every { wifi.recoveryEndpoint } answers { endpoint } |
|||
every { wifi.packetStream } returns packets |
|||
every { wifi.offerCommand(capture(acks)) } returns true |
|||
every { wifi.diagnosticEvent(any(), any()) } answers { events += secondArg<String>() } |
|||
coEvery { wifi.disconnectSuspend() } coAnswers { connected.value = false; session = 0; owner++ } |
|||
coEvery { wifi.reconnectForRecovery(any(), any(), any()) } coAnswers { |
|||
reconnects += firstArg<Long>() to secondArg<Long>() |
|||
if (firstArg<Long>() != owner || !reconnectWorks) false else { |
|||
connected.value = false |
|||
yield() |
|||
session = nextSession++ |
|||
connected.value = true |
|||
true |
|||
} |
|||
} |
|||
coEvery { wifi.sendCommand(any()) } coAnswers { |
|||
val request = firstArg<DctPacket>() |
|||
sent += request |
|||
times += scope.testScheduler.currentTime |
|||
val command = request.command.toInt() and 255 |
|||
if (holdCommand == command) gate.await() |
|||
if (silent != command && command !in listOf(0x0F, 0x17)) { |
|||
val data = when (command) { |
|||
1 -> byteArrayOf(1, 65) |
|||
3 -> ByteArray(6) |
|||
9 -> byteArrayOf(request.payload[0], 1) |
|||
0x08 -> byteArrayOf(0, 1) |
|||
0x20 -> byteArrayOf(1, 1) |
|||
5 -> byteArrayOf() |
|||
0x21 -> if (emptyStop) byteArrayOf() else byteArrayOf(1) |
|||
else -> byteArrayOf(1) |
|||
} |
|||
if (reject == command) data[0] = 2 |
|||
packets.emit(DctPacket((command + 0x80).toByte(), data, transportSessionId = request.transportSessionId)) |
|||
} |
|||
true |
|||
} |
|||
} |
|||
val repo = PacketRepositoryImpl(wifiSocketManager = wifi, ioDispatcher = dispatcher, |
|||
responseTimeoutMs = timeout, heartbeatIntervalMs = 40, heartbeatTimeoutMs = 20, |
|||
heartbeatDispatcher = dispatcher, recoveryDispatcher = dispatcher, |
|||
monotonicTimeMillis = { scope.testScheduler.currentTime }, streamSilenceTimeoutMs = 300, |
|||
recoveryDataTimeoutMs = 200, scope = scope.backgroundScope, |
|||
initialReceiveAutoRecoveryEnabled = autoRecovery) |
|||
suspend fun open(measure: Boolean = true) { |
|||
assertTrue(repo.connect("") is DctResult.Success) |
|||
assertTrue(repo.configureMeasurement(DctMeasurementConfiguration(projectName = "SavedProject", vehicleCode = "Car")) is DctResult.Success) |
|||
if (measure) assertTrue(repo.startStreaming() is DctResult.Success) |
|||
sent.clear(); times.clear() |
|||
} |
|||
suspend fun stream(valid: Boolean = true, from: Long = session) = packets.emit( |
|||
DctPacket(0xA3.toByte(), if (valid) byteArrayOf(1, 0xA0.toByte(), 9) else byteArrayOf(), transportSessionId = from)) |
|||
suspend fun enable() = packets.emit(DctPacket(0x80.toByte(), byteArrayOf(1), transportSessionId = session)) |
|||
fun controls() = sent.map { it.command.toInt() and 255 }.filter { it != 5 } |
|||
suspend fun close() { repo.disconnect() } |
|||
} |
|||
|
|||
@Test fun repositoryDefaultLeavesAutoRecoveryOff() = runTest { |
|||
assertFalse(PacketRepositoryImpl(scope = backgroundScope).receiveAutoRecoveryEnabled.value) |
|||
} |
|||
|
|||
@Test fun disabledRecoveryIgnoresSilenceHeartbeatTimeoutAndUnexpectedEnableButStillAcksData() = runTest { |
|||
val f = Fixture(this, autoRecovery = false); f.open() |
|||
assertFalse(f.repo.receiveAutoRecoveryEnabled.value) |
|||
f.silent = 5 |
|||
f.enable() |
|||
advanceTimeBy(20_000); runCurrent() |
|||
assertTrue(f.controls().isEmpty()) |
|||
assertEquals(StreamRecoveryState.IDLE, f.repo.streamRecovery.value) |
|||
assertEquals(DeviceConnectionState.MEASURING, f.repo.connectionState.value) |
|||
f.stream(); runCurrent() |
|||
assertEquals(1, f.acks.size) |
|||
assertTrue(f.repo.isStreaming.value) |
|||
assertTrue(f.reconnects.isEmpty()) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun disabledRecoveryDoesNotReconnectOnTcpLoss() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
f.repo.setReceiveAutoRecoveryEnabled(false) |
|||
f.session = 0; f.connected.value = false |
|||
advanceTimeBy(20_000); runCurrent() |
|||
assertTrue(f.reconnects.isEmpty()) |
|||
assertTrue(f.controls().isEmpty()) |
|||
assertEquals(DeviceConnectionState.ERROR, f.repo.connectionState.value) |
|||
assertEquals(StreamRecoveryState.IDLE, f.repo.streamRecovery.value) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun disablingDuringRecoveryCancelsPendingSetupAndAllLaterStarts() = runTest { |
|||
val f = Fixture(this); f.open(); f.holdCommand = 3 |
|||
advanceTimeBy(301); runCurrent() |
|||
assertEquals(StreamRecoveryState.RECOVERING, f.repo.streamRecovery.value) |
|||
f.repo.setReceiveAutoRecoveryEnabled(false) |
|||
val count = f.controls().size |
|||
f.gate.complete(Unit) |
|||
advanceTimeBy(20_000); runCurrent() |
|||
assertEquals(count, f.controls().size) |
|||
assertFalse(f.controls().contains(0x20)) |
|||
assertTrue(f.reconnects.isEmpty()) |
|||
assertEquals(StreamRecoveryState.IDLE, f.repo.streamRecovery.value) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun enablingDuringStalledMeasurementRestoresRecoveryWithoutManualRestart() = runTest { |
|||
val f = Fixture(this, autoRecovery = false); f.open() |
|||
advanceTimeBy(1_000); runCurrent() |
|||
f.repo.setReceiveAutoRecoveryEnabled(true) |
|||
advanceTimeBy(421); runCurrent() |
|||
assertEquals(1, f.controls().count { it == 0x20 }) |
|||
f.stream(); advanceTimeBy(25); runCurrent() |
|||
assertEquals(StreamRecoveryState.RECEIVING, f.repo.streamRecovery.value) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun disablingAfterStartKeepsNaturallyResumedTelemetryVisibleWithoutRetrying() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
advanceTimeBy(621); runCurrent() |
|||
assertEquals(StreamRecoveryState.RECOVERING, f.repo.streamRecovery.value) |
|||
assertFalse(f.repo.isStreaming.value) |
|||
f.repo.setReceiveAutoRecoveryEnabled(false) |
|||
val count = f.controls().size |
|||
f.stream(); runCurrent() |
|||
assertTrue(f.repo.isStreaming.value) |
|||
assertEquals(StreamRecoveryState.IDLE, f.repo.streamRecovery.value) |
|||
advanceTimeBy(2_000); runCurrent() |
|||
assertEquals(count, f.controls().size) |
|||
assertEquals(1, f.acks.size) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun togglingRecoveryDuringHealthyMeasurementDoesNotRestartPlayback() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
f.repo.setReceiveAutoRecoveryEnabled(false) |
|||
f.stream() |
|||
f.repo.setReceiveAutoRecoveryEnabled(true) |
|||
repeat(8) { advanceTimeBy(150); f.stream(); runCurrent() } |
|||
assertTrue(f.controls().isEmpty()) |
|||
assertEquals(9, f.acks.size) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun continuousValidDataNeverTriggersRecovery() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
repeat(20) { advanceTimeBy(150); f.stream(); runCurrent() } |
|||
assertEquals(StreamRecoveryState.IDLE, f.repo.streamRecovery.value) |
|||
assertTrue(f.controls().isEmpty()) |
|||
assertEquals(20, f.acks.size) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun heartbeatAndStartAckCannotCompleteRecoveryButRealDataCan() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
advanceTimeBy(299); runCurrent() |
|||
assertTrue(f.controls().isEmpty()) |
|||
advanceTimeBy(322); runCurrent() // 300 silence + 200 version gap + 120 DID setup. |
|||
assertEquals(StreamRecoveryState.RECOVERING, f.repo.streamRecovery.value) |
|||
assertEquals(DeviceConnectionState.MEASURING, f.repo.connectionState.value) |
|||
assertFalse(f.repo.isStreaming.value) |
|||
val controls = f.controls().size |
|||
assertTrue(f.repo.sendCommand(com.dct.app.data.protocol.DctProtocolRequests.hardwareId()) is DctResult.Failure) |
|||
assertEquals(controls, f.controls().size, "User commands must not interleave recovery setup") |
|||
assertTrue(f.sent.count { it.command == 5.toByte() } > 1) |
|||
assertTrue(f.controls().containsAll(listOf(0x21, 0, 1, 3, 4, 6, 8, 0x40, 0x11, 0x17, 9, 0x12, 0x20))) |
|||
val db = f.sent.single { it.command == 8.toByte() } |
|||
assertEquals("SavedProject", String(db.payload.copyOfRange(2, db.payload.size))) |
|||
advanceTimeBy(50); runCurrent() |
|||
assertEquals(StreamRecoveryState.RECOVERING, f.repo.streamRecovery.value) |
|||
f.stream(); advanceTimeBy(25); runCurrent() |
|||
assertEquals(StreamRecoveryState.RECEIVING, f.repo.streamRecovery.value) |
|||
assertTrue(f.repo.isStreaming.value) |
|||
verify { f.wifi.diagnosticEvent(7, match { it.startsWith("STREAM_RECOVERY_COMPLETE") }) } |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun duplicateEnableDuringHealthyStreamingDoesNotResetTheDevice() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
f.enable(); f.enable(); f.enable() |
|||
repeat(8) { advanceTimeBy(125); f.stream() } |
|||
runCurrent() |
|||
assertTrue(f.controls().isEmpty()) |
|||
assertEquals(StreamRecoveryState.RECEIVING, f.repo.streamRecovery.value) |
|||
assertEquals(8, f.acks.size) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun unsolicitedEnableWithNoDataRestoresSettingsAndStartsOnlyOnce() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
f.enable(); f.enable() |
|||
advanceTimeBy(1321); runCurrent() |
|||
assertEquals(1, f.controls().count { it == 0x20 }) |
|||
assertEquals(StreamRecoveryState.RECOVERING, f.repo.streamRecovery.value) |
|||
f.stream(); advanceTimeBy(25); runCurrent() |
|||
assertEquals(StreamRecoveryState.RECEIVING, f.repo.streamRecovery.value) |
|||
f.close() |
|||
} |
|||
|
|||
@ParameterizedTest @ValueSource(ints = [1, 9, 0x20]) |
|||
fun missingSetupResponseRetriesOnANewSessionWithoutEndingMeasurement(command: Int) = runTest { |
|||
val f = Fixture(this); f.open(); f.silent = command |
|||
var budget = 0L |
|||
while (f.events.none { it.startsWith("STREAM_RECOVERY_FAILED") } && budget < 20_000) { |
|||
advanceTimeBy(25); runCurrent(); budget += 25 |
|||
} |
|||
assertTrue(budget < 20_000) |
|||
assertEquals(DeviceConnectionState.MEASURING, f.repo.connectionState.value) |
|||
assertEquals(StreamRecoveryState.RECOVERING, f.repo.streamRecovery.value) |
|||
f.silent = null |
|||
budget = 0 |
|||
while (f.sent.none { it.command == 0x20.toByte() && it.transportSessionId == 8L } && budget < 5_000) { |
|||
advanceTimeBy(25); runCurrent(); budget += 25 |
|||
} |
|||
assertTrue(budget < 5_000) |
|||
assertEquals(listOf(42L to 7L), f.reconnects) |
|||
f.stream(from = 7) // Late bytes from the failed socket cannot complete recovery. |
|||
runCurrent() |
|||
assertEquals(StreamRecoveryState.RECOVERING, f.repo.streamRecovery.value) |
|||
f.stream(); advanceTimeBy(25); runCurrent() |
|||
assertEquals(StreamRecoveryState.RECEIVING, f.repo.streamRecovery.value) |
|||
assertTrue(f.sent.filter { it.transportSessionId != 7L }.all { it.transportSessionId == 8L }) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun startAckWithNoDataRetriesInsteadOfClaimingSuccess() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
advanceTimeBy(2825); runCurrent() |
|||
assertEquals(StreamRecoveryState.RECOVERING, f.repo.streamRecovery.value) |
|||
coVerify(exactly = 1) { f.wifi.reconnectForRecovery(42, 7, any()) } |
|||
advanceTimeBy(320); runCurrent() |
|||
f.stream(); advanceTimeBy(25); runCurrent() |
|||
assertEquals(StreamRecoveryState.RECEIVING, f.repo.streamRecovery.value) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun eofImmediatelyRecoversWhileKeepingMeasurementIntent() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
f.session = 0; f.connected.value = false; runCurrent() |
|||
assertEquals(DeviceConnectionState.MEASURING, f.repo.connectionState.value) |
|||
advanceTimeBy(321); runCurrent() |
|||
coVerify(exactly = 1) { f.wifi.reconnectForRecovery(42, 0, any()) } |
|||
f.stream(); advanceTimeBy(25); runCurrent() |
|||
assertTrue(f.repo.isStreaming.value) |
|||
assertEquals(StreamRecoveryState.RECEIVING, f.repo.streamRecovery.value) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun malformedDataDoesNotRenewTheSilenceBudget() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
repeat(3) { advanceTimeBy(100); f.stream(valid = false) } |
|||
runCurrent() |
|||
assertEquals(StreamRecoveryState.RECOVERING, f.repo.streamRecovery.value) |
|||
assertTrue(f.acks.all { it.payload.single() == 0.toByte() }) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun explicitStopDuringRecoveryCancelsAllLaterStartsAndRetries() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
advanceTimeBy(301); runCurrent() |
|||
assertTrue(f.repo.stopStreaming() is DctResult.Success) |
|||
val commands = f.controls().size |
|||
advanceTimeBy(20_000); runCurrent() |
|||
assertEquals(commands, f.controls().size) |
|||
assertFalse(f.controls().contains(0x20)) |
|||
assertEquals(DeviceConnectionState.READY, f.repo.connectionState.value) |
|||
assertEquals(StreamRecoveryState.IDLE, f.repo.streamRecovery.value) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun explicitStopAlsoWorksWhileTcpIsUnavailable() = runTest { |
|||
val f = Fixture(this); f.open(); f.reconnectWorks = false |
|||
f.session = 0; f.connected.value = false; runCurrent() |
|||
assertTrue(f.repo.stopStreaming() is DctResult.Success) |
|||
advanceTimeBy(20_000); runCurrent() |
|||
assertEquals(DeviceConnectionState.DISCONNECTED, f.repo.connectionState.value) |
|||
assertEquals(StreamRecoveryState.IDLE, f.repo.streamRecovery.value) |
|||
assertFalse(f.repo.isStreaming.value) |
|||
coVerify(exactly = 1) { f.wifi.reconnectForRecovery(any(), any(), any()) } |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun disconnectDuringRecoveryNeverReopensTheTransport() = runTest { |
|||
val f = Fixture(this); f.open() |
|||
advanceTimeBy(301); runCurrent() |
|||
f.close() |
|||
val commands = f.sent.size |
|||
advanceTimeBy(20_000); runCurrent() |
|||
assertEquals(commands, f.sent.size) |
|||
assertEquals(DeviceConnectionState.DISCONNECTED, f.repo.connectionState.value) |
|||
coVerify(exactly = 0) { f.wifi.reconnectForRecovery(any(), any(), any()) } |
|||
} |
|||
|
|||
@Test fun retryBackoffDoesNotSpinWhenDeviceIsUnavailable() = runTest { |
|||
val f = Fixture(this); f.open(); f.reconnectWorks = false |
|||
f.session = 0; f.connected.value = false; runCurrent() |
|||
advanceTimeBy(1999); runCurrent() |
|||
coVerify(exactly = 1) { f.wifi.reconnectForRecovery(any(), any(), any()) } |
|||
advanceTimeBy(1); runCurrent() |
|||
coVerify(exactly = 2) { f.wifi.reconnectForRecovery(any(), any(), any()) } |
|||
advanceTimeBy(3999); runCurrent() |
|||
coVerify(exactly = 2) { f.wifi.reconnectForRecovery(any(), any(), any()) } |
|||
advanceTimeBy(1); runCurrent() |
|||
coVerify(exactly = 3) { f.wifi.reconnectForRecovery(any(), any(), any()) } |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun readinessAloneDoesNotStartMeasurementAutomatically() = runTest { |
|||
val f = Fixture(this); f.open(measure = false) |
|||
advanceTimeBy(20_000); runCurrent() |
|||
assertTrue(f.controls().isEmpty()) |
|||
f.enable(); advanceTimeBy(250); runCurrent() |
|||
assertEquals(listOf(1, 9, 9), f.controls()) |
|||
assertEquals(DeviceConnectionState.READY, f.repo.connectionState.value) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun lostStartAckDoesNotResetAlreadyResumedFreshTelemetry() = runTest { |
|||
val f = Fixture(this); f.open(); f.silent = 0x20 |
|||
advanceTimeBy(621); runCurrent() |
|||
repeat(160) { advanceTimeBy(100); f.stream(); runCurrent() } |
|||
assertEquals(StreamRecoveryState.RECEIVING, f.repo.streamRecovery.value) |
|||
assertTrue(f.repo.isStreaming.value) |
|||
assertTrue(f.reconnects.isEmpty()) |
|||
assertEquals(1, f.controls().count { it == 0x20 }) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun legacyEmptyStopAckIsAcceptedDuringRecovery() = runTest { |
|||
val f = Fixture(this); f.open(); f.emptyStop = true |
|||
advanceTimeBy(621); runCurrent() |
|||
assertEquals(1, f.controls().count { it == 0x20 }) |
|||
f.stream(); advanceTimeBy(25); runCurrent() |
|||
assertEquals(StreamRecoveryState.RECEIVING, f.repo.streamRecovery.value) |
|||
assertTrue(f.reconnects.isEmpty()) |
|||
f.close() |
|||
} |
|||
|
|||
@Test fun manualStopCancelsARecoveryCommandWaitingForAnotherRequest() = runTest { |
|||
val f = Fixture(this, timeout = 2000); f.open(); f.holdCommand = 3 |
|||
val blocking = async { f.repo.sendCommand(com.dct.app.data.protocol.DctProtocolRequests.hardwareId()) } |
|||
runCurrent(); advanceTimeBy(301); runCurrent() |
|||
val stop = async { f.repo.stopStreaming() } |
|||
runCurrent(); f.gate.complete(Unit) |
|||
assertTrue(blocking.await() is DctResult.Success) |
|||
assertTrue(stop.await() is DctResult.Success) |
|||
assertEquals(listOf(3, 0x21), f.controls()) |
|||
advanceTimeBy(2000); runCurrent() |
|||
assertFalse(f.controls().contains(0x20)) |
|||
f.close() |
|||
} |
|||
} |
|||
@ -1,168 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.logger.CsvMeasurementLogger |
|||
import com.dct.app.data.logger.Mf4MeasurementLogger |
|||
import com.dct.app.data.logger.PcCsvColumn |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
import java.nio.ByteBuffer |
|||
import java.nio.ByteOrder |
|||
import java.text.SimpleDateFormat |
|||
import java.util.Date |
|||
import java.util.Locale |
|||
|
|||
class Mf4RecordingRegressionTest { |
|||
@TempDir lateinit var directory: File |
|||
private val startedAt = 1_790_923_490_000L |
|||
private fun bytes(file: File) = ByteBuffer.wrap(file.readBytes()).order(ByteOrder.LITTLE_ENDIAN) |
|||
private fun dt(buffer: ByteBuffer) = buffer.getLong(168 + 40).toInt() |
|||
private fun export(file: File) { |
|||
// Optional artifacts for an independent asammdf check, not an app dependency. |
|||
System.getenv("DCT_RECORDING_FIXTURES_DIR")?.let { path -> |
|||
File(path).apply { mkdirs() }.resolve(file.name).also { file.copyTo(it, overwrite = true) } |
|||
} |
|||
} |
|||
|
|||
@Test fun epochInputBecomesRelativeTimeWithoutChangingPhysicalValuesOrUnits() { |
|||
val headers = listOf("온도" to "°C", "Speed" to "km/h", "Missing" to "") |
|||
val logger = Mf4MeasurementLogger(directory, headers, "relative.mf4") |
|||
val file = logger.start(startedAt)!! |
|||
logger.logSample(startedAt / 1000.0 + 0.125, listOf(-12.5, 87.25, null)) |
|||
logger.logSample(startedAt / 1000.0 + 0.5, listOf(3.75, 88.0, Double.POSITIVE_INFINITY)) |
|||
logger.stop() |
|||
val data = bytes(file) |
|||
assertEquals(410, data.getShort(28).toInt()) |
|||
assertEquals(startedAt * 1_000_000, data.getLong(64 + 72)) |
|||
assertEquals(6L, data.getLong(232 + 16)) |
|||
assertEquals(2L, data.getLong(232 + 80)) |
|||
assertEquals(0.125, data.getDouble(dt(data) + 24), 0.000001) |
|||
assertEquals(0.5, data.getDouble(dt(data) + 24 + 32), 0.000001) |
|||
assertEquals(-12.5, data.getDouble(dt(data) + 32)) |
|||
assertTrue(data.getDouble(dt(data) + 48).isNaN()) |
|||
assertTrue(data.getDouble(dt(data) + 80).isNaN()) |
|||
export(file) |
|||
} |
|||
|
|||
@Test fun emptyMeasurementAndTimeOnlyFilesAreFinalized() { |
|||
for ((name, headers) in listOf("empty.mf4" to listOf("Signal" to "V"), |
|||
"time_only.mf4" to emptyList())) { |
|||
val logger = Mf4MeasurementLogger(directory, headers, name) |
|||
val file = logger.start(startedAt)!! |
|||
logger.stop() |
|||
logger.stop() // Idempotent close must not damage an empty recording. |
|||
val data = bytes(file) |
|||
assertEquals(0L, data.getLong(232 + 80)) |
|||
assertEquals(24L, data.getLong(dt(data) + 8)) |
|||
assertEquals(file.length(), dt(data) + 24L) |
|||
export(file) |
|||
} |
|||
} |
|||
|
|||
@Test fun wideDbcRecordingKeepsAllChannelsAndMissingTail() { |
|||
val headers = (0 until 4939).map { "DBC_$it" to if (it % 2 == 0) "V" else "" } |
|||
val logger = Mf4MeasurementLogger(directory, headers, "wide.mf4") |
|||
val file = logger.start(startedAt)!! |
|||
logger.logSample(startedAt / 1000.0 + 0.25, listOf(123.5)) |
|||
logger.stop() |
|||
val data = bytes(file) |
|||
assertEquals(1L, data.getLong(232 + 80)) |
|||
assertEquals(24L + 4940 * 8, data.getLong(dt(data) + 8)) |
|||
assertTrue(data.getDouble(data.limit() - 8).isNaN()) |
|||
export(file) |
|||
} |
|||
|
|||
@Test fun loggerRestartUsesNewOriginAndInvalidTimeDoesNotAddASample() { |
|||
val logger = Mf4MeasurementLogger(directory, listOf("Signal" to "V"), "restart.mf4") |
|||
assertNotNull(logger.start(startedAt)) |
|||
logger.logSample(startedAt / 1000.0 + 1.0, listOf(1.0)) |
|||
logger.stop() |
|||
val file = logger.start(startedAt + 5000)!! |
|||
logger.logSample(Double.NaN, listOf(99.0)) |
|||
logger.logSample((startedAt + 5000) / 1000.0 + 0.25, listOf(2.0)) |
|||
logger.stop() |
|||
val data = bytes(file) |
|||
assertEquals(1L, data.getLong(232 + 80)) |
|||
assertEquals(0.25, data.getDouble(dt(data) + 24), 0.000001) |
|||
export(file) |
|||
} |
|||
|
|||
@Test fun pcCsvUsesPacketTimeRatherThanDiskWriteTimeAndMatchesMf4Rows() { |
|||
val headers = listOf("Signal" to "V") |
|||
val csv = CsvMeasurementLogger(directory, headers, "paired.csv", listOf(PcCsvColumn("0", "[0x1]")), |
|||
withMilliseconds = true) |
|||
val mf4 = Mf4MeasurementLogger(directory, headers, "paired.mf4") |
|||
val csvFile = csv.start()!! |
|||
val mf4File = mf4.start(startedAt)!! |
|||
for ((offset, value) in listOf(0.125 to 12.25, 0.5 to -3.5)) { |
|||
val packetTime = startedAt / 1000.0 + offset |
|||
csv.logSample(packetTime, listOf(value)) |
|||
mf4.logSample(packetTime, listOf(value)) |
|||
} |
|||
csv.stop() |
|||
mf4.stop() |
|||
val rows = csvFile.readLines().drop(7) |
|||
assertEquals(2, rows.size) |
|||
assertTrue(rows[0].startsWith(SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.US).format(Date(startedAt + 125)))) |
|||
assertTrue(rows[0].endsWith(", 0,12.250")) |
|||
assertTrue(rows[1].endsWith(", 1,-3.500")) |
|||
assertEquals(rows.size.toLong(), bytes(mf4File).getLong(232 + 80)) |
|||
export(csvFile) |
|||
export(mf4File) |
|||
} |
|||
|
|||
@Test fun queuedPacketsBeforeSharedOriginKeepTheirCsvTimeAcrossSources() { |
|||
// Reproduce HE1i: ingress .905/.906 precedes the common header origin .915. |
|||
val originMillis = startedAt + 915 |
|||
val originSec = originMillis / 1000.0 |
|||
for ((source, earlyMillis) in listOf("mdb" to 905, "dbc" to 906, "formula" to 905)) { |
|||
val headers = listOf("Signal" to "V") |
|||
val csv = CsvMeasurementLogger(directory, headers, "queued_$source.csv", |
|||
listOf(PcCsvColumn("0", "[0x1]")), withMilliseconds = true) |
|||
val mf4 = Mf4MeasurementLogger(directory, headers, "queued_$source.mf4") |
|||
val csvFile = csv.start()!! |
|||
val mf4File = mf4.start(originMillis)!! |
|||
val packetMillis = listOf(startedAt + earlyMillis, originMillis, originMillis + 125) |
|||
for ((index, millis) in packetMillis.withIndex()) { |
|||
val packetSec = millis / 1000.0 |
|||
csv.logSample(packetSec, listOf(index.toDouble())) |
|||
mf4.logSample(packetSec, listOf(index.toDouble())) |
|||
} |
|||
csv.stop() |
|||
mf4.stop() |
|||
val data = bytes(mf4File) |
|||
val rows = csvFile.readLines().drop(7) |
|||
assertEquals(originMillis * 1_000_000, data.getLong(64 + 72)) |
|||
assertEquals(3L, data.getLong(232 + 80)) |
|||
assertEquals(3, rows.size) |
|||
assertTrue(data.getDouble(dt(data) + 24) < 0.0, "Queued ingress must not be clamped to zero") |
|||
for ((index, millis) in packetMillis.withIndex()) { |
|||
val relativeSec = data.getDouble(dt(data) + 24 + index * 16) |
|||
assertEquals(millis / 1000.0 - originSec, relativeSec, 0.000001) |
|||
assertEquals(millis / 1000.0, originSec + relativeSec, 0.000001) |
|||
val expectedClock = SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.US).format(Date(millis)) |
|||
assertTrue(rows[index].startsWith("$expectedClock, $index,")) |
|||
assertEquals(index.toDouble(), data.getDouble(dt(data) + 32 + index * 16)) |
|||
} |
|||
export(csvFile) |
|||
export(mf4File) |
|||
} |
|||
} |
|||
|
|||
@Test fun queuedPacketAcrossMidnightKeepsThePreviousDayIngressTime() { |
|||
val originMillis = 1_790_985_600_005L |
|||
val originSec = originMillis / 1000.0 |
|||
val logger = Mf4MeasurementLogger(directory, listOf("Signal" to "V"), "queued_midnight.mf4") |
|||
val file = logger.start(originMillis)!! |
|||
val packetMillis = originMillis - 10 |
|||
logger.logSample(packetMillis / 1000.0, listOf(7.0)) |
|||
logger.stop() |
|||
val data = bytes(file) |
|||
val relativeSec = data.getDouble(dt(data) + 24) |
|||
assertEquals(-0.01, relativeSec, 0.000001) |
|||
assertEquals(packetMillis / 1000.0, originSec + relativeSec, 0.000001) |
|||
assertEquals(1L, data.getLong(232 + 80)) |
|||
export(file) |
|||
} |
|||
} |
|||
@ -1,139 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.ringbuffer.TimeSeriesRingBuffer |
|||
import com.dct.app.domain.model.chart.DownsamplingAlgorithms |
|||
import org.junit.jupiter.api.Assertions.assertEquals |
|||
import org.junit.jupiter.api.Assertions.assertTrue |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import kotlin.math.sin |
|||
import kotlin.system.measureTimeMillis |
|||
|
|||
@DisplayName("MinMaxDownsampler 픽셀 컬럼 다운샘플링 단위 테스트") |
|||
class MinMaxDownsamplerTest { |
|||
|
|||
@Test |
|||
@DisplayName("10,000개 데이터 포인트를 500픽셀로 압축 시 80% 이상의 축소율을 달성해야 한다") |
|||
fun testDataCompressionRatio() { |
|||
val totalPoints = 10_000 |
|||
val buffer = TimeSeriesRingBuffer(totalPoints) |
|||
for (i in 0 until totalPoints) { |
|||
val t = i * 0.001 |
|||
val v = sin(t * 10.0) * 100.0 |
|||
buffer.addSample(t, v) |
|||
} |
|||
|
|||
val screenWidthPx = 500 |
|||
val downsampled = DownsamplingAlgorithms.minMaxDownsample( |
|||
buffer = buffer, |
|||
firstIdx = 0, |
|||
lastIdx = totalPoints - 1, |
|||
tMin = 0.0, |
|||
tMax = 10.0, |
|||
screenWidthPx = screenWidthPx |
|||
) |
|||
|
|||
// 화면 너비 500픽셀 기준 최대 2000개 이하로 압축 |
|||
assertTrue(downsampled.size <= screenWidthPx * 4, "압축된 포인트 개수가 4W 이하여야 함: ${downsampled.size}") |
|||
val reductionRatio = 1.0 - (downsampled.size.toDouble() / totalPoints.toDouble()) |
|||
assertTrue(reductionRatio >= 0.75, "압축률이 75% 이상이어야 합니다 (실제: ${reductionRatio * 100}%)") |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("중간에 발생한 급격한 임펄스 스파이크 Peak 및 Valley 극값이 100% 보존되어야 한다") |
|||
fun testImpulsePeakAndValleyPreservation() { |
|||
val totalPoints = 5_000 |
|||
val buffer = TimeSeriesRingBuffer(totalPoints) |
|||
|
|||
val spikeIndex = 2500 |
|||
val valleyIndex = 3500 |
|||
|
|||
for (i in 0 until totalPoints) { |
|||
val t = i * 0.01 |
|||
var v = 10.0 |
|||
if (i == spikeIndex) { |
|||
v = 9999.0 // 극단적 피크 |
|||
} else if (i == valleyIndex) { |
|||
v = -9999.0 // 극단적 밸리 |
|||
} |
|||
buffer.addSample(t, v) |
|||
} |
|||
|
|||
val downsampled = DownsamplingAlgorithms.minMaxDownsample( |
|||
buffer = buffer, |
|||
firstIdx = 0, |
|||
lastIdx = totalPoints - 1, |
|||
tMin = 0.0, |
|||
tMax = 50.0, |
|||
screenWidthPx = 300 |
|||
) |
|||
|
|||
val values = downsampled.map { it.second } |
|||
val maxVal = values.maxOrNull() ?: Double.MIN_VALUE |
|||
val minVal = values.minOrNull() ?: Double.MAX_VALUE |
|||
|
|||
assertEquals(9999.0, maxVal, 1e-6, "최대 피크가 완벽히 보존되어야 합니다") |
|||
assertEquals(-9999.0, minVal, 1e-6, "최소 밸리가 완벽히 보존되어야 합니다") |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("계단형 PWM 디지털 신호의 On/Off 엣지가 손실 없이 보존되어야 한다") |
|||
fun testPwmSignalEdgePreservation() { |
|||
val totalPoints = 2_000 |
|||
val buffer = TimeSeriesRingBuffer(totalPoints) |
|||
|
|||
// 100ms마다 0과 1이 교차하는 PWM 신호 |
|||
for (i in 0 until totalPoints) { |
|||
val t = i * 0.01 |
|||
val v = if ((i / 10) % 2 == 0) 1.0 else 0.0 |
|||
buffer.addSample(t, v) |
|||
} |
|||
|
|||
val downsampled = DownsamplingAlgorithms.minMaxDownsample( |
|||
buffer = buffer, |
|||
firstIdx = 0, |
|||
lastIdx = totalPoints - 1, |
|||
tMin = 0.0, |
|||
tMax = 20.0, |
|||
screenWidthPx = 200 |
|||
) |
|||
|
|||
val values = downsampled.map { it.second } |
|||
assertTrue(values.contains(0.0), "PWM Low 레벨이 포함되어야 합니다") |
|||
assertTrue(values.contains(1.0), "PWM High 레벨이 포함되어야 합니다") |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("10,000개 포인트 다운샘플링 수행 시간이 10ms 이내여야 한다") |
|||
fun testPerformanceBenchmark() { |
|||
val totalPoints = 10_000 |
|||
val buffer = TimeSeriesRingBuffer(totalPoints) |
|||
for (i in 0 until totalPoints) { |
|||
buffer.addSample(i * 0.001, (i % 50).toDouble()) |
|||
} |
|||
|
|||
// 워밍업 |
|||
DownsamplingAlgorithms.minMaxDownsample(buffer, 0, totalPoints - 1, 0.0, 10.0, 1000) |
|||
|
|||
val elapsed = measureTimeMillis { |
|||
for (iter in 0 until 10) { |
|||
DownsamplingAlgorithms.minMaxDownsample(buffer, 0, totalPoints - 1, 0.0, 10.0, 1000) |
|||
} |
|||
} |
|||
|
|||
val avgTime = elapsed / 10.0 |
|||
assertTrue(avgTime < 10.0, "평균 다운샘플링 소요 시간이 10ms 이내여야 합니다 (실제: ${avgTime}ms)") |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("다운샘플링 시 단절 NaN 마커가 같은 픽셀 버킷에 흡수되지 않아야 한다") |
|||
fun testGapMarkerSurvivesDownsampling() { |
|||
val buffer = TimeSeriesRingBuffer(7_000) |
|||
for (i in 0 until 3_500) buffer.addSample(i * 0.01, 1.0) |
|||
buffer.addGap(35.0) |
|||
for (i in 3_501 until 7_000) buffer.addSample(i * 0.01, 2.0) |
|||
|
|||
val points = DownsamplingAlgorithms.minMaxDownsample(buffer, 0, buffer.size - 1, 0.0, 70.0, 100) |
|||
assertTrue(points.any { it.second.isNaN() }, "단절 마커가 다운샘플링 결과에 남아야 합니다") |
|||
} |
|||
} |
|||
@ -1,203 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.model.chart.ChartAxisConfig |
|||
import com.dct.app.domain.model.chart.MultiAxisCoordinateTransformer |
|||
import org.junit.jupiter.api.Assertions.assertEquals |
|||
import org.junit.jupiter.api.Assertions.assertTrue |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
@DisplayName("MultiAxisCoordinateTransformer 단일축 및 다중축 좌표 변환 단위 테스트 (PC 레거시 1:1 검증)") |
|||
class MultiAxisCoordinateTransformTest { |
|||
|
|||
@Test |
|||
@DisplayName("시간에서 스크린 X 픽셀로의 변환 및 역변환 Round-trip 오차가 0.001% 미만이어야 한다") |
|||
fun testTimeCoordinateRoundTrip() { |
|||
val tMin = 10.0 |
|||
val tMax = 30.0 |
|||
val plotLeft = 100f |
|||
val plotWidth = 800f |
|||
|
|||
val testTimes = listOf(10.0, 15.0, 20.0, 25.5, 30.0) |
|||
|
|||
for (t in testTimes) { |
|||
val screenX = MultiAxisCoordinateTransformer.timeToScreenX( |
|||
timeSec = t, |
|||
tMinSec = tMin, |
|||
tMaxSec = tMax, |
|||
plotLeft = plotLeft, |
|||
plotWidth = plotWidth |
|||
) |
|||
|
|||
if (t == 10.0) assertEquals(100f, screenX, 1e-4f) |
|||
if (t == 30.0) assertEquals(900f, screenX, 1e-4f) |
|||
if (t == 20.0) assertEquals(500f, screenX, 1e-4f) |
|||
|
|||
val recoveredTime = MultiAxisCoordinateTransformer.screenXToTime( |
|||
screenX = screenX, |
|||
tMinSec = tMin, |
|||
tMaxSec = tMax, |
|||
plotLeft = plotLeft, |
|||
plotWidth = plotWidth |
|||
) |
|||
|
|||
val error = kotlin.math.abs(recoveredTime - t) |
|||
assertTrue(error < 1e-5, "Round-trip 시간 오차가 1e-5 미만이어야 함 (오차: $error)") |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("서로 다른 4개 Y축 범위에 대해 물리값과 Y픽셀 간의 정확한 독립 변환이 이루어져야 한다") |
|||
fun testMultiAxisValueToScreenY() { |
|||
val plotTop = 50f |
|||
val plotHeight = 400f |
|||
|
|||
val rpmAxis = ChartAxisConfig( |
|||
position = AxisPosition.LEFT_0, |
|||
minVal = 0.0, |
|||
maxVal = 8000.0 |
|||
) |
|||
val y0 = MultiAxisCoordinateTransformer.valueToScreenY(0.0, rpmAxis.minVal, rpmAxis.maxVal, plotTop, plotHeight) |
|||
assertEquals(450f, y0, 1e-4f) |
|||
|
|||
val yMax = MultiAxisCoordinateTransformer.valueToScreenY(8000.0, rpmAxis.minVal, rpmAxis.maxVal, plotTop, plotHeight) |
|||
assertEquals(50f, yMax, 1e-4f) |
|||
|
|||
val yMid = MultiAxisCoordinateTransformer.valueToScreenY(4000.0, rpmAxis.minVal, rpmAxis.maxVal, plotTop, plotHeight) |
|||
assertEquals(250f, yMid, 1e-4f) |
|||
|
|||
val tempAxis = ChartAxisConfig( |
|||
position = AxisPosition.LEFT_1, |
|||
minVal = -40.0, |
|||
maxVal = 120.0 |
|||
) |
|||
assertEquals(450f, MultiAxisCoordinateTransformer.valueToScreenY(-40.0, tempAxis.minVal, tempAxis.maxVal, plotTop, plotHeight), 1e-4f) |
|||
assertEquals(50f, MultiAxisCoordinateTransformer.valueToScreenY(120.0, tempAxis.minVal, tempAxis.maxVal, plotTop, plotHeight), 1e-4f) |
|||
assertEquals(250f, MultiAxisCoordinateTransformer.valueToScreenY(40.0, tempAxis.minVal, tempAxis.maxVal, plotTop, plotHeight), 1e-4f) |
|||
|
|||
val voltAxis = ChartAxisConfig( |
|||
position = AxisPosition.LEFT_2, |
|||
minVal = 10.0, |
|||
maxVal = 15.0 |
|||
) |
|||
assertEquals(450f, MultiAxisCoordinateTransformer.valueToScreenY(10.0, voltAxis.minVal, voltAxis.maxVal, plotTop, plotHeight), 1e-4f) |
|||
assertEquals(50f, MultiAxisCoordinateTransformer.valueToScreenY(15.0, voltAxis.minVal, voltAxis.maxVal, plotTop, plotHeight), 1e-4f) |
|||
assertEquals(250f, MultiAxisCoordinateTransformer.valueToScreenY(12.5, voltAxis.minVal, voltAxis.maxVal, plotTop, plotHeight), 1e-4f) |
|||
|
|||
val throttleAxis = ChartAxisConfig( |
|||
position = AxisPosition.LEFT_3, |
|||
minVal = 0.0, |
|||
maxVal = 100.0 |
|||
) |
|||
assertEquals(450f, MultiAxisCoordinateTransformer.valueToScreenY(0.0, throttleAxis.minVal, throttleAxis.maxVal, plotTop, plotHeight), 1e-4f) |
|||
assertEquals(50f, MultiAxisCoordinateTransformer.valueToScreenY(100.0, throttleAxis.minVal, throttleAxis.maxVal, plotTop, plotHeight), 1e-4f) |
|||
assertEquals(250f, MultiAxisCoordinateTransformer.valueToScreenY(50.0, throttleAxis.minVal, throttleAxis.maxVal, plotTop, plotHeight), 1e-4f) |
|||
|
|||
val recoveredRpm = MultiAxisCoordinateTransformer.screenYToValue(250f, rpmAxis.minVal, rpmAxis.maxVal, plotTop, plotHeight) |
|||
assertEquals(4000.0, recoveredRpm, 1e-4) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("축 경계에 닿은 파형은 선 두께만큼 안쪽에 보이고 범위 밖 값은 클리핑 좌표를 유지한다") |
|||
fun testVisibleSignalStrokeAtPlotEdges() { |
|||
val top = 50f |
|||
val height = 400f |
|||
assertEquals(53f, MultiAxisCoordinateTransformer.valueToVisibleStrokeY(100.0, 0.0, 100.0, top, height, 3f), 1e-4f) |
|||
assertEquals(447f, MultiAxisCoordinateTransformer.valueToVisibleStrokeY(0.0, 0.0, 100.0, top, height, 3f), 1e-4f) |
|||
assertEquals(250f, MultiAxisCoordinateTransformer.valueToVisibleStrokeY(50.0, 0.0, 100.0, top, height, 3f), 1e-4f) |
|||
assertEquals(52f, MultiAxisCoordinateTransformer.valueToVisibleStrokeY(100.0, 0.0, 100.0, top, height, 1f), 1e-4f) |
|||
assertEquals(49f, MultiAxisCoordinateTransformer.valueToVisibleStrokeY(100.25, 0.0, 100.0, top, height, 3f), 1e-4f) |
|||
assertEquals(451f, MultiAxisCoordinateTransformer.valueToVisibleStrokeY(-0.25, 0.0, 100.0, top, height, 3f), 1e-4f) |
|||
assertEquals(50f, MultiAxisCoordinateTransformer.valueToScreenY(100.0, 0.0, 100.0, top, height), 1e-4f) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("PC CChartStandardAxis 알고리즘에 따라 [-50 ~ 100] 범위는 10단위 16개 눈금이 정확히 생성되어야 한다") |
|||
fun testGenerateStandardTicksLegacyPC() { |
|||
val ticks = MultiAxisCoordinateTransformer.generateStandardTicks( |
|||
minVal = -50.0, |
|||
maxVal = 100.0, |
|||
heightPx = 300f, |
|||
pixelSpace = 20 |
|||
) |
|||
|
|||
val expected = listOf(-50.0, -40.0, -30.0, -20.0, -10.0, 0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0) |
|||
assertEquals(expected.size, ticks.size, "눈금 개수는 16개여야 함") |
|||
for (i in expected.indices) { |
|||
assertEquals(expected[i], ticks[i], 1e-5, "인덱스 $i 눈금 불일치") |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("PC CChartDateTimeAxis 알고리즘에 따라 시간 타임스탬프가 정수 스냅 단위로 정렬 생성되어야 한다") |
|||
fun testGenerateTimeTicksLegacyPC() { |
|||
// 30초 윈도우 (56850.0 ~ 56880.0) |
|||
val timeTicks = MultiAxisCoordinateTransformer.generateTimeTicks( |
|||
tMinSec = 56850.0, |
|||
tMaxSec = 56880.0, |
|||
widthPx = 500f, |
|||
pixelSpace = 100 |
|||
) |
|||
|
|||
assertTrue(timeTicks.isNotEmpty()) |
|||
for (t in timeTicks) { |
|||
// 모든 틱이 5초 또는 10초, 30초 등 정수 초 단위로 스냅 정렬 |
|||
assertEquals(0.0, t % 1.0, 1e-5, "틱은 정수 초 단위여야 함") |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("현재 그래프 여백: 단일축 58px, 다중축 12px + 축 너비 합계") |
|||
fun testLeftMarginCalculations() { |
|||
val widthPerAxis = 42f |
|||
|
|||
assertEquals(58f, MultiAxisCoordinateTransformer.calculateLeftMargin(1, isMultiAxis = false, axisWidthPx = widthPerAxis), 1e-4f) |
|||
assertEquals(58f, MultiAxisCoordinateTransformer.calculateLeftMargin(3, isMultiAxis = false, axisWidthPx = widthPerAxis), 1e-4f) |
|||
|
|||
assertEquals(58f, MultiAxisCoordinateTransformer.calculateLeftMargin(1, isMultiAxis = true, axisWidthPx = widthPerAxis), 1e-4f) |
|||
assertEquals(96f, MultiAxisCoordinateTransformer.calculateLeftMargin(2, isMultiAxis = true, axisWidthPx = widthPerAxis), 1e-4f) |
|||
assertEquals(138f, MultiAxisCoordinateTransformer.calculateLeftMargin(3, isMultiAxis = true, axisWidthPx = widthPerAxis), 1e-4f) |
|||
assertEquals(180f, MultiAxisCoordinateTransformer.calculateLeftMargin(4, isMultiAxis = true, axisWidthPx = widthPerAxis), 1e-4f) |
|||
assertEquals(180f, MultiAxisCoordinateTransformer.calculateLeftMargin(5, isMultiAxis = true, axisWidthPx = widthPerAxis), 1e-4f) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("일반 그래프는 우측 외부 범례, 다중축 그래프는 하단 외부 범례 여백을 정확히 계산해야 한다") |
|||
fun testPlotBoundsByGraphType() { |
|||
val canvasWidth = 1000f |
|||
val canvasHeight = 600f |
|||
|
|||
// 1. 일반 그래프 (단일축, 우측 외부 범례 120px) |
|||
val singleBounds = MultiAxisCoordinateTransformer.calculatePlotBounds( |
|||
canvasWidth = canvasWidth, |
|||
canvasHeight = canvasHeight, |
|||
leftAxisCount = 1, |
|||
isMultiAxis = false, |
|||
hasLegend = true, |
|||
legendWidthPx = 110f |
|||
) |
|||
assertEquals(58f, singleBounds.left, 1e-4f) |
|||
// rightMargin = (110 + 28).coerceIn(110..240) = 138f -> right = 1000 - 138 = 862f |
|||
assertEquals(862f, singleBounds.right, 1e-4f) |
|||
assertEquals(12f, singleBounds.top, 1e-4f) |
|||
// bottomMargin = 24f -> bottom = 600 - 24 = 576f |
|||
assertEquals(576f, singleBounds.bottom, 1e-4f) |
|||
|
|||
// 2. 다중축 그래프 (다중축 2개, 하단 외부 범례 62px) |
|||
val multiBounds = MultiAxisCoordinateTransformer.calculatePlotBounds( |
|||
canvasWidth = canvasWidth, |
|||
canvasHeight = canvasHeight, |
|||
leftAxisCount = 2, |
|||
isMultiAxis = true, |
|||
hasLegend = true, |
|||
legendPosition = 2, |
|||
axisWidthPx = 42f |
|||
) |
|||
assertEquals(96f, multiBounds.left, 1e-4f) |
|||
assertEquals(984f, multiBounds.right, 1e-4f) |
|||
assertEquals(12f, multiBounds.top, 1e-4f) |
|||
// bottomMargin = 24 + 32 + 4 = 60f |
|||
assertEquals(540f, multiBounds.bottom, 1e-4f) |
|||
} |
|||
} |
|||
@ -1,123 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.google.common.truth.Truth.assertThat |
|||
import com.dct.app.data.protocol.DctPacketCodec |
|||
import com.dct.app.domain.model.protocol.DctCommand |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import org.junit.jupiter.api.BeforeEach |
|||
import org.junit.jupiter.api.DisplayName |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.params.ParameterizedTest |
|||
import org.junit.jupiter.params.provider.EnumSource |
|||
|
|||
@DisplayName("PacketFramingAndCodec (DctPacketCodec) 인코딩/디코딩 단위 테스트") |
|||
class PacketFramingAndCodecTest { |
|||
|
|||
private lateinit var codec: DctPacketCodec |
|||
|
|||
@BeforeEach |
|||
fun setUp() { |
|||
codec = DctPacketCodec() |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("C++ 호환 ENABLE 커맨드 패킷 인코딩 구조 및 바이트 정합성 검증") |
|||
fun testEncodeEnableCommand() { |
|||
// ENABLE 커맨드 (0x00), Payload 0바이트 -> packLen = 1 |
|||
val packet = DctPacket.create(DctCommand.CMD_ENABLE) |
|||
val encoded = codec.encode(packet) |
|||
|
|||
// 기대 크기: packLen(1) + 5 = 6 Bytes |
|||
assertThat(encoded.size).isEqualTo(6) |
|||
assertThat(encoded[0]).isEqualTo(0xA1.toByte()) // Header |
|||
assertThat(encoded[1]).isEqualTo(0x00.toByte()) // LenH |
|||
assertThat(encoded[2]).isEqualTo(0x01.toByte()) // LenL |
|||
assertThat(encoded[3]).isEqualTo(0x00.toByte()) // CmdID (CMD_ENABLE) |
|||
|
|||
// Checksum: (0xA1 + 0x00 + 0x01 + 0x00 = 0xA2) ^ 0xFF = 0x5D |
|||
assertThat(encoded[4]).isEqualTo(0x5D.toByte()) |
|||
assertThat(encoded[5]).isEqualTo(0x7E.toByte()) // Footer |
|||
|
|||
// 디코딩 검증 |
|||
val decoded = codec.decode(encoded) |
|||
assertThat(decoded).isNotNull() |
|||
assertThat(decoded?.command).isEqualTo(DctCommand.CMD_ENABLE.code) |
|||
assertThat(decoded?.payload).isEmpty() |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@EnumSource(DctCommand::class) |
|||
@DisplayName("모든 DctCommand에 대한 인코딩 및 디코딩 왕복(Round-trip) 무결성 검증") |
|||
fun testAllCommandsRoundTrip(command: DctCommand) { |
|||
val dummyPayload = byteArrayOf(0x01, 0x02, 0x03, 0x04) |
|||
val originalPacket = DctPacket.create(command, dummyPayload, sequence = 42) |
|||
|
|||
val frame = codec.encode(originalPacket) |
|||
assertThat(codec.isValidFrame(frame)).isTrue() |
|||
|
|||
val decoded = codec.decode(frame, sequence = 42) |
|||
assertThat(decoded).isNotNull() |
|||
assertThat(decoded?.command).isEqualTo(command.code) |
|||
assertThat(decoded?.payload).isEqualTo(dummyPayload) |
|||
assertThat(decoded?.sequence).isEqualTo(42) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("Big-Endian 길이 필드 직렬화 검증 (대용량 1000바이트 페이로드)") |
|||
fun testLargePayloadBigEndianLengthEncoding() { |
|||
val largePayload = ByteArray(1000) { (it and 0xFF).toByte() } |
|||
val packet = DctPacket(command = DctCommand.SEND_CAN_FRAME.code, payload = largePayload) |
|||
|
|||
val encoded = codec.encode(packet) |
|||
val packLen = 1000 + 1 // 1001 = 0x03E9 |
|||
assertThat(packLen).isEqualTo(1001) |
|||
|
|||
assertThat(encoded.size).isEqualTo(1001 + 5) |
|||
assertThat(encoded[0]).isEqualTo(0xA1.toByte()) |
|||
assertThat(encoded[1]).isEqualTo(0x03.toByte()) // LenH |
|||
assertThat(encoded[2]).isEqualTo(0xE9.toByte()) // LenL |
|||
assertThat(encoded[3]).isEqualTo(DctCommand.SEND_CAN_FRAME.code) |
|||
assertThat(encoded[encoded.size - 1]).isEqualTo(0x7E.toByte()) |
|||
|
|||
val decoded = codec.decode(encoded) |
|||
assertThat(decoded).isNotNull() |
|||
assertThat(decoded?.payload?.size).isEqualTo(1000) |
|||
assertThat(decoded?.payload).isEqualTo(largePayload) |
|||
} |
|||
|
|||
@Test |
|||
@DisplayName("손상된 프레임은 decode 실패 및 isValidFrame false 반환") |
|||
fun testCorruptedFrames() { |
|||
val validPacket = DctPacket.create(DctCommand.CMD_VERSION, "V1.0".toByteArray()) |
|||
val validFrame = codec.encode(validPacket) |
|||
|
|||
// 1. 헤더 바이트 손상 |
|||
val badHeader = validFrame.copyOf() |
|||
badHeader[0] = 0x00 |
|||
assertThat(codec.decode(badHeader)).isNull() |
|||
assertThat(codec.isValidFrame(badHeader)).isFalse() |
|||
|
|||
// 2. 푸터 바이트 손상 |
|||
val badFooter = validFrame.copyOf() |
|||
badFooter[badFooter.size - 1] = 0x00 |
|||
assertThat(codec.decode(badFooter)).isNull() |
|||
assertThat(codec.isValidFrame(badFooter)).isFalse() |
|||
|
|||
// 3. 길이 필드 변조 |
|||
val badLen = validFrame.copyOf() |
|||
badLen[2] = (badLen[2] + 1).toByte() |
|||
assertThat(codec.decode(badLen)).isNull() |
|||
assertThat(codec.isValidFrame(badLen)).isFalse() |
|||
|
|||
// 4. 체크섬 바이트 변조 |
|||
val badChecksum = validFrame.copyOf() |
|||
badChecksum[badChecksum.size - 2] = (badChecksum[badChecksum.size - 2] + 1).toByte() |
|||
assertThat(codec.decode(badChecksum)).isNull() |
|||
assertThat(codec.isValidFrame(badChecksum)).isFalse() |
|||
|
|||
// 5. 프레임 길이가 너무 짧은 경우 (5바이트) |
|||
val tooShort = ByteArray(5) { 0xA1.toByte() } |
|||
assertThat(codec.decode(tooShort)).isNull() |
|||
assertThat(codec.isValidFrame(tooShort)).isFalse() |
|||
} |
|||
} |
|||
@ -1,23 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.common.PacketPipelineMetrics |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class PacketPipelineMetricsTest { |
|||
@Test fun receiveToProcessAgeTracksQueueWaitSeparatelyFromProcessing() { |
|||
val metrics = PacketPipelineMetrics() |
|||
assertEquals(0.0, metrics.snapshot().averageReceiveToProcessMillis) |
|||
metrics.recordReceiveToProcess(2_000_000) |
|||
metrics.recordReceiveToProcess(8_000_000) |
|||
metrics.recordReceiveToProcess(0) |
|||
metrics.recordReceiveToProcess(-1) |
|||
metrics.recordProcessing(100_000) |
|||
val result = metrics.snapshot() |
|||
assertEquals(3L, result.receiveToProcessCount) |
|||
assertEquals(10.0 / 3, result.averageReceiveToProcessMillis, 0.000001) |
|||
assertEquals(0L, result.lastReceiveToProcessNanos) |
|||
assertEquals(8_000_000L, result.maxReceiveToProcessNanos) |
|||
assertEquals(100.0, result.averageProcessingMicros) |
|||
} |
|||
} |
|||
@ -1,166 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.common.PacketDistributor |
|||
import com.dct.app.data.communication.OrderedPacketWriter |
|||
import com.dct.app.data.protocol.DctPacketCodec |
|||
import com.dct.app.data.protocol.SlidingRingBufferParser |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import kotlinx.coroutines.* |
|||
import kotlinx.coroutines.flow.collect |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import java.util.concurrent.CountDownLatch |
|||
import java.util.concurrent.TimeUnit |
|||
import java.util.concurrent.atomic.AtomicInteger |
|||
|
|||
class PacketPipelineReliabilityTest { |
|||
@Test fun consecutiveAcksAndControlWaitFiveMillisecondsAfterThePreviousWrite() = runBlocking { |
|||
val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO) |
|||
val entered = CountDownLatch(1) |
|||
val releaseFirst = CountDownLatch(1) |
|||
val finished = CountDownLatch(4) |
|||
val commands = mutableListOf<Int>() |
|||
val startedAt = mutableListOf<Long>() |
|||
val completedAt = mutableListOf<Long>() |
|||
val writer = OrderedPacketWriter(scope, write = { bytes -> |
|||
commands += bytes[0].toInt() |
|||
startedAt += System.nanoTime() |
|||
if (bytes[0] == 0x24.toByte()) { |
|||
entered.countDown() |
|||
check(releaseFirst.await(2, TimeUnit.SECONDS)) |
|||
} |
|||
// A slow write must not consume the following frame's quiet interval. |
|||
Thread.sleep(10) |
|||
completedAt += System.nanoTime() |
|||
finished.countDown() |
|||
}, closeTransport = { releaseFirst.countDown() }) |
|||
try { |
|||
assertTrue(writer.offer(byteArrayOf(0x24))) |
|||
assertTrue(entered.await(2, TimeUnit.SECONDS)) |
|||
assertTrue(writer.offer(byteArrayOf(0x23))) |
|||
assertTrue(writer.offer(byteArrayOf(0x50))) |
|||
val control = async(start = CoroutineStart.UNDISPATCHED) { writer.send(byteArrayOf(0x05)) } |
|||
releaseFirst.countDown() |
|||
assertTrue(finished.await(3, TimeUnit.SECONDS)) |
|||
assertTrue(control.await()) |
|||
assertEquals(listOf(0x24, 0x05, 0x23, 0x50), commands, |
|||
"Control priority and ACK ordering must survive pacing") |
|||
for (index in 1 until startedAt.size) { |
|||
val quietNanos = startedAt[index] - completedAt[index - 1] |
|||
assertTrue(quietNanos >= 5_000_000L, |
|||
"Frame $index began after only ${quietNanos / 1_000_000.0}ms of quiet") |
|||
} |
|||
} finally { writer.close(); scope.cancel() } |
|||
} |
|||
|
|||
@Test fun cancelledCallerDoesNotCloseSharedWriter() = runBlocking { |
|||
val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO) |
|||
val entered = CountDownLatch(1) |
|||
val gate = CountDownLatch(1) |
|||
val closed = AtomicInteger() |
|||
val writer = OrderedPacketWriter(scope, write = { |
|||
entered.countDown() |
|||
check(gate.await(3, TimeUnit.SECONDS)) |
|||
}, closeTransport = { closed.incrementAndGet(); gate.countDown() }) |
|||
try { |
|||
val caller = launch(start = CoroutineStart.UNDISPATCHED) { writer.send(byteArrayOf(1)) } |
|||
assertTrue(entered.await(2, TimeUnit.SECONDS)) |
|||
caller.cancelAndJoin() |
|||
assertEquals(0, closed.get()) |
|||
gate.countDown() |
|||
assertTrue(writer.send(byteArrayOf(2))) |
|||
} finally { writer.close(); scope.cancel() } |
|||
} |
|||
|
|||
@Test fun stalledSubscriberReceivesAll1001PacketsInOrder() = runBlocking { |
|||
val distributor = PacketDistributor() |
|||
val gate = CompletableDeferred<Unit>() |
|||
val received = mutableListOf<Int>() |
|||
val done = CompletableDeferred<Unit>() |
|||
val consumer = launch(start = CoroutineStart.UNDISPATCHED) { |
|||
distributor.packetStream.collect { |
|||
received.add(it.sequence) |
|||
if (it.sequence == 0) gate.await() |
|||
if (it.sequence == 1000) done.complete(Unit) |
|||
} |
|||
} |
|||
val producer = launch { |
|||
repeat(1001) { distributor.dispatchPacket(DctPacket(0xA3.toByte(), sequence = it)) } |
|||
} |
|||
yield() |
|||
assertFalse(producer.isCompleted, "A full buffer must suspend, not discard data") |
|||
gate.complete(Unit) |
|||
withTimeout(3000) { producer.join(); done.await() } |
|||
consumer.cancelAndJoin() |
|||
assertEquals((0..1000).toList(), received) |
|||
} |
|||
|
|||
@Test fun maximumWireFrameAndOversizedCoalescedReadAreLossless() { |
|||
val codec = DctPacketCodec() |
|||
val payload = ByteArray(65534) { (it % 256).toByte() } |
|||
val frame = codec.encode(DctPacket(0xA3.toByte(), payload)) |
|||
assertEquals(65540, frame.size) |
|||
val stream = frame + frame + frame |
|||
val parsed = SlidingRingBufferParser().parseStream(stream) |
|||
assertEquals(3, parsed.size) |
|||
parsed.forEach { assertArrayEquals(payload, it.payload) } |
|||
val fragmented = SlidingRingBufferParser() |
|||
assertTrue(fragmented.parseStream(frame.copyOfRange(0, 65535)).isEmpty()) |
|||
assertArrayEquals(payload, fragmented.parseStream(frame.copyOfRange(65535, frame.size)).single().payload) |
|||
assertThrows(IllegalArgumentException::class.java) { codec.encode(DctPacket(0xA3.toByte(), ByteArray(65535))) } |
|||
} |
|||
|
|||
@Test fun concurrentWritersNeverOverlapAndPreserveEnqueueOrder() = runBlocking { |
|||
val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO) |
|||
val entered = CountDownLatch(1) |
|||
val gate = CountDownLatch(1) |
|||
val values = mutableListOf<Int>() |
|||
val active = AtomicInteger() |
|||
val overlaps = AtomicInteger() |
|||
val writer = OrderedPacketWriter(scope, write = { |
|||
if (active.incrementAndGet() != 1) overlaps.incrementAndGet() |
|||
if (it[0] == 0.toByte()) { entered.countDown(); gate.await(2, TimeUnit.SECONDS) } |
|||
values.add(it[0].toInt()) |
|||
active.decrementAndGet() |
|||
}, closeTransport = { gate.countDown() }) |
|||
try { |
|||
val first = async(start = CoroutineStart.UNDISPATCHED) { writer.send(byteArrayOf(0)) } |
|||
assertTrue(entered.await(2, TimeUnit.SECONDS)) |
|||
val others = (1..20).map { async(start = CoroutineStart.UNDISPATCHED) { writer.send(byteArrayOf(it.toByte())) } } |
|||
gate.countDown() |
|||
assertTrue(first.await()) |
|||
assertTrue(others.awaitAll().all { it }) |
|||
assertEquals((0..20).toList(), values) |
|||
assertEquals(0, overlaps.get()) |
|||
} finally { writer.close(); scope.cancel() } |
|||
} |
|||
|
|||
@Test fun blockedWriteTimeoutDoesNotCloseTransport() = runBlocking { |
|||
val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO) |
|||
val gate = CountDownLatch(1) |
|||
val closed = AtomicInteger() |
|||
val writes = AtomicInteger() |
|||
val entered = CountDownLatch(1) |
|||
val writer = OrderedPacketWriter(scope, write = { |
|||
entered.countDown() |
|||
gate.await(2, TimeUnit.SECONDS) |
|||
writes.incrementAndGet() |
|||
}, closeTransport = { closed.incrementAndGet(); gate.countDown() }, timeoutMs = 100) |
|||
try { |
|||
withTimeout(2000) { |
|||
val first = async { writer.send(byteArrayOf(1)) } |
|||
withContext(Dispatchers.IO) { assertTrue(entered.await(1, TimeUnit.SECONDS)) } |
|||
val queued = async { writer.send(byteArrayOf(2)) } |
|||
assertFalse(first.await()) |
|||
assertFalse(queued.await()) |
|||
assertEquals(0, closed.get(), "A caller timeout must not close the socket") |
|||
gate.countDown() |
|||
delay(100) |
|||
assertTrue(writer.send(byteArrayOf(3)), "A fresh command must still be writable") |
|||
assertEquals(2, writes.get(), "The expired queued command must never reach the socket") |
|||
} |
|||
assertEquals(0, closed.get()) |
|||
} finally { writer.close(); scope.cancel() } |
|||
assertEquals(1, closed.get()) |
|||
} |
|||
} |
|||
@ -1,239 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.data.communication.WifiSocketManager |
|||
import com.dct.app.data.protocol.DctProtocolRequests |
|||
import com.dct.app.data.repository.PacketRepositoryImpl |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.domain.repository.DeviceConnectionState |
|||
import io.mockk.* |
|||
import kotlinx.coroutines.async |
|||
import kotlinx.coroutines.launch |
|||
import kotlinx.coroutines.flow.MutableSharedFlow |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import kotlinx.coroutines.test.* |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.params.ParameterizedTest |
|||
import org.junit.jupiter.params.provider.ValueSource |
|||
|
|||
class PacketRepositoryEnableRefreshTest { |
|||
private class Fixture(val testScope: TestScope, timeoutMs: Long = 50) { |
|||
val wifi = mockk<WifiSocketManager>(relaxed = true) |
|||
val packets = MutableSharedFlow<DctPacket>(extraBufferCapacity = 16) |
|||
val connected = MutableStateFlow(true) |
|||
var sessionId = 7L |
|||
val sent = mutableListOf<DctPacket>() |
|||
val writtenAt = mutableListOf<Pair<DctPacket, Long>>() |
|||
val acks = mutableListOf<DctPacket>() |
|||
var versionDelay = 0L |
|||
var silent: Byte? = null |
|||
var sendFailure: Byte? = null |
|||
var versionPayload = byteArrayOf(1, 65) |
|||
var environmentRejected = false |
|||
|
|||
init { |
|||
every { wifi.isConnected } returns connected |
|||
every { wifi.currentSessionId } answers { sessionId } |
|||
every { wifi.packetStream } returns packets |
|||
every { wifi.offerCommand(capture(acks)) } returns true |
|||
every { wifi.invalidateConnectionIfSession(any()) } answers { |
|||
if (firstArg<Long>() == sessionId && connected.value) { connected.value = false; true } else false |
|||
} |
|||
coEvery { wifi.disconnectSuspend() } coAnswers { connected.value = false } |
|||
coEvery { wifi.sendCommand(any()) } coAnswers { |
|||
val request = firstArg<DctPacket>() |
|||
sent += request |
|||
if (request.command == sendFailure) return@coAnswers false |
|||
if (request.command == 1.toByte()) kotlinx.coroutines.delay(versionDelay) |
|||
writtenAt += request to testScope.testScheduler.currentTime |
|||
if (request.command != silent && request.command != 0x0F.toByte()) { |
|||
val payload = when (request.command.toInt()) { |
|||
1 -> versionPayload |
|||
3 -> ByteArray(6) |
|||
9 -> byteArrayOf(request.payload[0], if (environmentRejected) 2 else 1) |
|||
0x20 -> byteArrayOf(1, 1) |
|||
else -> byteArrayOf(1) |
|||
} |
|||
packets.emit(DctPacket((request.command + 0x80).toByte(), payload, |
|||
transportSessionId = request.transportSessionId)) |
|||
} |
|||
true |
|||
} |
|||
} |
|||
|
|||
val repository = PacketRepositoryImpl(wifiSocketManager = wifi, |
|||
ioDispatcher = UnconfinedTestDispatcher(testScope.testScheduler), responseTimeoutMs = timeoutMs, |
|||
enableHeartbeat = false, monotonicTimeMillis = { testScope.testScheduler.currentTime }, scope = testScope.backgroundScope) |
|||
|
|||
suspend fun open(measuring: Boolean = false) { |
|||
assertTrue(repository.connect("") is DctResult.Success) |
|||
if (measuring) assertTrue(repository.startStreaming(30) is DctResult.Success) |
|||
sent.clear(); writtenAt.clear() |
|||
} |
|||
|
|||
suspend fun enable(payload: ByteArray = byteArrayOf(1), session: Long = sessionId) { |
|||
packets.emit(DctPacket(0x80.toByte(), payload, transportSessionId = session)) |
|||
} |
|||
} |
|||
|
|||
@Test |
|||
fun readyEnableRefreshesVersionAndReadOnlyEnvironmentWithoutInterruptingAcks() = runTest { |
|||
val f = Fixture(this) |
|||
f.open() |
|||
f.versionDelay = 25 |
|||
f.enable() |
|||
runCurrent() |
|||
// Keep receiving/ACKing while VERSION's actual write is still pending. |
|||
f.packets.emit(DctPacket(0xA3.toByte(), byteArrayOf(1, 0xA0.toByte(), 9), transportSessionId = 7)) |
|||
f.enable(); f.enable() |
|||
runCurrent() |
|||
assertEquals(1, f.acks.size) |
|||
assertEquals(0x23.toByte(), f.acks.single().command) |
|||
assertEquals(listOf(1), f.sent.map { it.command.toInt() }) |
|||
advanceTimeBy(224); runCurrent() |
|||
assertEquals(1, f.sent.size) |
|||
advanceTimeBy(1); runCurrent() |
|||
assertEquals(listOf(1, 9, 9), f.sent.map { it.command.toInt() }) |
|||
assertEquals(listOf(0, 3), f.sent.filter { it.command == 9.toByte() }.map { it.payload.single().toInt() }) |
|||
assertEquals(200L, f.writtenAt[1].second - f.writtenAt[0].second) |
|||
assertTrue(f.sent.all { it.transportSessionId == 7L }) |
|||
assertFalse(f.repository.isStreaming.value) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
assertTrue(f.connected.value) |
|||
verify(exactly = 1) { f.wifi.diagnosticEvent(7L, match { it.startsWith("ENABLE_REFRESH_COMPLETE") }) } |
|||
coVerify(exactly = 0) { f.wifi.disconnectSuspend() } |
|||
f.enable() |
|||
advanceTimeBy(225); runCurrent() |
|||
assertEquals(listOf(1, 9, 9, 1, 9, 9), f.sent.map { it.command.toInt() }, |
|||
"A later ENABLE must be able to refresh again after completion") |
|||
} |
|||
|
|||
@Test fun matchingInitialEnableReplyDoesNotStartAnotherRefresh() = runTest { |
|||
val f = Fixture(this) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
advanceTimeBy(500); runCurrent() |
|||
assertEquals(1, f.sent.count { it.command == 1.toByte() }) |
|||
assertEquals(2, f.sent.count { it.command == 9.toByte() }) |
|||
verify(exactly = 0) { f.wifi.diagnosticEvent(any(), match { it.startsWith("ENABLE_REFRESH_") }) } |
|||
} |
|||
|
|||
@Test fun versionReplyAfter200msDoesNotAddAnother200msBeforeEnvironment() = runTest { |
|||
val f = Fixture(this, timeoutMs = 1000) |
|||
f.open() |
|||
coEvery { f.wifi.sendCommand(match { it.command == 1.toByte() }) } coAnswers { |
|||
val request = firstArg<DctPacket>() |
|||
f.sent += request |
|||
f.writtenAt += request to testScheduler.currentTime |
|||
backgroundScope.launch(UnconfinedTestDispatcher(testScheduler)) { |
|||
kotlinx.coroutines.delay(250) |
|||
f.packets.emit(DctPacket(0x81.toByte(), byteArrayOf(1, 65), transportSessionId = 7)) |
|||
} |
|||
true |
|||
} |
|||
f.enable() |
|||
advanceTimeBy(249); runCurrent() |
|||
assertEquals(listOf(1), f.sent.map { it.command.toInt() }) |
|||
advanceTimeBy(1); runCurrent() |
|||
assertEquals(listOf(1, 9, 9), f.sent.map { it.command.toInt() }) |
|||
assertEquals(250L, f.writtenAt[1].second - f.writtenAt[0].second) |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@ValueSource(strings = ["empty", "nack", "extra", "stale"]) |
|||
fun invalidOrOldSessionEnableDoesNotQuery(failure: String) = runTest { |
|||
val f = Fixture(this) |
|||
f.open() |
|||
when (failure) { |
|||
"empty" -> f.enable(byteArrayOf()) |
|||
"nack" -> f.enable(byteArrayOf(2)) |
|||
"extra" -> f.enable(byteArrayOf(1, 1)) |
|||
else -> f.enable(session = 6) |
|||
} |
|||
advanceTimeBy(500); runCurrent() |
|||
assertTrue(f.sent.isEmpty()) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@ValueSource(strings = ["versionTimeout", "versionMalformed", "versionSendFailed", "environmentTimeout", "environmentRejected"]) |
|||
fun failedReadyRefreshReportsWithoutStartingMeasurementOrClosingTcp(failure: String) = runTest { |
|||
val f = Fixture(this) |
|||
f.open() |
|||
when (failure) { |
|||
"versionTimeout" -> f.silent = 1 |
|||
"versionMalformed" -> f.versionPayload = byteArrayOf(3, 65) |
|||
"versionSendFailed" -> f.sendFailure = 1 |
|||
"environmentTimeout" -> f.silent = 9 |
|||
else -> f.environmentRejected = true |
|||
} |
|||
f.enable() |
|||
advanceTimeBy(500); runCurrent() |
|||
assertEquals(if (failure.startsWith("version")) listOf(1) else listOf(1, 9), |
|||
f.sent.map { it.command.toInt() }) |
|||
assertTrue(f.connected.value) |
|||
assertFalse(f.repository.isStreaming.value) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
verify(exactly = 1) { f.wifi.diagnosticEvent(7L, match { it.startsWith("ENABLE_REFRESH_FAILED") }) } |
|||
coVerify(exactly = 0) { f.wifi.disconnectSuspend() } |
|||
} |
|||
|
|||
@Test fun disconnectCancelsRefreshDuringTheVersionEnvironmentGap() = runTest { |
|||
val f = Fixture(this) |
|||
f.open() |
|||
f.enable(); runCurrent() |
|||
assertEquals(listOf(1), f.sent.map { it.command.toInt() }) |
|||
assertTrue(f.repository.disconnect() is DctResult.Success) |
|||
advanceTimeBy(500); runCurrent() |
|||
assertEquals(listOf(1, 15), f.sent.map { it.command.toInt() }) |
|||
assertEquals(DeviceConnectionState.DISCONNECTED, f.repository.connectionState.value) |
|||
verify(exactly = 0) { f.wifi.diagnosticEvent(any(), match { it.startsWith("ENABLE_REFRESH_COMPLETE") }) } |
|||
} |
|||
|
|||
@Test fun transportLossCancelsOldRefreshAndOldRepliesCannotStartWorkOnNewSession() = runTest { |
|||
val f = Fixture(this) |
|||
f.open() |
|||
f.enable(); runCurrent() |
|||
f.connected.value = false; runCurrent() |
|||
f.sessionId = 8 |
|||
f.connected.value = true |
|||
f.open() |
|||
f.enable(session = 7) |
|||
advanceTimeBy(500); runCurrent() |
|||
assertTrue(f.sent.isEmpty()) |
|||
f.enable(session = 8) |
|||
advanceTimeBy(200); runCurrent() |
|||
assertEquals(listOf(1, 9, 9), f.sent.map { it.command.toInt() }) |
|||
assertTrue(f.sent.all { it.transportSessionId == 8L }) |
|||
} |
|||
|
|||
@Test fun enableDuringExplicitDisconnectCannotStartAnotherRefresh() = runTest { |
|||
val f = Fixture(this) |
|||
f.open(measuring = true) |
|||
f.silent = 0x21 |
|||
val disconnect = async { f.repository.disconnect() } |
|||
runCurrent() |
|||
f.enable() |
|||
advanceTimeBy(50); runCurrent() |
|||
assertTrue(disconnect.await() is DctResult.Success) |
|||
assertEquals(listOf(0x21, 0x0F), f.sent.map { it.command.toInt() }) |
|||
verify(exactly = 0) { f.wifi.diagnosticEvent(any(), match { it.startsWith("ENABLE_REFRESH_START") }) } |
|||
} |
|||
|
|||
@Test fun commandWaitingForMutexCannotBeRetaggedToAnotherSession() = runTest { |
|||
val f = Fixture(this) |
|||
f.open() |
|||
f.silent = 3 |
|||
val blocking = async { f.repository.sendCommand(DctProtocolRequests.hardwareId()) } |
|||
runCurrent() |
|||
val waiting = async { f.repository.sendCommand(DctProtocolRequests.version().copy(transportSessionId = 7)) } |
|||
runCurrent() |
|||
f.sessionId = 8 |
|||
advanceTimeBy(50); runCurrent() |
|||
assertTrue(blocking.await() is DctResult.Failure) |
|||
assertTrue(waiting.await() is DctResult.Failure) |
|||
assertEquals(listOf(3), f.sent.map { it.command.toInt() }) |
|||
assertTrue(f.repository.sendCommand(DctProtocolRequests.version().copy(transportSessionId = 7)) is DctResult.Failure) |
|||
assertEquals(listOf(3), f.sent.map { it.command.toInt() }) |
|||
} |
|||
} |
|||
@ -1,659 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.core.common.DctResult |
|||
import com.dct.app.data.communication.WifiSocketManager |
|||
import com.dct.app.data.protocol.DctProtocolRequests |
|||
import com.dct.app.data.parser.A2lParser |
|||
import com.dct.app.data.repository.PacketRepositoryImpl |
|||
import com.dct.app.domain.model.a2l.A2lDataType |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import com.dct.app.domain.model.protocol.* |
|||
import com.dct.app.domain.model.project.createDefaultSensorModules |
|||
import com.dct.app.domain.repository.DeviceConnectionState |
|||
import io.mockk.* |
|||
import kotlinx.coroutines.async |
|||
import kotlinx.coroutines.flow.MutableSharedFlow |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import kotlinx.coroutines.test.* |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.params.ParameterizedTest |
|||
import org.junit.jupiter.params.provider.CsvSource |
|||
import org.junit.jupiter.params.provider.ValueSource |
|||
|
|||
class PacketRepositoryResponseTest { |
|||
@Test fun collectorExceptionAndActualResubscriptionAreObservableWithoutChangingRetry() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
every { f.wifi.offerCommand(any()) } throws IllegalStateException("injected ACK failure") |
|||
f.packets.emit(DctPacket(DctCommand.SEND_CAN_FRAME.code, byteArrayOf(1, 0xA0.toByte(), 1), ingressSequence = 42)) |
|||
runCurrent() |
|||
verify { f.wifi.diagnosticEvent(any(), match { it.contains("COLLECTOR_ERROR") && it.contains("ingress=42") && it.contains("injected ACK failure") }) } |
|||
assertEquals(0, f.packets.subscriptionCount.value) |
|||
advanceTimeBy(99); runCurrent() |
|||
assertEquals(0, f.packets.subscriptionCount.value) |
|||
every { f.wifi.offerCommand(any()) } returns true |
|||
advanceTimeBy(1); runCurrent() |
|||
assertEquals(1, f.packets.subscriptionCount.value) |
|||
verify { f.wifi.diagnosticEvent(any(), match { it.contains("COLLECTOR_RESUBSCRIBED") }) } |
|||
f.packets.emit(DctPacket(DctCommand.SEND_CAN_FRAME.code, byteArrayOf(1, 0xA0.toByte(), 2))) |
|||
runCurrent() |
|||
verify(exactly = 2) { f.wifi.offerCommand(any()) } |
|||
} |
|||
@ParameterizedTest |
|||
@CsvSource("true,false", "false,true") |
|||
fun xcpCalibrationFollowsConfiguredEndianAcrossProjectChanges(firstMsb: Boolean, secondMsb: Boolean) = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
for (msb in listOf(firstMsb, secondMsb)) { |
|||
assertTrue(f.repository.configureMeasurement(xcpConfiguration(msb)) is DctResult.Success) |
|||
assertXcpCalibrationPackets(f, msb) |
|||
} |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@ValueSource(strings = ["rejected", "timeout", "malformed"]) |
|||
fun xcpFailedIfDataDoesNotReplaceAppliedEndian(failure: String) = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
if (failure == "timeout") f.sessionId = 7L |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
assertTrue(f.repository.sendXcpIfDatas(A2lParser.XcpIfData(isMsbFirst = true)) is DctResult.Success) |
|||
when (failure) { |
|||
"rejected" -> f.reject = 0x41 |
|||
"timeout" -> f.silent = 0x41 |
|||
"malformed" -> coEvery { f.wifi.sendCommand(match { it.command == 0x41.toByte() }) } coAnswers { |
|||
f.packets.emit(DctPacket(0xC1.toByte(), byteArrayOf(1, 99))) |
|||
true |
|||
} |
|||
} |
|||
assertTrue(f.repository.configureMeasurement(xcpConfiguration(false)) is DctResult.Failure) |
|||
if (failure == "timeout") { |
|||
assertFalse(f.connected.value) |
|||
f.sessionId = 8L |
|||
f.connected.value = true |
|||
f.silent = null |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
} |
|||
assertXcpCalibrationPackets(f, true) |
|||
} |
|||
|
|||
@Test fun xcpIfDataAckUpdatesEndianEvenWhenLaterSetupFails() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
f.reject = 0x42 |
|||
assertTrue(f.repository.configureMeasurement(xcpConfiguration(true)) is DctResult.Failure) |
|||
assertXcpCalibrationPackets(f, true) |
|||
} |
|||
|
|||
@Test fun xcpMissingIfDataUsesDefaultLittleEndianAfterMsbProject() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
assertTrue(f.repository.sendXcpIfDatas(A2lParser.XcpIfData(isMsbFirst = true)) is DctResult.Success) |
|||
assertTrue(f.repository.configureMeasurement(xcpConfiguration(true).copy(xcpIfData = null)) is DctResult.Success) |
|||
assertXcpCalibrationPackets(f, false) |
|||
} |
|||
|
|||
private fun xcpConfiguration(msb: Boolean) = DctMeasurementConfiguration( |
|||
a2lSignals = listOf(SignalDefinition(1, 1, "Calibration", MdbAttrType.ATTR_2_UINT16, |
|||
1.0, 0.0, "", 0, 0.0, 65535.0, adl = 0x12345678, a2lDataType = A2lDataType.UWORD)), |
|||
xcpIfData = A2lParser.XcpIfData(isMsbFirst = msb) |
|||
) |
|||
|
|||
private suspend fun assertXcpCalibrationPackets(f: Fixture, msb: Boolean) { |
|||
val valueBytes = if (msb) byteArrayOf(0x10, 0x20) else byteArrayOf(0x20, 0x10) |
|||
coEvery { f.wifi.sendCommand(match { it.command == 0x52.toByte() }) } coAnswers { |
|||
f.sentPackets += firstArg<DctPacket>() |
|||
f.packets.emit(DctPacket(0xD2.toByte(), byteArrayOf(1) + valueBytes)) |
|||
true |
|||
} |
|||
assertTrue(f.repository.writeXcpCharacteristic(0x12345678, A2lDataType.UWORD, 0x1020.toDouble()) is DctResult.Success) |
|||
val read = f.repository.readXcpCharacteristic(0x12345678, A2lDataType.UWORD) |
|||
assertTrue(read is DctResult.Success) |
|||
assertArrayEquals(valueBytes, (read as DctResult.Success).data) |
|||
// PC Characteristic payloads: [type][value][address] / [type][address]. |
|||
val expectedWrite = if (msb) byteArrayOf(2, 0x10, 0x20, 0x12, 0x34, 0x56, 0x78) |
|||
else byteArrayOf(2, 0x20, 0x10, 0x78, 0x56, 0x34, 0x12) |
|||
val expectedRead = if (msb) byteArrayOf(2, 0x12, 0x34, 0x56, 0x78) |
|||
else byteArrayOf(2, 0x78, 0x56, 0x34, 0x12) |
|||
assertArrayEquals(expectedWrite, f.sentPackets.last { it.command == 0x51.toByte() }.payload) |
|||
assertArrayEquals(expectedRead, f.sentPackets.last { it.command == 0x52.toByte() }.payload) |
|||
} |
|||
|
|||
@Test fun responseBudgetIncludesSlowSend() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
coEvery { f.wifi.sendCommand(any()) } coAnswers { kotlinx.coroutines.delay(1000); true } |
|||
val before = testScheduler.currentTime |
|||
assertTrue(f.repository.sendCommand(DctProtocolRequests.version()) is DctResult.Failure) |
|||
assertEquals(50, testScheduler.currentTime - before) |
|||
coVerify(exactly = 0) { f.wifi.disconnectSuspend() } |
|||
} |
|||
|
|||
@Test fun streamAcksValidateStructureAndNeverAcknowledgeOldSessions() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
every { f.wifi.currentSessionId } returns 7L |
|||
val sent = mutableListOf<DctPacket>() |
|||
every { f.wifi.offerCommand(capture(sent)) } returns true |
|||
f.packets.emit(DctPacket(0xA4.toByte(), byteArrayOf(0), transportSessionId = 6)) |
|||
f.packets.emit(DctPacket(0xA4.toByte(), byteArrayOf(1), transportSessionId = 7)) // Truncated module |
|||
f.packets.emit(DctPacket(0xA3.toByte(), byteArrayOf(1, 0xA4.toByte(), 1), transportSessionId = 7)) // Unknown MDB schema still ACKs |
|||
f.packets.emit(DctPacket(0xD0.toByte(), byteArrayOf(0, 1), transportSessionId = 7)) // Missing XCP item |
|||
assertEquals(listOf(0x24, 0x23, 0x50), sent.map { it.command.toInt() }) |
|||
assertEquals(listOf(0, 1, 0), sent.map { it.payload.single().toInt() }) |
|||
assertTrue(sent.all { it.transportSessionId == 7L }) |
|||
} |
|||
|
|||
private class Fixture(dispatcher: kotlinx.coroutines.CoroutineDispatcher) { |
|||
val wifi = mockk<WifiSocketManager>(relaxed = true) |
|||
val packets = MutableSharedFlow<DctPacket>(extraBufferCapacity = 8) |
|||
val connected = MutableStateFlow(true) |
|||
var sessionId = 0L |
|||
var reject: Byte? = null |
|||
var silent: Byte? = null |
|||
var versionPayload = byteArrayOf(1, 65) |
|||
val sentPackets = mutableListOf<DctPacket>() |
|||
init { |
|||
every { wifi.isConnected } returns connected |
|||
every { wifi.packetStream } returns packets |
|||
every { wifi.currentSessionId } answers { sessionId } |
|||
every { wifi.invalidateConnectionIfSession(any()) } answers { |
|||
if (firstArg<Long>() != 0L && firstArg<Long>() == wifi.currentSessionId && connected.value) { |
|||
sessionId = 0L |
|||
connected.value = false |
|||
true |
|||
} else false |
|||
} |
|||
coEvery { wifi.disconnectSuspend() } coAnswers { connected.value = false } |
|||
coEvery { wifi.sendCommand(any()) } coAnswers { |
|||
val request = firstArg<DctPacket>() |
|||
sentPackets += request |
|||
if (request.command == silent) return@coAnswers true |
|||
val subCmd = request.payload.firstOrNull() ?: 1 |
|||
val payload = when (request.command.toInt()) { |
|||
1 -> versionPayload |
|||
3 -> ByteArray(6) |
|||
8 -> byteArrayOf(subCmd, if (reject == request.command) 2 else 1) |
|||
9 -> byteArrayOf(subCmd, if (reject == request.command) 2 else 1) |
|||
12 -> byteArrayOf(subCmd, if (reject == request.command) 2 else 1) |
|||
else -> byteArrayOf(if (reject == request.command) 2 else 1) |
|||
} |
|||
packets.emit(DctPacket(command = (request.command + 0x80).toByte(), payload = payload)) |
|||
true |
|||
} |
|||
} |
|||
val repository = PacketRepositoryImpl(wifiSocketManager = wifi, ioDispatcher = dispatcher, responseTimeoutMs = 50) |
|||
} |
|||
|
|||
@Test fun firstEnvironmentQueryWaits200msAfterVersionWriteCompletes() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
var versionWrittenAt = -1L |
|||
var firstEnvAt = -1L |
|||
coEvery { f.wifi.sendCommand(match { it.command == 1.toByte() }) } coAnswers { |
|||
kotlinx.coroutines.delay(75) |
|||
f.packets.emit(DctPacket(0x81.toByte(), byteArrayOf(1, 65))) |
|||
versionWrittenAt = testScheduler.currentTime |
|||
true |
|||
} |
|||
coEvery { f.wifi.sendCommand(match { it.command == 9.toByte() }) } coAnswers { |
|||
if (firstEnvAt < 0) firstEnvAt = testScheduler.currentTime |
|||
f.packets.emit(DctPacket(0x89.toByte(), byteArrayOf(firstArg<DctPacket>().payload[0], 1))) |
|||
true |
|||
} |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
assertTrue(versionWrittenAt >= 0) |
|||
assertEquals(200L, firstEnvAt - versionWrittenAt) |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@CsvSource("0,false", "0,true", "9,false", "9,true", "18,false", "18,true", "3,false", "3,true", "4,false", "4,true") |
|||
fun failedHandshakeClosesOnlyFailedSessionAndCanReconnect(command: Int, nack: Boolean) = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
every { f.wifi.currentSessionId } returns 7L |
|||
every { f.wifi.invalidateConnectionIfSession(7L) } answers { f.connected.value = false; true } |
|||
if (nack) f.reject = command.toByte() else f.silent = command.toByte() |
|||
if (nack && command == 3) { |
|||
// HWID has no status byte: its failure path is a truncated address. |
|||
coEvery { f.wifi.sendCommand(match { it.command == 3.toByte() }) } coAnswers { |
|||
f.packets.emit(DctPacket(0x83.toByte(), ByteArray(if (f.reject == 3.toByte()) 5 else 6))) |
|||
true |
|||
} |
|||
} |
|||
f.repository.setInitialMeasurementConfiguration(DctMeasurementConfiguration(sensorModules = createDefaultSensorModules())) |
|||
assertTrue(f.repository.connect("") is DctResult.Failure) |
|||
assertEquals(DeviceConnectionState.ERROR, f.repository.connectionState.value) |
|||
assertFalse(f.repository.isConnected.value) |
|||
assertFalse(f.connected.value) |
|||
verify(exactly = 1) { f.wifi.invalidateConnectionIfSession(7L) } |
|||
assertFalse(f.sentPackets.any { it.command == 0x0F.toByte() || it.command == 0x20.toByte() }) |
|||
|
|||
// A new session must not inherit the failed session's response quarantine. |
|||
every { f.wifi.currentSessionId } returns 8L |
|||
f.connected.value = true |
|||
f.reject = null |
|||
f.silent = null |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
verify(exactly = 0) { f.wifi.invalidateConnectionIfSession(8L) } |
|||
} |
|||
|
|||
@Test fun cancelledHandshakeDuringPcGapClosesItsSocket() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
every { f.wifi.currentSessionId } returns 7L |
|||
every { f.wifi.invalidateConnectionIfSession(7L) } answers { f.connected.value = false; true } |
|||
val connect = async { f.repository.connect("") } |
|||
advanceTimeBy(100) |
|||
connect.cancel() |
|||
runCurrent() |
|||
assertTrue(connect.isCancelled) |
|||
assertFalse(f.connected.value) |
|||
assertEquals(DeviceConnectionState.ERROR, f.repository.connectionState.value) |
|||
verify(exactly = 1) { f.wifi.invalidateConnectionIfSession(7L) } |
|||
coVerify(exactly = 0) { f.wifi.sendCommand(match { it.command == 9.toByte() }) } |
|||
} |
|||
|
|||
@Test fun negativeEnableNeverReachesReady() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
f.reject = 0 |
|||
assertTrue(f.repository.connect("") is DctResult.Failure) |
|||
assertEquals(DeviceConnectionState.ERROR, f.repository.connectionState.value) |
|||
coVerify(exactly = 0) { f.wifi.sendCommand(match { it.command == 1.toByte() }) } |
|||
} |
|||
@Test fun existingDctTestVersionCompletesHandshake() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
f.versionPayload = "DCT-MOBI-v1.0.0\u0000".toByteArray(Charsets.US_ASCII) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
coVerify(exactly = 1) { f.wifi.sendCommand(match { it.command == 3.toByte() }) } |
|||
coVerify(exactly = 1) { f.wifi.sendCommand(match { it.command == 4.toByte() }) } |
|||
} |
|||
@Test fun correctedDctTestVersionCompletesHandshake() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
val version = "DCT-MOBI-v1.0.0".toByteArray(Charsets.US_ASCII) |
|||
f.versionPayload = byteArrayOf(version.size.toByte()) + version |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
} |
|||
|
|||
@Test fun initialHandshakeUsesCompleteCanAndSensorPayloads() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
f.repository.setInitialMeasurementConfiguration( |
|||
DctMeasurementConfiguration( |
|||
isHighSpeedCan = true, |
|||
isOldModel = true, |
|||
sensorModules = createDefaultSensorModules() |
|||
) |
|||
) |
|||
|
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
val env = f.sentPackets.filter { it.command == 0x09.toByte() } |
|||
assertTrue(env.any { it.payload.contentEquals(byteArrayOf(0x06, 0x11)) }) |
|||
val sm = f.sentPackets.first { it.command == 0x12.toByte() } |
|||
assertTrue(sm.payload.contentEquals(byteArrayOf(0x01, 0x01, 0xFF.toByte(), 0x00, 0x00, 0x00))) |
|||
} |
|||
@Test fun truncatedVersionStillStopsHandshakeBeforeHardwareId() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
f.versionPayload = byteArrayOf(15) + "DCT-MOBI-v1.0".toByteArray(Charsets.US_ASCII) |
|||
assertTrue(f.repository.connect("") is DctResult.Failure) |
|||
assertEquals(DeviceConnectionState.ERROR, f.repository.connectionState.value) |
|||
coVerify(exactly = 0) { f.wifi.sendCommand(match { it.command == 3.toByte() }) } |
|||
} |
|||
@Test fun configurationStopsAtNegativeAck() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
f.reject = 8 |
|||
val config = DctMeasurementConfiguration( |
|||
vehicleCode = "HE1", |
|||
projectName = "HE1ID", |
|||
mdbSignals = listOf(mockk(relaxed = true)) |
|||
) |
|||
assertTrue(f.repository.configureMeasurement(config) is DctResult.Failure) |
|||
coVerify(exactly = 0) { f.wifi.sendCommand(match { it.command == 0x10.toByte() }) } |
|||
assertTrue(f.connected.value) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@ValueSource(ints = [8, 9, 18, 65]) |
|||
fun configurationTimeoutClosesTcpEvenWithHeartbeatAndIgnoresLateAck(command: Int) = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
f.sessionId = 7L |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
f.sentPackets.clear() |
|||
f.silent = command.toByte() |
|||
val configuration = if (command == 65) xcpConfiguration(false) |
|||
else DctMeasurementConfiguration(projectName = "TEST") |
|||
val setup = async { f.repository.configureMeasurement(configuration) } |
|||
runCurrent() |
|||
if (command == 9 || command == 18) { |
|||
advanceTimeBy(120) // CAN-to-DID 100ms plus DID-to-environment 20ms. |
|||
runCurrent() |
|||
} |
|||
assertEquals(command, f.sentPackets.last().command.toInt() and 255) |
|||
f.packets.emit(DctPacket(0x85.toByte(), byteArrayOf(1), transportSessionId = 7L)) |
|||
advanceTimeBy(49) |
|||
assertFalse(setup.isCompleted) |
|||
assertTrue(f.connected.value) |
|||
advanceTimeBy(1) |
|||
runCurrent() |
|||
|
|||
val result = setup.await() |
|||
assertTrue(result is DctResult.Failure && result.error is com.dct.app.core.error.DctError.ProtocolError.ResponseTimeout) |
|||
assertFalse(f.connected.value) |
|||
assertFalse(f.repository.isConnected.value) |
|||
assertFalse(f.repository.isStreaming.value) |
|||
assertEquals(DeviceConnectionState.ERROR, f.repository.connectionState.value) |
|||
verify(exactly = 1) { f.wifi.invalidateConnectionIfSession(7L) } |
|||
val sentAtTimeout = f.sentPackets.size |
|||
f.packets.emit(DctPacket((command + 0x80).toByte(), byteArrayOf(0, 1), transportSessionId = 7L)) |
|||
assertEquals(sentAtTimeout, f.sentPackets.size) |
|||
assertEquals(DeviceConnectionState.ERROR, f.repository.connectionState.value) |
|||
assertTrue(f.repository.startStreaming() is DctResult.Failure) |
|||
assertFalse(f.sentPackets.any { it.command == 0x20.toByte() }) |
|||
|
|||
f.sessionId = 8L |
|||
f.connected.value = true |
|||
f.silent = null |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
assertTrue(f.repository.configureMeasurement(configuration) is DctResult.Success) |
|||
f.packets.emit(DctPacket((command + 0x80).toByte(), byteArrayOf(0, 1), transportSessionId = 7L)) |
|||
assertTrue(f.connected.value) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
verify(exactly = 0) { f.wifi.invalidateConnectionIfSession(8L) } |
|||
} |
|||
|
|||
@Test fun oldConfigurationTimeoutDoesNotCloseNewerTcpSession() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
f.sessionId = 7L |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
f.silent = 8 |
|||
val setup = async { f.repository.configureMeasurement(DctMeasurementConfiguration(projectName = "TEST")) } |
|||
runCurrent() |
|||
f.sessionId = 8L |
|||
advanceTimeBy(50) |
|||
runCurrent() |
|||
assertTrue(setup.await() is DctResult.Failure) |
|||
verify(exactly = 1) { f.wifi.invalidateConnectionIfSession(7L) } |
|||
assertTrue(f.connected.value) |
|||
assertTrue(f.repository.isConnected.value) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
verify(exactly = 0) { f.wifi.invalidateConnectionIfSession(8L) } |
|||
} |
|||
@Test fun timeoutKeepsTransportAndBlocksAmbiguousRetryUntilLateAck() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
coEvery { f.wifi.sendCommand(any()) } returns true |
|||
assertTrue(f.repository.sendCommand(DctProtocolRequests.constantWrite(0x1000, byteArrayOf(1))) is DctResult.Failure) |
|||
coVerify(exactly = 0) { f.wifi.disconnectSuspend() } |
|||
assertTrue(f.connected.value) |
|||
val command = DctProtocolRequests.constantWrite(0x1000, byteArrayOf(1)) |
|||
assertTrue(f.repository.sendCommand(command) is DctResult.Failure) |
|||
coVerify(exactly = 1) { f.wifi.sendCommand(any()) } |
|||
f.packets.emit(DctPacket((command.command + 0x80).toByte(), byteArrayOf(1))) |
|||
coEvery { f.wifi.sendCommand(any()) } coAnswers { |
|||
f.packets.emit(DctPacket((command.command + 0x80).toByte(), byteArrayOf(1))) |
|||
true |
|||
} |
|||
assertTrue(f.repository.sendCommand(command) is DctResult.Success) |
|||
} |
|||
@ParameterizedTest |
|||
@ValueSource(booleans = [false, true]) |
|||
fun ambiguousStartTimeoutKeepsTcpUntilExplicitDisconnect(stopAckLost: Boolean) = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
coEvery { f.wifi.sendCommand(match { it.command == DctCommand.CMD_START_TRANSMIT_DATA.code }) } coAnswers { |
|||
f.sentPackets += firstArg<DctPacket>() |
|||
true |
|||
} |
|||
coEvery { f.wifi.sendCommand(match { it.command == 0x21.toByte() }) } coAnswers { |
|||
f.sentPackets += firstArg<DctPacket>() |
|||
// A late successful START must not revive the run during rollback. |
|||
f.packets.emit(DctPacket(0xA0.toByte(), byteArrayOf(1, 1))) |
|||
if (!stopAckLost) f.packets.emit(DctPacket(0xA1.toByte(), byteArrayOf(1))) |
|||
true |
|||
} |
|||
|
|||
assertTrue(f.repository.startStreaming(30) is DctResult.Failure) |
|||
assertTrue(f.connected.value) |
|||
assertFalse(f.repository.isStreaming.value) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
assertFalse(f.sentPackets.any { it.command == 0x21.toByte() || it.command == 0x0F.toByte() }) |
|||
coVerify(exactly = 0) { f.wifi.disconnectSuspend() } |
|||
f.packets.emit(DctPacket(0xA0.toByte(), byteArrayOf(1, 1))) |
|||
assertFalse(f.repository.isStreaming.value) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
|
|||
// Only explicit Disconnect rolls back the uncertain START and closes TCP. |
|||
assertTrue(f.repository.disconnect() is DctResult.Success) |
|||
assertEquals(listOf(0x20, 0x21, 0x0F), f.sentPackets.takeLast(3).map { it.command.toInt() and 255 }) |
|||
coVerify(exactly = 1) { f.wifi.disconnectSuspend() } |
|||
assertFalse(f.connected.value) |
|||
assertFalse(f.repository.isStreaming.value) |
|||
assertEquals(DeviceConnectionState.DISCONNECTED, f.repository.connectionState.value) |
|||
f.packets.emit(DctPacket(0xA0.toByte(), byteArrayOf(1, 1))) |
|||
assertFalse(f.repository.isStreaming.value) |
|||
assertEquals(DeviceConnectionState.DISCONNECTED, f.repository.connectionState.value) |
|||
} |
|||
|
|||
@Test fun cancelledStartStillSendsStopBeforeDisableOnDisconnect() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
coEvery { f.wifi.sendCommand(match { it.command == 0x20.toByte() }) } coAnswers { |
|||
f.sentPackets += firstArg<DctPacket>() |
|||
true |
|||
} |
|||
val start = async { f.repository.startStreaming(30) } |
|||
runCurrent() |
|||
start.cancel() |
|||
start.join() |
|||
assertTrue(f.repository.disconnect() is DctResult.Success) |
|||
assertEquals(listOf(0x20, 0x21, 0x0F), f.sentPackets.takeLast(3).map { it.command.toInt() and 255 }) |
|||
assertFalse(f.connected.value) |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@ValueSource(longs = [0L, 75L]) |
|||
fun pcPostCanSetupSendsDidWithoutWaitingForAckThenRefreshesEnvironment(writeDelayMs: Long) = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
f.sentPackets.clear() |
|||
var didWrittenAt = -1L |
|||
var didStartedAt = -1L |
|||
var firstEnvAt = -1L |
|||
coEvery { f.wifi.sendCommand(match { it.command == 0x17.toByte() }) } coAnswers { |
|||
f.sentPackets += firstArg<DctPacket>() |
|||
didStartedAt = testScheduler.currentTime |
|||
kotlinx.coroutines.delay(writeDelayMs) |
|||
didWrittenAt = testScheduler.currentTime |
|||
true // PC does not gate setup completion on a 0x97 response. |
|||
} |
|||
coEvery { f.wifi.sendCommand(match { it.command == 9.toByte() && it.payload.firstOrNull() == 0.toByte() }) } coAnswers { |
|||
f.sentPackets += firstArg<DctPacket>() |
|||
firstEnvAt = testScheduler.currentTime |
|||
f.packets.emit(DctPacket(0x89.toByte(), byteArrayOf(0, 1))) |
|||
true |
|||
} |
|||
val before = testScheduler.currentTime |
|||
assertTrue(f.repository.configureMeasurement(DctMeasurementConfiguration( |
|||
didPreSetting = 0x31, isHighSpeedCan = false, sensorModules = createDefaultSensorModules() |
|||
)) is DctResult.Success) |
|||
assertEquals(listOf(0x40, 0x11, 0x17, 0x09, 0x09, 0x09, 0x12), |
|||
f.sentPackets.map { it.command.toInt() and 255 }) |
|||
assertEquals(100L, didStartedAt - before) |
|||
assertEquals(writeDelayMs, didWrittenAt - didStartedAt) |
|||
assertEquals(20L, firstEnvAt - didWrittenAt) |
|||
assertArrayEquals(byteArrayOf(0x31), f.sentPackets[2].payload) |
|||
assertEquals(listOf(0, 3, 6), f.sentPackets.filter { it.command == 9.toByte() } |
|||
.map { it.payload.first().toInt() }) |
|||
assertArrayEquals(byteArrayOf(6, 0), f.sentPackets.last { it.command == 9.toByte() }.payload) |
|||
} |
|||
|
|||
@Test fun cancellingDidEnvironmentGapDoesNotSendTheNextRequest() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
f.sentPackets.clear() |
|||
val setup = async { f.repository.configureMeasurement(DctMeasurementConfiguration()) } |
|||
advanceTimeBy(119) |
|||
runCurrent() |
|||
assertEquals(listOf(0x40, 0x11, 0x17), f.sentPackets.map { it.command.toInt() and 255 }) |
|||
setup.cancel() |
|||
runCurrent() |
|||
advanceTimeBy(50) |
|||
runCurrent() |
|||
assertTrue(setup.isCancelled) |
|||
assertFalse(f.sentPackets.any { it.command == 9.toByte() || it.command == 0x20.toByte() }) |
|||
} |
|||
|
|||
@Test fun rejectedCanRegistrationDoesNotSendDidOrPostSetup() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
f.sentPackets.clear() |
|||
f.reject = 0x11 |
|||
assertTrue(f.repository.configureMeasurement(DctMeasurementConfiguration()) is DctResult.Failure) |
|||
assertEquals(listOf(0x40, 0x11), f.sentPackets.map { it.command.toInt() and 255 }) |
|||
} |
|||
|
|||
@Test fun didWriteFailureStopsTheSetupBeforeEnvironmentRefresh() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
f.sentPackets.clear() |
|||
coEvery { f.wifi.sendCommand(match { it.command == 0x17.toByte() }) } returns false |
|||
assertTrue(f.repository.configureMeasurement(DctMeasurementConfiguration()) is DctResult.Failure) |
|||
assertEquals(listOf(0x40, 0x11), f.sentPackets.map { it.command.toInt() and 255 }) |
|||
} |
|||
|
|||
@ParameterizedTest |
|||
@ValueSource(ints = [0, 49, 255]) |
|||
fun didPresetMaskIsSerializedWithoutOverwritingProjectIntent(mask: Int) = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
assertTrue(f.repository.configureMeasurement(DctMeasurementConfiguration(didPreSetting = mask)) is DctResult.Success) |
|||
assertArrayEquals(byteArrayOf(mask.toByte()), f.sentPackets.single { it.command == 0x17.toByte() }.payload) |
|||
} |
|||
|
|||
@Test fun explicitStartRejectionAndMalformedResponseKeepTcpWithoutPretendingToMeasure() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
coEvery { f.wifi.sendCommand(match { it.command == 0x20.toByte() }) } coAnswers { |
|||
f.packets.emit(DctPacket(0xA0.toByte(), byteArrayOf(2, 1))) |
|||
true |
|||
} |
|||
assertTrue(f.repository.startStreaming(30) is DctResult.Failure) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
assertTrue(f.connected.value) |
|||
coEvery { f.wifi.sendCommand(match { it.command == 0x20.toByte() }) } coAnswers { |
|||
f.packets.emit(DctPacket(0xA0.toByte(), byteArrayOf(1))) |
|||
true |
|||
} |
|||
assertTrue(f.repository.startStreaming(30) is DctResult.Failure) |
|||
assertTrue(f.connected.value) |
|||
assertTrue(f.repository.isConnected.value) |
|||
assertFalse(f.repository.isStreaming.value) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
assertFalse(f.sentPackets.any { it.command == 0x21.toByte() || it.command == 0x0F.toByte() }) |
|||
coVerify(exactly = 0) { f.wifi.disconnectSuspend() } |
|||
} |
|||
|
|||
@Test fun configurationTimeoutAfterPlaybackKeepsTcpUntilExplicitDisconnectAndNewSessionResetsPolicy() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
f.sessionId = 7L |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
coEvery { f.wifi.sendCommand(match { it.command == 0x20.toByte() }) } coAnswers { |
|||
f.sentPackets += firstArg<DctPacket>() |
|||
f.packets.emit(DctPacket(0xA0.toByte(), byteArrayOf(1, 1))) |
|||
true |
|||
} |
|||
assertTrue(f.repository.startStreaming() is DctResult.Success) |
|||
assertTrue(f.repository.stopStreaming() is DctResult.Success) |
|||
f.silent = 9 |
|||
assertTrue(f.repository.configureMeasurement(DctMeasurementConfiguration()) is DctResult.Failure) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
assertTrue(f.connected.value) |
|||
verify(exactly = 0) { f.wifi.invalidateConnectionIfSession(any()) } |
|||
|
|||
assertTrue(f.repository.disconnect() is DctResult.Success) |
|||
assertFalse(f.connected.value) |
|||
coVerify(exactly = 1) { f.wifi.disconnectSuspend() } |
|||
assertEquals(0x0F.toByte(), f.sentPackets.last().command) |
|||
|
|||
f.sessionId = 8L |
|||
f.connected.value = true |
|||
f.silent = null |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
f.silent = 9 |
|||
assertTrue(f.repository.configureMeasurement(DctMeasurementConfiguration()) is DctResult.Failure) |
|||
assertFalse(f.connected.value) |
|||
assertEquals(DeviceConnectionState.ERROR, f.repository.connectionState.value) |
|||
verify(exactly = 1) { f.wifi.invalidateConnectionIfSession(8L) } |
|||
} |
|||
|
|||
@Test fun stopTimeoutEndsLocalMeasurementButKeepsTransportAlive() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
coEvery { |
|||
f.wifi.sendCommand(match { it.command == DctCommand.CMD_START_TRANSMIT_DATA.code }) |
|||
} coAnswers { |
|||
f.packets.emit(DctPacket(DctCommand.RES_START_TRANSMIT_DATA.code, byteArrayOf(1, 1))) |
|||
true |
|||
} |
|||
assertTrue(f.repository.startStreaming(30) is DctResult.Success) |
|||
|
|||
// Simulate a peer that accepted the STOP write but whose A1 ACK is |
|||
// delayed/lost. This must not be treated as a Wi-Fi/TCP disconnect. |
|||
coEvery { |
|||
f.wifi.sendCommand(match { it.command == DctCommand.CMD_STOP_TRANSMIT_DATA.code }) |
|||
} returns true |
|||
|
|||
assertTrue(f.repository.stopStreaming() is DctResult.Success) |
|||
coVerify(exactly = 0) { f.wifi.disconnectSuspend() } |
|||
assertTrue(f.connected.value) |
|||
assertEquals(DeviceConnectionState.READY, f.repository.connectionState.value) |
|||
assertFalse(f.repository.isStreaming.value) |
|||
} |
|||
|
|||
@Test fun restartWaitsForLateStopAckBeforeSendingStart() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
every { f.wifi.currentSessionId } returns 7L |
|||
assertTrue(f.repository.connect("") is DctResult.Success) |
|||
|
|||
coEvery { |
|||
f.wifi.sendCommand(match { it.command == DctCommand.CMD_START_TRANSMIT_DATA.code }) |
|||
} coAnswers { |
|||
f.packets.emit(DctPacket( |
|||
DctCommand.RES_START_TRANSMIT_DATA.code, |
|||
byteArrayOf(1, 1), |
|||
transportSessionId = 7L |
|||
)) |
|||
true |
|||
} |
|||
assertTrue(f.repository.startStreaming(30) is DctResult.Success) |
|||
|
|||
coEvery { |
|||
f.wifi.sendCommand(match { it.command == DctCommand.CMD_STOP_TRANSMIT_DATA.code }) |
|||
} returns true |
|||
assertTrue(f.repository.stopStreaming() is DctResult.Success) |
|||
|
|||
val restart = async { f.repository.startStreaming(30) } |
|||
runCurrent() |
|||
coVerify(exactly = 1) { |
|||
f.wifi.sendCommand(match { it.command == DctCommand.CMD_START_TRANSMIT_DATA.code }) |
|||
} |
|||
|
|||
f.packets.emit(DctPacket( |
|||
DctCommand.RES_STOP_TRANSMIT_DATA.code, |
|||
byteArrayOf(1), |
|||
transportSessionId = 7L |
|||
)) |
|||
runCurrent() |
|||
|
|||
assertTrue(restart.await() is DctResult.Success) |
|||
coVerify(exactly = 2) { |
|||
f.wifi.sendCommand(match { it.command == DctCommand.CMD_START_TRANSMIT_DATA.code }) |
|||
} |
|||
} |
|||
|
|||
@Test fun disableDoesNotWaitForUndefined8fResponse() = runTest { |
|||
val f = Fixture(UnconfinedTestDispatcher(testScheduler)) |
|||
coEvery { f.wifi.sendCommand(any()) } returns true |
|||
val before = testScheduler.currentTime |
|||
assertTrue(f.repository.sendCommand(DctProtocolRequests.disable()) is DctResult.Success) |
|||
assertEquals(before, testScheduler.currentTime) |
|||
} |
|||
} |
|||
@ -1,114 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.logger.CsvMeasurementLogger |
|||
import com.dct.app.data.logger.PcCsvColumn |
|||
import com.dct.app.data.repository.DpcProjectManager |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.MdbDatabase |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import com.dct.app.domain.model.mdb.SignalGroup |
|||
import com.dct.app.domain.model.project.DpcProject |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.presentation.main.MainUiState |
|||
import com.dct.app.presentation.main.MainViewModel |
|||
import com.dct.app.presentation.main.MeasurementRecordingState |
|||
import kotlinx.coroutines.cancel |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import org.json.JSONObject |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
import java.text.SimpleDateFormat |
|||
import java.util.Calendar |
|||
import java.util.Date |
|||
import java.util.Locale |
|||
|
|||
class PcCsvTimestampTest { |
|||
@TempDir lateinit var folder: File |
|||
private fun field(target: Any, name: String) = target.javaClass.getDeclaredField(name).also { it.isAccessible = true } |
|||
|
|||
@Test fun wholeSecondDisplayPreservesEverySampleAndTheDateAcrossMidnight() { |
|||
val start = Calendar.getInstance().apply { |
|||
clear(); set(2026, Calendar.OCTOBER, 6, 23, 59, 59); set(Calendar.MILLISECOND, 100) |
|||
}.timeInMillis |
|||
for (milliseconds in listOf(false, true)) { |
|||
val logger = CsvMeasurementLogger(folder, listOf("Value" to "V"), "midnight-$milliseconds.csv", |
|||
listOf(PcCsvColumn()), withMilliseconds = milliseconds) |
|||
val file = logger.start()!! |
|||
listOf(0L, 100L, 900L).forEachIndexed { index, delta -> |
|||
logger.logSample((start + delta) / 1000.0, listOf(index.toDouble())) |
|||
} |
|||
logger.stop() |
|||
val times = if (milliseconds) listOf("2026-10-06 23:59:59.100", "2026-10-06 23:59:59.200", "2026-10-07 00:00:00.000") |
|||
else listOf("2026-10-06 23:59:59", "2026-10-06 23:59:59", "2026-10-07 00:00:00") |
|||
val rows = file.readLines().drop(7) |
|||
assertEquals(3, rows.size) |
|||
rows.forEachIndexed { index, row -> assertEquals("${times[index]}, $index,${index}.000", row) } |
|||
} |
|||
} |
|||
|
|||
@Test fun existingPcTimestampKeysSurviveProjectSaveAndRestore() { |
|||
for (enabled in listOf(false, true)) for (interval in listOf(0, 1, 5)) { |
|||
val raw = JSONObject().put("csv_with_miliseconds", enabled).put("save_interval", interval) |
|||
val json = DpcProjectManager.serializeProjectToJson(DpcProject(rawJsonRoot = raw, csvWithMilliseconds = enabled, |
|||
baseFolder = folder.absolutePath, measuredFilesFolder = folder.resolve("Data").absolutePath)) |
|||
val restored = DpcProjectManager.parseProjectFromJson(json, null).rawJsonRoot!! |
|||
assertEquals(enabled, restored.getBoolean("csv_with_miliseconds")) |
|||
assertEquals(interval, restored.getInt("save_interval")) |
|||
} |
|||
} |
|||
|
|||
@Suppress("UNCHECKED_CAST") |
|||
@Test fun actualRecordingUsesCsvChoiceRegardlessOfSaveIntervalOrObsoleteTxtSetting() { |
|||
val cases = listOf("{}" to false, |
|||
"{\"csv_with_miliseconds\":false,\"save_interval\":0}" to false, |
|||
"{\"android_log_microseconds\":true}" to false, |
|||
"{\"csv_with_miliseconds\":true}" to true, |
|||
"{\"csv_with_miliseconds\":true,\"save_interval\":1}" to true, |
|||
"{\"csv_with_miliseconds\":true,\"save_interval\":0}" to true) |
|||
for ((settings, milliseconds) in cases) { |
|||
val fixture = MainViewModelTest().also { it.setUp() } |
|||
val vm = field(fixture, "viewModel").get(fixture) as MainViewModel |
|||
try { |
|||
vm.setCurrentProject(DpcProjectManager.parseProjectFromJson(settings, null).copy( |
|||
projectFileName = "CSV.dpc", mdbFileName = "fixture.mdb", |
|||
measuredFilesFolder = folder.absolutePath, writeCsv = true, writeMf4 = false)) |
|||
val signal = SignalDefinition(1, 1, "Value", MdbAttrType.ATTR_0_UINT8, 1.0, 0.0, "V", 0L, 0.0, 255.0) |
|||
val ui = field(vm, "_uiState").get(vm) as MutableStateFlow<MainUiState> |
|||
ui.value = ui.value.copy(isConnected = true, isMeasuring = true, |
|||
recordingState = MeasurementRecordingState.IDLE, |
|||
mdbDatabase = MdbDatabase("fixture.mdb", listOf(SignalGroup(1, "G", "", true, signals = listOf(signal))))) |
|||
vm.startMeasurementRecording() |
|||
assertEquals(MeasurementRecordingState.RECORDING, vm.uiState.value.recordingState) |
|||
vm.setCsvWithMilliseconds(!milliseconds) // Current file must keep its starting format. |
|||
val time = vm.uiState.value.recordingStartedAtMillis!! + 400 |
|||
val packet = DctPacket(0xA3.toByte(), byteArrayOf(1, 1, 7), receivedAtMillis = time) |
|||
MainViewModel::class.java.getDeclaredMethod("processIncomingPacket", DctPacket::class.java, |
|||
Double::class.javaPrimitiveType).also { it.isAccessible = true }.invoke(vm, packet, time / 1000.0) |
|||
val logger = (field(vm, "activeCsvLoggers").get(vm) as List<CsvMeasurementLogger>) |
|||
.single { it.outputFile!!.name.endsWith("_mdb.csv") } |
|||
vm.stopMeasurementRecording() |
|||
val pattern = if (milliseconds) "yyyy-MM-dd HH:mm:ss.SSS" else "yyyy-MM-dd HH:mm:ss" |
|||
val expected = SimpleDateFormat(pattern, Locale.US).format(Date(time)) |
|||
assertEquals(listOf("$expected, 0,7"), logger.outputFile!!.readLines().drop(7)) |
|||
vm.startMeasurementRecording() |
|||
assertEquals(MeasurementRecordingState.RECORDING, vm.uiState.value.recordingState) |
|||
val nextTime = vm.uiState.value.recordingStartedAtMillis!! + 123 |
|||
MainViewModel::class.java.getDeclaredMethod("processIncomingPacket", DctPacket::class.java, |
|||
Double::class.javaPrimitiveType).also { it.isAccessible = true }.invoke(vm, |
|||
packet.copy(receivedAtMillis = nextTime), nextTime / 1000.0) |
|||
val nextLogger = (field(vm, "activeCsvLoggers").get(vm) as List<CsvMeasurementLogger>) |
|||
.single { it.outputFile!!.name.endsWith("_mdb.csv") } |
|||
vm.stopMeasurementRecording() |
|||
val nextPattern = if (milliseconds) "yyyy-MM-dd HH:mm:ss" else "yyyy-MM-dd HH:mm:ss.SSS" |
|||
val nextExpected = SimpleDateFormat(nextPattern, Locale.US).format(Date(nextTime)) |
|||
assertEquals(listOf("$nextExpected, 0,7"), nextLogger.outputFile!!.readLines().drop(7)) |
|||
} finally { |
|||
vm.stopMeasurementRecording() |
|||
vm.scope.cancel() |
|||
fixture.tearDown() |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,158 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.repository.DpcProjectManager |
|||
import com.dct.app.domain.model.chart.AxisPosition |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import com.dct.app.domain.model.project.DpcProject |
|||
import org.json.JSONObject |
|||
import org.junit.jupiter.api.Assertions.assertEquals |
|||
import org.junit.jupiter.api.Assertions.assertFalse |
|||
import org.junit.jupiter.api.Assertions.assertNotNull |
|||
import org.junit.jupiter.api.Assertions.assertTrue |
|||
import org.junit.jupiter.api.Test |
|||
|
|||
class PcDpcCompatibilityTest { |
|||
@Test |
|||
fun pcGraphWindowsBecomeAndroidWorkspace() { |
|||
val json = JSONObject( |
|||
""" |
|||
{ |
|||
"name":"PC project", |
|||
"graphItem_property": { |
|||
"graph_linear": false, |
|||
"items":[{"ITEMTYPE":0,"RECLID":7,"INDEX":3},{"ITEMTYPE":1,"INDEX":4}] |
|||
}, |
|||
"formula_property":{"items":[{"name":"Duty","expression":"1+2"}]}, |
|||
"graphWnd_property":{"graphWndInfo":[{"index":2,"legendpos":1,"titlename":"Engine", "items":[ |
|||
{"item_type":0,"item_reclID":7,"item_index":3,"item_name":"RPM","item_hideshow":false,"item_thickness":4,"item_dashstyle":2}, |
|||
{"item_type":1,"item_index":4}, |
|||
{"item_type":2,"item_smindex":0,"item_chindex":1}, |
|||
{"item_type":3,"item_index":0}, |
|||
{"item_type":4,"item_index":4096,"item_name":"Battery"} |
|||
]}]}, |
|||
"multiXgraphWnd_property":{"multiXgraphWndInfo":[{"index":5,"legendpos":2,"titlename":"Multi", "items":[ |
|||
{"item_type":0,"item_reclID":7,"item_index":3} |
|||
]}]} |
|||
} |
|||
""".trimIndent() |
|||
) |
|||
|
|||
val project = DpcProjectManager.parseProjectFromJson(json.toString(), null) |
|||
val workspace = project.workspace |
|||
assertNotNull(workspace) |
|||
assertEquals("pc_page_1", workspace!!.activePageId) |
|||
assertEquals(2, workspace.pages.first().windows.size) |
|||
|
|||
val graph = workspace.pages.first().windows.first() |
|||
assertEquals("GRAPH", graph.type) |
|||
assertEquals("Engine", graph.title) |
|||
assertEquals( |
|||
listOf("sig_7_3", "can_4", "sm_01_02", "formula_Duty", "a2l_4096"), |
|||
graph.signals.map { it.signalId } |
|||
) |
|||
assertFalse(graph.signals.first().isVisible) |
|||
assertEquals(4f, graph.signals.first().lineWidthDp) |
|||
assertEquals(AxisPosition.LEFT_0, graph.signals.first().axisPosition) |
|||
assertEquals(AxisPosition.LEFT_0, graph.signals[1].axisPosition) |
|||
assertEquals(AxisPosition.LEFT_0, graph.signals[4].axisPosition) |
|||
assertEquals(AxisPosition.LEFT_0, workspace.pages.first().windows[1].signals.first().axisPosition) |
|||
assertEquals(false, project.graphLinear) |
|||
} |
|||
|
|||
@Test |
|||
fun pcTileWindowMapsToAlphanumericalAndRoundTrips() { |
|||
val json = JSONObject( |
|||
""" |
|||
{ |
|||
"name":"PC tiles", |
|||
"tileWnd_property":{"tileWndInfo":[{"index":3,"istilemode":false,"titlename":"Live values", "items":[ |
|||
{"item_type":0,"item_reclID":7,"item_index":3,"item_name":"RPM","item_hideshow":false,"item_tilecolor":16711935}, |
|||
{"item_type":1,"item_index":4,"item_tilecolor":255} |
|||
]}]} |
|||
} |
|||
""".trimIndent() |
|||
) |
|||
val parsed = DpcProjectManager.parseProjectFromJson(json.toString(), null) |
|||
val tile = parsed.workspace!!.pages.single().windows.single() |
|||
assertEquals("ALPHANUMERICAL", tile.type) |
|||
assertEquals(listOf("sig_7_3", "can_4"), tile.targetSignals) |
|||
assertEquals(setOf("sig_7_3"), tile.hiddenSignalIds) |
|||
assertEquals(false, tile.isTileMode) |
|||
|
|||
val saved = JSONObject(DpcProjectManager.serializeProjectToJson(parsed)) |
|||
.getJSONObject("tileWnd_property").getJSONArray("tileWndInfo").getJSONObject(0) |
|||
assertEquals("Live values", saved.getString("titlename")) |
|||
assertEquals(false, saved.getBoolean("istilemode")) |
|||
assertEquals(2, saved.getJSONArray("items").length()) |
|||
assertEquals(0, saved.getJSONArray("items").getJSONObject(0).getInt("item_type")) |
|||
assertEquals(7, saved.getJSONArray("items").getJSONObject(0).getInt("item_reclID")) |
|||
} |
|||
|
|||
@Test |
|||
fun androidWorkspaceIsExportedUsingPcGraphKeys() { |
|||
val signal = SignalDefinition( |
|||
reclid = 7, idx = 3, name = "RPM", attr = MdbAttrType.ATTR_2_UINT16, |
|||
cvsA = 1.0, cvsB = 0.0, unit = "rpm", color = 0x00112233L, |
|||
min = 0.0, max = 8000.0 |
|||
) |
|||
val source = JSONObject( |
|||
""" |
|||
{"name":"PC", "graphWnd_property":{"vendor":true}, |
|||
"multiXgraphWnd_property":{"vendor":true}, |
|||
"graphItem_property":{"graph_linear":true,"vendor":7}} |
|||
""".trimIndent() |
|||
) |
|||
val project = DpcProjectManager.parseProjectFromJson(source.toString(), null).copy( |
|||
graphLinear = true, |
|||
mdbDatabase = com.dct.app.domain.model.mdb.MdbDatabase( |
|||
groups = listOf(com.dct.app.domain.model.mdb.SignalGroup(7, "7", "", true, signals = listOf(signal))) |
|||
) |
|||
) |
|||
val workspace = com.dct.app.domain.model.project.DpcWorkspaceState( |
|||
activePageId = "page", |
|||
pages = listOf( |
|||
com.dct.app.domain.model.project.DpcPageState( |
|||
id = "page", title = "Page", |
|||
windows = listOf( |
|||
com.dct.app.domain.model.project.DpcWindowState( |
|||
id = "pc_graph_2", type = "GRAPH", title = "Engine", |
|||
signals = listOf( |
|||
com.dct.app.domain.model.project.DpcSignalBindingState( |
|||
"sig_7_3", "RPM", AxisPosition.LEFT_0, 0x00112233L, |
|||
unit = "rpm", isVisible = false, lineWidthDp = 4f, dashStyle = 2 |
|||
) |
|||
) |
|||
), |
|||
com.dct.app.domain.model.project.DpcWindowState( |
|||
id = "pc_multi_5", type = "MULTI_AXIS_GRAPH", title = "Multi" |
|||
) |
|||
) |
|||
) |
|||
) |
|||
) |
|||
|
|||
val serialized = JSONObject( |
|||
DpcProjectManager.serializeProjectToJson(project.copy(workspace = workspace)) |
|||
) |
|||
val graph = serialized.getJSONObject("graphWnd_property") |
|||
.getJSONArray("graphWndInfo").getJSONObject(0) |
|||
assertEquals(2, graph.getInt("index")) |
|||
assertEquals("Engine", graph.getString("titlename")) |
|||
val item = graph.getJSONArray("items").getJSONObject(0) |
|||
assertEquals(0, item.getInt("item_type")) |
|||
assertEquals(7, item.getInt("item_reclID")) |
|||
assertEquals(3, item.getInt("item_index")) |
|||
assertFalse(item.getBoolean("item_hideshow")) |
|||
assertEquals(4, item.getInt("item_thickness")) |
|||
assertEquals(2, item.getInt("item_dashstyle")) |
|||
assertEquals(1, serialized.getJSONObject("multiXgraphWnd_property") |
|||
.getJSONArray("multiXgraphWndInfo").length()) |
|||
val global = serialized.getJSONObject("graphItem_property").getJSONArray("items") |
|||
assertEquals(1, global.length()) |
|||
assertEquals(7, global.getJSONObject(0).getInt("RECLID")) |
|||
assertEquals(3, global.getJSONObject(0).getInt("INDEX")) |
|||
assertTrue(serialized.has("android_workspace")) |
|||
assertTrue(serialized.getJSONObject("graphWnd_property").getBoolean("vendor")) |
|||
} |
|||
} |
|||
@ -1,268 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.logger.Mf4MeasurementLogger |
|||
import com.dct.app.data.logger.PcMf4Channel |
|||
import com.dct.app.data.parser.A2lParser |
|||
import com.dct.app.domain.model.a2l.A2lDataType |
|||
import com.dct.app.domain.model.mdb.MdbAttrType |
|||
import com.dct.app.domain.model.mdb.MdbDatabase |
|||
import com.dct.app.domain.model.mdb.SignalDefinition |
|||
import com.dct.app.domain.model.mdb.SignalGroup |
|||
import com.dct.app.domain.model.project.DpcProject |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import com.dct.app.presentation.main.MainUiState |
|||
import com.dct.app.presentation.main.MainViewModel |
|||
import com.dct.app.presentation.main.MeasurementRecordingState |
|||
import kotlinx.coroutines.cancel |
|||
import kotlinx.coroutines.flow.MutableStateFlow |
|||
import org.json.JSONObject |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Assumptions.assumeTrue |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
import java.nio.ByteBuffer |
|||
import java.nio.ByteOrder |
|||
import java.util.zip.Inflater |
|||
|
|||
class PcMf4CompatibilityTest { |
|||
@TempDir lateinit var folder: File |
|||
private fun bytes(file: File) = ByteBuffer.wrap(file.readBytes()).order(ByteOrder.LITTLE_ENDIAN) |
|||
private fun export(file: File) { |
|||
System.getenv("DCT_PC_MF4_INPUT")?.let { root -> file.copyTo(File(root, file.name), overwrite = true) } |
|||
} |
|||
|
|||
private fun records(file: File): ByteBuffer { |
|||
val fileBytes = bytes(file) |
|||
val size = fileBytes.getInt(232 + 96) |
|||
val hl = fileBytes.getLong(168 + 40).toInt() |
|||
assertEquals("##HL", String(fileBytes.array(), hl, 4)) |
|||
assertEquals(1, fileBytes.get(hl + 34).toInt()) |
|||
var dl = fileBytes.getLong(hl + 24).toInt() |
|||
val output = java.io.ByteArrayOutputStream() |
|||
while (dl != 0) { |
|||
val dz = fileBytes.getLong(dl + 32).toInt() |
|||
assertEquals("##DZ", String(fileBytes.array(), dz, 4)) |
|||
assertEquals(size, fileBytes.getInt(dz + 28)) |
|||
val rawSize = fileBytes.getLong(dz + 32).toInt() |
|||
val zipSize = fileBytes.getLong(dz + 40).toInt() |
|||
val transposed = ByteArray(rawSize) |
|||
val inflater = Inflater() |
|||
try { |
|||
inflater.setInput(fileBytes.array(), dz + 48, zipSize) |
|||
var read = 0 |
|||
while (!inflater.finished() && read < rawSize) { |
|||
val amount = inflater.inflate(transposed, read, rawSize - read) |
|||
assertTrue(amount > 0, "Truncated compressed record data") |
|||
read += amount |
|||
} |
|||
assertEquals(rawSize, read) |
|||
} finally { inflater.end() } |
|||
val rows = rawSize / size |
|||
val raw = ByteArray(rawSize) |
|||
for (column in 0 until size) for (row in 0 until rows) raw[row * size + column] = transposed[column * rows + row] |
|||
output.write(raw) |
|||
dl = fileBytes.getLong(dl + 24).toInt() |
|||
} |
|||
return ByteBuffer.wrap(output.toByteArray()).order(ByteOrder.LITTLE_ENDIAN) |
|||
} |
|||
|
|||
@Test fun rawSignedWidthsAndConversionDoNotRoundTripThroughPhysicalDouble() { |
|||
val channels = listOf(PcMf4Channel("U8", dataType=0, bitCount=8), |
|||
PcMf4Channel("S16", "°C", 2, 16, factor=.1, offset=-40.0, description="sensor", |
|||
sourceName="sensor", sourcePath="ECU.sensor"), |
|||
PcMf4Channel("U64", dataType=0, bitCount=64), PcMf4Channel("F32", bitCount=32)) |
|||
val logger = Mf4MeasurementLogger(folder, channels.map { it.name to it.unit }, "raw.mf4", channels) |
|||
val file = logger.start(1000)!! |
|||
logger.logRawSampleAtMillis(1125, listOf(255, -134, -1L, 3.75)) |
|||
logger.logRawSampleAtMillis(1500, listOf(null, null, null, null)) |
|||
logger.stop() |
|||
val record = records(file) |
|||
assertEquals(23, bytes(file).getInt(232 + 96)) |
|||
assertEquals(.125, record.double) |
|||
assertEquals(255, record.get().toInt() and 255) |
|||
assertEquals(-134, record.short.toInt()) |
|||
assertEquals(-1L, record.long) // All 64 uint bits survive without Double conversion. |
|||
assertEquals(3.75f, record.float) |
|||
assertEquals(.5, record.double) |
|||
assertEquals(255, record.get().toInt() and 255) |
|||
assertEquals(-134, record.short.toInt()) // PC preserves previous values for other messages. |
|||
assertEquals(-1L, record.long) |
|||
assertEquals(3.75f, record.float) |
|||
val data = bytes(file) |
|||
assertEquals(9, data.getShort(64 + 80).toInt()) |
|||
assertTrue(data.getLong(64 + 32) > 0) |
|||
assertTrue(data.getLong(64 + 64) > 0) |
|||
val secondCn = data.getLong(336 + 24).toInt() |
|||
val thirdCn = data.getLong(secondCn + 24).toInt() |
|||
assertTrue(data.getLong(thirdCn + 48) > 0) |
|||
assertTrue(data.getLong(thirdCn + 56) > 0) |
|||
} |
|||
|
|||
@Test fun productionA2lDefinitionsPreserveNativeTypesUnitsSourceAndNonlinearConversions() { |
|||
val base = SignalDefinition(0, 1, "Rational", MdbAttrType.ATTR_3_INT16, 1.0, 0.0, "C", 0L, -100.0, 100.0, |
|||
description = "ECU measurement") |
|||
val measurement = A2lParser.A2lMeasurement("Rational", unit = "degC", symbolLink = "ECU.Rational") |
|||
for (type in A2lDataType.entries) { |
|||
val definition = PcMf4Channel.a2l(base.copy(a2lDataType = type), measurement to null) |
|||
assertEquals(if (type.isFloat) 4 else if (type.isSigned) 2 else 0, definition.dataType) |
|||
assertEquals(if (type == A2lDataType.FLOAT16_IEEE) 32 else type.byteSize * 8, definition.bitCount) |
|||
assertEquals("degC", definition.unit) // MF4 retains the original unit, not the UI alias. |
|||
assertEquals("ECU.Rational", definition.sourcePath) |
|||
assertEquals(-100.0 to 100.0, definition.rawRange) |
|||
} |
|||
val rational = A2lParser.CompuMethod("R", conversionType = "RAT_FUNC", |
|||
cvsA = 1.0, cvsB = 2.0, cvsC = 3.0, cvsD = 0.0, cvsE = 0.0, cvsF = 1.0) |
|||
val table = A2lParser.CompuMethod("T", conversionType = "TAB_INTP", tabIntpPoints = listOf(0.0 to 0.0, 10.0 to 100.0)) |
|||
val channels = listOf(PcMf4Channel.a2l(base.copy(a2lDataType = A2lDataType.SWORD), measurement to rational), |
|||
PcMf4Channel.a2l(base.copy(name = "Table", a2lDataType = A2lDataType.SWORD), |
|||
measurement.copy(name = "Table", symbolLink = "ECU.Table") to table)) |
|||
assertEquals(listOf(2, 4), channels.map { it.conversionType }) |
|||
val logger = Mf4MeasurementLogger(folder, channels.map { it.name to it.unit }, "conversions-pc.mf4", channels) |
|||
val file = logger.start(1000)!! |
|||
logger.logRawSampleAtMillis(1000, listOf(2, 2)) |
|||
logger.logRawSampleAtMillis(1125, listOf(5, 5)) |
|||
logger.stop() |
|||
export(file) // Independent reader verifies CC evaluation, not only the parameter bytes. |
|||
} |
|||
|
|||
@Test fun compressedChunksStayBoundedAndFollowTheDataListChain() { |
|||
val channels = listOf(PcMf4Channel("Count", dataType=0, bitCount=16)) |
|||
val logger = Mf4MeasurementLogger(folder, listOf("Count" to ""), "chunks.mf4", channels) |
|||
val file = logger.start(1000)!! |
|||
repeat(10_003) { logger.logRawSampleAtMillis(1000L + it, listOf(it)) } |
|||
logger.stop(); logger.stop() |
|||
val raw = records(file) |
|||
assertEquals(10_003 * 10, raw.remaining()) |
|||
repeat(10_003) { assertEquals(it / 1000.0, raw.double); assertEquals(it, raw.short.toInt() and 65535) } |
|||
assertEquals(10_003L, bytes(file).getLong(232 + 80)) |
|||
export(file) |
|||
} |
|||
|
|||
@Test fun emptyCompressedFileAndRestartRemainFinalized() { |
|||
val channel = PcMf4Channel("Value", dataType=2, bitCount=16) |
|||
val logger = Mf4MeasurementLogger(folder, listOf("Value" to ""), "empty-pc.mf4", listOf(channel)) |
|||
val file = logger.start(1000)!! |
|||
logger.stop(); assertEquals(0, records(file).remaining()); export(file) |
|||
logger.start(2000) |
|||
logger.logRawSampleAtMillis(1990, listOf(-2)) // Preserve the previously fixed queued ingress case. |
|||
logger.stop() |
|||
val raw = records(file) |
|||
assertEquals(-.01, raw.double); assertEquals(-2, raw.short.toInt()) |
|||
assertEquals(1L, bytes(file).getLong(232 + 80)) |
|||
export(file.copyTo(File(folder, "queued-pc.mf4"))) |
|||
} |
|||
|
|||
@Test fun newRecordingSeedsLiveRawStateAndAnExplicitNanDoesNotKeepAnOldFormulaValue() { |
|||
val channels = listOf(PcMf4Channel("Raw", dataType=0, bitCount=16), |
|||
PcMf4Channel("Formula", bitCount=32, physicalInput=true)) |
|||
val logger = Mf4MeasurementLogger(folder, channels.map { it.name to it.unit }, "seeded-pc.mf4", channels) |
|||
val file = logger.start(1000, mapOf("Raw" to 65535), mapOf("Formula" to 1.5))!! |
|||
logger.logRawSampleAtMillis(1000, listOf(null, null)) |
|||
logger.logRawSampleAtMillis(1125, listOf(null, Double.NaN)) |
|||
logger.logRawSampleAtMillis(1500, listOf(null, null)) |
|||
logger.stop() |
|||
val raw = records(file) |
|||
assertEquals(0.0, raw.double); assertEquals(65535, raw.short.toInt() and 65535); assertEquals(1.5f, raw.float) |
|||
assertEquals(.125, raw.double); assertEquals(65535, raw.short.toInt() and 65535); assertTrue(raw.float.isNaN()) |
|||
assertEquals(.5, raw.double); assertEquals(65535, raw.short.toInt() and 65535); assertTrue(raw.float.isNaN()) |
|||
} |
|||
|
|||
@Suppress("UNCHECKED_CAST") |
|||
@Test fun realRecordingStartAndRestartKeepLiveRawValuesFromOtherMdbMessages() { |
|||
fun field(target: Any, name: String) = target.javaClass.getDeclaredField(name).also { it.isAccessible = true } |
|||
val fixture = MainViewModelTest().also { it.setUp() } |
|||
val vm = field(fixture, "viewModel").get(fixture) as MainViewModel |
|||
val process = MainViewModel::class.java.getDeclaredMethod("processIncomingPacket", DctPacket::class.java, |
|||
Double::class.javaPrimitiveType).also { it.isAccessible = true } |
|||
val close = MainViewModel::class.java.getDeclaredMethod("closeMeasurementLoggers").also { it.isAccessible = true } |
|||
fun receive(recordId: Int, value: Int, time: Long) { |
|||
val payload = if (recordId == 1) byteArrayOf(1, 1, value.toByte()) |
|||
else byteArrayOf(1, 2, (value ushr 8).toByte(), value.toByte()) |
|||
process.invoke(vm, DctPacket(0xA3.toByte(), payload, receivedAtMillis = time), time / 1000.0) |
|||
} |
|||
try { |
|||
vm.setCurrentProject(DpcProject(mdbFileName = "fixture.mdb", projectFileName = "MID.dpc", |
|||
measuredFilesFolder = folder.absolutePath, writeCsv = false, writeMf4 = true)) |
|||
val a = SignalDefinition(1, 1, "A", MdbAttrType.ATTR_0_UINT8, 2.0, -10.0, "V", 0L, 0.0, 255.0) |
|||
val b = SignalDefinition(2, 2, "B", MdbAttrType.ATTR_2_UINT16, .1, -40.0, "C", 0L, 0.0, 65535.0) |
|||
val ui = field(vm, "_uiState").get(vm) as MutableStateFlow<MainUiState> |
|||
ui.value = ui.value.copy(isConnected = true, isMeasuring = true, |
|||
recordingState = MeasurementRecordingState.IDLE, |
|||
mdbDatabase = MdbDatabase("fixture.mdb", listOf( |
|||
SignalGroup(1, "A", "", true, signals = listOf(a)), |
|||
SignalGroup(2, "B", "", true, signals = listOf(b))))) |
|||
receive(1, 12, System.currentTimeMillis()) |
|||
receive(2, 500, System.currentTimeMillis()) |
|||
repeat(2) { recording -> |
|||
vm.startMeasurementRecording() |
|||
assertEquals(MeasurementRecordingState.RECORDING, vm.uiState.value.recordingState) |
|||
val start = vm.uiState.value.recordingStartedAtMillis!! |
|||
// Only one message arrives in each file. The other channel must come from live raw state. |
|||
receive(if (recording == 0) 1 else 2, if (recording == 0) 20 else 600, start + 125) |
|||
val logger = (field(vm, "activeMf4Loggers").get(vm) as List<Mf4MeasurementLogger>) |
|||
.single { it.outputFile!!.name.endsWith("_mdb.mf4") } |
|||
vm.stopMeasurementRecording() |
|||
assertEquals(MeasurementRecordingState.IDLE, vm.uiState.value.recordingState) |
|||
val raw = records(logger.outputFile!!) |
|||
assertEquals(16, raw.remaining()) // Exactly one sample: Time + 2 signed32 channels. |
|||
assertEquals(.125, raw.double) |
|||
assertEquals(20, raw.int) // Not the physical value 30, including on restart. |
|||
assertEquals(if (recording == 0) 500 else 600, raw.int) // Not physical 10/20. |
|||
} |
|||
} finally { |
|||
close.invoke(vm) |
|||
vm.scope.cancel() |
|||
fixture.tearDown() |
|||
} |
|||
} |
|||
|
|||
@Test fun wideTypedRecordingUsesBoundedCompressedChunksWithoutDroppingTailChannels() { |
|||
val channels = (0 until 4939).map { PcMf4Channel("DBC_$it", dataType=0, bitCount=32) } |
|||
val logger = Mf4MeasurementLogger(folder, channels.map { it.name to it.unit }, "wide-pc.mf4", channels) |
|||
val file = logger.start(1000)!! |
|||
repeat(400) { logger.logRawSampleAtMillis(1000L + it, listOf(it)) } |
|||
logger.stop() |
|||
val record = records(file) |
|||
assertEquals(19764, bytes(file).getInt(232 + 96)) |
|||
repeat(400) { row -> |
|||
assertEquals(row / 1000.0, record.double) |
|||
assertEquals(row, record.int) |
|||
repeat(4938) { assertEquals(0, record.int) } |
|||
} |
|||
export(file) |
|||
} |
|||
|
|||
@Test fun regenerateCommonInputForIndependentPcDllComparison() { |
|||
val path = System.getenv("DCT_PC_MF4_INPUT") |
|||
assumeTrue(path != null, "Optional PC raw-input artifacts for independent comparison") |
|||
val root = File(path!!) |
|||
for (name in listOf("reference", "synthetic")) { |
|||
val input = JSONObject(File(root, "$name.json").readText()) |
|||
val definitions = input.getJSONArray("channels") |
|||
val channels = (1 until definitions.length()).map { index -> |
|||
val c = definitions.getJSONObject(index) |
|||
val source = c.optJSONObject("source") |
|||
val conversion = c.optJSONObject("conversion") |
|||
val parameters = conversion?.getJSONArray("parameters") |
|||
PcMf4Channel(c.getString("name"), c.getString("unit"), c.getInt("data_type"), c.getInt("bit_count"), |
|||
factor=parameters?.getDouble(1) ?: 1.0, offset=parameters?.getDouble(0) ?: 0.0, |
|||
description=c.getString("description"), sourceName=source?.getString("name"), |
|||
sourcePath=source?.getString("path").orEmpty(), sourceComment=source?.getString("comment").orEmpty(), |
|||
rawRange=if(c.getInt("flags") and 8 != 0) c.getDouble("min_raw") to c.getDouble("max_raw") else null) |
|||
} |
|||
val logger = Mf4MeasurementLogger(root, channels.map { it.name to it.unit }, "android-$name.mf4", channels) |
|||
val start = input.getLong("start_ns") / 1_000_000L |
|||
val file = logger.start(start)!! |
|||
val samples = input.getJSONArray("records") |
|||
repeat(samples.length()) { index -> |
|||
val row = samples.getJSONArray(index) |
|||
logger.logRawSampleAtMillis(start + Math.round(row.getDouble(0) * 1000), |
|||
(1 until row.length()).map { if (row.isNull(it)) null else row.get(it) as Number }) |
|||
} |
|||
logger.stop() |
|||
assertEquals(input.getInt("record_size"), bytes(file).getInt(232 + 96)) |
|||
assertEquals(samples.length().toLong(), bytes(file).getLong(232 + 80)) |
|||
} |
|||
} |
|||
} |
|||
@ -1,189 +0,0 @@ |
|||
package com.dct.app.tests |
|||
|
|||
import com.dct.app.data.communication.WifiSocketManager |
|||
import com.dct.app.data.logger.PcOperationalLogger |
|||
import com.dct.app.data.protocol.DctPacketCodec |
|||
import com.dct.app.domain.model.protocol.DctPacket |
|||
import kotlinx.coroutines.* |
|||
import kotlinx.coroutines.flow.first |
|||
import kotlinx.coroutines.test.* |
|||
import org.junit.jupiter.api.Assertions.* |
|||
import org.junit.jupiter.api.Test |
|||
import org.junit.jupiter.api.io.TempDir |
|||
import java.io.File |
|||
import java.net.ServerSocket |
|||
import java.text.SimpleDateFormat |
|||
import java.util.Locale |
|||
|
|||
@OptIn(ExperimentalCoroutinesApi::class) |
|||
class PcOperationalLoggerTest { |
|||
@TempDir lateinit var folder: File |
|||
private val time = SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.US) |
|||
.parse("2026-10-01 12:34:56.789")!!.time |
|||
private val codec = DctPacketCodec() |
|||
private val packet = DctPacket(0xA3.toByte(), byteArrayOf(0, 1, 0xFF.toByte())) |
|||
private fun files(extension: String) = folder.listFiles()!!.filter { it.extension == extension } |
|||
private fun decodeLine(line: String): ByteArray = line.substringAfter("] ") |
|||
.trim().split(' ').map { it.toInt(16).toByte() }.toByteArray() |
|||
|
|||
@Test fun actionCsvHasPcHeadersEscapingAndDrainsOnClose() = runTest { |
|||
val logger = PcOperationalLogger({ folder }, StandardTestDispatcher(testScheduler), { time }) |
|||
logger.action("Open project file A,\"B\".dpc\nOK") |
|||
logger.close() |
|||
logger.action("must not be written") |
|||
logger.awaitClosed() |
|||
val file = files("csv").single() |
|||
assertEquals("2026-10-01_12-34-56_log.csv", file.name) |
|||
val csv = file.readText() |
|||
assertTrue(csv.startsWith("File: ${file.name}\r\nDate: 2026-10-01\r\n\r\n Time, Description,\r\n")) |
|||
assertTrue(csv.contains("12:34:56, Start DCT Program,")) |
|||
assertTrue(csv.contains("\"Open project file A,\"\"B\"\".dpc OK\"")) |
|||
assertTrue(csv.contains("Terminate DCT Program")) |
|||
assertFalse(csv.contains("must not")) |
|||
} |
|||
|
|||
@Test fun fullFramesAndIngressMillisecondsSurviveCallerMutation() = runTest { |
|||
val logger = PcOperationalLogger({ folder }, StandardTestDispatcher(testScheduler), { time }) |
|||
val bytes = codec.encode(packet) |
|||
logger.connected(1, "PC") |
|||
logger.frame(1, "Recv", bytes, time + 10) |
|||
logger.frame(1, "Send", bytes, time + 11) |
|||
bytes.fill(0) |
|||
logger.disconnected(1) |
|||
logger.close(); logger.awaitClosed() |
|||
val file = files("txt").single() |
|||
assertEquals("20261001_123456_log.txt", file.name) |
|||
val lines = file.readLines() |
|||
assertTrue(lines[0].startsWith("[Recv][12:34:56.799] A1 ")) |
|||
assertTrue(lines[1].startsWith("[Send][12:34:56.800] A1 ")) |
|||
lines.forEach { assertEquals(packet, codec.decode(decodeLine(it))) } |
|||
} |
|||
|
|||
@Test fun noPacketCreatesNoTxtAndSameSecondConnectionsNeverOverwrite() = runTest { |
|||
val logger = PcOperationalLogger({ folder }, StandardTestDispatcher(testScheduler), { time }) |
|||
logger.connected(1, "empty"); logger.disconnected(1) |
|||
logger.connected(2, "first"); logger.frame(2, "Recv", codec.encode(packet)) |
|||
logger.disconnected(2) |
|||
logger.connected(3, "second") |
|||
logger.frame(2, "Recv", codec.encode(packet)) // Stale writer after reconnect. |
|||
logger.disconnected(2) // Must not close connection 3. |
|||
logger.frame(3, "Send", codec.encode(packet)) |
|||
logger.close(); logger.awaitClosed() |
|||
assertEquals(2, files("txt").size) |
|||
assertEquals(setOf("20261001_123456_log.txt", "20261001_123456_log-01.txt"), files("txt").map { it.name }.toSet()) |
|||
assertEquals(2, files("txt").sumOf { it.readLines().size }) |
|||
} |
|||
|
|||
@Test fun fixedPcMillisecondsKeepEveryPacketInOrderEvenWithEqualTimestamps() = runTest { |
|||
val logger = PcOperationalLogger({ folder }, StandardTestDispatcher(testScheduler), { time }) |
|||
logger.connected(1, "PC") |
|||
val expected = (1..4).map { DctPacket(0xA3.toByte(), byteArrayOf(it.toByte())) } |
|||
logger.frame(1, "Recv", codec.encode(expected[0]), time) |
|||
logger.frame(1, "Recv", codec.encode(expected[1]), time) |
|||
logger.frame(1, "Recv", codec.encode(expected[2]), time) |
|||
logger.frame(1, "Send", codec.encode(expected[3]), time + 211) |
|||
logger.close(); logger.awaitClosed() |
|||
val lines = files("txt").single().readLines() |
|||
assertEquals(4, lines.size) |
|||
assertTrue(lines[0].startsWith("[Recv][12:34:56.789]")) |
|||
assertTrue(lines[1].startsWith("[Recv][12:34:56.789]")) |
|||
assertTrue(lines[2].startsWith("[Recv][12:34:56.789]")) |
|||
assertTrue(lines[3].startsWith("[Send][12:34:57.000]")) |
|||
assertEquals(expected, lines.map { codec.decode(decodeLine(it)) }) |
|||
} |
|||
|
|||
@Test fun sameSecondAppStartsPreservePreviousCsv() = runTest { |
|||
repeat(2) { |
|||
val logger = PcOperationalLogger({ folder }, StandardTestDispatcher(testScheduler), { time }) |
|||
logger.action("run $it"); logger.close(); logger.awaitClosed() |
|||
} |
|||
assertEquals(2, files("csv").size) |
|||
assertTrue(files("csv").any { it.readText().contains("run 0") }) |
|||
assertTrue(files("csv").any { it.readText().contains("run 1") }) |
|||
} |
|||
|
|||
@Test fun liveRawLogFlushesWithoutStoppingMeasurement() = runTest { |
|||
val logger = PcOperationalLogger({ folder }, StandardTestDispatcher(testScheduler), { time }) |
|||
logger.connected(1, "PC"); logger.frame(1, "Recv", codec.encode(packet)) |
|||
runCurrent() |
|||
advanceTimeBy(1001); runCurrent() |
|||
assertTrue(files("txt").single().readText().contains("[Recv][12:34:56.789]")) |
|||
assertFalse(files("csv").single().readText().contains("Terminate")) |
|||
logger.close(); logger.awaitClosed() |
|||
} |
|||
|
|||
@Test fun boundedQueueExplicitlyMarksIncompleteAndResumesOnNextConnection() = runTest { |
|||
val errors = mutableListOf<Throwable>() |
|||
val bytes = codec.encode(packet) |
|||
val logger = PcOperationalLogger({ folder }, StandardTestDispatcher(testScheduler), { time }, errors::add, bytes.size) |
|||
logger.connected(1, "PC") |
|||
logger.frame(1, "Recv", bytes) |
|||
logger.frame(1, "Recv", bytes) // Disk worker has not run; capacity exhausted. |
|||
logger.frame(1, "Recv", bytes) |
|||
runCurrent() |
|||
logger.disconnected(1); logger.connected(2, "PC") |
|||
logger.frame(2, "Recv", bytes) |
|||
logger.close(); logger.awaitClosed() |
|||
assertEquals(1, errors.size) |
|||
assertTrue(files("csv").single().readText().contains("Communication log incomplete")) |
|||
assertTrue(files("txt").any { it.readText().contains("# Communication log incomplete") }) |
|||
assertEquals(2, files("txt").sumOf { it.readLines().count { line -> line.startsWith("[Recv]") } }) |
|||
} |
|||
|
|||
@Test fun storageFailureIsReportedWithoutThrowingIntoCommunication() = runTest { |
|||
val errors = mutableListOf<Throwable>() |
|||
val notDirectory = File(folder, "not-a-folder").apply { writeText("preserve") } |
|||
val logger = PcOperationalLogger({ notDirectory }, StandardTestDispatcher(testScheduler), { time }, errors::add) |
|||
logger.connected(1, "PC"); logger.frame(1, "Recv", codec.encode(packet)) |
|||
logger.frame(1, "Send", codec.encode(packet)) |
|||
logger.close(); logger.awaitClosed() |
|||
assertEquals(2, errors.size) // CSV and first TXT; no diagnostic file writer. |
|||
assertEquals("preserve", notDirectory.readText()) |
|||
} |
|||
|
|||
@Test fun socketLogsActualTxAndValidatedFragmentedRxBeforeBusinessFiltering() = runBlocking { |
|||
val logger = PcOperationalLogger({ folder }) |
|||
val socketManager = WifiSocketManager(operationalLogger = logger) |
|||
ServerSocket(0).use { server -> |
|||
try { |
|||
assertFalse(socketManager.sendCommand(packet)) // No socket: no fictional TX entry. |
|||
val connected = CompletableDeferred<Unit>() |
|||
socketManager.connect("127.0.0.1", server.localPort, |
|||
onSuccess = { connected.complete(Unit) }, |
|||
onFailure = { connected.completeExceptionally(IllegalStateException(it)) }) |
|||
withContext(Dispatchers.IO) { server.accept() }.use { peer -> |
|||
peer.soTimeout = 3000 |
|||
withTimeout(5000) { connected.await() } |
|||
assertEquals(com.dct.app.data.communication.WifiApEndpoint("127.0.0.1", server.localPort), |
|||
socketManager.connectedEndpoint.value) |
|||
val received = async(start = CoroutineStart.UNDISPATCHED) { socketManager.packetStream.first() } |
|||
val frame = codec.encode(packet) |
|||
val corrupt = frame.copyOf().apply { this[lastIndex - 1] = 0 } |
|||
peer.getOutputStream().write(corrupt + frame.copyOfRange(0, 3)) |
|||
withTimeout(5000) { |
|||
while (socketManager.metrics.tcpBytesRead.get() < corrupt.size + 3L) delay(10) |
|||
} |
|||
assertFalse(received.isCompleted, "A partial/corrupt frame must not be published") |
|||
peer.getOutputStream().write(frame.copyOfRange(3, frame.size)) |
|||
assertEquals(packet, withTimeout(5000) { received.await() }) |
|||
assertTrue(socketManager.sendCommand(packet)) |
|||
assertArrayEquals(frame, withContext(Dispatchers.IO) { peer.getInputStream().readNBytes(frame.size) }) |
|||
socketManager.invalidateConnection() |
|||
assertNull(socketManager.connectedEndpoint.value) |
|||
} |
|||
} finally { |
|||
socketManager.close(); logger.close(); withTimeout(5000) { logger.awaitClosed() } |
|||
} |
|||
} |
|||
val lines = files("txt").single().readLines() |
|||
assertEquals(1, lines.count { it.startsWith("[Recv]") }) |
|||
assertEquals(1, lines.count { it.startsWith("[Send]") }) |
|||
lines.forEach { assertTrue(it.matches(Regex("\\[(Recv|Send)]\\[\\d{2}:\\d{2}:\\d{2}\\.\\d{3}] .*"))) } |
|||
lines.forEach { assertEquals(packet, codec.decode(decodeLine(it))) } |
|||
val csv = files("csv").single().readText() |
|||
assertTrue(csv.contains("Connected 127.0.0.1")) |
|||
assertTrue(csv.contains("Disconnected")) |
|||
assertTrue(files("rxdiag").isEmpty(), "TCP sessions must no longer create .rxdiag files") |
|||
assertTrue(folder.listFiles()!!.all { it.extension in setOf("txt", "csv") }) |
|||
} |
|||
} |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue