cmd/dif-dump: improve help and add tests

Author: sbinet

cmd/dif-dump/main.go

@@ -2,7 +2,24 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Command dif-dump decodes and displays DIF data.
+// dif-dump decodes and displays DIF data files.
+//
+// Usage: dif-dump [OPTIONS] FILE1 [FILE2 [FILE3 ...]]
+//
+// Example:
+//
+//  $> dif-dump ./testdata/Event_425050855_109_109_183
+//  === DIF-ID 0xb7 ===
+//  DIF trigger:        109
+//  ACQ trigger:          0
+//  Gbl trigger:        109
+//  Abs BCID:     425050855
+//  Time DIF:       1864732
+//  Frames:             183
+//    hroc=0x01 BCID= 1448778 000000000000000000000000000005f0
+//    hroc=0x01 BCID= 1533835 0400000055b955540000040000000000
+//    hroc=0x01 BCID= 1520655 00000010000000000000000000000000
+//  [...]
 package main
 
 import (
@@ -20,12 +37,49 @@ func main() {
 	log.SetPrefix("dif-dump: ")
 	log.SetFlags(0)
 
+	flag.Usage = func() {
+		fmt.Printf(`dif-dump decodes and displays DIF data files.
+
+Usage: dif-dump [OPTIONS] FILE1 [FILE2 [FILE3 ...]]
+
+Example:
+
+ $> dif-dump ./testdata/Event_425050855_109_109_183
+ === DIF-ID 0xb7 ===
+ DIF trigger:        109
+ ACQ trigger:          0
+ Gbl trigger:        109
+ Abs BCID:     425050855
+ Time DIF:       1864732
+ Frames:             183
+   hroc=0x01 BCID= 1448778 000000000000000000000000000005f0
+   hroc=0x01 BCID= 1533835 0400000055b955540000040000000000
+   hroc=0x01 BCID= 1520655 00000010000000000000000000000000
+ [...]
+
+`)
+		flag.PrintDefaults()
+	}
+
 	flag.Parse()
-	fname := flag.Arg(0)
 
+	if flag.NArg() == 0 {
+		flag.Usage()
+		log.Fatalf("missing path to input DIF file")
+	}
+
+	for _, fname := range flag.Args() {
+		err := process(os.Stdout, fname)
+		if err != nil {
+			log.Fatalf("could not dump file %q: %+v", fname, err)
+		}
+	}
+}
+
+func process(w io.Writer, fname string) error {
 	f, err := os.Open(fname)
 	if err != nil {
-		log.Fatalf("could not open %q: %+v", fname, err)
+		return xerrors.Errorf("could not open %q: %w", fname, err)
 	}
 	defer f.Close()
 
@@ -38,22 +92,24 @@ loop:
 			if xerrors.Is(err, io.EOF) {
 				break loop
 			}
-			log.Fatalf("could not decode DIF: %+v", err)
+			return xerrors.Errorf("could not decode DIF: %w", err)
 		}
-		fmt.Printf("=== DIF-ID 0x%x ===\n", d.Header.ID)
-		fmt.Printf("DIF trigger: % 10d\n", d.Header.DTC)
-		fmt.Printf("ACQ trigger: % 10d\n", d.Header.ATC)
-		fmt.Printf("Gbl trigger: % 10d\n", d.Header.GTC)
-		fmt.Printf("Abs BCID:    % 10d\n", d.Header.AbsBCID)
-		fmt.Printf("Time DIF:    % 10d\n", d.Header.TimeDIFTC)
-		fmt.Printf("Frames:      % 10d\n", len(d.Frames))
+		fmt.Fprintf(w, "=== DIF-ID 0x%x ===\n", d.Header.ID)
+		fmt.Fprintf(w, "DIF trigger: % 10d\n", d.Header.DTC)
+		fmt.Fprintf(w, "ACQ trigger: % 10d\n", d.Header.ATC)
+		fmt.Fprintf(w, "Gbl trigger: % 10d\n", d.Header.GTC)
+		fmt.Fprintf(w, "Abs BCID:    % 10d\n", d.Header.AbsBCID)
+		fmt.Fprintf(w, "Time DIF:    % 10d\n", d.Header.TimeDIFTC)
+		fmt.Fprintf(w, "Frames:      % 10d\n", len(d.Frames))
 
 		for _, frame := range d.Frames {
-			fmt.Printf("  hroc=0x%02x BCID=% 8d %x\n",
+			fmt.Fprintf(w, "  hroc=0x%02x BCID=% 8d %x\n",
 				frame.Header, frame.BCID, frame.Data,
 			)
 		}
 	}
+
+	return nil
 }
 
 func difIDFrom(f io.ReaderAt) uint8 {

cmd/dif-dump/main_test.go

@@ -0,0 +1,121 @@
+// Copyright 2020 The go-lpc Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/go-lpc/mim/dif"
+	"golang.org/x/xerrors"
+)
+
+func TestDump(t *testing.T) {
+	tmp, err := ioutil.TempDir("", "mim-dif-dump-")
+	if err != nil {
+		t.Fatalf("could not create tmp dir: %+v", err)
+	}
+	defer os.RemoveAll(tmp)
+
+	for _, tc := range []struct {
+		name string
+		data dif.DIF
+		want string
+		err  error
+	}{
+		{
+			name: "simple-dif",
+			data: dif.DIF{
+				Header: dif.GlobalHeader{
+					ID:        0x42,
+					DTC:       10,
+					ATC:       11,
+					GTC:       12,
+					AbsBCID:   0x0000112233445566,
+					TimeDIFTC: 0x00112233,
+				},
+				Frames: []dif.Frame{
+					{
+						Header: 1,
+						BCID:   0x001a1b1c,
+						Data:   [16]uint8{0xa, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+					},
+					{
+						Header: 2,
+						BCID:   0x002a2b2c,
+						Data: [16]uint8{
+							0xb, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+							210, 211, 212, 213, 214, 215,
+						},
+					},
+				},
+			},
+			want: `=== DIF-ID 0x42 ===
+DIF trigger:         10
+ACQ trigger:         11
+Gbl trigger:         12
+Abs BCID:     18838586676582
+Time DIF:       1122867
+Frames:               2
+  hroc=0x01 BCID= 1710876 0a0102030405060708090a0b0c0d0e0f
+  hroc=0x02 BCID= 2763564 0b15161718191a1b1c1dd2d3d4d5d6d7
+`,
+		},
+		{
+			name: "invalid-dif",
+			data: dif.DIF{},
+			want: string([]byte{0xb0, 0x42}),
+			err:  xerrors.Errorf("could not decode DIF: dif: could not read DIF header: %w", io.ErrUnexpectedEOF),
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			fname := filepath.Join(tmp, tc.name+".raw")
+			f, err := os.Create(fname)
+			if err != nil {
+				t.Fatalf("could not create raw dif file: %+v", err)
+			}
+			defer f.Close()
+
+			switch {
+			case tc.err == nil:
+				err = dif.NewEncoder(f).Encode(&tc.data)
+				if err != nil {
+					t.Fatalf("could not encode dif: %+v", err)
+				}
+			default:
+				_, err = f.Write([]byte(tc.want))
+				if err != nil {
+					t.Fatalf("could not encode dif: %+v", err)
+				}
+			}
+
+			err = f.Close()
+			if err != nil {
+				t.Fatalf("could not close raw dif file: %+v", err)
+			}
+
+			out := new(strings.Builder)
+			err = process(out, fname)
+			switch {
+			case err != nil && tc.err != nil:
+				if got, want := err.Error(), tc.err.Error(); got != want {
+					t.Fatalf("invalid error:\ngot= %v\nwant=%v\n", got, want)
+				}
+			case err != nil && tc.err == nil:
+				t.Fatalf("could not dif-dump: %+v", err)
+			case err == nil && tc.err == nil:
+				if got, want := out.String(), tc.want; got != want {
+					t.Fatalf("invalid dif-dump output:\ngot:\n%s\nwant:\n%s\n", got, want)
+				}
+			case err == nil && tc.err != nil:
+				t.Fatalf("invalid error:\ngot= %v\nwant=%v\n", err, tc.err)
+			}
+		})
+	}
+}