openprompt-lang 0.7.0 → 0.8.0

package/src/templates/knowledge/chapters/web/rust-libro-espanol/ch11-01-writing-tests_html.md

@@ -1,2226 +0,0 @@
-# Cómo Escribir Tests - El Lenguaje de Programación Rust
-
-> Fuente: [https://book.rustlang-es.org/ch11-01-writing-tests.html](https://book.rustlang-es.org/ch11-01-writing-tests.html)
-
-Los tests son funciones en Rust que verifican que el código no-test funciona de
-la manera esperada. Los cuerpos de las funciones de test típicamente realizan
-estas tres acciones:
-
-Veamos las características que Rust provee específicamente para escribir tests
-que incluyen el atributotest, algunas macros, y el atributoshould_panic.
-
-En su forma más simple, un test en Rust es una función que está anotada con el
-atributotest. Los atributos son metadatos sobre piezas de código Rust; un
-ejemplo es el atributoderiveque usamos con structs en el Capítulo 5. Para
-cambiar una función en una función de test, agrega#[test]en la línea antes
-defn. Cuando ejecutas tus tests con el comandocargo test, Rust construye
-un binario que corre las funciones anotadas y reporta si cada función de test
-pasa o falla.
-
-Cuando creamos un nuevo proyecto de librería con Cargo, se genera
-automáticamente un módulo de test con una función de test. Este módulo te da
-una plantilla para escribir tus tests para que no tengas que buscar la
-estructura y sintaxis exacta cada vez que comiences un nuevo proyecto. ¡Puedes
-agregar tantas funciones de test adicionales y tantos módulos de test como
-quieras!
-
-Exploraremos algunos aspectos de cómo funcionan los tests experimentando con la
-plantilla de test antes de testear cualquier código. Luego escribiremos algunos
-tests del mundo real que llaman a algún código que hemos escrito y verifican
-que su comportamiento es correcto.
-
-Creemos un nuevo proyecto de librería llamadoadderque sume dos números:
-
-El contenido del archivosrc/lib.rsen tu libreríaadderdebería verse como
-el Listado 11-1.
-
-El archivo comienza con una función de ejemplo llamadaadd, para que tengamos 
-algo que probar
-
-Por ahora, ignoremos las dos primeras líneas y nos enfoquemos solamente en la 
-funciónit_works().
-Nota la anotación#[test]: este atributo indica que esta es una función de
-test, así que el test runner sabe que debe tratar esta función como un test. También
-podríamos tener funciones no-test en el módulotestspara ayudar a configurar
-escenarios comunes o realizar operaciones comunes, así que siempre necesitamos
-indicar qué funciones son tests.
-
-El cuerpo de la función de test llama a la macroassert_eq!, que verifica que
-dos valores sean iguales. Si los valores no son iguales,assert_eq!falla y
-el test falla. Si son iguales, no pasa nada y el test pasa.
-
-El comandocargo testejecuta todos los tests en tu proyecto de librería, Como
-puedes ver en el Listado 11-2.
-
-Cargo compila y ejecuta el test. Vemos la línearunning 1 test. La siguiente
-línea muestra el nombre de la función de test generada, llamadatests::it_works, y que el resultado de ejecutar ese test esok. El resumen 
-generaltest result: ok.significa que todos los tests pasaron, y la porción 
-que lee1 passed; 0 failedtotaliza el número de tests que pasaron o fallaron.
-
-Es posible marcar un test como ignorado para que no se ejecute en una
-particular instancia; cubriremos eso en la sección“Ignorando algunos tests a
-menos que sean específicamente requeridos”más tarde
-en este capítulo. Porque no hemos hecho eso aquí, el resumen muestra0 ignored. También podemos pasar un argumento al comandocargo testpara
-ejecutar solo tests cuyo nombre coincida con un string; esto se llamafiltradoy lo cubriremos en la sección“Ejecutando un subconjunto de tests
-por nombre”. Tampoco hemos filtrado los tests que se
-ejecutan, así que el final del resumen muestra0 filtered out.
-
-La estadística0 measuredes para tests de benchmark que miden performance.
-Los tests de benchmark, al momento de escribir esto, solo están disponibles en
-Rust nightly. Verla documentación sobre tests de benchmarkpara
-aprender más.
-
-Nosotros podemos pasar un argumento al comandocargo testpara ejecutar solo
-los tests que coincidan con el nombre en un string; esto es conocido comofilteringy lo cubriremos en la sección“Ejecutando un sub conjunto de Tests por Nombre”. Aquí
-no filtraremos los tests para ser ejecutados, al final de todo mostrara0 filtered out.
-
-La siguiente parte del output de test, comenzando conDoc-tests adder, es
-para los resultados de cualquier test de documentación. No tenemos tests de
-documentación aún, pero Rust puede compilar cualquier ejemplo de código que
-aparezca en nuestra documentación de API. ¡Esta característica ayuda a mantener
-tus docs y tu código en sincronía! Discutiremos cómo escribir tests de
-documentación en la sección“Documentación como tests”del Capítulo 14. Por ahora, ignoraremos el outputDoc-tests.
-
-Comenzaremos a personalizar el test para nuestras propias necesidades. Primero
-cambiaremos el nombre de la funciónit_worksa un nombre diferente, comoexploration, así:
-
-Filename: src/lib.rs
-
-Entonces ejecutamoscargo testde nuevo. El output ahora muestraexplorationen lugar deit_works:
-
-Ahora agregaremos otro test, ¡pero esta vez haremos un test que falle! Los
-tests fallan cuando algo en la función de test hace panic. Cada test se ejecuta
-en un nuevo thread, y cuando el thread principal ve que un thread de test ha
-muerto, el test se marca como fallido. En el Capítulo 9, hablamos sobre cómo la
-forma más simple de hacer panic es llamar a la macropanic!. Ingresa el nuevo
-test como una función llamadaanother, así que tu archivosrc/lib.rsse ve
-como el Listado 11-3.
-
-Volvemos a ejecutar los tests usandocargo test. El output debería verse como
-el Listado 11-4, que muestra que nuestro testexplorationpasó yanotherfalló.
-
-En lugar deok, la líneatest tests::anothermuestraFAILED. Dos nuevas
-secciones aparecen entre los resultados individuales y el resumen: la primera
-muestra la razón detallada de cada falla de test. En este caso, obtenemos los
-detalles de queanotherfalló porquepanicked at 'Make this test fail'en la
-línea 17 del archivosrc/lib.rs. La siguiente sección lista solo los nombres
-de todos los tests que fallaron, lo cual es útil cuando hay muchos tests y
-mucho output detallado de tests fallidos. Podemos usar el nombre de un test
-fallido para ejecutar solo ese test y depurarlo más fácilmente; hablaremos más
-sobre formas de ejecutar tests en la sección“Controlando cómo se ejecutan los
-tests”.
-
-La línea de resumen se muestra al final: en general, nuestro resultado de test
-esFAILED. Tenemos un test que pasó y uno que falló.
-
-Ahora que has visto cómo se ven los resultados de tests en diferentes
-escenarios, veamos algunas macros que son útiles en tests que no seanpanic!.
-
-La macroassert!, proporcionada por la biblioteca estándar, es útil cuando
-quieres asegurarte de que alguna condición en un test se evalúe comotrue. Le
-damos a la macroassert!un argumento que se evalúa a un booleano. Si el valor
-estrue, no pasa nada y el test pasa. Si el valor esfalse, la macroassert!llama apanic!para hacer que el test falle. Usar la macroassert!nos ayuda a verificar que nuestro código esté funcionando de la forma que
-queremos.
-
-En el capítulo 5, en el Listado 5-15, usamos un structRectangley un métodocan_hold, que se repiten aquí en el Listado 11-5. Pondremos este código en el
-archivosrc/lib.rs, luego escribiremos algunos tests para él usando la macroassert!.
-
-El métodocan_holddevuelve un valor booleano, lo que significa que es un caso
-de uso perfecto para la macroassert!. En el Listado 11-6, escribimos un test
-que ejercita el métodocan_holdcreando una instancia deRectangleque tiene
-un ancho de 8 y una altura de 7 y afirmando que puede contener otra instancia
-deRectangleque tiene un ancho de 5 y una altura de 1.
-
-Observa que hemos agregado una nueva línea dentro del módulotests:use super::*;. El módulotestses un módulo regular que sigue las reglas de
-visibilidad habituales que cubrimos en el Capítulo 7 en la sección“Paths para referirse a un item en el árbol de
-módulos”.
-Como el módulotestses un módulo interno, necesitamos traer el código bajo
-test en el módulo externo al alcance del módulo interno. Usamos un asterisco aquí
-para que cualquier cosa que definamos en el módulo externo esté disponible para
-este módulotests.
-
-Hemos llamado a nuestro testlarger_can_hold_smaller, y hemos creado dos
-instancias deRectangleque necesitamos. Luego llamamos a la macroassert!y le pasamos el resultado de llamar alarger.can_hold(&smaller). Esta
-expresión debería devolvertrue, por lo que nuestro test debería pasar.
-¡Veámoslo!
-
-¡Pasó! Ahora agreguemos otro test, esta vez afirmando que un rectángulo más
-pequeño no puede contener un rectángulo más grande:
-
-Filename: src/lib.rs
-
-Porque el resultado correcto de la funcióncan_holden este caso esfalse,
-necesitamos negar ese resultado antes de pasarlo a la macroassert!. Como
-resultado, nuestro test pasará sican_holddevuelvefalse:
-
-¡Dos tests que pasan! Ahora veamos qué sucede con nuestros resultados de test
-cuando introducimos un bug en nuestro código. Cambiaremos la implementación del
-métodocan_holdreemplazando el signo 'mayor que' por un signo 'menor que' cuando
-compara los anchos:
-
-Ejecutar los tests ahora produce lo siguiente:
-
-¡Nuestros tests atraparon el bug! Debido a quelarger.widthes8ysmaller.widthes5, la comparación de los anchos encan_holdahora devuelvefalse: 8 no es menor que 5.
-
-Una manera común de verificar la funcionalidad es probar la igualdad entre el
-resultado del código bajo test y el valor que esperamos que el código devuelva.
-Podrías hacer esto usando la macroassert!y pasándole una expresión usando
-el operador==. Sin embargo, este es un test tan común que la biblioteca
-estándar provee un par de macros —assert_eq!yassert_ne!— para realizar
-este test de manera más conveniente. Estas macros comparan dos argumentos por
-igualdad o desigualdad, respectivamente. También imprimirán los dos valores si
-la aserción falla, lo que hace más fácil verpor quéfalló el test;
-conversamente, la macroassert!solo indica que obtuvo un valorfalsepara
-la expresión==, sin imprimir los valores que llevaron al valorfalse.
-
-En el Listado 11-7, escribimos una función llamadaadd_twoque suma2a su
-parámetro, luego testeamos esta función usando la macroassert_eq!.
-
-¡Veamos que pasa!
-
-Creamos una variable llamadaresultque contiene el resultado de la llamadaadd_two(2). Luego hemos pasado4como argumento aassert_eq!, que es igual 
-al resultado de llamar aadd_two(2). La línea para este test estest tests::it_adds_two ... ok, y el textookindica que nuestro test pasó!
-
-Vamos a introducir un error en nuestro código para ver cómo se veassert_eq!cuando falla. Cambiaremos la implementación de la funciónadd_twopara que
-en su lugar añada3:
-
-Ejecutemos los tests nuevamente:
-
-¡Nuestro test atrapó el bug! El testit_adds_twofalló, y el mensaje nos dice
-que la aserción que falló fueassertion `left == right` failedy
-cuáles son los valores deleftyright. Este mensaje nos ayuda a comenzar a
-debuggear: el argumentoleftfue4pero el argumentoright, donde
-llamamos aadd_two(2), fue5. Puedes imaginar que esto sería especialmente
-útil cuando tenemos muchos tests en marcha.
-
-Cabe señalar que en algunos lenguajes y frameworks de test, los parámetros de
-las funciones de aserción de igualdad se llamanexpectedyactual, y el
-orden en que especificamos los argumentos importa. Sin embargo, en Rust, se
-llamanleftyright, y el orden en que especificamos el valor que esperamos
-y el valor que el código produce no importa. Podríamos escribir la aserción en
-este test comoassert_eq!(add_two(2), result), lo que resultaría en el mismo
-mensaje de error que muestraassertion failed: `(left == right)`.
-
-La macroassert_ne!pasará si los dos valores que le proporcionamos no son
-iguales. Esta macro es más útil en casos en los que no estamos seguros de cuál
-será el valor, pero sabemos que el valor definitivamenteno deberíaser. Por
-ejemplo, si estamos testeando una función que está garantizada de cambiar su
-entrada de alguna manera, pero la forma en que la entrada cambia depende del
-día de la semana en que ejecutamos nuestros tests, lo mejor sería afirmar que
-el output de la función no es igual al input.
-
-En la base, las macrosassert_eq!yassert_ne!usan los operadores==y!=, respectivamente. Cuando las aserciones fallan, estas macros imprimen sus
-argumentos usando el formato de debug, lo que significa que los valores que se
-comparan deben implementar los traitsPartialEqyDebug. Todos los tipos
-primitivos y la mayoría de los tipos de la biblioteca estándar implementan
-estos traits. Para las estructuras y enumeraciones que definas, deberás
-implementarPartialEqpara afirmar la igualdad de esos tipos. También
-necesitarás implementarDebugpara imprimir los valores cuando la aserción
-falla. Debido a que ambos traits son derivables, como se mencionó en el
-Listado 5-12 en el Capítulo 5, esto suele ser tan sencillo como agregar la
-anotación#[derive(PartialEq, Debug)]a la definición de tu estructura o
-enumeración. Consulta el Apéndice C,“Traits derivables,”para obtener más detalles sobre estos y otros traits derivables.
-
-También puedes agregar un mensaje personalizado a ser impreso con el mensaje de
-fallo como argumentos opcionales a las macrosassert!,assert_eq!yassert_ne!. Cualquier argumento especificado después de los argumentos
-requeridos se pasa a la macroformat!(discutida en el Capítulo 8 en la
-sección“Concatenación con el operador+o la macroformat!”), por lo que puedes pasar una format string que contenga marcadores de
-posición{}y valores para ir en esos marcadores de posición. Los mensajes
-personalizados son útiles para documentar lo que significa una aserción; cuando
-un test falla, tendrás una mejor idea de cuál es el problema con el código.
-
-Por ejemplo, supongamos que tenemos una función que saluda a las personas por
-nombre y queremos probar que el nombre que pasamos a la función aparece en el
-output:
-
-Filename: src/lib.rs
-
-Las especificaciones para este programa aún no se han acordado, y estamos
-bastante seguros de que el textoHelloal comienzo del saludo cambiará.
-Decidimos que no queremos tener que actualizar el test cuando cambien los
-requisitos, por lo que en lugar de verificar la igualdad exacta con el valor
-devuelto de la funcióngreeting, solo afirmaremos que el output contiene el
-texto del parámetro de entrada.
-
-Ahora introduciremos un bug en este código cambiandogreetingpara excluir elnamey veremos cómo se ve el fallo de test predeterminado:
-
-Ejecutando este test produce lo siguiente:
-
-El resultado indica simplemente que la aserción falló y en qué línea se
-encuentra. Un mensaje de fallo más útil imprimiría el valor de la funcióngreeting. Agreguemos un mensaje de fallo personalizado compuesto por un
-format string con un marcador de posición reemplazado por el valor real que
-obtuvimos de la funcióngreeting:
-
-Ahora, cuando ejecutemos el test, obtendremos un mensaje de error más
-informativo:
-
-Podemos ver el valor que realmente obtuvimos en el output del test, lo que
-nos ayudaría a debuggear lo que sucedió en lugar de lo que esperábamos que
-sucediera.
-
-Además de verificar los valores de retorno, es importante verificar que nuestro
-código maneje las condiciones de error como esperamos. Por ejemplo, considera
-el tipoGuessque creamos en el Listado 9-13 del Capítulo 9. Otro código que
-usaGuessdepende de la garantía de que las instancias deGuesscontendrán
-solo valores entre 1 y 100. Podemos escribir un test que asegure que al
-intentar crear una instancia deGuesscon un valor fuera de ese rango, se
-produzca un panic.
-
-Lo hacemos agregando el atributoshould_panica nuestra función de test. El
-test pasa si el código dentro de la función hace un panic; el test falla si el
-código dentro de la función no hace un panic.
-
-El Listado 11-8 muestra un test que verifica que las condiciones de error deGuess::newsucedan cuando esperamos que sucedan.
-
-Colocamos el atributo#[should_panic]después del atributo#[test]y antes
-de la función de test a la que se aplica. Veamos el resultado cuando pase este
-test:
-
-¡Se ve bien! Ahora introduzcamos un bug en nuestro código eliminando la
-condición de que la funciónnewhará un panic si el valor es mayor que 100:
-
-Cuando ejecutemos el test del Listado 11-8, veremos que fallará:
-
-No obtenemos un mensaje muy útil en este caso, pero cuando miramos la función
-de test, vemos que está anotada con#[should_panic]. El fallo que obtuvimos
-significa que el código en la función de test no causó un panic.
-
-Los tests que usanshould_panicpueden ser imprecisos. Un testshould_panicpasaría incluso si el test hace un panic por una razón diferente a la que
-esperábamos. Para hacer que los testsshould_panicsean más precisos,
-podemos agregar un parámetro opcionalexpectedal atributoshould_panic.
-El test harness se asegurará de que el mensaje de error contenga el texto
-proporcionado. Por ejemplo, considera el código modificado paraGuessen el
-Listado 11-9 donde la funciónnewhace un panic con mensajes diferentes
-dependiendo de si el valor es demasiado pequeño o demasiado grande.
-
-Este test fallará porque el valor que pusimos en el parámetroexpecteddel
-atributoshould_panices un substring del mensaje que genera la funciónGuess::new. Podríamos haber especificado todo el mensaje de excepción que
-esperamos, que en este caso seríaGuess value must be less than or equal to 100, got 200. Lo que elijas especificar depende de cuánto del mensaje de
-excepción es único o dinámico y de cuán preciso quieras que sea tu test. En
-este caso, un substring del mensaje de excepción es suficiente para asegurar
-que el código en la función de test ejecuta el casoelse if value > 100.
-
-Para ver que sucede cuando un testshould_paniccon un mensajeexpectedfalla, introduzcamos un bug en nuestro código al intercambiar los cuerpos de
-los bloquesif value < 1yelse if value > 100:
-
-Esta vez, cuando ejecutemos el testshould_panic, fallará:
-
-El mensaje de error indica que el test falló con un error como esperábamos, pero
-el mensaje de panic no incluyó el string esperadoless than or equal to 100. El mensaje de panic que obtuvimos en este caso fueGuess value must be greater than or equal to 1, got 200.. ¡Ahora podemos
-empezar a descubrir dónde está nuestro bug!
-
-Hasta ahora, todos nuestros tests entran en panic cuando fallan. ¡También podemos
-escribir tests que usenResult<T, E>! Aquí está el test del Listado 11-1,
-reescrito para usarResult<T, E>y devolver unErren lugar de hacer un
-panic:
-
-La funciónit_worksahora tiene el tipo de retornoResult<(), String>. En
-el cuerpo de la función, en lugar de llamar al macroassert_eq!, devolvemosOk(())cuando el test pasa y unErrcon unStringdentro cuando el test
-falla.
-
-Escribir tests que devuelvan unResult<T, E>te permite usar el operador?en el cuerpo de los tests, lo que puede ser una forma conveniente de
-escribir tests que fallarán si cualquier operación dentro de ellos devuelve
-una varianteErr.
-
-No puedes utilizar la anotación#[should_panic]en tests que usenResult<T, E>. Para asegurar que una operación devuelve una varianteErr,nouses el
-operador?en el valorResult<T, E>. En su lugar, usaassert!(value.is_err()).
-
-Ahora que conoces varias formas de escribir tests, veamos qué sucede cuando
-ejecutamos nuestros tests y exploremos las diferentes opciones que podemos usar
-concargo test.
-
-```
-test
-```
-
-```
-should_panic
-```
-
-```
-test
-```
-
-```
-derive
-```
-
-```
-#[test]
-```
-
-```
-fn
-```
-
-```
-cargo test
-```
-
-```
-adder
-```
-
-```
-$cargo new adder --libCreated library `adder` project$cdadder
-```
-
-```
-$cargo new adder --libCreated library `adder` project$cdadder
-```
-
-```
-src/lib.rs
-```
-
-```
-adder
-```
-
-```
-pubfnadd(left:u64, right:u64) ->u64{
-    left + right
-}#[cfg(test)]modtests {usesuper::*;#[test]fnit_works() {letresult = add(2,2);assert_eq!(result,4);
-    }
-}
-```
-
-```
-pubfnadd(left:u64, right:u64) ->u64{
-    left + right
-}#[cfg(test)]modtests {usesuper::*;#[test]fnit_works() {letresult = add(2,2);assert_eq!(result,4);
-    }
-}
-```
-
-```
-add
-```
-
-```
-it_works()
-```
-
-```
-#[test]
-```
-
-```
-tests
-```
-
-```
-assert_eq!
-```
-
-```
-assert_eq!
-```
-
-```
-cargo test
-```
-
-```
-$cargotestCompiling adder v0.1.0 (file:///projects/adder)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.57s
-     Running unittests src/lib.rs (target/debug/deps/adder-01ad14159ff659ab)
-
-running 1 test
-test tests::it_works ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests adder
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-$cargotestCompiling adder v0.1.0 (file:///projects/adder)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.57s
-     Running unittests src/lib.rs (target/debug/deps/adder-01ad14159ff659ab)
-
-running 1 test
-test tests::it_works ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests adder
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-running 1 test
-```
-
-```
-tests::it_works
-```
-
-```
-ok
-```
-
-```
-test result: ok.
-```
-
-```
-1 passed; 0 failed
-```
-
-```
-0 ignored
-```
-
-```
-cargo test
-```
-
-```
-0 filtered out
-```
-
-```
-0 measured
-```
-
-```
-cargo test
-```
-
-```
-0 filtered out
-```
-
-```
-Doc-tests adder
-```
-
-```
-Doc-tests
-```
-
-```
-it_works
-```
-
-```
-exploration
-```
-
-```
-pubfnadd(left:u64, right:u64) ->u64{
-    left + right
-}#[cfg(test)]modtests {usesuper::*;#[test]fnexploration() {letresult = add(2,2);assert_eq!(result,4);
-    }
-}
-```
-
-```
-pubfnadd(left:u64, right:u64) ->u64{
-    left + right
-}#[cfg(test)]modtests {usesuper::*;#[test]fnexploration() {letresult = add(2,2);assert_eq!(result,4);
-    }
-}
-```
-
-```
-cargo test
-```
-
-```
-exploration
-```
-
-```
-it_works
-```
-
-```
-$cargotestCompiling adder v0.1.0 (file:///projects/adder)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.59s
-     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)
-
-running 1 test
-test tests::exploration ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests adder
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-$cargotestCompiling adder v0.1.0 (file:///projects/adder)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.59s
-     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)
-
-running 1 test
-test tests::exploration ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests adder
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-panic!
-```
-
-```
-another
-```
-
-```
-pubfnadd(left:u64, right:u64) ->u64{
-    left + right
-}#[cfg(test)]modtests {usesuper::*;#[test]fnexploration() {letresult = add(2,2);assert_eq!(result,4);
-    }#[test]fnanother() {panic!("Make this test fail");
-    }
-}
-```
-
-```
-pubfnadd(left:u64, right:u64) ->u64{
-    left + right
-}#[cfg(test)]modtests {usesuper::*;#[test]fnexploration() {letresult = add(2,2);assert_eq!(result,4);
-    }#[test]fnanother() {panic!("Make this test fail");
-    }
-}
-```
-
-```
-cargo test
-```
-
-```
-exploration
-```
-
-```
-another
-```
-
-```
-$cargotestCompiling adder v0.1.0 (file:///projects/adder)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.72s
-     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)
-
-running 2 tests
-test tests::another ... FAILED
-test tests::exploration ... ok
-
-failures:
-
----- tests::another stdout ----
-
-thread 'tests::another' panicked at src/lib.rs:17:9:
-Make this test fail
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-
-
-failures:
-    tests::another
-
-test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-$cargotestCompiling adder v0.1.0 (file:///projects/adder)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.72s
-     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)
-
-running 2 tests
-test tests::another ... FAILED
-test tests::exploration ... ok
-
-failures:
-
----- tests::another stdout ----
-
-thread 'tests::another' panicked at src/lib.rs:17:9:
-Make this test fail
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-
-
-failures:
-    tests::another
-
-test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-ok
-```
-
-```
-test tests::another
-```
-
-```
-FAILED
-```
-
-```
-another
-```
-
-```
-panicked at 'Make this test fail'
-```
-
-```
-FAILED
-```
-
-```
-panic!
-```
-
-```
-assert!
-```
-
-```
-assert!
-```
-
-```
-true
-```
-
-```
-assert!
-```
-
-```
-true
-```
-
-```
-false
-```
-
-```
-assert!
-```
-
-```
-panic!
-```
-
-```
-assert!
-```
-
-```
-Rectangle
-```
-
-```
-can_hold
-```
-
-```
-assert!
-```
-
-```
-#[derive(Debug)]structRectangle{
-    width:u32,
-    height:u32,
-}implRectangle {fncan_hold(&self, other: &Rectangle) ->bool{self.width > other.width &&self.height > other.height
-    }
-}
-```
-
-```
-#[derive(Debug)]structRectangle{
-    width:u32,
-    height:u32,
-}implRectangle {fncan_hold(&self, other: &Rectangle) ->bool{self.width > other.width &&self.height > other.height
-    }
-}
-```
-
-```
-can_hold
-```
-
-```
-assert!
-```
-
-```
-can_hold
-```
-
-```
-Rectangle
-```
-
-```
-Rectangle
-```
-
-```
-#[derive(Debug)]structRectangle{width:u32,height:u32,}implRectangle {fncan_hold(&self, other: &Rectangle) ->bool{self.width > other.width &&self.height > other.height}}#[cfg(test)]modtests {usesuper::*;#[test]fnlarger_can_hold_smaller() {letlarger = Rectangle {
-            width:8,
-            height:7,
-        };letsmaller = Rectangle {
-            width:5,
-            height:1,
-        };assert!(larger.can_hold(&smaller));
-    }
-}
-```
-
-```
-#[derive(Debug)]structRectangle{width:u32,height:u32,}implRectangle {fncan_hold(&self, other: &Rectangle) ->bool{self.width > other.width &&self.height > other.height}}#[cfg(test)]modtests {usesuper::*;#[test]fnlarger_can_hold_smaller() {letlarger = Rectangle {
-            width:8,
-            height:7,
-        };letsmaller = Rectangle {
-            width:5,
-            height:1,
-        };assert!(larger.can_hold(&smaller));
-    }
-}
-```
-
-```
-tests
-```
-
-```
-use super::*;
-```
-
-```
-tests
-```
-
-```
-tests
-```
-
-```
-tests
-```
-
-```
-larger_can_hold_smaller
-```
-
-```
-Rectangle
-```
-
-```
-assert!
-```
-
-```
-larger.can_hold(&smaller)
-```
-
-```
-true
-```
-
-```
-$cargotestCompiling rectangle v0.1.0 (file:///projects/rectangle)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
-     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)
-
-running 1 test
-test tests::larger_can_hold_smaller ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests rectangle
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-$cargotestCompiling rectangle v0.1.0 (file:///projects/rectangle)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
-     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)
-
-running 1 test
-test tests::larger_can_hold_smaller ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests rectangle
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-#[derive(Debug)]structRectangle{width:u32,height:u32,}implRectangle {fncan_hold(&self, other: &Rectangle) ->bool{self.width > other.width &&self.height > other.height}}#[cfg(test)]modtests {usesuper::*;#[test]fnlarger_can_hold_smaller() {// --snip--letlarger = Rectangle {width:8,height:7,};letsmaller = Rectangle {width:5,height:1,};assert!(larger.can_hold(&smaller));}#[test]fnsmaller_cannot_hold_larger() {letlarger = Rectangle {
-            width:8,
-            height:7,
-        };letsmaller = Rectangle {
-            width:5,
-            height:1,
-        };assert!(!smaller.can_hold(&larger));
-    }
-}
-```
-
-```
-#[derive(Debug)]structRectangle{width:u32,height:u32,}implRectangle {fncan_hold(&self, other: &Rectangle) ->bool{self.width > other.width &&self.height > other.height}}#[cfg(test)]modtests {usesuper::*;#[test]fnlarger_can_hold_smaller() {// --snip--letlarger = Rectangle {width:8,height:7,};letsmaller = Rectangle {width:5,height:1,};assert!(larger.can_hold(&smaller));}#[test]fnsmaller_cannot_hold_larger() {letlarger = Rectangle {
-            width:8,
-            height:7,
-        };letsmaller = Rectangle {
-            width:5,
-            height:1,
-        };assert!(!smaller.can_hold(&larger));
-    }
-}
-```
-
-```
-can_hold
-```
-
-```
-false
-```
-
-```
-assert!
-```
-
-```
-can_hold
-```
-
-```
-false
-```
-
-```
-$cargotestCompiling rectangle v0.1.0 (file:///projects/rectangle)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
-     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)
-
-running 2 tests
-test tests::larger_can_hold_smaller ... ok
-test tests::smaller_cannot_hold_larger ... ok
-
-test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests rectangle
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-$cargotestCompiling rectangle v0.1.0 (file:///projects/rectangle)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
-     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)
-
-running 2 tests
-test tests::larger_can_hold_smaller ... ok
-test tests::smaller_cannot_hold_larger ... ok
-
-test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests rectangle
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-can_hold
-```
-
-```
-#[derive(Debug)]structRectangle{width:u32,height:u32,}// --snip--implRectangle {fncan_hold(&self, other: &Rectangle) ->bool{self.width < other.width &&self.height > other.height
-    }
-}#[cfg(test)]modtests {usesuper::*;#[test]fnlarger_can_hold_smaller() {letlarger = Rectangle {width:8,height:7,};letsmaller = Rectangle {width:5,height:1,};assert!(larger.can_hold(&smaller));}#[test]fnsmaller_cannot_hold_larger() {letlarger = Rectangle {width:8,height:7,};letsmaller = Rectangle {width:5,height:1,};assert!(!smaller.can_hold(&larger));}}
-```
-
-```
-#[derive(Debug)]structRectangle{width:u32,height:u32,}// --snip--implRectangle {fncan_hold(&self, other: &Rectangle) ->bool{self.width < other.width &&self.height > other.height
-    }
-}#[cfg(test)]modtests {usesuper::*;#[test]fnlarger_can_hold_smaller() {letlarger = Rectangle {width:8,height:7,};letsmaller = Rectangle {width:5,height:1,};assert!(larger.can_hold(&smaller));}#[test]fnsmaller_cannot_hold_larger() {letlarger = Rectangle {width:8,height:7,};letsmaller = Rectangle {width:5,height:1,};assert!(!smaller.can_hold(&larger));}}
-```
-
-```
-$cargotestCompiling rectangle v0.1.0 (file:///projects/rectangle)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
-     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)
-
-running 2 tests
-test tests::larger_can_hold_smaller ... FAILED
-test tests::smaller_cannot_hold_larger ... ok
-
-failures:
-
----- tests::larger_can_hold_smaller stdout ----
-
-thread 'tests::larger_can_hold_smaller' panicked at src/lib.rs:28:9:
-assertion failed: larger.can_hold(&smaller)
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-
-
-failures:
-    tests::larger_can_hold_smaller
-
-test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-$cargotestCompiling rectangle v0.1.0 (file:///projects/rectangle)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
-     Running unittests src/lib.rs (target/debug/deps/rectangle-6584c4561e48942e)
-
-running 2 tests
-test tests::larger_can_hold_smaller ... FAILED
-test tests::smaller_cannot_hold_larger ... ok
-
-failures:
-
----- tests::larger_can_hold_smaller stdout ----
-
-thread 'tests::larger_can_hold_smaller' panicked at src/lib.rs:28:9:
-assertion failed: larger.can_hold(&smaller)
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-
-
-failures:
-    tests::larger_can_hold_smaller
-
-test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-larger.width
-```
-
-```
-8
-```
-
-```
-smaller.width
-```
-
-```
-5
-```
-
-```
-can_hold
-```
-
-```
-false
-```
-
-```
-assert_eq!
-```
-
-```
-assert_ne!
-```
-
-```
-assert!
-```
-
-```
-==
-```
-
-```
-assert_eq!
-```
-
-```
-assert_ne!
-```
-
-```
-assert!
-```
-
-```
-false
-```
-
-```
-==
-```
-
-```
-false
-```
-
-```
-add_two
-```
-
-```
-2
-```
-
-```
-assert_eq!
-```
-
-```
-pubfnadd_two(a:usize) ->usize{
-    a +2}#[cfg(test)]modtests {usesuper::*;#[test]fnit_adds_two() {letresult = add_two(2);assert_eq!(result,4);
-    }
-}
-```
-
-```
-pubfnadd_two(a:usize) ->usize{
-    a +2}#[cfg(test)]modtests {usesuper::*;#[test]fnit_adds_two() {letresult = add_two(2);assert_eq!(result,4);
-    }
-}
-```
-
-```
-$cargotestCompiling adder v0.1.0 (file:///projects/adder)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.58s
-     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)
-
-running 1 test
-test tests::it_adds_two ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests adder
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-$cargotestCompiling adder v0.1.0 (file:///projects/adder)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.58s
-     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)
-
-running 1 test
-test tests::it_adds_two ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests adder
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-result
-```
-
-```
-add_two(2)
-```
-
-```
-4
-```
-
-```
-assert_eq!
-```
-
-```
-add_two(2)
-```
-
-```
-test tests::it_adds_two ... ok
-```
-
-```
-ok
-```
-
-```
-assert_eq!
-```
-
-```
-add_two
-```
-
-```
-3
-```
-
-```
-pubfnadd_two(a:usize) ->usize{
-    a +3}#[cfg(test)]modtests {usesuper::*;#[test]fnit_adds_two() {letresult = add_two(2);assert_eq!(result,4);}}
-```
-
-```
-pubfnadd_two(a:usize) ->usize{
-    a +3}#[cfg(test)]modtests {usesuper::*;#[test]fnit_adds_two() {letresult = add_two(2);assert_eq!(result,4);}}
-```
-
-```
-$cargotestCompiling adder v0.1.0 (file:///projects/adder)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.61s
-     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)
-
-running 1 test
-test tests::it_adds_two ... FAILED
-
-failures:
-
----- tests::it_adds_two stdout ----
-
-thread 'tests::it_adds_two' panicked at src/lib.rs:12:9:
-assertion `left == right` failed
-  left: 5
- right: 4
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-
-
-failures:
-    tests::it_adds_two
-
-test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-$cargotestCompiling adder v0.1.0 (file:///projects/adder)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.61s
-     Running unittests src/lib.rs (target/debug/deps/adder-92948b65e88960b4)
-
-running 1 test
-test tests::it_adds_two ... FAILED
-
-failures:
-
----- tests::it_adds_two stdout ----
-
-thread 'tests::it_adds_two' panicked at src/lib.rs:12:9:
-assertion `left == right` failed
-  left: 5
- right: 4
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-
-
-failures:
-    tests::it_adds_two
-
-test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-it_adds_two
-```
-
-```
-assertion `left == right` failed
-```
-
-```
-left
-```
-
-```
-right
-```
-
-```
-left
-```
-
-```
-4
-```
-
-```
-right
-```
-
-```
-add_two(2)
-```
-
-```
-5
-```
-
-```
-expected
-```
-
-```
-actual
-```
-
-```
-left
-```
-
-```
-right
-```
-
-```
-assert_eq!(add_two(2), result)
-```
-
-```
-assertion failed: `(left == right)`
-```
-
-```
-assert_ne!
-```
-
-```
-assert_eq!
-```
-
-```
-assert_ne!
-```
-
-```
-==
-```
-
-```
-!=
-```
-
-```
-PartialEq
-```
-
-```
-Debug
-```
-
-```
-PartialEq
-```
-
-```
-Debug
-```
-
-```
-#[derive(PartialEq, Debug)]
-```
-
-```
-assert!
-```
-
-```
-assert_eq!
-```
-
-```
-assert_ne!
-```
-
-```
-format!
-```
-
-```
-+
-```
-
-```
-format!
-```
-
-```
-{}
-```
-
-```
-pubfngreeting(name: &str) ->String{format!("Hello {name}!")
-}#[cfg(test)]modtests {usesuper::*;#[test]fngreeting_contains_name() {letresult = greeting("Carol");assert!(result.contains("Carol"));
-    }
-}
-```
-
-```
-pubfngreeting(name: &str) ->String{format!("Hello {name}!")
-}#[cfg(test)]modtests {usesuper::*;#[test]fngreeting_contains_name() {letresult = greeting("Carol");assert!(result.contains("Carol"));
-    }
-}
-```
-
-```
-Hello
-```
-
-```
-greeting
-```
-
-```
-greeting
-```
-
-```
-name
-```
-
-```
-pubfngreeting(name: &str) ->String{String::from("Hello!")
-}#[cfg(test)]modtests {usesuper::*;#[test]fngreeting_contains_name() {letresult = greeting("Carol");assert!(result.contains("Carol"));}}
-```
-
-```
-pubfngreeting(name: &str) ->String{String::from("Hello!")
-}#[cfg(test)]modtests {usesuper::*;#[test]fngreeting_contains_name() {letresult = greeting("Carol");assert!(result.contains("Carol"));}}
-```
-
-```
-$cargotestCompiling greeter v0.1.0 (file:///projects/greeter)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.91s
-     Running unittests src/lib.rs (target/debug/deps/greeter-170b942eb5bf5e3a)
-
-running 1 test
-test tests::greeting_contains_name ... FAILED
-
-failures:
-
----- tests::greeting_contains_name stdout ----
-
-thread 'tests::greeting_contains_name' panicked at src/lib.rs:12:9:
-assertion failed: result.contains("Carol")
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-
-
-failures:
-    tests::greeting_contains_name
-
-test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-$cargotestCompiling greeter v0.1.0 (file:///projects/greeter)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.91s
-     Running unittests src/lib.rs (target/debug/deps/greeter-170b942eb5bf5e3a)
-
-running 1 test
-test tests::greeting_contains_name ... FAILED
-
-failures:
-
----- tests::greeting_contains_name stdout ----
-
-thread 'tests::greeting_contains_name' panicked at src/lib.rs:12:9:
-assertion failed: result.contains("Carol")
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-
-
-failures:
-    tests::greeting_contains_name
-
-test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-greeting
-```
-
-```
-greeting
-```
-
-```
-pubfngreeting(name: &str) ->String{String::from("Hello!")}#[cfg(test)]modtests {usesuper::*;#[test]fngreeting_contains_name() {letresult = greeting("Carol");assert!(
-            result.contains("Carol"),"Greeting did not contain name, value was `{result}`");
-    }}
-```
-
-```
-pubfngreeting(name: &str) ->String{String::from("Hello!")}#[cfg(test)]modtests {usesuper::*;#[test]fngreeting_contains_name() {letresult = greeting("Carol");assert!(
-            result.contains("Carol"),"Greeting did not contain name, value was `{result}`");
-    }}
-```
-
-```
-$cargotestCompiling greeter v0.1.0 (file:///projects/greeter)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.93s
-     Running unittests src/lib.rs (target/debug/deps/greeter-170b942eb5bf5e3a)
-
-running 1 test
-test tests::greeting_contains_name ... FAILED
-
-failures:
-
----- tests::greeting_contains_name stdout ----
-
-thread 'tests::greeting_contains_name' panicked at src/lib.rs:12:9:
-Greeting did not contain name, value was `Hello!`
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-
-
-failures:
-    tests::greeting_contains_name
-
-test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-$cargotestCompiling greeter v0.1.0 (file:///projects/greeter)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.93s
-     Running unittests src/lib.rs (target/debug/deps/greeter-170b942eb5bf5e3a)
-
-running 1 test
-test tests::greeting_contains_name ... FAILED
-
-failures:
-
----- tests::greeting_contains_name stdout ----
-
-thread 'tests::greeting_contains_name' panicked at src/lib.rs:12:9:
-Greeting did not contain name, value was `Hello!`
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-
-
-failures:
-    tests::greeting_contains_name
-
-test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-should_panic
-```
-
-```
-Guess
-```
-
-```
-Guess
-```
-
-```
-Guess
-```
-
-```
-Guess
-```
-
-```
-should_panic
-```
-
-```
-Guess::new
-```
-
-```
-pubstructGuess{
-    value:i32,
-}implGuess {pubfnnew(value:i32) -> Guess {ifvalue <1|| value >100{panic!("Guess value must be between 1 and 100, got {value}.");
-        }
-
-        Guess { value }
-    }
-}#[cfg(test)]modtests {usesuper::*;#[test]#[should_panic]fngreater_than_100() {
-        Guess::new(200);
-    }
-}
-```
-
-```
-pubstructGuess{
-    value:i32,
-}implGuess {pubfnnew(value:i32) -> Guess {ifvalue <1|| value >100{panic!("Guess value must be between 1 and 100, got {value}.");
-        }
-
-        Guess { value }
-    }
-}#[cfg(test)]modtests {usesuper::*;#[test]#[should_panic]fngreater_than_100() {
-        Guess::new(200);
-    }
-}
-```
-
-```
-#[should_panic]
-```
-
-```
-#[test]
-```
-
-```
-$cargotestCompiling guessing_game v0.1.0 (file:///projects/guessing_game)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.58s
-     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)
-
-running 1 test
-test tests::greater_than_100 - should panic ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests guessing_game
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-$cargotestCompiling guessing_game v0.1.0 (file:///projects/guessing_game)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.58s
-     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)
-
-running 1 test
-test tests::greater_than_100 - should panic ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-   Doc-tests guessing_game
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-```
-
-```
-new
-```
-
-```
-pubstructGuess{value:i32,}// --snip--implGuess {pubfnnew(value:i32) -> Guess {ifvalue <1{panic!("Guess value must be between 1 and 100, got {value}.");
-        }
-
-        Guess { value }
-    }
-}#[cfg(test)]modtests {usesuper::*;#[test]#[should_panic]fngreater_than_100() {Guess::new(200);}}
-```
-
-```
-pubstructGuess{value:i32,}// --snip--implGuess {pubfnnew(value:i32) -> Guess {ifvalue <1{panic!("Guess value must be between 1 and 100, got {value}.");
-        }
-
-        Guess { value }
-    }
-}#[cfg(test)]modtests {usesuper::*;#[test]#[should_panic]fngreater_than_100() {Guess::new(200);}}
-```
-
-```
-$cargotestCompiling guessing_game v0.1.0 (file:///projects/guessing_game)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.62s
-     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)
-
-running 1 test
-test tests::greater_than_100 - should panic ... FAILED
-
-failures:
-
----- tests::greater_than_100 stdout ----
-note: test did not panic as expected
-
-failures:
-    tests::greater_than_100
-
-test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-$cargotestCompiling guessing_game v0.1.0 (file:///projects/guessing_game)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.62s
-     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)
-
-running 1 test
-test tests::greater_than_100 - should panic ... FAILED
-
-failures:
-
----- tests::greater_than_100 stdout ----
-note: test did not panic as expected
-
-failures:
-    tests::greater_than_100
-
-test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-#[should_panic]
-```
-
-```
-should_panic
-```
-
-```
-should_panic
-```
-
-```
-should_panic
-```
-
-```
-expected
-```
-
-```
-should_panic
-```
-
-```
-Guess
-```
-
-```
-new
-```
-
-```
-pubstructGuess{value:i32,}// --snip--implGuess {pubfnnew(value:i32) -> Guess {ifvalue <1{panic!("Guess value must be greater than or equal to 1, got {value}.");
-        }elseifvalue >100{panic!("Guess value must be less than or equal to 100, got {value}.");
-        }
-
-        Guess { value }
-    }
-}#[cfg(test)]modtests {usesuper::*;#[test]#[should_panic(expected ="less than or equal to 100")]fngreater_than_100() {
-        Guess::new(200);
-    }
-}
-```
-
-```
-pubstructGuess{value:i32,}// --snip--implGuess {pubfnnew(value:i32) -> Guess {ifvalue <1{panic!("Guess value must be greater than or equal to 1, got {value}.");
-        }elseifvalue >100{panic!("Guess value must be less than or equal to 100, got {value}.");
-        }
-
-        Guess { value }
-    }
-}#[cfg(test)]modtests {usesuper::*;#[test]#[should_panic(expected ="less than or equal to 100")]fngreater_than_100() {
-        Guess::new(200);
-    }
-}
-```
-
-```
-expected
-```
-
-```
-should_panic
-```
-
-```
-Guess::new
-```
-
-```
-Guess value must be less than or equal to 100, got 200
-```
-
-```
-else if value > 100
-```
-
-```
-should_panic
-```
-
-```
-expected
-```
-
-```
-if value < 1
-```
-
-```
-else if value > 100
-```
-
-```
-pubstructGuess{value:i32,}implGuess {pubfnnew(value:i32) -> Guess {ifvalue <1{panic!("Guess value must be less than or equal to 100, got {value}.");
-        }elseifvalue >100{panic!("Guess value must be greater than or equal to 1, got {value}.");
-        }Guess { value }}}#[cfg(test)]modtests {usesuper::*;#[test]#[should_panic(expected ="less than or equal to 100")]fngreater_than_100() {Guess::new(200);}}
-```
-
-```
-pubstructGuess{value:i32,}implGuess {pubfnnew(value:i32) -> Guess {ifvalue <1{panic!("Guess value must be less than or equal to 100, got {value}.");
-        }elseifvalue >100{panic!("Guess value must be greater than or equal to 1, got {value}.");
-        }Guess { value }}}#[cfg(test)]modtests {usesuper::*;#[test]#[should_panic(expected ="less than or equal to 100")]fngreater_than_100() {Guess::new(200);}}
-```
-
-```
-should_panic
-```
-
-```
-$cargotestCompiling guessing_game v0.1.0 (file:///projects/guessing_game)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
-     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)
-
-running 1 test
-test tests::greater_than_100 - should panic ... FAILED
-
-failures:
-
----- tests::greater_than_100 stdout ----
-
-thread 'tests::greater_than_100' panicked at src/lib.rs:12:13:
-Guess value must be greater than or equal to 1, got 200.
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: panic did not contain expected string
-      panic message: `"Guess value must be greater than or equal to 1, got 200."`,
- expected substring: `"less than or equal to 100"`
-
-failures:
-    tests::greater_than_100
-
-test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-$cargotestCompiling guessing_game v0.1.0 (file:///projects/guessing_game)
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.66s
-     Running unittests src/lib.rs (target/debug/deps/guessing_game-57d70c3acb738f4d)
-
-running 1 test
-test tests::greater_than_100 - should panic ... FAILED
-
-failures:
-
----- tests::greater_than_100 stdout ----
-
-thread 'tests::greater_than_100' panicked at src/lib.rs:12:13:
-Guess value must be greater than or equal to 1, got 200.
-note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: panic did not contain expected string
-      panic message: `"Guess value must be greater than or equal to 1, got 200."`,
- expected substring: `"less than or equal to 100"`
-
-failures:
-    tests::greater_than_100
-
-test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
-
-error: test failed, to rerun pass `--lib`
-```
-
-```
-less than or equal to 100
-```
-
-```
-Guess value must be greater than or equal to 1, got 200.
-```
-
-```
-Result<T, E>
-```
-
-```
-Result<T, E>
-```
-
-```
-Result<T, E>
-```
-
-```
-Err
-```
-
-```
-pubfnadd(left:u64, right:u64) ->u64{left + right}#[cfg(test)]modtests {usesuper::*;#[test]fnit_works() ->Result<(),String> {letresult = add(2,2);ifresult ==4{Ok(())
-        }else{Err(String::from("two plus two does not equal four"))
-        }
-    }}
-```
-
-```
-pubfnadd(left:u64, right:u64) ->u64{left + right}#[cfg(test)]modtests {usesuper::*;#[test]fnit_works() ->Result<(),String> {letresult = add(2,2);ifresult ==4{Ok(())
-        }else{Err(String::from("two plus two does not equal four"))
-        }
-    }}
-```
-
-```
-it_works
-```
-
-```
-Result<(), String>
-```
-
-```
-assert_eq!
-```
-
-```
-Ok(())
-```
-
-```
-Err
-```
-
-```
-String
-```
-
-```
-Result<T, E>
-```
-
-```
-?
-```
-
-```
-Err
-```
-
-```
-#[should_panic]
-```
-
-```
-Result<T, E>
-```
-
-```
-Err
-```
-
-```
-?
-```
-
-```
-Result<T, E>
-```
-
-```
-assert!(value.is_err())
-```
-
-```
-cargo test
-```
-
-- El Lenguaje de Programación Rust
-- Prefacio
-- Introducción
-- 1.Empezando
-- 1.1.Instalación1.2.¡Hola, Mundo!1.3.¡Hola, Cargo!
-- 1.1.Instalación
-- 1.2.¡Hola, Mundo!
-- 1.3.¡Hola, Cargo!
-- 2.Programando un juego de adivinanzas
-- 3.Conceptos Comunes de Programación
-- 3.1.Variables y Mutabilidad3.2.Tipos de Datos3.3.Funciones3.4.Comentarios3.5.Flujo de Control
-- 3.1.Variables y Mutabilidad
-- 3.2.Tipos de Datos
-- 3.3.Funciones
-- 3.4.Comentarios
-- 3.5.Flujo de Control
-- 4.Entendiendo el Ownership
-- 4.1.¿Qué es el Ownership?4.2.Referencias y Prestamos4.3.El Tipo Slice
-- 4.1.¿Qué es el Ownership?
-- 4.2.Referencias y Prestamos
-- 4.3.El Tipo Slice
-- 5.Usando Structs para Estructurar Datos Relacionados
-- 5.1.Definiendo e Instanciando Structs5.2.Un Programa de Ejemplo Usando Structs5.3.Sintaxis de Métodos
-- 5.1.Definiendo e Instanciando Structs
-- 5.2.Un Programa de Ejemplo Usando Structs
-- 5.3.Sintaxis de Métodos
-- 6.Enums y Pattern Matching
-- 6.1.Definiendo un Enum6.2.El operador de control de flujo match6.3.Flujo de Control Conciso con if let y let else
-- 6.1.Definiendo un Enum
-- 6.2.El operador de control de flujo match
-- 6.3.Flujo de Control Conciso con if let y let else
-- 7.Administrando Proyectos en Crecimiento con Paquetes, Crates y Módulos
-- 7.1.Paquetes y Crates7.2.Definiendo módulos para controlar el scope y la privacidad7.3.Paths para referirse a un item en el árbol de módulos7.4.Incluyendo rutas al Scope con la palabra clave use7.5.Separando Módulos en Diferentes Archivos
-- 7.1.Paquetes y Crates
-- 7.2.Definiendo módulos para controlar el scope y la privacidad
-- 7.3.Paths para referirse a un item en el árbol de módulos
-- 7.4.Incluyendo rutas al Scope con la palabra clave use
-- 7.5.Separando Módulos en Diferentes Archivos
-- 8.Colecciones comunes
-- 8.1.Almacenando listas de valores con vectores8.2.Almacenando texto codificado en UTF-8 con Strings8.3.Almacenar Claves con Valores Asociados en HashMaps
-- 8.1.Almacenando listas de valores con vectores
-- 8.2.Almacenando texto codificado en UTF-8 con Strings
-- 8.3.Almacenar Claves con Valores Asociados en HashMaps
-- 9.Manejo de Errores
-- 9.1.Errores irrecuperables con panic!9.2.Errores recuperables con Result9.3.panic! o no panic!
-- 9.1.Errores irrecuperables con panic!
-- 9.2.Errores recuperables con Result
-- 9.3.panic! o no panic!
-- 10.Tipos Genéricos, Traits y Lifetimes
-- 10.1.Tipos de Datos Genéricos10.2.Traits: Definiendo Comportamiento Compartido10.3.Validando Referencias con Lifetimes
-- 10.1.Tipos de Datos Genéricos
-- 10.2.Traits: Definiendo Comportamiento Compartido
-- 10.3.Validando Referencias con Lifetimes
-- 11.Escribiendo Tests Automatizados
-- 11.1.Cómo Escribir Tests11.2.Controlando Cómo Los Tests Son Ejecutados11.3.Organización De Los Tests
-- 11.1.Cómo Escribir Tests
-- 11.2.Controlando Cómo Los Tests Son Ejecutados
-- 11.3.Organización De Los Tests
-- 12.Un proyecto de I/O: Construyendo un programa de línea de comandos
-- 12.1.Aceptando argumentos de línea de comandos12.2.Leyendo un archivo12.3.Refactorizando para mejorar la modularidad y el manejo de errores12.4.Desarrollando la funcionalidad de la biblioteca con T.D.D.12.5.Trabajando con Variables de Entorno12.6.Escribiendo mensajes de error estándar en lugar del output estándar
-- 12.1.Aceptando argumentos de línea de comandos
-- 12.2.Leyendo un archivo
-- 12.3.Refactorizando para mejorar la modularidad y el manejo de errores
-- 12.4.Desarrollando la funcionalidad de la biblioteca con T.D.D.
-- 12.5.Trabajando con Variables de Entorno
-- 12.6.Escribiendo mensajes de error estándar en lugar del output estándar
-- 13.Características De Lenguajes Funcionales: Iteradores y Closures
-- 13.1.Closures: Funciones anónimas que capturan su entorno13.2.Procesando una serie de elementos con Iteradores13.3.Mejorando nuestro proyecto I/O13.4.Comparando Performance: Bucles vs. Iteradores
-- 13.1.Closures: Funciones anónimas que capturan su entorno
-- 13.2.Procesando una serie de elementos con Iteradores
-- 13.3.Mejorando nuestro proyecto I/O
-- 13.4.Comparando Performance: Bucles vs. Iteradores
-- 14.Más sobre Cargo y Crates.io
-- 14.1.Personalizando Compilaciones con Perfiles de Lanzamiento14.2.Publicando un Crate a Crates.io14.3.Cargo Workspaces14.4.Instalando Binarios con cargo install14.5.Extendiendo Cargo con Comandos Personalizados
-- 14.1.Personalizando Compilaciones con Perfiles de Lanzamiento
-- 14.2.Publicando un Crate a Crates.io
-- 14.3.Cargo Workspaces
-- 14.4.Instalando Binarios con cargo install
-- 14.5.Extendiendo Cargo con Comandos Personalizados
-- 15.Smart Pointers
-- 15.1.Usando Box<T> para Apuntar a Datos en el Heap15.2.Tratando los Smart Pointers como Referencias Regulares con el Trait Deref15.3.Ejecutando Código al Limpiar con el Trait Drop15.4.Rc<T>, el Smart Pointer de Conteo de Referencias15.5.RefCell<T> y el Patrón de Mutabilidad Interior15.6.Referencias Circulares Pueden Fugar Memoria
-- 15.1.Usando Box<T> para Apuntar a Datos en el Heap
-- 15.2.Tratando los Smart Pointers como Referencias Regulares con el Trait Deref
-- 15.3.Ejecutando Código al Limpiar con el Trait Drop
-- 15.4.Rc<T>, el Smart Pointer de Conteo de Referencias
-- 15.5.RefCell<T> y el Patrón de Mutabilidad Interior
-- 15.6.Referencias Circulares Pueden Fugar Memoria
-- 16.Concurrencia sin miedo
-- 16.1.Usando Threads para Ejecutar Código Simultáneamente16.2.Usando el Pasaje de Mensajes para Transferir Datos entre Hilos16.3.Concurrencia con Estado Compartido16.4.Concurrencia extensible con los traits Sync y Send
-- 16.1.Usando Threads para Ejecutar Código Simultáneamente
-- 16.2.Usando el Pasaje de Mensajes para Transferir Datos entre Hilos
-- 16.3.Concurrencia con Estado Compartido
-- 16.4.Concurrencia extensible con los traits Sync y Send
-- 17.Fundamentos de la Programación Asíncrona: Async, Await, Futures y Streams
-- 17.1.Futures y la sintaxis Async17.2.Aplicando Concurrencia Con Async17.3.Trabajar con cualquier número de futuros17.4.Streams17.5.Profundizando en los Traits para Async17.6.Futuros, tareas e hilos
-- 17.1.Futures y la sintaxis Async
-- 17.2.Aplicando Concurrencia Con Async
-- 17.3.Trabajar con cualquier número de futuros
-- 17.4.Streams
-- 17.5.Profundizando en los Traits para Async
-- 17.6.Futuros, tareas e hilos
-- 18.Rust como un Lenguaje de Programación Orientado a Objetos
-- 18.1.Características de Lenguajes Orientados a Objetos18.2.Usando Trait Objects que Permiten Valores de Diferentes Tipos18.3.Implementando un Patrón de Diseño Orientado a Objetos
-- 18.1.Características de Lenguajes Orientados a Objetos
-- 18.2.Usando Trait Objects que Permiten Valores de Diferentes Tipos
-- 18.3.Implementando un Patrón de Diseño Orientado a Objetos
-- 19.Patterns and Matching
-- 19.1.Todos los lugares donde se pueden usar Patterns19.2.Refutabilidad: Si un Pattern Puede Fallar al Hacer Match19.3.Sintaxis de los Patterns
-- 19.1.Todos los lugares donde se pueden usar Patterns
-- 19.2.Refutabilidad: Si un Pattern Puede Fallar al Hacer Match
-- 19.3.Sintaxis de los Patterns
-- 20.Características Avanzadas
-- 20.1.Rust Inseguro20.2.Traits Avanzados20.3.Tipos Avanzados20.4.Funciones y Closures Avanzados20.5.Macros
-- 20.1.Rust Inseguro
-- 20.2.Traits Avanzados
-- 20.3.Tipos Avanzados
-- 20.4.Funciones y Closures Avanzados
-- 20.5.Macros
-- 21.Proyecto Final: Construyendo un Servidor Web Multithread
-- 21.1.Construyendo un Servidor Web de un Solo Hilo21.2.Convirtiendo Nuestro Servidor de un solo Hilo en un Servidor Multihilo21.3.Apagado y limpieza eficientes
-- 21.1.Construyendo un Servidor Web de un Solo Hilo
-- 21.2.Convirtiendo Nuestro Servidor de un solo Hilo en un Servidor Multihilo
-- 21.3.Apagado y limpieza eficientes
-- 22.Apéndice
-- 22.1.A - Palabras claves22.2.B - Operadores y Símbolos22.3.C - Traits derivables22.4.D - Herramientas de desarrollo útiles22.5.E - Ediciones22.6.F - Traducciones del libro22.7.G - Cómo se hace Rust y “Rust Nightly”
-- 22.1.A - Palabras claves
-- 22.2.B - Operadores y Símbolos
-- 22.3.C - Traits derivables
-- 22.4.D - Herramientas de desarrollo útiles
-- 22.5.E - Ediciones
-- 22.6.F - Traducciones del libro
-- 22.7.G - Cómo se hace Rust y “Rust Nightly”
-
-- 1.1.Instalación
-- 1.2.¡Hola, Mundo!
-- 1.3.¡Hola, Cargo!
-
-- 3.1.Variables y Mutabilidad
-- 3.2.Tipos de Datos
-- 3.3.Funciones
-- 3.4.Comentarios
-- 3.5.Flujo de Control
-
-- 4.1.¿Qué es el Ownership?
-- 4.2.Referencias y Prestamos
-- 4.3.El Tipo Slice
-
-- 5.1.Definiendo e Instanciando Structs
-- 5.2.Un Programa de Ejemplo Usando Structs
-- 5.3.Sintaxis de Métodos
-
-- 6.1.Definiendo un Enum
-- 6.2.El operador de control de flujo match
-- 6.3.Flujo de Control Conciso con if let y let else
-
-- 7.1.Paquetes y Crates
-- 7.2.Definiendo módulos para controlar el scope y la privacidad
-- 7.3.Paths para referirse a un item en el árbol de módulos
-- 7.4.Incluyendo rutas al Scope con la palabra clave use
-- 7.5.Separando Módulos en Diferentes Archivos
-
-- 8.1.Almacenando listas de valores con vectores
-- 8.2.Almacenando texto codificado en UTF-8 con Strings
-- 8.3.Almacenar Claves con Valores Asociados en HashMaps
-
-- 9.1.Errores irrecuperables con panic!
-- 9.2.Errores recuperables con Result
-- 9.3.panic! o no panic!
-
-- 10.1.Tipos de Datos Genéricos
-- 10.2.Traits: Definiendo Comportamiento Compartido
-- 10.3.Validando Referencias con Lifetimes
-
-- 11.1.Cómo Escribir Tests
-- 11.2.Controlando Cómo Los Tests Son Ejecutados
-- 11.3.Organización De Los Tests
-
-- 12.1.Aceptando argumentos de línea de comandos
-- 12.2.Leyendo un archivo
-- 12.3.Refactorizando para mejorar la modularidad y el manejo de errores
-- 12.4.Desarrollando la funcionalidad de la biblioteca con T.D.D.
-- 12.5.Trabajando con Variables de Entorno
-- 12.6.Escribiendo mensajes de error estándar en lugar del output estándar
-
-- 13.1.Closures: Funciones anónimas que capturan su entorno
-- 13.2.Procesando una serie de elementos con Iteradores
-- 13.3.Mejorando nuestro proyecto I/O
-- 13.4.Comparando Performance: Bucles vs. Iteradores
-
-- 14.1.Personalizando Compilaciones con Perfiles de Lanzamiento
-- 14.2.Publicando un Crate a Crates.io
-- 14.3.Cargo Workspaces
-- 14.4.Instalando Binarios con cargo install
-- 14.5.Extendiendo Cargo con Comandos Personalizados
-
-- 15.1.Usando Box<T> para Apuntar a Datos en el Heap
-- 15.2.Tratando los Smart Pointers como Referencias Regulares con el Trait Deref
-- 15.3.Ejecutando Código al Limpiar con el Trait Drop
-- 15.4.Rc<T>, el Smart Pointer de Conteo de Referencias
-- 15.5.RefCell<T> y el Patrón de Mutabilidad Interior
-- 15.6.Referencias Circulares Pueden Fugar Memoria
-
-- 16.1.Usando Threads para Ejecutar Código Simultáneamente
-- 16.2.Usando el Pasaje de Mensajes para Transferir Datos entre Hilos
-- 16.3.Concurrencia con Estado Compartido
-- 16.4.Concurrencia extensible con los traits Sync y Send
-
-- 17.1.Futures y la sintaxis Async
-- 17.2.Aplicando Concurrencia Con Async
-- 17.3.Trabajar con cualquier número de futuros
-- 17.4.Streams
-- 17.5.Profundizando en los Traits para Async
-- 17.6.Futuros, tareas e hilos
-
-- 18.1.Características de Lenguajes Orientados a Objetos
-- 18.2.Usando Trait Objects que Permiten Valores de Diferentes Tipos
-- 18.3.Implementando un Patrón de Diseño Orientado a Objetos
-
-- 19.1.Todos los lugares donde se pueden usar Patterns
-- 19.2.Refutabilidad: Si un Pattern Puede Fallar al Hacer Match
-- 19.3.Sintaxis de los Patterns
-
-- 20.1.Rust Inseguro
-- 20.2.Traits Avanzados
-- 20.3.Tipos Avanzados
-- 20.4.Funciones y Closures Avanzados
-- 20.5.Macros
-
-- 21.1.Construyendo un Servidor Web de un Solo Hilo
-- 21.2.Convirtiendo Nuestro Servidor de un solo Hilo en un Servidor Multihilo
-- 21.3.Apagado y limpieza eficientes
-
-- 22.1.A - Palabras claves
-- 22.2.B - Operadores y Símbolos
-- 22.3.C - Traits derivables
-- 22.4.D - Herramientas de desarrollo útiles
-- 22.5.E - Ediciones
-- 22.6.F - Traducciones del libro
-- 22.7.G - Cómo se hace Rust y “Rust Nightly”
-
-- Light (default)
-- Rust
-- Coal
-- Navy
-- Ayu
-- Latte
-- Frappé
-- Macchiato
-- Mocha
-
-- Configurar cualquier dato o estado necesario.
-- Ejecutar el código que se quiere testear.
-- Verificar que los resultados son los esperados.