---
# System prepended metadata

title: 'Assignment #3'

---

![](https://i.imgur.com/r2Upi0M.png)

## Verificação e Validação de Software

### Professor: 
José Campos

### Alunos:
João Lopes      nº55812
Filipe Martins  nº55814

# Assignment #3

Este assignment passa pela realização de testes Boundary Value Analysis(BVA), sendo estes testes do tipo *Black-Box Testing*, para tal tivemos de identificar 3 funções do projeto Jpass.

O Boundary Value Analysis passa por construir partições para os inputs de uma função e testar os limites dessas mesmas partições.

Para a realização dos testes unitários utilizamos a ferramente JUnit, que é uma das ferramentas mais utilizadas na criação de testes unitários para Java.

Neste assignment consta uma breve explicação da função a ser testada, como foi utilizada a BVA e quais os testes a realizar para a mesma, e por fim uma explicação dos testes desenvolvidos e também os resultados obtidos.



## Função - 1

Esta função tem como objetivo cortar uma string com mais de x caracteres e retornar uma string. A função recebe uma string como argumento e um número que ira servir para limite de carateres, a função ira depois verificar se a string tem ou não um número de caracteres superior ao que foi passado como parâmetro. Caso seja superior a mesma ira ser cortada e todos os caracteres depois do limite irão serão substituídos por '...' caso contrário é devolvida a string por inteiro.
  
```
public static String stripString(String text, int length) {
        String result = text;
        if (text != null && text.length() > length) {
            result = text.substring(0, length) + "...";
        }
        return result;
    }
```

**Boundary Value Analysis**

Para a seguinte função vamos contruir um limite para o parâmetro `int`, visto que não existe nenhum tipo de documentação tivemos que ser nós a definir os limites. Como tal, para a função estabelecemos um limite de 0 a 10. Este limite será utlizado para cortar a string. Para os testes, estes limites devem ser testados com um número igual ao limite e, se possível,um número superior e inferior, sendo estes os numeros diretamente acima e abaixo do limite (ex. limite = 10, superior = 11, inferior = 9).A string será testada com 11 caracteres para todos os testes. No entanto temos que alargar os testes feitos à string pois tem que existir a separação de string constituída por caracteres, números e ambos (caracteres e números).

**Limite 0:**
Para o limite 0, iremos testar os valores 0 e 1.


* `String` de caracteres com tamanho igual a 11:
    * Limite igual a 0.
    * Limite superior a 0 (limite = 1).

* `String` de números com tamanho igual a 11:
    * Limite igual a 0.
    * Limite superior a 0 (limite = 1).

* `String` de caracteres e de números com tamanho igual a 11:
    * Limite igual a 0.
    * Limite superior a 0 (limite = 1).

**Limite 10:**
Os testes devem ser repetidos para o limite 10, no entanto estes testes diferem, pois agora é possível testar para um número inferior ao limite. Como tal iremos utilizar os valores 9, 10 e 11.

* `String` de caracteres com tamanho igual a 11:
    * Limite igual a 10.
    * Limite superior a 10 (limite = 11).
    * Limite inferior a 10 (limite = 9).

* `String` de números com tamanho igual a 11:
    * Limite igual a 10.
    * Limite superior a 10 (limite = 11).
    * Limite inferior a 10 (limite = 9).

* `String` de caracteres e de números com tamanho igual a 11:
    * Limite igual a 10.
    * Limite superior a 10 (limite = 11).
    * Limite inferior a 10 (limite = 9).


**Testes Unitários**

Para o primeiro caso da boundary value analysis, temos o limite 0. Como tal temos de testar o limite com os valores 0 e 1 para todas as condições da string. Os testes para esta categoria passam por realizar 6 métodos diferentes que cobrem todas as condições:
* 3 funções teste com o limite a 0 e com as 3 condições que foram estabelecidas para a `String`, só números, só com caracteres e com caracteres e números. 
* 3 funções teste com o limite a 1 para as diferentes condições da `String`. 

Todos os testes deram positivo, pelo que o resultado esperado foi cumprido.

Para o segundo caso da boundary value analysis, temos o limite 10. Como tal temos de testar o limite com os valores 10, 9 e 11. Para todos estes valores temos que repetir novamente todas as condições da string.

Para tal foram feitos 9 testes:
* 3 funções teste com o limite a 9 e com as 3 condições que foram estabelecidas para a string, só números, só com caracteres e com caracteres e números. 
* 3 funções teste com o limite a 10 para as diferentes condições da string. 
* 3 funções teste com o limite a 11 para as diferentes condições da string. 

Todos os testes deram positivo, pelo que o resultado esperado é cumprido.
Visto que todos os testes para ambos os limites deram positivos, podemos assumir que esta função passa nos testes boundary value analysis.



## Função - 2

Esta função escolhida para realizar os testes é a função `setClipboardContent(String str)`, esta função tem como objetivo receber uma string e definir a mesma no *System ClipBoard*.

```
public static void setClipboardContent(String str) throws Exception {
        if (str == null || str.isEmpty()) {
            clearClipboardContent();
            return;
        }
        try {
            StringSelection selection = new StringSelection(str);
            Toolkit.getDefaultToolkit().getSystemClipboard().setContents(selection, selection);
        } catch (Throwable throwable) {
            throw new Exception("Cannot set clipboard content.");
        }
    }
```

**Boundary Value Analysis**

Nesta função temos só um input, que é uma string. Em termos de documentação, esta não existe, não tendo uma definição clara dos limites do input recebido.
De modo a representar a *boundary value analysis* criamos duas partições:
1. A `String` tem de ter um tamanho maior que 0.
2. Os caracteres da string têm de ser imprimíveis, ou seja, têm de estar dentro do intervalo de valores onde os caracteres imprimíveis se encontram.

Começando pela primeira partição, conseguimos identificar que o *on-point* é o valor 0, ou seja, uma string com tamanho 0, e que o *off-point* é 1.
Desta forma ficamos com os *out-points* como todos os valores menores que 0, e os *in-points* como todos os valores maiores que 1.

Assim chegamos aos seguintes testes:
* `String` com tamanho 0.
* `String` com tamanho 1.

![](https://i.imgur.com/iIFsUZn.png)

Na segunda partição verificamos que como os caracteres têm de estar dentro de um dado intervalo de `char`.
Assim identificamos os dois limites, neste caso os caracteres têm de ser maiores ou iguais a 32 e menores ou iguais a 127.

No primeiro limite verificamos que o *on-point* é o valor 32 e que o *off-point* é 31, tendo como *in-points* os valores maiores que 32 e os *out-points* valores menores que 32.

Assim obtemos os seguintes testes:

* `String` com caracteres com valor decimal igual a 31.
* `String` com caracteres com valor decimal igual a 32.

No segundo limite o *on-point* é o valor 127 e o *off-point* o valor 128, sendo os *in-points* valores menores que 127 e os *out-points* valores maiores que 127.

Desta forma obtemos os dois últimos testes:


* `String` com caracteres com valor decimal igual a 127.
* `String` com caracteres com valor decimal igual a 128.

![](https://i.imgur.com/HMyfLKp.png)

**Testes Unitários**

Passando para os testes, começando pela primeira partição, temos o teste relativo ao tamanho da string ser igual a zero, visto que este tamanho foi considerado invalido, na teoria é previsto que resultado do seu teste seja negativo. Após a realização do mesmo conseguimos comprovar a suposição, tendo o valor do teste retornado null e não definido o *clipboard* com uma string vazia.

No segundo teste, que era relativo ao tamanho da string ser igual a 1, já esperaríamos um valor no *clipboard*, visto que este tamanho já é valido. Conseguimos então, depois da realização do teste, confirmar que realmente este tamanho é valido, e então é definido o *clipboard* com o valor fornecido como input com um tamanho igual a 1. 


Já na segunda partição, começando por testar o primeiro limite, cujo *in-point* era 32 e o *off-point* 31, verificamos que, ainda que na teoria o teste que continha caracteres com o valor decimal igual a 31 não deveria definir o *clipboard*, o mesmo acontece, ou seja, a função não verifica se está ou não a adicionar uma string que contém caracteres não imprimíveis. No teste relativo à string que contém caracteres com o valor decimal igual a 32, como foi previsto, o *clipboard* foi definido.

Por fim no segundo limite sucedeu-se o mesmo que no primeiro, na teoria o teste com a string que continha caracteres com o valor decimal igual a 128 não deveria definir o *clipboard*, mas o mesmo sucede-se. No teste com a string que continha caracteres com o valor decimal igual a 127, foi confirmado que o valor era valido e que o *clipboard* seria definido.

Após a realização dos testes chegamos a conclusão que nem todos os testes definidos inicialmente obtiveram o valor esperado, desta forma verificamos uma discordância entre os resultados obtidos e os resultados esperados.

## Função - 3

Esta função tem como propósito remover todos os caracteres XML que são invalidos, para tal é utilizado um *loop* pelos caracteres da string fornecida como parâmetro e é verificado se cada caracter é ou não inválido, utilizando o seu valor hexadecimal, caso o caracter não seja válido é substituído pelo caracter `'?'`.

```
 public static String stripNonValidXMLCharacters(final String in) {
        if (in == null || in.isEmpty()) {
            return in;
        }
        StringBuilder out = new StringBuilder();
        char current;
        for (int i = 0; i < in.length(); i++) {
            current = in.charAt(i);
            if ((current == 0x9) || (current == 0xA) || (current == 0xD)
                    || ((current >= 0x20) && (current <= 0xD7FF))
                    || ((current >= 0xE000) && (current <= 0xFFFD))) {
                out.append(current);
            } else {
                out.append('?');
            }
        }
        return out.toString();
    }
```

**Boundary Value Analysis**

Para esta função só temos uma string com input. Pela documentação apresentada, neste caso javadoc, o único limite percetível é a condição da string ser empty, null ou contrario, ou seja, uma string com caracteres.

De modo a representar a *boundary value analysis* criamos uma partição:
1. A `String` tem de ter um tamanho maior que 0.

![](https://i.imgur.com/iIFsUZn.png)


Relativamente à partição, temos o mesmo caso da função anterior.
Conseguimos identificar que o *on-point* é o valor 0, ou seja, uma string com tamanho 0, e que o *off-point* é 1.
Desta forma conseguimos identificar que os *out-points* são todos os valores menores que 0, e os *in-points* são todos os valores maiores que 1.

Assim chegamos aos seguintes testes:
* `String` com tamanho 0.
* `String` com tamanho 1.

**Testes unitários**

No primeiro teste o objetivo era verificar se a função conseguia ou não lidar com o parâmetro *null* ou empty, como podemos observar no javadoc apresentado conseguimos perceber que o resultado esperado seria uma empty string.

Como tal o primeiro teste passou pela criação de duas funções teste para ambas as condições da string:
* `String` empty.
* Valor null.

A primeira função deu o resultado esperado, onde introduzimos uma string empty e recebemos também uma string empty. 
No entanto o segundo teste não apresentou o resultado esperado. Para um input com o valor null, o resultado esperado é uma string empty, contudo o resultado apresentado foi o valor null.

O segundo teste passa por colocar uma string com pelo menos um caracter. Para tal foi feita uma função teste na qual foi testada uma string com um caracter valido.
 
Após a realização dos testes conseguimos verificar, que nem todos os testes  deram o resultado esperado, sendo que existe alguma discordância entre o resultado da função e o que está descrito na documentação.























