Pausa para café #87. Por que o teste unitário é importante para os desenvolvedores? 5 maneiras de copiar um array em Java

Por que o teste unitário é importante para os desenvolvedores?

Fonte: SearchSoftwareQuality Vamos discutir por que o teste de unidade é importante e valioso e como ele facilita a depuração. O teste unitário é uma ferramenta poderosa para melhorar a qualidade do software. Os testes de unidade fornecem verificação fundamental de que um aplicativo está em conformidade com as especificações do software e se comporta conforme planejado. Quando bem feito, testes de unidade:

• reduzir o número de defeitos e identificá-los nos estágios iniciais do ciclo de vida de desenvolvimento;
• melhorar a legibilidade do código;
• permitir a reutilização de código;
• aumentar a velocidade de implantação.

Vejamos por que o teste unitário é importante, como esse tipo de teste se originou e quais são as barreiras para sua implementação.

História dos testes unitários

Um erro detectado precocemente economiza tempo e esforço. Durante os primeiros 50 anos de história da computação, o teste unitário e a depuração eram essencialmente a mesma coisa. Mas na década de 1990, o código tornou-se tão complexo que muitas vezes era impossível dividir o sistema em pequenas partes para executá-las isoladamente. Em 1997, um programador chamado Kent Beck criou o JUnit, um plugin de ambiente de desenvolvimento para testar pequenos trechos de código. O código de teste que avalia o código-fonte é chamado de testes unitários. Esse tipo de teste unitário se tornou básico por muitos anos. Depois que Beck criou o JUnit, Martin Fowler escreveu um livro, Refactoring, no qual propôs maneiras de transformar o código para torná-lo mais isolado e testável. A combinação de refatoração de código e testes unitários levou ao desenvolvimento orientado a testes, onde a criação de testes unitários é essencial para o processo de programação. Nele, o código deve ser testável antes mesmo de ser criado. Assim, o processo de programação não é concluído até que os testes unitários sejam executados. O projeto pode então passar para a fase de pesquisa em nível de sistemas ou humano.

Exemplo de teste unitário

Este exemplo demonstra a importância dos testes unitários. Aqui o JUnit avalia uma função simples que converte a temperatura de Fahrenheit para Celsius. Fórmula de conversão: C = (F-32) * 5/9. Apenas algumas linhas, incluindo a assinatura da função e chaves, podem ser implementadas no código como uma função de biblioteca. No entanto, não fica claro na função que estes são critérios. Essas opções podem incluir arredondamento para cima ou para baixo, números reais ou limites superiores e inferiores. Vamos criar exemplos de testes de unidade para esta função de conversão de temperatura em Perl usando o módulo Test::More. A primeira linha é um comentário que informa ao programador o que esperar do código restante.

# is (input, expected result, comment)
is( FtoC(32),0,'Freezing point is F32, C 0');
is( FtoC(212),100,'Boiling point is F212, C 100');
is( FtoC(59038),32767, 'Upper limit of C is 32767');
is( FtoC(59039),undefined, 'One past upper limit is error');

A estrutura JUnit depende de sistemas orientados a objetos e objetos de teste, mas o conceito é semelhante.

Testes unitários isolados

Um dos benefícios dos testes unitários é que eles isolam uma função, classe ou método e testam apenas aquele trecho de código. Melhores componentes individuais proporcionam resiliência geral do sistema. Dessa forma, você obtém um código confiável. Os testes unitários também alteram a natureza do processo de depuração. Para tentar corrigir um bug, os programadores simplesmente escrevem um teste que falhou e depois o repetem para que ele passe sem violar as expectativas anteriores. Esse processo elimina o ciclo manual da depuração tradicional por meio de configuração, recriação, pausa e teste. Para alterar o código e torná-lo adequado para testes unitários, os programadores devem mudar a forma como trabalham. Quaisquer partes de código escritas sem testes unitários provavelmente serão consideradas não testadas, pelo menos como módulos individuais.

Adaptando testes unitários

Software legado é um software que está em execução há muito tempo e provavelmente foi escrito sem testes de unidade. O código legado tem valor para a empresa. Funciona de forma estável por muitos anos. Alguns programas desenvolvidos sem testes unitários processam transações de milhões de dólares por dia. Mas o código que não possui testes de unidade se transforma em uma grande bola de sujeira com o tempo, porque foi tocado por muitos programadores de manutenção de código ao longo dos anos. A refatoração permite que os programadores façam alterações gradualmente em um sistema para torná-lo testável. No entanto, essas mudanças levam tempo. Vários anos atrás, discuti com meu colega Bob Reselman a questão do uso de testes unitários para aplicações legadas. Reselman argumentou que implementar testes unitários em aplicações construídas sem eles é muito caro e até estúpido. Em vez disso, ele recomendou que a organização iniciasse um novo desenvolvimento com testes unitários e deixasse os aplicativos legados de lado. Isso pode ser verdade para COBOL, geradores de relatórios e outros aplicativos, mas eu diria que em aplicativos escritos em linguagens modernas — C++, C#, Java e Ruby — é muito fácil adicionar testes de unidade retroativamente. Em vez de escrevê-los para todo o aplicativo, basta adicionar testes de unidade à alteração atual e refatorar conforme você avança.

Maior velocidade, qualidade e testabilidade

Os gerentes de projeto dizem que o planejamento envolve compensações entre qualidade, quantidade de trabalho concluído, recursos e tempo. Para adicionar algo a uma área, você deve retirar algo de outra. Testes unitários eficazes quebram esta regra. É por isso que os testes unitários são importantes e valiosos para as organizações. Bons testes unitários produzem código testável que melhora a qualidade. Este código terá menos defeitos, o que significa menos correções de bugs para concluir o projeto mais rapidamente. Quando o software encontra bugs, os testes de unidade aceleram a depuração, correção e gravação de código. E isso acontece de tal forma que a probabilidade de recorrência de um defeito é significativamente reduzida, ao mesmo tempo que melhora a qualidade e a velocidade do código. Embora não exista uma solução mágica no desenvolvimento de software, testes de unidade eficazes podem acelerar o desenvolvimento, os testes e até mesmo parte da engenharia de requisitos funcionais.

5 maneiras de copiar um array em Java

Fonte: Dev.to Então você tem dois arrays A e B e precisa copiar os elementos de A para B. Bem, existem diferentes maneiras de fazer isso em Java e vou mostrá-las agora.

Método um: ForLoop

É aqui que o bom e velho loop for vem em nosso auxílio :

int[] A = {1,2,4,4};
int[] B = new int[];

 for (int i = 0; i < A.length; i++){
      B[i] = A[i];
}

Método dois: .clone()

O método de clonagem de array também pode ajudar a alcançar o resultado desejado:

int[] A = {1,2,4,4};
int[] B = A.clone();//the clone method copies the content of A into B;

Método três: System.arraycopy()

A próxima maneira é usar o método System.arraycopy() , que está no pacote java.lang . Antes de prosseguirmos com seu uso, vamos discutir sua assinatura:

public static void arraycopy(
    Object src, //:source array, in this case A
    int srcPos, //:the start index for copy, typically 0
    Object dest, //:destination object in this case B.
    int destPos, //:the index to place the copied elements
    int length //:the length of the contents to be copied
);

Aplicativo:

int[] A = {1,2,4,4};
int[] B = new int[];

System.arraycopy(A, 0, B, 0, A.length);

Método Quatro: Arrays.copyOf()

A próxima opção de cópia que discutiremos é a classe Arrays do pacote java.utils . Preste atenção na assinatura dele:

public static int[] copyOf(
    int[] original, // :source array in this case A
    int newLength // :the length of the contents to be copied
);

Aplicativo:

int[] A = {1,2,4,4};
int[] B = Arrays.copyOf(A, 3);

Método cinco: Arrays.copyOfRange()

Então, esta será a última opção que veremos neste post. Também é da classe Arrays presente no pacote java.utils . Vejamos sua assinatura novamente:

public static int[] copyOfRange​(
    int[] original, // :source array in this case A
    int from,  //:the start index for copy, typically 0
    int to // the end index exclusive
);

Aplicativo:

int[] A = {1,2,3,4,5,6,7};
int[] B = Arrays.copyOfRange(A, 0, A.length);