测试失败，应该在其中放置JSON的空片

Question

I am testing a piece of code, called Compile:

// Compile takes in code, and returns JSON
// bytes and an error if there was one
func Compile(in string) ([]byte, error) {
    // iterate through every line in the code
    for _, line := range strings.Split(in, "
") {
        // Divide the line into sections
        // for easier processing
        tokens := strings.Split(line, " ")
        for _, a := range availableExpressions {
            for _, b := range availableStatements {
                if tokens[1] == b {
                    // It is an expression, so
                    // calculate the value of
                    // the expression
                    var val int
                    num1, err := strconv.Atoi(tokens[0])
                    if err != nil {
                        return nil, err
                    }
                    num2, err := strconv.Atoi(tokens[1])
                    if err != nil {
                        return nil, err
                    }
                    args := []int{num1, num2}
                    switch b {
                    case "+":
                        val = args[0] + args[1]
                    case "*":
                        val = args[0] * args[1]
                    case "-":
                        val = args[0] - args[1]
                    case "/":
                        val = args[0] / args[1]
                    }
                    cmd := &Mixed{
                        isExpression: true,
                        isStatement:  false,
                        Value: &Expression{
                            Name: b,
                            // for some reason go doesn't
                            // let me put args directly
                            Arguments: []interface{}{args},
                            Value:     val,
                        }}
                    fmt.Println(cmd.Value)
                    commands = append(commands, cmd)
                } else if tokens[0] == a {
                    // argument is a statement, don't bother
                    // to evaluate the value
                    arguments := strings.Join(tokens[1:], " ")
                    cmd := &Mixed{
                        isStatement:  true,
                        isExpression: false,
                        Value: &Statement{
                            Name:      a,
                            Arguments: []interface{}{arguments},
                        }}
                    fmt.Println(cmd.Value)
                    commands = append(commands, cmd)
                }
            }
        }
    }
    gen, err := json.Marshal(commands)
    // fmt prints an empty slice
    // no matter what is in
    fmt.Println(commands)
    // empty the commands
    commands = make([]*Mixed, 0)
    if err != nil {
        return nil, err
    }
    return gen, nil
}

But when running the test:

$ cat compile_test.go
package main

import "fmt"
import "testing"

func TestCompile(t *testing.T) {
    cases := []struct {
        in  string
        out string
    }{
        {
            in:  "print \"Hello World\"",
            out: "[{\"Name\":\"print\",\"Arguments\":[\"Hello World\"]}]",
        },
        {
            in:  "print \"My name is Jack White\"",
            out: "[{\"Name\":\"print\",\"Arguments\":[\"My name is Jack White\"]}]",
        },
    }
    real_stuff, err := Compile(cases[0].in)
    if err != nil {
        fmt.Printf("error: %s
", err)
    }
    if string(real_stuff) != cases[0].out {
        fmt.Printf("got %s, expected %s
", string(real_stuff), cases[0].out)
        t.Fail()
    }
    real_stuff, err = Compile(cases[1].in)
    if err != nil {
        fmt.Printf("error: %s
", err)
    }
    if string(real_stuff) != cases[1].out {
        fmt.Printf("got %s, expected %s
", string(real_stuff), cases[1].out)
        t.Fail()
    }
}
$ go test
[]
got [], expected [{"Name":"print","Arguments":["Hello World"]}]
[]
got [], expected [{"Name":"print","Arguments":["My name is Jack White"]}]
--- FAIL: TestCompile (0.06s)

Can someone explain why the test fails and why Compile doesn't work?

Answer 1

You need to debug your code logic:

I switched:

    for _, a := range availableExpressions {
        for _, b := range availableStatements {

with:

    for _, a := range availableStatements {
        for _, b := range availableExpressions {

Run this:

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "strconv"
    "strings"
)

// Function not implemented yet,
// but there for completedness
type Function struct {
    Name      string
    Arguments []interface{}
    // A function can contain
    // both expressions and
    // statements
    Code []Mixed
}

// Mixed can be either Statement
// or Expression
type Mixed struct {
    isStatement  bool
    isExpression bool
    Value        interface{}
}

// Statement represents
// statements. How a statement
// is used is entirely up to
// the interpreter.
type Statement struct {
    Name      string
    Arguments []interface{}
}

// Since an Expression
// is calculated beforehand,
// store the value
type Expression struct {
    Name      string
    Arguments []interface{}
    Value     interface{}
}

// commands contains commands to
// execute later.
// It is of type Mixed because Mixed
// can be of type Expression or Statement
var commands = make([]*Mixed, 0)

var availableStatements = []string{
    "print",
}
var availableExpressions = []string{
    "+",
    "-",
    "*",
    "/",
}

// Compile takes in code, and returns JSON
// bytes and an error if there was one
func Compile(in string) ([]byte, error) {
    // iterate through every line in the code
    for _, line := range strings.Split(in, "
") {
        // Divide the line into sections
        // for easier processing
        tokens := strings.Split(line, " ")
        for _, a := range availableStatements {
            for _, b := range availableExpressions {
                if tokens[1] == b {
                    // It is an expression, so
                    // calculate the value of
                    // the expression
                    var val int
                    num1, err := strconv.Atoi(tokens[0])
                    if err != nil {
                        return nil, err
                    }
                    num2, err := strconv.Atoi(tokens[1])
                    if err != nil {
                        return nil, err
                    }
                    args := []int{num1, num2}
                    switch b {
                    case "+":
                        val = args[0] + args[1]
                    case "*":
                        val = args[0] * args[1]
                    case "-":
                        val = args[0] - args[1]
                    case "/":
                        val = args[0] / args[1]
                    }
                    cmd := &Mixed{
                        isExpression: true,
                        isStatement:  false,
                        Value: &Expression{
                            Name: b,
                            // for some reason go doesn't
                            // let me put args directly
                            Arguments: []interface{}{args},
                            Value:     val,
                        }}
                    fmt.Println(cmd.Value)
                    commands = append(commands, cmd)
                } else if tokens[0] == a {
                    // argument is a statement, don't bother
                    // to evaluate the value
                    arguments := strings.Join(tokens[1:], " ")
                    cmd := &Mixed{
                        isStatement:  true,
                        isExpression: false,
                        Value: &Statement{
                            Name:      a,
                            Arguments: []interface{}{arguments},
                        }}
                    fmt.Println(cmd.Value)
                    commands = append(commands, cmd)
                }
            }
        }
    }
    gen, err := json.Marshal(commands)
    fmt.Println(commands)
    // empty the commands
    commands = make([]*Mixed, 0)
    if err != nil {
        return nil, err
    }
    return gen, nil
}

func Execute(input_file string) error {
    // open input file
    f, err := ioutil.ReadFile(input_file)
    if err != nil {
        return err
    }
    // unmarshal the JSON
    var data []*Mixed
    err = json.Unmarshal(f, data)
    if err != nil {
        return err
    }
    for _, v := range data {
        var a *Expression
        var b *Statement
        // get absolute value of v
        if v.isExpression {
            a = v.Value.(*Expression)
            b = nil
        } else if v.isStatement {
            b = v.Value.(*Statement)
            a = nil
        }
        // since the expression is
        // already calculated at compile-time,
        // don't bother evaluating
        if a != nil {
            fmt.Println(a.Value)
        }
        if b != nil {
            // on the other hand, evaluate
            // statements since they're *not*
            // evaluated at compile-time
            switch b.Name {
            case "print":
                for _, n := range b.Arguments {
                    fmt.Printf("%v", n)
                }
                fmt.Printf("
")
            }
        }
    }
    return nil
}

func main() {
    cases := []struct {
        in  string
        out string
    }{
        {
            in:  "print \"Hello World\"",
            out: "[{\"Name\":\"print\",\"Arguments\":[\"Hello World\"]}]",
        },
        {
            in:  "print \"My name is Jack White\"",
            out: "[{\"Name\":\"print\",\"Arguments\":[\"My name is Jack White\"]}]",
        },
    }
    real_stuff, err := Compile(cases[0].in)
    if err != nil {
        fmt.Printf("error: %s
", err)
    }
    fmt.Println(string(real_stuff))
    if string(real_stuff) != cases[0].out {
        fmt.Printf("got %s, expected %s
", string(real_stuff), cases[0].out)
        //t.Fail()
    }
    real_stuff, err = Compile(cases[1].in)
    if err != nil {
        fmt.Printf("error: %s
", err)
    }
    fmt.Println(string(real_stuff))
    if string(real_stuff) != cases[1].out {
        fmt.Printf("got %s, expected %s
", string(real_stuff), cases[1].out)
        //t.Fail()
    }
}

output (go test):

&{print ["Hello World"]}
&{print ["Hello World"]}
&{print ["Hello World"]}
&{print ["Hello World"]}
[0xc04204e3c0 0xc04204e420 0xc04204e460 0xc04204e4c0]
got [{"Value":{"Name":"print","Arguments":["\"Hello World\""]}},{"Value":{"Name":"print","Arguments":["\"Hello World\""]}},{"Value":{"Name":"print","Arguments":["\"Hello World\""]}},{"Value":{"Name":"print","Arguments":["\"Hello World\""]}}], expected [{"Name":"print","Arguments":["Hello World"]}]
&{print ["My name is Jack White"]}
&{print ["My name is Jack White"]}
&{print ["My name is Jack White"]}
&{print ["My name is Jack White"]}
[0xc04204e6e0 0xc04204e720 0xc04204e760 0xc04204e7c0]
got [{"Value":{"Name":"print","Arguments":["\"My name is Jack White\""]}},{"Value":{"Name":"print","Arguments":["\"My name is Jack White\""]}},{"Value":{"Name":"print","Arguments":["\"My name is Jack White\""]}},{"Value":{"Name":"print","Arguments":["\"My name is Jack White\""]}}], expected [{"Name":"print","Arguments":["My name is Jack White"]}]
--- FAIL: TestCompile (0.00s)
FAIL
exit status 1
FAIL    ar/sogo 0.016s