Anda di halaman 1dari 27

Pruebas de caja blanca

Prueba y Mantenimiento del Software


Alicia Brbara Expsito Santana
23/04/2012
INDICE

1.- Introduccin 3

2.- Pruebas

2.1.- Prueba del camino bsico 4

Grfico de flujo 4

Complejidad ciclomtica 7

Descripcin de los caminos 9

o 1er camino 10
o 2 camino 11
o 3er camino 12
o 4 camino 13
o 5 camino 14
o 6 camino 15

2.2.- Prueba de condicin 18

o 1era expresin 19
o 2 expresin
Tabla 1 20
Tabla 2 21
Tabla 3 22
Tabla 4 23
o 3er expresin 24

2.3.- Prueba de bucles 25

3.- Conclusiones 27

2
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.

3
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:

4
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

5
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:

6
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.

7
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.

8
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. Nodos: 1, 2, 9, 10, 12
2. Nodos: 1, 2, 9, 11, 12
3. Nodos: 1, 2, 3, 9, 10, 12
4. Nodos: 1, 2, 3, 4, 5, 8, 2,...
5. Nodos: 1, 2, 3, 4, 5, 6, 8, 2,
6. 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:

9
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; Nodo 12

Camino Parmetros de Entrada Parmetros de Salida

Nodos: 1, 2, 9, 10, 12 Valor[1] = no vlido IMPOSIBLE, NUNCA SE


EJECUTAR ESTE
No se observa el array.
CAMINO.

10
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 Parmetros de Entrada Parmetros de Salida

Nodos: 1, 2, 9, 11, 12 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 Parmetros de Entrada Parmetros de Salida

Nodos: 1, 2, 3, 9, 10, 12 Valor[1] = vlido IMPOSIBLE, NUNCA SE


EJECUTAR ESTE
CAMINO

12
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 Parmetros de Entrada Parmetros de Salida

Nodos: 1, 2, 3, 4, 5, 8, 2,... 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 Parmetros de Entrada Parmetros de Salida

Nodos: 1, 2, 3, 4, 5, 6, 8, Valor[1] = vlido Total.entrada = 1


2,
Valor[1] >= mnimo y Valor[1] Total.vlido = 0
> mximo
Suma = 0

14
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 Parmetros de Entrada Parmetros de Salida

Nodos: 1, 2, 3, 4, 5, 6, 7, 8, Valor[1] = vlido Total.entrada = 1


2,
Valor[1] >= mnimo y Valor[1] Total.vlido = 1
<= mximo
Suma = Valor[1]

15
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 Parmetros de Entrada Parmetros de Salida Color

Nodos: 1, 2, 9, 10, 1 Valor[1] = no vlido IMPOSIBLE, NUNCA Rojo


12 SE EJECUTAR ESTE
No se observa el
CAMINO
array.

Nodos: 1, 2, 9, 11, 2 Valor[1] = no vlido Media = -999 Naranja


12
No se observa el Total.entrada = 0
array.
Total.vlido = 0

Nodos: 1, 2, 3, 9, 10, 3 Valor[1] = vlido IMPOSIBLE, NUNCA Amarillo


12 SE EJECUTAR ESTE
CAMINO

Nodos: 1, 2, 3, 4, 5, 4 Valor[1] = vlido Total.entrada = 1 Verde


8, 2,...
Valor[1] < mnimo Total.vlido = 0

Suma = 0

Nodos: 1, 2, 3, 4, 5, 5 Valor[1] = vlido Total.entrada = 1 Azul


6, 8, 2,
Valor[1] >= mnimo Total.vlido = 0
y Valor[1] > mximo
Suma = 0

Nodos: 1, 2, 3, 4, 5, 6 Valor[1] = vlido Total.entrada = 1 Violeta


6, 7, 8, 2,
Valor[1] >= mnimo Total.vlido = 1
y Valor[1] <=
Suma = Valor[1]
mximo

16
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 VALOR [i] Total.entrada Resultado


total.entrada<100

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:

VALOR[i]>mnimo and valor<mximo VALOR [i] mnimo mximo Resultado

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 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.

Paraque 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:

VALOR[i]=mnimo and valor=mximo VALOR [i] mnimo mximo Resultado

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 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.

Paraque 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:

VALOR[i]>mnimo and valor=mximo VALOR [i] mnimo mximo Resultado

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 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:

VALOR[i]=mnimo and valor <mximo VALOR [i] mnimo mximo Resultado

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 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

V >0 Suma/total.vlido Continuar

F <=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.

Paraque 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. No pasar por el bucle, es decir, iterar cero veces.


2. Iterar una sola vez.
3. Iterar dos veces.
4. Iterar k veces, siendo k un nmero menor que n.
5. Iterar n-1 veces.
6. 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 Total.entrada Media = -999


existente < 100

1 vez Array(*) con 1 Total.entrada Media = valor observado del array


valor mnimo < 100

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


valores mnimo < 100 del array / 2.

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


25 < n) 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 = Array(*) con 99 Total.entrada Media = suma de los valores observados


100) 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