github.com/SmartMeshFoundation/Spectrum@v0.0.0-20220621030607-452a266fee1e/rlp/raw_test.go (about) 1 // Copyright 2015 The Spectrum Authors 2 // This file is part of the Spectrum library. 3 // 4 // The Spectrum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The Spectrum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the Spectrum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package rlp 18 19 import ( 20 "bytes" 21 "io" 22 "reflect" 23 "testing" 24 ) 25 26 func TestCountValues(t *testing.T) { 27 tests := []struct { 28 input string // note: spaces in input are stripped by unhex 29 count int 30 err error 31 }{ 32 // simple cases 33 {"", 0, nil}, 34 {"00", 1, nil}, 35 {"80", 1, nil}, 36 {"C0", 1, nil}, 37 {"01 02 03", 3, nil}, 38 {"01 C406070809 02", 3, nil}, 39 {"820101 820202 8403030303 04", 4, nil}, 40 41 // size errors 42 {"8142", 0, ErrCanonSize}, 43 {"01 01 8142", 0, ErrCanonSize}, 44 {"02 84020202", 0, ErrValueTooLarge}, 45 46 { 47 input: "A12000BF49F440A1CD0527E4D06E2765654C0F56452257516D793A9B8D604DCFDF2AB853F851808D10000000000000000000000000A056E81F171BCC55A6FF8345E692C0F86E5B48E01B996CADC001622FB5E363B421A0C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", 48 count: 2, 49 }, 50 } 51 for i, test := range tests { 52 count, err := CountValues(unhex(test.input)) 53 if count != test.count { 54 t.Errorf("test %d: count mismatch, got %d want %d\ninput: %s", i, count, test.count, test.input) 55 } 56 if !reflect.DeepEqual(err, test.err) { 57 t.Errorf("test %d: err mismatch, got %q want %q\ninput: %s", i, err, test.err, test.input) 58 } 59 } 60 } 61 62 func TestSplitTypes(t *testing.T) { 63 if _, _, err := SplitString(unhex("C100")); err != ErrExpectedString { 64 t.Errorf("SplitString returned %q, want %q", err, ErrExpectedString) 65 } 66 if _, _, err := SplitList(unhex("01")); err != ErrExpectedList { 67 t.Errorf("SplitString returned %q, want %q", err, ErrExpectedList) 68 } 69 if _, _, err := SplitList(unhex("81FF")); err != ErrExpectedList { 70 t.Errorf("SplitString returned %q, want %q", err, ErrExpectedList) 71 } 72 } 73 74 func TestSplit(t *testing.T) { 75 tests := []struct { 76 input string 77 kind Kind 78 val, rest string 79 err error 80 }{ 81 {input: "01FFFF", kind: Byte, val: "01", rest: "FFFF"}, 82 {input: "80FFFF", kind: String, val: "", rest: "FFFF"}, 83 {input: "C3010203", kind: List, val: "010203"}, 84 85 // errors 86 {input: "", err: io.ErrUnexpectedEOF}, 87 88 {input: "8141", err: ErrCanonSize, rest: "8141"}, 89 {input: "B800", err: ErrCanonSize, rest: "B800"}, 90 {input: "B802FFFF", err: ErrCanonSize, rest: "B802FFFF"}, 91 {input: "B90000", err: ErrCanonSize, rest: "B90000"}, 92 {input: "B90055", err: ErrCanonSize, rest: "B90055"}, 93 {input: "BA0002FFFF", err: ErrCanonSize, rest: "BA0002FFFF"}, 94 {input: "F800", err: ErrCanonSize, rest: "F800"}, 95 {input: "F90000", err: ErrCanonSize, rest: "F90000"}, 96 {input: "F90055", err: ErrCanonSize, rest: "F90055"}, 97 {input: "FA0002FFFF", err: ErrCanonSize, rest: "FA0002FFFF"}, 98 99 {input: "81", err: ErrValueTooLarge, rest: "81"}, 100 {input: "8501010101", err: ErrValueTooLarge, rest: "8501010101"}, 101 {input: "C60607080902", err: ErrValueTooLarge, rest: "C60607080902"}, 102 103 // size check overflow 104 {input: "BFFFFFFFFFFFFFFFFF", err: ErrValueTooLarge, rest: "BFFFFFFFFFFFFFFFFF"}, 105 {input: "FFFFFFFFFFFFFFFFFF", err: ErrValueTooLarge, rest: "FFFFFFFFFFFFFFFFFF"}, 106 107 { 108 input: "B838FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 109 err: ErrValueTooLarge, 110 rest: "B838FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 111 }, 112 { 113 input: "F838FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 114 err: ErrValueTooLarge, 115 rest: "F838FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 116 }, 117 118 // a few bigger values, just for kicks 119 { 120 input: "F839FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 121 kind: List, 122 val: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 123 rest: "", 124 }, 125 { 126 input: "F90211A060EF29F20CC1007AE6E9530AEE16F4B31F8F1769A2D1264EC995C6D1241868D6A07C62AB8AC9838F5F5877B20BB37B387BC2106E97A3D52172CBEDB5EE17C36008A00EAB6B7324AADC0F6047C6AFC8229F09F7CF451B51D67C8DFB08D49BA8C3C626A04453343B2F3A6E42FCF87948F88AF7C8FC16D0C2735CBA7F026836239AB2C15FA024635C7291C882CE4C0763760C1A362DFC3FFCD802A55722236DE058D74202ACA0A220C808DE10F55E40AB25255201CFF009EA181D3906638E944EE2BF34049984A08D325AB26796F1CCB470F69C0F842501DC35D368A0C2575B2D243CFD1E8AB0FDA0B5298FF60DA5069463D610513C9F04F24051348391A143AFFAB7197DFACDEA72A02D2A7058A4463F8FB69378369E11EF33AE3252E2DB86CB545B36D3C26DDECE5AA0888F97BCA8E0BD83DC5B3B91CFF5FAF2F66F9501010682D67EF4A3B4E66115FBA0E8175A60C93BE9ED02921958F0EA55DA0FB5E4802AF5846147BAD92BC2D8AF26A08B3376FF433F3A4250FA64B7F804004CAC5807877D91C4427BD1CD05CF912ED8A09B32EF0F03BD13C37FF950C0CCCEFCCDD6669F2E7F2AA5CB859928E84E29763EA09BBA5E46610C8C8B1F8E921E5691BF8C7E40D75825D5EA3217AA9C3A8A355F39A0EEB95BC78251CCCEC54A97F19755C4A59A293544EEE6119AFA50531211E53C4FA00B6E86FE150BF4A9E0FEEE9C90F5465E617A861BB5E357F942881EE762212E2580", 127 kind: List, 128 val: "A060EF29F20CC1007AE6E9530AEE16F4B31F8F1769A2D1264EC995C6D1241868D6A07C62AB8AC9838F5F5877B20BB37B387BC2106E97A3D52172CBEDB5EE17C36008A00EAB6B7324AADC0F6047C6AFC8229F09F7CF451B51D67C8DFB08D49BA8C3C626A04453343B2F3A6E42FCF87948F88AF7C8FC16D0C2735CBA7F026836239AB2C15FA024635C7291C882CE4C0763760C1A362DFC3FFCD802A55722236DE058D74202ACA0A220C808DE10F55E40AB25255201CFF009EA181D3906638E944EE2BF34049984A08D325AB26796F1CCB470F69C0F842501DC35D368A0C2575B2D243CFD1E8AB0FDA0B5298FF60DA5069463D610513C9F04F24051348391A143AFFAB7197DFACDEA72A02D2A7058A4463F8FB69378369E11EF33AE3252E2DB86CB545B36D3C26DDECE5AA0888F97BCA8E0BD83DC5B3B91CFF5FAF2F66F9501010682D67EF4A3B4E66115FBA0E8175A60C93BE9ED02921958F0EA55DA0FB5E4802AF5846147BAD92BC2D8AF26A08B3376FF433F3A4250FA64B7F804004CAC5807877D91C4427BD1CD05CF912ED8A09B32EF0F03BD13C37FF950C0CCCEFCCDD6669F2E7F2AA5CB859928E84E29763EA09BBA5E46610C8C8B1F8E921E5691BF8C7E40D75825D5EA3217AA9C3A8A355F39A0EEB95BC78251CCCEC54A97F19755C4A59A293544EEE6119AFA50531211E53C4FA00B6E86FE150BF4A9E0FEEE9C90F5465E617A861BB5E357F942881EE762212E2580", 129 rest: "", 130 }, 131 { 132 input: "F877A12000BF49F440A1CD0527E4D06E2765654C0F56452257516D793A9B8D604DCFDF2AB853F851808D10000000000000000000000000A056E81F171BCC55A6FF8345E692C0F86E5B48E01B996CADC001622FB5E363B421A0C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", 133 kind: List, 134 val: "A12000BF49F440A1CD0527E4D06E2765654C0F56452257516D793A9B8D604DCFDF2AB853F851808D10000000000000000000000000A056E81F171BCC55A6FF8345E692C0F86E5B48E01B996CADC001622FB5E363B421A0C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470", 135 rest: "", 136 }, 137 } 138 139 for i, test := range tests { 140 kind, val, rest, err := Split(unhex(test.input)) 141 if kind != test.kind { 142 t.Errorf("test %d: kind mismatch: got %v, want %v", i, kind, test.kind) 143 } 144 if !bytes.Equal(val, unhex(test.val)) { 145 t.Errorf("test %d: val mismatch: got %x, want %s", i, val, test.val) 146 } 147 if !bytes.Equal(rest, unhex(test.rest)) { 148 t.Errorf("test %d: rest mismatch: got %x, want %s", i, rest, test.rest) 149 } 150 if err != test.err { 151 t.Errorf("test %d: error mismatch: got %q, want %q", i, err, test.err) 152 } 153 } 154 } 155 156 func TestReadSize(t *testing.T) { 157 tests := []struct { 158 input string 159 slen byte 160 size uint64 161 err error 162 }{ 163 {input: "", slen: 1, err: io.ErrUnexpectedEOF}, 164 {input: "FF", slen: 2, err: io.ErrUnexpectedEOF}, 165 {input: "00", slen: 1, err: ErrCanonSize}, 166 {input: "36", slen: 1, err: ErrCanonSize}, 167 {input: "37", slen: 1, err: ErrCanonSize}, 168 {input: "38", slen: 1, size: 0x38}, 169 {input: "FF", slen: 1, size: 0xFF}, 170 {input: "FFFF", slen: 2, size: 0xFFFF}, 171 {input: "FFFFFF", slen: 3, size: 0xFFFFFF}, 172 {input: "FFFFFFFF", slen: 4, size: 0xFFFFFFFF}, 173 {input: "FFFFFFFFFF", slen: 5, size: 0xFFFFFFFFFF}, 174 {input: "FFFFFFFFFFFF", slen: 6, size: 0xFFFFFFFFFFFF}, 175 {input: "FFFFFFFFFFFFFF", slen: 7, size: 0xFFFFFFFFFFFFFF}, 176 {input: "FFFFFFFFFFFFFFFF", slen: 8, size: 0xFFFFFFFFFFFFFFFF}, 177 {input: "0102", slen: 2, size: 0x0102}, 178 {input: "010203", slen: 3, size: 0x010203}, 179 {input: "01020304", slen: 4, size: 0x01020304}, 180 {input: "0102030405", slen: 5, size: 0x0102030405}, 181 {input: "010203040506", slen: 6, size: 0x010203040506}, 182 {input: "01020304050607", slen: 7, size: 0x01020304050607}, 183 {input: "0102030405060708", slen: 8, size: 0x0102030405060708}, 184 } 185 186 for _, test := range tests { 187 size, err := readSize(unhex(test.input), test.slen) 188 if err != test.err { 189 t.Errorf("readSize(%s, %d): error mismatch: got %q, want %q", test.input, test.slen, err, test.err) 190 continue 191 } 192 if size != test.size { 193 t.Errorf("readSize(%s, %d): size mismatch: got %#x, want %#x", test.input, test.slen, size, test.size) 194 } 195 } 196 }