Nombre 

Barly Eduardo Espinal 

Matricula 

2017‐4928 

Periodo académico 

2019‐2 

Nombre del profesor 

Ing. Leandro Fondeur 

Nombre del tema de estudio 

Práctica 8 ‐ Técnicas de prueba del Software 

 
1. Con sus palabras, describa la diferencia entre verificación y validación. ¿Ambas
usan los métodos de diseño de casos de prueba y estrategias de pruebas? Explique
su respuesta.

La verificación se refiere al conjunto de tareas que garantizan que el software

implementa correctamente una función específica.

La validación es un conjunto diferente de tareas que aseguran que el software que se

construye sigue los requerimientos del cliente.

Diferencias

Verificación: “¿Construimos el producto correctamente?” se ocupa de controlar si la

aplicación cumple con las especificaciones iniciales.

Validación: “¿Construimos el producto correcto?” se ocupa de controlar si la aplicación

satisface los requerimientos del cliente.

¿Ambas usan los métodos de diseño de casos de prueba y estrategias de pruebas?

La validación usamos Pruebas de Caja Negra (Grafos, partición equivalente y prueba de

valores límites) para la verificación empleamos Pruebas de Caja Blanca (Prueba de
Camino crítico: Grafo de flujo, complejidad ciclomática; prueba de Condición:
ramificaciones, dominio, operador relacional y de ramificación; Prueba de Flujo de datos
y Prueba de Bucles).

2. Mencione algunos problemas que pueden asociarse con la creación de un grupo de

prueba independiente. ¿Los GPI y el SQA se integran con las mismas personas?
Justifique su respuesta.

Desde un punto de vista psicológico, el análisis y diseño de software (junto con la

codificación) son tareas constructivas. El ingeniero de software analiza, modela y luego
crea un programa de computadora y su documentación. Como cualquier constructor, el
ingeniero de software está orgulloso del edificio que construyó y ve con desconfianza a
quien intente derrumbarlo. Cuando comienzan las pruebas, hay un sutil, pero definitivo,
intento por “romper” lo que construyó el ingeniero de software. Desde el punto de vista
del constructor, las pruebas pueden considerarse como (psicológicamente) destructivas.
De modo que el constructor actuará con cuidado, y diseñará y ejecutará pruebas que
demostrarán que el programa funciona, en lugar de descubrir errores.
Desafortunadamente, los errores estarán presentes. Y si el ingeniero de software no los
encuentra, ¡el cliente lo hará!
 ¿Los GPI y el SQA se integran con las mismas personas?

El propósito de un GIP (Grupo Independiente de Prueba) es el de eliminar el conflicto de

intereses que, de otro modo, estaría presente. Al personal del equipo que forma el equipo
independiente se le paga para que encuentre errores. El responsable del desarrollo del
software no entrega simplemente el programa al GIP y se desentiende. El responsable del
desarrollo y el GIP trabajan estrechamente a lo largo del proyecto de software para
asegurar que se realizan pruebas “exhaustivas”, mientras se realiza la prueba, el
desarrollador debe estar disponible para corregir los errores que se van descubriendo.

La verificación y la validación abarcan una amplia lista de actividades SQA (Software

Quality Assurance) que incluye:

Revisiones técnicas formales, auditorias de calidad y de configuración, monitorización de

rendimientos, simulación, estudios de factibilidad, revisión de la documentación, revisión
de la base de datos, análisis algorítmico, pruebas de desarrollo, pruebas de validación y
pruebas de instalación.

Las pruebas constituyen el último bastión desde el cual se puede evaluar la calidad y
descubrir los errores. Pero las pruebas no deben ser vistas como una red de seguridad. No
se pueden probar la calidad. Si no está ahí antes de comenzar la prueba, no estará cuando
se termine.

3. ¿Por qué un módulo altamente acoplado es difícil para la prueba de unidad?

Si para cambiar un módulo en un programa tenemos que cambiar otro módulo, entonces
hay acoplamiento entre ellos.

El acoplamiento puede aparecer bajo varias formas. Por ejemplo, si hay código repetido
esparcido entre los módulos, también habrá un cierto acoplamiento, porque cambiar un
fragmento de código repetido implica cambiarlo en todos los módulos que aparecen.
Incluso puede que haya dependencias entre módulos y no nos demos cuenta de ello.
Pero el acoplamiento también ocurre cuando el código de un módulo utiliza código de
otro módulo, bien porque llama a un método, o accede a sus datos.
Por ello, como tal, el acoplamiento no es algo que debas evitar a toda costa.
Porque, aunque dividamos nuestro programa en módulos, esos módulos tendrán que
interactuar entre sí de alguna manera (si no tendríamos distintos programas
independientes) y tendremos algo de acoplamiento entre ellos.
4. El concepto de "antierrores” (sección 17.3.1) es una forma extremadamente efectiva
de brindar asistencia de depuración interna cuando se descubre un error:

o Desarrolle un conjunto de lineamientos para antierror.

 Si la conexión falla con el server me lo informe
 Si los valores introducidos cumplen las condiciones de los parámetros
 Para que un formulario sea enviado los campos que son obligatorios deben
de estar llenos
 Incongruencia con la información de la base de datos
 Que los datos cumplan con las condiciones de frontera

o Analice las ventajas de usar la técnica.

Permite reducir los errores en el sistema, lo cual lleva a implementación de la

calidad desde un principio, lo cual lleva a una reducción de los costes, lo cual
lleva a mejorar la calidad general y mejorar el servicio al cliente, sin hablar de las
importantes mejoras a la productividad etc.

o Analice las desventajas.

El análisis se hace en cada módulo, con lo cual el modulo puede funcionar

perfectamente bien, pero, si este depende de otro modulo y en este se encuentran
errores debido a que no se supo hacer un sistema antierror adecuado se hará más
complicado buscar el error

5. ¿Cómo puede la calendarización del proyecto afectar la prueba de integración?

Si no se planifica la realización de las pruebas de integración, en el cronograma de

desarrollo e implantación del sistema previamente, realizar las pruebas a desfase o
únicamente al final del desarrollo del sistema, puede ocasionar un fuerte retraso, ya que
habrá sin lugar a dudas cambios imprevistos y modificaciones que realizarle al sistema y
así, no se podrá cumplir con las actividades establecidas en el cronograma para las fechas
indicadas en él.
6. ¿Quién debe realizar la prueba de validación: el desarrollador o el usuario del
software? Justifique su respuesta.

Yo creo que ambos deberían participar en este proceso, debido a:

El desarrollador

Las Pruebas de Validación en la ingeniería de software son el proceso de revisión que

verifica que el sistema de software producido cumple con las especificaciones y que
logran su cometido. Es una parte del proceso de pruebas del software de un proyecto, que
también utiliza técnicas tales como evaluaciones, inspecciones y tutoriales. La validación
es el proceso de comprobar que lo que se ha especificado es lo que el usuario realmente
quería.

Se trata de evaluar el sistema o parte de este durante o al final del desarrollo para
determinar si satisfacer los requisitos iniciales. La pregunta a realizarse es: ¿Es esto lo
que el cliente quiere?

El cliente

Finalmente, debemos organizar las pruebas de aceptación del usuario (UAT, User
Acceptance Testing). Sobre la base de estos resultados, podemos decidir implementar una
nueva versión del software.

7. Myers [Mye79] usa el siguiente programa como una auto-valoración de su habilidad

para especificar pruebas adecuadas: un programa lee tres valores enteros. Los tres
se interpretan como representación de las longitudes de los lados de un triángulo. El
programa imprime un mensaje que indica si el triángulo es escaleno, isósceles o
equilátero. Desarrolle un conjunto de casos de prueba que crea que probarán este
programa de manera adecuada.

Me voy a guiar del video que proporciono en el virtual que me ha encantado, pero voy a
hacer una lista de cosas para agilizar el proceso

Caso 1
Descripción Valor Resultado Resultado Resultado
esperado obtenido
Triángulo Todos los Triángulo Triángulo Triangulo
equilátero ángulos iguales equilátero equilátero equilátero
Triángulo Dos ángulos Triángulo Triángulo Triángulo
isósceles iguales isósceles isósceles isósceles
 Triángulo Todos los Triángulo Triángulo Triángulo
escaleno ángulos son escaleno escaleno escaleno
distintos

8. Diseñe e implemente el programa (con manipulación de error donde sea adecuado)

que se especifica en el problema anterior. Derive un gráfico de flujo para el
programa y aplique prueba de ruta básica para desarrollar casos de prueba que
garanticen la prueba de todos los enunciados en el programa. Ejecute los casos y
muestre sus resultados.

El programa fue desarrollado en html, es decir, si solo copia y pega, debería funcionar
todo

<!DOCTYPE html> 
<html lang="en"> 
  <head> 
    <title></title> 
    <meta charset="UTF‐8" /> 
    <meta name="viewport" content="width=device‐width, initial‐scale=1" /> 
    <script 
      src="https://code.jquery.com/jquery‐3.3.1.slim.min.js" 
      integrity="sha384‐
q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" 
      crossorigin="anonymous" 
    ></script> 
    <script 
      
src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js" 
      integrity="sha384‐
UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1" 
      crossorigin="anonymous" 
    ></script> 
    <script 
      
src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" 
      integrity="sha384‐
JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" 
      crossorigin="anonymous" 
    ></script> 
    <script> 
      $(document).ready(function() { 
        $("#ejecutar").click(function() { 
          var a = parseFloat($("#a").val()); 
          var b = parseFloat($("#b").val()); 
          var c = parseFloat($("#c").val()); 
 
          //aqui se revisa si los valores no son numeros y no nulos 
          if (isNaN(a) || isNaN(b) || isNaN(c)) { 
            // 1 2 3 
            alert( 
              // 4 
              "Favor de ingresar numeros, no texto y la caja no puede estar 
vacia" 
            ); 
          } //aqui se revisa si los valores son enteros 
          else if (a % 1 == 0 && b % 1 == 0 && c % 1 == 0) { 
            //5 6 7 
            //aqui se revisa si los valores son positivos 
            if (a > 0 && b > 0 && c > 0) { 
              // 9 10 11 
              //triangulo equilatero 
              if (a == c && a == b) { 
                //13 14 
                alert("El triangulo es equilatero"); //15 
              } //triangulo escaleno 
              else if ( 
                (a == b && a + b > c) || //16 17 
                (a == c && a + c > b) || //18 19 
                (c == b && c + b > a) // 20 21 
              ) { 
                alert("El triangulo es isoceles"); //22 
                //Validacion de triangulo 
              } else if (a + b <= c || c + b <= a || a + c <= b) { 
                //23 24 25 
                alert( 
                  //26 
                  "El triangulo no es valido ya que la sumatoria de dos de sus 
lados es menor o igual al tercer lado" 
                ); 
              } else { 
                //27 
                alert("El triangulo es escaleno"); 
              } 
            } else { 
              // 12 
              alert("Los numeros tienen que ser mayor que cero"); 
            } 
          } else { 
            //8 
            alert("Los numeros no pueden ser decimales"); 
          } 
        }); 
      }); 
    </script> 
  </head> 
  <body> 
    <div class="container"> 
      <h3> 
        Programa de verificacion de triangulos equilatero, isoceles y escaleno 
      </h3> 
      <p>Digite numeros enteros</p> 
      <label 
        >Lado A 
        <input type="text" id="a" /> 
      </label> 
      <label 
        >Lado B 
        <input type="text" id="b" /> 
      </label> 
      <label 
        >Lado C 
        <input type="text" id="c" /> 
      </label> 
      <button id="ejecutar">Ejecutar</button> 
    </div> 
  </body> 
</html> 
 
 
# de aristas = 48

# de nodos 35

Calculo de complejidad = 48 – 35 + 2 = 15

Caso 1
Descripción Valor Resultado Resultado Resultado
esperado obtenido
Triángulo Todos los Triángulo Triángulo
equilátero lados equilátero equilátero
iguales
Triángulo Dos lados Triángulo Triángulo
isósceles iguales isósceles isósceles

Triángulo Todos los Triángulo Triángulo

escaleno lados son escaleno escaleno
distintos

Caso 2
Descripción Valor Resultado Resultado Resultado
esperado obtenido
Triángulo Todos Triángulo Triángulo
equilátero los lados equilátero equilátero
iguales

Triángulo Dos Triángulo Triángulo

isósceles lados isósceles isósceles
iguales
Triángulo Todos Triángulo Triángulo
escaleno los lados escaleno escaleno
son
distintos

Palabras o palabras Error para Error de Error de conversión

valor nulo strings conversión
Lado 0 o 0o Error para Error Error inesperado
negativo negativo valores 0 ó inesperado
negativos

Caso 3
Descripció Valor Resultad Resultad Resultado
n o o
esperado obtenido
Triángulo Todos Triángulo Triángulo
equilátero los equilátero equilátero
ángulos
iguales

Triángulo Dos Triángulo Triángulo

isósceles ángulos isósceles isósceles
iguales

Triángulo Todos Triángulo Triángulo

escaleno los escaleno escaleno
lados
son
distintos
Palabras o palabras Error para Error de
valor nulo strings conversión

Lado 0 o 0o Error para Error

negativo negativ valores 0 ó inesperado
o negativos

Lado decimal Decimal Error para Sin error

valores no
enteros

Validación de La suma Error de Sin error

triangulo de dos triangulo
lados no inexistente
puede
ser
mayor
al 3er
lado
 Caso 3
Descripció Valor Resultado Resultado Resultado
n esperado obtenido
Triángulo Todos Triángulo Triángulo
equilátero los equilátero equilátero
lados
iguales

Triángulo Dos Triángulo Triángulo

isósceles lados isósceles isósceles
iguales

Triángulo Todos Triángulo Triángulo

escaleno los escaleno escaleno
lados
son
distintos

Palabras o palabras Error para Error de

valor nulo strings conversió
n

Lado 0 o 0o Error para Error

negativo negativ valores 0 inesperad
o ó o
negativos
Lado Decimal Error para Sin error
decimal valores no
enteros

Validación La Error de Sin error El triangulo no es valido ya que la 

de suma de triangulo sumatoria de dos de sus lados es menor 
triangulo dos inexistent
o igual al tercer lado 
lados no e
puede
ser
mayor
al 3er
lado

Entrada Camino Salida

A=4, B=3, C=5 1,2,3,5,6,7,9,10,11,13,14,16,18,20,23,24,25,27 Triangulo es
escaleno
A=4, B=4, C=4 1,2,3,5,6,7,9,10,11,13,14,15,F Triangulo es
equilátero
A=4, B=4, C=5 1,2,3,5,6,7,9,10,11,13,14,16,17,22,F Triangulo isósceles
A=4, B=3, C=8 1,2,3,5,6,7,9,10,11,13,14,16,18,20,23,26, F El triángulo no es
válido ya que la
sumatoria de dos de
sus lados es menor o
igual al tercer lado
A=4.5, B=4, 1,2,3,5,8, F Los números no
C=5 pueden ser decimales
A=0, B=4, C=5 1,2,3,5,6,7,9,12,F Los números tiene
que ser mayor que
cero
A=”Hola”, B=4, 1,4,F Favor ingresar
C=5 números, no texto y
no deje alguna caja
vacía
9. Especifique, diseñe e implemente una herramienta de software que calcule la
complejidad ciclomática para el lenguaje de programación de su elección. Use la
matriz de grafo como la estructura de datos operativa en su diseño.

Para un mejor desempeño en el programa en vez de la matriz llevar letras, llevara 0

donde no haya conexión y 1 donde si haya conexión, de esta forma:
 El programa fue desarrollado en C#

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 
 
namespace matriz 
{ 
    class Program 
    { 
        private int[,] mat; 
        private int tamano; 
        private int contador; 
        private int nodoPredicado; 
 
        public void matrizTamano() 
        { 
            Console.Write("ingrese el tamaño de la matriz "); 
            tamano = int.Parse(Console.ReadLine()); 
            mat = new int[tamano, tamano]; 
        } 
 
         
 
 
 
        public void llenarMatriz() 
        { 
             
            for (int i = 0; i < tamano; i++) 
            { 
                for (int k = 0; k < tamano; k++) 
                { 
                    Console.Write("Ingrese los datos por columnas" + "[" + i + "," + k + 
"] = "); 
                    string linea; 
                    linea = Console.ReadLine(); 
                    mat[i, k] = int.Parse(linea); 
 
                } 
            } 
        } 
 
        public void imprimir() 
        { 
            Console.WriteLine("Esta es la matriz digitada"); 
 
            for(int i = 0; i < tamano; i++) 
            { 
                for(int j = 0; j < tamano; j++) 
                { 
                    Console.Write(mat[i,j] + " "); 
                     
                } 
                Console.WriteLine(); 
            } 
            Console.ReadLine(); 
             
        } 
 
        public void complejidad() 
        { 
            for(int i = 0; i < tamano; i++) 
            { 
 
 
                for (int j = 0; j < tamano; j++) 
                { 
                    if (mat[i,j] == 1) 
                    { 
                        contador++; 
 
 
                    } 
 
                     
                } 
 
                if (contador > 1 && contador % 2 == 0) 
                { 
                    nodoPredicado++; 
                } 
                else 
                { 
                    contador ‐= 1; 
                    if (contador > 1 && contador % 2 == 0) 
                    { 
                        nodoPredicado++; 
                    } 
                } 
                contador = 0; 
            } 
 
            Console.Write("La complejidad ciclomatica es " + (nodoPredicado + 1)); 
            Console.ReadLine(); 
        } 
 
        static void Main(string[] args) 
        { 
            Program pv = new Program(); 
 
            pv.matrizTamano(); 
            pv.llenarMatriz(); 
            pv.imprimir(); 
            pv.complejidad(); 
        } 
    } 
} 
10. Adicione algunos objetivos de prueba adicionales que no se estudiaron en la sección
18.1.

 Identificar y asegurar que los defectos encontrados se han corregido antes de

entregar el software al cliente.
 Diseñar casos de prueba que sistemáticamente saquen a la luz diferentes clases de
errores, haciéndolo con la menor cantidad de tiempo y esfuerzo.
 Una parte necesaria de un caso de prueba es la definición del resultado esperado.
 Los casos de pruebas tienen que ser escritos no solo para condiciones de entrada
válidas y esperadas sino también para condiciones no válidas e inesperadas.
 El número de errores sin descubrir es directamente proporcional al número de
errores descubiertos.

11. Diseñe una herramienta automatizada que reconozca bucles y que los clasifique
como se indica en la sección 18.5.3.
12. using System; 
13. using System.Collections.Generic; 
14. using System.Linq; 
15. using System.Text; 
16. using System.Threading.Tasks; 
17.  
18. namespace matriz_bucle 
19. { 
20.     class Program 
21.     { 
22.         string[] bucles = { "for", "while" }; 
23.         string[] tipos = { "Es un bucle simple", "Es un bucle anidado", "Es un 
bucle concatenado", "Es un bucle no estructurado" }; 
24.         int[] tiposBucles = { 0, 0, 0, 0 }; 
25.         int contando = 0; 
26.         string texto = ""; 
27.         int contador = 0; 
28.         bool buclesBool = false; 
29.         bool boolEncontrado = false; 
30.  
31.         public void codigo() 
32.         { 
33.             Console.WriteLine("Favor digitar el codigo a reconocer:\n"); 
34.             string codigo = Console.ReadLine(); 
35.  
36.             for (int i = 0; i < codigo.Length; i++) 
37.             { 
38.  
39.                 texto += codigo[i]; 
40.                 if (texto.Length >= 0 && texto.Length <= 5) 
41.                 { 
42.                     for (int j = 0; j < bucles.Length; j++) 
43.                     { 
44.                         if ((boolEncontrado = 
texto.ToUpper().Equals(bucles[j].ToUpper()))) 
45.                         { 
46.                             buclesBool = boolEncontrado; 
47.                             if (contador == 0) 
48.                             { 
49.                                 contando++; 
50.                             } 
51.                         } 
52.                     } 
53.                 } 
54.  
55.                 if (codigo[i] == '{') 
56.                 { 
57.                     contador++; 
58.                     texto = ""; 
59.                 } 
60.                 else if (codigo[i] == '}') 
61.                 { 
62.                     contador‐‐; 
63.                     texto = ""; 
64.                 } 
65.  
66.                 if (contador == 0 && buclesBool) 
67.                 { 
68.                     tiposBucles[0] = 1; 
69.                     buclesBool = false; 
70.                 } 
71.                 else if (contador > 0 && buclesBool) 
72.                 { 
73.                     tiposBucles[0] = 0; 
74.                     tiposBucles[1] = 2; 
75.                     buclesBool = false; 
76.                 } 
77.  
78.                 if (contando > 1) 
79.                 { 
80.                     tiposBucles[0] = 0; 
81.                     tiposBucles[2] = 3; 
82.                 } 
83.  
84.                 if (codigo[i] == ' ') 
85.                 { 
86.                     texto = ""; 
87.                 } 
88.  
89.             } 
90.         } 
91.  
92.         public void respuesta() 
93.         { 
94.             for (int i = 0; i < tiposBucles.Length; i++) 
95.             { 
96.                 if (tiposBucles[i] > 0) 
97.                 { 
98.                     Console.WriteLine("\n" + tipos[tiposBucles[i] ‐ 1]); 
99.                 } 
100.             } 
101.             Console.ReadKey(true); 
102.         } 
103.  
104.  
105.         public static void Main(string[] args) 
106.         { 
107.  
108.             Program pv = new Program(); 
109.  
110.             pv.codigo(); 
111.             pv.respuesta(); 
112.              
113.  
114.              
115.         } 
116.     } 
117. } 

12- ¿Las pruebas exhaustivas (incluso si es posible para programas muy pequeños)
garantizarán que el programa es 100 por ciento correcto? Justifique su respuesta.

No, incluso las pruebas exhaustivas no garantizarán que la el programa es 100 por ciento
correcto. Hay demasiadas variables a tener en cuenta. Considera lo siguiente: Pruebas de
instalación ¿Se instaló el programa de acuerdo con las instrucciones?

Pruebas de integración:

¿Funcionó el programa con todos los otros programas en el sistema sin interferencia, y lo
hizo Los módulos instalados del programa se integran y funcionan? ¿Con otros módulos
instalados?

Prueba de funcionamiento:

¿Funcionó cada una de las funciones del programa correctamente?

Pruebas unitarias:

¿Funcionó la unidad como independiente diseñado, y funcionó la unidad cuando se

coloca en el general proceso? Pruebas de aceptación del usuario: ¿cumplió el programa
todos los ¿Los requisitos del usuario y el trabajo según el diseño del usuario? Si bien
estas son solo las pruebas básicas para un exhaustivo escenario de prueba, podría seguir
probando más allá de estas pruebas utilizando métodos destructivos, programa interno de
caja blanca, pruebas, establecer ejercicios del programa utilizando automatizado guiones,
etc