Vous êtes sur la page 1sur 27

Pruebas de caja blanca

Prueba y Mantenimiento del Software


Alicia Brbara Expsito Santana
23/04/2012

INDICE

1.- Introduccin

2.- Pruebas
2.1.- Prueba del camino bsico

Grfico de flujo

Complejidad ciclomtica

Descripcin de los caminos

1er camino
2 camino
3er camino
4 camino
5 camino
o 6 camino
o
o
o
o
o

2.2.- Prueba de condicin


o
o

1era expresin
2 expresin

Tabla 1
Tabla 2
Tabla 3
Tabla 4

3er expresin

2.3.- Prueba de bucles

10
11
12
13
14
15
18
19
20
21
22
23
24

25

3.- Conclusiones

27

1.- Introduccin
Las pruebas de caja blanca, que sera mejor llamarlas de caja
transparente, se establecen por medio del diseo de casos que usan como
base las estructuras de control del flujo. Estas pruebas se pueden clasificar
en tres tipos segn sus objetivos:
1. Que se ejecute por lo menos una vez cada instruccin 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 bsico, que se basa en la
complejidad del flujo de ejecucin desglosado en un conjunto bsico de
caminos. Los casos en los que se divide la prueba, obtenidos en funcin
del conjunto bsico, 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 mdulo para buscar errores que
puedan estar en variables lgicas, parntesis, operadores relacionales o
expresiones lgicas.
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.

2.- Pruebas
2.1.- Prueba del camino bsico
Grfico de flujo
Generar el grfico de flujo indicando a qu zona del cdigo
corresponde cada nodo.
El grafo del flujo representa los caminos de ejecucin que se pueden
seguir en un procedimiento, mdulo, etc. Es un grafo orientado en el que
los vrtices representan instrucciones o conjuntos de instrucciones que se
ejecutan como una unidad, como por ejemplo, la asignacin de valores a
variables, sentencias de control de iteracin en bucles y sentencias de
comprobacin de la iteracin en estructuras de control, y las aristas
representan bifurcaciones en el flujo. Cada arista representa la posibilidad
de que una vez terminada la ejecucin de un vrtice se pase a ejecutar
otro.
El grfico de flujo de ejecucin del programa es el siguiente:

El grfico de flujo se obtiene a partir de observar el cdigo y


asignarle a cada sentencia el nmero del nodo que le corresponde, como
se observa en la siguiente tabla:
PARMETROS DE LA INTERFAZ DE LA FUNCIN
Interface returns media, total.entrada, total.valido;
Interface acepts valor, mnimo, mximo;
DECLARACIN DE TIPOS
Type valor[1:100] is SCALAR array;
Type media, total.entrada, total.valido, minimo, mximo, suma is SCALAR;
Type i is INTEGER;
INICIALIZACIN DE VARIABLES
i=1; total.entrada=total.valido=0; suma=0;

Nodo 1

CDIGO DE LA FUNCIN
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 <=mximo

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

Como podemos ver, la declaracin de tipos no supone una accin a


contemplar en el grafo, pero s lo es la inicializacin, ya que es una
asignacin de valores. Tambin contemplamos las sentencias de control y
por ltimo, el final de la funcin, ya que el programa no debera acabar en
dos nodos, que seran los 10 y 11, sino en un doceavo nodo, que suponga
el retorno de la funcin.

Para poder apreciarlo claramente, podemos observar la siguiente


imagen, donde se muestra el grafo con la instruccin correspondiente a
cada nodo:

Complejidad ciclomtica
La complejidad ciclomtica es un parmetro de los grafos de flujo y
representa la complejidad lgica de ejecucin del programa. En el
contexto de las pruebas, la cuanta de la complejidad ciclomtica
representa el nmero de caminos independientes que forman un conjunto
de caminos bsicos y por ello nos da el nmero mnimo de pruebas que
garantiza la ejecucin de cada instruccin al menos una vez.
La complejidad ciclomtica se representa por CC(G) y se puede
calcular de varias formas:
1. CC(G) = Nmero de regiones en que se subdivide el plano que
representa el grafo, considerando la que queda fuera del grafo
como una regin ms. En este caso, la complejidad ciclomtica de
nuestro grafo quedara 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 regin 3 es la misma que
la regin exterior, por lo que slo se cuenta una vez.

2. CC(G) = Aristas Vrtices + 2. En este caso tenemos 16 aristas, que


son las lneas que unen los nodos, y 12 vrtices, que son los
distintos nodos. Haciendo el clculo obtenemos que la complejidad
ciclomtica de nuestro grafo quedara como:
CC(G) = 16 12 + 2 = 6, debido a que A = 16 y V = 12.

3. CC(G) = P + 1, donde P es el nmero de vrtices desde donde parte


ms de una arista, aunque esta definicin no se puede aplicar con la
estructura de seleccin de mltiples alternativas, ya que desde un
vrtice parten ms de dos aristas. En nuestro caso el nmero de
vrtices desde donde sale ms de una arista es cinco, ya que los
nodos nmero 2, 3, 5, 6 y 9 tienen ms de una alternativa. Por ello,
la complejidad ciclomtica de nuestro grafo sera la siguiente:
CC(G) = 5 + 1 = 6, ya que de los vrtices 2, 3, 5, 6 y 9 sale ms de una
arista.

Dado que con las tres formas de calcular la complejidad ciclomtica


obtenemos el mismo resultado, no cabe lugar a la duda de que el clculo
est mal realizado.
El resultado de la complejidad ciclomtica nos indica el nmero de
caminos bsicos posibles, es decir, de caminos independientes que se
pueden generar.

Descripcin de los distintos caminos bsicos


La generacin de los casos en los que se divide la prueba se puede
realizar siguiendo unos sencillos pasos que se enumeran a continuacin:
1. Partiendo del cdigo fuente se representa el grafo de flujo.
2. Se determina la complejidad ciclomtica.
3. Se genera un conjunto bsico de caminos. O sea, tantos caminos
independientes como indica la complejidad ciclomtica.
4. Se establecen los datos que forzarn la ejecucin de cada camino
del conjunto bsico.
Por tanto, pueden obtenerse seis posibles caminos bsicos que se
muestran a continuacin y que ordenamos de ms corto a ms 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 continuacin se muestran los valores necesarios de los


parmetros de entrada para cada uno de los caminos y los valores de los
parmetros de salida esperados y su correspondiente explicacin:

1. Primer camino: El primer camino nunca se podr ejecutar porque, para


que no se cumpla la condicin del nodo nmero 2, se debe estar
observando en la primera iteracin una posicin que no pertenece al
array, por lo que en la condicin del nodo 9, el total.vlido ser 0, y no
mayor que 0, por lo que dicha condicin 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

Parmetros de Entrada
Valor[1] = no vlido
No se observa el array.

10

Parmetros 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 condicin del nodo nmero 2, se debe estar
observando un valor no perteneciente al array, y el total.vlido es 0, ya
que se inicializ en el nodo nmero 1, con lo que no se accede al bucle
sino que se comprueba la condicin del nodo 9. Dado que el valor de la
variable total.vlido no se ha modificado y es 0, se accede al nodo nmero
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

Parmetros de Entrada

Parmetros de Salida

Valor[1] = no vlido

Media = -999

No se observa el array.

Total.entrada = 0
Total.vlido = 0

11

3. Tercer camino: El tercer camino no se ejecutar nunca, ya que, para que


se cumpla la condicin del nodo nmero 2, se debe estar observando el
primer valor del array, y el nmero total de datos de entrada para la
primera iteracin es 0, ya que la variable total.entrada se inicializ a 0 en
el nodo nmero 1, con lo que debera entrar al bucle, es decir, al nodo 4,
pero salta al nodo nmero 10, lo que es imposible para ser la primera
iteracin.

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

Parmetros de Entrada
Valor[1] = vlido

12

Parmetros de Salida
IMPOSIBLE, NUNCA SE
EJECUTAR ESTE
CAMINO

4. Cuarto camino: El cuarto camino se puede ejecutar, ya que, para que se


cumpla la condicin del nodo nmero 2, se debe estar observando el
primer valor del array, y la condicin del nodo nmero 3 tambin se
cumple, ya que la variable total.entrada se inicializ en el nodo nmero 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 nmero 4, con lo que se
quedara con valor numrico total.entrada = 1. El siguiente paso para que
se siguiese el flujo esperado es que el valor observado del array fuera
menor que el mnimo estipulado, lo cual no se puede permitir, como
expresa la condicin del nodo nmero 5, con lo que el programa decidira
ignorarlo, incrementando en el nodo nmero 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,...

Parmetros de Entrada

Parmetros de Salida

Valor[1] = vlido

Total.entrada = 1

Valor[1] < mnimo

Total.vlido = 0
Suma = 0

13

5. Quinto camino: El quinto camino se puede ejecutar, ya que para que se


cumpla la condicin del nodo nmero 2, se debe estar observando el
primer valor del array, y la condicin del nodo nmero 3 tambin se
cumple, ya que la variable total.entrada se inicializ en el nodo nmero 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 nmero 4, con lo que se
quedara con valor numrico total.entrada = 1. El siguiente paso para que
se siguiese el flujo esperado es que el valor observado del array fuera
mayor que el mnimo estipulado, lo cual es lo deseable, como expresa la
condicin del nodo nmero 5, pero tambin mayor que el valor mximo,
lo cual no se debe permitir, como expresa claramente el nodo nmero 6,
con lo que el programa decidira ignorarlo, incrementando en el nodo
nmero 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 <=mximo

Nodo 6

...
i++;

Nodo 8

Camino
Nodos: 1, 2, 3, 4, 5, 6, 8,
2,

Parmetros de Entrada

Parmetros de Salida

Valor[1] = vlido

Total.entrada = 1

Valor[1] >= mnimo y Valor[1]


> mximo

Total.vlido = 0

14

Suma = 0

6.
Sexto camino: Por ltimo, el sexto camino se puede ejecutar, ya
que, para que se cumpla la condicin del nodo nmero 2, se debe estar
observando el primer valor del array, y la condicin del nodo nmero 3
tambin se cumple, ya que la variable total.entrada se inicializ en el nodo
nmero 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 nmero 4, con
lo que se quedara con valor numrico total.entrada = 1. El siguiente paso
para que se siguiese el flujo esperado es que el valor observado del array
estuviera entre los valores mnimos y mximos permitidos, lo cual es
deseable, como expresan los nodos nmeros 5 y 6. A continuacin se
accedera al nodo nmero 7, donde se actualizaran algunas variables, y a
continuacin 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 <=mximo

Nodo 6

Then {total.valido++; Suma+=valor[i];}

Nodo 7

i++;

Nodo 8

Camino
Nodos: 1, 2, 3, 4, 5, 6, 7, 8,
2,

Parmetros de Entrada

Parmetros de Salida

Valor[1] = vlido

Total.entrada = 1

Valor[1] >= mnimo y Valor[1]


<= mximo

Total.vlido = 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 parmetros
de entrada necesarios para su ejecucin y sus correspondientes grafos.

Camino

Nmero

Nodos: 1, 2, 9, 10,
12

Nodos: 1, 2, 9, 11,
12

Parmetros de Entrada

Parmetros de Salida

Color

IMPOSIBLE, NUNCA
SE EJECUTAR ESTE
CAMINO

Rojo

Valor[1] = no vlido

Media = -999

Naranja

No se observa el
array.

Total.entrada = 0

Valor[1] = no vlido
No se observa el
array.

Total.vlido = 0

Nodos: 1, 2, 3, 9, 10,
12

Valor[1] = vlido

IMPOSIBLE, NUNCA
SE EJECUTAR ESTE
CAMINO

Amarillo

Nodos: 1, 2, 3, 4, 5,
8, 2,...

Valor[1] = vlido

Total.entrada = 1

Verde

Valor[1] < mnimo

Total.vlido = 0
Suma = 0

Nodos: 1, 2, 3, 4, 5,
6, 8, 2,

Nodos: 1, 2, 3, 4, 5,
6, 7, 8, 2,

Valor[1] = vlido

Total.entrada = 1

Azul

Valor[1] >= mnimo Total.vlido = 0


y Valor[1] > mximo
Suma = 0
Valor[1] = vlido

Total.entrada = 1

Valor[1] >= mnimo


y Valor[1] <=
mximo

Total.vlido = 1

16

Suma = Valor[1]

Violeta

Camino 1

Camino 2

Camino 3

Camino 4

Camino 5

Camino 6

17

2.2.- Prueba de condicin


Indicar para cada una de las posibilidades de cada una de
las condiciones los valores de entrada y de salida
Es ms frecuente encontrar errores en las instrucciones
condicionales que en las secuenciales. Las condiciones estn formadas por
variables lgicas, expresiones lgicas y expresiones relacionales. El
objetivo de las pruebas de condiciones es ejercitar adecuadamente todas
las condiciones del mdulo para buscar errores que puedan estar en
variables lgicas, parntesis, operadores relacionales o expresiones
lgicas.
Para ejercitar una condicin se deben comprobar todos los casos
posibles de sta, teniendo en cuenta que para una expresin lgica con n
operandos se necesitarn
pruebas.
Las condiciones son las siguientes:
1. VALOR[i] <>999 and total.entrada<100
2. VALOR[i]>=mnimo and valor<=mximo
3. total.vlido>0
Como podemos ver, las condiciones que encontramos en el cdigo
son la expresin VALOR[i] <>999 and total.entrada<100, que tiene dos
operandos, por lo que necesitar
tablas; la expresin
VALOR[i]>=mnimo and valor<=mximo, que tiene cuatro operandos, por
lo que necesitar
tablas; y la expresin total.vlido>0, que tiene un
operando, por lo que necesitar tablas.
A continuacin se muestran en tablas las tres condiciones,
indicando las posibles opciones de valores verdadero-falso que podran
tomar, el valor de sus variables y el resultado que dara cada una de las
posibles opciones.

18

1.
Para la expresin 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 expresin se dan cuatro posibles opciones de valores


verdadero-falso.
Para que se diera el caso de que el resultado de la expresin fuera
VV, tendra que estar observndose un valor del array y el total de la
entrada ser menor que cien, con lo que se continuara la ejecucin normal
del programa.
Para

que se diera el caso de que el resultado de la expresin fuera


VF, tendra que estar observndose un valor del array y el total de entrada
ser mayor que cien, lo cual es imposible ya que el array tiene como
mximo cien nodos, as que el total de entrada ser como mximo cien.
Para que se diera el caso de que el resultado de la expresin fuera
FV, tendra 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 extrao, con lo que la condicin no se aceptara y el
programa decidira no aceptarla y no continuar.
Para que se diera el caso de que el resultado de la expresin fuera
FF, tendra que darse el caso de que no se estuviera observando una
posicin 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 mximo a
cien, que es el nmero de nodos que tendr el array como mximo.
19

2.
Para la expresin VALOR[i]>=mnimo and valor<=mximo, hay
cuatro posibles opciones reflejadas en las cuatro siguientes tablas. Para
ello hemos supuesto un valor mnimo y mximo de prueba.
Tabla 1:
mnimo mximo

Resultado

VALOR[i]>mnimo and valor<mximo

VALOR [i]

VV

>0 y <100

100

Continuar

VF

>0 y >=100

100

No continuar

FV

<=0 y <100

100

No continuar

FF

<=0 y >=100

100

IMPOSIBLE

Para esta expresin se dan cuatro posibles opciones de valores


verdadero-falso.
Para que se diera el caso de que el resultado de la expresin fuera
VV, tendra que estar observndose un valor del array que estuviera entre
el mnimo y el mximo, ambos no includos, con lo que se aceptara y se
continuara con la ejecucin normal del programa. Ejemplo: 50.
Para

que se diera el caso de que el resultado de la expresin fuera


VF, tendra que estar observndose un valor del array que fuera igual o
mayor al mximo permitido (obviamente es mayor que el mnimo
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 expresin fuera
FV, tendra que estar observndose un valor del array que fuera menor o
igual que el mnimo permitido (obviamente menor que el mximo
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 expresin fuera
FF, tendra que darse el caso de que el valor observado del array fuera
menor o igual que el mnimo y mayor o igual que el mximo, lo cual es
imposible y nunca suceder. Ejemplo: inexistente.
20

Tabla 2:
mnimo mximo

Resultado

VALOR[i]=mnimo and valor=mximo

VALOR [i]

VV

=0 y =100

Continuar

VF

=0 y != 100

100

No continuar

FV

!=0 y =100

100

No continuar

FF

!=0 y !=100

100

No continuar

Para esta expresin se dan cuatro posibles opciones de valores


verdadero-falso.
Para que se diera el caso de que el resultado de la expresin fuera
VV, tendra que estar observndose un valor del array que fuera el
mnimo y el mximo, lo cual se aceptara si el mnimo y el mximo tuvieran
el mismo valor numrico. Ejemplo: 0.
Para

que se diera el caso de que el resultado de la expresin fuera


VF, tendra que estar observndose un valor del array que fuera igual al
mnimo permitido pero distinto al mximo, 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 expresin fuera
FV, tendra que estar observndose un valor del array que distinto que el
mnimo permitido pero igual que el mximo, 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 expresin fuera
FF, tendra que darse el caso de que el valor observado del array fuera
distinto que el mnimo y que el mximo, lo cual es posible, pero no se
permite, con lo que se decide no continuar. Ejemplo: 25.

21

Tabla 3:
mnimo mximo

Resultado

VALOR[i]>mnimo and valor=mximo

VALOR [i]

VV

>0 y =100

100

Continuar

VF

>0 y !=100

100

No continuar

FV

<=0 y =100

100

IMPOSIBLE

FF

<=0 y !=100

100

No continuar

Para esta expresin se dan cuatro posibles opciones de valores


verdadero-falso.
Para que se diera el caso de que el resultado de la expresin fuera
VV, tendra que estar observndose un valor mayor que el mnimo e igual
al mximo, lo cual se acepta y se decide continuar. Ejemplo: 100.
Para

que se diera el caso de que el resultado de la expresin fuera


VF, tendra que estar observndose un valor mayor que el mnimo pero
distinto al mximo, lo cual no se aceptara y se decidira no continuar.
Ejemplo: 50.
Para que se diera el caso de que el resultado de la expresin fuera
FV, tendra que darse el caso de que se estuviera observando un valor
menor o igual que el mnimo e igual al mximo, lo cual es imposible.
Ejemplo: inexistente.
Para que se diera el caso de que el resultado de la expresin fuera
FF, tendra que darse el caso de que se estuviera observando un valor
menor o igual que el mnimo y distinto al mximo, con lo que se decidira
no continuar. Ejemplo: 0.

22

Tabla 4:
mnimo mximo

Resultado

VALOR[i]=mnimo and valor <mximo

VALOR [i]

VV

=0 y <100

100

Continuar

VF

=0 Y >=100

100

IMPOSIBLE

FV

!=0 y <100

100

No continuar

FF

!=0 y >=100

100

No continuar

Para esta expresin se dan cuatro posibles opciones de valores


verdadero-falso.
Para que se diera el caso de que el resultado de la expresin fuera
VV, tendra que estar observndose un valor igual al mnimo y que sea
menor que el mximo. Esto sucedera si el mnimo y el mximo no tienen
el mismo valor numrico. Ejemplo: 0.
Para

que se diera el caso de que el resultado de la expresin fuera


VF, tendra que estar observndose un valor igual al mnimo pero mayor o
igual que el mximo. En este caso no se aceptara, pero si el mnimo y el
mximo tuvieran el mismo valor numrico, como por ejemplo el 0, se
aceptara. Para este caso es imposible.
Para que se diera el caso de que el resultado de la expresin fuera
FV, tendra que darse el caso de que se estuviera observando un valor
distinto al mnimo pero menor que el mximo, lo cual es posible, pero
decide no aceptarse. Ejemplo: 50.
Para que se diera el caso de que el resultado de la expresin fuera
FF, tendra que darse el caso de que se estuviera observando un valor del
array distinto al mnimo y menor o igual que el mximo, lo cual es posible,
pero decide no aceptarse. Ejemplo: 100.

23

3.

Para la expresin total.vlido>0, hay una nica posible tabla:

Total.vlido>0

Total.vlido

Media

Resultado

>0

Suma/total.vlido

Continuar

<=0

-999

No continuar

Para esta expresin se dan dos posibles opciones de valores


verdadero-falso.
Para que se diera el caso de que el resultado de la expresin fuera
V, tendra que haberse observado algn valor permitido entre los lmites
mnimos y mximos permitidos. Con ello la media resultante sera el valor
numrico de la suma entre el valor numrico del total.vlido.
Para

que se diera el caso de que el resultado de la expresin fuera


F, tendra que no haberse observado ningn valor permitido entre los
lmites mnimos y mximo permitidos. Si el total.vlido fuera cero, estara
no permitido y la media resultante sera el valor numrico -999, mientras
que la otra opcin sera que el total.vlido 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
frecunteme de aparicin de errores es vlido dedicarles una atencin
especial.
El diseo 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 plantearan 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 nmero 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 nmero de iteraciones. En la primera columna se muestra el
nmero de iteraciones que deseamos que ocurran; en la columna de
Valor[i] vemos lo que sera necesario que sucediera con esa posicin del
array para que se ejecutara el bucle el nmero de veces deseado; en la
columna donde se indica el total.entrada se observa el valor necesario que
tendra 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 mnimo

Total.entrada
< 100

Media = valor observado del array

2 veces

Array(*) con 2 Total.entrada Media = suma de los valores observados


valores mnimo
< 100
del array / 2.

k veces (k =
25 < n)

Array(*) con 25 Total.entrada Media = suma de los valores observados


valores mnimo
< 100
del array / 25.

n 1 veces (n Array(*) con 98 Total.entrada Media = suma de los valores observados


1 = 99)
valores mnimo
< 100
del array / 98.
n veces (n =
100)

Array(*) con 99 Total.entrada Media = suma de los valores observados


valores mnimo
< 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 verificacin formal por la existencia de
lmites temporales, problemas de mercado, etc., en cuyo caso cabe
realizar una serie de pruebas de tipo prctico 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 verificacin formal.
Existen varias tcnicas 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 bsicas
globales, porque no es posible su diseo, sino de pruebas puntuales
incidiendo en las dos lneas anteriores. En concreto, en esta prctica
hemos abordado las pruebas del tipo llamado de caja blanca, aplicadas a
programas sencillos, habiendo realizado pruebas de caminos bsicos,
pruebas de condiciones y pruebas de bucles.

27