Vai al contenuto

Barcode Scanner Emulator

Come testare i lettori di codici a barre nelle applicazioni web

Molti lettori di codici a barre USB e Bluetooth inviano i dati decodificati come input da tastiera, così un campo con il focus in un'applicazione web può ricevere una lettura senza un'API del browser specifica del lettore. Le porte seriali e gli SDK del produttore sono integrazioni distinte. Puoi testare il percorso da tastiera con un lettore fisico o con pressioni simulate.

Un'applicazione web di solito vede un lettore di codici a barre come una tastiera. Il test verifica se il controllo con il focus riceve il carico utile che l'applicazione si aspetta e se la pagina gestisce il terminatore che il lettore è configurato per inviare. Quel terminatore può essere Enter, Tab o niente.

Usa una sessione del tester di input dei codici a barre quando un lettore fisico è collegato. Usa il Barcode Scanner Emulator quando ti serve lo stesso percorso da tastiera durante lo sviluppo e l'hardware non è sulla scrivania. Un passaggio più ampio su focus, layout e flussi POS è in Come testare l'input di un lettore di codici a barre. Questa guida resta sull'applicazione nel browser: acquisizione, suffissi, validazione e gli eventi che puoi osservare davvero.

Come i lettori di codici a barre comunicano con le applicazioni web

La modalità di interfaccia decide che cosa può ricevere la pagina. Confermala prima di cambiare il codice del modulo. Un lettore può spesso cambiare modalità leggendo un codice a barre di configurazione dal manuale del produttore.

Emulazione tastiera HID USB

In modalità tastiera HID USB il lettore si enumera come una tastiera. Il sistema operativo carica il suo driver di tastiera normale. Dopo aver decodificato un simbolo, il lettore invia i caratteri come pressioni al controllo che ha il focus della tastiera. La pagina ascolta quelle pressioni oppure legge il testo che inseriscono. Non apre una connessione verso il dispositivo.

Per questo un campo di cassa, una casella di ricerca o un altro input di testo può accettare una lettura con HTML ordinario. La guida Emulazione tastiera HID descrive in modo più dettagliato la sequenza delle pressioni, i prefissi e i suffissi.

HID Bluetooth

Un lettore Bluetooth associato come tastiera usa lo stesso percorso dell'applicazione. L'host lo tratta come una tastiera HID e il campo con il focus riceve le pressioni. Associazione, batteria e radio sono questioni del dispositivo. Quando i caratteri arrivano al browser, la pagina li gestisce come l'input di un'emulazione USB.

Porta seriale e porta COM virtuale

Un lettore seriale, comprese molte modalità di porta COM virtuale USB, invia il testo decodificato come byte su una porta. Il focus non sceglie la destinazione. La sceglie il processo che apre la porta. Un campo di testo che ascolta solo le pressioni non vede quel flusso.

I browser basati su Chromium possono aprire una porta seriale tramite la Web Serial API dopo che l'utente seleziona la porta e concede il permesso. Firefox e Safari non forniscono quell'API. Un test di emulazione non esercita un'integrazione seriale, e un test seriale non dice che cosa digiterà un lettore in emulazione.

Interfacce specifiche del produttore

Alcuni dispositivi usano un SDK del produttore, OPOS, JPOS o un'interfaccia HID che non è una tastiera, come USB HID POS. Quelle interfacce non scrivono nel campo con il focus. Una pagina web normale non può caricare un SDK nativo. Chromium può richiedere alcuni dispositivi HID che non sono tastiere tramite WebHID dopo un gesto dell'utente. I dispositivi HID della classe tastiera restano bloccati, quindi un lettore in emulazione resta indistinguibile da una tastiera. Tratta un'interfaccia del produttore come un'integrazione a sé e testala con il software che apre davvero quell'interfaccia.

Che cosa può vedere il browser

Una lettura in emulazione arriva come eventi keydown e keyup, e i caratteri stampabili aggiornano il campo con il focus. Il browser non riceve un nome di dispositivo, un numero di serie USB né un contrassegno che indichi un lettore. I browser che implementano WebHID rifiutano ancora le interfacce tastiera, quindi lo script della pagina non può leggere nemmeno i report HID grezzi di un lettore in emulazione.

event.key è il carattere o il nome del tasto dopo che il sistema operativo ha applicato il layout di tastiera attivo. event.code nomina il tasto fisico, come Digit1 o Numpad1, e può restare uguale quando un disallineamento di layout cambia event.key. Nessuna delle due proprietà identifica l'hardware.

Come testare un lettore di codici a barre fisico in un browser

Fallo prima di eseguire il debug del codice dell'applicazione. Mostra la stringa esatta e il terminatore che il browser ha ricevuto.

  1. Collega il lettore e attendi che indichi di avere alimentazione. Per il Bluetooth, completa l'associazione e conferma che l'host usa un profilo tastiera.
  2. Conferma la modalità di input. L'emulazione tastiera, la tastiera HID USB o la tastiera HID Bluetooth possono scrivere in un campo. Le modalità seriale, SPP e SDK del produttore no.
  3. Apri il tester di input dei codici a barre.
  4. Fai clic su Avvia test oppure sull'area di lettura. Diventa blu quando è pronto. La pagina non prende il focus da sola.
  5. Leggi un codice a barre di cui conosci già il carico utile. Inizia con un valore numerico breve, poi leggi un valore che include la punteggiatura che l'applicazione memorizza.
  6. Leggi il valore acquisito e il conteggio dei caratteri. Confronta entrambi con il carico utile atteso, compreso un prefisso che il lettore inserisce prima dei dati.
  7. Controlla il suffisso. Il tester segnala ENTER, TAB o Nessuno. Con Cattura automatica attiva, il risultato compare dopo Enter, Tab o una breve pausa quando i tasti si fermano. Disattiva Cattura automatica quando vuoi che l'acquisizione resti in attesa finché non premi Ferma.
  8. Confronta quel risultato con la stringa che l'applicazione deve memorizzare. Un prefisso, un carattere sostituito o un terminatore mancante va corretto nella configurazione del lettore oppure gestito di proposito nella pagina. Non trattarlo come un errore di decodifica finché questo confronto non è fatto.

Il tester registra gli eventi di tastiera che il browser può vedere. Non può identificare il dispositivo USB né leggere una porta seriale. Quando un editor di testo riceve la lettura e il browser no, continua con Il lettore funziona in Notepad ma non nel POS.

Acquisire l'input del lettore di codici a barre con JavaScript

Un lettore scrive nell'elemento che ha il focus. Dai al campo un'etichetta visibile, lascialo come un input di testo normale così chi usa la tastiera può digitare un codice, e leggi il valore quando il flusso dice che l'inserimento è completo. La pagina sotto fa questo. Enter invia il modulo una volta. Tab completa un valore non vuoto e poi lascia che il browser sposti il focus. Una lettura senza terminatore resta nel campo finché qualcuno non attiva 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>

Salva quel file e aprilo in un browser desktop. Fai clic sul campo se il focus si è spostato. Un lettore in emulazione, o l'emulatore della sezione successiva, scrive allora in #barcode.

Il focus è necessario. Se document.activeElement è il corpo del documento, un pulsante o un altro input, i listener di questo campo non vedono la lettura. I caratteri finiscono nel controllo con il focus oppure si perdono. Chiama field.focus() quando il flusso è pronto per una lettura, anche dopo la chiusura di una finestra di dialogo.

L'input vuoto viene ignorato. Il modulo resta al suo posto e il testo di stato dice che non è stato ricevuto nulla. Lo spazio da solo è vuoto dopo trim().

L'esempio non aggiunge Enter né Tab. Se il lettore non è configurato per inviarli, il valore resta nel campo e Look up è il percorso di completamento. autocomplete="off" riduce la possibilità che un valore salvato sostituisca la lettura. L'etichetta, il pulsante e Shift+Tab restano disponibili, così una persona può inserire un codice senza lettore.

Gestisci Enter in un solo punto. Questo esempio usa l'evento submit del modulo, che copre anche il pulsante Look up e un Enter da tastiera. Un secondo listener keydown per Enter registrerebbe la stessa lettura due volte. Se l'input non è dentro un modulo, ascolta Enter su keydown e chiama preventDefault() così un modulo antenato non viene inviato a sua volta:

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

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

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

Svuota il campo dopo un'accettazione riuscita, così la lettura successiva non si accoda al carico utile precedente. Dopo Enter, l'esempio rimette il focus sullo stesso campo perché quel flusso si aspetta un'altra lettura nella stessa casella. Dopo Tab, lascia il focus fermo così il browser può passare al controllo successivo.

Gestire i suffissi ENTER e TAB

Un suffisso è un tasto che il lettore può inviare dopo il carico utile. È un'impostazione del dispositivo. Enter è comune ed è facoltativo. La guida Suffissi ENTER e TAB nei lettori di codici a barre descrive come distinguere i terminatori. Conferma l'impostazione sul lettore che stai testando, poi fai corrispondere la pagina a quel flusso.

ENTER

Enter dentro un campo di testo di una riga invia il modulo che lo contiene nei browser attuali. Usalo quando una lettura deve confermare il valore, come in una casella di ricerca. preventDefault() sull'evento submit impedisce al browser di lasciare la pagina. Omettilo quando una navigazione di pagina intera è il comportamento che vuoi.

Se il codice a barre compare e il modulo non fa nulla, il lettore potrebbe non inviare alcun suffisso. Al lettore di codici a barre manca ENTER percorre quella configurazione. Alcuni dispositivi inviano NumPad Enter. event.key resta "Enter". Controlla event.key, non solo event.code === "Enter", altrimenti quel lettore sembrerà guasto.

TAB

Tab sposta il focus sul controllo focalizzabile successivo. Si adatta a una sequenza come codice prodotto e poi quantità. Sorprende un modulo che si aspettava che Enter inviasse i dati.

Leggi il valore in keydown mentre il campo ha ancora il focus. Il browser sposta il focus dopo quell'evento. Lascia l'azione predefinita al suo posto quando il controllo successivo deve ricevere il focus. preventDefault() tiene il focus dov'è, utile quando il valore non è valido e vuoi che l'operatore lo veda. Ignora Shift+Tab così chi usa la tastiera può tornare indietro nel modulo. Un suffisso Tab del lettore è Tab senza Shift.

Un suffisso Tab può anche spostare il focus prima che il codice legga il campo, se il listener è su blur o change e qualcos'altro svuota il controllo. Leggi il valore dal target dell'evento keydown.

Nessun suffisso

Senza suffisso, il carico utile resta nel campo. L'applicazione deve decidere quando la lettura è finita. Un pulsante esplicito, un Enter successivo dell'operatore o il passaggio a un altro passo sono punti di completamento affidabili. Un timer di inattività può trattare una pausa nella digitazione come la fine di una lettura. Quel timer è un'euristica. Un lettore lento, un ritardo Bluetooth o una persona che digita in fretta possono finire dal lato sbagliato della soglia. Preferisci un suffisso configurato quando il flusso ha bisogno di un segnale netto di fine lettura.

Differenze di configurazione

Lettori della stessa marca possono uscire con suffissi diversi, e un codice a barre di configurazione può cambiare il suffisso senza alcuna modifica nel JavaScript. Alcuni dispositivi inviano un prefisso, un identificatore di simbologia come ]C1, oppure CR e LF. Testa le tre impostazioni di terminatore che gli utenti possono scegliere davvero: Enter, Tab e nessuno. Annota quale usano i lettori distribuiti e testa la pagina rispetto a quell'impostazione.

Validazione dell'input del lettore di codici a barre

Valida la stringa che il campo ha ricevuto. Non dare per scontato che ogni codice a barre abbia la stessa lunghezza, lo stesso set di caratteri o lo stesso checksum. I carichi utili di Code 128 e QR variano. EAN-13 ha 13 cifre. Un'applicazione che memorizza entrambi ha bisogno di regole per entrambi.

Input vuoto. Rifiutalo o ignorarlo. Un suffisso senza carico utile, o un clic su Look up in un campo vuoto, non deve creare un record.

Caratteri imprevisti. Confronta la stringa ricevuta con un'etichetta nota. Un disallineamento di layout si vede spesso come un simbolo cambiato, per esempio una cifra o una punteggiatura spostate, mentre la lunghezza resta la stessa. I caratteri di controllo possono arrivare da un prefisso o da un separatore di gruppo GS1. Consenti i caratteri che il formato definisce. L'esempio sopra rifiuta i caratteri di controllo ASCII così restano visibili nel testo di stato. Un parser GS1 che si aspetta un separatore di gruppo deve consentire quel carattere e rifiutare il resto.

Lunghezza. Applica le lunghezze che l'applicazione accetta. Un minimo e un massimo globali sono più sicuri di una sola lunghezza obbligatoria quando il modulo riceve più di una simbologia. maxlength sull'input tronca in silenzio un carico utile più lungo, quindi impostalo solo quando ogni codice accettato ci sta.

Prefisso. Togli un prefisso solo quando hai configurato il lettore per inviare esattamente quel prefisso e l'applicazione non lo memorizza.

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

Un identificatore di simbologia AIM è un dato se il lettore è impostato per trasmetterlo. Lascialo al suo posto finché non hai deciso se l'applicazione lo memorizza.

Suffisso. Tieni il terminatore fuori dal valore memorizzato. Enter e Tab sono tasti. Non vengono inseriti in un input di testo normale. Un carico utile seriale può ancora includere i byte CR o LF. Toglili al confine in cui analizzi il flusso seriale e verifica di non toglierli dal mezzo di un carico utile che li contiene in modo legittimo.

Invii duplicati. Una lettura può essere gestita due volte se sia keydown sia submit vengono eseguiti per lo stesso Enter. Usa un solo percorso di completamento. Una seconda lettura dello stesso codice è un'altra domanda. Un modulo di magazzino può incrementare la quantità. Un modulo di biglietto può rifiutare un codice già riscattato. Metti quella regola nell'applicazione e testala di proposito. Il browser non può distinguere una seconda pressione del grilletto da un secondo listener.

Regole dell'applicazione. I checksum appartengono a simbologie specifiche. EAN-13 usa l'ultima cifra come cifra di controllo. Questa funzione accetta solo quel formato:

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 e QR non usano quel calcolo. Il lettore può aver già verificato la propria simbologia e trasmesso i dati leggibili. Valida i formati che memorizzi e ripeti il controllo sul server. La stringa inviata è input utente ordinario. Il browser non può dimostrare che l'ha prodotta un lettore.

Testare l'input del lettore senza hardware fisico

Il Barcode Scanner Emulator è un'app desktop per Windows, macOS e Linux. Inserisci il testo da inviare, scegli un ritardo di digitazione e scegli un suffisso tra nessuno, ENTER o TAB. Una scorciatoia globale digita quel testo nell'applicazione con il focus. Riproduce il percorso da tastiera che usa un lettore in emulazione. Non illumina un'etichetta, non legge un simbolo e non decodifica una simbologia.

Usa la pagina di esempio sopra, o la pagina che stai costruendo:

  1. Apri la pagina in un browser desktop e fai clic sul campo del codice a barre.
  2. Nell'emulatore, inserisci un valore noto come 123456789012.
  3. Imposta il suffisso su ENTER. Imposta il ritardo di digitazione se vuoi che la raffica somigli a un lettore che hai già misurato.
  4. Premi la scorciatoia globale di lettura dell'emulatore mentre il campo del browser ha ancora il focus.
  5. Conferma il testo di stato e che il valore è stato accettato una volta.
  6. Ripeti con TAB. Il focus deve spostarsi e il valore deve essere accettato una volta.
  7. Ripeti senza suffisso. Il testo deve restare nel campo finché non attivi Look up.
  8. Metti il focus sul tester di input dei codici a barre e invia di nuovo lo stesso valore. Confronta la stringa acquisita, il prefisso e il suffisso con ciò che l'applicazione ha memorizzato.

Installazione e prima scorciatoia sono descritte in Per iniziare. Dopo una modifica delle impostazioni, invia una lettura nel tester di input prima di fidarti del risultato nell'applicazione.

L'hardware resta necessario per le parti ottiche e specifiche del dispositivo del test:

  • Se quel lettore può decodificare il simbolo stampato o visualizzato, comprese etichette danneggiate, dimensioni, contrasto e distanza.
  • Supporto delle simbologie. Un lettore laser 1D non può leggere un codice QR. Vedi Test dei codici QR: come testare i lettori di QR.
  • Enumerazione USB, associazione Bluetooth e la configurazione propria del lettore per layout di tastiera e suffisso.
  • Integrazioni seriali, HID POS e SDK del produttore.

L'emulatore è lo strumento giusto per la logica dell'applicazione lungo il percorso da tastiera. È lo strumento sbagliato per dimostrare che un determinato lettore legge una determinata etichetta.

Eseguire il debug degli eventi tastiera del lettore di codici a barre

Osserva gli eventi in questo ordine quando il valore memorizzato è sbagliato.

keydown. Si attiva per ogni tasto, compresi Enter e Tab, prima che il browser inserisca un carattere o sposti il focus. Leggi il terminatore qui. event.repeat è vero quando un tasto resta premuto. Un lettore in emulazione invia di norma una pressione distinta per ogni carattere.

input. Si attiva sul campo dopo che un carattere stampabile ne ha cambiato il valore. È l'evento giusto da osservare se ti serve il testo mentre cresce. Non si attiva per Enter o Tab, perché quei tasti non inseriscono un carattere in un input di testo.

change. Si attiva dopo che il valore viene confermato, di solito quando il campo perde il focus. Un lettore che lascia il focus nello stesso campo non produce change alla fine della lettura. Non usare change come unico segnale di completamento.

event.key e event.code. Registra entrambi quando un carattere è sbagliato. Un disallineamento tra il layout del lettore e quello del sistema operativo cambia event.key e lascia event.code come il tasto che il lettore intendeva. Le cifre del tastierino numerico usano Numpad1 e codici simili. Alcune maschere di input le trattano in modo diverso da Digit1. Layout di tastiera errato del lettore di codici a barre spiega il disallineamento di layout.

Focus. Registra document.activeElement subito prima di una lettura. Se non è il campo del codice a barre, il resto della traccia spiega il controllo sbagliato. Gli iframe hanno un focus proprio. Una lettura in un frame incorporato è visibile allo script dentro quel frame.

Temporizzazione. I lettori spesso finiscono un carico utile breve ben sotto il secondo. Il tester di input confronta l'intervallo medio tra i caratteri con una soglia di 100 ms ed etichetta il risultato come temporizzazione, non come identificazione dell'hardware. Una soglia di intervallo può trattare chi digita in fretta, la compilazione automatica o l'emulatore come un lettore. Un lettore con ritardo tra i caratteri, un collegamento Bluetooth o un carico utile lungo può sembrare digitazione. Usa il valore acquisito e il suffisso. Usa la temporizzazione come indizio.

Il tester degli eventi tastiera elenca ogni keydown e keyup con key, code, modificatori e marche temporali. Usalo quando la stringa assemblata nasconde un tasto di prefisso o un codice del tastierino. Il registro sono eventi del browser. Non è traffico USB grezzo.

Problemi comuni nelle applicazioni web

La lettura va nel campo sbagliato. L'input in emulazione segue il focus. Fai clic sul campo di destinazione dopo ogni navigazione, finestra di dialogo o messaggio di validazione che sposta il focus. Una finestra modale senza campo di testo può ingoiare la lettura come scorciatoie.

Il lettore funziona in un editor di testo e non nel browser. Il dispositivo sta digitando. La pagina non accetta quei tasti. Controlla il focus, un input disabilitato o di sola lettura e un listener keydown che chiama preventDefault() sui tasti stampabili. Un listener che gestisce solo paste non vede mai l'input in emulazione. Inizia da Il lettore di codici a barre non funziona se nessuna applicazione riceve caratteri.

Enter invia il modulo due volte o esce dalla pagina. Il browser invia il modulo e il listener gestisce anche Enter. Chiama preventDefault() su uno di quei percorsi ed elabora il valore una volta. Un modulo con più campi può essere inviato prima che i campi successivi siano compilati quando il lettore invia Enter. Usa Tab per quel flusso, oppure impedisci l'invio finché il modulo non è completo.

Tab cambia il focus. Quello è il tasto Tab. Configura Enter sul lettore, oppure leggi il valore in keydown e consenti lo spostamento del focus. Vedi la sezione sui suffissi sopra.

Il layout di tastiera è sbagliato. Le cifre possono sopravvivere a un disallineamento che cambia la punteggiatura. Leggi un valore noto che contiene i simboli che memorizzi, sul layout che la postazione usa davvero.

La stessa lettura crea due record. Cerca due listener su un solo Enter prima di cercare due letture fisiche. Poi testa una seconda lettura deliberata e conferma la regola di quantità o di duplicato che l'applicazione documenta.

Il valore manca o è troncato. Un attributo maxlength, una maschera di input o preventDefault() sui tasti carattere possono scartare o tagliare il carico utile. Confronta il conteggio dei caratteri nel tester di input con il valore nel campo. Un prefisso può anche far sembrare troppo lungo un carico utile corretto.

I codici QR non compaiono mai. Il lettore può essere solo 1D, oppure la simbologia QR può essere disattivata. L'applicazione non può correggerlo. Conferma l'hardware con Test dei codici QR: come testare i lettori di QR, poi torna al test del campo.

Lista di controllo per testare l'applicazione web

Usala sulla build che intendi pubblicare, in ogni browser che supporti. Controlla un profilo nuovo e anche un profilo con estensioni di gestore password e di compilazione automatica, perché quelle estensioni spostano il focus.

  • Il lettore è collegato o associato, e l'host lo mostra pronto.
  • Il lettore è in modalità emulazione tastiera, non seriale e non in una modalità SDK del produttore.
  • Il campo del codice a barre ha il focus subito prima della lettura. document.activeElement è quel campo.
  • Un codice a barre noto arriva carattere per carattere, lunghezza compresa.
  • Un suffisso ENTER invia o accetta il valore una volta e non lascia il terminatore nella stringa memorizzata.
  • Un suffisso TAB sposta il focus sul controllo previsto, e il valore viene letto prima dello spostamento.
  • Una configurazione senza suffisso lascia il valore disponibile finché l'applicazione non lo completa.
  • Un invio vuoto viene rifiutato o ignorato.
  • Una lettura non crea due record. Una seconda lettura reale segue la regola di duplicato dell'applicazione.
  • Punteggiatura, simboli e ogni separatore GS1 che i formati usano sopravvivono all'andata e al ritorno.
  • Il layout di tastiera del lettore e quello del sistema operativo producono i caratteri stampati sull'etichetta.
  • Dopo aver scollegato e ricollegato, o dopo la caduta del collegamento Bluetooth, la lettura successiva raggiunge ancora il campo.
  • Diverse letture di seguito restano valori separati. Il campo non li concatena.
  • Gli stessi controlli passano nei browser che supporti, con e senza le estensioni comuni di compilazione automatica.

Per le finestre di dialogo, l'ordine di tabulazione su un'intera cassa e i flussi di quantità nel POS, continua con Come testare l'input di un lettore di codici a barre.

Matrice dei casi di test

La colonna del lettore è ciò che fanno il dispositivo e il browser. La colonna del comportamento atteso è ciò che l'applicazione deve fare in risposta. Le regole di business, per esempio se un codice prodotto ripetuto incrementa la quantità, appartengono all'applicazione. Indicale nel test invece di supporre una sola regola per ogni prodotto.

Scenario Comportamento atteso
Codice a barre valido L'applicazione accetta il valore e memorizza il carico utile senza il terminatore.
Input vuoto L'applicazione lo rifiuta o lo ignora e non crea un record.
Suffisso ENTER L'applicazione invia o accetta il valore una volta.
Suffisso TAB Il focus passa al controllo successivo previsto e il valore viene conservato.
Nessun suffisso L'input resta disponibile finché l'applicazione non lo elabora.
Letture rapide consecutive Ogni valore viene elaborato a parte e non viene concatenato con il precedente.
Layout di tastiera errato I caratteri imprevisti sono visibili nel valore acquisito e non superano la validazione.
Lettura duplicata L'applicazione segue la propria regola di duplicato, per esempio incrementare la quantità o rifiutare una ripetizione.
Formato di codice a barre non valido L'applicazione mostra l'errore di validazione di quel formato e non memorizza il valore.
Focus di input perso L'applicazione non inventa un codice a barre. La lettura manca o finisce nel controllo con il focus, e la pagina resta in uno stato sicuro.

Esegui le righe valido, vuoto, ENTER, TAB e nessun suffisso con il lettore fisico e di nuovo con l'emulatore. Esegui le righe di layout di tastiera, QR e riconnessione sull'hardware. Quelle righe dipendono dal dispositivo, dall'etichetta o dal layout del sistema operativo, che le pressioni simulate non riproducono.