Pruebas de caja blanca

Pruebas de caja blanca
Prueba y Mantenimiento del Software
Alicia Bárbara Expósito Santana
23/04/2012
INDICE
1.- Introducción
3
2.- Pruebas
2.1.- Prueba del camino básico
4
· Gráfico de flujo
4
· Complejidad ciclomática
7
· Descripción de los caminos
9
1er camino
2º camino
3er camino
4º camino
5º camino
o 6º camino
o
o
o
o
o
2.2.- Prueba de condición
o
o
1era expresión
2ª expresión




o
Tabla 1
Tabla 2
Tabla 3
Tabla 4
3er expresión
2.3.- Prueba de bucles
10
11
12
13
14
15
18
19
20
21
22
23
24
25
3.- Conclusiones
27
2
1.- Introducción
Las pruebas de caja blanca, que sería mejor llamarlas de caja
transparente, se establecen por medio del diseño de casos que usan como
base las estructuras de control del flujo. Estas pruebas se pueden clasificar
en tres tipos según sus objetivos:
1. Que se ejecute por lo menos una vez cada instrucción del programa.
2. Garantizar que todas las condiciones se comprueban como
verdaderas y falsas.
3. Que se ejecuten los bucles, probando el caso general y los casos
extremos.
Para comprobar la ausencia de errores en el software haremos tres
pruebas.
La primera es la prueba del camino básico, que se basa en la
complejidad del flujo de ejecución desglosado en un conjunto básico de
caminos. Los casos en los que se divide la prueba, obtenidos en función
del conjunto básico, garantizan que se ejecuta por lo menos una vez cada
sentencia del programa.
La prueba de condiciones tiene como objetivo ejercitar
adecuadamente todas las condiciones del módulo para buscar errores que
puedan estar en variables lógicas, paréntesis, operadores relacionales o
expresiones lógicas.
Por último la prueba de bucles tiene como objetivo reducir la
posibilidad de que se pase por alto un error no encontrado en otro tipo de
prueba.
3
2.- Pruebas
2.1.- Prueba del camino básico
· Gráfico de flujo
Generar el gráfico de flujo indicando a qué zona del código
corresponde cada nodo.
El grafo del flujo representa los caminos de ejecución que se pueden
seguir en un procedimiento, módulo, etc. Es un grafo orientado en el que
los vértices representan instrucciones o conjuntos de instrucciones que se
ejecutan como una unidad, como por ejemplo, la asignación de valores a
variables, sentencias de control de iteración en bucles y sentencias de
comprobación de la iteración en estructuras de control, y las aristas
representan bifurcaciones en el flujo. Cada arista representa la posibilidad
de que una vez terminada la ejecución de un vértice se pase a ejecutar
otro.
El gráfico de flujo de ejecución del programa es el siguiente:
4
El gráfico de flujo se obtiene a partir de observar el código y
asignarle a cada sentencia el número del nodo que le corresponde, como
se observa en la siguiente tabla:
PARÁMETROS DE LA INTERFAZ DE LA FUNCIÓN
Interface returns media, total.entrada, total.valido;
Interface acepts valor, mínimo, máximo;
DECLARACIÓN DE TIPOS
Type valor[1:100] is SCALAR array;
Type media, total.entrada, total.valido, minimo, máximo, suma is SCALAR;
Type i is INTEGER;
INICIALIZACIÓN DE VARIABLES
i=1; total.entrada=total.valido=0; suma=0;
Nodo 1
CÓDIGO DE LA FUNCIÓN
do while valor[i]<>-999 and
Nodo 2
total.entrada<100
Nodo 3
{ total.entrada++;
Nodo 4
If valor[i] >=minimo and
Nodo 5
valor <=máximo
Nodo 6
Then {total.valido++; Suma+=valor[i];}
Nodo 7
Else null;
End if;
i++;
Nodo 8
end do}
if total.valido>0
Nodo 9
Then media = suma/total.valido;
Nodo 10
Else media = -999;
Nodo 11
End if;
End media;
Nodo 12
5
Como podemos ver, la declaración de tipos no supone una acción a
contemplar en el grafo, pero sí lo es la inicialización, ya que es una
asignación de valores. También contemplamos las sentencias de control y
por último, el final de la función, ya que el programa no debería acabar en
dos nodos, que serían los 10 y 11, sino en un doceavo nodo, que suponga
el retorno de la función.
Para poder apreciarlo claramente, podemos observar la siguiente
imagen, donde se muestra el grafo con la instrucción correspondiente a
cada nodo:
6
· Complejidad ciclomática
La complejidad ciclomática es un parámetro de los grafos de flujo y
representa la complejidad lógica de ejecución del programa. En el
contexto de las pruebas, la cuantía de la complejidad ciclomática
representa el número de caminos independientes que forman un conjunto
de caminos básicos y por ello nos da el número mínimo de pruebas que
garantiza la ejecución de cada instrucción al menos una vez.
La complejidad ciclomática se representa por CC(G) y se puede
calcular de varias formas:
1. CC(G) = Número de regiones en que se subdivide el plano que
representa el grafo, considerando la que queda fuera del grafo
como una región más. En este caso, la complejidad ciclomática de
nuestro grafo quedaría como CC(G) = 6, ya que:
CC(G) = 6, porque existen las regiones R1, R2, R3, R4, R5 y R6.
Es necesario tener en cuenta que la región 3 es la misma que
la región exterior, por lo que sólo se cuenta una vez.
7
2. CC(G) = Aristas – Vértices + 2. En este caso tenemos 16 aristas, que
son las líneas que unen los nodos, y 12 vértices, que son los
distintos nodos. Haciendo el cálculo obtenemos que la complejidad
ciclomática de nuestro grafo quedaría como:
CC(G) = 16 – 12 + 2 = 6, debido a que A = 16 y V = 12.
3. CC(G) = P + 1, donde P es el número de vértices desde donde parte
más de una arista, aunque esta definición no se puede aplicar con la
estructura de selección de múltiples alternativas, ya que desde un
vértice parten más de dos aristas. En nuestro caso el número de
vértices desde donde sale más de una arista es cinco, ya que los
nodos número 2, 3, 5, 6 y 9 tienen más de una alternativa. Por ello,
la complejidad ciclomática de nuestro grafo sería la siguiente:
CC(G) = 5 + 1 = 6, ya que de los vértices 2, 3, 5, 6 y 9 sale más de una
arista.
Dado que con las tres formas de calcular la complejidad ciclomática
obtenemos el mismo resultado, no cabe lugar a la duda de que el cálculo
esté mal realizado.
El resultado de la complejidad ciclomática nos indica el número de
caminos básicos posibles, es decir, de caminos independientes que se
pueden generar.
8
· Descripción de los distintos caminos básicos
La generación de los casos en los que se divide la prueba se puede
realizar siguiendo unos sencillos pasos que se enumeran a continuación:
1. Partiendo del código fuente se representa el grafo de flujo.
2. Se determina la complejidad ciclomática.
3. Se genera un conjunto básico de caminos. O sea, tantos caminos
independientes como indica la complejidad ciclomática.
4. Se establecen los datos que forzarán la ejecución de cada camino
del conjunto básico.
Por tanto, pueden obtenerse seis posibles caminos básicos que se
muestran a continuación y que ordenamos de más corto a más largo:
1.
2.
3.
4.
5.
6.
Nodos: 1, 2, 9, 10, 12
Nodos: 1, 2, 9, 11, 12
Nodos: 1, 2, 3, 9, 10, 12
Nodos: 1, 2, 3, 4, 5, 8, 2,...
Nodos: 1, 2, 3, 4, 5, 6, 8, 2,…
Nodos: 1, 2, 3, 4, 5, 6, 7, 8, 2,…
A continuación se muestran los valores necesarios de los
parámetros de entrada para cada uno de los caminos y los valores de los
parámetros de salida esperados y su correspondiente explicación:
9
1. Primer camino: El primer camino nunca se podrá ejecutar porque, para
que no se cumpla la condición del nodo número 2, se debe estar
observando en la primera iteración una posición que no pertenece al
array, por lo que en la condición del nodo 9, el total.válido será 0, y no
mayor que 0, por lo que dicha condición no se acepta y es imposible
acceder al nodo 10.
i=1; total.entrada=total.valido=0; suma=0;
Nodo 1
do while valor[i]<>-999 and
Nodo 2
…
if total.valido>0
Nodo 9
Then media = suma/total.valido;
Nodo 10
...
End media;
Camino
Nodos: 1, 2, 9, 10, 12
Nodo 12
Parámetros de Entrada
Valor[1] = no válido
No se observa el array.
10
Parámetros de Salida
IMPOSIBLE, NUNCA SE
EJECUTARÁ ESTE
CAMINO.
2. Segundo camino: El segundo camino se puede reproducir, ya que, para
que no se cumpla la condición del nodo número 2, se debe estar
observando un valor no perteneciente al array, y el total.válido es 0, ya
que se inicializó en el nodo número 1, con lo que no se accede al bucle
sino que se comprueba la condición del nodo 9. Dado que el valor de la
variable total.válido no se ha modificado y es 0, se accede al nodo número
11, asignando a la variable media el valor -999.
i=1; total.entrada=total.valido=0; suma=0;
Nodo 1
do while valor[i]<>-999 and
Nodo 2
…
if total.valido>0
Nodo 9
...
Else media = -999;
Nodo 11
End media;
Nodo 12
Camino
Nodos: 1, 2, 9, 11, 12
Parámetros de Entrada
Parámetros de Salida
Valor[1] = no válido
Media = -999
No se observa el array.
Total.entrada = 0
Total.válido = 0
11
3. Tercer camino: El tercer camino no se ejecutará nunca, ya que, para que
se cumpla la condición del nodo número 2, se debe estar observando el
primer valor del array, y el número total de datos de entrada para la
primera iteración es 0, ya que la variable total.entrada se inicializó a 0 en
el nodo número 1, con lo que debería entrar al bucle, es decir, al nodo 4,
pero salta al nodo número 10, lo que es imposible para ser la primera
iteración.
i=1; total.entrada=total.valido=0; suma=0;
Nodo 1
do while valor[i]<>-999 and
Nodo 2
total.entrada<100
Nodo 3
…
if total.valido>0
Nodo 9
...
Else media = -999;
Nodo 11
End media;
Nodo 12
Camino
Nodos: 1, 2, 3, 9, 10, 12
Parámetros de Entrada
Valor[1] = válido
12
Parámetros de Salida
IMPOSIBLE, NUNCA SE
EJECUTARÁ ESTE
CAMINO
4. Cuarto camino: El cuarto camino se puede ejecutar, ya que, para que se
cumpla la condición del nodo número 2, se debe estar observando el
primer valor del array, y la condición del nodo número 3 también se
cumple, ya que la variable total.entrada se inicializó en el nodo número 1
y no ha cambiado su valor, con lo que se entra en el bucle y se incrementa
el valor de la variable total.entrada en el nodo número 4, con lo que se
quedaría con valor numérico total.entrada = 1. El siguiente paso para que
se siguiese el flujo esperado es que el valor observado del array fuera
menor que el mínimo estipulado, lo cual no se puede permitir, como
expresa la condición del nodo número 5, con lo que el programa decidiría
ignorarlo, incrementando en el nodo número 8 el valor de la variable i,
que hace de iterador, y continuando con el bucle.
i=1; total.entrada=total.valido=0; suma=0;
Nodo 1
do while valor[i]<>-999 and
Nodo 2
total.entrada<100
Nodo 3
{ total.entrada++;
Nodo 4
If valor[i] >=minimo and
Nodo 5
…
i++;
Nodo 8
…
Camino
Nodos: 1, 2, 3, 4, 5, 8, 2,...
Parámetros de Entrada
Parámetros de Salida
Valor[1] = válido
Total.entrada = 1
Valor[1] < mínimo
Total.válido = 0
Suma = 0
13
5. Quinto camino: El quinto camino se puede ejecutar, ya que para que se
cumpla la condición del nodo número 2, se debe estar observando el
primer valor del array, y la condición del nodo número 3 también se
cumple, ya que la variable total.entrada se inicializó en el nodo número 1
y no ha cambiado su valor, con lo que se entra en el bucle y se incrementa
el valor de la variable total.entrada en el nodo número 4, con lo que se
quedaría con valor numérico total.entrada = 1. El siguiente paso para que
se siguiese el flujo esperado es que el valor observado del array fuera
mayor que el mínimo estipulado, lo cual es lo deseable, como expresa la
condición del nodo número 5, pero también mayor que el valor máximo,
lo cual no se debe permitir, como expresa claramente el nodo número 6,
con lo que el programa decidiría ignorarlo, incrementando en el nodo
número 8 el valor de la variable i, que hace de iterador y continuando con
el bucle.
i=1; total.entrada=total.valido=0; suma=0;
Nodo 1
do while valor[i]<>-999 and
Nodo 2
total.entrada<100
Nodo 3
{ total.entrada++;
Nodo 4
If valor[i] >=minimo and
Nodo 5
valor <=máximo
Nodo 6
...
i++;
Nodo 8
…
Camino
Nodos: 1, 2, 3, 4, 5, 6, 8,
2,…
Parámetros de Entrada
Parámetros de Salida
Valor[1] = válido
Total.entrada = 1
Valor[1] >= mínimo y Valor[1]
> máximo
Total.válido = 0
14
Suma = 0
6.
Sexto camino: Por último, el sexto camino se puede ejecutar, ya
que, para que se cumpla la condición del nodo número 2, se debe estar
observando el primer valor del array, y la condición del nodo número 3
también se cumple, ya que la variable total.entrada se inicializó en el nodo
número 1 y no ha cambiado su valor, con lo que se entra en el bucle y se
incrementa el valor de la variable total.entrada en el nodo número 4, con
lo que se quedaría con valor numérico total.entrada = 1. El siguiente paso
para que se siguiese el flujo esperado es que el valor observado del array
estuviera entre los valores mínimos y máximos permitidos, lo cual es
deseable, como expresan los nodos números 5 y 6. A continuación se
accedería al nodo número 7, donde se actualizarían algunas variables, y a
continuación al 8, incrementando el valor de la variable i, que hace de
iterador, y continuando con el bucle.
i=1; total.entrada=total.valido=0; suma=0;
Nodo 1
do while valor[i]<>-999 and
Nodo 2
total.entrada<100
Nodo 3
{ total.entrada++;
Nodo 4
If valor[i] >=minimo and
Nodo 5
valor <=máximo
Nodo 6
Then {total.valido++; Suma+=valor[i];}
Nodo 7
i++;
Nodo 8
…
Camino
Nodos: 1, 2, 3, 4, 5, 6, 7, 8,
2,…
Parámetros de Entrada
Parámetros de Salida
Valor[1] = válido
Total.entrada = 1
Valor[1] >= mínimo y Valor[1]
<= máximo
Total.válido = 1
15
Suma = Valor[1]
Por tanto concluimos con la siguiente tabla, donde se muestra el
resumen de lo que se ha dicho hasta ahora: los caminos, los parámetros
de entrada necesarios para su ejecución y sus correspondientes grafos.
Camino
Número
Nodos: 1, 2, 9, 10,
12
1
Nodos: 1, 2, 9, 11,
12
2
Parámetros de Entrada
Parámetros de Salida
Color
IMPOSIBLE, NUNCA
SE EJECUTARÁ ESTE
CAMINO
Rojo
Valor[1] = no válido
Media = -999
Naranja
No se observa el
array.
Total.entrada = 0
Valor[1] = no válido
No se observa el
array.
Total.válido = 0
Nodos: 1, 2, 3, 9, 10,
12
3
Valor[1] = válido
IMPOSIBLE, NUNCA
SE EJECUTARÁ ESTE
CAMINO
Amarillo
Nodos: 1, 2, 3, 4, 5,
8, 2,...
4
Valor[1] = válido
Total.entrada = 1
Verde
Valor[1] < mínimo
Total.válido = 0
Suma = 0
Nodos: 1, 2, 3, 4, 5,
6, 8, 2,…
5
Nodos: 1, 2, 3, 4, 5,
6, 7, 8, 2,…
6
Valor[1] = válido
Total.entrada = 1
Azul
Valor[1] >= mínimo Total.válido = 0
y Valor[1] > máximo
Suma = 0
Valor[1] = válido
Total.entrada = 1
Valor[1] >= mínimo
y Valor[1] <=
máximo
Total.válido = 1
16
Suma = Valor[1]
Violeta
Camino 1
Camino 2
Camino 3
Camino 4
Camino 5
Camino 6
17
2.2.- Prueba de condición
· Indicar para cada una de las posibilidades de cada una de
las condiciones los valores de entrada y de salida
Es más frecuente encontrar errores en las instrucciones
condicionales que en las secuenciales. Las condiciones están formadas por
variables lógicas, expresiones lógicas y expresiones relacionales. El
objetivo de las pruebas de condiciones es ejercitar adecuadamente todas
las condiciones del módulo para buscar errores que puedan estar en
variables lógicas, paréntesis, operadores relacionales o expresiones
lógicas.
Para ejercitar una condición se deben comprobar todos los casos
posibles de ésta, teniendo en cuenta que para una expresión lógica con n
operandos se necesitarán
pruebas.
Las condiciones son las siguientes:
1. VALOR[i] <>999 and total.entrada<100
2. VALOR[i]>=mínimo and valor<=máximo
3. total.válido>0
Como podemos ver, las condiciones que encontramos en el código
son la expresión VALOR[i] <>999 and total.entrada<100, que tiene dos
operandos, por lo que necesitará
tablas; la expresión
VALOR[i]>=mínimo and valor<=máximo, que tiene cuatro operandos, por
lo que necesitará
tablas; y la expresión total.válido>0, que tiene un
operando, por lo que necesitará tablas.
A continuación se muestran en tablas las tres condiciones,
indicando las posibles opciones de valores verdadero-falso que podrían
tomar, el valor de sus variables y el resultado que daría cada una de las
posibles opciones.
18
1.
Para la expresión VALOR[i] <>999 and total.entrada<100, hay una
única posible tabla:
VALOR[i] <>-999 and
total.entrada<100
VALOR [i]
Total.entrada
Resultado
VV
Type Integer
<100
Continuar
VF
Type Integer
>100
IMPOSIBLE
FV
Fuera del array
<100
No continuar
FF
Fuera del array
>100
No continuar
Para esta expresión se dan cuatro posibles opciones de valores
verdadero-falso.
· Para que se diera el caso de que el resultado de la expresión fuera
VV, tendría que estar observándose un valor del array y el total de la
entrada ser menor que cien, con lo que se continuaría la ejecución normal
del programa.
· Para
que se diera el caso de que el resultado de la expresión fuera
VF, tendría que estar observándose un valor del array y el total de entrada
ser mayor que cien, lo cual es imposible ya que el array tiene como
máximo cien nodos, así que el total de entrada será como máximo cien.
· Para que se diera el caso de que el resultado de la expresión fuera
FV, tendría que darse el caso de que se estuviera observando un valor no
perteneciente al array y que el total de la entrada fuera menor que cien, lo
cual es posible y nada extraño, con lo que la condición no se aceptaría y el
programa decidiría no aceptarla y no continuar.
· Para que se diera el caso de que el resultado de la expresión fuera
FF, tendría que darse el caso de que no se estuviera observando una
posición del array y el total de la entrada fuera mayor que cien, lo cual no
podrá ocurrir nunca, porque el total de entrada llegará como máximo a
cien, que es el número de nodos que tendrá el array como máximo.
19
2.
Para la expresión VALOR[i]>=mínimo and valor<=máximo, hay
cuatro posibles opciones reflejadas en las cuatro siguientes tablas. Para
ello hemos supuesto un valor mínimo y máximo de prueba.
Tabla 1:
mínimo máximo
Resultado
VALOR[i]>mínimo and valor<máximo
VALOR [i]
VV
>0 y <100
0
100
Continuar
VF
>0 y >=100
0
100
No continuar
FV
<=0 y <100
0
100
No continuar
FF
<=0 y >=100
0
100
IMPOSIBLE
Para esta expresión se dan cuatro posibles opciones de valores
verdadero-falso.
· Para que se diera el caso de que el resultado de la expresión fuera
VV, tendría que estar observándose un valor del array que estuviera entre
el mínimo y el máximo, ambos no incluídos, con lo que se aceptaría y se
continuaría con la ejecución normal del programa. Ejemplo: 50.
· Para
que se diera el caso de que el resultado de la expresión fuera
VF, tendría que estar observándose un valor del array que fuera igual o
mayor al máximo permitido (obviamente es mayor que el mínimo
permitido), lo cual no se acepta y el programa decide no continuar.
Ejemplo: 100.
· Para que se diera el caso de que el resultado de la expresión fuera
FV, tendría que estar observándose un valor del array que fuera menor o
igual que el mínimo permitido (obviamente menor que el máximo
permitido), lo cual no se acepta y el programa decide no continuar.
Ejemplo: 0.
· Para que se diera el caso de que el resultado de la expresión fuera
FF, tendría que darse el caso de que el valor observado del array fuera
menor o igual que el mínimo y mayor o igual que el máximo, lo cual es
imposible y nunca sucederá. Ejemplo: inexistente.
20
Tabla 2:
mínimo máximo
Resultado
VALOR[i]=mínimo and valor=máximo
VALOR [i]
VV
=0 y =100
0
0
Continuar
VF
=0 y != 100
0
100
No continuar
FV
!=0 y =100
0
100
No continuar
FF
!=0 y !=100
0
100
No continuar
Para esta expresión se dan cuatro posibles opciones de valores
verdadero-falso.
· Para que se diera el caso de que el resultado de la expresión fuera
VV, tendría que estar observándose un valor del array que fuera el
mínimo y el máximo, lo cual se aceptaría si el mínimo y el máximo tuvieran
el mismo valor numérico. Ejemplo: 0.
· Para
que se diera el caso de que el resultado de la expresión fuera
VF, tendría que estar observándose un valor del array que fuera igual al
mínimo permitido pero distinto al máximo, lo cual no se acepta y el
programa decide no continuar. Ejemplo: 0.
· Para que se diera el caso de que el resultado de la expresión fuera
FV, tendría que estar observándose un valor del array que distinto que el
mínimo permitido pero igual que el máximo, lo cual no se acepta y el
programa decide no continuar. Ejemplo: 100.
· Para que se diera el caso de que el resultado de la expresión fuera
FF, tendría que darse el caso de que el valor observado del array fuera
distinto que el mínimo y que el máximo, lo cual es posible, pero no se
permite, con lo que se decide no continuar. Ejemplo: 25.
21
Tabla 3:
mínimo máximo
Resultado
VALOR[i]>mínimo and valor=máximo
VALOR [i]
VV
>0 y =100
0
100
Continuar
VF
>0 y !=100
0
100
No continuar
FV
<=0 y =100
0
100
IMPOSIBLE
FF
<=0 y !=100
0
100
No continuar
Para esta expresión se dan cuatro posibles opciones de valores
verdadero-falso.
· Para que se diera el caso de que el resultado de la expresión fuera
VV, tendría que estar observándose un valor mayor que el mínimo e igual
al máximo, lo cual se acepta y se decide continuar. Ejemplo: 100.
· Para
que se diera el caso de que el resultado de la expresión fuera
VF, tendría que estar observándose un valor mayor que el mínimo pero
distinto al máximo, lo cual no se aceptaría y se decidiría no continuar.
Ejemplo: 50.
· Para que se diera el caso de que el resultado de la expresión fuera
FV, tendría que darse el caso de que se estuviera observando un valor
menor o igual que el mínimo e igual al máximo, lo cual es imposible.
Ejemplo: inexistente.
· Para que se diera el caso de que el resultado de la expresión fuera
FF, tendría que darse el caso de que se estuviera observando un valor
menor o igual que el mínimo y distinto al máximo, con lo que se decidiría
no continuar. Ejemplo: 0.
22
Tabla 4:
mínimo máximo
Resultado
VALOR[i]=mínimo and valor <máximo
VALOR [i]
VV
=0 y <100
0
100
Continuar
VF
=0 Y >=100
0
100
IMPOSIBLE
FV
!=0 y <100
0
100
No continuar
FF
!=0 y >=100
0
100
No continuar
Para esta expresión se dan cuatro posibles opciones de valores
verdadero-falso.
· Para que se diera el caso de que el resultado de la expresión fuera
VV, tendría que estar observándose un valor igual al mínimo y que sea
menor que el máximo. Esto sucedería si el mínimo y el máximo no tienen
el mismo valor numérico. Ejemplo: 0.
· Para
que se diera el caso de que el resultado de la expresión fuera
VF, tendría que estar observándose un valor igual al mínimo pero mayor o
igual que el máximo. En este caso no se aceptaría, pero si el mínimo y el
máximo tuvieran el mismo valor numérico, como por ejemplo el 0, se
aceptaría. Para este caso es imposible.
· Para que se diera el caso de que el resultado de la expresión fuera
FV, tendría que darse el caso de que se estuviera observando un valor
distinto al mínimo pero menor que el máximo, lo cual es posible, pero
decide no aceptarse. Ejemplo: 50.
· Para que se diera el caso de que el resultado de la expresión fuera
FF, tendría que darse el caso de que se estuviera observando un valor del
array distinto al mínimo y menor o igual que el máximo, lo cual es posible,
pero decide no aceptarse. Ejemplo: 100.
23
3.
Para la expresión total.válido>0, hay una única posible tabla:
Total.válido>0
Total.válido
Media
Resultado
V
>0
Suma/total.válido
Continuar
F
<=0
-999
No continuar
Para esta expresión se dan dos posibles opciones de valores
verdadero-falso.
· Para que se diera el caso de que el resultado de la expresión fuera
V, tendría que haberse observado algún valor permitido entre los límites
mínimos y máximos permitidos. Con ello la media resultante sería el valor
numérico de la suma entre el valor numérico del total.válido.
· Para
que se diera el caso de que el resultado de la expresión fuera
F, tendría que no haberse observado ningún valor permitido entre los
límites mínimos y máximo permitidos. Si el total.válido fuera cero, estaría
no permitido y la media resultante sería el valor numérico -999, mientras
que la otra opción sería que el total.válido fuera menor que cero, lo cual
es imposible.
24
2.3.- Prueba de bucles
· Aplicar el bucle a toda s las pruebas simples de bucles
Los bucles son elementos comunes en los que se fundamentan
muchos algoritmos, por ello y teniendo en cuenta que es un lugar
frecuénteme de aparición de errores es válido dedicarles una atención
especial.
El diseño de las pruebas para probar los bucles tienen como
objetivo reducir la posibilidad de que pase por alto un error no
encontrado en otro tipo de prueba.
Para un bucle en el que se permiten hasta n pasos de plantearían las
siguientes pruebas:
1.
2.
3.
4.
5.
6.
No pasar por el bucle, es decir, iterar cero veces.
Iterar una sola vez.
Iterar dos veces.
Iterar k veces, siendo k un número menor que n.
Iterar n-1 veces.
Iterar n veces
Los resultados de esta prueba los observamos en la siguiente tabla
donde se recogen los datos obtenidos en las pruebas mencionadas
variando el número de iteraciones. En la primera columna se muestra el
número de iteraciones que deseamos que ocurran; en la columna de
Valor[i] vemos lo que sería necesario que sucediera con esa posición del
array para que se ejecutara el bucle el número de veces deseado; en la
columna donde se indica el total.entrada se observa el valor necesario que
tendría que tener dicho valor para que se ejecutara el bucle de la forma
deseada en la primera columna; por último, podemos ver el resultado que
dará el programa.
25
Iteraciones
Valor[i]
Total.entrada
Resultado
0 veces
Array no
existente
Total.entrada
< 100
Media = -999
1 vez
Array(*) con 1
valor mínimo
Total.entrada
< 100
Media = valor observado del array
2 veces
Array(*) con 2 Total.entrada Media = suma de los valores observados
valores mínimo
< 100
del array / 2.
k veces (k =
25 < n)
Array(*) con 25 Total.entrada Media = suma de los valores observados
valores mínimo
< 100
del array / 25.
n – 1 veces (n Array(*) con 98 Total.entrada Media = suma de los valores observados
– 1 = 99)
valores mínimo
< 100
del array / 98.
n veces (n =
100)
Array(*) con 99 Total.entrada Media = suma de los valores observados
valores mínimo
< 100
del array / 99.
* = si existiera.
26
3.- Conclusiones
El desarrollo de programas implica una serie de actividades
humanas en las que la posibilidad de que se produzcan fallos es enorme.
Encontrar estos fallos es una tarea primordial para un programador. A
veces, no es posible hacer una verificación formal por la existencia de
límites temporales, problemas de mercado, etc., en cuyo caso cabe
realizar una serie de pruebas de tipo práctico a modo de test para acortar
en lo posible los errores. Debido a la imposibilidad de hacer pruebas
exhaustivas, la no existencia de fallos en un programa nunca estará
garantizada si no se realiza una verificación formal.
Existen varias técnicas de pruebas que utilizan dos enfoques
distintos, por un lado se trata de aprovechar el conocimiento de las
especificaciones del programa y por otro lado las estructuras básicas
globales, porque no es posible su diseño, sino de pruebas puntuales
incidiendo en las dos líneas anteriores. En concreto, en esta práctica
hemos abordado las pruebas del tipo llamado de caja blanca, aplicadas a
programas sencillos, habiendo realizado pruebas de caminos básicos,
pruebas de condiciones y pruebas de bucles.
27