O que é um exemplo de teste de integração de sistema (SIT)

O que é teste de integração de sistema?

System Teste de integração é definido como um tipo de teste de software realizado em um ambiente integrado de hardware e software para verificar o comportamento do sistema completo. São testes realizados em um sistema completo e integrado para avaliar a conformidade do sistema com seus requisitos especificados.

O Teste de Integração de Sistemas (SIT) é realizado para verificar as interações entre os módulos de um sistema de software. Ele trata da verificação dos requisitos de software de alto e baixo nível especificados na Especificação/Dados de Requisitos de Software e no Documento de Design de Software. Também verifica a coexistência de um sistema de software com outros e testa a interface entre os módulos do aplicativo de software. Neste tipo de teste, os módulos são primeiro testados individualmente e depois combinados para formar um sistema. Por exemplo, componentes de software e/ou hardware são combinados e testados progressivamente até que todo o sistema esteja integrado.

Teste de INTEGRAÇÃO de Sistema (SIT): Tutorial Completo

Por que fazer testes de integração de sistemas?

Na Engenharia de Software, o Teste de Integração de Sistemas é feito porque,

  • Ajuda a detectar Defeito cedo
  • Feedback anterior sobre a aceitabilidade do módulo individual estará disponível
  • O agendamento de correções de defeitos é flexível e pode ser sobreposto ao desenvolvimento
  • Fluxo de dados correto
  • Fluxo de controle correto
  • Tempo correto
  • Uso correto de memória
  • Correto com os requisitos de software

Como fazer testes de integração de sistemas

É uma técnica sistemática para construir a estrutura do programa durante a realização de testes para descobrir erros associados à interface.

Todos os módulos são integrados antecipadamente e todo o programa é testado como um todo. Mas durante esse processo, é provável que um conjunto de erros seja encontrado.

A correção de tais erros é difícil porque o isolamento das causas é complicado pela vasta expansão de todo o programa. Assim que esses erros forem corrigidos e corrigidos, um novo aparecerá e o processo continuará perfeitamente em um loop infinito.. Para evitar esta situação, outra abordagem é utilizada, a Integração Incremental. Veremos mais detalhes sobre uma abordagem incremental later no tutorial.

Existem alguns métodos incrementais, como os testes de integração conduzidos em um sistema baseado no processador de destino. A metodologia utilizada é Preto Box ensaio. Tanto a integração de baixo para cima quanto de cima para baixo podem ser usadas.

Os casos de teste são definidos usando apenas requisitos de software de alto nível.

A integração de software também pode ser alcançada em grande parte no ambiente host, com unidades específicas do ambiente alvo continuando a ser simuladas no host. Será novamente necessário repetir os testes no ambiente de destino para confirmação.

Os testes de confirmação neste nível identificarão problemas específicos do ambiente, como erros na alocação e desalocação de memória. A praticidade de conduzir integração de software no ambiente host dependerá de quanta funcionalidade específica do destino existe. Para alguns sistemas embarcados, o acoplamento com o ambiente alvo será muito forte, tornando impraticável conduzir a integração de software no ambiente host.

Grandes desenvolvimentos de software dividirão a integração de software em vários níveis. Os níveis mais baixos de integração de software poderiam ser baseados predominantemente no ambiente host, com later níveis de integração de software se tornando mais dependentes do ambiente de destino.

Nota: Se apenas o software estiver sendo testado, ele será chamado de Teste de Integração de Software de Software [SSIT] e se tanto o hardware quanto o software estiverem sendo testados, será chamado de Teste de Integração de Software de Hardware [HSIT].

Critérios de entrada e saída para testes de integração

Normalmente, ao realizar testes de integração, a estratégia ETVX (critérios de entrada, tarefa, validação e critérios de saída) é usada.

Critério de entrada:

Entradas:

  • Dados de requisitos de software
  • Documento de Projeto de Software
  • Plano de Verificação de Software
  • Documentos de integração de software

Atividades:

  • Com base nos requisitos de alto e baixo nível, crie casos de teste e procedimentos
  • Combine compilações de módulos de baixo nível que implementam uma funcionalidade comum
  • Desenvolva um equipamento de teste
  • Teste a compilação
  • Depois que o teste é aprovado, a compilação é combinada com outras compilações e testada até que o sistema seja integrado como um todo.
  • Execute novamente todos os testes na plataforma baseada no processador de destino e obtenha os resultados

Critérios de Saída:

  • Conclusão bem sucedida da integração do módulo de Software no Hardware alvo
  • Desempenho correto do software de acordo com os requisitos especificados

Saídas

  • Relatórios de teste de integração
  • Casos e procedimentos de teste de software [SVCP].

Teste de integração de software de hardware

Teste de integração de software de hardware é um processo de teste de componentes de software de computador (CSC) para funcionalidades de alto nível no ambiente de hardware de destino. O objetivo dos testes de integração hardware/software é testar o comportamento do software desenvolvido integrado no componente de hardware.

Teste de integração hardware-software baseado em requisitos

O objetivo dos testes de integração de hardware/software baseados em requisitos é garantir que o software no computador de destino satisfaça os requisitos de alto nível. Erros típicos revelados por este método de teste incluem:

  • Erros de interfaces de hardware/software
  • Violações de particionamento de software.
  • Incapacidade de detectar falhas por teste integrado
  • Resposta incorreta a falhas de hardware
  • Erro devido ao sequenciamento, cargas de entrada transitórias e transientes de potência de entrada
  • Feedback faz loops de comportamento incorreto
  • Controle incorreto ou impróprio do hardware de gerenciamento de memória
  • Problema de contenção de barramento de dados
  • Operação incorreta do mecanismo para verificar a compatibilidade e correção do software carregável em campo

A integração de software de hardware trata da verificação dos requisitos de alto nível. Todos os testes neste nível são realizados no hardware alvo.

  • Preto box teste é a principal metodologia de teste usada neste nível de teste.
  • Definir casos de teste apenas dos requisitos de alto nível
  • Um teste deve ser executado em hardware padrão de produção (no alvo)

Coisas a considerar ao projetar casos de teste para integração HW/SW

  • Aquisição correta de todos os dados pelo software
  • Dimensionamento e variedade de dados conforme esperado de hardware para software
  • Saída correta de dados de software para hardware
  • Dados dentro das especificações (faixa normal)
  • Dados fora das especificações (faixa anormal)
  • Dados de limite
  • Interrompe o processamento
  • Cronometragem
  • Uso correto da memória (endereçamento, sobreposições, etc.)
  • Transições de estado

Nota: Para testes de interrupção, todas as interrupções serão verificadas independentemente da solicitação inicial, passando pelo serviço completo e até a conclusão. Os casos de teste serão projetados especificamente para testar adequadamente as interrupções.

Teste de integração de software para software

É o teste do componente de software do computador operando no computador host/destino

Ambiente, simulando todo o sistema [outros CSC's], e na funcionalidade de alto nível.

Ele se concentra no comportamento de um CSC em um ambiente host/alvo simulado. A abordagem usada para Integração de Software pode ser uma abordagem incremental (de cima para baixo, de baixo para cima ou uma combinação de ambas).

Abordagem Incremental

O teste incremental é uma forma de teste de integração. Neste tipo de método de teste, você primeiro testa cada módulo do software individualmente e depois continua o teste anexando outros módulos a ele, depois outro e assim por diante.

A integração incremental contrasta com a abordagem do big bang. O programa é construído e testado em pequenos segmentos, onde os erros são mais fáceis de isolar e corrigir. É mais provável que as interfaces sejam testadas completamente e uma abordagem de teste sistemático pode ser aplicada.

Existem dois tipos de teste incremental

  • Abordagem de cima para baixo
  • Abordagem de baixo para cima

Abordagem de cima para baixo

Nesse tipo de abordagem, o indivíduo começa testando apenas a interface do usuário, com a funcionalidade subjacente simulada por stubs, depois avança para baixo integrando as camadas cada vez mais baixas, conforme mostrado na imagem abaixo.

Teste de INTEGRAÇÃO de Sistema (SIT): Tutorial Completo

  • Começando com o módulo de controle principal, os módulos são integrados movendo-se para baixo na hierarquia de controle
  • Os submódulos do módulo de controle principal são incorporados à estrutura, seja em largura ou em profundidade.
  • A integração em profundidade integra todos os módulos em um caminho de controle principal da estrutura, conforme exibido a seguirwing diagrama:

Teste de INTEGRAÇÃO de Sistema (SIT): Tutorial Completo

O processo de integração do módulo é feito a seguirwing maneiras:

  1. O módulo de controle principal é usado como driver de teste e os stubs são substituídos por todos os módulos diretamente subordinados ao módulo de controle principal.
  2. Os stubs subordinados são substituídos um de cada vez por módulos reais, dependendo da abordagem selecionada (largura primeiro ou profundidade primeiro).
  3. Os testes são executados à medida que cada módulo é integrado.
  4. Após a conclusão de cada conjunto de testes, outro stub é substituído por um módulo real na conclusão de cada conjunto de testes.
  5. Para garantir que novos erros não foram introduzidos Teste de regressão pode ser executado.

O processo continua da etapa 2 até que toda a estrutura do programa seja construída. A estratégia de cima para baixo parece relativamente simples, mas na prática surgem problemas logísticos.

O mais comum desses problemas ocorre quando o processamento em níveis inferiores na hierarquia é necessário para testar adequadamente os níveis superiores.

Os stubs substituem os módulos de baixo nível no início do teste descendente e, portanto, nenhum dado significativo pode fluir para cima na estrutura do programa.

Desafios que o testador pode enfrentar:

  • Atrase muitos testes até que os stubs sejam substituídos por módulos reais.
  • Desenvolva stubs que executem funções limitadas que simulem o módulo real.
  • Integre o software da parte inferior da hierarquia para cima.

Nota: A primeira abordagem faz com que percamos algum controle sobre a correspondência entre testes específicos e a incorporação de módulos específicos. Isto pode resultar em dificuldade em determinar a causa dos erros, o que tende a violar a natureza altamente restrita da abordagem de cima para baixo.

A segunda abordagem é viável, mas pode levar a sobrecargas significativas, à medida que os stubs se tornam cada vez mais comuns.plex.

Abordagem de baixo para cima

A integração ascendente inicia a construção e os testes com módulos no nível mais baixo da estrutura do programa. Neste processo, os módulos são integrados de baixo para cima.

Nesta abordagem o processamento necessário para os módulos subordinados a um determinado nível está sempre disponível e a necessidade de stubs é eliminada.

Este processo de teste de integração é realizado em uma série de quatro etapas

  1. Módulos de baixo nível são combinados em clusters que executam uma subfunção específica de software.
  2. Um driver é escrito para coordenar a entrada e a saída do caso de teste.
  3. O cluster ou build é testado.
  4. Os drivers são removidos e os clusters são combinados subindo na estrutura do programa.

À medida que a integração avança, aumenta a necessidade de aulas separadas de pilotos de teste. Na verdade, se os dois níveis superiores da estrutura do programa forem integrados de cima para baixo, o número de impulsionadores pode ser reduzido substancialmente e a integração dos clusters é bastante simplificada. A integração segue o padrão ilustrado abaixo. À medida que a integração avança, aumenta a necessidade de aulas separadas de pilotos de teste.

Teste de INTEGRAÇÃO de Sistema (SIT): Tutorial Completo

Nota: Se os dois níveis superiores da estrutura do programa forem integrados de cima para baixo, o número de impulsionadores pode ser reduzido substancialmente e a integração das compilações é bastante simplificada.

Abordagem do Big Bang

Nesta abordagem, todos os módulos não são integrados até e a menos que todos os módulos estejam prontos. Depois de prontos, todos os módulos são integrados e então executados para saber se todos os módulos integrados estão funcionando ou não.

Nesta abordagem, é difícil saber a causa raiz da falha devido à integração de tudo de uma vez.

Além disso, haverá uma grande chance de ocorrência de bugs críticos no ambiente de produção.

Esta abordagem é adotada apenas quando o teste de integração precisa ser feito imediatamente.

Resumo:

  • A integração é realizada para verificar as interações entre os módulos de um sistema de software. Ajuda a detectar defeitos precocemente
  • O teste de integração pode ser feito para integração Hardware-Software ou Integração Hardware-Hardware
  • O teste de integração é feito por dois métodos
    • Abordagem incremental
    • Abordagem do Big Bang
  • Ao realizar testes de integração, geralmente a estratégia ETVX (critérios de entrada, tarefa, validação e critérios de saída) é usada.