Saltar para o conteúdo

Barcode Scanner Emulator

Como testar a introdução do leitor de códigos QR em aplicações web

Muitos leitores externos compatíveis com QR usam o modo de cunha de teclado e escrevem o texto QR descodificado no campo com foco. Teste esse percurso lendo uma carga conhecida e comparando-a com o valor que a página recebeu. Nem todo leitor de QR escreve como um teclado. Dispositivos série e descodificadores de câmara são integrações diferentes, e os eventos de teclado do navegador não identificam o leitor físico.

Um código QR guarda dados. O leitor, ou um descodificador de câmara, transforma esses dados em texto. A aplicação web tem de receber esse texto, decidir quando a leitura terminou e validá-lo. Este guia é esse ensaio da aplicação. Gerar etiquetas, verificar o contraste e confirmar que um aparelho consegue descodificar QR Code está em Teste de códigos QR: como testar leitores de códigos QR. Os formulários de códigos de barras em geral, incluindo os dígitos de controlo de EAN, estão em Como testar leitores de códigos de barras em aplicações web.

Testar a introdução do leitor de QR em 60 segundos

Use uma carga que tenha escolhido, para que um carácter errado seja óbvio. Este percurso usa QR-INPUT-TEST-12345.

  1. Abra o gerador de códigos QR e gere um código QR para QR-INPUT-TEST-12345. O gerador corre no navegador. Não contacta o leitor.
  2. Ligue um leitor compatível com QR que esteja em modo de cunha de teclado. Um leitor apenas 1D não consegue descodificar este símbolo.
  3. Abra o testador de introdução de códigos de barras.
  4. Clique em Iniciar teste ou na área de leitura, para o campo ter o foco. O testador não toma o foco por si e não abre o leitor.
  5. Leia o código QR.
  6. Leia o texto captado e a contagem de caracteres.
  7. Compare esse texto com QR-INPUT-TEST-12345. A comparação inclui maiúsculas e minúsculas, hífenes e o comprimento.
  8. Leia o sufixo. O testador indica ENTER, TAB ou Nenhum quando o leitor envia uma dessas teclas.

O testador regista os eventos de teclado que o navegador consegue ver. Não identifica o dispositivo USB, não lê uma porta série e não descodifica a imagem QR.

Modos de introdução do leitor de QR

O mesmo código QR impresso pode chegar por três integrações diferentes. O ensaio de um modo não exercita os outros.

Leitores de QR em cunha de teclado

No modo de teclado USB HID, ou no modo de teclado Bluetooth HID, o sistema operativo trata o leitor como um teclado. Depois da descodificação, o leitor escreve a carga no controlo que tem o foco. Um <input> ou <textarea> normal pode recebê-la. A página não abre o dispositivo. O guia Cunha de teclado HID descreve a sequência de premidas, os prefixos e os sufixos.

O foco decide o destino. Se o elemento com foco for o corpo do documento, um botão ou outro quadro, os escutadores deste campo não vêem a leitura.

Leitores de QR série

Um leitor USB série ou de porta COM virtual envia o texto descodificado como bytes ao processo que abriu a porta. O foco não escolhe esse processo. Um campo que apenas escuta premidas fica vazio enquanto um terminal nessa porta mostra a carga.

Os navegadores baseados em Chromium podem abrir uma porta escolhida pelo utilizador com a API Web Serial, num contexto seguro, após um gesto do utilizador. O Firefox e o Safari não disponibilizam essa API. Um leitor em cunha não aparece como porta série. Os nomes de porta, o baud e o enquadramento dependem do aparelho e do controlador. Leitores de códigos de barras USB HID e série compara as duas interfaces. O testador de introdução de códigos de barras não consegue ler uma porta COM.

Leitura de QR por câmara

Uma integração de câmara captura uma imagem e descodifica o código QR em software. A página usa uma API de câmara e um descodificador. Não recebe eventos keydown da carga. Aplicações de câmara do telemóvel, botões de câmara na página e um leitor por imagem que escreve num campo são três produtos diferentes. Passar um ensaio de cunha não significa que o botão da câmara funciona, e uma descodificação de câmara bem-sucedida não significa que um leitor em cunha irá escrever a mesma cadeia.

Captar a introdução do leitor de QR com JavaScript

A página abaixo lê um campo com foco. Enter submete o formulário, e o botão Accept usa esse mesmo handler de submit, pelo que uma leitura é processada uma vez. Sem um sufixo ENTER, o texto fica no campo até alguém activar Accept. A carga captada é escrita com textContent, pelo que caracteres como < permanecem visíveis como texto.

O exemplo aceita três formatos da aplicação: um id de bilhete como QR-INPUT-TEST-12345, um URL http ou https, ou um objecto JSON. Regista o texto lido. Não navega para um URL encontrado no código QR. Um leitor que não envia Enter continua a funcionar pelo botão. Tab percorre o rótulo, o campo e o botão como habitualmente, porque o script não o retém.

<!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>

Guarde o ficheiro e abra-o num navegador de secretária. Clique no campo antes de ler. autocomplete="off" reduz a hipótese de um valor guardado substituir a leitura. O rótulo e o botão permanecem disponíveis, pelo que uma pessoa pode escrever uma carga sem leitor.

Trate Enter apenas no evento submit do formulário. Um segundo escutador de keydown para Enter regista a mesma leitura duas vezes. preventDefault() mantém o navegador nesta página. Limpe o campo após uma decisão, para que a leitura seguinte não se junte ao texto anterior.

Uma carga QR pode conter uma quebra de linha. Um leitor em cunha escreve muitas vezes essa quebra como Enter. Numa introdução de uma linha, o formulário pode ser submetido na primeira linha e perder o resto. Use um textarea, ou uma leitura série que conserve os bytes, quando a aplicação tiver de aceitar texto de várias linhas. Confirme esse comportamento com um código QR cuja carga inclua uma quebra de linha.

Tratamento de cargas QR

Um símbolo QR não promete um formato de aplicação. A mesma simbologia pode transportar qualquer um destes:

  • Texto simples, como QR-INPUT-TEST-12345.
  • Um URL.
  • Um identificador escolhido pela aplicação.
  • Uma carga estruturada, como um número de bilhete mais um código de local.
  • Texto JSON, quando a aplicação definiu essa codificação.

O leitor transmite os caracteres descodificados. Não verifica se correspondem a uma regra de bilhete, a um catálogo de produtos ou a um esquema JSON. Valide a cadeia na página e valide-a de novo no servidor. O valor submetido é introdução comum do utilizador. O navegador não pode provar que um leitor o produziu.

Validar a introdução de QR

Não presuma que uma carga QR é numérica. As regras de EAN-13 não se aplicam. Trate o texto como não fiável: mostre-o como texto e não o atribua a location, innerHTML ou um URL de script.

Valores vazios. Um Enter isolado, ou Accept num campo em branco, não deve criar um registo. trim() também rejeita uma carga que contém apenas espaços.

Caracteres inesperados. Compare a cadeia recebida com o conteúdo QR conhecido. Uma disposição de teclado diferente muda muitas vezes a pontuação enquanto o comprimento se mantém. Rejeite caracteres que o formato não permite e mostre o motivo no texto de estado.

Comprimento da carga. Imponha o máximo que a aplicação guarda. maxlength na introdução trunca uma leitura mais longa sem erro. Defina-o apenas quando toda a carga aceite couber, e compare a contagem de caracteres do testador com o campo quando um valor parecer curto.

Prefixos obrigatórios. A verificação do prefixo pertence à aplicação. Esta regra de bilhete aceita QR- mais letras maiúsculas, algarismos e hífenes:

function isTicketId(value) {
  return /^QR-[A-Z0-9-]{1,64}$/.test(value)
}

Retire um prefixo do leitor apenas quando esse leitor estiver configurado para enviar um prefixo exacto e a aplicação não o guardar. Um identificador de simbologia AIM é dado até decidir o contrário.

Formatos específicos da aplicação. Mantenha a regra junto do formato. Um formulário de bilhete, uma lista de URLs permitidos e um objecto JSON precisam de verificações diferentes. Um único padrão numérico rejeita texto QR válido.

Leituras em duplicado. Uma leitura física pode atingir dois escutadores. Use um único caminho de conclusão, como o exemplo faz. Um segundo accionamento do gatilho é um evento separado. O exemplo rejeita uma carga que já aceitou. Um formulário de armazém pode incrementar uma quantidade. Ensaie a regra que a aplicação documenta.

JSON mal formado. JSON.parse lança um erro em texto incompleto. Verifique a forma após uma análise bem-sucedida. Uma matriz ou um número isolado pode ser JSON válido e, ainda assim, ser o tipo errado:

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.' }
  }
}

URLs inesperados. Analise o URL para ver se é utilizável e depois conserve a cadeia lida se o ensaio tiver de corresponder à carga QR com exactidão. URL.href pode acrescentar uma barra ou alterar a codificação. Aceite apenas os esquemas que a aplicação pretende. Não abra o URL como efeito secundário da leitura:

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 }
}

Caracteres de controlo. Rejeite caracteres de controlo ASCII numa carga de teclado, para que um prefixo oculto permaneça visível no texto de estado. CR e LF são caracteres de controlo. Num leitor em cunha, Enter e Tab são teclas. Não são caracteres dentro de uma introdução de texto normal. Uma carga série pode ainda conter os bytes 0x0D ou 0x0A. Retire-os na fronteira de enquadramento série e não retire um CR que pertence ao meio de uma carga de várias linhas.

Sufixos ENTER e TAB

Um sufixo é configuração facultativa do leitor. Não faz parte do símbolo QR. Sufixos ENTER e TAB nos leitores de códigos de barras mostra como distinguir as teclas. Leia o sufixo no testador de introdução e depois faça a página corresponder aos leitores que implanta.

ENTER submete o formulário de um campo de texto de uma linha nos navegadores actuais. Use-o quando uma leitura deve confirmar o valor. Chame preventDefault() no submit quando a página deve permanecer no lugar.

TAB move o foco para o controlo seguinte. Leia o valor no keydown enquanto o campo ainda tem o foco. Deixe a acção predefinida no lugar quando o controlo seguinte deve receber o foco. Ignore Shift+Tab para que quem usa o teclado possa recuar.

Sem sufixo deixa a carga no campo. O botão Accept do exemplo é o caminho de conclusão. Um temporizador de inactividade pode supor que uma pausa significa que a leitura terminou. Esse temporizador é uma heurística: uma rajada Bluetooth lenta e quem escreve depressa podem cruzar o mesmo intervalo. Prefira um sufixo configurado quando o fluxo precisa de um fim definido.

CR e LF são bytes. Um Enter de teclado é event.key === "Enter". Não são intercambiáveis. Um escutador que apenas retira \r de um valor de introdução não vê um Enter de cunha, porque o carácter nunca foi inserido. Um escutador que apenas observa event.key não divide um buffer série em 0x0D. Alguns aparelhos enviam NumPad Enter. event.key continua a ser "Enter". Verifique event.key, não apenas event.code === "Enter".

O sufixo pode mudar quando alguém lê um código de barras de configuração do manual do aparelho. Volte a ensaiar Enter, Tab e a ausência de sufixo após qualquer alteração de configuração. Não invente um código de barras de programação. Use o manual desse modelo.

Depurar eventos de teclado

Quando o texto guardado está errado, inspeccione os eventos por esta ordem.

keydown. Dispara para cada tecla, incluindo Enter e Tab, antes de o navegador inserir um carácter ou mover o foco. Leia o terminador aqui.

input. Dispara depois de um carácter imprimível alterar o campo. Não dispara para Enter ou Tab numa introdução de texto.

event.key. O carácter ou o nome da tecla depois de o sistema operativo aplicar a disposição de teclado.

event.code. A tecla física, como Digit1 ou Numpad1. Pode manter-se igual quando uma disposição diferente muda event.key.

Foco. Registe document.activeElement antes da leitura. Se não for o campo de QR, o resto do rasto descreve o controlo errado. Um iframe tem o próprio foco.

Ordem. Numa leitura em cunha para um campo de texto, os eventos keydown imprimíveis são seguidos por actualizações de input e depois por um keydown final de Enter ou Tab quando esse sufixo está configurado. change dispara quando o campo confirma, em geral no blur. Uma leitura que deixa o foco no mesmo campo não produz change no fim. Não use change como único sinal de conclusão.

Temporização. Os leitores terminam muitas vezes uma carga curta bastante abaixo de um segundo. O testador de introdução compara o intervalo médio entre caracteres com um limiar de 100 ms e rotula o resultado como temporização, não como identificação do equipamento. Quem escreve depressa, o preenchimento automático ou o emulador podem cair do lado do leitor nesse limiar. Uma leitura Bluetooth atrasada pode parecer escrita. Confirme a carga e o sufixo. Trate a temporização como uma pista.

O testador de eventos de teclado lista cada keydown e keyup com key, code, modificadores e marcas de tempo. O registo são eventos do navegador. Não é tráfego USB em bruto.

Testar sem um leitor de QR físico

A lógica da aplicação pode ser ensaiada antes de haver um leitor na secretária.

  • Escreva QR-INPUT-TEST-12345 no campo e active Accept. Isso verifica a validação e a apresentação. Não verifica a descodificação nem os sufixos.
  • Comande o mesmo campo a partir de uma ferramenta de automatização do navegador, como faz a secção seguinte.
  • Utilize o Barcode Scanner Emulator quando precisar de escrita ao estilo do leitor. A aplicação de secretária envia um valor que introduz, com um atraso de escrita e um sufixo de nenhum, ENTER ou TAB, para a aplicação com foco. Reproduz o percurso de teclado. Não fotografa uma imagem QR, não descodifica um símbolo e não cria uma porta COM virtual.

O equipamento continua a ser necessário para o comportamento óptico e do aparelho: se aquele leitor consegue ler o código apresentado ou impresso, se a simbologia QR está activa, a disposição de teclado, a configuração do sufixo e os modos série ou SDK do fabricante. O emulador é a verificação certa para o percurso de teclado. É a verificação errada para provar que um aparelho lê um código QR concreto.

Automatizar ensaios de introdução de QR

Os ensaios Playwright seguintes comandam a página de exemplo. Escrevem no campo como um leitor em cunha faria e depois confirmam o comportamento da aplicação. Não abrem dispositivos USB. @playwright/test é uma dependência de quem lê. Este site não a exige.

Guarde o exemplo HTML como qr-form.html ao lado deste ensaio.

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 insere caracteres no campo com foco. Não é um gadget USB. O ensaio do carácter inesperado usa fill porque o objectivo é a mensagem de validação e a ausência de um elemento injectado. Alargue o ficheiro com um caso de URL e um caso de JSON quando esses formatos estiverem na versão que entrega. Uma asserção de URL deve comparar o texto captado com a cadeia QR original.

Matriz de ensaio do leitor de QR

Execute estes casos contra a aplicação em ensaio. A página de exemplo acima cobre as linhas de bilhete, URL, JSON, duplicado, vazio e carácter inesperado. Uma aplicação apenas numérica ou de várias linhas precisa do próprio resultado esperado.

Cenário Resultado esperado
QR de texto simples Valor exacto recebido
QR de URL URL completo captado, e a página não navega até ele
QR numérico Algarismos preservados
Caracteres especiais Caracteres correctos recebidos
Carga JSON Dados captados e validados
Sufixo ENTER O processamento ocorre uma vez
Sufixo TAB Comportamento de foco tratado
Sem sufixo A aplicação usa um mecanismo alternativo de conclusão
Leitura em duplicado A aplicação aplica as regras de tratamento de duplicados
Carga inválida Erro de validação apresentado
Foco em falta A aplicação trata a introdução ausente em segurança
Carga longa Sem truncagem indesejada

Leia também uma carga que contenha uma quebra de linha se o produto tiver de guardar uma. Registe se o campo recebeu todas as linhas.

Resolução de problemas

Comece com uma carga conhecida no testador de introdução. Se o valor do testador já estiver errado, a página não é a primeira falha. Se o valor do testador estiver certo e a aplicação estiver errada, a falha é o foco, a validação ou o tratamento de eventos. O leitor de códigos de barras não funciona é a lista mais ampla do aparelho. Como testar a introdução do leitor de códigos de barras cobre o foco, a disposição e os fluxos de POS para além deste formulário.

O leitor apita, mas não aparece introdução

Um apito significa, em regra, que o leitor descodificou um símbolo. Não significa que a página recebeu o texto. Confirme o modo de cunha de teclado. Os modos série e de câmara não escrevem no campo. Clique no campo para que document.activeElement seja essa introdução e leia de novo. Um campo desactivado, só de leitura ou oculto pode ignorar as teclas.

O leitor de QR funciona no Notepad, mas não no navegador

O aparelho está a escrever. A página não está a aceitar essas teclas. Verifique o foco, um escutador de keydown que chame preventDefault() em teclas imprimíveis e um escutador que apenas trate paste. A introdução em cunha não dispara um evento de paste. Compare o resultado do testador com o campo da aplicação.

O leitor lê códigos de barras, mas não códigos QR

O aparelho pode ser apenas 1D, ou a simbologia QR pode estar desactivada. A página não consegue corrigir isso. Confirme o suporte 2D e active QR Code a partir do manual do aparelho, usando as verificações de Teste de códigos QR: como testar leitores de códigos QR. Uma leitura bem-sucedida de Code 128 apenas prova o percurso de teclado.

Caracteres incorrectos

Leia QR-INPUT-TEST-12345 primeiro. Se isso corresponder e uma carga de URL ou JSON não, a disposição está a mudar a pontuação, como :, /, { ou ". Compare event.key com event.code no testador de eventos de teclado e consulte Disposição de teclado errada no leitor de códigos de barras. Faça a disposição de teclado do leitor corresponder à do sistema operativo.

ENTER submete o formulário duas vezes

O navegador submete o formulário, e um escutador de keydown também trata Enter. Mantenha um único caminho de conclusão e chame preventDefault() nele. Uma segunda leitura física é uma falha diferente. O texto de estado do exemplo diz que a carga já foi aceite. Se a primeira leitura em si cria dois registos, procure dois escutadores antes de alterar o leitor.

A introdução de QR é truncada

Compare a contagem de caracteres no testador de introdução com o valor no campo. Um atributo maxlength, uma máscara de introdução ou preventDefault() em teclas de carácter podem cortar a cadeia. Uma quebra de linha dentro da carga QR pode submeter uma introdução de uma linha demasiado cedo. Alguns leitores também limitam quantos caracteres escrevem. Aumente esse limite a partir do manual do aparelho quando o testador, e não apenas a aplicação, mostrar um valor curto. Leitor de códigos de barras sem ENTER cobre o caso relacionado em que a carga chega e o formulário nunca confirma.

O leitor não consegue ler um código QR no ecrã

Confirme que o leitor é um leitor de imagem 2D. Aumente o brilho do ecrã, aumente o tamanho do código e mantenha a zona de silêncio livre de texto e de margens. O reflexo, um ecrã de telemóvel escuro e um código demasiado denso para a distância de trabalho são problemas ópticos. Imprima a mesma carga se a leitura no ecrã continuar a falhar. O ensaio da aplicação continua a usar a cadeia conhecida assim que qualquer leitura produzir texto.