.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/mod@v0.3.0/sumdb/tlog/note_test.go

   1 // Copyright 2019 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package tlog
   6
   7 import (
   8         "strings"
   9         "testing"
  10 )
  11
  12 func TestFormatTree(t *testing.T) {
  13         n := int64(123456789012)
  14         h := RecordHash([]byte("hello world"))
  15         golden := "go.sum database tree\n123456789012\nTszzRgjTG6xce+z2AG31kAXYKBgQVtCSCE40HmuwBb0=\n"
  16         b := FormatTree(Tree{n, h})
  17         if string(b) != golden {
  18                 t.Errorf("FormatTree(...) = %q, want %q", b, golden)
  19         }
  20 }
  21
  22 func TestParseTree(t *testing.T) {
  23         in := "go.sum database tree\n123456789012\nTszzRgjTG6xce+z2AG31kAXYKBgQVtCSCE40HmuwBb0=\n"
  24         goldH := RecordHash([]byte("hello world"))
  25         goldN := int64(123456789012)
  26         tree, err := ParseTree([]byte(in))
  27         if tree.N != goldN || tree.Hash != goldH || err != nil {
  28                 t.Fatalf("ParseTree(...) = Tree{%d, %v}, %v, want Tree{%d, %v}, nil", tree.N, tree.Hash, err, goldN, goldH)
  29         }
  30
  31         // Check invalid trees.
  32         var badTrees = []string{
  33                 "not-" + in,
  34                 "go.sum database tree\n0xabcdef\nTszzRgjTG6xce+z2AG31kAXYKBgQVtCSCE40HmuwBb0=\n",
  35                 "go.sum database tree\n123456789012\nTszzRgjTG6xce+z2AG31kAXYKBgQVtCSCE40HmuwBTOOBIG=\n",
  36         }
  37         for _, bad := range badTrees {
  38                 _, err := ParseTree([]byte(bad))
  39                 if err == nil {
  40                         t.Fatalf("ParseTree(%q) succeeded, want failure", in)
  41                 }
  42         }
  43
  44         // Check junk on end is ignored.
  45         var goodTrees = []string{
  46                 in + "JOE",
  47                 in + "JOE\n",
  48                 in + strings.Repeat("JOE\n", 1000),
  49         }
  50         for _, good := range goodTrees {
  51                 _, err := ParseTree([]byte(good))
  52                 if tree.N != goldN || tree.Hash != goldH || err != nil {
  53                         t.Fatalf("ParseTree(...+%q) = Tree{%d, %v}, %v, want Tree{%d, %v}, nil", good[len(in):], tree.N, tree.Hash, err, goldN, goldH)
  54                 }
  55         }
  56 }
  57
  58 func TestFormatRecord(t *testing.T) {
  59         id := int64(123456789012)
  60         text := "hello, world\n"
  61         golden := "123456789012\nhello, world\n\n"
  62         msg, err := FormatRecord(id, []byte(text))
  63         if err != nil {
  64                 t.Fatalf("FormatRecord: %v", err)
  65         }
  66         if string(msg) != golden {
  67                 t.Fatalf("FormatRecord(...) = %q, want %q", msg, golden)
  68         }
  69
  70         var badTexts = []string{
  71                 "",
  72                 "hello\nworld",
  73                 "hello\n\nworld\n",
  74                 "hello\x01world\n",
  75         }
  76         for _, bad := range badTexts {
  77                 msg, err := FormatRecord(id, []byte(bad))
  78                 if err == nil {
  79                         t.Errorf("FormatRecord(id, %q) = %q, want error", bad, msg)
  80                 }
  81         }
  82 }
  83
  84 func TestParseRecord(t *testing.T) {
  85         in := "123456789012\nhello, world\n\njunk on end\x01\xff"
  86         goldID := int64(123456789012)
  87         goldText := "hello, world\n"
  88         goldRest := "junk on end\x01\xff"
  89         id, text, rest, err := ParseRecord([]byte(in))
  90         if id != goldID || string(text) != goldText || string(rest) != goldRest || err != nil {
  91                 t.Fatalf("ParseRecord(%q) = %d, %q, %q, %v, want %d, %q, %q, nil", in, id, text, rest, err, goldID, goldText, goldRest)
  92         }
  93
  94         in = "123456789012\nhello, world\n\n"
  95         id, text, rest, err = ParseRecord([]byte(in))
  96         if id != goldID || string(text) != goldText || len(rest) != 0 || err != nil {
  97                 t.Fatalf("ParseRecord(%q) = %d, %q, %q, %v, want %d, %q, %q, nil", in, id, text, rest, err, goldID, goldText, "")
  98         }
  99         if rest == nil {
 100                 t.Fatalf("ParseRecord(%q): rest = []byte(nil), want []byte{}", in)
 101         }
 102
 103         // Check invalid records.
 104         var badRecords = []string{
 105                 "not-" + in,
 106                 "123\nhello\x01world\n\n",
 107                 "123\nhello\xffworld\n\n",
 108                 "123\nhello world\n",
 109                 "0x123\nhello world\n\n",
 110         }
 111         for _, bad := range badRecords {
 112                 id, text, rest, err := ParseRecord([]byte(bad))
 113                 if err == nil {
 114                         t.Fatalf("ParseRecord(%q) = %d, %q, %q, nil, want error", in, id, text, rest)
 115                 }
 116         }
 117 }