|
|
@@ -0,0 +1,284 @@
|
|
|
1
|
+[English](#markdown-header-testing-and-unit-testing) | [Español](#markdown-header-pruebas-y-pruebas-unitarias)
|
|
|
2
|
+
|
|
|
3
|
+#Pruebas y pruebas unitarias
|
|
|
4
|
+
|
|
|
5
|
+
|
|
|
6
|
+
|
|
|
7
|
+
|
|
|
8
|
+
|
|
|
9
|
+
|
|
|
10
|
+Como habrás aprendido en experiencias de laboratorio anteriores, el lograr que un programa compile es solo una pequeña parte de programar. El compilador se encargará de decirte si hubo errores de sintaxis, pero no podrá detectar errores en la lógica del programa. Es muy importante el probar las funciones del programa para validar que producen los resultados correctos y esperados.
|
|
|
11
|
+
|
|
|
12
|
+Una manera de hacer estas pruebas es verificando partes del programa "a mano". Otra manera es insertando pedazos de código o funciones y probando el programa con conjuntos representativos de datos que verifiquen si el programa va haciendo lo que se supone y te ayude a detectar problemas. La biblioteca `cassert` de C++ tiene funciones para hacer pruebas y en la experiencia de laboratorio de hoy utilizarás una de ellas.
|
|
|
13
|
+
|
|
|
14
|
+
|
|
|
15
|
+
|
|
|
16
|
+##Objetivos:
|
|
|
17
|
+
|
|
|
18
|
+1. Validar el funcionamiento de varios programas haciendo pruebas "a mano".
|
|
|
19
|
+2. Crear pruebas unitarias para validar funciones a partir de su descripción.
|
|
|
20
|
+
|
|
|
21
|
+
|
|
|
22
|
+
|
|
|
23
|
+##Pre-Lab:
|
|
|
24
|
+
|
|
|
25
|
+Antes de llegar al laboratorio debes:
|
|
|
26
|
+
|
|
|
27
|
+1. haber repasado los conceptos básicos relacionados a pruebas y pruebas unitarias.
|
|
|
28
|
+
|
|
|
29
|
+2. haber repasado el uso de la función `assert` para hacer pruebas.
|
|
|
30
|
+
|
|
|
31
|
+3. haber estudiado los conceptos e instrucciones para la sesión de laboratorio.
|
|
|
32
|
+
|
|
|
33
|
+4. haber tomado el [quiz Pre-Lab 7](http://moodle.ccom.uprrp.edu/mod/quiz/attempt.php?attempt=2134) (recuerda que el quiz Pre-Lab puede tener conceptos explicados en las instrucciones del laboratorio).
|
|
|
34
|
+
|
|
|
35
|
+
|
|
|
36
|
+##Sesión de laboratorio:
|
|
|
37
|
+
|
|
|
38
|
+###Ejercicio 1
|
|
|
39
|
+
|
|
|
40
|
+Este ejercicio es una adaptación del ejercicio en [1]. Se te ha dado un programa que implementa varias versiones de cinco funciones simples, por ejemplo, el juego "piedra-papel-tijera" y el ordenar 3 números. Probando las versiones de cada función, tú y tu pareja determinarán cuál de las versiones está implementada correctamente.
|
|
|
41
|
+
|
|
|
42
|
+Este ejercicion **NO requiere programación**, solo pruebas "a mano". Para este ejercicio no tienes que implementar las pruebas unitarias, solo usa tu habilidad de hacer pruebas a mano.
|
|
|
43
|
+
|
|
|
44
|
+Por ejemplo, asumamos que una amiga te provee un porgrama. Ella asegura que el programa resuleve el siguiente problema
|
|
|
45
|
+
|
|
|
46
|
+ "dados tres enteros, despliega el valor máximo".
|
|
|
47
|
+
|
|
|
48
|
+Supongamos que el programa tienen una interfase como la siguiente:
|
|
|
49
|
+
|
|
|
50
|
+
|
|
|
51
|
+
|
|
|
52
|
+
|
|
|
53
|
+**Figura 1** - Interfase de un programa para hallar el valor máximo entre tres enteros.
|
|
|
54
|
+
|
|
|
55
|
+Podrías determinar si el programa provee resultados válidos **sin analizar el código fuente**. Por ejemplo, podrías intentar los siguientes casos:
|
|
|
56
|
+
|
|
|
57
|
+* a = 4, b = 2, c = 1; resultado esperado: 4
|
|
|
58
|
+* a = 3, b = 6, c = 2; resultado esperado: 6
|
|
|
59
|
+* a = 1, b = 10, c = 100; resultado esperado: 100
|
|
|
60
|
+
|
|
|
61
|
+Si alguno de estos tres casos no da el resultado esperado, el programa de tu amiga no funciona. Por otro lado, si los tres casos funcionan, entonces el programa tiene una probabilidad alta de estar correcto.
|
|
|
62
|
+
|
|
|
63
|
+En este ejercicio estarás validando varias versiones de las siguientes funciones:
|
|
|
64
|
+
|
|
|
65
|
+
|
|
|
66
|
+* **3 Sorts:** una función que recibe tres "strings" o números y los ordena en orden lexicográfico (alfabético). Por ejemplo, dados `jirafa`, `zorra`, y `coqui`, los ordena como: `coqui`, `jirafa`, y `zorra`. Para simplificar el ejercicio, solo usaremos "strings" con letras minúsculas. Otro ejemplo, dados `1`, `3` y `2`, los ordena como `1`, `2`, y `3`.
|
|
|
67
|
+
|
|
|
68
|
+ 
|
|
|
69
|
+
|
|
|
70
|
+ **Figura 2** - Interfase de la función `3 Sorts`.
|
|
|
71
|
+
|
|
|
72
|
+
|
|
|
73
|
+
|
|
|
74
|
+
|
|
|
75
|
+
|
|
|
76
|
+* **Dice:** cuando el usuario marca el botón `Roll them`, el programa genera dos números aleatorios entre 1 y 6. El programa informa la suma de los números aleatorios. Tu tarea es determinar en cuál de las versiones (si alguna) la programadora implementó bien la función de suma.
|
|
|
77
|
+
|
|
|
78
|
+ 
|
|
|
79
|
+
|
|
|
80
|
+ **Figura 3** - Interfase de la función `Dice`.
|
|
|
81
|
+
|
|
|
82
|
+* **Rock, Papers, Scissors:** Cada uno de los jugadores entra su jugada y el programa informa quién ganó. La interfase del juego se muestra en la siguiente figura:
|
|
|
83
|
+
|
|
|
84
|
+ 
|
|
|
85
|
+
|
|
|
86
|
+ **Figura 4** - Interfase de la función `Rock, Papers, Scissors`.
|
|
|
87
|
+
|
|
|
88
|
+
|
|
|
89
|
+* **Zulu time:** Dada una hora en tiempo Zulu (Hora en el Meridiano de Greenwich) y la zona militar en la que el usuario desea saber la hora, el programa escribe la hora en esa zona. El formato para el dato de entrada es en formato de 23 horas `####`, por ejemplo `2212` sería las 10:12 pm. La lista de zonas militares válidas la puedes encontrar en http://en.wikipedia.org/wiki/List_of_military_time_zones. Lo que sigue son ejemplos de cómo deben ser los resultados del programa:
|
|
|
90
|
+
|
|
|
91
|
+ * Dada hora Zulu 1230 y zona A (UTC+1), el resultado debe ser 1330.
|
|
|
92
|
+ * Dada hora Zulu 1230 y zona N (UTC-1), el resultado debe ser 1130.
|
|
|
93
|
+ * Puerto Rico está en la zona militar Q (UTC-4), por lo tanto, cuando es 1800 en hora Zulu, son las 1400 en Puerto Rico.
|
|
|
94
|
+
|
|
|
95
|
+ 
|
|
|
96
|
+
|
|
|
97
|
+ **Figura 5** - Interfase de la función `Zulu time`.
|
|
|
98
|
+
|
|
|
99
|
+####**Instrucciones:**
|
|
|
100
|
+
|
|
|
101
|
+1. Por favor, asegúrate de que tú y tu apreja de laboratorio entienden las descripciones de las funciones de arriba. Pregúntale a tu instructor de laboratorio si necesitas aclarar algo. Para cada una de las funciones descritas arriba, escribe en tu libreta las pruebas que harás para determinar la validez de las funciones. Para cada función, piensa en los errores lógicos que la programadora pudo haber cometido y escribe una prueba que determine si se cometió ese error. Para cada prueba, escribe los valores que utilizarás y el resultado que esperas obtener.
|
|
|
102
|
+
|
|
|
103
|
+
|
|
|
104
|
+2. Abre un terminal y escribe el comando `git clone https://bitbucket.org/eip-uprrp/lab07-testing.git` para descargar la carpeta `Lab07-Testing` a tu computadora.
|
|
|
105
|
+
|
|
|
106
|
+3. Haz doble "click" en el archivo `testing.pro` para cargar este proyecto a Qt.
|
|
|
107
|
+
|
|
|
108
|
+4. Corre el programa. Verás una pantalla similar a la siguiente:
|
|
|
109
|
+
|
|
|
110
|
+ 
|
|
|
111
|
+
|
|
|
112
|
+ **Figura 6** - Pantalla para seleccionar la función que se va a probar.
|
|
|
113
|
+
|
|
|
114
|
+5. Selecciona el botón de `3 Sorts` y obtendrás la siguiente interfase:
|
|
|
115
|
+
|
|
|
116
|
+
|
|
|
117
|
+ 
|
|
|
118
|
+
|
|
|
119
|
+ **Figura 7** - Interfase de `3 Sorts`.
|
|
|
120
|
+
|
|
|
121
|
+
|
|
|
122
|
+6. La "Version Alpha" en la caja indica que estás corriendo la primera versión del algoritmo `3 Sorts`. Usa las pruebas que escibiste en el paso 1 para validar la "Version Alpha". Luego, haz lo mismo para las versiones Beta, Gamma y Delta. Escribe cuál es la versión correcta en cada una de las funciones. Además, explica las pruebas que realizaste y que te permitieron determinar que las otras versiones son incorrectas.
|
|
|
123
|
+
|
|
|
124
|
+Por ejemplo, puedes organizar tus respuestas en una tabla como la que sigue:
|
|
|
125
|
+
|
|
|
126
|
+
|
|
|
127
|
+| 3 Sorts | | | | | |
|
|
|
128
|
+| ------------- | ----------- | ----------- | ----------- | ----------- | ----------- |
|
|
|
129
|
+| Num | Test | Result Alpha | Res. Beta | Res. Gamma | Res. Delta |
|
|
|
130
|
+| 1| "alce", "coyote", "zorro" | "alce", "coyote", "zorro" | .... | .... |
|
|
|
131
|
+| 2| "alce", "zorro", "coyote" | "zorro", "alce", "coyote" | .... | .... |
|
|
|
132
|
+
|
|
|
133
|
+
|
|
|
134
|
+**Figura 8** - Tabla para organizar resultados de las pruebas.
|
|
|
135
|
+
|
|
|
136
|
+Recuerda añadir información que indique cuál(es) de las versiones fueron implementadas correctamente. También recuerda especificar cuáles pruebas te permitieron determinar las versiones que eran incorrectas. **Nota:** en cada una de las funciones, puede que ninguna versión sea correcta y puede que haya más de una versión correcta.
|
|
|
137
|
+
|
|
|
138
|
+Puedes ver ejemplos de cómo organizar tus resultados [aquí](http://i.imgur.com/ggDZ3TQ.png) y [aquí](http://i.imgur.com/rpApVqm.png). Entrega los resultados de este ejercicio en la sección de [Entregas del Lab 7 en Moodle](http://moodle.ccom.uprrp.edu/mod/quiz/edit.php?cmid=7145).
|
|
|
139
|
+
|
|
|
140
|
+
|
|
|
141
|
+###Ejercicio 2
|
|
|
142
|
+
|
|
|
143
|
+Hacer pruebas "a mano" cada vez que corres un programa es una tarea que resulta "cansona" bien rápido. Tú y tu pareja lo hicieron para unas pocas funciones simples. !Imagínate hacer lo mismo para un programa complejo completo como un buscador o un procesador de palabras!
|
|
|
144
|
+
|
|
|
145
|
+Las *pruebas unitarias* ayudan a los programadores a validar códigos y simplificar el proceso de depuración ("debugging") a la vez que evitan la tarea tediosa de hacer pruebas a mano en cada ejecución.
|
|
|
146
|
+
|
|
|
147
|
+####**Instrucciones:**
|
|
|
148
|
+
|
|
|
149
|
+1. En el menú de QT, ve a `Build` y selecciona `Clean Project "Testing"`.
|
|
|
150
|
+
|
|
|
151
|
+2. Ve a la carpeta `Lab07-Testing` y haz doble "click" en el archivo `UnitTests.pro` para cargar este proyecto a Qt.
|
|
|
152
|
+
|
|
|
153
|
+3. El proyecto solo contiene el archivo de código fuente `main.cpp`. Este archivo contiene cuatro funciones: `fact`, `isALetter`, `isValidTime`, y `gcd`, cuyos resultados son solo parcialmente correctos. Tu tarea es escribir pruebas unitarias para cada una de las funciones para identificar los resultados erróneos. ** No necesitas reescribir las funciones para corregirlas. **
|
|
|
154
|
+
|
|
|
155
|
+ Para la función `fact` se provee la función `test_fact()` como función de prueba unitaria. Si invocas esta función desde `main`, compilas y corres el programa debes obtener un mensaje como el siguiente:
|
|
|
156
|
+
|
|
|
157
|
+
|
|
|
158
|
+ ```cpp
|
|
|
159
|
+ Assertion failed: (fact(2) == 2), function test_fact,
|
|
|
160
|
+
|
|
|
161
|
+ file ../UnitTests/main.cpp, line 69.
|
|
|
162
|
+ ```
|
|
|
163
|
+
|
|
|
164
|
+ Esto debe ser suficiente para saber que la función `fact` NO está correctamente implementada. Comenta la invocación de `test_fact()` en `main`.
|
|
|
165
|
+
|
|
|
166
|
+
|
|
|
167
|
+4. Escribe una prueba unitaria llamada `test_isALetter` para la función `isALetter`. En la prueba unitaria escribe varias afirmaciones ("asserts") para probar algunos datos de entrada y sus valores esperados (mira la función `test_fact` para que te inspires). Invoca `test_isALetter` desde `main`. Continúa escribiendo "asserts" hasta que alguno falle. Copia la prueba unitaria `test_isALetter` y el mensaje de afirmación obtenido en un archivo.
|
|
|
168
|
+
|
|
|
169
|
+5. Repite el paso 4 paras las otras dos funciones, `isValidTime` y `gcd`. Recuerda que debes llamar a cada una de las funciones de prueba unitaria desde `main` para que corran. Copia cada una de las funciones y los mensajes de afirmación obtenidos en el archivo y entrega el archivo [aquí]
|
|
|
170
|
+(http://moodle.ccom.uprrp.edu/mod/assignment/view.php?id=7546).
|
|
|
171
|
+
|
|
|
172
|
+
|
|
|
173
|
+
|
|
|
174
|
+## Referencias
|
|
|
175
|
+
|
|
|
176
|
+[1] http://nifty.stanford.edu/2005/TestMe/
|
|
|
177
|
+
|
|
|
178
|
+[English](#markdown-header-testing-and-unit-testing) | [Español](#markdown-header-pruebas-y-pruebas-unitarias)
|
|
|
179
|
+
|
|
|
180
|
+#Testing and Unit Testing
|
|
|
181
|
+
|
|
|
182
|
+
|
|
|
183
|
+
|
|
|
184
|
+
|
|
|
185
|
+
|
|
|
186
|
+##Objectives
|
|
|
187
|
+
|
|
|
188
|
+Throughout this exercise the students will practice:
|
|
|
189
|
+
|
|
|
190
|
+* Testing various versions of a program to validate their operation
|
|
|
191
|
+* Unit Testing
|
|
|
192
|
+
|
|
|
193
|
+## Concepts
|
|
|
194
|
+
|
|
|
195
|
+As you have learned in previous labs, getting a program to compile is only a minor part of programming. It is super important to test functions in order to validate that they produce the correct results.
|
|
|
196
|
+
|
|
|
197
|
+
|
|
|
198
|
+### Exercise 1
|
|
|
199
|
+
|
|
|
200
|
+This exercise is an adaptation of [1]. You are provided with a program that implements several versions of five simple functions, e.g. rock-paper-scisors, sorting 3 numbers. By testing the versions, you and your partner will determine which of the versions is correctly implemented.
|
|
|
201
|
+
|
|
|
202
|
+This first exercise requires **NO programming**, just testing. For this first exercise, you **do not** have to implement any unit tests. Just use you testing ability (*by hand*) to determine which function version is the one that is correctly implemented.
|
|
|
203
|
+
|
|
|
204
|
+For instance, let us assume that a friend provides you with a program. He claims that his program solves the following problem:
|
|
|
205
|
+
|
|
|
206
|
+> *"given three different integers, displays the maximum value"*.
|
|
|
207
|
+
|
|
|
208
|
+Let's say that the program has an interfaces as follows:
|
|
|
209
|
+
|
|
|
210
|
+
|
|
|
211
|
+
|
|
|
212
|
+**Without analysing the source code**, you could determine if the program provides valid results. You could try the following cases:
|
|
|
213
|
+
|
|
|
214
|
+* a = 4, b = 2, c = 1, expect result: 4
|
|
|
215
|
+* a = 3, b = 6, c = 2, expected result: 6
|
|
|
216
|
+* a = 1, b = 10, c = 100, expected result: 100
|
|
|
217
|
+
|
|
|
218
|
+If any of the three cases fails to give the expected result, you friend's program is not working. On the other hand, If all three cases are successful, then the program has a high probability of being correct.
|
|
|
219
|
+
|
|
|
220
|
+In this exercise, you will be validating various versions of the following functions:
|
|
|
221
|
+
|
|
|
222
|
+* **3 Sorts**: a program that receives three strings and sorts them in lexicographical order. For example, given `jirafa`, `zorra`, and `coqui`. Will sort them as: `coqui`, `jirafa`, and `zorra`.
|
|
|
223
|
+
|
|
|
224
|
+* **Dice**: when the user presses the `Roll them` button, the program will generate two random numbers between 1 and 6. The sum of the random numbers is reported.
|
|
|
225
|
+
|
|
|
226
|
+* **Rock, Papers, Scissors**: The user enters the play for the two players ( 'R' for Rock, 'P' for Paper and 'S' for Scissors) and specifies the number of games needed to win the tournament. The program then reports who won and the score. The program reports if a player wins the tournament.
|
|
|
227
|
+
|
|
|
228
|
+* **Check Writer**: The user enters a number between 0 and 999,999,999 (inclusive). The program's output is a long string version of the number. For example, if the user inputs '654123' the program will output 'six hundred fifty four thousand one hundred twenty three'.
|
|
|
229
|
+
|
|
|
230
|
+* **Zulu time**: given the time in zulu time (Greenwich Mean Time) and the military zone that the user whishes to know, the program outputs the time at that zone. The format for the input is `####` in 23 hour format, e.g. 2212. The list of valid military zones is given in http://en.wikipedia.org/wiki/List_of_military_time_zones. Examples of correct output:
|
|
|
231
|
+ * Given 1230 and zone A, the output would be 1330
|
|
|
232
|
+ * Given 1230 and zone N, the output would be 1130
|
|
|
233
|
+
|
|
|
234
|
+
|
|
|
235
|
+Step 1:
|
|
|
236
|
+For each of the functions described above, write down in your notebook the tests that you will perform in order to determine validity.
|
|
|
237
|
+
|
|
|
238
|
+Step 2:
|
|
|
239
|
+Download the program from $XYZ$.
|
|
|
240
|
+
|
|
|
241
|
+Step 3:
|
|
|
242
|
+Run the program. You will see a window similar to the following:
|
|
|
243
|
+
|
|
|
244
|
+
|
|
|
245
|
+
|
|
|
246
|
+Click the **3 Sorts** button and you will get the following:
|
|
|
247
|
+
|
|
|
248
|
+
|
|
|
249
|
+
|
|
|
250
|
+The "Version Alpha" combo box indicates that you are running the first version of the 3 Sorts algorithm. Use the tests that you wrote in step 1 to validate "Version Alpha". Then, do the same for versions beta, gamma and delta. Report which is the correct version in every method. Also, explain the tests that you performed that allowed you to determine that the other versions are incorrect.
|
|
|
251
|
+
|
|
|
252
|
+For example, you could organice your results into a table.
|
|
|
253
|
+
|
|
|
254
|
+| Num | Test | Alpha | Beta | Gamma | Delta |
|
|
|
255
|
+| ------------- | ----------- | ----------- | ----------- | ----------- | ----------- |
|
|
|
256
|
+| 1| "alce", "coyote", "zorro" | "alce", "coyote", "zorro" | .... | .... |
|
|
|
257
|
+| 2| "alce", "zorro", "coyote" | "zorro", "alce", "coyote" | .... | .... |
|
|
|
258
|
+
|
|
|
259
|
+### Exercise 2
|
|
|
260
|
+
|
|
|
261
|
+Running tests "by hand" each time that you run a program gets tiresome very quickly. You and your partner have done it for a few simple functions. Imagine doing the same for full-blown program!, such as a browser or word processor.
|
|
|
262
|
+
|
|
|
263
|
+*Unit tests* help programmers produce valid code and ease the process of debugging while avoiding the tedious task of entering tests by hand on each execution.
|
|
|
264
|
+
|
|
|
265
|
+
|
|
|
266
|
+Step 1:
|
|
|
267
|
+Download the proyect from $XYZ$. The proyect contains only one source code file `main.cpp`. This file contains four functions whose results are only partially correct. Your task is to write unit tests for each them to identify their wrong results. **You do not need to rewrite the functions to correct them**.
|
|
|
268
|
+
|
|
|
269
|
+A unit test function `test_fact()` is provided for the function `fact`. If you invoke this function from `main` and compile and run the program. You will get the following message:
|
|
|
270
|
+
|
|
|
271
|
+```cpp
|
|
|
272
|
+Assertion failed: (fact(2) == 2), function test_fact, file ../UnitTests/main.cpp, line 69.
|
|
|
273
|
+```
|
|
|
274
|
+
|
|
|
275
|
+This would be enough for us to claim that function `fact` is not correctly implemented. Comment the invocation of `test_fact()` from main.
|
|
|
276
|
+
|
|
|
277
|
+Step 2:
|
|
|
278
|
+Write unit tests for the rest of the functions. Remember that you must call each of the unit test functions from the `main` for them to run. Copy each of the functions in the provided sheet.
|
|
|
279
|
+
|
|
|
280
|
+
|
|
|
281
|
+### References
|
|
|
282
|
+
|
|
|
283
|
+[1] http://nifty.stanford.edu/2005/TestMe/
|
|
|
284
|
+
|
