From ecd5d58562452267ec7d0439b2f3caf8c05ebe45 Mon Sep 17 00:00:00 2001 From: Kevin Atkinson Date: Fri, 31 Aug 2018 15:01:41 -0400 Subject: [PATCH 1/4] Gofmt. --- multibase_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/multibase_test.go b/multibase_test.go index d688e66..f389f5c 100644 --- a/multibase_test.go +++ b/multibase_test.go @@ -7,13 +7,13 @@ import ( ) func TestMap(t *testing.T) { - for s,e := range Encodings { + for s, e := range Encodings { s2 := EncodingToStr[e] if s != s2 { t.Errorf("round trip failed on encoding map: %s != %s", s, s2) } } - for e,s := range EncodingToStr { + for e, s := range EncodingToStr { e2 := Encodings[s] if e != e2 { t.Errorf("round trip failed on encoding map: '%c' != '%c'", e, e2) From ac3d23441b195be0508184a532fbfb355e3e2111 Mon Sep 17 00:00:00 2001 From: Kevin Atkinson Date: Fri, 31 Aug 2018 15:06:09 -0400 Subject: [PATCH 2/4] Don't return an error on NewEncoder, panic on invalid encodings instead. Most of the time this method will be used with a constant and the error will be thrown away anyway. By not returning an error we can use this function to initialize global variables. The function EncoderByName should be used when working with user provided input and we care about the error. --- encoder.go | 10 ++++++---- encoder_test.go | 34 +++++++++++++++------------------- 2 files changed, 21 insertions(+), 23 deletions(-) diff --git a/encoder.go b/encoder.go index d1f87f0..9323b57 100644 --- a/encoder.go +++ b/encoder.go @@ -10,13 +10,15 @@ type Encoder struct { enc Encoding } -// NewEncoder create a new Encoder from an Encoding -func NewEncoder(base Encoding) (Encoder, error) { +// NewEncoder create a new Encoder from an Encoding. It will panic is +// the encoding is invalid. To check for a valid encoding use the +// EncodingToStr map. +func NewEncoder(base Encoding) Encoder { _, ok := EncodingToStr[base] if !ok { - return Encoder{-1}, fmt.Errorf("Unsupported multibase encoding: %d", base) + panic(fmt.Errorf("Unsupported multibase encoding: %d", base)) } - return Encoder{base}, nil + return Encoder{base} } // EncoderByName creates an encoder from a string, the string can diff --git a/encoder_test.go b/encoder_test.go index d09c805..6274e44 100644 --- a/encoder_test.go +++ b/encoder_test.go @@ -4,13 +4,6 @@ import ( "testing" ) -func TestInvalidPrefix(t *testing.T) { - _, err := NewEncoder('q') - if err == nil { - t.Error("expected failure") - } -} - func TestInvalidName(t *testing.T) { values := []string{"invalid", "", "q"} for _, val := range values { @@ -21,23 +14,26 @@ func TestInvalidName(t *testing.T) { } } -func TestPrefix(t *testing.T) { - for str, base := range Encodings { - prefix, err := NewEncoder(base) - if err != nil { - t.Fatalf("NewEncoder(%c) failed: %v", base, err) - } - str1, err := Encode(base, sampleBytes) +func TestEncoder(t *testing.T) { + for name, code := range Encodings { + encoder := NewEncoder(code) + str, err := Encode(code, sampleBytes) if err != nil { t.Fatal(err) } - str2 := prefix.Encode(sampleBytes) - if str1 != str2 { - t.Errorf("encoded string mismatch: %s != %s", str1, str2) + str2 := encoder.Encode(sampleBytes) + if str != str2 { + t.Errorf("encoded string mismatch: %s != %s", str, str2) } - _, err = EncoderByName(str) + _, err = EncoderByName(name) if err != nil { - t.Fatalf("NewEncoder(%s) failed: %v", str, err) + t.Errorf("EncoderByName(%s) failed: %v", name, err) + } + // Test that an encoder can be created from the single letter + // prefix + _, err = EncoderByName(str[0:1]) + if err != nil { + t.Errorf("EncoderByName(%s) failed: %v", str[0:1], err) } } } From 2170058ef98bc1e5186780d59e0a4512ef4b7cce Mon Sep 17 00:00:00 2001 From: Kevin Atkinson Date: Fri, 31 Aug 2018 18:17:03 -0400 Subject: [PATCH 3/4] Add CheckEncoding function. --- encoder.go | 21 +++++++++++++++------ encoder_test.go | 7 +++++++ 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/encoder.go b/encoder.go index 9323b57..f4d35a1 100644 --- a/encoder.go +++ b/encoder.go @@ -10,17 +10,26 @@ type Encoder struct { enc Encoding } -// NewEncoder create a new Encoder from an Encoding. It will panic is -// the encoding is invalid. To check for a valid encoding use the -// EncodingToStr map. +// NewEncoder create a new Encoder from an Encoding. It will panic if +// the encoding is invalid. To check for a valid encoding use +// CheckEncoding. func NewEncoder(base Encoding) Encoder { - _, ok := EncodingToStr[base] - if !ok { - panic(fmt.Errorf("Unsupported multibase encoding: %d", base)) + err := CheckEncoding(base) + if err != nil { + panic(err) } return Encoder{base} } +// CheckEncoding checks that an encoding is valid +func CheckEncoding(base Encoding) error { + _, ok := EncodingToStr[base] + if !ok { + return fmt.Errorf("Unsupported multibase encoding: %d", base) + } + return nil +} + // EncoderByName creates an encoder from a string, the string can // either be the multibase name or single character multibase prefix func EncoderByName(str string) (Encoder, error) { diff --git a/encoder_test.go b/encoder_test.go index 6274e44..39f1009 100644 --- a/encoder_test.go +++ b/encoder_test.go @@ -4,6 +4,13 @@ import ( "testing" ) +func TestInvalidEncoding(t *testing.T) { + err := CheckEncoding(Encoding('q')) + if err == nil { + t.Errorf("CheckEncoding('q') expected failure") + } +} + func TestInvalidName(t *testing.T) { values := []string{"invalid", "", "q"} for _, val := range values { From 3b3047873d428f3373a6279d3174cfb05c11ccc2 Mon Sep 17 00:00:00 2001 From: Kevin Atkinson Date: Fri, 31 Aug 2018 20:08:55 -0400 Subject: [PATCH 4/4] Use MustNewEncoder instead for version that does not panic. --- encoder.go | 29 ++++++++++++++--------------- encoder_test.go | 17 +++++++++++------ 2 files changed, 25 insertions(+), 21 deletions(-) diff --git a/encoder.go b/encoder.go index f4d35a1..42e753f 100644 --- a/encoder.go +++ b/encoder.go @@ -10,24 +10,23 @@ type Encoder struct { enc Encoding } -// NewEncoder create a new Encoder from an Encoding. It will panic if -// the encoding is invalid. To check for a valid encoding use -// CheckEncoding. -func NewEncoder(base Encoding) Encoder { - err := CheckEncoding(base) - if err != nil { - panic(err) - } - return Encoder{base} -} - -// CheckEncoding checks that an encoding is valid -func CheckEncoding(base Encoding) error { +// NewEncoder create a new Encoder from an Encoding +func NewEncoder(base Encoding) (Encoder, error) { _, ok := EncodingToStr[base] if !ok { - return fmt.Errorf("Unsupported multibase encoding: %d", base) + return Encoder{-1}, fmt.Errorf("Unsupported multibase encoding: %d", base) } - return nil + return Encoder{base}, nil +} + +// MustNewEncoder is like NewEncoder but will panic if the encoding is +// invalid. +func MustNewEncoder(base Encoding) Encoder { + _, ok := EncodingToStr[base] + if !ok { + panic("Unsupported multibase encoding") + } + return Encoder{base} } // EncoderByName creates an encoder from a string, the string can diff --git a/encoder_test.go b/encoder_test.go index 39f1009..3db2c13 100644 --- a/encoder_test.go +++ b/encoder_test.go @@ -4,10 +4,10 @@ import ( "testing" ) -func TestInvalidEncoding(t *testing.T) { - err := CheckEncoding(Encoding('q')) +func TestInvalidCode(t *testing.T) { + _, err := NewEncoder('q') if err == nil { - t.Errorf("CheckEncoding('q') expected failure") + t.Error("expected failure") } } @@ -23,7 +23,12 @@ func TestInvalidName(t *testing.T) { func TestEncoder(t *testing.T) { for name, code := range Encodings { - encoder := NewEncoder(code) + encoder, err := NewEncoder(code) + if err != nil { + t.Fatal(err) + } + // Make sure the MustNewEncoder doesn't panic + MustNewEncoder(code) str, err := Encode(code, sampleBytes) if err != nil { t.Fatal(err) @@ -34,13 +39,13 @@ func TestEncoder(t *testing.T) { } _, err = EncoderByName(name) if err != nil { - t.Errorf("EncoderByName(%s) failed: %v", name, err) + t.Fatalf("EncoderByName(%s) failed: %v", name, err) } // Test that an encoder can be created from the single letter // prefix _, err = EncoderByName(str[0:1]) if err != nil { - t.Errorf("EncoderByName(%s) failed: %v", str[0:1], err) + t.Fatalf("EncoderByName(%s) failed: %v", str[0:1], err) } } }