func initBinary() { Binary = &ForeignTemplate{TemplateName: "binary"} tm["zbase32"] = Binary Binary.Classes = make(map[string]*ForeignClass) Binary.Classes["z32"] = &ForeignClass{Template: Binary, Class: "z32", Applicator: func(c *ForeignClass, o otm.Object) (post func(*ForeignClass, otm.Object) error, err error) { c.Entity = &BinaryDecodeEntity{} post = func(c *ForeignClass, _o otm.Object) error { if o, ok := _o.(*object); ok { for i, _c := range o.vl { switch c := _c.(type) { case string: if c != "" { if data, err := zbase32.DecodeString(c); err == nil { o.vl[i] = data } else { return err } } case otm.Object: if c.Qualident().Template == "" || c.Qualident().Template == "zbase32" { if data, err := zbase32.DecodeString(c.Qualident().Class); err == nil { o.vl[i] = data } else { return err } } } } } return nil } return }} }
func main() { log.SetFlags(0) log.SetPrefix(prog + ": ") flag.Usage = usage flag.Parse() if flag.NArg() > 0 { for _, input := range flag.Args() { decoded, err := zbase32.DecodeString(input) if err != nil { log.Fatal(err) } if _, err := os.Stdout.Write(decoded); err != nil { log.Fatal(err) } } } else { scanner := bufio.NewScanner(os.Stdin) for scanner.Scan() { input := scanner.Text() decoded, err := zbase32.DecodeString(input) if err != nil { log.Fatalf("decoding input: %q: %v", input, err) } if _, err = os.Stdout.Write(decoded); err != nil { log.Fatal(err) } } if err := scanner.Err(); err != nil { log.Fatalf("reading standard input:", err) } } }
func TestQuickPythonDecodeBytes(t *testing.T) { if !*python { t.Skip("Skipping, use -python to enable") } us := func(orig []byte) ([]byte, error) { encoded := zbase32.EncodeToString(orig) return zbase32.DecodeString(encoded) } them := func(orig []byte) ([]byte, error) { // the python library raises IndexError on zero-length input if len(orig) == 0 { return []byte{}, nil } encoded := zbase32.EncodeToString(orig) cmd := exec.Command("python", "-c", ` import sys, zbase32 enc = sys.stdin.read() sys.stdout.write(zbase32.a2b(enc)) `) cmd.Stdin = strings.NewReader(encoded) cmd.Stderr = os.Stderr output, err := cmd.Output() if err != nil { return nil, fmt.Errorf("cannot run python: %v", err) } return output, nil } if err := quick.CheckEqual(us, them, nil); err != nil { t.Fatal(err) } }
func TestDecodeBad(t *testing.T) { input := `foo!bar` _, err := zbase32.DecodeString(input) switch err := err.(type) { case nil: t.Fatalf("expected error from bad decode") case zbase32.CorruptInputError: if g, e := err.Error(), `illegal z-base-32 data at input byte 3`; g != e { t.Fatalf("wrong error: %q != %q", g, e) } default: t.Fatalf("wrong error from bad decode: %T: %v", err, err) } }
func TestQuickRoundtripBytes(t *testing.T) { fn := func(orig []byte) bool { encoded := zbase32.EncodeToString(orig) decoded, err := zbase32.DecodeString(encoded) if err != nil { t.Logf("orig=\t%x", orig) t.Logf("enc=\t%q", encoded) t.Fatalf("encode-decode roundtrip gave error: %v", err) } if !bytes.Equal(orig, decoded) { t.Logf("orig=\t%x", orig) t.Logf("dec=\t%x", decoded) t.Logf("enc=\t%q", encoded) return false } return true } if err := quick.Check(fn, nil); err != nil { t.Fatal(err) } }