Barcode Scanner Emulator
Så testar du inmatning från QR-läsare i webbprogram
Många externa läsare som klarar QR använder keyboard wedge och skriver den avkodade QR-texten i det fokuserade fältet. Testa den vägen genom att läsa av en känd nyttolast och jämföra den med värdet sidan tog emot. Inte varje QR-läsare skriver som ett tangentbord. Seriella enheter och kameraavkodare är andra integrationer, och tangentbordshändelser i webbläsaren identifierar inte den fysiska läsaren.
En QR-kod lagrar data. Läsaren, eller en kameraavkodare, gör om de data till text. Webbprogrammet måste sedan ta emot texten, avgöra när avläsningen är klar och validera den. Den här guiden är det programtestet. Att ta fram etiketter, kontrollera kontrast och bekräfta att en enhet kan avkoda QR Code tas upp i QR-test: så testar du QR-läsare. Allmänna streckkodsformulär, inklusive kontrollsiffror för EAN, tas upp i Så testar du streckkodsläsare i webbprogram.
Testa QR-inmatning på 60 sekunder
Använd en nyttolast du själv valt, så att ett fel tecken syns. Den här genomgången använder QR-INPUT-TEST-12345.
- Öppna QR-kodgeneratorn och generera en QR-kod för
QR-INPUT-TEST-12345. Generatorn körs i webbläsaren. Den kontaktar inte läsaren. - Anslut en läsare som klarar QR och är inställd på keyboard wedge. En läsare som bara klarar 1D kan inte avkoda den här symbolen.
- Öppna streckkodsinmatningstestaren.
- Klicka på Starta test, eller klicka i avläsningsytan, så att fältet har fokus. Testaren tar inte fokus av sig själv, och den öppnar inte läsaren.
- Läs av QR-koden.
- Läs den infångade texten och antalet tecken.
- Jämför texten med
QR-INPUT-TEST-12345. Överensstämmelsen omfattar skiftläge, bindestreck och längd. - Läs suffixet. Testaren rapporterar ENTER, TAB eller Ingen när läsaren skickar någon av de tangenterna.
Testaren registrerar tangentbordshändelser som webbläsaren kan se. Den identifierar inte USB-enheten, läser inte en serieport och avkodar inte QR-bilden.
Inmatningslägen för QR-läsare
Samma utskrivna QR-kod kan komma in genom tre olika integrationer. Ett test av ett läge övar inte de andra.
QR-läsare med keyboard wedge
I läget USB HID-tangentbord, eller Bluetooth HID-tangentbord, behandlar operativsystemet läsaren som ett tangentbord. Efter en avkodning skriver läsaren nyttolasten i den kontroll som har fokus. En vanlig <input> eller <textarea> kan ta emot den. Sidan öppnar inte enheten. Guiden HID keyboard wedge beskriver tangentföljden, prefix och suffix.
Fokus avgör destinationen. Om det fokuserade elementet är dokumentets body, en knapp eller en annan ram ser lyssnarna på det här fältet inte avläsningen.
Seriella QR-läsare
En USB-seriell läsare eller en läsare med virtuell COM-port skickar den avkodade texten som byte till den process som öppnade porten. Fokus väljer inte den processen. Ett fält som bara lyssnar efter tangenttryckningar förblir tomt medan en terminal på den porten visar nyttolasten.
Chromium-baserade webbläsare kan öppna en port som användaren valt med Web Serial API, i en säker kontext, efter en användargest. Firefox och Safari har inte det API:et. En killäsare syns inte som en serieport. Portnamn, baud och inramning beror på enheten och drivrutinen. USB HID jämfört med seriella streckkodsläsare jämför de två gränssnitten. Streckkodsinmatningstestaren kan inte läsa en COM-port.
Kamerabaserad QR-avläsning
En kameraintegration tar en bild och avkodar QR-koden i programvara. Sidan använder ett kamera-API och en avkodare. Den tar inte emot keydown-händelser för nyttolasten. Appar för telefonkamera, kameraknappar i sidan och en hårdvarubildläsare som skriver i ett fält är tre olika produkter. Ett godkänt kiltest betyder inte att kameraknappen fungerar, och en lyckad kameraavkodning betyder inte att en killäsare skriver samma sträng.
Fånga inmatning från QR-läsare med JavaScript
Sidan nedan läser ett fokuserat fält. Enter skickar formuläret, och knappen Accept använder samma submit-hanterare, så en avläsning behandlas en gång. Utan ett ENTER-suffix stannar texten i fältet tills någon aktiverar Accept. Den infångade nyttolasten skrivs med textContent, så tecken som < syns som text.
Exemplet godkänner tre programformat: ett biljett-id som QR-INPUT-TEST-12345, en URL med http eller https, eller ett JSON-objekt. Det registrerar den avlästa texten. Det navigerar inte till en URL som finns i QR-koden. En läsare som inte skickar Enter fungerar ändå via knappen. Tab går genom etiketten, fältet och knappen som vanligt, eftersom skriptet inte fångar den.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>QR input example</title>
</head>
<body>
<form id="qr-form">
<label for="qr">QR payload</label>
<input id="qr" name="qr" type="text" autocomplete="off" spellcheck="false">
<button type="submit">Accept</button>
</form>
<p id="status" role="status"></p>
<pre id="captured"></pre>
<script>
const form = document.querySelector('#qr-form')
const field = document.querySelector('#qr')
const status = document.querySelector('#status')
const captured = document.querySelector('#captured')
if (
!(form instanceof HTMLFormElement) ||
!(field instanceof HTMLInputElement) ||
!(status instanceof HTMLElement) ||
!(captured instanceof HTMLElement)
) {
throw new Error('QR form markup is missing.')
}
const accepted = new Set()
function classify(raw) {
if (/[\u0000-\u001F\u007F]/.test(raw)) {
return { status: 'invalid', message: 'Control character in the QR payload.' }
}
const value = raw.trim()
if (!value) {
return { status: 'empty' }
}
if (value.length > 2048) {
return { status: 'invalid', message: 'QR payload is longer than this form accepts.' }
}
if (/^QR-[A-Z0-9-]{1,64}$/.test(value)) {
return { status: 'ok', value }
}
if (value.startsWith('{')) {
try {
const data = JSON.parse(value)
if (!data || typeof data !== 'object' || Array.isArray(data)) {
return { status: 'invalid', message: 'QR JSON must be an object.' }
}
return { status: 'ok', value }
} catch {
return { status: 'invalid', message: 'QR text is not valid JSON.' }
}
}
if (value.startsWith('http://') || value.startsWith('https://')) {
try {
const url = new URL(value)
if (url.protocol !== 'http:' && url.protocol !== 'https:') {
return { status: 'invalid', message: 'Only http and https URLs are accepted.' }
}
return { status: 'ok', value }
} catch {
return { status: 'invalid', message: 'The QR text is not a valid URL.' }
}
}
return { status: 'invalid', message: 'Unexpected QR payload.' }
}
form.addEventListener('submit', (event) => {
event.preventDefault()
const outcome = classify(field.value)
if (outcome.status === 'empty') {
status.textContent = 'No QR payload received.'
field.focus()
return
}
if (outcome.status === 'invalid') {
status.textContent = outcome.message
captured.textContent = ''
field.focus()
return
}
if (accepted.has(outcome.value)) {
status.textContent = 'Already accepted ' + outcome.value
field.value = ''
field.focus()
return
}
accepted.add(outcome.value)
captured.textContent = outcome.value
status.textContent = 'Accepted ' + outcome.value
field.value = ''
field.focus()
})
</script>
</body>
</html>
Spara filen och öppna den i en skrivbordswebbläsare. Klicka i fältet innan du läser av. autocomplete="off" minskar risken att ett sparat värde ersätter avläsningen. Etiketten och knappen finns kvar, så en person kan skriva en nyttolast utan läsare.
Hantera Enter bara i formulärets submit-händelse. En andra keydown-lyssnare för Enter registrerar samma avläsning två gånger. preventDefault() håller webbläsaren kvar på sidan. Töm fältet efter ett beslut så att nästa avläsning inte läggs till efter den föregående texten.
En QR-nyttolast kan innehålla en radbrytning. En killäsare skriver ofta den brytningen som Enter. I en enradig inmatning kan formuläret skickas vid första raden och tappa resten. Använd en textarea, eller en seriell läsare som behåller byten, när programmet måste ta emot flerradig text. Bekräfta beteendet med en QR-kod vars nyttolast innehåller en nyrad.
Hantera QR-nyttolaster
En QR-symbol lovar inte ett programformat. Samma symbologi kan bära något av detta:
- Vanlig text, till exempel
QR-INPUT-TEST-12345. - En URL.
- En identifierare som programmet valt.
- En strukturerad nyttolast, till exempel ett biljettnummer plus en platskod.
- JSON-text, när programmet har definierat den kodningen.
Läsaren skickar de avkodade tecknen. Den kontrollerar inte att de matchar en biljettregel, en produktkatalog eller ett JSON-schema. Validera strängen på sidan, och validera den igen på servern. Det postade värdet är vanlig användarinmatning. Webbläsaren kan inte bevisa att en läsare skapade det.
Validera QR-inmatning
Utgå inte från att en QR-nyttolast är numerisk. Regler för EAN-13 gäller inte. Behandla texten som opålitlig: visa den som text, och tilldela den inte till location, innerHTML eller en skript-URL.
Tomma värden. Ett ensamt Enter, eller Accept på ett tomt fält, ska inte skapa en post. trim() avvisar också en nyttolast som bara består av mellanslag.
Oväntade tecken. Jämför den mottagna strängen med det kända QR-innehållet. En felaktig tangentbordslayout ändrar ofta interpunktion medan längden är densamma. Avvisa tecken som formatet inte tillåter, och visa orsaken i statustexten.
Nyttolastens längd. Tillämpa det maximum ditt program lagrar. maxlength på inmatningen kortar av en längre avläsning utan fel. Sätt det bara när varje godkänd nyttolast får plats, och jämför testarens teckenantal med fältet när ett värde ser kort ut.
Obligatoriska prefix. En prefixkontroll hör till programmet. Den här biljettregeln godkänner QR- plus versaler, siffror och bindestreck:
function isTicketId(value) {
return /^QR-[A-Z0-9-]{1,64}$/.test(value)
}
Ta bort ett läsarprefix bara när den läsaren är inställd att skicka ett exakt prefix och programmet inte lagrar det. En AIM-symbologiidentifierare är data tills du bestämmer något annat.
Programspecifika format. Håll regeln intill formatet. Ett biljettformulär, en lista över tillåtna URL:er och ett JSON-objekt behöver olika kontroller. Ett enda numeriskt mönster avvisar giltig QR-text.
Dubbla avläsningar. En fysisk avläsning kan träffa två lyssnare. Använd en enda avslutningsväg, som exemplet gör. Ett andra tryck på avtryckaren är en separat händelse. Exemplet avvisar en nyttolast det redan har godkänt. Ett lagerformulär kan i stället öka ett antal. Testa den regel ditt program dokumenterar.
Felaktig JSON. JSON.parse kastar vid ofullständig text. Kontrollera formen efter en lyckad tolkning. En array eller ett ensamt tal kan vara giltig JSON och ändå ha fel typ:
function readJsonObject(value) {
try {
const data = JSON.parse(value)
if (!data || typeof data !== 'object' || Array.isArray(data)) {
return { ok: false, message: 'QR JSON must be an object.' }
}
return { ok: true, data }
} catch {
return { ok: false, message: 'QR text is not valid JSON.' }
}
}
Oväntade URL:er. Tolka URL:en för att se om den går att använda, och behåll sedan den avlästa strängen om testet måste matcha QR-nyttolasten exakt. URL.href kan lägga till ett snedstreck eller ändra kodningen. Godkänn bara de scheman programmet avser. Öppna inte URL:en som en bieffekt av avläsningen:
function readWebUrl(value) {
let url
try {
url = new URL(value)
} catch {
return { ok: false, message: 'The QR text is not a valid URL.' }
}
if (url.protocol !== 'http:' && url.protocol !== 'https:') {
return { ok: false, message: 'Only http and https URLs are accepted.' }
}
return { ok: true, value }
}
Kontrolltecken. Avvisa ASCII-kontrolltecken i en tangentbordsnyttolast så att ett dolt prefix förblir synligt i statustexten. CR och LF är kontrolltecken. På en killäsare är Enter och Tab tangenter. De är inte tecken inuti en vanlig textinmatning. En seriell nyttolast kan ändå innehålla byten 0x0D eller 0x0A. Ta bort dem vid den seriella inramningsgränsen, och ta inte bort ett CR som hör hemma mitt i en flerradig nyttolast.
Suffixen ENTER och TAB
Ett suffix är valfri läsarkonfiguration. Det ingår inte i QR-symbolen. Suffixen ENTER och TAB i streckkodsläsare visar hur tangenterna skiljs åt. Läs suffixet i inmatningstestaren, och låt sedan sidan matcha de läsare du driftsätter.
ENTER skickar formuläret för ett enradigt textfält i aktuella webbläsare. Använd det när en avläsning ska bekräfta värdet. Anropa preventDefault() på submit när sidan ska stanna kvar.
TAB flyttar fokus till nästa kontroll. Läs värdet i keydown medan fältet fortfarande har fokus. Låt standardåtgärden vara kvar när nästa fält ska få fokus. Ignorera Shift+Tab så att en tangentbordsanvändare kan gå bakåt.
Inget suffix lämnar nyttolasten i fältet. Knappen Accept i exemplet är avslutningsvägen. En inaktivitetstimer kan gissa att en paus betyder att avläsningen är slut. Den timern är en heuristik: en långsam Bluetooth-skur och en person som skriver snabbt kan båda passera samma lucka. Föredra ett konfigurerat suffix när flödet behöver ett fast slut.
CR och LF är byte. Ett tangentbords-Enter är event.key === "Enter". De är inte utbytbara. En lyssnare som bara tar bort \r från ett inmatningsvärde ser inte ett kil-Enter, eftersom tecknet aldrig infogades. En lyssnare som bara bevakar event.key delar inte en seriell buffert på 0x0D. Vissa enheter skickar NumPad Enter. event.key är fortfarande "Enter". Kontrollera event.key, inte bara event.code === "Enter".
Suffixet kan ändras när någon läser av en konfigurationsstreckkod ur enhetens handbok. Testa Enter, Tab och inget suffix igen efter varje konfigurationsändring. Hitta inte på en programmeringsstreckkod. Använd handboken för den modellen.
Felsök tangentbordshändelser
När den lagrade texten är fel, granska händelserna i den här ordningen.
keydown. Utlöses för varje tangent, inklusive Enter och Tab, innan webbläsaren infogar ett tecken eller flyttar fokus. Läs avslutaren här.
input. Utlöses efter att ett utskrivbart tecken ändrar fältet. Det utlöses inte för Enter eller Tab på en textinmatning.
event.key. Tecknet eller tangentnamnet efter att operativsystemet tillämpat tangentbordslayouten.
event.code. Den fysiska tangenten, till exempel Digit1 eller Numpad1. Den kan vara oförändrad när en felaktig layout ändrar event.key.
Fokus. Logga document.activeElement före avläsningen. Om det inte är QR-fältet beskriver resten av spåret fel kontroll. En iframe har eget fokus.
Ordning. För en kilavläsning i ett textfält följs utskrivbara keydown-händelser av input-uppdateringar, och sedan en sista keydown för Enter eller Tab när det suffixet är inställt. change utlöses när fältet bekräftar, vanligen vid blur. En avläsning som lämnar fokus i samma fält ger inte change på slutet. Använd inte change som den enda avslutningssignalen.
Timing. Läsare avslutar ofta en kort nyttolast på väl under en sekund. Inmatningstestaren jämför det genomsnittliga mellanrummet mellan tecken med en tröskel på 100 ms och märker resultatet som timing, inte som hårdvaruidentifiering. En person som skriver snabbt, autofyll eller emulatorn kan hamna på läsarsidan av den tröskeln. En fördröjd Bluetooth-avläsning kan se ut som tangenttryckningar. Kontrollera nyttolasten och suffixet. Behandla timing som en ledtråd.
Loggen i tangentbordshändelsetestaren listar varje keydown och keyup med key, code, modifierare och tidsstämplar. Loggen är webbläsarhändelser. Den är inte rå USB-trafik.
Testa utan en fysisk QR-läsare
Programlogik kan testas innan en läsare står på skrivbordet.
- Skriv
QR-INPUT-TEST-12345i fältet och aktivera Accept. Det kontrollerar validering och visning. Det kontrollerar inte avkodning eller suffix. - Driv samma fält från ett automatiseringsverktyg i webbläsaren, som nästa avsnitt gör.
- Använd Barcode Scanner Emulator när du behöver skrivning i läsarstil. Skrivbordsprogrammet skickar ett värde du anger, med en skrivfördröjning och ett suffix på inget, ENTER eller TAB, till programmet som har fokus. Det återskapar tangentbordsvägen. Det fotograferar inte en QR-bild, avkodar inte en symbol och skapar inte en virtuell COM-port.
Hårdvara krävs fortfarande för optiskt beteende och enhetsbeteende: om den läsaren kan läsa den visade eller utskrivna koden, om QR-symbologin är påslagen, tangentbordslayout, suffixkonfiguration och seriella lägen eller tillverkar-SDK. Emulatorn är rätt kontroll för tangentbordsvägen. Den är fel kontroll för att bevisa att en enhet läser en viss QR-kod.
Automatisera tester av QR-inmatning
Följande Playwright-tester driver exempelsidan. De skriver i fältet som en killäsare skulle göra, och kontrollerar sedan programbeteendet. De öppnar inte USB-enheter. @playwright/test är ett beroende för den som kör testet. Den här webbplatsen kräver det inte.
Spara HTML-exemplet som qr-form.html bredvid det här testet.
import { readFileSync } from 'node:fs'
import { expect, test } from '@playwright/test'
const html = readFileSync(new URL('./qr-form.html', import.meta.url), 'utf8')
async function openForm(page) {
await page.setContent(html)
}
test('accepts a known QR payload once', async ({ page }) => {
await openForm(page)
const field = page.getByLabel('QR payload')
await field.pressSequentially('QR-INPUT-TEST-12345')
await field.press('Enter')
await expect(page.getByRole('status')).toHaveText('Accepted QR-INPUT-TEST-12345')
await expect(page.locator('#captured')).toHaveText('QR-INPUT-TEST-12345')
})
test('rejects an unexpected payload', async ({ page }) => {
await openForm(page)
const field = page.getByLabel('QR payload')
await field.pressSequentially('not-a-ticket')
await field.press('Enter')
await expect(page.getByRole('status')).toHaveText('Unexpected QR payload.')
await expect(page.locator('#captured')).toBeEmpty()
})
test('commits on ENTER and rejects a duplicate scan', async ({ page }) => {
await openForm(page)
const field = page.getByLabel('QR payload')
await field.pressSequentially('QR-INPUT-TEST-12345')
await field.press('Enter')
await field.pressSequentially('QR-INPUT-TEST-12345')
await field.press('Enter')
await expect(page.getByRole('status')).toHaveText('Already accepted QR-INPUT-TEST-12345')
await expect(page.locator('#captured')).toHaveText('QR-INPUT-TEST-12345')
})
test('does not capture keys while the field is unfocused', async ({ page }) => {
await openForm(page)
await page.getByRole('button', { name: 'Accept' }).focus()
await page.keyboard.type('QR-INPUT-TEST-12345')
await expect(page.getByLabel('QR payload')).toHaveValue('')
await expect(page.locator('#captured')).toBeEmpty()
await expect(page.getByRole('status')).toHaveText('')
})
test('shows unexpected characters as text', async ({ page }) => {
await openForm(page)
const payload = '<img src=x onerror=alert(1)>'
const field = page.getByLabel('QR payload')
await field.fill(payload)
await page.getByRole('button', { name: 'Accept' }).click()
await expect(page.getByRole('status')).toHaveText('Unexpected QR payload.')
await expect(page.locator('#captured img')).toHaveCount(0)
await expect(page.locator('img')).toHaveCount(0)
})
pressSequentially infogar tecken i det fokuserade fältet. Det är inte en USB-gadget. Testet av oväntade tecken använder fill eftersom målet är valideringsmeddelandet och att inget injicerat element finns. Utöka filen med ett URL-fall och ett JSON-fall när de formaten ingår i bygget du släpper. En URL-kontroll ska jämföra den infångade texten med den ursprungliga QR-strängen.
Testmatris för QR-läsare
Kör dessa mot programmet som testas. Exempelsidan ovan täcker raderna för biljett, URL, JSON, dubblett, tomt värde och oväntade tecken. Ett program som bara tar siffror eller flera rader behöver ett eget väntat resultat.
| Scenario | Väntat resultat |
|---|---|
| QR med vanlig text | Exakt värde mottaget |
| QR med URL | Hela URL:en infångas, och sidan navigerar inte till den |
| Numerisk QR | Siffrorna bevaras |
| Specialtecken | Rätt tecken mottagna |
| JSON-nyttolast | Data infångas och valideras |
| Suffixet ENTER | Behandlingen sker en gång |
| Suffixet TAB | Fokusbeteendet hanteras |
| Inget suffix | Programmet använder en annan avslutningsmekanism |
| Dubbel avläsning | Programmet tillämpar sina dubblettregler |
| Ogiltig nyttolast | Valideringsfel visas |
| Saknat fokus | Programmet hanterar utebliven inmatning säkert |
| Lång nyttolast | Ingen oavsiktlig avkortning |
Läs också av en nyttolast som innehåller en nyrad om produkten måste lagra en. Anteckna om fältet tog emot varje rad.
Felsökning
Börja med en känd nyttolast i inmatningstestaren. Om testarens värde redan är fel är sidan inte det första felet. Om testarens värde är rätt och programmet är fel ligger felet i fokus, validering eller händelsehantering. Streckkodsläsaren fungerar inte är den bredare kontrollistan för enheten. Så testar du inmatning från streckkodsläsare tar upp fokus, layout och POS-flöden bortom det här formuläret.
Läsaren piper men ingen inmatning syns
Ett pip betyder vanligen att läsaren avkodade en symbol. Det betyder inte att sidan tog emot texten. Bekräfta keyboard wedge. Seriella lägen och kameralägen skriver inte i fältet. Klicka i fältet så att document.activeElement är den inmatningen, och läs sedan av igen. Ett inaktiverat, skrivskyddat eller dolt fält kan ignorera tangenterna.
QR-läsaren fungerar i Notepad men inte i webbläsaren
Enheten skriver. Sidan tar inte emot de tangenterna. Kontrollera fokus, en keydown-lyssnare som anropar preventDefault() på utskrivbara tangenter, och en lyssnare som bara hanterar paste. Kilinmatning utlöser inte en paste-händelse. Jämför testarens resultat med programfältet.
Läsaren läser streckkoder men inte QR-koder
Enheten kan vara enbart 1D, eller så kan QR-symbologin vara avstängd. Sidan kan inte rätta det. Bekräfta 2D-stöd och slå på QR Code från enhetens handbok, med kontrollerna i QR-test: så testar du QR-läsare. En lyckad avläsning av Code 128 bevisar bara tangentbordsvägen.
Felaktiga tecken
Läs av QR-INPUT-TEST-12345 först. Om den stämmer och en URL eller JSON-nyttolast inte gör det ändrar layouten interpunktion som :, /, { eller ". Jämför event.key med event.code i tangentbordshändelsetestaren, och se Fel tangentbordslayout på streckkodsläsaren. Matcha läsarens tangentbordslayout med operativsystemet.
ENTER skickar formuläret två gånger
Webbläsaren skickar formuläret, och en keydown-lyssnare hanterar också Enter. Behåll en avslutningsväg och anropa preventDefault() där. En andra fysisk avläsning är ett annat fel. Statustexten i exemplet säger att nyttolasten redan var godkänd. Om den första avläsningen själv skapar två poster, leta efter två lyssnare innan du ändrar läsaren.
QR-inmatningen är avkortad
Jämför antalet tecken i inmatningstestaren med värdet i fältet. Ett maxlength-attribut, en inmatningsmask eller preventDefault() på teckentangenter kan kapa strängen. En nyrad inuti QR-nyttolasten kan skicka en enradig inmatning för tidigt. Vissa läsare begränsar också hur många tecken de skriver. Höj den gränsen från enhetens handbok när testaren, inte bara programmet, visar ett kort värde. Streckkodsläsaren saknar ENTER tar upp det besläktade fallet där nyttolasten kommer fram och formuläret aldrig bekräftar.
Läsaren kan inte läsa en QR-kod på skärmen
Bekräfta att läsaren är en 2D-bildläsare. Höj skärmens ljusstyrka, öka kodens storlek och håll den tysta zonen fri från text och ramar. Bländning, en mörk telefonskärm och en kod som är för tät för arbetsavståndet är optiska problem. Skriv ut samma nyttolast om skärmavläsningen fortsätter att misslyckas. Programtestet använder fortfarande den kända strängen när en avläsning väl ger text.