Comment tester l'entrée imbriquée dans Go

l'éditeur php Youzi vous présente comment tester les entrées imbriquées dans Go. Lors de l'écriture de code Go, vous rencontrez souvent des situations dans lesquelles vous devez gérer des entrées imbriquées, telles que des données JSON imbriquées ou des tableaux multidimensionnels. Comment tester efficacement ces entrées imbriquées est une question clé. Cet article vous montrera quelques méthodes et techniques pratiques pour vous aider à tester facilement les entrées imbriquées dans Go et à garantir l'exactitude et la stabilité de votre code. Que vous soyez débutant ou développeur expérimenté, ces conseils vous seront très utiles lors de l’écriture et du test du code Go. Découvrons-le ensemble !

Contenu de la question

J'ai pour fonction d'utiliser os.stdin pour obtenir les commentaires de l'utilisateur

func (i input) getinput(stdin io.reader) (string, error) {
    reader := bufio.newreader(stdin)

    data, err := reader.readstring('\n')
    if err != nil {
        return "", fmt.errorf("get input error: %w", err)
    }

    return strings.replaceall(data, "\n", ""), nil
}

Dans mon programme, j'ai besoin d'avoir 2 entrées :

• D'abord utilisé pour obtenir des informations de base telles que le nom d'utilisateur
• Le second est utilisé pour obtenir des informations supplémentaires qui dépendent de la première entrée

name,err := getinput(os.stdin)
if err != nil {
 // error handling.....
}

switch name {
  case "test":
    //do something...
    age, err := getinput(os.stdin)
    if err != nil {
      // error handling.....
    }
    fmt.println(age)

  case "another":
    // here another input
}

Est-il possible d'écrire un test unitaire pour cette situation ? Pour tester une saisie utilisateur, j'ai utilisé cet extrait de code et cela fonctionne :

    var stdin bytes.Buffer
    stdin.Write([]byte(fmt.Sprintf("%s\n", tt.input)))
    GetInput(stdin)

Mais cela ne fonctionne pas avec 2 entrées imbriquées

Solution de contournement

Envisagez peut-être d'utiliser une fonction qui renvoie un type spécifique de résultat et de la mettre dans un package séparé.

Depuis que j'ai vu name 和 age ，也许我们可以假设一个具体类型，例如 person mentionné pour clarification.

Il est important de noter que nous souhaitons inclure le lecteur réel comme paramètre, plutôt que d'avoir une référence codée en dur à os.stdin . Cela rend possible la simulation d’entrées imbriquées en premier lieu.

Dans ce cas, la signature de la méthode pourrait ressembler à ceci :

func nestedinput(input io.reader) (*person, error)

Le type correspondant peut être :

type person struct {
    name string
    age  int
}

Si vous avez maintenant fusionné vos extraits de code dans un fichier go complet, dans un répertoire séparé portant le nom input.go, cela pourrait ressembler à ceci :

package input

import (
    "bufio"
    "fmt"
    "io"
    "strconv"
    "strings"
)

func getinput(reader *bufio.reader) (string, error) {
    data, err := reader.readstring('\n')
    if err != nil {
        return "", fmt.errorf("get input error: %w", err)
    }

    return strings.replaceall(data, "\n", ""), nil
}

type person struct {
    name string
    age  int
}

func nestedinput(input io.reader) (*person, error) {
    reader := bufio.newreader(input)
    name, err := getinput(reader)
    if err != nil {
        return nil, err
    }

    switch name {
    case "q":
        return nil, nil
    default:
        agestr, err := getinput(reader)
        if err != nil {
            return nil, err
        }
        age, err := strconv.atoi(agestr)
        if err != nil {
            return nil, err
        }
        return &person{name: name, age: age}, nil
    }
}

q 的输入返回 nil、nil et peut être utilisé pour terminer la saisie, par exemple si la requête est effectuée en boucle.

Tests unitaires

Tests unitaires

func test_nestedinput(t *testing.t)

Le fichier nommé input_test.go devrait maintenant fournir les données d'entrée.

Puisque nestedinput 函数现在需要 io.reader est pris comme paramètre, nous pouvons simplement générer l'entrée requise, par exemple

input := strings.newreader("george\n26\n")

Le test pourrait donc ressembler à ceci :

package input

import (
    "strings"
    "testing"
)

func Test_nestedInput(t *testing.T) {
    input := strings.NewReader("George\n26\n")
    person, err := NestedInput(input)
    if err != nil {
        t.Error("nested input failed")
    }
    if person == nil {
        t.Errorf("expected person, but got nil")
        return
    }
    if person.Name != "George" {
        t.Errorf("wrong name %s, expected 'George'", person.Name)
    }
    if person.Age != 26 {
        t.Errorf("wrong age %d, expected 26", person.Age)
    }
}

Bien sûr, le test peut être étendu avec plus de détails. Cependant, comme vous pouvez le constater, cela simule une entrée imbriquée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!