Hoppa till innehållet

Barcode Scanner Emulator

Så testar du streckkodsläsare i webbprogram

Många streckkodsläsare med USB och Bluetooth skickar avkodade data som tangentbordsinmatning, så ett fokuserat fält i ett webbprogram kan ta emot en avläsning utan ett webbläsar-API särskilt för läsare. Serieportar och tillverkar-SDK:er är separata integrationer. Du kan testa tangentbordsvägen med en fysisk läsare eller med simulerade tangenttryckningar.

Ett webbprogram ser vanligen en streckkodsläsare som ett tangentbord. Testet är om den fokuserade kontrollen tar emot den nyttolast ditt program väntar sig, och om sidan hanterar den avslutare som läsaren är inställd att skicka. Avslutaren kan vara Enter, Tab eller ingen alls.

Använd en session i streckkodsinmatningstestaren när en fysisk läsare är ansluten. Använd Barcode Scanner Emulator när du behöver samma tangentbordsväg under utvecklingen och hårdvaran inte står på skrivbordet. En bredare genomgång av fokus, layout och POS-flöden finns i Så testar du inmatning från streckkodsläsare. Den här guiden stannar vid webbläsarprogrammet: infångning, suffix, validering och de händelser du faktiskt kan se.

Hur streckkodsläsare kommunicerar med webbprogram

Gränssnittsläget avgör vad sidan kan ta emot. Bekräfta det innan du ändrar formulärkod. En läsare kan ofta byta läge genom att läsa av en konfigurationsstreckkod ur tillverkarens handbok.

USB HID keyboard wedge

I läget USB HID-tangentbord räknas läsaren upp som ett tangentbord. Operativsystemet läser in sin vanliga tangentbordsdrivrutin. När läsaren har avkodat en symbol skickar den tecknen som tangenttryckningar till den kontroll som har tangentbordsfokus. Sidan lyssnar efter de tryckningarna, eller läser texten de infogar. Den öppnar ingen anslutning till enheten.

Den vägen är skälet till att ett kassafält, en sökruta eller vilken annan textinmatning som helst kan ta emot en avläsning med vanlig HTML. Guiden HID keyboard wedge går igenom tangentföljden, prefix och suffix mer ingående.

Bluetooth HID

En Bluetooth-läsare som är parkopplad som tangentbord använder samma programväg. Värden behandlar den som ett HID-tangentbord, och det fokuserade fältet tar emot tangenttryckningar. Parkoppling, batteri och radio hör till enheten. När tecknen väl når webbläsaren hanterar sidan dem på samma sätt som USB-kilinmatning.

Serieport och virtuell COM-port

En seriell läsare, även många virtuella COM-portlägen över USB, skickar den avkodade texten som byte på en port. Fokus väljer inte mottagaren. Det gör den process som öppnar porten. Ett textfält som bara lyssnar efter tangenttryckningar ser inte den strömmen.

Chromium-baserade webbläsare kan öppna en serieport via Web Serial API efter att användaren valt porten och gett tillstånd. Firefox och Safari har inte det API:et. Ett kiltest övar inte en serieintegration, och ett serietest säger inte vad en killäsare kommer att skriva.

Tillverkarspecifika gränssnitt

Vissa enheter använder ett tillverkar-SDK, OPOS, JPOS eller ett HID-gränssnitt som inte är ett tangentbord, till exempel USB HID POS. De gränssnitten skriver inte i det fokuserade fältet. En vanlig webbsida kan inte läsa in ett inbyggt SDK. Chromium kan begära vissa HID-enheter som inte är tangentbord via WebHID efter en användargest. HID-enheter i tangentbordsklassen förblir spärrade, så en killäsare går inte att skilja från ett tangentbord. Behandla ett tillverkargränssnitt som en egen integration och testa det med programmet som faktiskt öppnar gränssnittet.

Vad webbläsaren kan se

En kilavläsning kommer som händelserna keydown och keyup, och utskrivbara tecken uppdaterar det fokuserade fältet. Webbläsaren får inget enhetsnamn, inget USB-serienummer och ingen flagga som säger att källan är en läsare. Webbläsare som implementerar WebHID vägrar fortfarande tangentbordsgränssnitt, så sidskript kan inte heller läsa de råa HID-rapporterna från en killäsare.

event.key är tecknet eller tangentnamnet efter att operativsystemet tillämpat den aktiva tangentbordslayouten. event.code namnger den fysiska tangenten, till exempel Digit1 eller Numpad1, och kan vara oförändrad när en layoutmiss stämmer om event.key. Ingen av egenskaperna identifierar hårdvaran.

Så testar du en fysisk streckkodsläsare i en webbläsare

Kör det här innan du felsöker programkod. Det visar den exakta strängen och avslutaren som webbläsaren tog emot.

  1. Anslut läsaren och vänta tills den visar att den har ström. För Bluetooth, slutför parkopplingen och bekräfta att värden använder en tangentbordsprofil.
  2. Bekräfta inmatningsläget. Keyboard wedge, USB HID-tangentbord eller Bluetooth HID-tangentbord kan skriva i ett fält. Seriellt läge, SPP och tillverkar-SDK gör det inte.
  3. Öppna streckkodsinmatningstestaren.
  4. Klicka på Starta test, eller klicka i avläsningsytan. Den blir blå när den är redo. Sidan tar inte fokus av sig själv.
  5. Läs av en streckkod vars nyttolast du redan känner. Börja med ett kort numeriskt värde, och läs sedan av ett värde som innehåller den interpunktion ditt program lagrar.
  6. Läs det infångade värdet och antalet tecken. Jämför båda med den nyttolast du väntar dig, inklusive ett prefix som läsaren skjuter in före data.
  7. Kontrollera suffixet. Testaren rapporterar ENTER, TAB eller Ingen. Med Automatisk registrering på syns resultatet efter Enter, Tab eller en kort paus när tangenterna slutar. Stäng av Automatisk registrering när du vill att infångningen ska hållas kvar tills du trycker på Stoppa.
  8. Jämför resultatet med strängen ditt program ska lagra. Ett prefix, ett utbytt tecken eller en saknad avslutare ska rättas i läsarens konfiguration eller hanteras medvetet på sidan. Behandla det inte som ett avkodningsfel förrän jämförelsen är gjord.

Testaren registrerar tangentbordshändelser som webbläsaren kan se. Den kan inte identifiera USB-enheten eller läsa en serieport. När en textredigerare tar emot avläsningen och webbläsaren inte gör det, fortsätt med Läsaren fungerar i Notepad men inte i POS.

Fånga inmatning från streckkodsläsare med JavaScript

En läsare skriver i det element som har fokus. Ge fältet en synlig etikett, lämna det som en vanlig textinmatning så att tangentbordsanvändare kan skriva en kod, och läs värdet när flödet säger att inmatningen är klar. Sidan nedan gör det. Enter skickar formuläret en gång. Tab slutför ett icke-tomt värde och låter sedan webbläsaren flytta fokus. En avläsning utan avslutare stannar i fältet tills någon aktiverar Look up.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Barcode input example</title>
</head>
<body>
  <form id="barcode-form">
    <label for="barcode">Barcode</label>
    <input id="barcode" name="barcode" type="text" autocomplete="off" spellcheck="false">
    <button type="submit">Look up</button>
  </form>
  <p id="message" role="status"></p>
  <ul id="accepted"></ul>
  <script>
    const form = document.querySelector('#barcode-form')
    const field = document.querySelector('#barcode')
    const message = document.querySelector('#message')
    const list = document.querySelector('#accepted')

    if (
      !(form instanceof HTMLFormElement) ||
      !(field instanceof HTMLInputElement) ||
      !(message instanceof HTMLElement) ||
      !(list instanceof HTMLUListElement)
    ) {
      throw new Error('Barcode form markup is missing.')
    }

    function payload(raw) {
      return raw.replace(/[\r\n]/g, '').trim()
    }

    function classify(raw) {
      const value = payload(raw)
      if (!value) {
        return { status: 'empty' }
      }
      if (/[\u0000-\u001F\u007F]/.test(value)) {
        return {
          status: 'invalid',
          message: 'Control character in the barcode. Check the prefix, suffix, and symbology identifier.',
        }
      }
      return { status: 'ok', value }
    }

    function accept(value) {
      const item = document.createElement('li')
      item.textContent = value
      list.append(item)
      message.textContent = 'Accepted ' + value
      field.value = ''
    }

    function reject(text) {
      message.textContent = text
    }

    form.addEventListener('submit', (event) => {
      event.preventDefault()
      const outcome = classify(field.value)
      if (outcome.status === 'empty') {
        reject('No barcode received.')
        field.focus()
        return
      }
      if (outcome.status === 'invalid') {
        reject(outcome.message)
        field.focus()
        return
      }
      accept(outcome.value)
      field.focus()
    })

    field.addEventListener('keydown', (event) => {
      if (event.key !== 'Tab' || event.shiftKey) {
        return
      }
      const outcome = classify(field.value)
      if (outcome.status === 'empty') {
        return
      }
      if (outcome.status === 'invalid') {
        event.preventDefault()
        reject(outcome.message)
        return
      }
      accept(outcome.value)
    })

    field.focus()
  </script>
</body>
</html>

Spara filen och öppna den i en skrivbordswebbläsare. Klicka i fältet om fokus har flyttats. En killäsare, eller emulatorn i nästa avsnitt, skriver sedan i #barcode.

Fokus krävs. Om document.activeElement är dokumentets kropp, en knapp eller en annan inmatning ser fältets lyssnare inte avläsningen. Tecknen hamnar i den fokuserade kontrollen, eller så försvinner de. Anropa field.focus() när flödet är redo för en avläsning, även efter att en dialog stängts.

Tom inmatning ignoreras. Formuläret ligger kvar, och statustexten säger att inget togs emot. Enbart blanksteg är tomt efter trim().

Exemplet lägger inte till Enter eller Tab. Om läsaren inte är inställd att skicka dem ligger värdet kvar i fältet och Look up är vägen till slutförande. autocomplete="off" minskar risken att ett sparat värde ersätter avläsningen. Etiketten, knappen och Shift+Tab finns kvar, så en person kan mata in en kod utan läsare.

Hantera Enter på ett ställe. Exemplet använder formulärets submit-händelse, som också täcker knappen Look up och Enter från tangentbordet. En andra keydown-lyssnare för Enter skulle registrera samma avläsning två gånger. Om inmatningen inte ligger i ett formulär, lyssna efter Enter på keydown och anropa preventDefault() så att ett överordnat formulär inte skickas också:

field.addEventListener('keydown', (event) => {
  if (event.key !== 'Enter') {
    return
  }

  event.preventDefault()
  const value = field.value.trim()
  if (!value) {
    return
  }

  console.log(value)
  field.value = ''
})

Töm fältet efter ett lyckat godkännande så att nästa avläsning inte hängs på den föregående nyttolasten. Efter Enter fokuserar exemplet samma fält igen, eftersom det flödet väntar en ny avläsning i samma ruta. Efter Tab lämnar det fokus ifred så att webbläsaren kan gå vidare till nästa kontroll.

Hantera suffixen ENTER och TAB

Ett suffix är en tangent som läsaren kan skicka efter nyttolasten. Det är en enhetsinställning. Enter är vanligt, och det är valfritt. Guiden Suffixen ENTER och TAB i streckkodsläsare beskriver hur du skiljer avslutarna åt. Bekräfta inställningen på läsaren du testar, och låt sedan sidan följa det flödet.

ENTER

Enter i ett enradigt textfält skickar det omgivande formuläret i aktuella webbläsare. Använd det när en avläsning ska bekräfta värdet, som i en sökruta. preventDefault() på submit-händelsen hindrar webbläsaren från att navigera bort. Utelämna det när en hel sidnavigering är beteendet du vill ha.

Om streckkoden syns och formuläret inte gör något kan läsaren sakna suffix. Streckkodsläsaren saknar ENTER går igenom den konfigurationen. Vissa enheter skickar NumPad Enter. event.key är fortfarande "Enter". Kontrollera event.key, inte bara event.code === "Enter", annars ser den läsaren trasig ut.

TAB

Tab flyttar fokus till nästa fokuserbara kontroll. Det passar en följd som produktkod och sedan antal. Det överraskar ett formulär som väntade att Enter skulle skicka det.

Läs värdet i keydown medan fältet fortfarande har fokus. Webbläsaren flyttar fokus efter den händelsen. Låt standardåtgärden vara kvar när nästa kontroll ska få fokus. preventDefault() håller fokus kvar, vilket är användbart när värdet är ogiltigt och operatören ska se det. Ignorera Shift+Tab så att en tangentbordsanvändare kan gå bakåt i formuläret. Ett Tab-suffix från läsaren är Tab utan Shift.

Ett Tab-suffix kan också flytta fokus innan din kod läser fältet, om lyssnaren sitter på blur eller change och något annat tömmer kontrollen. Läs värdet från keydown-händelsens mål.

Inget suffix

Utan suffix ligger nyttolasten kvar i fältet. Programmet måste avgöra när avläsningen är klar. En uttrycklig knapp, ett senare Enter från operatören eller ett steg vidare är pålitliga slutpunkter. En inaktivitetstimer kan behandla en paus i skrivandet som slutet på en avläsning. Timern är en heuristik. En långsam läsare, en Bluetooth-fördröjning eller en person som skriver snabbt kan hamna på fel sida om tröskeln. Föredra ett konfigurerat suffix när flödet behöver en tydlig signal om avläsningens slut.

Skillnader i konfiguration

Läsare av samma märke kan levereras med olika suffix, och en konfigurationsstreckkod kan byta suffix utan någon ändring i din JavaScript. Vissa enheter skickar ett prefix, en symbologiidentifierare som ]C1, eller CR och LF. Testa de tre avslutarinställningar dina användare faktiskt kan välja: Enter, Tab och inget. Anteckna vilken de driftsatta läsarna använder, och testa sidan mot den inställningen.

Validering av inmatning från streckkodsläsare

Validera strängen som fältet tog emot. Utgå inte från att varje streckkod har samma längd, teckenuppsättning eller kontrollsiffra. Nyttolaster i Code 128 och QR varierar. EAN-13 är 13 siffror. Ett program som lagrar båda behöver regler för båda.

Tom inmatning. Avvisa eller ignorera den. Ett suffix utan nyttolast, eller ett klick på Look up i ett tomt fält, ska inte skapa en post.

Oväntade tecken. Jämför den mottagna strängen med en känd etikett. En layoutmiss syns ofta som en ändrad symbol, till exempel en förskjuten siffra eller interpunktion, medan längden är densamma. Styrtecken kan komma från ett prefix eller från en GS1-gruppavgränsare. Tillåt de tecken ditt format definierar. Exemplet ovan avvisar ASCII-styrtecken så att de syns i statustexten. En GS1-tolk som väntar en gruppavgränsare ska tillåta det tecknet och avvisa resten.

Längd. Tillämpa de längder ditt program godtar. Ett globalt minimum och maximum är säkrare än en enda obligatorisk längd när formuläret tar emot mer än en symbologi. maxlength på inmatningen kortar tyst en längre nyttolast, så sätt det bara när varje godkänd kod ryms.

Prefix. Ta bort ett prefix bara när du ställt in läsaren att skicka just det prefixet och programmet inte lagrar det.

function withoutConfiguredPrefix(value, prefix) {
  if (prefix && value.startsWith(prefix)) {
    return value.slice(prefix.length)
  }
  return value
}

En AIM-symbologiidentifierare är data om läsaren är inställd att sända den. Låt den ligga kvar tills du bestämt om programmet lagrar den.

Suffix. Håll avslutaren utanför det lagrade värdet. Enter och Tab är tangenter. De infogas inte i en vanlig textinmatning. En seriell nyttolast kan ändå innehålla CR- eller LF-byte. Ta bort dem vid gränsen där du tolkar serieströmmen, och testa att du inte tar bort dem ur mitten av en nyttolast som legitimt innehåller dem.

Dubbla inskick. En avläsning kan hanteras två gånger om både keydown och submit körs för samma Enter. Använd en enda slutförandeväg. En andra avläsning av samma kod är en annan fråga. Ett lagerformulär kan öka antalet. Ett biljettformulär kan avvisa en kod som redan lösts in. Lägg den regeln i programmet, och testa den med avsikt. Webbläsaren kan inte skilja ett andra avtryck från en andra lyssnare.

Programregler. Kontrollsiffror hör till bestämda symbologier. EAN-13 använder sista siffran som kontrollsiffra. Den här funktionen godtar bara det formatet:

function isEan13(value) {
  if (!/^\d{13}$/.test(value)) {
    return false
  }

  let sum = 0
  for (let index = 0; index < 12; index += 1) {
    const digit = Number(value[index])
    sum += index % 2 === 0 ? digit : digit * 3
  }

  const check = (10 - (sum % 10)) % 10
  return check === Number(value[12])
}

Code 128, Code 39 och QR använder inte den beräkningen. Läsaren kan redan ha kontrollerat sin egen symbologi och sänt den läsbara texten. Validera de format du lagrar, och upprepa kontrollen på servern. Den postade strängen är vanlig användarinmatning. Webbläsaren kan inte bevisa att en läsare framställde den.

Testa inmatning från streckkodsläsare utan fysisk hårdvara

Barcode Scanner Emulator är ett skrivbordsprogram för Windows, macOS och Linux. Du anger texten som ska skickas, väljer en skrivfördröjning och väljer ett suffix: inget, ENTER eller TAB. En global genväg skriver den texten i programmet som har fokus. Den återskapar tangentbordsvägen som en killäsare använder. Den belyser inte en etikett, läser inte en symbol och avkodar inte en symbologi.

Använd exempelsidan ovan, eller sidan du bygger:

  1. Öppna sidan i en skrivbordswebbläsare och klicka i streckkodsfältet.
  2. Ange ett känt värde i emulatorn, till exempel 123456789012.
  3. Sätt suffixet till ENTER. Sätt skrivfördröjningen om du vill att skuren ska likna en läsare du redan mätt.
  4. Tryck på emulatorns globala avläsningsgenväg medan webbläsarfältet fortfarande har fokus.
  5. Bekräfta statustexten och att värdet godkändes en gång.
  6. Upprepa med TAB. Fokus ska flyttas, och värdet ska godkännas en gång.
  7. Upprepa utan suffix. Texten ska ligga kvar i fältet tills du aktiverar Look up.
  8. Fokusera streckkodsinmatningstestaren och skicka samma värde igen. Jämför den infångade strängen, prefixet och suffixet med det programmet lagrade.

Installation och den första genvägen tas upp i Kom igång. Efter en inställningsändring, skicka en avläsning till inmatningstestaren innan du litar på resultatet i programmet.

Hårdvara krävs fortfarande för de optiska och enhetsspecifika delarna av testet:

  • Om just den läsaren kan avkoda den utskrivna eller visade symbolen, inklusive skadade etiketter, storlek, kontrast och avstånd.
  • Stöd för symbologi. En 1D-laserläsare kan inte läsa en QR-kod. Se QR-test: så testar du QR-läsare.
  • USB-uppräkning, Bluetooth-parkoppling och läsarens egen tangentbordslayout och suffixkonfiguration.
  • Integrationer för serie, HID POS och tillverkar-SDK.

Emulatorn är rätt verktyg för programlogik längs tangentbordsvägen. Den är fel verktyg för att bevisa att en viss läsare läser en viss etikett.

Felsök tangentbordshändelser från streckkodsläsare

Titta på händelserna i den här ordningen när det lagrade värdet är fel.

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. event.repeat är true när en tangent hålls ned. En killäsare skickar normalt ett särskilt tryck för varje tecken.

input. Utlöses på fältet efter att ett utskrivbart tecken ändrat dess värde. Det är rätt händelse att bevaka om du behöver texten medan den växer. Den utlöses inte för Enter eller Tab, eftersom de tangenterna inte infogar ett tecken i en textinmatning.

change. Utlöses efter att värdet bekräftats, vanligen när fältet förlorar fokus. En läsare som lämnar fokus i samma fält ger inte change i slutet av avläsningen. Använd inte change som den enda signalen om slutförande.

event.key och event.code. Logga båda när ett tecken är fel. En miss mellan läsarens layout och operativsystemets layout ändrar event.key och lämnar event.code likt tangenten läsaren avsåg. Siffror från det numeriska tangentbordet använder Numpad1 och liknande koder. Vissa inmatningsmasker behandlar dem annorlunda än Digit1. Fel tangentbordslayout på streckkodsläsaren förklarar layoutmissen.

Fokus. Logga document.activeElement omedelbart före en avläsning. Om det inte är streckkodsfältet förklarar resten av spåret fel kontroll. Iframes har eget fokus. En avläsning in i en inbäddad ram syns för skript inuti den ramen.

Tid. Läsare avslutar ofta en kort nyttolast på väl under en sekund. Inmatningstestaren jämför det genomsnittliga mellanrummet mellan tecken med ett tröskelvärde på 100 ms och märker resultatet som tid, inte som en hårdvaruidentifiering. Ett mellanrumströskelvärde kan behandla en snabb skrivare, autofyll eller emulatorn som en läsare. En läsare med fördröjning mellan tecken, en Bluetooth-länk eller en lång nyttolast kan se ut som skrivning. Använd det infångade värdet och suffixet. Använd tiden som en ledtråd.

Listan i tangentbordshändelsetestaren visar varje keydown och keyup med key, code, modifierare och tidsstämplar. Använd den när den sammansatta strängen döljer en prefixtangent eller en numerisk kod. Den är webbläsarhändelser, inte rå USB-trafik.

Vanliga problem i webbprogram

Avläsningen hamnar i fel fält. Kilinmatning följer fokus. Klicka i målfältet efter varje navigering, dialog eller valideringsmeddelande som flyttar fokus. En modal utan textfält kan svälja avläsningen som snabbkommandon.

Läsaren fungerar i en textredigerare men inte i webbläsaren. Enheten skriver. Sidan tar inte emot de tangenterna. Kontrollera fokus, en inaktiverad eller skrivskyddad inmatning och en keydown-lyssnare som anropar preventDefault() på utskrivbara tangenter. En lyssnare som bara hanterar paste ser aldrig kilinmatning. Börja med Streckkodsläsaren fungerar inte om inget program tar emot tecken.

Enter skickar formuläret två gånger eller navigerar bort. Webbläsaren skickar formuläret, och din lyssnare hanterar också Enter. Anropa preventDefault() på en av vägarna och behandla värdet en gång. Ett formulär med flera fält kan skickas innan senare fält är ifyllda när läsaren skickar Enter. Använd Tab för det flödet, eller hindra inskicket tills formuläret är komplett.

Tab byter fokus. Det är tangenten Tab. Ställ antingen in Enter på läsaren, eller läs värdet i keydown och tillåt fokusflytten. Se suffixavsnittet ovan.

Tangentbordslayouten är fel. Siffror kan överleva en miss som ändrar interpunktion. Läs av ett känt värde som innehåller symbolerna du lagrar, på den layout arbetsstationen faktiskt använder.

Samma avläsning skapar två poster. Leta efter två lyssnare på ett Enter innan du letar efter två fysiska avläsningar. Testa sedan en avsiktlig andra avläsning och bekräfta den antal- eller dubblettregel ditt program dokumenterar.

Värdet saknas eller är avhugget. Ett maxlength-attribut, en inmatningsmask eller preventDefault() på teckentangenter kan tappa eller kapa nyttolasten. Jämför antalet tecken i inmatningstestaren med värdet i ditt fält. Ett prefix kan också få en korrekt nyttolast att se för lång ut.

QR-koder syns aldrig. Läsaren kan vara enbart 1D, eller så kan QR-symbologin vara avstängd. Programmet kan inte rätta det. Bekräfta hårdvaran med QR-test: så testar du QR-läsare, och återgå sedan till fälttestet.

Checklista för test av webbprogram

Använd den här på bygget du tänker släppa, i varje webbläsare du stöder. Kontrollera både en ny profil och en profil med tillägg för lösenordshanterare och autofyll, eftersom de tilläggen flyttar fokus.

  • Läsaren är ansluten eller parkopplad, och värden visar att den är redo.
  • Läsaren är i keyboard wedge-läge, inte i seriellt läge eller ett tillverkar-SDK-läge.
  • Streckkodsfältet är fokuserat omedelbart före avläsningen. document.activeElement är det fältet.
  • En känd streckkod kommer fram tecken för tecken, inklusive längd.
  • Ett ENTER-suffix skickar eller godkänner värdet en gång och lämnar inte avslutaren i den lagrade strängen.
  • Ett TAB-suffix flyttar fokus till den kontroll du avser, och värdet läses före flytten.
  • En konfiguration utan suffix lämnar värdet tillgängligt tills programmet slutför det.
  • Ett tomt inskick avvisas eller ignoreras.
  • En avläsning skapar inte två poster. En andra verklig avläsning följer programmets dubblettregel.
  • Interpunktion, symboler och en GS1-avgränsare som dina format använder överlever tur och retur.
  • Läsarens tangentbordslayout och operativsystemets layout ger de tecken som är tryckta på etiketten.
  • Efter urkoppling och återinkoppling, eller efter att Bluetooth-länken faller, når nästa avläsning fortfarande fältet.
  • Flera avläsningar i rad förblir separata värden. Fältet slår inte ihop dem.
  • Samma kontroller går igenom i webbläsarna du stöder, med och utan vanliga autofylltillägg.

För dialoger, tabbordning över en hel kassa och POS-flöden för antal, fortsätt med Så testar du inmatning från streckkodsläsare.

Matris för testfall

Läsarkolumnen är vad enheten och webbläsaren gör. Kolumnen för väntat beteende är vad programmet ska göra som svar. Affärsregler, till exempel om en upprepad produktkod ökar antalet, hör till programmet. Ange dem i testet i stället för att anta en regel för varje produkt.

Scenario Väntat beteende
Giltig streckkod Programmet godkänner värdet och lagrar nyttolasten utan avslutaren.
Tom inmatning Programmet avvisar eller ignorerar den och skapar ingen post.
ENTER-suffix Programmet skickar eller godkänner värdet en gång.
TAB-suffix Fokus flyttas till den avsedda nästa kontrollen, och värdet behålls.
Inget suffix Inmatningen förblir tillgänglig tills programmet behandlar den.
Snabba avläsningar i följd Varje värde behandlas för sig och slås inte ihop med det föregående.
Fel tangentbordslayout Oväntade tecken syns i det infångade värdet och valideringen misslyckas.
Dubbel avläsning Programmet följer sin egen dubblettregel, till exempel att öka antalet eller avvisa en upprepning.
Ogiltigt streckkodsformat Programmet visar valideringsfelet för det formatet och lagrar inte värdet.
Förlorat inmatningsfokus Programmet hittar inte på en streckkod. Avläsningen saknas eller hamnar i den fokuserade kontrollen, och sidan stannar i ett säkert läge.

Kör raderna för giltig, tom, ENTER, TAB och inget suffix med den fysiska läsaren och igen med emulatorn. Kör raderna för tangentbordslayout, QR och återinkoppling på hårdvaran. De raderna beror på enheten, etiketten eller operativsystemets layout, vilket simulerade tangenttryckningar inte återskapar.