O que é o Teste de Integração de Sistema?
O Teste de Integração de Sistema é definido como um tipo de teste de software realizado em um ambiente integrado de hardware e software para verificar o comportamento de todo o sistema. É um teste conduzido em um sistema completo e integrado para avaliar a conformidade do sistema com seus requisitos especificados.
O Teste de Integração de Sistema (SIT) é executado para verificar as interações entre os módulos de um sistema de software. Ele lida com a 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.
Ele 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. Nesse tipo de teste, os módulos são testados primeiro individualmente e depois combinados para formar um sistema.
Por exemplo, os componentes de software e / ou hardware são combinados e testados progressivamente até que todo o sistema seja integrado.
Neste tutorial, você aprenderá-
- O que é o Teste de Integração de Sistema?
- Por que fazer o teste de integração do sistema?
- Como fazer o teste de integração do sistema
- Critérios de entrada e saída para teste de integração
- Teste de integração de hardware para software
- Teste de integração de software para software
- Abordagem de cima para baixo
- Abordagem de baixo para cima
- Abordagem Big Bang
Por que fazer o teste de integração do sistema?
Em Engenharia de Software, o Teste de Integração de Sistema é feito porque,
- Ajuda a detectar defeitos precocemente
- O feedback anterior sobre a aceitabilidade do módulo individual estará disponível
- A programação de correções de defeitos é flexível e pode ser sobreposta ao desenvolvimento
- Fluxo de dados correto
- Fluxo de controle correto
- Tempo correto
- Uso correto de memória
- Corrija com os requisitos de software
Como fazer o teste de integração do sistema
É 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. Porém, durante esse processo, é provável que um conjunto de erros seja encontrado.
A correção de tais erros é difícil porque as causas do isolamento são complicadas pela vasta expansão de todo o programa. Assim que esses erros forem retificados e corrigidos, um novo aparecerá e o processo continuará continuamente em um loop infinito . Para evitar essa situação, outra abordagem é usada, Integração Incremental. Veremos mais detalhes sobre uma abordagem incremental posteriormente no tutorial.
Existem alguns métodos incrementais, como os testes de integração realizados em um sistema baseado no processador de destino. A metodologia utilizada é o Black Box Testing. Pode-se usar a integração ascendente ou descendente.
Os casos de teste são definidos usando apenas os requisitos de software de alto nível.
A integração do software também pode ser alcançada amplamente no ambiente do host, com unidades específicas para o ambiente de destino continuando a ser simuladas no host. Será 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 a integração de software no ambiente host dependerá de quanta funcionalidade específica de destino existe. Para alguns sistemas embarcados, o acoplamento com o ambiente de destino será muito forte, tornando impraticável conduzir a integração do software no ambiente do host.
Os 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 podem ser baseados predominantemente no ambiente de host, com os níveis posteriores de integração de software se tornando mais dependentes do ambiente de destino.
Nota: Se apenas o software está sendo testado, ele é chamado de Teste de integração de software de software [SSIT] e se o hardware e o software estão sendo testados, ele é chamado de Teste de integração de software de hardware [HSIT].
Critérios de entrada e saída para teste de integração
Normalmente, durante a execução do teste 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:
- Conclusão do Teste de Unidade
Entradas:
- Dados de requisitos de software
- Documento de Design 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 construção
- Depois que o teste é aprovado, o build é combinado com outros builds e testado até que o sistema seja integrado como um todo.
- Reexecute todos os testes na plataforma baseada no processador de destino e obtenha os resultados
Critério de saída:
- Conclusão bem-sucedida da integração do módulo de software no hardware de destino
- 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
O 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 do teste de integração de hardware / software é testar o comportamento do software desenvolvido integrado no componente de hardware.
Teste de integração de hardware-software baseado em requisitos
O objetivo do teste de integração de hardware / software baseado em requisitos é certificar-se de que o software no computador de destino satisfará os requisitos de alto nível. Os erros típicos revelados por este método de teste incluem:
- Erros de interface 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
- O feedback bloqueia o 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 exatidão do software carregável em campo
Integração de software de hardware lida com a verificação dos requisitos de alto nível. Todos os testes neste nível são conduzidos no hardware de destino.
- O teste de caixa preta é a metodologia de teste primária usada neste nível de teste.
- Defina casos de teste apenas a partir dos requisitos de alto nível
- Um teste deve ser executado no hardware padrão de produção (no destino)
Coisas a considerar ao projetar casos de teste para integração HW / SW
- Aquisição correta de todos os dados pelo software
- Escala e intervalo de dados conforme esperado de hardware para software
- Saída correta de dados do software para o hardware
- Dados dentro das especificações (faixa normal)
- Dados fora das especificações (faixa anormal)
- Dados de limite
- Interrompe o processamento
- Tempo
- Uso correto da memória (endereçamento, sobreposições, etc.)
- Transições de estado
Nota: Para o teste de interrupção, todas as interrupções serão verificadas independentemente da solicitação inicial por meio do serviço completo e até a conclusão. Os casos de teste serão projetados especificamente para testar as interrupções de forma adequada.
Teste de integração de software para software
É o teste do componente de software do computador operando no computador host / destino
Ambiente, enquanto simula 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 / destino 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. Nesse tipo de método de teste, você primeiro testa cada módulo do software individualmente e, em seguida, continua o teste anexando outros módulos a ele, depois outro e assim por diante.
A integração incremental é o contraste 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ática 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, em seguida, você move para baixo integrando as camadas inferior e inferior, conforme mostrado na imagem abaixo.
- Começando com o módulo de controle principal, os módulos são integrados movendo-se para baixo através da hierarquia de controle
- Os submódulos do módulo de controle principal são incorporados à estrutura de maneira ampla ou profunda.
- A integração em profundidade integra todos os módulos em um caminho de controle principal da estrutura, conforme exibido no diagrama a seguir:
O processo de integração do módulo é feito da seguinte maneira:
- O módulo de controle principal é usado como um driver de teste e os stubs são substituídos por todos os módulos diretamente subordinados ao módulo de controle principal.
- Os stubs subordinados são substituídos um de cada vez pelos módulos reais, dependendo da abordagem selecionada (largura primeiro ou profundidade primeiro).
- Os testes são executados à medida que cada módulo é integrado.
- Na conclusão de cada conjunto de testes, outro esboço é substituído por um módulo real na conclusão de cada conjunto de testes
- Para certificar-se de que novos erros não foram introduzidos, o Teste de Regressão pode ser executado.
O processo continua a partir da etapa 2 até que toda a estrutura do programa seja construída. A estratégia de cima para baixo parece relativamente descomplicada, mas, na prática, surgem problemas logísticos.
O mais comum desses problemas ocorre quando o processamento em níveis baixos da 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 de cima para baixo 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 executam funções limitadas que simulam o módulo real.
- Integre o software da base da hierarquia para cima.
Nota: A primeira abordagem nos faz perder algum controle sobre a correspondência entre testes específicos e incorporação de módulos específicos. Isso 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 uma sobrecarga significativa, pois os stubs se tornam cada vez mais complexos.
Abordagem de baixo para cima
A integração ascendente começa a construção e o teste com módulos no nível mais baixo na estrutura do programa. Nesse 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
- Módulos de baixo nível são combinados em clusters que executam uma subfunção de software específica.
- Um driver é escrito para coordenar a entrada e a saída do caso de teste.
- O cluster ou construção é testado.
- Os drivers são removidos e os clusters são combinados, movendo-se para cima na estrutura do programa.
À medida que a integração avança, a necessidade de aulas separadas para os testadores. Na verdade, se os dois níveis superiores da estrutura do programa forem integrados de cima para baixo, o número de drivers pode ser reduzido substancialmente e a integração de clusters é bastante simplificada. A integração segue o padrão ilustrado abaixo. À medida que a integração avança, a necessidade de aulas separadas para os testadores.
Nota: Se os dois níveis superiores da estrutura do programa forem integrados de cima para baixo, o número de drivers pode ser reduzido substancialmente e a integração de compilações é bastante simplificada.
Abordagem Big Bang
Nessa abordagem, todos os módulos não são integrados até e a menos que todos os módulos estejam prontos. Uma vez prontos, todos os módulos são integrados e depois executados para saber se todos os módulos integrados estão funcionando ou não.
Nessa 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.
Essa abordagem é adotada apenas quando o teste de integração deve ser feito de uma vez.
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 de hardware-software ou hardware-hardware
- O teste de integração é feito por dois métodos
- Abordagem incremental
- Abordagem big bang
- Durante a execução do Teste de Integração, geralmente a estratégia ETVX (Critérios de entrada, tarefa, validação e critérios de saída) é usada.