IVI Test Engineer Interview Prep
Chapter 9 · Core skill

Tools, traces & logs

The JD mentions "simulation tools for vehicle signals", "logs, traces and evidence" and "trace/log analysis". This chapter explains each tool in plain words and teaches you to read traces and logs, with exercises.

IntermediateReading time: 55 min + exercisesOften asked: log analysis, CANoe, tools used
In very simple words
  • CANoe sends fake car signals and records everything on the network (the trace).
  • DLT Viewer / ADB logcat show what the ECU software writes in its log.
  • To find a bug's cause, look at the same time in both: was the input right? was the output wrong?

See it as a picture: Log analysis timeline · Practise in the mock CANoe lab

Your toolbox at a glance

NeedTypical tools
Simulate the car's signalsVector CANoe (+ CAPL scripts, panels), dSPACE, NI VeriStand, custom simulators
Watch and record the busCANoe, CANalyzer, PCAN-View, BusMaster
Read ECU logsDLT Viewer (Linux ECUs), ADB logcat (Android), serial console
Diagnostics / flashingCANoe diagnostics, Vector vFlash, OEM tools (e.g. ODIS for VW group, ISTA for BMW, XENTRY for Mercedes)
Run automationRobot Framework, pytest, ecu.test, CANoe test modules, Jenkins
Bugs and tasksJira (most common), Polarion, ALM, Redmine
Test cases and resultsJira Xray/Zephyr, Polarion, TestRail, ALM
Requirements and traceabilityPolarion, IBM DOORS, Codebeamer, Jira
DocumentationConfluence, SharePoint
EvidenceScreen recorder / video grabber, camera, Snipping Tool, OBS
Say this: "What tools have you used?"

"[List only what you used, grouped like this:] For simulation and traces, [CANoe]; for logs, [DLT Viewer / ADB logcat]; for defects, Jira; for test cases and results, [Xray / TestRail]; for requirements, [Polarion / DOORS]; for automation, [Robot Framework with Jenkins]. I adapt quickly to customer-specific tools because the concepts are the same."

Vector CANoe: the signal simulator

Simple idea

CANoe is a PC program that can pretend to be all the other ECUs of the car (this is called rest-bus simulation). It sends the messages they would send, so the real head unit and cluster on your bench think they are in a real car. It also records everything on the bus.

The parts of CANoe you'll use

PartWhat it is for
Configuration (.cfg)The saved setup: which networks, which DBC files, which simulated ECUs, which panels. The customer usually provides it.
Start / Stop measurementThe big lightning/start button. Nothing is sent or recorded until the measurement runs.
Simulation setupShows the simulated ECUs (nodes); you can switch a node off to simulate a missing ECU (timeout test!).
PanelsWindows with sliders, buttons and switches to change signals by hand (e.g. temperature slider, gear selector).
Trace windowLive list of all messages with time, ID, name, data and decoded signals.
Data / Graphics windowShow selected signal values as numbers or as graphs over time.
Write windowText output from CAPL scripts and CANoe itself.
Logging blockSaves the trace to a file (.blf or .asc) for evidence.
Replay blockPlays back a recorded trace, e.g. from a test drive, to reproduce a problem.
Diagnostics consoleSend diagnostic requests: read/clear DTCs, read the SW version.

CANalyzer is its smaller sibling: mainly for watching, analysing and recording the bus, with limited simulation.

CAPL: CANoe's scripting language

CAPL looks like the C language. It is event-driven: you write "when this happens, do that" (on key press, on message received, on timer).

variables {
  msTimer rampTimer;          // a timer in milliseconds
  float temp = 6.0;
}

on key 'r' {                  // press 'r' to start the ramp
  temp = 6.0;
  setTimer(rampTimer, 2000);
}

on timer rampTimer {          // every 2 s: lower the temperature by 0.1
  temp = temp - 0.1;
  $Outside_Temp = temp;       // set the signal value
  write("Outside_Temp = %.1f", temp);
  if (temp > 3.85) setTimer(rampTimer, 2000);
}

on message Ambient_Info {     // whenever this message is on the bus
  write("Raw byte 0 = 0x%02X", this.byte(0));
}

This script does the BVA "falling" test automatically: 6.0 → 5.9 → … → 3.9 °C, with 2 s at each value, while you watch the cluster.

Level check

For this role you should know what CAPL is and be able to read a simple script. Writing complex CAPL is not expected for 1–2 years' experience unless your CV says so.

Say this: "How do you use signal simulation?"

"I load the customer's CANoe configuration, start the measurement so the rest-bus simulation runs, and use the panels or a small CAPL script to set signals like speed, gear or outside temperature. For failure tests I stop a simulated node or send invalid values. I always log the trace to a .blf file so I have evidence with timestamps."

Reading a CAN trace

A trace is a recording of the bus. In text form (.asc) it looks like this:

date Wed Sep 30 10:15:00.000 am 2026
base hex  timestamps absolute
   31.920000 1  3A5             Rx   d 8 5C 00 00 00 00 00 00 00
   32.020000 1  1F0             Rx   d 8 88 13 00 00 00 00 00 00
   32.120000 1  3A5             Rx   d 8 5A 00 00 00 00 00 00 00
   32.220000 1  3A5             Rx   d 8 5A 00 00 00 00 00 00 00
ColumnExampleMeaning
Time32.120000Seconds since measurement start
Channel1Which CAN network (CAN 1, CAN 2…)
ID3A5Message ID (hex)
DirectionRx / TxReceived or transmitted by the tool
d 8d = data frame, 8 = length8 data bytes follow
Data5A 00 00…The bytes; the DBC turns them into signals
ExerciseOutside_Temp = byte 0 of 0x3A5, factor 0.5, offset −40. What happened at 32.12 s? And what is message 0x1F0 if it carries speed in bytes 0–1 (Intel), factor 0.01?

At 31.92 s byte 0 was 0x5C = 92 → 92 × 0.5 − 40 = 6.0 °C. At 32.12 s it changed to 0x5A = 90 → 5.0 °C. So the temperature dropped from 6.0 to 5.0 °C at 32.12 s — exactly the moment to check the snowflake.

0x1F0 bytes 0–1 in Intel order are 88 13 → read as 0x1388 = 5000 → 5000 × 0.01 = 50.00 km/h. (Intel = little-endian: the lower byte comes first.)

Try it in the CAN decoder.

ECU logs: DLT and DLT Viewer

Simple idea

A log is the software's diary: it writes lines like "button pressed", "USB mounted", "error: file not found". Linux-based car ECUs use the DLT format (Diagnostic Log and Trace, an AUTOSAR/COVESA standard). The program to read it is DLT Viewer.

Index  Time                     ECU   App   Ctx   Level  Payload
10231  2026/09/30 10:15:32.124  CLU1  HMI   TEMP  info   OutsideTemp=5.0 IceWarning active=1
10232  2026/09/30 10:15:32.130  CLU1  HMI   GFX   debug  Icon snowflake visible
10240  2026/09/30 10:15:40.010  HU01  MED   USB   error  Mount failed: /dev/sda1 not found
10241  2026/09/30 10:15:40.012  HU01  MED   PLY   warn   No playable source, switching to radio
FieldMeaning
TimeWhen it happened (compare with the trace and the video)
ECU IDWhich ECU wrote it (CLU1 = cluster, HU01 = head unit)
App IDWhich application (HMI, MED = media)
Context IDWhich part of the application (TEMP, USB, GFX)
LevelHow serious: fatal > error > warn > info > debug > verbose
PayloadThe message text

How you use DLT Viewer: connect to the ECU (usually over Ethernet, default TCP port 3490) or open a saved .dlt file; add filters (only App ID "HMI", only level error and above); search text; set markers at important moments; export the relevant part and attach it to the ticket.

ExerciseRead the log above. What two stories does it tell?

1) At 10:15:32.124 the cluster received 5.0 °C and decided "IceWarning active=1", then drew the snowflake 6 ms later. The input was correct, the decision was wrong → bug in the cluster HMI logic (< vs ≤).

2) At 10:15:40 the head unit failed to mount the USB stick and switched to radio. Next step: is the USB stick/hub OK (environment) or does it happen with other sticks too (product bug)?

Android head units: ADB and logcat

Many new head units run Android Automotive OS. There you use ADB (Android Debug Bridge), a command-line tool, and logcat, the Android log.

CommandWhat it does
adb devicesList connected devices (is the head unit visible?)
adb logcat -cClear the old log before a test
adb logcat -v time > log.txtSave the log with timestamps to a file
adb logcat *:EShow only errors (and worse)
adb logcat -s MediaPlayerShow only one tag
adb shell screencap -p /sdcard/s.png + adb pull /sdcard/s.pngTake a screenshot and copy it to the PC
adb shell screenrecord /sdcard/v.mp4Record a video of the screen
adb bugreport bug.zipCollect a full debug package (logs, system state)
adb shell getprop ro.build.fingerprintRead the exact software build
adb rebootRestart the device

Logcat levels: Verbose, Debug, Info, Warning, Error, Fatal. Important keywords: FATAL EXCEPTION (an app crashed), ANR (Application Not Responding = frozen), tombstone (native crash).

Log analysis: the method

  1. Find the exact failure timeFrom the video, the Robot log timestamp, or your notes.
  2. Align the clocksPC time, ECU time and video time may differ by seconds. Find one known event in all of them (e.g. ignition on) to align.
  3. Open trace and logs around that time±30 seconds is a good window.
  4. Check the inputIn the CAN trace: did the expected signal really arrive with the right value?
  5. Check the reactionIn the ECU log: was the input received? What was decided? Any error, exception, crash, restart, timeout?
  6. Compare with a passing runWhat is different?
  7. Write down the story and attach evidencePut the key lines and timestamps in the ticket; attach the trimmed files and keep the originals.

Search keywords: error, fail, exception, fatal, crash, abort, timeout, reset, restart, watchdog, not found, invalid, SNA, overflow.

Say this: "How do you perform log analysis?"

"I start from the exact failure time from the video or test log and align the clocks. Then I look at the CAN trace around that moment to check whether the input signal was correct, and at the ECU log — DLT or logcat — to see how the software reacted: errors, exceptions, restarts or timeouts. I compare with a passing run, and in the ticket I describe what I found with the timestamps and attach the trimmed logs and trace."

Diagnostics and flashing tools

  • Read and clear DTCs before and after tests (see chapter 2).
  • Read the software version to confirm the right build is on the bench.
  • Flashing (installing a build): with a flashing tool (e.g. Vector vFlash), the OEM's tool, a USB update, or a customer script. After flashing: check the version and do a smoke test.

Test management & traceability tools

ToolUsed forKey idea
Jira + Xray / ZephyrTests, executions, bugs in one placeTest Execution per build; failed test → linked bug
PolarionRequirements, tests, results, traceabilityWork items linked together; very common in automotive
IBM DOORSRequirements managementEach requirement has an ID and links to tests
CodebeamerRequirements + tests + ALMSimilar to Polarion
TestRail / ALMTest case managementTest runs and results per version
ConfluenceTeam documentationBench guides, process pages, meeting notes
Say this: "How do you maintain traceability?"

"Every test case carries the ID of the requirement it covers, and in the tool they're linked. Test executions are linked to the test cases, and failed executions to the defect tickets. That way a coverage report shows untested requirements, and when a requirement changes, the tool flags the linked tests for update."

Evidence: good habits

  • Name files clearly: IVI-1433_TC-TEMP-003_24.3.1_B03_video.mp4.
  • Keep trace and video running while testing so you never miss a rare bug.
  • Screenshot the problem with the software version visible if possible.
  • Store originals; attach trimmed parts to tickets.

Remote benches

  • Access through VPN + remote desktop to the bench PC.
  • A webcam points at the screens; a video grabber captures the display output.
  • A remote power switch / relay box lets you power-cycle and switch ignition.
  • Etiquette: book bench time, don't change configuration without telling others, leave the bench in a clean state, report hardware problems to the local team.

Bench health checklist (before every run)

  • ☐ Correct build flashed and version checked
  • ☐ Power supply voltage correct (e.g. 13.5 V), relay box working
  • ☐ CANoe configuration and DBC version match the build
  • ☐ Phones charged, paired as needed; USB sticks with test data plugged in
  • ☐ Logging on: trace, DLT/logcat, video
  • ☐ DTCs cleared
  • ☐ Smoke test passed