Ir para o conteúdo

Barcode Scanner Emulator

Como testar leitores de código de barras em aplicativos web

Muitos leitores de código de barras USB e Bluetooth enviam os dados decodificados como entrada de teclado, então um campo em foco em um aplicativo web pode receber uma leitura sem uma API de navegador específica do leitor. Portas seriais e SDKs do fabricante são integrações separadas. Você pode testar o caminho do teclado com um leitor físico ou com teclas simuladas.

Um aplicativo web em geral vê um leitor de código de barras como um teclado. O teste é saber se o controle em foco recebe a carga que o aplicativo espera e se a página trata o terminador que o leitor está configurado para enviar. Esse terminador pode ser Enter, Tab ou nada.

Use uma sessão do testador de entrada de código de barras quando um leitor físico estiver conectado. Use o Barcode Scanner Emulator quando precisar do mesmo caminho de teclado durante o desenvolvimento e o hardware não estiver na mesa. Uma passagem mais ampla por foco, layout e fluxos de POS está em Como testar a entrada do leitor de código de barras. Este guia fica no aplicativo do navegador: captura, sufixos, validação e os eventos que você consegue observar de fato.

Como os leitores de código de barras se comunicam com aplicativos web

O modo de interface decide o que a página pode receber. Confirme isso antes de mudar o código do formulário. Um leitor muitas vezes consegue trocar de modo ao ler um código de barras de configuração do manual do fabricante.

Cunha de teclado HID USB

No modo de teclado HID USB o leitor se enumera como um teclado. O sistema operacional carrega o driver de teclado normal. Depois de decodificar um símbolo, o leitor envia os caracteres como teclas para o controle que tem o foco do teclado. A página escuta essas teclas ou lê o texto que elas inserem. Ela não abre uma conexão com o dispositivo.

É por isso que um campo de checkout, uma caixa de busca ou qualquer outra entrada de texto pode aceitar uma leitura com HTML comum. O guia Cunha de teclado HID cobre a sequência de teclas, os prefixos e os sufixos com mais detalhe.

HID Bluetooth

Um leitor Bluetooth pareado como teclado usa o mesmo caminho do aplicativo. O host o trata como um teclado HID, e o campo em foco recebe as teclas. Pareamento, bateria e rádio são assuntos do dispositivo. Quando os caracteres chegam ao navegador, a página os trata do mesmo jeito que a entrada de cunha USB.

Porta serial e porta COM virtual

Um leitor serial, inclusive muitos modos de porta COM virtual USB, envia o texto decodificado como bytes em uma porta. O foco não escolhe o destino. Quem escolhe é o processo que abre a porta. Um campo de texto que só escuta teclas não vê esse fluxo.

Navegadores baseados em Chromium podem abrir uma porta serial pela Web Serial API depois que o usuário seleciona a porta e concede a permissão. Firefox e Safari não oferecem essa API. Um teste de cunha não exercita uma integração serial, e um teste serial não diz o que um leitor em cunha vai digitar.

Interfaces específicas do fabricante

Alguns dispositivos usam um SDK do fabricante, OPOS, JPOS ou uma interface HID que não é teclado, como USB HID POS. Essas interfaces não digitam no campo em foco. Uma página web normal não consegue carregar um SDK nativo. O Chromium pode pedir alguns dispositivos HID que não são teclado pela WebHID depois de um gesto do usuário. Dispositivos HID da classe teclado continuam bloqueados, então um leitor em cunha permanece indistinguível de um teclado. Trate uma interface de fabricante como uma integração própria e teste-a com o software que de fato abre essa interface.

O que o navegador consegue ver

Uma leitura em cunha chega como eventos keydown e keyup, e os caracteres imprimíveis atualizam o campo em foco. O navegador não recebe um nome de dispositivo, um número de série USB nem uma marca que diga que é um leitor. Navegadores que implementam WebHID ainda recusam interfaces de teclado, então o script da página também não consegue ler os relatórios HID brutos de um leitor em cunha.

event.key é o caractere ou o nome da tecla depois que o sistema operacional aplica o layout de teclado ativo. event.code nomeia a tecla física, como Digit1 ou Numpad1, e pode continuar igual quando um layout diferente muda event.key. Nenhuma das duas propriedades identifica o hardware.

Como testar um leitor de código de barras físico em um navegador

Faça isto antes de depurar o código do aplicativo. Mostra a string exata e o terminador que o navegador recebeu.

  1. Conecte o leitor e espere até ele mostrar que está ligado. No Bluetooth, termine o pareamento e confirme que o host usa um perfil de teclado.
  2. Confirme o modo de entrada. Cunha de teclado, teclado HID USB ou teclado HID Bluetooth conseguem digitar em um campo. Os modos serial, SPP e SDK do fabricante não.
  3. Abra o testador de entrada de código de barras.
  4. Clique em Iniciar teste ou na área de leitura. Ela fica azul quando está pronta. A página não toma o foco sozinha.
  5. Leia um código de barras cuja carga você já conhece. Comece com um valor numérico curto e depois leia um valor que inclua a pontuação que o aplicativo armazena.
  6. Leia o valor capturado e a contagem de caracteres. Compare os dois com a carga esperada, inclusive qualquer prefixo que o leitor insira antes dos dados.
  7. Verifique o sufixo. O testador informa ENTER, TAB ou Nenhum. Com Captura automática ligada, o resultado aparece depois de Enter, Tab ou uma pausa curta quando as teclas param. Desligue Captura automática quando quiser que a captura fique retida até você pressionar Parar.
  8. Compare esse resultado com a string que o aplicativo deve armazenar. Um prefixo, um caractere substituído ou um terminador ausente deve ser corrigido na configuração do leitor ou tratado de propósito na página. Não trate isso como falha de decodificação até essa comparação estar feita.

O testador registra eventos de teclado que o navegador consegue ver. Ele não identifica o dispositivo USB nem lê uma porta serial. Quando um editor de texto recebe a leitura e o navegador não, continue com Funciona no Notepad, mas não no POS.

Capturar a entrada do leitor de código de barras com JavaScript

Um leitor digita no elemento que tem o foco. Dê ao campo um rótulo visível, deixe-o como uma entrada de texto normal para que quem usa o teclado possa digitar um código, e leia o valor quando o fluxo disser que a entrada está completa. A página abaixo faz isso. Enter envia o formulário uma vez. Tab conclui um valor não vazio e depois deixa o navegador mover o foco. Uma leitura sem terminador fica no campo até alguém ativar 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>

Salve esse arquivo e abra-o em um navegador de desktop. Clique no campo se o foco tiver saído. Um leitor em cunha, ou o emulador da seção seguinte, então digita em #barcode.

O foco é necessário. Se document.activeElement for o corpo do documento, um botão ou outra entrada, os listeners deste campo não veem a leitura. Os caracteres caem no controle em foco ou se perdem. Chame field.focus() quando o fluxo estiver pronto para uma leitura, inclusive depois que um diálogo fechar.

Entrada vazia é ignorada. O formulário permanece no lugar, e o texto de status diz que nada foi recebido. Espaço em branco sozinho fica vazio depois de trim().

O exemplo não adiciona Enter nem Tab. Se o leitor não estiver configurado para enviá-los, o valor permanece no campo e Look up é o caminho de conclusão. autocomplete="off" reduz a chance de um valor salvo substituir a leitura. O rótulo, o botão e Shift+Tab continuam disponíveis, então uma pessoa pode digitar um código sem leitor.

Trate Enter em um só lugar. Este exemplo usa o evento submit do formulário, que também cobre o botão Look up e um Enter do teclado. Um segundo listener keydown para Enter registraria a mesma leitura duas vezes. Se a entrada não estiver dentro de um formulário, escute Enter em keydown e chame preventDefault() para que um formulário ancestral também não seja enviado:

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

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

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

Limpe o campo depois de uma aceitação bem-sucedida para que a leitura seguinte não se acrescente à carga anterior. Depois de Enter, o exemplo foca o mesmo campo de novo porque esse fluxo espera outra leitura na mesma caixa. Depois de Tab, ele deixa o foco quieto para o navegador poder ir ao controle seguinte.

Como tratar os sufixos ENTER e TAB

Um sufixo é uma tecla que o leitor pode enviar depois da carga. É um ajuste do dispositivo. Enter é comum e é opcional. O guia Sufixos ENTER e TAB em leitores de código de barras descreve como distinguir os terminadores. Confirme o ajuste no leitor que você está testando e depois faça a página combinar com esse fluxo.

ENTER

Enter dentro de um campo de texto de uma linha envia o formulário que o envolve nos navegadores atuais. Use isso quando uma leitura deve confirmar o valor, como em uma caixa de consulta. preventDefault() no evento submit impede o navegador de sair da página. Omita isso quando uma navegação de página inteira for o comportamento que você quer.

Se o código de barras aparece e o formulário não faz nada, o leitor pode não estar enviando sufixo. Leitor de código de barras sem ENTER percorre essa configuração. Alguns dispositivos enviam NumPad Enter. event.key continua sendo "Enter". Verifique event.key, não só event.code === "Enter", senão esse leitor vai parecer quebrado.

TAB

Tab move o foco para o próximo controle que pode recebê-lo. Isso serve para uma sequência como código do produto e depois quantidade. Surpreende um formulário que esperava que Enter enviasse os dados.

Leia o valor em keydown enquanto o campo ainda tem o foco. O navegador move o foco depois desse evento. Deixe a ação padrão no lugar quando o controle seguinte deve receber o foco. preventDefault() mantém o foco onde está, o que é útil quando o valor é inválido e você quer que o operador veja. Ignore Shift+Tab para que quem usa o teclado possa voltar pelo formulário. Um sufixo Tab do leitor é Tab sem Shift.

Um sufixo Tab também pode mover o foco antes de o código ler o campo, se o listener estiver em blur ou change e outra coisa limpar o controle. Leia o valor a partir do target do evento keydown.

Sem sufixo

Sem sufixo, a carga fica no campo. O aplicativo tem de decidir quando a leitura terminou. Um botão explícito, um Enter posterior do operador ou a passagem para outra etapa são pontos de conclusão confiáveis. Um temporizador de inatividade pode tratar uma pausa na digitação como o fim de uma leitura. Esse temporizador é uma heurística. Um leitor lento, um atraso de Bluetooth ou uma pessoa que digita rápido pode cair do lado errado do limiar. Prefira um sufixo configurado quando o fluxo precisa de um sinal firme de fim de leitura.

Diferenças de configuração

Leitores da mesma marca podem sair de fábrica com sufixos diferentes, e um código de barras de configuração pode mudar o sufixo sem nenhuma mudança no JavaScript. Alguns dispositivos enviam um prefixo, um identificador de simbologia como ]C1, ou CR e LF. Teste os três ajustes de terminador que os usuários conseguem escolher de fato: Enter, Tab e nenhum. Anote qual os leitores implantados usam e teste a página contra esse ajuste.

Validação da entrada do leitor de código de barras

Valide a string que o campo recebeu. Não presuma que todo código de barras tem o mesmo comprimento, o mesmo conjunto de caracteres ou a mesma soma de verificação. Cargas de Code 128 e QR variam. EAN-13 tem 13 dígitos. Um aplicativo que armazena os dois precisa de regras para os dois.

Entrada vazia. Rejeite ou ignore. Um sufixo sem carga, ou um clique em Look up em um campo em branco, não deve criar um registro.

Caracteres inesperados. Compare a string recebida com uma etiqueta conhecida. Um layout diferente muitas vezes aparece como um símbolo alterado, como um dígito ou uma pontuação deslocados, enquanto o comprimento permanece o mesmo. Caracteres de controle podem vir de um prefixo ou de um separador de grupo GS1. Permita os caracteres que o formato define. O exemplo acima rejeita caracteres de controle ASCII para que continuem visíveis no texto de status. Um analisador GS1 que espera um separador de grupo deve permitir esse caractere e rejeitar o resto.

Comprimento. Aplique os comprimentos que o aplicativo aceita. Um mínimo e um máximo globais são mais seguros do que um único comprimento obrigatório quando o formulário recebe mais de uma simbologia. maxlength na entrada trunca em silêncio uma carga mais longa, então defina isso só quando cada código aceito couber.

Prefixo. Remova um prefixo só quando você configurou o leitor para enviar exatamente esse prefixo e o aplicativo não o armazena.

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

Um identificador de simbologia AIM é dado se o leitor está ajustado para transmiti-lo. Deixe-o no lugar até decidir se o aplicativo o armazena.

Sufixo. Mantenha o terminador fora do valor armazenado. Enter e Tab são teclas. Eles não são inseridos em uma entrada de texto normal. Uma carga serial ainda pode incluir bytes CR ou LF. Remova-os na fronteira em que você analisa o fluxo serial e teste que você não os remove do meio de uma carga que os contém de forma legítima.

Envios duplicados. Uma leitura pode ser tratada duas vezes se tanto keydown quanto submit rodarem para o mesmo Enter. Use um único caminho de conclusão. Uma segunda leitura do mesmo código é outra pergunta. Um formulário de depósito pode incrementar a quantidade. Um formulário de ingresso pode rejeitar um código que já foi resgatado. Coloque essa regra no aplicativo e teste de propósito. O navegador não consegue distinguir um segundo acionamento do gatilho de um segundo listener.

Regras do aplicativo. Somas de verificação pertencem a simbologias específicas. EAN-13 usa o último dígito como dígito verificador. Esta função aceita só esse 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 não usam esse cálculo. O leitor pode já ter conferido a própria simbologia e transmitido os dados legíveis. Valide os formatos que você armazena e repita a conferência no servidor. A string enviada é entrada de usuário comum. O navegador não pode provar que um leitor a produziu.

Testar a entrada do leitor sem hardware físico

O Barcode Scanner Emulator é um aplicativo de desktop para Windows, macOS e Linux. Você digita o texto a enviar, escolhe um atraso de digitação e escolhe um sufixo entre nenhum, ENTER ou TAB. Um atalho global digita esse texto no aplicativo em foco. Ele reproduz o caminho de teclado que um leitor em cunha usa. Não ilumina uma etiqueta, não lê um símbolo e não decodifica uma simbologia.

Use a página de exemplo acima ou a página que você está construindo:

  1. Abra a página em um navegador de desktop e clique no campo do código de barras.
  2. No emulador, digite um valor conhecido como 123456789012.
  3. Defina o sufixo como ENTER. Ajuste o atraso de digitação se quiser que a rajada se pareça com um leitor que você já mediu.
  4. Pressione o atalho global de leitura do emulador enquanto o campo do navegador ainda tem o foco.
  5. Confirme o texto de status e que o valor foi aceito uma vez.
  6. Repita com TAB. O foco deve se mover, e o valor deve ser aceito uma vez.
  7. Repita sem sufixo. O texto deve permanecer no campo até você ativar Look up.
  8. Foque o testador de entrada de código de barras e envie o mesmo valor de novo. Compare a string capturada, o prefixo e o sufixo com o que o aplicativo armazenou.

A instalação e o primeiro atalho estão em Primeiros passos. Depois de uma mudança de configuração, envie uma leitura para o testador de entrada antes de confiar no resultado do aplicativo.

O hardware ainda é necessário para as partes ópticas e específicas do dispositivo do teste:

  • Se aquele leitor consegue decodificar o símbolo impresso ou exibido, inclusive etiquetas danificadas, tamanho, contraste e distância.
  • Suporte a simbologias. Um leitor a laser 1D não consegue ler um código QR. Veja Teste de código QR: como testar leitores de código QR.
  • Enumeração USB, pareamento Bluetooth e a configuração própria do leitor para layout de teclado e sufixo.
  • Integrações serial, HID POS e SDK do fabricante.

O emulador é a ferramenta certa para a lógica do aplicativo ao longo do caminho do teclado. É a ferramenta errada para provar que um leitor específico lê uma etiqueta específica.

Depurar eventos de teclado do leitor de código de barras

Observe os eventos nesta ordem quando o valor armazenado está errado.

keydown. Dispara para cada tecla, inclusive Enter e Tab, antes de o navegador inserir um caractere ou mover o foco. Leia o terminador aqui. event.repeat é verdadeiro quando uma tecla fica pressionada. Um leitor em cunha normalmente envia um pressionamento distinto para cada caractere.

input. Dispara no campo depois que um caractere imprimível muda o valor. É o evento certo de observar se você precisa do texto à medida que ele cresce. Não dispara para Enter nem Tab, porque essas teclas não inserem um caractere em uma entrada de texto.

change. Dispara depois que o valor é confirmado, em geral quando o campo perde o foco. Um leitor que deixa o foco no mesmo campo não produz change no fim da leitura. Não use change como único sinal de conclusão.

event.key e event.code. Registre os dois quando um caractere está errado. Um desencontro entre o layout do leitor e o do sistema operacional muda event.key e deixa event.code como a tecla que o leitor pretendia. Dígitos do teclado numérico usam Numpad1 e códigos parecidos. Algumas máscaras de entrada tratam isso de forma diferente de Digit1. Layout de teclado errado no leitor de código de barras explica o desencontro de layout.

Foco. Registre document.activeElement imediatamente antes de uma leitura. Se não for o campo do código de barras, o resto do rastro explica o controle errado. Iframes têm o próprio foco. Uma leitura em um quadro incorporado é visível para o script dentro desse quadro.

Tempo. Leitores muitas vezes terminam uma carga curta bem abaixo de um segundo. O testador de entrada compara o intervalo médio entre caracteres com um limiar de 100 ms e rotula o resultado como tempo, não como identificação do hardware. Um limiar de intervalo pode tratar quem digita rápido, o preenchimento automático ou o emulador como um leitor. Um leitor com atraso entre caracteres, um enlace Bluetooth ou uma carga longa pode parecer digitação. Use o valor capturado e o sufixo. Use o tempo como pista.

O testador de eventos de teclado lista cada keydown e keyup com key, code, modificadores e marcas de tempo. Use-o quando a string montada esconde uma tecla de prefixo ou um código de teclado numérico. O registro são eventos do navegador. Não é tráfego USB bruto.

Problemas comuns em aplicativos web

A leitura vai para o campo errado. A entrada em cunha segue o foco. Clique no campo de destino depois de cada navegação, diálogo ou mensagem de validação que mova o foco. Um modal sem campo de texto pode engolir a leitura como atalhos de teclado.

O leitor funciona em um editor de texto e não no navegador. O dispositivo está digitando. A página não está aceitando essas teclas. Verifique o foco, uma entrada desabilitada ou somente leitura e um listener keydown que chame preventDefault() em teclas imprimíveis. Um listener que só trata paste nunca vê a entrada em cunha. Comece por Leitor de código de barras não funciona se nenhum aplicativo recebe caracteres.

Enter envia o formulário duas vezes ou sai da página. O navegador envia o formulário, e o listener também trata Enter. Chame preventDefault() em um desses caminhos e processe o valor uma vez. Um formulário de vários campos pode ser enviado antes de os campos seguintes serem preenchidos quando o leitor envia Enter. Use Tab para esse fluxo ou impeça o envio até o formulário estar completo.

Tab muda o foco. Essa é a tecla Tab. Configure Enter no leitor ou leia o valor em keydown e permita o movimento do foco. Veja a seção de sufixos acima.

O layout de teclado está errado. Dígitos podem sobreviver a um desencontro que muda a pontuação. Leia um valor conhecido que contenha os símbolos que você armazena, no layout que a estação realmente usa.

A mesma leitura cria dois registros. Procure dois listeners em um mesmo Enter antes de procurar duas leituras físicas. Depois teste uma segunda leitura de propósito e confirme a regra de quantidade ou de duplicata que o aplicativo documenta.

O valor falta ou está truncado. Um atributo maxlength, uma máscara de entrada ou preventDefault() em teclas de caractere podem descartar ou cortar a carga. Compare a contagem de caracteres no testador de entrada com o valor do seu campo. Um prefixo também pode fazer uma carga correta parecer longa demais.

Códigos QR nunca aparecem. O leitor pode ser só 1D, ou a simbologia QR pode estar desativada. O aplicativo não consegue corrigir isso. Confirme o hardware com Teste de código QR: como testar leitores de código QR e volte ao teste do campo.

Lista de verificação para testar o aplicativo web

Use-a na build que você pretende publicar, em cada navegador que você suporta. Verifique um perfil novo e também um perfil com extensões de gerenciador de senhas e de preenchimento automático, porque essas extensões movem o foco.

  • O leitor está conectado ou pareado, e o host o mostra pronto.
  • O leitor está em modo de cunha de teclado, não em serial nem em um modo SDK do fabricante.
  • O campo do código de barras está em foco imediatamente antes da leitura. document.activeElement é esse campo.
  • Um código de barras conhecido chega caractere por caractere, comprimento incluído.
  • Um sufixo ENTER envia ou aceita o valor uma vez e não deixa o terminador na string armazenada.
  • Um sufixo TAB move o foco para o controle pretendido, e o valor é lido antes do movimento.
  • Uma configuração sem sufixo deixa o valor disponível até o aplicativo concluí-lo.
  • Um envio vazio é rejeitado ou ignorado.
  • Uma leitura não cria dois registros. Uma segunda leitura real segue a regra de duplicata do aplicativo.
  • Pontuação, símbolos e qualquer separador GS1 que os formatos usem sobrevivem à ida e volta.
  • O layout de teclado do leitor e o do sistema operacional produzem os caracteres impressos na etiqueta.
  • Depois de desconectar e reconectar, ou depois de o enlace Bluetooth cair, a leitura seguinte ainda chega ao campo.
  • Várias leituras seguidas permanecem valores separados. O campo não os concatena.
  • As mesmas verificações passam nos navegadores que você suporta, com e sem extensões comuns de preenchimento automático.

Para diálogos, a ordem de tabulação em um checkout inteiro e fluxos de quantidade no POS, continue com Como testar a entrada do leitor de código de barras.

Matriz de casos de teste

A coluna do leitor é o que o dispositivo e o navegador fazem. A coluna de comportamento esperado é o que o aplicativo deve fazer em resposta. Regras de negócio, como um código de produto repetido incrementar a quantidade, pertencem ao aplicativo. Declare-as no teste em vez de presumir uma regra só para todo produto.

Cenário Comportamento esperado
Código de barras válido O aplicativo aceita o valor e armazena a carga sem o terminador.
Entrada vazia O aplicativo a rejeita ou a ignora e não cria um registro.
Sufixo ENTER O aplicativo envia ou aceita o valor uma vez.
Sufixo TAB O foco vai para o controle seguinte pretendido, e o valor é mantido.
Sem sufixo A entrada permanece disponível até o aplicativo processá-la.
Leituras rápidas consecutivas Cada valor é processado à parte e não é concatenado com o anterior.
Layout de teclado errado Caracteres inesperados ficam visíveis no valor capturado e falham na validação.
Leitura duplicada O aplicativo segue a própria regra de duplicata, como incrementar a quantidade ou rejeitar uma repetição.
Formato de código de barras inválido O aplicativo mostra o erro de validação daquele formato e não armazena o valor.
Foco de entrada perdido O aplicativo não inventa um código de barras. A leitura está ausente ou cai no controle em foco, e a página permanece em um estado seguro.

Execute as linhas de válido, vazio, ENTER, TAB e sem sufixo com o leitor físico e de novo com o emulador. Execute as linhas de layout de teclado, QR e reconexão no hardware. Essas linhas dependem do dispositivo, da etiqueta ou do layout do sistema operacional, o que teclas simuladas não reproduzem.