From 2e0d8c3889590253b091de5d1c12b1a4dadf1c8f Mon Sep 17 00:00:00 2001 From: Thomas Voss Date: Sat, 10 Aug 2024 20:16:48 +0200 Subject: Do some renaming --- cmd/mfmt/main.go | 18 ++-- cmd/mfmt/util_test.go | 6 +- mintage/parser.go | 204 +++++++++++++++++++++++++++++++++++ mintage/parser_test.go | 277 ++++++++++++++++++++++++++++++++++++++++++++++++ mintages/parser.go | 204 ----------------------------------- mintages/parser_test.go | 277 ------------------------------------------------ 6 files changed, 493 insertions(+), 493 deletions(-) create mode 100644 mintage/parser.go create mode 100644 mintage/parser_test.go delete mode 100644 mintages/parser.go delete mode 100644 mintages/parser_test.go diff --git a/cmd/mfmt/main.go b/cmd/mfmt/main.go index b8e0722..5ff2a0a 100644 --- a/cmd/mfmt/main.go +++ b/cmd/mfmt/main.go @@ -8,11 +8,11 @@ import ( "strings" "unsafe" - "git.thomasvoss.com/euro-cash.eu/mintages" + "git.thomasvoss.com/euro-cash.eu/mintage" ) -const cols = unsafe.Sizeof(mintages.Row{}.Cols) / - unsafe.Sizeof(mintages.Row{}.Cols[0]) +const cols = unsafe.Sizeof(mintage.Row{}.Cols) / + unsafe.Sizeof(mintage.Row{}.Cols[0]) var rv int @@ -37,7 +37,7 @@ func main() { } func mfmt(path string, in io.Reader, out io.Writer) error { - data, err := mintages.Parse(in, path) + data, err := mintage.Parse(in, path) if err != nil { return err } @@ -75,7 +75,7 @@ func mfmt(path string, in io.Reader, out io.Writer) error { return nil } -func formatSection(out io.Writer, rows []mintages.Row) { +func formatSection(out io.Writer, rows []mintage.Row) { var ( year string longestMM int @@ -133,9 +133,9 @@ func formatSection(out io.Writer, rows []mintages.Row) { } func formatInt(n int) string { - if n <= mintages.Invalid { + if n <= mintage.Invalid { panic(fmt.Sprintf("invalid input %d", n)) - } else if n == mintages.Unknown { + } else if n == mintage.Unknown { return "?" } @@ -158,9 +158,9 @@ func formatInt(n int) string { func intlen(v int) int { switch { - case v <= mintages.Invalid: + case v <= mintage.Invalid: panic("mintage count is negative and not -1") - case v == 0, v == mintages.Unknown: + case v == 0, v == mintage.Unknown: return 1 default: n := 0 diff --git a/cmd/mfmt/util_test.go b/cmd/mfmt/util_test.go index e008e0b..af97146 100644 --- a/cmd/mfmt/util_test.go +++ b/cmd/mfmt/util_test.go @@ -6,7 +6,7 @@ package main import ( "testing" - "git.thomasvoss.com/euro-cash.eu/mintages" + "git.thomasvoss.com/euro-cash.eu/mintage" ) func TestFormatInt(t *testing.T) { @@ -18,7 +18,7 @@ func TestFormatInt(t *testing.T) { {123, "123"}, {81758, "81.758"}, {752759237528, "752.759.237.528"}, - {mintages.Unknown, "?"}, + {mintage.Unknown, "?"}, } { s := formatInt(x.n) if s != x.s { @@ -33,7 +33,7 @@ func TestIntLen(t *testing.T) { {123, len("123")}, {81758, len("81758")}, {752759237528, len("752759237528")}, - {mintages.Unknown, len("?")}, + {mintage.Unknown, len("?")}, } { n := intlen(x.x) if n != x.y { diff --git a/mintage/parser.go b/mintage/parser.go new file mode 100644 index 0000000..242a3bb --- /dev/null +++ b/mintage/parser.go @@ -0,0 +1,204 @@ +package mintage + +import ( + "bufio" + "fmt" + "io" + "strconv" + "strings" + "unicode" +) + +const ( + _ = -iota + Unknown // Unknown mintage + Invalid // All mintages <= than this are invalid +) + +type SyntaxError struct { + expected, got string + file string + linenr int +} + +func (e SyntaxError) Error() string { + return fmt.Sprintf("%s:%d: syntax error: expected %s but got %s", + e.file, e.linenr, e.expected, e.got) +} + +type Row struct { + Label string + Cols [8]int +} + +type Set struct { + StartYear int + Circ, BU, Proof []Row +} + +func Parse(reader io.Reader, file string) (Set, error) { + var ( + data Set // Our data struct + slice *[]Row // Where to append mintages + year int // The current year we are at + ) + + scanner := bufio.NewScanner(reader) + for linenr := 1; scanner.Scan(); linenr++ { + var mintmark struct { + s string + star bool + } + + line := scanner.Text() + tokens := strings.FieldsFunc(strings.TrimSpace(line), unicode.IsSpace) + + switch { + case len(tokens) == 0: + continue + case tokens[0] == "BEGIN": + if len(tokens)-1 != 1 { + return Set{}, SyntaxError{ + expected: "single argument to ‘BEGIN’", + got: fmt.Sprintf("%d arguments", len(tokens)-1), + file: file, + linenr: linenr, + } + } + + arg := tokens[1] + + switch arg { + case "CIRC": + slice = &data.Circ + case "BU": + slice = &data.BU + case "PROOF": + slice = &data.Proof + default: + if !isNumeric(arg, false) { + return Set{}, SyntaxError{ + expected: "‘CIRC’, ‘BU’, ‘PROOF’, or a year", + got: arg, + file: file, + linenr: linenr, + } + } + data.StartYear, _ = strconv.Atoi(arg) + } + + year = data.StartYear - 1 + case isLabel(tokens[0]): + n := len(tokens[0]) + if n > 2 && tokens[0][n-2] == '*' { + mintmark.star = true + mintmark.s = tokens[0][:n-2] + } else { + mintmark.s = tokens[0][:n-1] + } + tokens = tokens[1:] + if !isNumeric(tokens[0], true) && tokens[0] != "?" { + return Set{}, SyntaxError{ + expected: "mintage row after label", + got: tokens[0], + file: file, + linenr: linenr, + } + } + fallthrough + case isNumeric(tokens[0], true), tokens[0] == "?": + switch { + case slice == nil: + return Set{}, SyntaxError{ + expected: "coin type declaration", + got: tokens[0], + file: file, + linenr: linenr, + } + case data.StartYear == 0: + return Set{}, SyntaxError{ + expected: "start year declaration", + got: tokens[0], + file: file, + linenr: linenr, + } + } + + numcoins := len(Row{}.Cols) + tokcnt := len(tokens) + + if tokcnt != numcoins { + word := "entries" + if tokcnt == 1 { + word = "entry" + } + return Set{}, SyntaxError{ + expected: fmt.Sprintf("%d mintage entries", numcoins), + got: fmt.Sprintf("%d %s", tokcnt, word), + file: file, + linenr: linenr, + } + } + + var row Row + switch { + case mintmark.s == "": + year++ + row.Label = strconv.Itoa(year) + case mintmark.star: + year++ + fallthrough + default: + row.Label = fmt.Sprintf("%d %s", year, mintmark.s) + } + + for i, tok := range tokens { + if tok == "?" { + row.Cols[i] = Unknown + } else { + row.Cols[i] = atoiWithDots(tok) + } + } + *slice = append(*slice, row) + default: + return Set{}, SyntaxError{ + expected: "‘BEGIN’ directive or mintage row", + got: fmt.Sprintf("invalid token ‘%s’", tokens[0]), + file: file, + linenr: linenr, + } + } + } + + return data, nil +} + +func isNumeric(s string, dot bool) bool { + for _, ch := range s { + switch ch { + case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + default: + if ch != '.' || !dot { + return false + } + } + } + return true +} + +func isLabel(s string) bool { + n := len(s) + return (n > 2 && s[n-1] == ':' && s[n-2] == '*') || + (n > 1 && s[n-1] == ':') +} + +func atoiWithDots(s string) int { + n := 0 + for _, ch := range s { + if ch == '.' { + continue + } + n = n*10 + int(ch) - '0' + } + return n +} diff --git a/mintage/parser_test.go b/mintage/parser_test.go new file mode 100644 index 0000000..0a67685 --- /dev/null +++ b/mintage/parser_test.go @@ -0,0 +1,277 @@ +package mintage + +import ( + "bytes" + "errors" + "testing" +) + +func TestParserComplete(t *testing.T) { + data, err := Parse(bytes.NewBuffer([]byte(` + BEGIN 2020 + BEGIN CIRC + 1.000 1001 1002 1003 1004 1005 1006 1007 + 2000 ? 2002 2003 2004 2005 2006 2007 + BEGIN BU + 1.100 1101 1102 1103 1104 1105 1106 1107 + 2100 ? 2102 2103 2104 2105 2106 2107 + BEGIN PROOF + 1.200 1201 1202 1203 1204 1205 1206 1207 + 2200 ? 2202 2203 2204 2205 2206 2207 + `)), "-") + + if err != nil { + t.Fatalf(`Expected err=nil; got "%s"`, err) + } + if data.StartYear != 2020 { + t.Fatalf("Expected data.StartYear=2020; got %d", + data.StartYear) + } + + for i, row := range data.Circ { + for j, col := range row.Cols { + var n int + if i == 1 && j == 1 { + n = -1 + } else { + n = 1000*i + j + 1000 + } + if col != n { + t.Fatalf("Expected data.Circ[i][j]=%d; got %d", n, col) + } + } + } + + for i, row := range data.BU { + for j, col := range row.Cols { + var n int + if i == 1 && j == 1 { + n = -1 + } else { + n = 1000*i + j + 1100 + } + if col != n { + t.Fatalf("Expected data.BU[i][j]=%d; got %d", n, col) + } + } + } + + for i, row := range data.Proof { + for j, col := range row.Cols { + var n int + if i == 1 && j == 1 { + n = -1 + } else { + n = 1000*i + j + 1200 + } + if col != n { + t.Fatalf("Expected data.Proof[i][j]=%d; got %d", n, col) + } + } + } + + if len(data.Circ) != 2 { + t.Fatalf("Expected len(data.Circ)=2; got %d", len(data.Circ)) + } + if len(data.BU) != 2 { + t.Fatalf("Expected len(data.BU)=2; got %d", len(data.BU)) + } + if len(data.Proof) != 2 { + t.Fatalf("Expected len(data.Proof)=2; got %d", len(data.Proof)) + } +} + +func TestParserNoProof(t *testing.T) { + data, err := Parse(bytes.NewBuffer([]byte(` + BEGIN 2020 + BEGIN CIRC + 1.000 1001 1002 1003 1004 1005 1006 1007 + 2000 ? 2002 2003 2004 2005 2006 2007 + BEGIN BU + 1.100 1101 1102 1103 1104 1105 1106 1107 + 2100 ? 2102 2103 2104 2105 2106 2107 + `)), "-") + + if err != nil { + t.Fatalf(`Expected err=nil; got "%s"`, err) + } + + if len(data.Proof) != 0 { + t.Fatalf("Expected len(data.Proof)=0; got %d", len(data.Proof)) + } +} + +func TestParserMintmarks(t *testing.T) { + data, err := Parse(bytes.NewBuffer([]byte(` + BEGIN 2020 + BEGIN CIRC + 1.000 1001 1002 1003 1004 1005 1006 1007 + KNM*: 2000 ? 2002 2003 2004 2005 2006 2007 + MdP: 3000 ? 3002 3003 3004 3005 3006 3007 + `)), "-") + + if err != nil { + t.Fatalf(`Expected err=nil; got "%s"`, err) + } + + for i, row := range data.Circ { + for j, col := range row.Cols { + var n int + if i > 0 && j == 1 { + n = -1 + } else { + n = 1000*i + j + 1000 + } + if col != n { + t.Fatalf("Expected data.Circ[i][j]=%d; got %d", n, col) + } + } + } + + if data.Circ[0].Label != "2020" { + t.Fatalf(`Expected data.Circ[0].Label="2020"; got %s`, data.Circ[0].Label) + } + if data.Circ[1].Label != "2021\u00A0KNM" { + t.Fatalf(`Expected data.Circ[1].Label="2021 KNM"; got %s`, data.Circ[1].Label) + } + if data.Circ[2].Label != "2021\u00A0MdP" { + t.Fatalf(`Expected data.Circ[2].Label="2021 MdP"; got %s`, data.Circ[2].Label) + } +} + +func TestParserNoYear(t *testing.T) { + _, err := Parse(bytes.NewBuffer([]byte(` + BEGIN CIRC + 1.000 1001 1002 1003 1004 1005 1006 1007 + 2000 ? 2002 2003 2004 2005 2006 2007 + BEGIN BU + 1.100 1101 1102 1103 1104 1105 1106 1107 + 2100 ? 2102 2103 2104 2105 2106 2107 + BEGIN PROOF + 1.200 1201 1202 1203 1204 1205 1206 1207 + 2200 ? 2202 2203 2204 2205 2206 2207 + `)), "-") + + var sErr SyntaxError + if !errors.As(err, &sErr) { + t.Fatalf("Expected err=SyntaxError; got %s", err) + } +} + +func TestParserNoType(t *testing.T) { + _, err := Parse(bytes.NewBuffer([]byte(` + BEGIN 2020 + 1.000 1001 1002 1003 1004 1005 1006 1007 + 2000 ? 2002 2003 2004 2005 2006 2007 + BEGIN BU + 1.100 1101 1102 1103 1104 1105 1106 1107 + 2100 ? 2102 2103 2104 2105 2106 2107 + BEGIN PROOF + 1.200 1201 1202 1203 1204 1205 1206 1207 + 2200 ? 2202 2203 2204 2205 2206 2207 + `)), "-") + + var sErr SyntaxError + if !errors.As(err, &sErr) { + t.Fatalf("Expected err=SyntaxError; got %s", err) + } +} + +func TestParserNoYearOrType(t *testing.T) { + _, err := Parse(bytes.NewBuffer([]byte(` + 1.000 1001 1002 1003 1004 1005 1006 1007 + 2000 ? 2002 2003 2004 2005 2006 2007 + BEGIN BU + 1.100 1101 1102 1103 1104 1105 1106 1107 + 2100 ? 2102 2103 2104 2105 2106 2107 + BEGIN PROOF + 1.200 1201 1202 1203 1204 1205 1206 1207 + 2200 ? 2202 2203 2204 2205 2206 2207 + `)), "-") + + var sErr SyntaxError + if !errors.As(err, &sErr) { + t.Fatalf("Expected err=SyntaxError; got %s", err) + } +} + +func TestParserBadToken(t *testing.T) { + _, err := Parse(bytes.NewBuffer([]byte(` + BEGIN 2020 + BEGIN CIRC + 1.000 1001 1002 1003 1004 1005 1006 1007 + I’m bad + 2000 ? 2002 2003 2004 2005 2006 2007 + BEGIN BU + 1.100 1101 1102 1103 1104 1105 1106 1107 + 2100 ? 2102 2103 2104 2105 2106 2107 + BEGIN PROOF + 1.200 1201 1202 1203 1204 1205 1206 1207 + 2200 ? 2202 2203 2204 2205 2206 2207 + `)), "-") + + var sErr SyntaxError + if !errors.As(err, &sErr) { + t.Fatalf("Expected err=SyntaxError; got %s", err) + } +} + +func TestParserShortRow(t *testing.T) { + _, err := Parse(bytes.NewBuffer([]byte(` + BEGIN 2020 + BEGIN CIRC + 1.000 1001 1002 1003 1004 1005 1006 1007 + 2000 ? 2002 2003 2004 2005 2006 2007 + BEGIN BU + 1.100 1101 1102 1103 1104 1105 1106 1107 + 2100 ? 2102 2103 2104 2105 2106 + BEGIN PROOF + 1.200 1201 1202 1203 1204 1205 1206 1207 + 2200 ? 2202 2203 2204 2205 2206 2207 + `)), "-") + + var sErr SyntaxError + if !errors.As(err, &sErr) { + t.Fatalf("Expected err=SyntaxError; got %s", err) + } +} + +func TestParserLongRow(t *testing.T) { + _, err := Parse(bytes.NewBuffer([]byte(` + BEGIN 2020 + BEGIN CIRC + 1.000 1001 1002 1003 1004 1005 1006 1007 + 2000 ? 2002 2003 2004 2005 2006 2007 + BEGIN BU + 1.100 1101 1102 1103 1104 1105 1106 1107 + 2100 ? 2102 2103 2104 2105 2106 2107 2108 + BEGIN PROOF + 1.200 1201 1202 1203 1204 1205 1206 1207 + 2200 ? 2202 2203 2204 2205 2206 2207 + `)), "-") + + var sErr SyntaxError + if !errors.As(err, &sErr) { + t.Fatalf("Expected err=SyntaxError; got %s", err) + } +} + +func TestParserBadCoinType(t *testing.T) { + _, err := Parse(bytes.NewBuffer([]byte(` + BEGIN 2020 + BEGIN CIRCULATED + 1.000 1001 1002 1003 1004 1005 1006 1007 + 2000 ? 2002 2003 2004 2005 2006 2007 + BEGIN BU + 1.100 1101 1102 1103 1104 1105 1106 1107 + 2100 ? 2102 2103 2104 2105 2106 2107 + BEGIN PROOF + 1.200 1201 1202 1203 1204 1205 1206 1207 + 2200 ? 2202 2203 2204 2205 2206 2207 + `)), "-") + + var sErr SyntaxError + if !errors.As(err, &sErr) { + t.Fatalf("Expected err=SyntaxError; got %s", err) + } +} diff --git a/mintages/parser.go b/mintages/parser.go deleted file mode 100644 index 9f0c66f..0000000 --- a/mintages/parser.go +++ /dev/null @@ -1,204 +0,0 @@ -package mintages - -import ( - "bufio" - "fmt" - "io" - "strconv" - "strings" - "unicode" -) - -const ( - _ = -iota - Unknown // Unknown mintage - Invalid // All mintages <= than this are invalid -) - -type SyntaxError struct { - expected, got string - file string - linenr int -} - -func (e SyntaxError) Error() string { - return fmt.Sprintf("%s:%d: syntax error: expected %s but got %s", - e.file, e.linenr, e.expected, e.got) -} - -type Row struct { - Label string - Cols [8]int -} - -type Data struct { - StartYear int - Circ, BU, Proof []Row -} - -func Parse(reader io.Reader, file string) (Data, error) { - var ( - data Data // Our data struct - slice *[]Row // Where to append mintages - year int // The current year we are at - ) - - scanner := bufio.NewScanner(reader) - for linenr := 1; scanner.Scan(); linenr++ { - var mintmark struct { - s string - star bool - } - - line := scanner.Text() - tokens := strings.FieldsFunc(strings.TrimSpace(line), unicode.IsSpace) - - switch { - case len(tokens) == 0: - continue - case tokens[0] == "BEGIN": - if len(tokens)-1 != 1 { - return Data{}, SyntaxError{ - expected: "single argument to ‘BEGIN’", - got: fmt.Sprintf("%d arguments", len(tokens)-1), - file: file, - linenr: linenr, - } - } - - arg := tokens[1] - - switch arg { - case "CIRC": - slice = &data.Circ - case "BU": - slice = &data.BU - case "PROOF": - slice = &data.Proof - default: - if !isNumeric(arg, false) { - return Data{}, SyntaxError{ - expected: "‘CIRC’, ‘BU’, ‘PROOF’, or a year", - got: arg, - file: file, - linenr: linenr, - } - } - data.StartYear, _ = strconv.Atoi(arg) - } - - year = data.StartYear - 1 - case isLabel(tokens[0]): - n := len(tokens[0]) - if n > 2 && tokens[0][n-2] == '*' { - mintmark.star = true - mintmark.s = tokens[0][:n-2] - } else { - mintmark.s = tokens[0][:n-1] - } - tokens = tokens[1:] - if !isNumeric(tokens[0], true) && tokens[0] != "?" { - return Data{}, SyntaxError{ - expected: "mintage row after label", - got: tokens[0], - file: file, - linenr: linenr, - } - } - fallthrough - case isNumeric(tokens[0], true), tokens[0] == "?": - switch { - case slice == nil: - return Data{}, SyntaxError{ - expected: "coin type declaration", - got: tokens[0], - file: file, - linenr: linenr, - } - case data.StartYear == 0: - return Data{}, SyntaxError{ - expected: "start year declaration", - got: tokens[0], - file: file, - linenr: linenr, - } - } - - numcoins := len(Row{}.Cols) - tokcnt := len(tokens) - - if tokcnt != numcoins { - word := "entries" - if tokcnt == 1 { - word = "entry" - } - return Data{}, SyntaxError{ - expected: fmt.Sprintf("%d mintage entries", numcoins), - got: fmt.Sprintf("%d %s", tokcnt, word), - file: file, - linenr: linenr, - } - } - - var row Row - switch { - case mintmark.s == "": - year++ - row.Label = strconv.Itoa(year) - case mintmark.star: - year++ - fallthrough - default: - row.Label = fmt.Sprintf("%d %s", year, mintmark.s) - } - - for i, tok := range tokens { - if tok == "?" { - row.Cols[i] = Unknown - } else { - row.Cols[i] = atoiWithDots(tok) - } - } - *slice = append(*slice, row) - default: - return Data{}, SyntaxError{ - expected: "‘BEGIN’ directive or mintage row", - got: fmt.Sprintf("invalid token ‘%s’", tokens[0]), - file: file, - linenr: linenr, - } - } - } - - return data, nil -} - -func isNumeric(s string, dot bool) bool { - for _, ch := range s { - switch ch { - case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': - default: - if ch != '.' || !dot { - return false - } - } - } - return true -} - -func isLabel(s string) bool { - n := len(s) - return (n > 2 && s[n-1] == ':' && s[n-2] == '*') || - (n > 1 && s[n-1] == ':') -} - -func atoiWithDots(s string) int { - n := 0 - for _, ch := range s { - if ch == '.' { - continue - } - n = n*10 + int(ch) - '0' - } - return n -} diff --git a/mintages/parser_test.go b/mintages/parser_test.go deleted file mode 100644 index f61b63d..0000000 --- a/mintages/parser_test.go +++ /dev/null @@ -1,277 +0,0 @@ -package mintages - -import ( - "bytes" - "errors" - "testing" -) - -func TestParserComplete(t *testing.T) { - data, err := Parse(bytes.NewBuffer([]byte(` - BEGIN 2020 - BEGIN CIRC - 1.000 1001 1002 1003 1004 1005 1006 1007 - 2000 ? 2002 2003 2004 2005 2006 2007 - BEGIN BU - 1.100 1101 1102 1103 1104 1105 1106 1107 - 2100 ? 2102 2103 2104 2105 2106 2107 - BEGIN PROOF - 1.200 1201 1202 1203 1204 1205 1206 1207 - 2200 ? 2202 2203 2204 2205 2206 2207 - `)), "-") - - if err != nil { - t.Fatalf(`Expected err=nil; got "%s"`, err) - } - if data.StartYear != 2020 { - t.Fatalf("Expected data.StartYear=2020; got %d", - data.StartYear) - } - - for i, row := range data.Circ { - for j, col := range row.Cols { - var n int - if i == 1 && j == 1 { - n = -1 - } else { - n = 1000*i + j + 1000 - } - if col != n { - t.Fatalf("Expected data.Circ[i][j]=%d; got %d", n, col) - } - } - } - - for i, row := range data.BU { - for j, col := range row.Cols { - var n int - if i == 1 && j == 1 { - n = -1 - } else { - n = 1000*i + j + 1100 - } - if col != n { - t.Fatalf("Expected data.BU[i][j]=%d; got %d", n, col) - } - } - } - - for i, row := range data.Proof { - for j, col := range row.Cols { - var n int - if i == 1 && j == 1 { - n = -1 - } else { - n = 1000*i + j + 1200 - } - if col != n { - t.Fatalf("Expected data.Proof[i][j]=%d; got %d", n, col) - } - } - } - - if len(data.Circ) != 2 { - t.Fatalf("Expected len(data.Circ)=2; got %d", len(data.Circ)) - } - if len(data.BU) != 2 { - t.Fatalf("Expected len(data.BU)=2; got %d", len(data.BU)) - } - if len(data.Proof) != 2 { - t.Fatalf("Expected len(data.Proof)=2; got %d", len(data.Proof)) - } -} - -func TestParserNoProof(t *testing.T) { - data, err := Parse(bytes.NewBuffer([]byte(` - BEGIN 2020 - BEGIN CIRC - 1.000 1001 1002 1003 1004 1005 1006 1007 - 2000 ? 2002 2003 2004 2005 2006 2007 - BEGIN BU - 1.100 1101 1102 1103 1104 1105 1106 1107 - 2100 ? 2102 2103 2104 2105 2106 2107 - `)), "-") - - if err != nil { - t.Fatalf(`Expected err=nil; got "%s"`, err) - } - - if len(data.Proof) != 0 { - t.Fatalf("Expected len(data.Proof)=0; got %d", len(data.Proof)) - } -} - -func TestParserMintmarks(t *testing.T) { - data, err := Parse(bytes.NewBuffer([]byte(` - BEGIN 2020 - BEGIN CIRC - 1.000 1001 1002 1003 1004 1005 1006 1007 - KNM*: 2000 ? 2002 2003 2004 2005 2006 2007 - MdP: 3000 ? 3002 3003 3004 3005 3006 3007 - `)), "-") - - if err != nil { - t.Fatalf(`Expected err=nil; got "%s"`, err) - } - - for i, row := range data.Circ { - for j, col := range row.Cols { - var n int - if i > 0 && j == 1 { - n = -1 - } else { - n = 1000*i + j + 1000 - } - if col != n { - t.Fatalf("Expected data.Circ[i][j]=%d; got %d", n, col) - } - } - } - - if data.Circ[0].Label != "2020" { - t.Fatalf(`Expected data.Circ[0].Label="2020"; got %s`, data.Circ[0].Label) - } - if data.Circ[1].Label != "2021\u00A0KNM" { - t.Fatalf(`Expected data.Circ[1].Label="2021 KNM"; got %s`, data.Circ[1].Label) - } - if data.Circ[2].Label != "2021\u00A0MdP" { - t.Fatalf(`Expected data.Circ[2].Label="2021 MdP"; got %s`, data.Circ[2].Label) - } -} - -func TestParserNoYear(t *testing.T) { - _, err := Parse(bytes.NewBuffer([]byte(` - BEGIN CIRC - 1.000 1001 1002 1003 1004 1005 1006 1007 - 2000 ? 2002 2003 2004 2005 2006 2007 - BEGIN BU - 1.100 1101 1102 1103 1104 1105 1106 1107 - 2100 ? 2102 2103 2104 2105 2106 2107 - BEGIN PROOF - 1.200 1201 1202 1203 1204 1205 1206 1207 - 2200 ? 2202 2203 2204 2205 2206 2207 - `)), "-") - - var sErr SyntaxError - if !errors.As(err, &sErr) { - t.Fatalf("Expected err=SyntaxError; got %s", err) - } -} - -func TestParserNoType(t *testing.T) { - _, err := Parse(bytes.NewBuffer([]byte(` - BEGIN 2020 - 1.000 1001 1002 1003 1004 1005 1006 1007 - 2000 ? 2002 2003 2004 2005 2006 2007 - BEGIN BU - 1.100 1101 1102 1103 1104 1105 1106 1107 - 2100 ? 2102 2103 2104 2105 2106 2107 - BEGIN PROOF - 1.200 1201 1202 1203 1204 1205 1206 1207 - 2200 ? 2202 2203 2204 2205 2206 2207 - `)), "-") - - var sErr SyntaxError - if !errors.As(err, &sErr) { - t.Fatalf("Expected err=SyntaxError; got %s", err) - } -} - -func TestParserNoYearOrType(t *testing.T) { - _, err := Parse(bytes.NewBuffer([]byte(` - 1.000 1001 1002 1003 1004 1005 1006 1007 - 2000 ? 2002 2003 2004 2005 2006 2007 - BEGIN BU - 1.100 1101 1102 1103 1104 1105 1106 1107 - 2100 ? 2102 2103 2104 2105 2106 2107 - BEGIN PROOF - 1.200 1201 1202 1203 1204 1205 1206 1207 - 2200 ? 2202 2203 2204 2205 2206 2207 - `)), "-") - - var sErr SyntaxError - if !errors.As(err, &sErr) { - t.Fatalf("Expected err=SyntaxError; got %s", err) - } -} - -func TestParserBadToken(t *testing.T) { - _, err := Parse(bytes.NewBuffer([]byte(` - BEGIN 2020 - BEGIN CIRC - 1.000 1001 1002 1003 1004 1005 1006 1007 - I’m bad - 2000 ? 2002 2003 2004 2005 2006 2007 - BEGIN BU - 1.100 1101 1102 1103 1104 1105 1106 1107 - 2100 ? 2102 2103 2104 2105 2106 2107 - BEGIN PROOF - 1.200 1201 1202 1203 1204 1205 1206 1207 - 2200 ? 2202 2203 2204 2205 2206 2207 - `)), "-") - - var sErr SyntaxError - if !errors.As(err, &sErr) { - t.Fatalf("Expected err=SyntaxError; got %s", err) - } -} - -func TestParserShortRow(t *testing.T) { - _, err := Parse(bytes.NewBuffer([]byte(` - BEGIN 2020 - BEGIN CIRC - 1.000 1001 1002 1003 1004 1005 1006 1007 - 2000 ? 2002 2003 2004 2005 2006 2007 - BEGIN BU - 1.100 1101 1102 1103 1104 1105 1106 1107 - 2100 ? 2102 2103 2104 2105 2106 - BEGIN PROOF - 1.200 1201 1202 1203 1204 1205 1206 1207 - 2200 ? 2202 2203 2204 2205 2206 2207 - `)), "-") - - var sErr SyntaxError - if !errors.As(err, &sErr) { - t.Fatalf("Expected err=SyntaxError; got %s", err) - } -} - -func TestParserLongRow(t *testing.T) { - _, err := Parse(bytes.NewBuffer([]byte(` - BEGIN 2020 - BEGIN CIRC - 1.000 1001 1002 1003 1004 1005 1006 1007 - 2000 ? 2002 2003 2004 2005 2006 2007 - BEGIN BU - 1.100 1101 1102 1103 1104 1105 1106 1107 - 2100 ? 2102 2103 2104 2105 2106 2107 2108 - BEGIN PROOF - 1.200 1201 1202 1203 1204 1205 1206 1207 - 2200 ? 2202 2203 2204 2205 2206 2207 - `)), "-") - - var sErr SyntaxError - if !errors.As(err, &sErr) { - t.Fatalf("Expected err=SyntaxError; got %s", err) - } -} - -func TestParserBadCoinType(t *testing.T) { - _, err := Parse(bytes.NewBuffer([]byte(` - BEGIN 2020 - BEGIN CIRCULATED - 1.000 1001 1002 1003 1004 1005 1006 1007 - 2000 ? 2002 2003 2004 2005 2006 2007 - BEGIN BU - 1.100 1101 1102 1103 1104 1105 1106 1107 - 2100 ? 2102 2103 2104 2105 2106 2107 - BEGIN PROOF - 1.200 1201 1202 1203 1204 1205 1206 1207 - 2200 ? 2202 2203 2204 2205 2206 2207 - `)), "-") - - var sErr SyntaxError - if !errors.As(err, &sErr) { - t.Fatalf("Expected err=SyntaxError; got %s", err) - } -} -- cgit v1.2.3