• No se han encontrado resultados

Pruebas de caja blanca

N/A
N/A
Protected

Academic year: 2021

Share "Pruebas de caja blanca"

Copied!
27
0
0

Texto completo

(1)

Pruebas de caja blanca

Prueba y Mantenimiento del Software

Alicia Bárbara Expósito Santana 23/04/2012

(2)

2

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

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 condición

18 o 1era expresión 19 o 2ª expresión

 Tabla 1 20  Tabla 2 21  Tabla 3 22  Tabla 4 23 o 3er expresión 24

2.3.- Prueba de bucles

25

3.- Conclusiones

27

(3)

3

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.

(4)

4

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.

(5)

5

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;

(6)

6

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:

(7)

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

(8)

8

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.

(9)

9

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

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:

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

(10)

10

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.

Camino Parámetros de Entrada Parámetros de Salida

Nodos: 1, 2, 9, 10, 12 Valor[1] = no válido

No se observa el array.

IMPOSIBLE, NUNCA SE EJECUTARÁ ESTE CAMINO.

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

...

(11)

11

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.

Camino Parámetros de Entrada Parámetros de Salida

Nodos: 1, 2, 9, 11, 12 Valor[1] = no válido

No se observa el array.

Media = -999 Total.entrada = 0 Total.válido = 0

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

(12)

12

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.

Camino Parámetros de Entrada Parámetros de Salida

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

EJECUTARÁ ESTE CAMINO

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

(13)

13

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.

Camino Parámetros de Entrada Parámetros de Salida

Nodos: 1, 2, 3, 4, 5, 8, 2,... Valor[1] = válido

Valor[1] < mínimo

Total.entrada = 1 Total.válido = 0 Suma = 0

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

(14)

14

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.

Camino Parámetros de Entrada Parámetros de Salida

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

Valor[1] = válido

Valor[1] >= mínimo y Valor[1] > máximo

Total.entrada = 1 Total.válido = 0 Suma = 0

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

(15)

15

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.

Camino Parámetros de Entrada Parámetros de Salida

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

Valor[1] = válido

Valor[1] >= mínimo y Valor[1] <= máximo

Total.entrada = 1 Total.válido = 1 Suma = Valor[1]

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

(16)

16

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 Parámetros de Entrada Parámetros de Salida Color

Nodos: 1, 2, 9, 10, 12 1 Valor[1] = no válido No se observa el array. IMPOSIBLE, NUNCA SE EJECUTARÁ ESTE CAMINO Rojo Nodos: 1, 2, 9, 11, 12 2 Valor[1] = no válido No se observa el array. Media = -999 Total.entrada = 0 Total.válido = 0 Naranja 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 Valor[1] < mínimo Total.entrada = 1 Total.válido = 0 Suma = 0 Verde Nodos: 1, 2, 3, 4, 5, 6, 8, 2,… 5 Valor[1] = válido Valor[1] >= mínimo y Valor[1] > máximo Total.entrada = 1 Total.válido = 0 Suma = 0 Azul Nodos: 1, 2, 3, 4, 5, 6, 7, 8, 2,… 6 Valor[1] = válido Valor[1] >= mínimo y Valor[1] <= máximo Total.entrada = 1 Total.válido = 1 Suma = Valor[1] Violeta

(17)

17

Camino 1 Camino 2 Camino 3

(18)

18

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:

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.

1. VALOR[i] <>999 and total.entrada<100 2. VALOR[i]>=mínimo and valor<=máximo 3. total.válido>0

(19)

19

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.

(20)

20

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:

VALOR[i]>mínimo and valor<máximo VALOR [i] mínimo máximo 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 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.

(21)

21

Tabla 2:

VALOR[i]=mínimo and valor=máximo VALOR [i] mínimo máximo 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 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.

(22)

22

Tabla 3:

VALOR[i]>mínimo and valor=máximo VALOR [i] mínimo máximo 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 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.

(23)

23

Tabla 4:

VALOR[i]=mínimo and valor <máximo VALOR [i] mínimo máximo 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 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.

(24)

24

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.

(25)

25

2.3.- Prueba de bucles

· Aplicar el bucle a todas 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. 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 número 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 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.

(26)

26

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

valores mínimo

Total.entrada < 100

Media = suma de los valores observados del array / 2. k veces (k = 25 < n) Array(*) con 25 valores mínimo Total.entrada < 100

Media = suma de los valores observados del array / 25. n – 1 veces (n – 1 = 99) Array(*) con 98 valores mínimo Total.entrada < 100

Media = suma de los valores observados del array / 98. n veces (n = 100) Array(*) con 99 valores mínimo Total.entrada < 100

Media = suma de los valores observados del array / 99.

(27)

27

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.

Referencias

Documento similar

Asimismo una reflexión calmada sobre las intrincadas relaciones existentes en el péndulo que va del ODM 1 al ODM 8, debería conducirnos a observar por qué las formas mediante las

Primeros ecos de la Revolución griega en España: Alberto Lista y el filohelenismo liberal conservador español 369 Dimitris Miguel Morfakidis Motos.. Palabras de clausura

37 El TPI, en los fundamentos jurídicos del 149 al 154 de la sentencia «Virgia- micina», examinó las dos actividades complementarias que integran la evaluación de riesgos:

En su natal Caracas, donde se formó Bello como latinista, no pudo tener la oportunidad de aprender griego. Cuando nació, ya hacía 14 años que los jesuitas habían sido

Este parón o bloqueo de las ventas españolas al resto de la Comunidad contrasta sin em- bargo con la evolución interior de ese mismo mercado en cuan- to a la demanda de hortalizas.

Pero cuando vio a Mar sacar el fuego de bajo su ala, voló de vuelta a su tribu a contarles lo que había visto.... Justo antes de que el sol saliera, Tatkanna se despertó y comenzó

El interesado podrá acudir ante el señor Personero Municipal o a la Defensoría del Pueblo para que se le colabore en la elaboración de su demanda o petición, así como en los

1. LAS GARANTÍAS CONSTITUCIONALES.—2. C) La reforma constitucional de 1994. D) Las tres etapas del amparo argentino. F) Las vías previas al amparo. H) La acción es judicial en