consensus/segwit/segwit_test.go

   1 package segwit
   2
   3 import (
   4         "encoding/hex"
   5         "testing"
   6 )
   7
   8 func TestConvertProgram(t *testing.T) {
   9         cases := []struct {
  10                 desc    string
  11                 program string
  12                 script  string
  13                 fun     func(prog []byte) ([]byte, error)
  14         }{
  15                 {
  16                         desc:    "multi sign 2-1",
  17                         program: "0020e402787b2bf9749f8fcdcc132a44e86bacf36780ec5df2189a11020d590533ee",
  18                         script:  "76aa20e402787b2bf9749f8fcdcc132a44e86bacf36780ec5df2189a11020d590533ee8808ffffffffffffffff7c00c0",
  19                         fun:     ConvertP2SHProgram,
  20                 },
  21                 {
  22                         desc:    "multi sign 5-3",
  23                         program: "00200824e931fb806bd77fdcd291aad3bd0a4493443a4120062bd659e64a3e0bac66",
  24                         script:  "76aa200824e931fb806bd77fdcd291aad3bd0a4493443a4120062bd659e64a3e0bac668808ffffffffffffffff7c00c0",
  25                         fun:     ConvertP2SHProgram,
  26                 },
  27                 {
  28                         desc:    "single sign",
  29                         program: "001437e1aec83a4e6587ca9609e4e5aa728db7007449",
  30                         script:  "76ab1437e1aec83a4e6587ca9609e4e5aa728db700744988ae7cac",
  31                         fun:     ConvertP2PKHSigProgram,
  32                 },
  33         }
  34
  35         for i, c := range cases {
  36                 progBytes, err := hex.DecodeString(c.program)
  37                 if err != nil {
  38                         t.Fatal(err)
  39                 }
  40
  41                 gotScript, err := c.fun(progBytes)
  42                 if c.script != hex.EncodeToString(gotScript) {
  43                         t.Errorf("case #%d (%s) got script:%s, expect script:%s", i, c.desc, hex.EncodeToString(gotScript), c.script)
  44                 }
  45         }
  46 }
  47
  48 func TestProgramType(t *testing.T) {
  49         cases := []struct {
  50                 desc    string
  51                 program string
  52                 fun     func(prog []byte) bool
  53                 yes     bool
  54         }{
  55                 {
  56                         desc:    "normal P2WPKHScript",
  57                         program: "001437e1aec83a4e6587ca9609e4e5aa728db7007449",
  58                         fun:     IsP2WPKHScript,
  59                         yes:     true,
  60                 },
  61                 {
  62                         desc:    "ugly P2WPKHScript",
  63                         program: "00200824e931fb806bd77fdcd291aad3bd0a4493443a4120062bd659e64a3e0bac66",
  64                         fun:     IsP2WPKHScript,
  65                         yes:     false,
  66                 },
  67                 {
  68                         desc:    "ugly P2WPKHScript",
  69                         program: "51",
  70                         fun:     IsP2WPKHScript,
  71                         yes:     false,
  72                 },
  73                 {
  74                         desc:    "normal P2WSHScript",
  75                         program: "00200824e931fb806bd77fdcd291aad3bd0a4493443a4120062bd659e64a3e0bac66",
  76                         fun:     IsP2WSHScript,
  77                         yes:     true,
  78                 },
  79                 {
  80                         desc:    "ugly P2WSHScript",
  81                         program: "001437e1aec83a4e6587ca9609e4e5aa728db7007449",
  82                         fun:     IsP2WSHScript,
  83                         yes:     false,
  84                 },
  85                 {
  86                         desc:    "ugly P2WSHScript",
  87                         program: "51",
  88                         fun:     IsP2WSHScript,
  89                         yes:     false,
  90                 },
  91                 {
  92                         desc:    "normal IsStraightforward",
  93                         program: "51",
  94                         fun:     IsStraightforward,
  95                         yes:     true,
  96                 },
  97                 {
  98                         desc:    "ugly IsStraightforward",
  99                         program: "001437e1aec83a4e6587ca9609e4e5aa728db7007449",
 100                         fun:     IsStraightforward,
 101                         yes:     false,
 102                 },
 103                 {
 104                         desc:    "ugly IsStraightforward",
 105                         program: "00200824e931fb806bd77fdcd291aad3bd0a4493443a4120062bd659e64a3e0bac66",
 106                         fun:     IsStraightforward,
 107                         yes:     false,
 108                 },
 109         }
 110
 111         for i, c := range cases {
 112                 progBytes, err := hex.DecodeString(c.program)
 113                 if err != nil {
 114                         t.Fatal(err)
 115                 }
 116
 117                 if c.fun(progBytes) != c.yes {
 118                         t.Errorf("case #%d (%s) got %t, expect %t", i, c.desc, c.fun(progBytes), c.yes)
 119                 }
 120         }
 121 }
 122
 123 func TestIsBCRPScript(t *testing.T) {
 124         tests := []struct {
 125                 program  string
 126                 expected bool
 127         }{
 128                 {
 129                         program:  "",
 130                         expected: false,
 131                 },
 132                 {
 133                         program:  "ae20ac20f5cdb9ada2ae9836bcfff32126d6b885aa3f73ee111a95d1bf37f3904aca5151ad",
 134                         expected: false,
 135                 },
 136                 {
 137                         program:  "694c04626372704c01014c2820e9108d3ca8049800727f6a3505b3a2710dc579405dde03c250f16d9a7e1e6e787403ae7cac00c0",
 138                         expected: false,
 139                 },
 140                 {
 141                         program:  "6a4c04424352504c01014c2820e9108d3ca8049800727f6a3505b3a2710dc579405dde03c250f16d9a7e1e6e787403ae7cac00c0",
 142                         expected: false,
 143                 },
 144                 {
 145                         program:  "6a4c04626372704c01024c2820e9108d3ca8049800727f6a3505b3a2710dc579405dde03c250f16d9a7e1e6e787403ae7cac00c0",
 146                         expected: false,
 147                 },
 148                 {
 149                         program:  "6a4c04626372704c01014c2820e9108d3ca8049800727f6a3505b3a2710dc579405dde03c250f16d9a7e1e6e787403ae7cac00c0",
 150                         expected: true,
 151                 },
 152         }
 153
 154         for i, test := range tests {
 155                 program, err := hex.DecodeString(test.program)
 156                 if err != nil {
 157                         t.Fatal(err)
 158                 }
 159
 160                 expected := IsBCRPScript(program)
 161                 if expected != test.expected {
 162                         t.Errorf("TestIsTemplateRegister #%d failed: got %v want %v", i, expected, test.expected)
 163                 }
 164         }
 165 }