Preguntas tipo test (I) Indique cuál de los siguientes enunciados es verdadero: La etapa de mayor coste en tiempo y recursos es la implementación. En los modelos de desarrollo basados en prototipos lo deseable es incrementar los factores de calidad en cada iteración manteniendo constante la funcionalidad. Un incremento en la eficiencia suele afectar negativamente a la extendibilidad. El nivel de cohesión mide el grado de interrelación entre los módulos.  Programación II (Sistemas) - Curso 2002/03

Preguntas tipo test (II) Indique cuál de los siguientes enunciados es falso: La etapa de análisis produce como resultado las especificaciones de la aplicación. Un módulo debe ocultar los detalles de cómo realiza su tarea. Los factores de calidad son independientes entre sí. Reducir la cohesión puede incrementar el acoplamiento, y viceversa.  Programación II (Sistemas) - Curso 2002/03

Preguntas tipo test (III) En el paradigma de programación bajo contrato.. Un módulo nunca puede fallar. Los parámetros de un módulo deben cumplir la postcondición para que la precondición sea cierta. Si la precondición es cierta, entonces los resultados deben cumplir la postcondición. El módulo que llama a otro debe garantizar su postcondición.  Programación II (Sistemas) - Curso 2002/03

Preguntas tipo test (IV) La descripción de los objetivos de la aplicación se encuentra en.. Sólo en el documento de especificaciones, dentro de la documentación del sistema. Sólo en el documento de descripción funcional, dentro de la documentación del usuario. En los dos documentos anteriores. En ningún documento concreto.  Programación II (Sistemas) - Curso 2002/03

Preguntas tipo test (V) Un analista diseña una batería de pruebas para un módulo. Al probar el módulo con esa batería no se detecta ningún fallo. ¿Cuál sería la valoración más adecuada de éste resultado desde el punto de vista del analista? La prueba ha sido un éxito. La prueba ha sido un fracaso. El módulo está libre de errores. El diseño de la batería de pruebas es correcto.  Programación II (Sistemas) - Curso 2002/03

Preguntas tipo test (VI) Un módulo recibe como entrada dos enteros, a y b, y devuelve como resultado la cadena "error" si a < 0, la cadena "iguales" si a = b (y no es error) y "distintos" en el resto de casos. Indicar cuál de los siguientes conjuntos de pares de valores (a,b) podría corresponder a la columna de entradas de una batería de pruebas obtenida aplicando la técnica de caja negra (sin análisis de valores límite): (0,0) (0,1) (1,0) (1,1) (-1,-1) (-1,1) (-1,0) (0,-1) (-1,-1) (4,-3) (2,2) (-3,3) Particiones {a < 0}1 {a  0, a = b}2 {a  0, a  b}3 2,3,3 2,1,1 1,3,1  3,2,1 Programación II (Sistemas) - Curso 2002/03

Preguntas tipo test (VII) Indicar cuál de las siguientes afirmaciones es falsa: La cobertura de decisiónes incluye cobertura de sentencias. Si no existen ramas vacías, la cobertura de sentencias incluye cobertura de decisiones. Si no existen decisiones anidadas, la cobertura de condiciónes incluye cobertura de decisiones. Si cada decisión consta de una única condición, la cobertura de condición múltiple es equivalente a cobertura de condiciónes.  C1 or C2 + _ Dec. C1 C2 T T F T F T Programación II (Sistemas) - Curso 2002/03

Preguntas tipo test (VIII) Indique la precondición más débil que hace correcto el siguiente fragmento de código: { falso } n := n+1; { n = n+1 } { cierto } n := n+1; { n = n+1 } { n = n } n := n+1; { n = n+1 } { n = N } n := n+1; { n = n+1 }  falso Programación II (Sistemas) - Curso 2002/03

Preguntas de respuesta corta (I) Un módulo recibe como entrada una fecha (dia, mes y año) y devuelve dos valores: El número de días transcurridos desde el 1/1/2000, y el día de la semana (calculado a partir del valor anterior). ¿Cuál es el nivel de cohesión del módulo? Éste módulo es llamado por otro al que sólo le interesa saber el día de la semana. ¿Cuál sería el tipo de acoplamiento entre los módulos? Secuencial Acoplamiento por Estructura Programación II (Sistemas) - Curso 2002/03

Preguntas de respuesta corta (II) ¿Existe alguna cobertura de caja blanca que garantice que con los casos de prueba generados se van a recorrer todos los posibles flujos de ejecución del algoritmo? Si la respuesta es afirmativa, indicar cual es esa cobertura y justificar la respuesta. En caso contrario, proporcionar un contraejemplo. Cobertura de cond. múltiple C2a and C2b C1a and C1b D1 D2 D1 D2 C1a C1b C2a C2b T T T T T T F F T F T F F F F T F T F F F F F F Contraejemplo: existen caminos no cubiertos Programación II (Sistemas) - Curso 2002/03

{ a = x+d } { x  y } Problema (I) Se dispone de la siguiente función: function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; while a <> y do <a,d> := <a+1,d+1> end end; Para los siguientes candidatos a invariantes del bucle, comprobar si son correctos o no. En caso afirmativo encontrar la postcondición. { a = x+d } { x  y } Programación II (Sistemas) - Curso 2002/03

Candidato a invariante: { a = x+d } Problema (II) Candidato a invariante: { a = x+d } function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; { a = x+1, d = 0 }  { a = x+d } while a <> y do { a = x+d, a  y } { a+1 = x+d+1, a+1  y+1 } <a,d> := <a+1,d+1> { a = x+d, a  y+1 } { a = x+d } end end; function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; { a = x+1, d = 0, y  x } while a <> y do { a = x+d, a  y } { a+1 = x+d+1, a+1  y+1 } <a,d> := <a+1,d+1> { a = x+d, a  y+1 } { a = x+d } end end; function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; { a = x+1, d = 0 }  { a = x+d } while a <> y do { a = x+d, a  y } { a+1 = x+d+1, a+1  y+1 } <a,d> := <a+1,d+1> { a = x+d, a  y+1 } { a = x+d } end end; function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; { a = x+1, d = 0 }  { a = x+d } { a = x+1, d = 0 }  { x+1 = x+0 } while a <> y do { a = x+d, a  y } { a+1 = x+d+1, a+1  y+1 } <a,d> := <a+1,d+1> { a = x+d, a  y+1 } { a = x+d } end end; function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; while a <> y do { a = x+d, a  y } { a+1 = x+d+1, a+1  y+1 } <a,d> := <a+1,d+1> { a = x+d, a  y+1 } { a = x+d } end end; function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; while a <> y do { a = x+d, a  y } { a+1 = x+d+1, a+1  y+1 } <a,d> := <a+1,d+1> end end; function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; while a <> y do <a,d> := <a+1,d+1> end end; function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; while a <> y do <a,d> := <a+1,d+1> { a = x+d } end end; function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; while a <> y do { a = x+d, a  y } <a,d> := <a+1,d+1> { a = x+d } end end; function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; while a <> y do { a = x+d, a  y } { a+1 = x+d+1, a+1  y+1 } <a,d> := <a+1,d+1> { a = x+d, a  y+1 } end end; Programación II (Sistemas) - Curso 2002/03

Candidato a invariante: { x  y } Problema (III) Candidato a invariante: { x  y } function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; while a <> y do <a,d> := <a+1,d+1> end end; function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; { a = x+1, d = 0, x  y }  { x  y } while a <> y do { x  y } <a,d> := <a+1,d+1> end end; Programación II (Sistemas) - Curso 2002/03

|y-x-n-2| < |y-x-n-1| y-x-n-2 < -1 -y+x+n+2 < -y+x+n+1 Problema (IV) Demostrar la finitud del algoritmo indicando, en su caso, las modificaciones que se deberían realizar a la pre-condición. function dif(x,y: integer) dev d: integer; var a: integer; begin { y  x } <a,d> := <x+1,0>; while a <> y do <a,d> := <a+1,d+1> end end; vn = |y-a| = |y-x-n-1| vn+1 < vn |y-x-n-2| < |y-x-n-1| y-x-n-2 < -1 -y+x+n+2 < -y+x+n+1 2 < 1 falso vn = |y-a| = |y-x-n-1| vn+1 < vn |y-x-n-2| < |y-x-n-1| y-x-n-2 = -1 |-1| < |0| 1 < 0 falso vn = |y-a| = |y-x-n-1| vn+1 < vn |y-x-n-2| < |y-x-n-1| y-x-n-2 > 0 y-x-n-2 < y-x-n-1 -1 < 0 cierto vn = |y-a| = |y-x-n-1| vn  0  |y-a| = 0  y = a vn > 0  |y-a| > 0  y  a an = x+1+n y-x-n-2 > 0  y  x-1 Programación II (Sistemas) - Curso 2002/03