Error type checking in Go for unit table tests

Question

I want to test the type of the error returned against a table test of expected results, like so:

var tabletest = []struct{
  instruction string
  want string
  err error
}{
  {"synonym for hi", "hello", nil}, // input, retval, errtype
  {"synonym for hig", "", TranslationError{}}, 
  {"sssnymm for hi", "", InstructionError{}},
}

func TestThesaurus(t *Testing) {
  for _, testcase := range tabletest {
    got, err := Thesaurus(testcase.instruction)
    // check error type
    // check result type
  }
}

In the example above, different error sub-classes are returned based on the type of error that occurred. You may imagine that the caller of the made-up Thesaurus function would handle each error type differently.

What is the idiomatic way to assert that the type of error returned, and the type of error expected, are the same?

Linear · Accepted Answer · 2014-04-29 20:27:11Z

5

Use a type switch.

func TestThesaurus(t *Testing) {
  for _, testcase := range tabletest {
    got, err := Thesaurus(testcase.instruction)

    // Don't use && because we want to trap all cases where err is nil
    if err == nil  {
      if testcase.err != nil {
          // failure
      }
      continue
    }

    switch err.(type) {
    case TranslationError:
        if _,ok := (testcase.err).(TranslationError); !ok {
           // failure
        }
    case InstructionError:
        if _,ok := (testcase.err).(InstructionError); !ok {
           // failure
        }
    default:
        // Unrecognized error, failure
    }
}

It's definitely not as succinct as the reflect way of doing it, but I think it's more Go-ish and explicit.

answered Apr 29, 2014 at 20:27

Linear

22.5k7 gold badges64 silver badges73 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Alex Over a year ago

This is indeed very clear as to what errors might be expected to occur. I'd certainly prefer to handle the function that way if calling it for real. I'm still of two minds as to whether the clarity justifies the verbosity, though.

Alex · Accepted Answer · 2014-04-30 18:33:59Z

4

There's also this idiom:

In Thesaurus...

import "errors"

var (
    TranslationError = errors.New("")
    InstructionError = errors.New("")
)

In Testcase...

if err != testcase.err {

}

However, I think in this idiom the errors must be defined in advance (i.e. the message cannot be changed).

edited Apr 30, 2014 at 18:33

answered Apr 29, 2014 at 20:41

Alex

18.6k10 gold badges51 silver badges53 bronze badges

Comments

Alex · Accepted Answer · 2014-04-29 19:30:45Z

2

reflect.TypeOf does the job:

import "reflect"

...

func TestThesaurus(t *Testing) {
  for _, testcase := range tabletest {
    got, err := Thesaurus(testcase.instruction)
    // check error type
    if goterr, wanterr := reflect.TypeOf(err), reflect.TypeOf(testcase.err); 
         goterr != wanterr {
      t.Errorf("For instruction %q, unexpected error: %q. Wanted %q", 
               testcase.instruction, goterr, wanterr)
    }
    // check result type
    if want := testcase.want; got != want {
      t.Errorf("For instruction %q, got %q, want %q.", 
               testcase.instruction, got, want)
    }
  }
}

Whether or not it's idiomatic is for the community to decide.

answered Apr 29, 2014 at 19:30

Alex

18.6k10 gold badges51 silver badges53 bronze badges

Collectives™ on Stack Overflow

Error type checking in Go for unit table tests

3 Answers 3

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related