Directorio de artículos
Tarea 2: informe de práctica TDD
entorno de laboratorio
Sistema operativo : Mac OS
Compilador : VScode
Ejercicios de capítulos iterativos
Ejercicio 1
- Modifique el código de prueba para que la persona que llama pueda especificar el número de repeticiones de caracteres y luego corrija el código.
El primer archivo de prueba preparado repeat_test.gosustancialmente las mismas secciones de código y dado que solo es necesario cambiar Repeat()la función de los dos parámetros, es la necesidad de repetir una cadena, y el otro es el número de repeticiones, como sigue
package iteration
import "testing"
func TestRepeat(t *testing.T) {
repeated := Repeat("a", 4 )
expected := "aaaaa"
if repeated != expected {
t.Errorf("expected '%q' but got '%q'", expected, repeated)
}
}
Primero ejecute el código de prueba y obtenga los siguientes resultados
Puede ver que la compilación fallará porque la función a probar no está escrita
Comience a escribir la Repeat()función, la función toma dos parámetros, un tipo de cadena y el otro es un int, un método se implementa en forma de bucle for, como sigue
package iteration
func Repeat(character string, count int) string {
var ret string = ""
for i := 0; i < count; i++ {
ret += character
}
return ret
}
Después de escribir el código de prueba, compilar y ejecutar, ya sea directamente en la línea de comandos VScode a go testun comando para probar los resultados obtenidos se muestran a continuación
Puede ver los resultados FAIL, porque la razón por la que elegí repetir la prueba 4 veces, para que los resultados no sean los deseados, vuelva a probar el cambio de código, puede obtener el resultado correcto, aparecerá en el archivo de prueba de la PASSsiguiente manera:
Ejercicio 2
- Escribe un
ExampleRepeatpara mejorar la documentación de tu función
En el ejemplo de uso, el capítulo anterior: entero mencionado anteriormente, directamente en la repeat_test.gocreación de una nueva función ExampleRepeat, esta función se usa para generar el resultado obtenido ( nota : dado que debe enviarse al comienzo del código, es necesario importar el fmtpaquete), Compare con el contenido de los siguientes comentarios, si es el mismo, tendrá éxito, de lo contrario fallará. El código es el siguiente:
func ExampleRepeat() {
s := Repeat("a", 5)
fmt.Println(s)
// Output: aaaa
}
Puede ver que configuré la iteración 5 veces, y la salida comentada a continuación se itera cuatro veces, por lo que debería obtener el resultado incorrecto, como se muestra a continuación:
Vuelva a modificar los siguientes comentarios para que se repita cinco veces, y los resultados de la prueba son los siguientes:
Se puede ver en el resultado que la prueba fue exitosa. PASS
Ejercicio 3
- Eche un vistazo al paquete de cuerdas . Encuentra funciones que creas que podrían ser útiles y escribe algunas pruebas para ellas. Invertir tiempo en aprender la biblioteca estándar dará sus frutos lentamente.
func Compare(a, b string) intFunción, esta función se utiliza para comparar el tamaño lexicográfico de la cadena antes y después, si a <b, devuelve -1; si a = b, devuelve 0; si a> b, devuelve 1, el archivo de código de prueba escompare_test.go
package iteration
import (
"strings"
"testing"
)
func TestCompare(t *testing.T) {
ans := strings.Compare("h", "z")
expected := -1
if ans != expected {
t.Errorf("expected '%d' but got '%d'", expected, ans)
}
}
Luego prueba, los resultados son los siguientes:
El resultado muestra que la prueba es exitosa
func Count(s, substr string) intFunción, esta función es contar el número de subcadena subcadena en la cadena s, y luego devolver el valor, el archivo de código de prueba escount_test.go
package iteration
import (
"strings"
"testing"
)
func TestCount(t *testing.T) {
ans := strings.Count("cheeze", "e")
expected := 3
if ans != expected {
t.Errorf("expected '%d' but got '%d'", expected, ans)
}
}
Luego prueba, los resultados son los siguientes:
Se puede ver en el resultado que la prueba fue exitosa.
func ReplaceAll(s, old, new string) stringFunción, esta función reemplaza todas las cadenas antiguas con cadenas nuevas en la cadena s. El archivo probado esreplace_test.go
package iteration
import (
"strings"
"testing"
)
func TestReplace(t *testing.T) {
ans := strings.ReplaceAll("oink oink oink", "oink", "moo")
expected := "moo moo moo"
if ans != expected {
t.Errorf("expected '%s' but got '%s'", expected, ans)
}
}
Luego prueba, los resultados son los siguientes:
Se puede ver en el resultado que la prueba fue exitosa.
Implementación de algoritmo de clasificación rápida
Introducción al algoritmo
Clasificación rápida (Quicksort) es una mejora de la clasificación de burbujas. Los principales pasos del algoritmo son:
Primero establezca un valor de límite y divida la matriz en partes izquierda y derecha por el valor de límite.
Recopile datos mayores o iguales que el valor de corte a la derecha de la matriz y datos menores que el valor de corte a la izquierda de la matriz. En este momento, cada elemento de la parte izquierda es menor o igual que el valor de corte y cada elemento de la parte derecha es mayor o igual que el valor de corte.
Luego, los datos de la izquierda y la derecha se pueden ordenar de forma independiente. Para los datos de la matriz a la izquierda, también puede tomar un valor de demarcación para dividir esta parte de los datos en partes izquierda y derecha, y también colocar el valor más pequeño a la izquierda y el valor más grande a la derecha. Los datos de la matriz de la derecha también se pueden procesar de manera similar.
Repita el proceso anterior, puede ver que esta es una definición recursiva. Después de ordenar de forma recursiva la parte izquierda, ordena de forma recursiva la parte derecha. Cuando se ordenan los datos de las partes izquierda y derecha, se completa la clasificación de toda la matriz.
A través de la descripción anterior del algoritmo, primero complete una función principal para probar si la clasificación rápida se implementó correctamente, el código es el siguiente:
package main
import "fmt"
const MAXN = 10
var arr = []int{
7, 4, 8, 5, 3, 6, 9, 1, 10, 2}
// 快速排序递归实现
func QuickSort(arr []int, l, r int) {
pivot := arr[l] // 选取中间值
pos := l // 中间值的位置
i, j := l, r
for i <= j {
for j >= pos && arr[j] >= pivot {
j--
}
if j >= pos {
arr[pos] = arr[j]
pos = j
}
for i <= pos && arr[i] <= pivot {
i++
}
if i <= pos {
arr[pos] = arr[i]
pos = i
}
}
arr[pos] = pivot
if pos-l > 1 {
QuickSort(arr, l, pos-1)
}
if r-pos > 1 {
QuickSort(arr, pos+1, r)
}
}
func main() {
QuickSort(arr, 0, len(arr)-1)
for i := 0; i < MAXN; i++ {
fmt.Printf("%d\t", arr[i])
}
}
Al ejecutar el código completo, puede ver el resultado de la siguiente manera:
Escribe la prueba primero
Primero escriba un archivo de prueba QuickSort_test.go, pero no escriba QuickSort.goarchivos para ver si la salida del archivo de prueba
package Qsort
import "testing"
const MAXN = 10
var arr = []int{
7, 4, 8, 5, 3, 6, 9, 1, 10, 2}
func TestQuickSort(t *testing.T) {
QuickSort(arr, 0, MAXN-1)
expected := []int{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
flag := true
for i := 0; i < MAXN; i++ {
if arr[i] != expected[i] {
flag = false
}
}
if flag == false {
t.Errorf("expected ")
for i := 0; i < MAXN; i++ {
t.Errorf("%d\t", expected[i])
}
t.Errorf("but got")
for i := 0; i < MAXN; i++ {
t.Errorf("%d\t", arr[i])
}
}
}
Después de escribir el código, ejecútelo directamente y obtenga los siguientes resultados
Puede ver que debido a la falta del archivo probado, compilará errores
Prueba de ejecución de código mínima
Comience a escribir el archivo de código que se probará QuickSort.go, para que la prueba se pueda ejecutar correctamente, así que simplemente escriba un código vacío con la sintaxis correcta
package Qsort
// 快速排序递归实现
func QuickSort(arr []int, l, r int) {
}
Después de escribir el código, pruébelo y el resultado de salida es el siguiente
Prueba de finalización de código exitosa
Una vez finalizada la prueba previa QuickSort.go, modifique el archivo y el código modificado se
package Qsort
// 快速排序递归实现
func QuickSort(arr []int, l, r int) {
pivot := arr[l] // 选取中间值
pos := l // 中间值的位置
i, j := l, r
for i <= j {
for j >= pos && arr[j] >= pivot {
j--
}
if j >= pos {
arr[pos] = arr[j]
pos = j
}
for i <= pos && arr[i] <= pivot {
i++
}
if i <= pos {
arr[pos] = arr[i]
pos = i
}
}
arr[pos] = pivot
if pos-l > 1 {
QuickSort(arr, l, pos-1)
}
if r-pos > 1 {
QuickSort(arr, pos+1, r)
}
}
Primera prueba, cambie el 2 esperado en el código de prueba a 3 para ver si el archivo de prueba puede detectar errores, el resultado se muestra en la figura
En la figura anterior, podemos ver que el archivo de prueba puede detectar errores y luego realizar la prueba correcta. El resultado es el
que se muestra en la figura anterior. Puede ver que la prueba fue exitosa y pasó, lo que indica que el código de clasificación rápido que diseñé es correcto.
Refactor
Dado que el algoritmo original no tiene mucho que modificar, los comentarios se hacen por encima del código original.
Benchmarks
Escriba una prueba comparativa en el archivo de prueba, haga que el código de prueba se ejecute bN veces y pruebe cuánto tiempo lleva, el código agregado es el siguiente
func BenchmarkQuickSort(b *testing.B) {
for i := 0; i < b.N; i++ {
var arrt = []int{
7, 4, 8, 5, 3, 6, 9, 1, 10, 2}
QuickSort(arrt, 0, MAXN-1)
}
}
Escrito después del código de evaluación comparativa, ingrese el comando en la línea de comando, go test -bench=.el tiempo para ejecutar el código de prueba, el resultado es el siguiente
Hasta ahora, se ha completado todo el proceso de prueba.
dirección de github
Portal de código: Portal
para resumir
A través de este experimento, aprendí los pasos básicos de las pruebas, entendí conceptos como TDD, refactorización, pruebas, pruebas comparativas y dominé aún más algunos usos del lenguaje GO. Puedo usarlo hábilmente en la escritura de código y en la escritura de código. También encontré algunas dificultades, que se resolvieron mediante el aprendizaje de GO en la red de aprendizaje de idiomas C.